sd/source/ui/func/fusel.cxx

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