sd/source/ui/func/fusel.cxx

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