LCOV - code coverage report
Current view: top level - libreoffice/sd/source/ui/func - fusel.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 603 0.0 %
Date: 2012-12-27 Functions: 0 21 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "fusel.hxx"
      21             : #include <basic/sbstar.hxx>
      22             : #include <svx/svdpagv.hxx>
      23             : #include <svx/svdogrp.hxx>
      24             : #include <svx/polysc3d.hxx>
      25             : #include "drawview.hxx"
      26             : #include <svtools/imapobj.hxx>
      27             : #include <svl/urihelper.hxx>
      28             : #include <unotools/localfilehelper.hxx>
      29             : #include <svx/svxids.hrc>
      30             : #include <svx/xfillit0.hxx>
      31             : #include <sfx2/app.hxx>
      32             : #include <sfx2/viewfrm.hxx>
      33             : #include <svl/aeitem.hxx>
      34             : #include <svl/stritem.hxx>
      35             : #include <svl/intitem.hxx>
      36             : #include <sfx2/dispatch.hxx>
      37             : #include <tools/urlobj.hxx>
      38             : #include <sfx2/docfile.hxx>
      39             : #include <editeng/eeitem.hxx>
      40             : #include <editeng/flditem.hxx>
      41             : 
      42             : #include <svx/svdotable.hxx>
      43             : 
      44             : #include "app.hrc"
      45             : #include "strings.hrc"
      46             : #include "res_bmp.hrc"
      47             : #include "GraphicDocShell.hxx"
      48             : #include "app.hxx"
      49             : #include "DrawDocShell.hxx"
      50             : #include "stlpool.hxx"
      51             : #include "anminfo.hxx"
      52             : #include "fudraw.hxx"
      53             : #include "ViewShell.hxx"
      54             : #include "ViewShellBase.hxx"
      55             : #include "FrameView.hxx"
      56             : #include "View.hxx"
      57             : #include "Window.hxx"
      58             : #include "drawdoc.hxx"
      59             : #include "sdpage.hxx"
      60             : #include "DrawViewShell.hxx"
      61             : #include "ToolBarManager.hxx"
      62             : #include "pgjump.hxx"
      63             : #include <svx/globl3d.hxx>
      64             : #include "Client.hxx"
      65             : 
      66             : #include "slideshow.hxx"
      67             : 
      68             : #include <svx/svdundo.hxx>
      69             : #include <avmedia/mediawindow.hxx>
      70             : 
      71             : #include <svx/sdrhittesthelper.hxx>
      72             : 
      73             : using namespace ::com::sun::star;
      74             : 
      75             : namespace sd {
      76             : 
      77           0 : TYPEINIT1( FuSelection, FuDraw );
      78             : 
      79             : /*************************************************************************
      80             : |*
      81             : |* Constructor
      82             : |*
      83             : \************************************************************************/
      84             : 
      85           0 : FuSelection::FuSelection (
      86             :     ViewShell* pViewSh,
      87             :     ::sd::Window* pWin,
      88             :     ::sd::View* pView,
      89             :     SdDrawDocument* pDoc,
      90             :     SfxRequest& rReq)
      91             :     : FuDraw(pViewSh, pWin, pView, pDoc, rReq),
      92             :       bTempRotation(sal_False),
      93             :       bSelectionChanged(sal_False),
      94             :       bHideAndAnimate(sal_False),
      95             :       pHdl(NULL),
      96             :       bSuppressChangesOfSelection(sal_False),
      97             :       bMirrorSide0(sal_False),
      98             :       nEditMode(SID_BEZIER_MOVE),
      99           0 :       pWaterCanCandidate(NULL)
     100             : {
     101           0 : }
     102             : 
     103           0 : FunctionReference FuSelection::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
     104             : {
     105           0 :     FunctionReference xFunc( new FuSelection( pViewSh, pWin, pView, pDoc, rReq ) );
     106           0 :     xFunc->DoExecute(rReq);
     107           0 :     return xFunc;
     108             : }
     109             : 
     110           0 : void FuSelection::DoExecute( SfxRequest& rReq )
     111             : {
     112           0 :     FuDraw::DoExecute( rReq );
     113             : 
     114             :     // Select object bar
     115           0 :     SelectionHasChanged();
     116           0 : }
     117             : 
     118             : /*************************************************************************
     119             : |*
     120             : |* Destructor
     121             : |*
     122             : \************************************************************************/
     123             : 
     124           0 : FuSelection::~FuSelection()
     125             : {
     126           0 :     mpView->UnmarkAllPoints();
     127           0 :     mpView->ResetCreationActive();
     128             : 
     129           0 :     if ( mpView->GetDragMode() != SDRDRAG_MOVE )
     130             :     {
     131           0 :         mpView->SetDragMode(SDRDRAG_MOVE);
     132             :     }
     133           0 : }
     134             : 
     135             : /*************************************************************************
     136             : |*
     137             : |* MouseButtonDown-event
     138             : |*
     139             : \************************************************************************/
     140             : 
     141           0 : sal_Bool FuSelection::MouseButtonDown(const MouseEvent& rMEvt)
     142             : {
     143             :     // Hack for #?????#
     144           0 :     bHideAndAnimate = sal_False;
     145             : 
     146           0 :     pHdl = NULL;
     147           0 :     sal_Bool bReturn = FuDraw::MouseButtonDown(rMEvt);
     148           0 :     sal_Bool bWaterCan = SD_MOD()->GetWaterCan();
     149           0 :     const bool bReadOnly = mpDocSh->IsReadOnly();
     150             :     // When the right mouse button is pressed then only select objects
     151             :     // (and deselect others) as a preparation for showing the context
     152             :     // menu.
     153           0 :     const bool bSelectionOnly = rMEvt.IsRight();
     154             : 
     155           0 :     bMBDown = sal_True;
     156           0 :     bSelectionChanged = sal_False;
     157             : 
     158           0 :     if ( mpView->IsAction() )
     159             :     {
     160           0 :         if ( rMEvt.IsRight() )
     161           0 :             mpView->BckAction();
     162           0 :         return sal_True;
     163             :     }
     164             : 
     165           0 :     sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
     166           0 :     sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
     167             : 
     168             :     // The following code is executed for right clicks as well as for left
     169             :     // clicks in order to modify the selection for the right button as a
     170             :     // preparation for the context menu.  The functions BegMarkObject() and
     171             :     // BegDragObject(), however, are not called for right clicks because a)
     172             :     // it makes no sense and b) to have IsAction() return sal_False when called
     173             :     // from Command() which is a prerequisite for the context menu.
     174           0 :     if ((rMEvt.IsLeft() || rMEvt.IsRight())
     175           0 :         && !mpView->IsAction()
     176           0 :         && (mpView->IsFrameDragSingles() || !mpView->HasMarkablePoints()))
     177             :     {
     178             :         /******************************************************************
     179             :         * NO BEZIER_EDITOR
     180             :         ******************************************************************/
     181           0 :         mpWindow->CaptureMouse();
     182           0 :         pHdl = mpView->PickHandle(aMDPos);
     183             :         SdrObject* pObj;
     184             :         SdrPageView* pPV;
     185             : 
     186           0 :         long nAngle0  = GetAngle(aMDPos - mpView->GetRef1());
     187           0 :         nAngle0 -= 27000;
     188           0 :         nAngle0 = NormAngle360(nAngle0);
     189           0 :         bMirrorSide0 = sal_Bool (nAngle0 < 18000L);
     190             : 
     191           0 :         if (!pHdl && mpView->Is3DRotationCreationActive())
     192             :         {
     193             :             /******************************************************************
     194             :             * If 3D-rotation bodies are about to be created,
     195             :             * end creation now.
     196             :             ******************************************************************/
     197           0 :             bSuppressChangesOfSelection = sal_True;
     198           0 :             if(mpWindow)
     199           0 :                 mpWindow->EnterWait();
     200           0 :             mpView->End3DCreation();
     201           0 :             bSuppressChangesOfSelection = sal_False;
     202           0 :             mpView->ResetCreationActive();
     203           0 :             if(mpWindow)
     204           0 :                 mpWindow->LeaveWait();
     205             :         }
     206             : 
     207           0 :         sal_Bool bTextEdit = sal_False;
     208           0 :         SdrViewEvent aVEvt;
     209           0 :         SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
     210             : 
     211           0 :         if ( eHit == SDRHIT_TEXTEDITOBJ && ( mpViewShell->GetFrameView()->IsQuickEdit() || dynamic_cast< sdr::table::SdrTableObj* >( aVEvt.pObj ) != NULL ) )
     212             :         {
     213           0 :             bTextEdit = sal_True;
     214             :         }
     215             : 
     216           0 :         if(!bTextEdit
     217           0 :             && !mpDocSh->IsReadOnly()
     218           0 :             && ((mpView->IsMarkedHit(aMDPos, nHitLog) && !rMEvt.IsShift() && !rMEvt.IsMod2()) || pHdl != NULL)
     219           0 :             && (rMEvt.GetClicks() != 2)
     220             :             )
     221             :         {
     222           0 :             if (!pHdl && mpView->Is3DRotationCreationActive())
     223             :             {
     224             :                 // Switch between 3D-rotation body -> selection
     225           0 :                 mpView->ResetCreationActive();
     226             :             }
     227           0 :             else if (bWaterCan)
     228             :             {
     229             :                 // Remember the selected object for proper handling in
     230             :                 // MouseButtonUp().
     231           0 :                 pWaterCanCandidate = pickObject (aMDPos);
     232             :             }
     233             :             else
     234             :             {
     235             :                 // Handle oder marked object hit
     236           0 :                 bFirstMouseMove = sal_True;
     237           0 :                 aDragTimer.Start();
     238             :             }
     239             : 
     240           0 :             if ( ! rMEvt.IsRight())
     241           0 :                 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl, nDrgLog);
     242           0 :             bReturn = sal_True;
     243             :         }
     244             :         else
     245             :         {
     246           0 :             if (!rMEvt.IsMod2() && mpView->PickObj(aMDPos, mpView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMACRO))
     247             :             {
     248           0 :                 mpView->BegMacroObj(aMDPos, nHitLog, pObj, pPV, mpWindow);
     249           0 :                 bReturn = sal_True;
     250             :             }
     251           0 :             else if ( bTextEdit )
     252             :             {
     253           0 :                 sal_uInt16 nSdrObjKind = aVEvt.pObj->GetObjIdentifier();
     254             : 
     255           0 :                 if (aVEvt.pObj->GetObjInventor() == SdrInventor &&
     256             :                     (nSdrObjKind == OBJ_TEXT ||
     257             :                      nSdrObjKind == OBJ_TITLETEXT ||
     258             :                      nSdrObjKind == OBJ_OUTLINETEXT ||
     259           0 :                      !aVEvt.pObj->IsEmptyPresObj()))
     260             :                 {
     261             :                     // Seamless Editing: branch to text input
     262           0 :                     if (!rMEvt.IsShift())
     263           0 :                         mpView->UnmarkAll();
     264             : 
     265           0 :                     SfxUInt16Item aItem(SID_TEXTEDIT, 1);
     266             :                     mpViewShell->GetViewFrame()->GetDispatcher()->
     267             :                     Execute(SID_TEXTEDIT, SFX_CALLMODE_SYNCHRON |
     268           0 :                             SFX_CALLMODE_RECORD, &aItem, 0L);
     269           0 :                     return bReturn; // CAUTION, due to the synchronous slot the object is deleted now
     270             :                 }
     271             :             }
     272           0 :             else if ( !rMEvt.IsMod2() && rMEvt.GetClicks() == 1 &&
     273             :                       aVEvt.eEvent == SDREVENT_EXECUTEURL )
     274             :              {
     275           0 :                 mpWindow->ReleaseMouse();
     276           0 :                 SfxStringItem aStrItem(SID_FILE_NAME, aVEvt.pURLField->GetURL());
     277           0 :                 SfxStringItem aReferer(SID_REFERER, mpDocSh->GetMedium()->GetName());
     278           0 :                 SfxBoolItem aBrowseItem( SID_BROWSE, sal_True );
     279           0 :                 SfxViewFrame* pFrame = mpViewShell->GetViewFrame();
     280           0 :                 mpWindow->ReleaseMouse();
     281             : 
     282           0 :                 if (rMEvt.IsMod1())
     283             :                 {
     284             :                     // Open in new frame
     285             :                     pFrame->GetDispatcher()->Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
     286           0 :                                 &aStrItem, &aBrowseItem, &aReferer, 0L);
     287             :                 }
     288             :                 else
     289             :                 {
     290             :                     // Open in current frame
     291           0 :                     SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame);
     292             :                     pFrame->GetDispatcher()->Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
     293           0 :                                 &aStrItem, &aFrameItem, &aBrowseItem, &aReferer, 0L);
     294             :                 }
     295             : 
     296           0 :                 bReturn = sal_True;
     297             :             }
     298           0 :             else if(!rMEvt.IsMod2()
     299           0 :                 && mpViewShell->ISA(DrawViewShell)
     300             :                 )
     301             :             {
     302           0 :                 if(mpView->PickObj(aMDPos, mpView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER))
     303             :                 {
     304             :                     // Animate object when not just selecting.
     305           0 :                     if ( ! bSelectionOnly)
     306           0 :                         bReturn = AnimateObj(pObj, aMDPos);
     307             : 
     308           0 :                     if (!bReturn && (pObj->ISA(SdrObjGroup) || pObj->ISA(E3dPolyScene)))
     309             :                     {
     310           0 :                         if(rMEvt.GetClicks() == 1)
     311             :                         {
     312             :                             // Look into the group
     313           0 :                             if (mpView->PickObj(aMDPos, mpView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER | SDRSEARCH_DEEP))
     314           0 :                                 bReturn = AnimateObj(pObj, aMDPos);
     315             :                         }
     316           0 :                         else if( !bReadOnly && rMEvt.GetClicks() == 2)
     317             :                         {
     318             :                             // New: double click on selected Group object
     319             :                             // enter group
     320           0 :                             if ( ! bSelectionOnly
     321             :                                 && pObj
     322           0 :                                 && pObj->GetPage() == pPV->GetPage())
     323           0 :                                 bReturn = pPV->EnterGroup(pObj);
     324             :                         }
     325             :                     }
     326             :                 }
     327             : 
     328             :                 // #i71727# replaced else here with two possibilities, once the original else (!pObj)
     329             :                 // and also ignoring the found object when it's on a masterpage
     330           0 :                 if(!pObj || (pObj->GetPage() && pObj->GetPage()->IsMasterPage()))
     331             :                 {
     332           0 :                     if(mpView->IsGroupEntered() && 2 == rMEvt.GetClicks())
     333             :                     {
     334             :                         // New: double click on empty space/on obj on MasterPage, leave group
     335           0 :                         mpView->LeaveOneGroup();
     336           0 :                         bReturn = sal_True;
     337             :                     }
     338             :                 }
     339             :             }
     340             : 
     341           0 :             if (!bReturn)
     342             :             {
     343           0 :                 if (bWaterCan)
     344             :                 {
     345           0 :                     if ( ! (rMEvt.IsShift() || rMEvt.IsMod2()))
     346             :                     {
     347             :                         // Find the object under the current mouse position
     348             :                         // and store it for the MouseButtonUp() method to
     349             :                         // evaluate.
     350           0 :                         pWaterCanCandidate = pickObject (aMDPos);
     351             :                     }
     352             :                 }
     353             :                 else
     354             :                 {
     355           0 :                     bReturn = sal_True;
     356           0 :                     sal_Bool bDeactivateOLE = sal_False;
     357             : 
     358           0 :                     if ( !rMEvt.IsShift() && !rMEvt.IsMod2() )
     359             :                     {
     360             :                         OSL_ASSERT (mpViewShell->GetViewShell()!=NULL);
     361             :                         Client* pIPClient = static_cast<Client*>(
     362           0 :                             mpViewShell->GetViewShell()->GetIPClient());
     363             : 
     364           0 :                         if (pIPClient && pIPClient->IsObjectInPlaceActive())
     365             :                         {
     366             :                             // OLE-Objekt gets deactivated in subsequent UnmarkAll()
     367           0 :                             bDeactivateOLE = sal_True;
     368             :                         }
     369             : 
     370           0 :                         mpView->UnmarkAll();
     371             :                     }
     372             : 
     373           0 :                     sal_Bool bMarked = sal_False;
     374             : 
     375           0 :                     if ( !rMEvt.IsMod1() && !bDeactivateOLE)
     376             :                     {
     377           0 :                         if ( rMEvt.IsMod2() )
     378             :                         {
     379           0 :                             bMarked = mpView->MarkNextObj(aMDPos, nHitLog, rMEvt.IsShift() );
     380             :                         }
     381             :                         else
     382             :                         {
     383           0 :                             sal_Bool bToggle = sal_False;
     384             : 
     385           0 :                             if (rMEvt.IsShift() && mpView->GetMarkedObjectList().GetMarkCount() > 1)
     386             :                             {
     387             :                                 // No Toggle on single selection
     388           0 :                                 bToggle = sal_True;
     389             :                             }
     390             : 
     391           0 :                             bMarked = mpView->MarkObj(aMDPos, nHitLog, bToggle, sal_False);
     392             :                         }
     393             :                     }
     394             : 
     395           0 :                     if( !bDeactivateOLE )
     396             :                     {
     397           0 :                         if ( !bReadOnly &&
     398             :                              bMarked                                                   &&
     399           0 :                              (!rMEvt.IsShift() || mpView->IsMarkedHit(aMDPos, nHitLog)))
     400             :                         {
     401             :                             /**********************************************************
     402             :                              * Move object
     403             :                              **********************************************************/
     404           0 :                             aDragTimer.Start();
     405             : 
     406           0 :                             pHdl=mpView->PickHandle(aMDPos);
     407           0 :                             if ( ! rMEvt.IsRight())
     408           0 :                                 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl, nDrgLog);
     409             :                         }
     410             :                         else
     411             :                         {
     412             :                             /**********************************************************
     413             :                              * Select object
     414             :                              **********************************************************/
     415           0 :                             if ( ! rMEvt.IsRight())
     416           0 :                                 mpView->BegMarkObj(aMDPos);
     417             :                         }
     418             :                     }
     419             : 
     420           0 :                     if( bMarked && bTempRotation && (nSlotId == SID_OBJECT_ROTATE) && !rMEvt.IsShift() && (rMEvt.GetClicks() != 2) )
     421             :                     {
     422           0 :                         nSlotId = SID_OBJECT_SELECT;
     423           0 :                         Activate();
     424             :                     }
     425             :                 }
     426             :             }
     427           0 :         }
     428             :     }
     429           0 :     else if ( !bReadOnly
     430           0 :               && (rMEvt.IsLeft() || rMEvt.IsRight())
     431           0 :               && !mpView->IsAction())
     432             :     {
     433             :         /**********************************************************************
     434             :         * BEZIER-EDITOR
     435             :         **********************************************************************/
     436           0 :         mpWindow->CaptureMouse();
     437           0 :         SdrViewEvent aVEvt;
     438           0 :         SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
     439             : 
     440           0 :         if (eHit == SDRHIT_HANDLE && aVEvt.pHdl->GetKind() == HDL_BWGT)
     441             :         {
     442             :             /******************************************************************
     443             :             * Drag Handle
     444             :             ******************************************************************/
     445           0 :             if ( ! rMEvt.IsRight())
     446           0 :                 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, aVEvt.pHdl, nDrgLog);
     447             :         }
     448           0 :         else if (eHit == SDRHIT_MARKEDOBJECT && nEditMode == SID_BEZIER_INSERT)
     449             :         {
     450             :             /******************************************************************
     451             :             * Insert glue point
     452             :             ******************************************************************/
     453           0 :             mpView->BegInsObjPoint(aMDPos, rMEvt.IsMod1());
     454             :         }
     455           0 :         else if (eHit == SDRHIT_MARKEDOBJECT && rMEvt.IsMod1())
     456             :         {
     457             :             /******************************************************************
     458             :             * Select glue point
     459             :             ******************************************************************/
     460           0 :             if (!rMEvt.IsShift())
     461           0 :                 mpView->UnmarkAllPoints();
     462             : 
     463           0 :             if ( ! rMEvt.IsRight())
     464           0 :                 mpView->BegMarkPoints(aMDPos);
     465             :         }
     466           0 :         else if (eHit == SDRHIT_MARKEDOBJECT && !rMEvt.IsShift() && !rMEvt.IsMod2())
     467             :         {
     468             :             /******************************************************************
     469             :             * Move object
     470             :             ******************************************************************/
     471           0 :             if ( ! rMEvt.IsRight())
     472           0 :                 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, NULL, nDrgLog);
     473             :         }
     474           0 :         else if (eHit == SDRHIT_HANDLE)
     475             :         {
     476             :             /******************************************************************
     477             :             * Select glue point
     478             :             ******************************************************************/
     479           0 :             if (!mpView->IsPointMarked(*aVEvt.pHdl) || rMEvt.IsShift())
     480             :             {
     481           0 :                 if (!rMEvt.IsShift())
     482             :                 {
     483           0 :                     mpView->UnmarkAllPoints();
     484           0 :                     pHdl = mpView->PickHandle(aMDPos);
     485             :                 }
     486             :                 else
     487             :                 {
     488           0 :                     if (mpView->IsPointMarked(*aVEvt.pHdl))
     489             :                     {
     490           0 :                         mpView->UnmarkPoint(*aVEvt.pHdl);
     491           0 :                         pHdl = NULL;
     492             :                     }
     493             :                     else
     494             :                     {
     495           0 :                         pHdl = mpView->PickHandle(aMDPos);
     496             :                     }
     497             :                 }
     498             : 
     499           0 :                 if (pHdl)
     500             :                 {
     501           0 :                     mpView->MarkPoint(*pHdl);
     502           0 :                     if ( ! rMEvt.IsRight())
     503           0 :                         mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl, nDrgLog);
     504             :                 }
     505             :             }
     506             :             else
     507             :             {
     508             :                 // Point IS marked and NO shift is pressed. Start
     509             :                 // dragging of selected point(s)
     510           0 :                 pHdl = mpView->PickHandle(aMDPos);
     511           0 :                 if(pHdl)
     512           0 :                     if ( ! rMEvt.IsRight())
     513           0 :                         mpView->BegDragObj(aMDPos, (OutputDevice*)NULL, pHdl, nDrgLog);
     514             :             }
     515             :         }
     516             :         else
     517             :         {
     518             :             /******************************************************************
     519             :             * Select or drag object
     520             :             ******************************************************************/
     521           0 :             if (!rMEvt.IsShift() && !rMEvt.IsMod2() && eHit == SDRHIT_UNMARKEDOBJECT)
     522             :             {
     523           0 :                mpView->UnmarkAllObj();
     524             :             }
     525             : 
     526           0 :             sal_Bool bMarked = sal_False;
     527             : 
     528           0 :             if (!rMEvt.IsMod1())
     529             :             {
     530           0 :                 if (rMEvt.IsMod2())
     531             :                 {
     532           0 :                     bMarked = mpView->MarkNextObj(aMDPos, nHitLog, rMEvt.IsShift());
     533             :                 }
     534             :                 else
     535             :                 {
     536           0 :                     bMarked = mpView->MarkObj(aMDPos, nHitLog, rMEvt.IsShift(), sal_False);
     537             :                 }
     538             :             }
     539             : 
     540           0 :             if (bMarked &&
     541           0 :                 (!rMEvt.IsShift() || eHit == SDRHIT_MARKEDOBJECT))
     542             :             {
     543             :                 // Move object
     544           0 :                 if ( ! rMEvt.IsRight())
     545           0 :                     mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, aVEvt.pHdl, nDrgLog);
     546             :             }
     547           0 :             else if (mpView->AreObjectsMarked())
     548             :             {
     549             :                 /**************************************************************
     550             :                 * Select glue point
     551             :                 **************************************************************/
     552           0 :                 if (!rMEvt.IsShift())
     553           0 :                     mpView->UnmarkAllPoints();
     554             : 
     555           0 :                 if ( ! rMEvt.IsRight())
     556           0 :                     mpView->BegMarkPoints(aMDPos);
     557             :             }
     558             :             else
     559             :             {
     560             :                 /**************************************************************
     561             :                 * Select object
     562             :                 **************************************************************/
     563           0 :                 if ( ! rMEvt.IsRight())
     564           0 :                     mpView->BegMarkObj(aMDPos);
     565             :             }
     566             : 
     567           0 :             ForcePointer(&rMEvt);
     568           0 :         }
     569             :     }
     570             : 
     571           0 :     if (!bIsInDragMode)
     572             :     {
     573           0 :         ForcePointer(&rMEvt);
     574             :     }
     575             : 
     576           0 :     return bReturn;
     577             : }
     578             : 
     579             : /*************************************************************************
     580             : |*
     581             : |* MouseMove-event
     582             : |*
     583             : \************************************************************************/
     584             : 
     585           0 : sal_Bool FuSelection::MouseMove(const MouseEvent& rMEvt)
     586             : {
     587           0 :     sal_Bool bReturn = FuDraw::MouseMove(rMEvt);
     588             : 
     589           0 :     if (aDragTimer.IsActive())
     590             :     {
     591           0 :         if(bFirstMouseMove)
     592             :         {
     593           0 :             bFirstMouseMove = sal_False;
     594             :         }
     595             :         else
     596             :         {
     597           0 :             aDragTimer.Stop();
     598             :         }
     599             :     }
     600             : 
     601           0 :     if (mpView->IsAction())
     602             :     {
     603           0 :         Point aPix(rMEvt.GetPosPixel());
     604           0 :         Point aPnt(mpWindow->PixelToLogic(aPix));
     605             : 
     606           0 :         ForceScroll(aPix);
     607             : 
     608           0 :         if (mpView->IsInsObjPoint())
     609             :         {
     610           0 :             mpView->MovInsObjPoint(aPnt);
     611             :         }
     612             :         else
     613             :         {
     614           0 :             mpView->MovAction(aPnt);
     615             :         }
     616             :     }
     617             : 
     618           0 :     ForcePointer(&rMEvt);
     619             : 
     620           0 :     return (bReturn);
     621             : }
     622             : 
     623             : /*************************************************************************
     624             : |*
     625             : |* MouseButtonUp-event
     626             : |*
     627             : \************************************************************************/
     628             : 
     629           0 : sal_Bool FuSelection::MouseButtonUp(const MouseEvent& rMEvt)
     630             : {
     631           0 :     sal_Bool bReturn = sal_False;
     632             :     // When the right mouse button is pressed then only select objects
     633             :     // (and deselect others) as a preparation for showing the context
     634             :     // menu.
     635           0 :     const bool bSelectionOnly = rMEvt.IsRight();
     636             :     SdrObject* pObj;
     637             :     SdrPageView* pPV;
     638             : 
     639           0 :     if (bHideAndAnimate)
     640             :     {
     641             :         // Animation is still running -> return immediately
     642           0 :         bHideAndAnimate = sal_False;
     643           0 :         pHdl = NULL;
     644           0 :         mpWindow->ReleaseMouse();
     645           0 :         return(sal_True);
     646             :     }
     647             : 
     648           0 :     if (aDragTimer.IsActive() )
     649             :     {
     650           0 :         aDragTimer.Stop();
     651           0 :         bIsInDragMode = sal_False;
     652             :     }
     653             : 
     654           0 :     if( !mpView )
     655           0 :         return (sal_False);
     656             : 
     657           0 :     Point aPnt( mpWindow->PixelToLogic( rMEvt.GetPosPixel() ) );
     658           0 :     sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
     659           0 :     sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
     660             : 
     661           0 :     if (mpView->IsFrameDragSingles() || !mpView->HasMarkablePoints())
     662             :     {
     663             :         /**********************************************************************
     664             :         * NO BEZIER_EDITOR
     665             :         **********************************************************************/
     666           0 :         if ( mpView->IsDragObj() )
     667             :         {
     668             :             /******************************************************************
     669             :             * Object was moved
     670             :             ******************************************************************/
     671           0 :             FrameView* pFrameView = mpViewShell->GetFrameView();
     672           0 :             sal_Bool bDragWithCopy = (rMEvt.IsMod1() && pFrameView->IsDragWithCopy());
     673             : 
     674           0 :             if (bDragWithCopy)
     675             :             {
     676           0 :                 bDragWithCopy = !mpView->IsPresObjSelected(sal_False, sal_True);
     677             :             }
     678             : 
     679           0 :             mpView->SetDragWithCopy(bDragWithCopy);
     680           0 :             mpView->EndDragObj( mpView->IsDragWithCopy() );
     681             : 
     682           0 :             mpView->ForceMarkedToAnotherPage();
     683             : 
     684           0 :             if (!rMEvt.IsShift() && !rMEvt.IsMod1() && !rMEvt.IsMod2() &&
     685           0 :                 !bSelectionChanged                   &&
     686           0 :                 Abs(aPnt.X() - aMDPos.X()) < nDrgLog &&
     687           0 :                 Abs(aPnt.Y() - aMDPos.Y()) < nDrgLog)
     688             :             {
     689             :                 /*************************************************************
     690             :                 * If a user wants to click on an object in front of a masked
     691             :                 * one, he releases the mouse button immediately
     692             :                 **************************************************************/
     693           0 :                 if (mpView->PickObj(aMDPos, mpView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER | SDRSEARCH_BEFOREMARK))
     694             :                 {
     695             :                     //not Needed in the ordinary pick routine for some reason...
     696           0 :                     mpView->UnmarkAllObj();
     697           0 :                     mpView->MarkObj(pObj,pPV,false,false);
     698           0 :                     return (bReturn);
     699             :                 }
     700             :                 /**************************************************************
     701             :                 * Toggle between selection and rotation
     702             :                 **************************************************************/
     703           0 :                 SdrObject* pSingleObj = NULL;
     704           0 :                 sal_uLong nMarkCount = mpView->GetMarkedObjectList().GetMarkCount();
     705             : 
     706           0 :                 if (nMarkCount==1)
     707             :                 {
     708           0 :                     pSingleObj = mpView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
     709             :                 }
     710             : 
     711           0 :                 if (nSlotId == SID_OBJECT_SELECT
     712           0 :                     && mpView->IsRotateAllowed()
     713             : 
     714           0 :                     && (rMEvt.GetClicks() != 2)
     715           0 :                     && (mpViewShell->GetFrameView()->IsClickChangeRotation()
     716             :                         || (pSingleObj
     717           0 :                             && pSingleObj->GetObjInventor()==E3dInventor))
     718           0 :                     && ! bSelectionOnly)
     719             : 
     720             :                 {
     721           0 :                     bTempRotation = sal_True;
     722           0 :                     nSlotId = SID_OBJECT_ROTATE;
     723           0 :                     Activate();
     724             :                 }
     725           0 :                 else if (nSlotId == SID_OBJECT_ROTATE)
     726             :                 {
     727           0 :                     nSlotId = SID_OBJECT_SELECT;
     728           0 :                     Activate();
     729             :                 }
     730             :             }
     731           0 :             else if (nSlotId == SID_CONVERT_TO_3D_LATHE)
     732             :             {
     733           0 :                 if (!pHdl)
     734             :                 {
     735           0 :                     bSuppressChangesOfSelection = sal_True;
     736           0 :                     mpView->Start3DCreation();
     737           0 :                     bSuppressChangesOfSelection = sal_False;
     738             :                 }
     739           0 :                 else if (pHdl->GetKind() != HDL_MIRX &&
     740           0 :                          pHdl->GetKind() != HDL_REF1 &&
     741           0 :                          pHdl->GetKind() != HDL_REF2 && mpView->Is3DRotationCreationActive())
     742             :                 {
     743             :                     /*********************************************************
     744             :                     * If 3D-rotation bodies are about to be created,
     745             :                     * end creation now
     746             :                     **********************************************************/
     747           0 :                      long nAngle1  = GetAngle(aPnt - mpView->GetRef1());
     748           0 :                      nAngle1 -= 27000;
     749           0 :                      nAngle1 = NormAngle360(nAngle1);
     750           0 :                      sal_Bool bMirrorSide1 = sal_Bool (nAngle1 < 18000L);
     751             : 
     752           0 :                      if (bMirrorSide0 != bMirrorSide1)
     753             :                      {
     754           0 :                          bSuppressChangesOfSelection = sal_True;
     755           0 :                         if(mpWindow)
     756           0 :                             mpWindow->EnterWait();
     757           0 :                          mpView->End3DCreation();
     758           0 :                          bSuppressChangesOfSelection = sal_False;
     759           0 :                          nSlotId = SID_OBJECT_SELECT;
     760           0 :                         if(mpWindow)
     761           0 :                             mpWindow->LeaveWait();
     762           0 :                          Activate();
     763             :                     }
     764             :                 }
     765             :             }
     766             :         }
     767           0 :         else if (rMEvt.IsMod1()
     768           0 :             && !rMEvt.IsMod2()
     769           0 :             && Abs(aPnt.X() - aMDPos.X()) < nDrgLog
     770           0 :             && Abs(aPnt.Y() - aMDPos.Y()) < nDrgLog)
     771             :         {
     772             :             // Enter group
     773           0 :             mpView->MarkObj(aPnt, nHitLog, rMEvt.IsShift(), rMEvt.IsMod1());
     774             :         }
     775             : 
     776           0 :         if (mpView->IsAction() )
     777             :         {
     778           0 :             mpView->EndAction();
     779             :         }
     780             : 
     781           0 :         if( SD_MOD()->GetWaterCan() )
     782             :         {
     783           0 :             if( rMEvt.IsRight() )
     784             :             {
     785             :                 // In watering-can mode, on press onto right mouse button, a undo is executed
     786           0 :                 mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_UNDO, SFX_CALLMODE_ASYNCHRON );
     787             :             }
     788           0 :             else if (pWaterCanCandidate != NULL)
     789             :             {
     790             :                 // Is the candiate object still under the mouse?
     791           0 :                 if (pickObject (aPnt) == pWaterCanCandidate)
     792             :                 {
     793             :                     SdStyleSheetPool* pPool = static_cast<SdStyleSheetPool*>(
     794           0 :                         mpDocSh->GetStyleSheetPool());
     795           0 :                     if (pPool != NULL)
     796             :                     {
     797             :                         SfxStyleSheet* pStyleSheet = static_cast<SfxStyleSheet*>(
     798           0 :                             pPool->GetActualStyleSheet());
     799           0 :                         if (pStyleSheet != NULL && mpView->IsUndoEnabled() )
     800             :                         {
     801             :                             // Added UNDOs for the WaterCan mode. This was never done in
     802             :                             // the past, thus it was missing all the time.
     803           0 :                             SdrUndoAction* pUndoAttr = mpDoc->GetSdrUndoFactory().CreateUndoAttrObject(*pWaterCanCandidate, sal_True, sal_True);
     804           0 :                             mpView->BegUndo(pUndoAttr->GetComment());
     805           0 :                             mpView->AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoGeoObject(*pWaterCanCandidate));
     806           0 :                             mpView->AddUndo(pUndoAttr);
     807             : 
     808           0 :                             pWaterCanCandidate->SetStyleSheet (pStyleSheet, sal_False);
     809             : 
     810           0 :                             mpView->EndUndo();
     811             :                         }
     812             :                     }
     813             :                 }
     814             :             }
     815             :             // else when there has been no object under the mouse when the
     816             :             // button was pressed then nothing happens even when there is
     817             :             // one now.
     818             :         }
     819             : 
     820           0 :         sal_uInt16 nClicks = rMEvt.GetClicks();
     821             : 
     822           0 :         if (nClicks == 2 && rMEvt.IsLeft() && bMBDown &&
     823           0 :             !rMEvt.IsMod1() && !rMEvt.IsShift() )
     824             :         {
     825           0 :             DoubleClick(rMEvt);
     826             :         }
     827             : 
     828           0 :         bMBDown = sal_False;
     829             : 
     830           0 :         ForcePointer(&rMEvt);
     831           0 :         pHdl = NULL;
     832           0 :         mpWindow->ReleaseMouse();
     833           0 :         SdrObject* pSingleObj = NULL;
     834           0 :         sal_uLong nMarkCount = mpView->GetMarkedObjectList().GetMarkCount();
     835             : 
     836           0 :         if (nMarkCount==1)
     837             :         {
     838           0 :             pSingleObj = mpView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
     839             :         }
     840             : 
     841           0 :         if ( (nSlotId != SID_OBJECT_SELECT && nMarkCount==0)                    ||
     842           0 :              ( mpView->GetDragMode() == SDRDRAG_CROOK &&
     843           0 :               !mpView->IsCrookAllowed( mpView->IsCrookNoContortion() ) ) ||
     844           0 :              ( mpView->GetDragMode() == SDRDRAG_SHEAR &&
     845           0 :               !mpView->IsShearAllowed() && !mpView->IsDistortAllowed() ) ||
     846             :              ( nSlotId==SID_CONVERT_TO_3D_LATHE && pSingleObj &&
     847           0 :               (pSingleObj->GetObjInventor() != SdrInventor         ||
     848           0 :                pSingleObj->GetObjIdentifier() == OBJ_MEASURE) ) )
     849             :         {
     850           0 :             bReturn = sal_True;
     851           0 :             ForcePointer(&rMEvt);
     852           0 :             pHdl = NULL;
     853           0 :             mpWindow->ReleaseMouse();
     854           0 :             FuDraw::MouseButtonUp(rMEvt);
     855           0 :             mpViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_SYNCHRON);
     856           0 :             return bReturn; // CAUTION, due to the synchronous slot, the object is deleted now.
     857             :         }
     858             : 
     859           0 :         FuDraw::MouseButtonUp(rMEvt);
     860             :     }
     861             :     else
     862             :     {
     863             :         /**********************************************************************
     864             :         * BEZIER_EDITOR
     865             :         **********************************************************************/
     866           0 :         if ( mpView->IsAction() )
     867             :         {
     868           0 :             if ( mpView->IsInsObjPoint() )
     869             :             {
     870           0 :                 mpView->EndInsObjPoint(SDRCREATE_FORCEEND);
     871             :             }
     872           0 :             else if ( mpView->IsDragObj() )
     873             :             {
     874           0 :                 FrameView* pFrameView = mpViewShell->GetFrameView();
     875           0 :                 sal_Bool bDragWithCopy = (rMEvt.IsMod1() && pFrameView->IsDragWithCopy());
     876             : 
     877           0 :                 if (bDragWithCopy)
     878             :                 {
     879           0 :                     bDragWithCopy = !mpView->IsPresObjSelected(sal_False, sal_True);
     880             :                 }
     881             : 
     882           0 :                 mpView->SetDragWithCopy(bDragWithCopy);
     883           0 :                 mpView->EndDragObj( mpView->IsDragWithCopy() );
     884             :             }
     885             :             else
     886             :             {
     887           0 :                 mpView->EndAction();
     888             : 
     889           0 :                 sal_uInt16 nDrgLog2 = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
     890           0 :                 Point aPos = mpWindow->PixelToLogic( rMEvt.GetPosPixel() );
     891             : 
     892           0 :                 if (Abs(aMDPos.X() - aPos.X()) < nDrgLog2 &&
     893           0 :                     Abs(aMDPos.Y() - aPos.Y()) < nDrgLog2 &&
     894           0 :                     !rMEvt.IsShift() && !rMEvt.IsMod2())
     895             :                 {
     896           0 :                     SdrViewEvent aVEvt;
     897           0 :                     SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
     898             : 
     899           0 :                     if (eHit == SDRHIT_NONE)
     900             :                     {
     901             :                         // Click on the same place - unselect
     902           0 :                         mpView->UnmarkAllObj();
     903           0 :                     }
     904             :                 }
     905             :             }
     906             :         }
     907           0 :         else if (!rMEvt.IsShift() && rMEvt.IsMod1() && !rMEvt.IsMod2() &&
     908           0 :                  Abs(aPnt.X() - aMDPos.X()) < nDrgLog &&
     909           0 :                  Abs(aPnt.Y() - aMDPos.Y()) < nDrgLog)
     910             :         {
     911             :             // Enter group
     912           0 :             mpView->MarkObj(aPnt, nHitLog, sal_False, rMEvt.IsMod1());
     913             :         }
     914             : 
     915             : 
     916           0 :         ForcePointer(&rMEvt);
     917           0 :         pHdl = NULL;
     918           0 :         mpWindow->ReleaseMouse();
     919             : 
     920           0 :         FuDraw::MouseButtonUp(rMEvt);
     921             :     }
     922             : 
     923           0 :     return (bReturn);
     924             : }
     925             : 
     926             : /*************************************************************************
     927             : |*
     928             : |* Process keyboard input
     929             : |*
     930             : |* If a KeyEvent is being processed, the Return-Wert is sal_True,
     931             : |* sal_False otherwise.
     932             : |*
     933             : \************************************************************************/
     934             : 
     935           0 : sal_Bool FuSelection::KeyInput(const KeyEvent& rKEvt)
     936             : {
     937           0 :     sal_Bool bReturn = sal_False;
     938             : 
     939           0 :     switch (rKEvt.GetKeyCode().GetCode())
     940             :     {
     941             :         case KEY_ESCAPE:
     942             :         {
     943           0 :             bReturn = FuSelection::cancel();
     944             :         }
     945           0 :         break;
     946             :     }
     947             : 
     948           0 :     if (!bReturn)
     949             :     {
     950           0 :         bReturn = FuDraw::KeyInput(rKEvt);
     951             : 
     952           0 :         if(mpView->GetMarkedObjectList().GetMarkCount() == 0)
     953             :         {
     954           0 :             mpView->ResetCreationActive();
     955             : 
     956           0 :             mpViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
     957             :         }
     958             :     }
     959             : 
     960           0 :     return(bReturn);
     961             : 
     962             : }
     963             : 
     964             : 
     965             : /*************************************************************************
     966             : |*
     967             : |* Activate function
     968             : |*
     969             : \************************************************************************/
     970             : 
     971           0 : void FuSelection::Activate()
     972             : {
     973             :     SdrDragMode eMode;
     974           0 :     mpView->ResetCreationActive();
     975           0 :     mpView->SetEditMode(SDREDITMODE_EDIT);
     976             : 
     977           0 :     switch( nSlotId )
     978             :     {
     979             :         case SID_OBJECT_ROTATE:
     980             :         {
     981             :             // (mapped) Slot is explicitly set to rotate
     982           0 :             if( mpViewShell->ISA(DrawViewShell) )
     983             :             {
     984             :                 sal_uInt16* pSlotArray =
     985           0 :                     static_cast<DrawViewShell*>(mpViewShell)->GetSlotArray();
     986           0 :                 pSlotArray[ 1 ] = SID_OBJECT_ROTATE;
     987             :             }
     988             : 
     989           0 :             eMode = SDRDRAG_ROTATE;
     990             : 
     991           0 :             if ( mpView->GetDragMode() != eMode )
     992           0 :                 mpView->SetDragMode(eMode);
     993             :         }
     994           0 :         break;
     995             : 
     996             :         case SID_OBJECT_MIRROR:
     997             :         {
     998           0 :             eMode = SDRDRAG_MIRROR;
     999             : 
    1000           0 :             if ( mpView->GetDragMode() != eMode )
    1001           0 :                 mpView->SetDragMode(eMode);
    1002             :         }
    1003           0 :         break;
    1004             : 
    1005             :         case SID_OBJECT_CROP:
    1006             :         {
    1007           0 :             eMode = SDRDRAG_CROP;
    1008             : 
    1009           0 :             if ( mpView->GetDragMode() != eMode )
    1010           0 :                 mpView->SetDragMode(eMode);
    1011             :         }
    1012           0 :         break;
    1013             : 
    1014             :         case SID_OBJECT_TRANSPARENCE:
    1015             :         {
    1016           0 :             eMode = SDRDRAG_TRANSPARENCE;
    1017             : 
    1018           0 :             if ( mpView->GetDragMode() != eMode )
    1019           0 :                 mpView->SetDragMode(eMode);
    1020             :         }
    1021           0 :         break;
    1022             : 
    1023             :         case SID_OBJECT_GRADIENT:
    1024             :         {
    1025           0 :             eMode = SDRDRAG_GRADIENT;
    1026             : 
    1027           0 :             if ( mpView->GetDragMode() != eMode )
    1028           0 :                 mpView->SetDragMode(eMode);
    1029             :         }
    1030           0 :         break;
    1031             : 
    1032             :         case SID_OBJECT_SHEAR:
    1033             :         {
    1034           0 :             eMode = SDRDRAG_SHEAR;
    1035             : 
    1036           0 :             if ( mpView->GetDragMode() != eMode )
    1037           0 :                 mpView->SetDragMode(eMode);
    1038             :         }
    1039           0 :         break;
    1040             : 
    1041             :         case SID_OBJECT_CROOK_ROTATE:
    1042             :         {
    1043           0 :             eMode = SDRDRAG_CROOK;
    1044             : 
    1045           0 :             if ( mpView->GetDragMode() != eMode )
    1046             :             {
    1047           0 :                 mpView->SetDragMode(eMode);
    1048           0 :                 mpView->SetCrookMode(SDRCROOK_ROTATE);
    1049             :             }
    1050             :         }
    1051           0 :         break;
    1052             : 
    1053             :         case SID_OBJECT_CROOK_SLANT:
    1054             :         {
    1055           0 :             eMode = SDRDRAG_CROOK;
    1056             : 
    1057           0 :             if ( mpView->GetDragMode() != eMode )
    1058             :             {
    1059           0 :                 mpView->SetDragMode(eMode);
    1060           0 :                 mpView->SetCrookMode(SDRCROOK_SLANT);
    1061             :             }
    1062             :         }
    1063           0 :         break;
    1064             : 
    1065             :         case SID_OBJECT_CROOK_STRETCH:
    1066             :         {
    1067           0 :             eMode = SDRDRAG_CROOK;
    1068             : 
    1069           0 :             if ( mpView->GetDragMode() != eMode )
    1070             :             {
    1071           0 :                 mpView->SetDragMode(eMode);
    1072           0 :                 mpView->SetCrookMode(SDRCROOK_STRETCH);
    1073             :             }
    1074             :         }
    1075           0 :         break;
    1076             : 
    1077             :         case SID_CONVERT_TO_3D_LATHE:
    1078             :         {
    1079           0 :             eMode = SDRDRAG_MIRROR;
    1080           0 :             bSuppressChangesOfSelection = sal_True;
    1081             : 
    1082           0 :             if ( mpView->GetDragMode() != eMode )
    1083           0 :                 mpView->SetDragMode(eMode);
    1084             : 
    1085           0 :             if (!mpView->Is3DRotationCreationActive())
    1086           0 :                 mpView->Start3DCreation();
    1087             : 
    1088           0 :             bSuppressChangesOfSelection = sal_False;
    1089             :         }
    1090           0 :         break;
    1091             : 
    1092             :         default:
    1093             :         {
    1094           0 :             eMode = SDRDRAG_MOVE;
    1095             : 
    1096           0 :             if ( mpView->GetDragMode() != eMode )
    1097           0 :                 mpView->SetDragMode(eMode);
    1098             :         }
    1099           0 :         break;
    1100             :     }
    1101             : 
    1102           0 :     if (nSlotId != SID_OBJECT_ROTATE)
    1103             :     {
    1104           0 :         bTempRotation = sal_False;
    1105             :     }
    1106             : 
    1107           0 :     FuDraw::Activate();
    1108           0 : }
    1109             : 
    1110             : 
    1111             : 
    1112             : /*************************************************************************
    1113             : |*
    1114             : |* Deactivate function
    1115             : |*
    1116             : \************************************************************************/
    1117             : 
    1118           0 : void FuSelection::Deactivate()
    1119             : {
    1120           0 :     FuDraw::Deactivate();
    1121           0 : }
    1122             : 
    1123             : 
    1124             : /*************************************************************************
    1125             : |*
    1126             : |* Selection was changed
    1127             : |*
    1128             : \************************************************************************/
    1129             : 
    1130           0 : void FuSelection::SelectionHasChanged()
    1131             : {
    1132           0 :     bSelectionChanged = sal_True;
    1133             : 
    1134           0 :     FuDraw::SelectionHasChanged();
    1135             : 
    1136           0 :     if ((mpView->Is3DRotationCreationActive() && !bSuppressChangesOfSelection))
    1137             :     {
    1138             :         // Switch rotation body -> selection
    1139           0 :         mpView->ResetCreationActive();
    1140           0 :         nSlotId = SID_OBJECT_SELECT;
    1141           0 :         Activate();
    1142             :     }
    1143             : 
    1144             :     // Activate the right tool bar for the current context of the view.
    1145           0 :     mpViewShell->GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*mpViewShell, *mpView);
    1146           0 : }
    1147             : 
    1148             : 
    1149             : /*************************************************************************
    1150             : |*
    1151             : |* Set current bezier edit mode
    1152             : |*
    1153             : \************************************************************************/
    1154             : 
    1155           0 : void FuSelection::SetEditMode(sal_uInt16 nMode)
    1156             : {
    1157           0 :     nEditMode = nMode;
    1158             : 
    1159           0 :     if (nEditMode == SID_BEZIER_INSERT)
    1160             :     {
    1161           0 :         mpView->SetInsObjPointMode(sal_True);
    1162             :     }
    1163             :     else
    1164             :     {
    1165           0 :         mpView->SetInsObjPointMode(sal_False);
    1166             :     }
    1167             : 
    1168           0 :     ForcePointer();
    1169             : 
    1170           0 :     SfxBindings& rBindings = mpViewShell->GetViewFrame()->GetBindings();
    1171           0 :     rBindings.Invalidate(SID_BEZIER_MOVE);
    1172           0 :     rBindings.Invalidate(SID_BEZIER_INSERT);
    1173           0 : }
    1174             : 
    1175             : /*************************************************************************
    1176             : |*
    1177             : |* Execute animation or interaction
    1178             : |*
    1179             : \************************************************************************/
    1180             : 
    1181           0 : sal_Bool FuSelection::AnimateObj(SdrObject* pObj, const Point& rPos)
    1182             : {
    1183           0 :     sal_Bool bAnimated = sal_False;
    1184           0 :     sal_Bool bClosed = pObj->IsClosedObj();
    1185           0 :     sal_Bool bFilled = sal_False;
    1186             : 
    1187           0 :     if (bClosed)
    1188             :     {
    1189           0 :         SfxItemSet aSet(mpDoc->GetPool());
    1190             : 
    1191           0 :         aSet.Put(pObj->GetMergedItemSet());
    1192             : 
    1193           0 :         const XFillStyleItem& rFillStyle = (const XFillStyleItem&) aSet.Get(XATTR_FILLSTYLE);
    1194           0 :         bFilled = rFillStyle.GetValue() != XFILL_NONE;
    1195             :     }
    1196             : 
    1197           0 :     const SetOfByte* pVisiLayer = &mpView->GetSdrPageView()->GetVisibleLayers();
    1198           0 :     sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
    1199           0 :     const long  n2HitLog = nHitLog * 2;
    1200           0 :     Point aHitPosR(rPos);
    1201           0 :     Point aHitPosL(rPos);
    1202           0 :     Point aHitPosT(rPos);
    1203           0 :     Point aHitPosB(rPos);
    1204             : 
    1205           0 :     aHitPosR.X() += n2HitLog;
    1206           0 :     aHitPosL.X() -= n2HitLog;
    1207           0 :     aHitPosT.Y() += n2HitLog;
    1208           0 :     aHitPosB.Y() -= n2HitLog;
    1209             : 
    1210           0 :     if ( !bClosed                                      ||
    1211             :          !bFilled                                      ||
    1212           0 :          (SdrObjectPrimitiveHit(*pObj, aHitPosR, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) &&
    1213           0 :           SdrObjectPrimitiveHit(*pObj, aHitPosL, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) &&
    1214           0 :           SdrObjectPrimitiveHit(*pObj, aHitPosT, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) &&
    1215           0 :           SdrObjectPrimitiveHit(*pObj, aHitPosB, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) ) )
    1216             :     {
    1217           0 :         if ( mpDoc->GetIMapInfo( pObj ) )
    1218             :         {
    1219           0 :             const IMapObject* pIMapObj = mpDoc->GetHitIMapObject( pObj, rPos, *mpWindow );
    1220             : 
    1221           0 :             if ( pIMapObj && pIMapObj->GetURL().Len() )
    1222             :             {
    1223             :                 // Jump to Document
    1224           0 :                 mpWindow->ReleaseMouse();
    1225           0 :                 SfxStringItem aStrItem(SID_FILE_NAME, pIMapObj->GetURL());
    1226           0 :                 SfxStringItem aReferer(SID_REFERER, mpDocSh->GetMedium()->GetName());
    1227           0 :                 SfxViewFrame* pFrame = mpViewShell->GetViewFrame();
    1228           0 :                 SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame);
    1229           0 :                 SfxBoolItem aBrowseItem( SID_BROWSE, sal_True );
    1230           0 :                 mpWindow->ReleaseMouse();
    1231             :                 pFrame->GetDispatcher()->
    1232             :                     Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
    1233           0 :                             &aStrItem, &aFrameItem, &aBrowseItem, &aReferer, 0L);
    1234             : 
    1235           0 :                 bAnimated = sal_True;
    1236             :             }
    1237             :         }
    1238           0 :         else if (!mpDocSh->ISA(GraphicDocShell)        &&
    1239           0 :                  mpView->ISA(DrawView)                 &&
    1240           0 :                  mpDoc->GetAnimationInfo(pObj))
    1241             :         {
    1242             :             /**********************************************************
    1243             :             * Animation-object hit in the middle -> interaction
    1244             :             **********************************************************/
    1245           0 :             SdAnimationInfo* pInfo = mpDoc->GetAnimationInfo(pObj);
    1246           0 :             DrawViewShell* pDrViewSh = static_cast<DrawViewShell*>(mpViewShell);
    1247           0 :             mpWindow->ReleaseMouse();
    1248             : 
    1249           0 :             switch (pInfo->meClickAction)
    1250             :             {
    1251             :                 case presentation::ClickAction_BOOKMARK:
    1252             :                 {
    1253             :                      // Jump to Bookmark (Page or Object)
    1254           0 :                     SfxStringItem aItem(SID_NAVIGATOR_OBJECT, pInfo->GetBookmark());
    1255             :                     mpViewShell->GetViewFrame()->GetDispatcher()->
    1256           0 :                     Execute(SID_NAVIGATOR_OBJECT, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD, &aItem, 0L);
    1257           0 :                     bAnimated = sal_True;
    1258             :                 }
    1259           0 :                 break;
    1260             : 
    1261             :                 case presentation::ClickAction_DOCUMENT:
    1262             :                 {
    1263           0 :                     String sBookmark( pInfo->GetBookmark() );
    1264             :                     // Jump to document
    1265           0 :                     if (sBookmark.Len())
    1266             :                     {
    1267           0 :                         SfxStringItem aReferer(SID_REFERER, mpDocSh->GetMedium()->GetName());
    1268           0 :                         SfxStringItem aStrItem(SID_FILE_NAME, sBookmark);
    1269           0 :                         SfxViewFrame* pFrame = mpViewShell->GetViewFrame();
    1270           0 :                         SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame);
    1271           0 :                         SfxBoolItem aBrowseItem( SID_BROWSE, sal_True );
    1272             :                         pFrame->GetDispatcher()->
    1273             :                         Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
    1274           0 :                                 &aStrItem, &aFrameItem, &aBrowseItem, &aReferer, 0L);
    1275             :                     }
    1276             : 
    1277           0 :                     bAnimated = sal_True;
    1278             :                 }
    1279           0 :                 break;
    1280             : 
    1281             :                 case presentation::ClickAction_PREVPAGE:
    1282             :                 {
    1283             :                     // Jump to the previous page
    1284           0 :                     SfxUInt16Item aItem(SID_NAVIGATOR_PAGE, PAGE_PREVIOUS);
    1285             :                     mpViewShell->GetViewFrame()->GetDispatcher()->
    1286             :                     Execute(SID_NAVIGATOR_PAGE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD,
    1287           0 :                             &aItem, 0L);
    1288           0 :                     bAnimated = sal_True;
    1289             :                 }
    1290           0 :                 break;
    1291             : 
    1292             :                 case presentation::ClickAction_NEXTPAGE:
    1293             :                 {
    1294             :                     // Jump to the next page
    1295           0 :                     SfxUInt16Item aItem(SID_NAVIGATOR_PAGE, PAGE_NEXT);
    1296             :                     mpViewShell->GetViewFrame()->GetDispatcher()->
    1297             :                     Execute(SID_NAVIGATOR_PAGE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD,
    1298           0 :                             &aItem, 0L);
    1299           0 :                     bAnimated = sal_True;
    1300             :                 }
    1301           0 :                 break;
    1302             : 
    1303             :                 case presentation::ClickAction_FIRSTPAGE:
    1304             :                 {
    1305             :                     // Jump to the first page
    1306           0 :                     SfxUInt16Item aItem(SID_NAVIGATOR_PAGE, PAGE_FIRST);
    1307             :                     mpViewShell->GetViewFrame()->GetDispatcher()->
    1308             :                     Execute(SID_NAVIGATOR_PAGE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD,
    1309           0 :                             &aItem, 0L);
    1310           0 :                     bAnimated = sal_True;
    1311             :                 }
    1312           0 :                 break;
    1313             : 
    1314             :                 case presentation::ClickAction_LASTPAGE:
    1315             :                 {
    1316             :                     // Jump to the last page
    1317           0 :                     SfxUInt16Item aItem(SID_NAVIGATOR_PAGE, PAGE_LAST);
    1318             :                     mpViewShell->GetViewFrame()->GetDispatcher()->
    1319             :                     Execute(SID_NAVIGATOR_PAGE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD,
    1320           0 :                             &aItem, 0L);
    1321           0 :                     bAnimated = sal_True;
    1322             :                 }
    1323           0 :                 break;
    1324             : 
    1325             :                 case presentation::ClickAction_SOUND:
    1326             :                 {
    1327             :                         try
    1328             :                         {
    1329           0 :                             mxPlayer.set( avmedia::MediaWindow::createPlayer( pInfo->GetBookmark()), uno::UNO_QUERY_THROW );
    1330           0 :                             mxPlayer->start();
    1331             :                         }
    1332           0 :                         catch( uno::Exception& )
    1333             :                         {
    1334             :                         }
    1335           0 :                     bAnimated = sal_True;
    1336             :                 }
    1337           0 :                 break;
    1338             : 
    1339             :                 case presentation::ClickAction_VERB:
    1340             :                 {
    1341             :                     // Assign verb
    1342           0 :                     mpView->UnmarkAll();
    1343           0 :                     mpView->MarkObj(pObj, mpView->GetSdrPageView(), sal_False, sal_False);
    1344           0 :                     pDrViewSh->DoVerb((sal_Int16)pInfo->mnVerb);
    1345           0 :                     bAnimated = sal_True;
    1346             :                 }
    1347           0 :                 break;
    1348             : 
    1349             :                 case presentation::ClickAction_PROGRAM:
    1350             :                 {
    1351           0 :                    String aBaseURL = GetDocSh()->GetMedium()->GetBaseURL();
    1352             :                    INetURLObject aURL( ::URIHelper::SmartRel2Abs( INetURLObject(aBaseURL), pInfo->GetBookmark(),
    1353             :                                                 URIHelper::GetMaybeFileHdl(), true, false,
    1354           0 :                                                 INetURLObject::WAS_ENCODED, INetURLObject::DECODE_UNAMBIGUOUS ) );
    1355             : 
    1356           0 :                    if( INET_PROT_FILE == aURL.GetProtocol() )
    1357             :                    {
    1358           0 :                         SfxStringItem aUrl( SID_FILE_NAME, aURL.GetMainURL( INetURLObject::NO_DECODE ) );
    1359           0 :                         SfxBoolItem aBrowsing( SID_BROWSE, sal_True );
    1360             : 
    1361           0 :                         SfxViewFrame* pViewFrm = SfxViewFrame::Current();
    1362           0 :                         if (pViewFrm)
    1363             :                             pViewFrm->GetDispatcher()->Execute( SID_OPENDOC,
    1364             :                                                           SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
    1365             :                                                         &aUrl,
    1366             :                                                         &aBrowsing,
    1367           0 :                                                         0L );
    1368             :                    }
    1369             : 
    1370           0 :                     bAnimated = sal_True;
    1371             :                 }
    1372           0 :                 break;
    1373             : 
    1374             :                 case presentation::ClickAction_MACRO:
    1375             :                 {
    1376             :                     // Execute macro
    1377           0 :                     String aMacro = pInfo->GetBookmark();
    1378             : 
    1379           0 :                     if ( SfxApplication::IsXScriptURL( aMacro ) )
    1380             :                     {
    1381           0 :                         uno::Any aRet;
    1382           0 :                         uno::Sequence< sal_Int16 > aOutArgsIndex;
    1383           0 :                         uno::Sequence< uno::Any > aOutArgs;
    1384             :                         uno::Sequence< uno::Any >* pInArgs =
    1385           0 :                             new uno::Sequence< uno::Any >(0);
    1386             : 
    1387             :                         ErrCode eErr = mpDocSh->CallXScript( aMacro,
    1388           0 :                             *pInArgs, aRet, aOutArgsIndex, aOutArgs);
    1389             : 
    1390             :                         // Check the return value from the script
    1391           0 :                         sal_Bool bTmp = sal_False;
    1392           0 :                         if ( eErr == ERRCODE_NONE &&
    1393           0 :                              aRet.getValueType() == getCppuBooleanType() &&
    1394           0 :                              sal_True == ( aRet >>= bTmp ) &&
    1395             :                              bTmp == sal_True )
    1396             :                         {
    1397           0 :                             bAnimated = sal_True;
    1398             :                         }
    1399             :                         else
    1400             :                         {
    1401           0 :                             bAnimated = sal_False;
    1402           0 :                         }
    1403             :                     }
    1404             :                     else
    1405             :                     {
    1406             :                         // aMacro has got following format:
    1407             :                         // "Macroname.Modulname.Libname.Documentname" or
    1408             :                         // "Macroname.Modulname.Libname.Applicationsname"
    1409             :                         String aMacroName =
    1410           0 :                             aMacro.GetToken(0, sal_Unicode('.'));
    1411             :                         String aModulName =
    1412           0 :                              aMacro.GetToken(1, sal_Unicode('.'));
    1413             :                         String aLibName   =
    1414           0 :                              aMacro.GetToken(2, sal_Unicode('.'));
    1415             :                         String aDocName   =
    1416           0 :                              aMacro.GetToken(3, sal_Unicode('.'));
    1417             : 
    1418             :                         // In this moment the Call-method only
    1419             :                         // resolves modulename+macroname
    1420           0 :                         String aExecMacro(aModulName);
    1421           0 :                         aExecMacro.Append( sal_Unicode('.') );
    1422           0 :                         aExecMacro.Append( aMacroName );
    1423           0 :                         bAnimated = mpDocSh->GetBasic()->Call(aExecMacro);
    1424           0 :                     }
    1425             :                 }
    1426           0 :                 break;
    1427             : 
    1428             :                 default:
    1429             :                 {
    1430           0 :                     bAnimated = sal_False;
    1431             :                 }
    1432           0 :                 break;
    1433             :             }
    1434             :         }
    1435             : 
    1436           0 :         if (!bAnimated                               &&
    1437           0 :             mpView->ISA(DrawView)                 &&
    1438           0 :             !mpDocSh->ISA(GraphicDocShell)        &&
    1439           0 :             SlideShow::IsRunning( mpViewShell->GetViewShellBase() ) &&
    1440           0 :             mpDoc->GetAnimationInfo(pObj))
    1441             :         {
    1442             :             /**********************************************************
    1443             :             * Effect-Object hit in the middle -> Play effect
    1444             :             **********************************************************/
    1445           0 :             SdAnimationInfo* pInfo = mpDoc->GetAnimationInfo(pObj);
    1446             : 
    1447           0 :             switch (pInfo->meClickAction)
    1448             :             {
    1449             :                 case presentation::ClickAction_VANISH:
    1450             :                 case presentation::ClickAction_INVISIBLE:
    1451           0 :                     break;
    1452             : 
    1453             :                 default:
    1454           0 :                     bAnimated = sal_False;
    1455           0 :                 break;
    1456             :             }
    1457             :         }
    1458             :     }
    1459             : 
    1460           0 :     return bAnimated;
    1461             : }
    1462             : 
    1463             : 
    1464             : 
    1465             : /** is called when the current function should be aborted. <p>
    1466             :     This is used when a function gets a KEY_ESCAPE but can also
    1467             :     be called directly.
    1468             : 
    1469             :     @returns true if a active function was aborted
    1470             : */
    1471           0 : bool FuSelection::cancel()
    1472             : {
    1473           0 :     if (mpView->Is3DRotationCreationActive())
    1474             :     {
    1475           0 :         mpView->ResetCreationActive();
    1476           0 :         mpViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
    1477           0 :         return true;
    1478             :     }
    1479             :     else
    1480             :     {
    1481           0 :         return false;
    1482             :     }
    1483             : }
    1484             : 
    1485             : 
    1486             : 
    1487             : 
    1488           0 : SdrObject* FuSelection::pickObject (const Point& rTestPoint)
    1489             : {
    1490           0 :     SdrObject* pObject = NULL;
    1491             :     SdrPageView* pPageView;
    1492           0 :     sal_uInt16 nHitLog = sal_uInt16 (mpWindow->PixelToLogic(Size(HITPIX,0)).Width());
    1493           0 :     mpView->PickObj (rTestPoint, nHitLog, pObject, pPageView, SDRSEARCH_PICKMARKABLE);
    1494           0 :     return pObject;
    1495             : }
    1496             : } // end of namespace sd
    1497             : 
    1498             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10