LCOV - code coverage report
Current view: top level - libreoffice/sd/source/ui/func - fudraw.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 1 435 0.2 %
Date: 2012-12-27 Functions: 2 22 9.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <sot/object.hxx>
      22             : #include <editeng/eeitem.hxx>
      23             : #include <vcl/waitobj.hxx>
      24             : 
      25             : #include <editeng/flditem.hxx>
      26             : #include <svx/svdogrp.hxx>
      27             : #include <tools/urlobj.hxx>
      28             : #include <vcl/help.hxx>
      29             : #include <svx/bmpmask.hxx>
      30             : #include <svx/svdotext.hxx>
      31             : #include <sfx2/app.hxx>
      32             : #include <sfx2/dispatch.hxx>
      33             : #include <sfx2/bindings.hxx>
      34             : #include <svx/svdpagv.hxx>
      35             : #include <svtools/imapobj.hxx>
      36             : #include <svx/svxids.hrc>
      37             : #include <svx/obj3d.hxx>
      38             : #include <svx/polysc3d.hxx>
      39             : 
      40             : #include <sfx2/viewfrm.hxx>
      41             : 
      42             : #include "anminfo.hxx"
      43             : #include "imapinfo.hxx"
      44             : #include "app.hrc"
      45             : #include "glob.hrc"
      46             : #include "strings.hrc"
      47             : #include "res_bmp.hrc"
      48             : 
      49             : #include "app.hxx"
      50             : #include "GraphicDocShell.hxx"
      51             : #include "fudraw.hxx"
      52             : #include "ViewShell.hxx"
      53             : #include "FrameView.hxx"
      54             : #include "View.hxx"
      55             : #include "Window.hxx"
      56             : #include "drawdoc.hxx"
      57             : #include "DrawDocShell.hxx"
      58             : #include "Client.hxx"
      59             : #include "sdresid.hxx"
      60             : #include "drawview.hxx"
      61             : #include "fusel.hxx"
      62             : #include <svl/aeitem.hxx>
      63             : #include <vcl/msgbox.hxx>
      64             : #include "slideshow.hxx"
      65             : #include <svx/sdrhittesthelper.hxx>
      66             : 
      67             : using namespace ::com::sun::star;
      68             : 
      69             : namespace sd {
      70             : 
      71           0 : TYPEINIT1( FuDraw, FuPoor );
      72             : 
      73             : /*************************************************************************
      74             : |*
      75             : |* Base-class for all drawmodul-specific functions
      76             : |*
      77             : \************************************************************************/
      78             : 
      79           0 : FuDraw::FuDraw(ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView,
      80             :                SdDrawDocument* pDoc, SfxRequest& rReq) :
      81             :     FuPoor(pViewSh, pWin, pView, pDoc, rReq),
      82             :     bMBDown(sal_False),
      83             :     bDragHelpLine(sal_False),
      84           0 :     bPermanent(sal_False)
      85             : {
      86           0 : }
      87             : 
      88             : /*************************************************************************
      89             : |*
      90             : |* Destruktor
      91             : |*
      92             : \************************************************************************/
      93             : 
      94           0 : FuDraw::~FuDraw()
      95             : {
      96           0 :     mpView->BrkAction();
      97           0 : }
      98             : 
      99             : /*************************************************************************
     100             : |*
     101             : |* MouseButtonDown-event
     102             : |*
     103             : \************************************************************************/
     104             : 
     105           0 : sal_Bool FuDraw::MouseButtonDown(const MouseEvent& rMEvt)
     106             : {
     107             :     // remember button state for creation of own MouseEvents
     108           0 :     SetMouseButtonCode(rMEvt.GetButtons());
     109             : 
     110           0 :     sal_Bool bReturn = sal_False;
     111             : 
     112           0 :     bDragHelpLine = sal_False;
     113             : 
     114           0 :     aMDPos = mpWindow->PixelToLogic( rMEvt.GetPosPixel() );
     115             : 
     116           0 :     if ( rMEvt.IsLeft() )
     117             :     {
     118           0 :         FrameView* pFrameView = mpViewShell->GetFrameView();
     119             : 
     120           0 :         bool bOrtho = sal_False;
     121             : 
     122           0 :         sal_Bool bRestricted = sal_True;
     123             : 
     124           0 :         if (mpView->IsDragObj())
     125             :         {
     126             :             // object is dragged (move, resize,...)
     127           0 :             const SdrHdl* pHdl = mpView->GetDragStat().GetHdl();
     128             : 
     129           0 :             if (!pHdl || (!pHdl->IsCornerHdl() && !pHdl->IsVertexHdl()))
     130             :             {
     131             :                 // Move
     132           0 :                 bRestricted = sal_False;
     133             :             }
     134             :         }
     135             : 
     136             :         // #i33136#
     137           0 :         if(bRestricted && doConstructOrthogonal())
     138             :         {
     139             :             // Restrict movement:
     140             :             // rectangle->quadrat, ellipse->circle etc.
     141           0 :             bOrtho = !rMEvt.IsShift();
     142             :         }
     143             :         else
     144             :         {
     145           0 :             bOrtho = rMEvt.IsShift() != pFrameView->IsOrtho();
     146             :         }
     147             : 
     148           0 :         if (!mpView->IsSnapEnabled())
     149           0 :             mpView->SetSnapEnabled(sal_True);
     150           0 :         sal_Bool bSnapModPressed = rMEvt.IsMod1();
     151             : 
     152           0 :         sal_Bool bGridSnap = pFrameView->IsGridSnap();
     153           0 :         bGridSnap = (bSnapModPressed != bGridSnap);
     154             : 
     155           0 :         if (mpView->IsGridSnap() != bGridSnap)
     156           0 :             mpView->SetGridSnap(bGridSnap);
     157             : 
     158           0 :         sal_Bool bBordSnap = pFrameView->IsBordSnap();
     159           0 :         bBordSnap = (bSnapModPressed != bBordSnap);
     160             : 
     161           0 :         if (mpView->IsBordSnap() != bBordSnap)
     162           0 :             mpView->SetBordSnap(bBordSnap);
     163             : 
     164           0 :         sal_Bool bHlplSnap = pFrameView->IsHlplSnap();
     165           0 :         bHlplSnap = (bSnapModPressed != bHlplSnap);
     166             : 
     167           0 :         if (mpView->IsHlplSnap() != bHlplSnap)
     168           0 :             mpView->SetHlplSnap(bHlplSnap);
     169             : 
     170           0 :         sal_Bool bOFrmSnap = pFrameView->IsOFrmSnap();
     171           0 :         bOFrmSnap = (bSnapModPressed != bOFrmSnap);
     172             : 
     173           0 :         if (mpView->IsOFrmSnap() != bOFrmSnap)
     174           0 :             mpView->SetOFrmSnap(bOFrmSnap);
     175             : 
     176           0 :         sal_Bool bOPntSnap = pFrameView->IsOPntSnap();
     177           0 :         bOPntSnap = (bSnapModPressed != bOPntSnap);
     178             : 
     179           0 :         if (mpView->IsOPntSnap() != bOPntSnap)
     180           0 :             mpView->SetOPntSnap(bOPntSnap);
     181             : 
     182           0 :         sal_Bool bOConSnap = pFrameView->IsOConSnap();
     183           0 :         bOConSnap = (bSnapModPressed != bOConSnap);
     184             : 
     185           0 :         if (mpView->IsOConSnap() != bOConSnap)
     186           0 :             mpView->SetOConSnap(bOConSnap);
     187             : 
     188           0 :         sal_Bool bAngleSnap = rMEvt.IsShift() == !pFrameView->IsAngleSnapEnabled();
     189             : 
     190           0 :         if (mpView->IsAngleSnapEnabled() != bAngleSnap)
     191           0 :             mpView->SetAngleSnapEnabled(bAngleSnap);
     192             : 
     193           0 :         if (mpView->IsOrtho() != bOrtho)
     194           0 :             mpView->SetOrtho(bOrtho);
     195             : 
     196           0 :         sal_Bool bCenter = rMEvt.IsMod2();
     197             : 
     198           0 :         if ( mpView->IsCreate1stPointAsCenter() != bCenter ||
     199           0 :              mpView->IsResizeAtCenter() != bCenter )
     200             :         {
     201           0 :             mpView->SetCreate1stPointAsCenter(bCenter);
     202           0 :             mpView->SetResizeAtCenter(bCenter);
     203             :         }
     204             : 
     205           0 :         SdrPageView* pPV = 0;
     206           0 :         sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
     207             : 
     208             :         // look only for HelpLines when they are visible (!)
     209           0 :         sal_Bool bHelpLine(sal_False);
     210           0 :         if(mpView->IsHlplVisible())
     211           0 :             bHelpLine = mpView->PickHelpLine(aMDPos, nHitLog, *mpWindow, nHelpLine, pPV);
     212           0 :         sal_Bool bHitHdl = (mpView->PickHandle(aMDPos) != NULL);
     213             : 
     214           0 :         if ( bHelpLine
     215           0 :             && !mpView->IsCreateObj()
     216           0 :             && ((mpView->GetEditMode() == SDREDITMODE_EDIT && !bHitHdl) || (rMEvt.IsShift() && bSnapModPressed)) )
     217             :         {
     218           0 :             mpWindow->CaptureMouse();
     219           0 :             mpView->BegDragHelpLine(nHelpLine, pPV);
     220           0 :             bDragHelpLine = mpView->IsDragHelpLine();
     221           0 :             bReturn = sal_True;
     222             :         }
     223             :     }
     224           0 :     ForcePointer(&rMEvt);
     225             : 
     226           0 :     return bReturn;
     227             : }
     228             : 
     229             : /*************************************************************************
     230             : |*
     231             : |* MouseMove-event
     232             : |*
     233             : \************************************************************************/
     234             : 
     235           0 : sal_Bool FuDraw::MouseMove(const MouseEvent& rMEvt)
     236             : {
     237           0 :     FrameView* pFrameView = mpViewShell->GetFrameView();
     238           0 :     Point aPos = mpWindow->PixelToLogic( rMEvt.GetPosPixel() );
     239             : 
     240           0 :     bool bOrtho = sal_False;
     241             : 
     242           0 :     sal_Bool bRestricted = sal_True;
     243             : 
     244           0 :     if (mpView->IsDragObj())
     245             :     {
     246             :         // object is dragged (move, resize, ...)
     247           0 :         const SdrHdl* pHdl = mpView->GetDragStat().GetHdl();
     248             : 
     249           0 :         if (!pHdl || (!pHdl->IsCornerHdl() && !pHdl->IsVertexHdl()))
     250             :         {
     251             :             // Move
     252           0 :             bRestricted = sal_False;
     253             :         }
     254             :     }
     255             : 
     256           0 :     if (mpView->IsAction())
     257             :     {
     258             :         // #i33136#
     259           0 :         if(bRestricted && doConstructOrthogonal())
     260             :         {
     261             :             // Restrict movement:
     262             :             // rectangle->quadrat, ellipse->circle etc.
     263           0 :             bOrtho = !rMEvt.IsShift();
     264             :         }
     265             :         else
     266             :         {
     267           0 :             bOrtho = rMEvt.IsShift() != pFrameView->IsOrtho();
     268             :         }
     269             : 
     270           0 :         sal_Bool bSnapModPressed = rMEvt.IsMod2();
     271           0 :         mpView->SetDragWithCopy(rMEvt.IsMod1() && pFrameView->IsDragWithCopy());
     272             : 
     273           0 :         sal_Bool bGridSnap = pFrameView->IsGridSnap();
     274           0 :         bGridSnap = (bSnapModPressed != bGridSnap);
     275             : 
     276           0 :         if (mpView->IsGridSnap() != bGridSnap)
     277           0 :             mpView->SetGridSnap(bGridSnap);
     278             : 
     279           0 :         sal_Bool bBordSnap = pFrameView->IsBordSnap();
     280           0 :         bBordSnap = (bSnapModPressed != bBordSnap);
     281             : 
     282           0 :         if (mpView->IsBordSnap() != bBordSnap)
     283           0 :             mpView->SetBordSnap(bBordSnap);
     284             : 
     285           0 :         sal_Bool bHlplSnap = pFrameView->IsHlplSnap();
     286           0 :         bHlplSnap = (bSnapModPressed != bHlplSnap);
     287             : 
     288           0 :         if (mpView->IsHlplSnap() != bHlplSnap)
     289           0 :             mpView->SetHlplSnap(bHlplSnap);
     290             : 
     291           0 :         sal_Bool bOFrmSnap = pFrameView->IsOFrmSnap();
     292           0 :         bOFrmSnap = (bSnapModPressed != bOFrmSnap);
     293             : 
     294           0 :         if (mpView->IsOFrmSnap() != bOFrmSnap)
     295           0 :             mpView->SetOFrmSnap(bOFrmSnap);
     296             : 
     297           0 :         sal_Bool bOPntSnap = pFrameView->IsOPntSnap();
     298           0 :         bOPntSnap = (bSnapModPressed != bOPntSnap);
     299             : 
     300           0 :         if (mpView->IsOPntSnap() != bOPntSnap)
     301           0 :             mpView->SetOPntSnap(bOPntSnap);
     302             : 
     303           0 :         sal_Bool bOConSnap = pFrameView->IsOConSnap();
     304           0 :         bOConSnap = (bSnapModPressed != bOConSnap);
     305             : 
     306           0 :         if (mpView->IsOConSnap() != bOConSnap)
     307           0 :             mpView->SetOConSnap(bOConSnap);
     308             : 
     309           0 :         sal_Bool bAngleSnap = rMEvt.IsShift() == !pFrameView->IsAngleSnapEnabled();
     310             : 
     311           0 :         if (mpView->IsAngleSnapEnabled() != bAngleSnap)
     312           0 :             mpView->SetAngleSnapEnabled(bAngleSnap);
     313             : 
     314           0 :         if (mpView->IsOrtho() != bOrtho)
     315           0 :             mpView->SetOrtho(bOrtho);
     316             : 
     317           0 :         sal_Bool bCenter = rMEvt.IsMod2();
     318             : 
     319           0 :         if ( mpView->IsCreate1stPointAsCenter() != bCenter ||
     320           0 :              mpView->IsResizeAtCenter() != bCenter )
     321             :         {
     322           0 :             mpView->SetCreate1stPointAsCenter(bCenter);
     323           0 :             mpView->SetResizeAtCenter(bCenter);
     324             :         }
     325             : 
     326           0 :         if ( mpView->IsDragHelpLine() )
     327           0 :             mpView->MovDragHelpLine(aPos);
     328             :     }
     329             : 
     330           0 :     sal_Bool bReturn = mpView->MouseMove(rMEvt, mpWindow);
     331             : 
     332           0 :     if (mpView->IsAction())
     333             :     {
     334             :         // Because the flag set back if necessary in MouseMove
     335           0 :         if (mpView->IsOrtho() != bOrtho)
     336           0 :             mpView->SetOrtho(bOrtho);
     337             :     }
     338             : 
     339           0 :     ForcePointer(&rMEvt);
     340             : 
     341           0 :     return bReturn;
     342             : }
     343             : 
     344             : /*************************************************************************
     345             : |*
     346             : |* MouseButtonUp-event
     347             : |*
     348             : \************************************************************************/
     349             : 
     350           0 : sal_Bool FuDraw::MouseButtonUp(const MouseEvent& rMEvt)
     351             : {
     352           0 :     if ( mpView->IsDragHelpLine() )
     353           0 :         mpView->EndDragHelpLine();
     354             : 
     355           0 :     if ( bDragHelpLine )
     356             :     {
     357           0 :         Rectangle aOutputArea(Point(0,0), mpWindow->GetOutputSizePixel());
     358             : 
     359           0 :         if ( !aOutputArea.IsInside(rMEvt.GetPosPixel()) )
     360           0 :             mpView->GetSdrPageView()->DeleteHelpLine(nHelpLine);
     361             : 
     362           0 :         mpWindow->ReleaseMouse();
     363             :     }
     364             : 
     365           0 :     FrameView* pFrameView = mpViewShell->GetFrameView();
     366           0 :     mpView->SetOrtho( pFrameView->IsOrtho() );
     367           0 :     mpView->SetAngleSnapEnabled( pFrameView->IsAngleSnapEnabled() );
     368           0 :     mpView->SetSnapEnabled(sal_True);
     369           0 :     mpView->SetCreate1stPointAsCenter(sal_False);
     370           0 :     mpView->SetResizeAtCenter(sal_False);
     371           0 :     mpView->SetDragWithCopy(pFrameView->IsDragWithCopy());
     372           0 :     mpView->SetGridSnap(pFrameView->IsGridSnap());
     373           0 :     mpView->SetBordSnap(pFrameView->IsBordSnap());
     374           0 :     mpView->SetHlplSnap(pFrameView->IsHlplSnap());
     375           0 :     mpView->SetOFrmSnap(pFrameView->IsOFrmSnap());
     376           0 :     mpView->SetOPntSnap(pFrameView->IsOPntSnap());
     377           0 :     mpView->SetOConSnap(pFrameView->IsOConSnap());
     378             : 
     379           0 :     bIsInDragMode = sal_False;
     380           0 :     ForcePointer(&rMEvt);
     381           0 :     FuPoor::MouseButtonUp(rMEvt);
     382             : 
     383           0 :     return sal_False;
     384             : }
     385             : 
     386             : /*************************************************************************
     387             : |*
     388             : |* Process keyboard-events
     389             : |*
     390             : |* When processing a KeyEvent the returnvalue is sal_True, otherwise sal_False.
     391             : |*
     392             : \************************************************************************/
     393             : 
     394           0 : sal_Bool FuDraw::KeyInput(const KeyEvent& rKEvt)
     395             : {
     396           0 :     sal_Bool bReturn = sal_False;
     397             : 
     398           0 :     switch ( rKEvt.GetKeyCode().GetCode() )
     399             :     {
     400             :         case KEY_ESCAPE:
     401             :         {
     402           0 :             bReturn = FuDraw::cancel();
     403             :         }
     404           0 :         break;
     405             : 
     406             :         case KEY_DELETE:
     407             :         case KEY_BACKSPACE:
     408             :         {
     409           0 :             if (!mpDocSh->IsReadOnly())
     410             :             {
     411           0 :                 if ( mpView && mpView->IsPresObjSelected(sal_False, sal_True, sal_False, sal_True) )
     412             :                 {
     413           0 :                     InfoBox(mpWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute();
     414             :                 }
     415             :                 else
     416             :                 {
     417             :                     // Falls IP-Client aktiv, werden die Pointer
     418             :                     // auf das OLE- und das alte Graphic-Object
     419             :                     // am SdClient zurueckgesetzt, damit bei
     420             :                     // ::SelectionHasChanged nach dem Loeschen
     421             :                     // nicht mehr versucht wird, ein Grafik-Objekt
     422             :                     // zu restaurieren, das gar nicht mehr existiert.
     423             :                     // Alle anderen OLE-Objekte sind davon nicht
     424             :                     // betroffen
     425             :                     OSL_ASSERT (mpViewShell->GetViewShell()!=NULL);
     426             :                     Client* pIPClient = static_cast<Client*>(
     427           0 :                         mpViewShell->GetViewShell()->GetIPClient());
     428           0 :                     if (pIPClient && pIPClient->IsObjectInPlaceActive())
     429           0 :                         pIPClient->SetSdrGrafObj(NULL);
     430             : 
     431             :                     // wait-mousepointer while deleting object
     432           0 :                     WaitObject aWait( (Window*)mpViewShell->GetActiveWindow() );
     433             :                     // delete object
     434           0 :                     mpView->DeleteMarked();
     435             :                 }
     436             :             }
     437           0 :             bReturn = sal_True;
     438             :         }
     439           0 :         break;
     440             : 
     441             :         case KEY_TAB:
     442             :         {
     443           0 :             KeyCode aCode = rKEvt.GetKeyCode();
     444             : 
     445           0 :             if ( !aCode.IsMod1() && !aCode.IsMod2() )
     446             :             {
     447             :                 // Moved next line which was a bugfix itself into
     448             :                 // the scope which really does the object selection travel
     449             :                 // and thus is allowed to call SelectionHasChanged().
     450             : 
     451             :                 // Switch to FuSelect.
     452             :                 mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
     453             :                     SID_OBJECT_SELECT,
     454           0 :                     SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
     455             : 
     456             :                 // changeover to the next object
     457           0 :                 if(!mpView->MarkNextObj( !aCode.IsShift() ))
     458             :                 {
     459             :                     // No next object: go over open end and
     460             :                     // get first from the other side
     461           0 :                     mpView->UnmarkAllObj();
     462           0 :                     mpView->MarkNextObj(!aCode.IsShift());
     463             :                 }
     464             : 
     465           0 :                 if(mpView->AreObjectsMarked())
     466           0 :                     mpView->MakeVisible(mpView->GetAllMarkedRect(), *mpWindow);
     467             : 
     468           0 :                 bReturn = sal_True;
     469             :             }
     470             :         }
     471           0 :         break;
     472             : 
     473             :         case KEY_END:
     474             :         {
     475           0 :             KeyCode aCode = rKEvt.GetKeyCode();
     476             : 
     477           0 :             if ( aCode.IsMod1() )
     478             :             {
     479             :                 // mark last object
     480           0 :                 mpView->UnmarkAllObj();
     481           0 :                 mpView->MarkNextObj(sal_False);
     482             : 
     483           0 :                 if(mpView->AreObjectsMarked())
     484           0 :                     mpView->MakeVisible(mpView->GetAllMarkedRect(), *mpWindow);
     485             : 
     486           0 :                 bReturn = sal_True;
     487             :             }
     488             :         }
     489           0 :         break;
     490             : 
     491             :         case KEY_HOME:
     492             :         {
     493           0 :             KeyCode aCode = rKEvt.GetKeyCode();
     494             : 
     495           0 :             if ( aCode.IsMod1() )
     496             :             {
     497             :                 // mark first object
     498           0 :                 mpView->UnmarkAllObj();
     499           0 :                 mpView->MarkNextObj(sal_True);
     500             : 
     501           0 :                 if(mpView->AreObjectsMarked())
     502           0 :                     mpView->MakeVisible(mpView->GetAllMarkedRect(), *mpWindow);
     503             : 
     504           0 :                 bReturn = sal_True;
     505             :             }
     506             :         }
     507           0 :         break;
     508             : 
     509             :         default:
     510           0 :         break;
     511             :     }
     512             : 
     513           0 :     if (!bReturn)
     514             :     {
     515           0 :         bReturn = FuPoor::KeyInput(rKEvt);
     516             :     }
     517             :     else
     518             :     {
     519           0 :         mpWindow->ReleaseMouse();
     520             :     }
     521             : 
     522           0 :     return (bReturn);
     523             : }
     524             : 
     525             : /*************************************************************************
     526             : |*
     527             : |* Aktivate function
     528             : |*
     529             : \************************************************************************/
     530             : 
     531           0 : void FuDraw::Activate()
     532             : {
     533           0 :     FuPoor::Activate();
     534           0 :     ForcePointer();
     535           0 : }
     536             : 
     537             : /*************************************************************************
     538             : |*
     539             : |* Deaktivate function
     540             : |*
     541             : \************************************************************************/
     542             : 
     543           0 : void FuDraw::Deactivate()
     544             : {
     545           0 :     FuPoor::Deactivate();
     546           0 : }
     547             : 
     548             : 
     549             : /*************************************************************************
     550             : |*
     551             : |* Toggle mouse-pointer
     552             : |*
     553             : \************************************************************************/
     554             : 
     555           0 : void FuDraw::ForcePointer(const MouseEvent* pMEvt)
     556             : {
     557           0 :     Point aPnt;
     558           0 :     sal_uInt16 nModifier = 0;
     559           0 :     sal_Bool bLeftDown = sal_False;
     560           0 :     sal_Bool bDefPointer = sal_True;
     561             : 
     562           0 :     if (pMEvt)
     563             :     {
     564           0 :         aPnt = mpWindow->PixelToLogic(pMEvt->GetPosPixel());
     565           0 :         nModifier = pMEvt->GetModifier();
     566           0 :         bLeftDown = pMEvt->IsLeft();
     567             :     }
     568             :     else
     569             :     {
     570           0 :         aPnt = mpWindow->PixelToLogic(mpWindow->GetPointerPosPixel());
     571             :     }
     572             : 
     573           0 :     if (mpView->IsDragObj())
     574             :     {
     575           0 :         if (SD_MOD()->GetWaterCan() && !mpView->PickHandle(aPnt))
     576             :         {
     577             :             /******************************************************************
     578             :             * Giesskannenmodus
     579             :             ******************************************************************/
     580           0 :             bDefPointer = sal_False;
     581           0 :             mpWindow->SetPointer(Pointer(POINTER_FILL));
     582             :         }
     583             :     }
     584             :     else
     585             :     {
     586           0 :         SdrHdl* pHdl = mpView->PickHandle(aPnt);
     587             : 
     588           0 :         if (SD_MOD()->GetWaterCan() && !pHdl)
     589             :         {
     590             :             /******************************************************************
     591             :             * Giesskannenmodus
     592             :             ******************************************************************/
     593           0 :             bDefPointer = sal_False;
     594           0 :             mpWindow->SetPointer(Pointer(POINTER_FILL));
     595             :         }
     596           0 :         else if (!pHdl &&
     597           0 :                  mpViewShell->GetViewFrame()->HasChildWindow(SvxBmpMaskChildWindow::GetChildWindowId()))
     598             :         {
     599             :             /******************************************************************
     600             :             * Pipettenmodus
     601             :             ******************************************************************/
     602           0 :             SvxBmpMask* pMask = (SvxBmpMask*) mpViewShell->GetViewFrame()->GetChildWindow(SvxBmpMaskChildWindow::GetChildWindowId())->GetWindow();
     603             : 
     604           0 :             if (pMask && pMask->IsEyedropping())
     605             :             {
     606           0 :                 bDefPointer = sal_False;
     607           0 :                 mpWindow->SetPointer(Pointer(POINTER_REFHAND));
     608             :             }
     609             :         }
     610           0 :         else if (!mpView->IsAction())
     611             :         {
     612           0 :             SdrObject* pObj = NULL;
     613           0 :             SdrPageView* pPV = NULL;
     614           0 :             SdrViewEvent aVEvt;
     615           0 :             SdrHitKind eHit = SDRHIT_NONE;
     616           0 :             SdrDragMode eDragMode = mpView->GetDragMode();
     617             : 
     618           0 :             if (pMEvt)
     619             :             {
     620           0 :                 eHit = mpView->PickAnything(*pMEvt, SDRMOUSEMOVE, aVEvt);
     621             :             }
     622             : 
     623           0 :             if ((eDragMode == SDRDRAG_ROTATE) && (eHit == SDRHIT_MARKEDOBJECT))
     624             :             {
     625             :                 // The goal of this request is show always the rotation-arrow for 3D-objects at rotation-modus
     626             :                 // Independent of the settings at Extras->Optionen->Grafik "Objekte immer verschieben"
     627             :                 // 2D-objects acquit in an other way. Otherwise, the rotation of 3d-objects around any axises
     628             :                 // wouldn't be possible per default.
     629           0 :                 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
     630           0 :                 SdrObject* pObject = rMarkList.GetMark(0)->GetMarkedSdrObj();
     631           0 :                 if ((pObject->ISA(E3dObject)) && (rMarkList.GetMarkCount() == 1))
     632             :                 {
     633           0 :                     mpWindow->SetPointer(Pointer(POINTER_ROTATE));
     634           0 :                     bDefPointer = sal_False;     // Otherwise it'll be calles Joes routine and the mousepointer will reconfigurate again
     635             :                 }
     636             :             }
     637             : 
     638           0 :             if (eHit == SDRHIT_NONE)
     639             :             {
     640             :                 // found nothing -> look after at the masterpage
     641           0 :                 mpView->PickObj(aPnt, mpView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER);
     642             :             }
     643           0 :             else if (eHit == SDRHIT_UNMARKEDOBJECT)
     644             :             {
     645           0 :                 pObj = aVEvt.pObj;
     646             :             }
     647           0 :             else if (eHit == SDRHIT_TEXTEDITOBJ && this->ISA(FuSelection))
     648             :             {
     649           0 :                 sal_uInt16 nSdrObjKind = aVEvt.pObj->GetObjIdentifier();
     650             : 
     651           0 :                 if ( nSdrObjKind != OBJ_TEXT        &&
     652             :                      nSdrObjKind != OBJ_TITLETEXT   &&
     653             :                      nSdrObjKind != OBJ_OUTLINETEXT &&
     654           0 :                      aVEvt.pObj->IsEmptyPresObj() )
     655             :                 {
     656           0 :                     pObj = NULL;
     657           0 :                     bDefPointer = sal_False;
     658           0 :                     mpWindow->SetPointer(Pointer(POINTER_ARROW));
     659             :                 }
     660             :             }
     661             : 
     662           0 :             if (pObj && pMEvt && !pMEvt->IsMod2() && this->ISA(FuSelection))
     663             :             {
     664             :                 // Auf Animation oder ImageMap pruefen
     665           0 :                 bDefPointer = !SetPointer(pObj, aPnt);
     666             : 
     667           0 :                 if (bDefPointer && (pObj->ISA(SdrObjGroup) || pObj->ISA(E3dPolyScene)))
     668             :                 {
     669             :                     // In die Gruppe hineinschauen
     670           0 :                     if (mpView->PickObj(aPnt, mpView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER | SDRSEARCH_DEEP))
     671           0 :                         bDefPointer = !SetPointer(pObj, aPnt);
     672             :                 }
     673           0 :             }
     674             :         }
     675             :     }
     676             : 
     677           0 :     if (bDefPointer)
     678             :     {
     679             :         mpWindow->SetPointer(mpView->GetPreferedPointer(
     680           0 :                             aPnt, mpWindow, nModifier, bLeftDown));
     681             :     }
     682           0 : }
     683             : 
     684             : /*************************************************************************
     685             : |*
     686             : |* Set cursor for animaton or imagemap
     687             : |*
     688             : \************************************************************************/
     689             : 
     690           0 : sal_Bool FuDraw::SetPointer(SdrObject* pObj, const Point& rPos)
     691             : {
     692           0 :     sal_Bool bSet = sal_False;
     693             : 
     694           0 :     sal_Bool bAnimationInfo = (!mpDocSh->ISA(GraphicDocShell) &&
     695           0 :                           mpDoc->GetAnimationInfo(pObj)) ? sal_True:sal_False;
     696             : 
     697           0 :     sal_Bool bImageMapInfo = sal_False;
     698             : 
     699           0 :     if (!bAnimationInfo)
     700           0 :         bImageMapInfo = mpDoc->GetIMapInfo(pObj) ? sal_True:sal_False;
     701             : 
     702           0 :     if (bAnimationInfo || bImageMapInfo)
     703             :     {
     704           0 :         const SetOfByte* pVisiLayer = &mpView->GetSdrPageView()->GetVisibleLayers();
     705           0 :         sal_uInt16 nHitLog(sal_uInt16 (mpWindow->PixelToLogic(Size(HITPIX,0)).Width()));
     706           0 :         long  n2HitLog(nHitLog * 2);
     707           0 :         Point aHitPosR(rPos);
     708           0 :         Point aHitPosL(rPos);
     709           0 :         Point aHitPosT(rPos);
     710           0 :         Point aHitPosB(rPos);
     711             : 
     712           0 :         aHitPosR.X() += n2HitLog;
     713           0 :         aHitPosL.X() -= n2HitLog;
     714           0 :         aHitPosT.Y() += n2HitLog;
     715           0 :         aHitPosB.Y() -= n2HitLog;
     716             : 
     717           0 :         if ( !pObj->IsClosedObj() ||
     718           0 :             ( SdrObjectPrimitiveHit(*pObj, aHitPosR, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) &&
     719           0 :               SdrObjectPrimitiveHit(*pObj, aHitPosL, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) &&
     720           0 :               SdrObjectPrimitiveHit(*pObj, aHitPosT, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false) &&
     721           0 :               SdrObjectPrimitiveHit(*pObj, aHitPosB, nHitLog, *mpView->GetSdrPageView(), pVisiLayer, false)))
     722             :         {
     723             :             /**********************************************************
     724             :             * hit inside the object (without margin) or open object
     725             :             ********************************************************/
     726             : 
     727           0 :             if (bAnimationInfo)
     728             :             {
     729             :                 /******************************************************
     730             :                 * Click-Action
     731             :                 ******************************************************/
     732           0 :                 SdAnimationInfo* pInfo = mpDoc->GetAnimationInfo(pObj);
     733             : 
     734           0 :                 if ((mpView->ISA(DrawView) &&
     735             :                       (pInfo->meClickAction == presentation::ClickAction_BOOKMARK  ||
     736             :                        pInfo->meClickAction == presentation::ClickAction_DOCUMENT  ||
     737             :                        pInfo->meClickAction == presentation::ClickAction_PREVPAGE  ||
     738             :                        pInfo->meClickAction == presentation::ClickAction_NEXTPAGE  ||
     739             :                        pInfo->meClickAction == presentation::ClickAction_FIRSTPAGE ||
     740             :                        pInfo->meClickAction == presentation::ClickAction_LASTPAGE  ||
     741             :                        pInfo->meClickAction == presentation::ClickAction_VERB      ||
     742             :                        pInfo->meClickAction == presentation::ClickAction_PROGRAM   ||
     743             :                        pInfo->meClickAction == presentation::ClickAction_MACRO     ||
     744             :                        pInfo->meClickAction == presentation::ClickAction_SOUND))
     745             :                                                                     ||
     746           0 :                     (mpView->ISA(DrawView) &&
     747           0 :                         SlideShow::IsRunning( mpViewShell->GetViewShellBase() )   &&
     748             :                          (pInfo->meClickAction == presentation::ClickAction_VANISH            ||
     749             :                           pInfo->meClickAction == presentation::ClickAction_INVISIBLE         ||
     750             :                           pInfo->meClickAction == presentation::ClickAction_STOPPRESENTATION ||
     751             :                          (pInfo->mbActive &&
     752             :                           ( pInfo->meEffect != presentation::AnimationEffect_NONE ||
     753             :                             pInfo->meTextEffect != presentation::AnimationEffect_NONE )))))
     754             :                     {
     755             :                         // Animations-Objekt
     756           0 :                         bSet = sal_True;
     757           0 :                         mpWindow->SetPointer(Pointer(POINTER_REFHAND));
     758             :                     }
     759             :             }
     760           0 :             else if (bImageMapInfo &&
     761           0 :                      mpDoc->GetHitIMapObject(pObj, rPos, *mpWindow))
     762             :             {
     763             :                 /******************************************************
     764             :                 * ImageMap
     765             :                 ******************************************************/
     766           0 :                 bSet = sal_True;
     767           0 :                 mpWindow->SetPointer(Pointer(POINTER_REFHAND));
     768             :             }
     769             :         }
     770             :     }
     771             : 
     772           0 :     return bSet;
     773             : }
     774             : 
     775             : 
     776             : 
     777             : /*************************************************************************
     778             : |*
     779             : |* Response of doubleclick
     780             : |*
     781             : \************************************************************************/
     782             : 
     783           0 : void FuDraw::DoubleClick(const MouseEvent& rMEvt)
     784             : {
     785           0 :     sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
     786             : 
     787           0 :     if ( mpView->AreObjectsMarked() )
     788             :     {
     789           0 :         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
     790             : 
     791           0 :         if (rMarkList.GetMarkCount() == 1)
     792             :         {
     793           0 :             SdrMark* pMark = rMarkList.GetMark(0);
     794           0 :             SdrObject* pObj = pMark->GetMarkedSdrObj();
     795             : 
     796           0 :             sal_uInt32 nInv = pObj->GetObjInventor();
     797           0 :             sal_uInt16 nSdrObjKind = pObj->GetObjIdentifier();
     798             : 
     799           0 :             if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2)
     800             :             {
     801           0 :                 DrawDocShell* pDocSh = mpDoc->GetDocSh();
     802             : 
     803           0 :                 if ( !pDocSh->IsUIActive() )
     804             :                 {
     805             :                     /**********************************************************
     806             :                     * activate OLE-object
     807             :                     **********************************************************/
     808           0 :                     mpViewShell->ActivateObject( (SdrOle2Obj*) pObj, 0);
     809           0 :                 }
     810             :             }
     811           0 :             else if (nInv == SdrInventor &&  nSdrObjKind == OBJ_GRAF && pObj->IsEmptyPresObj() )
     812             :             {
     813             :                 mpViewShell->GetViewFrame()->
     814             :                     GetDispatcher()->Execute( SID_INSERT_GRAPHIC,
     815           0 :                                               SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
     816             :             }
     817           0 :             else if ( ( pObj->ISA(SdrTextObj) || pObj->ISA(SdrObjGroup) ) &&
     818           0 :                       !SD_MOD()->GetWaterCan()                            &&
     819           0 :                       mpViewShell->GetFrameView()->IsDoubleClickTextEdit() &&
     820           0 :                       !mpDocSh->IsReadOnly())
     821             :             {
     822           0 :                 SfxUInt16Item aItem(SID_TEXTEDIT, 2);
     823             :                 mpViewShell->GetViewFrame()->GetDispatcher()->
     824             :                                  Execute(SID_TEXTEDIT, SFX_CALLMODE_ASYNCHRON |
     825           0 :                                          SFX_CALLMODE_RECORD, &aItem, 0L);
     826             :             }
     827           0 :             else if (nInv == SdrInventor &&  nSdrObjKind == OBJ_GRUP)
     828             :             {
     829             :                 // hit group -> select subobject
     830           0 :                 mpView->UnMarkAll();
     831           0 :                 mpView->MarkObj(aMDPos, nHitLog, rMEvt.IsShift(), sal_True);
     832             :             }
     833             :         }
     834             :     }
     835             :     else
     836           0 :         mpViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
     837           0 : }
     838             : 
     839             : /*************************************************************************
     840             : |*
     841             : |* Help-event
     842             : |*
     843             : \************************************************************************/
     844             : 
     845           0 : sal_Bool FuDraw::RequestHelp(const HelpEvent& rHEvt)
     846             : {
     847           0 :     sal_Bool bReturn = sal_False;
     848             : 
     849           0 :     if (Help::IsBalloonHelpEnabled() || Help::IsQuickHelpEnabled())
     850             :     {
     851           0 :         SdrViewEvent aVEvt;
     852             : 
     853           0 :         MouseEvent aMEvt(mpWindow->GetPointerPosPixel(), 1, 0, MOUSE_LEFT);
     854             : 
     855           0 :         SdrHitKind eHit = mpView->PickAnything(aMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
     856             : 
     857           0 :         SdrObject* pObj = aVEvt.pObj;
     858             : 
     859           0 :         if (eHit != SDRHIT_NONE && pObj != NULL)
     860             :         {
     861           0 :             Point aPosPixel = rHEvt.GetMousePosPixel();
     862             : 
     863           0 :             bReturn = SetHelpText(pObj, aPosPixel, aVEvt);
     864             : 
     865           0 :             if (!bReturn && (pObj->ISA(SdrObjGroup) || pObj->ISA(E3dPolyScene)))
     866             :             {
     867             :                 // In die Gruppe hineinschauen
     868           0 :                 SdrPageView* pPV = NULL;
     869             : 
     870           0 :                 Point aPos(mpWindow->PixelToLogic(mpWindow->ScreenToOutputPixel(aPosPixel)));
     871             : 
     872           0 :                 if (mpView->PickObj(aPos, mpView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER | SDRSEARCH_DEEP))
     873           0 :                     bReturn = SetHelpText(pObj, aPosPixel, aVEvt);
     874             :             }
     875           0 :         }
     876             :     }
     877             : 
     878           0 :     if (!bReturn)
     879             :     {
     880           0 :         bReturn = FuPoor::RequestHelp(rHEvt);
     881             :     }
     882             : 
     883           0 :     return(bReturn);
     884             : }
     885             : 
     886             : 
     887             : 
     888             : /*************************************************************************
     889             : |*
     890             : |* Command-event
     891             : |*
     892             : \************************************************************************/
     893             : 
     894           0 : sal_Bool FuDraw::SetHelpText(SdrObject* pObj, const Point& rPosPixel, const SdrViewEvent& rVEvt)
     895             : {
     896           0 :     sal_Bool bSet = sal_False;
     897           0 :     String aHelpText;
     898           0 :     Point aPos(mpWindow->PixelToLogic(mpWindow->ScreenToOutputPixel(rPosPixel)));
     899             : 
     900             :     // URL fuer IMapObject unter Pointer ist Hilfetext
     901           0 :     if ( mpDoc->GetIMapInfo(pObj) )
     902             :     {
     903           0 :         IMapObject* pIMapObj = mpDoc->GetHitIMapObject(pObj, aPos, *mpWindow );
     904             : 
     905           0 :         if ( pIMapObj )
     906             :         {
     907             :             // show name
     908           0 :             aHelpText = pIMapObj->GetAltText();
     909             : 
     910           0 :             if (aHelpText.Len() == 0)
     911             :             {
     912             :                 // show url if no name is available
     913           0 :                 aHelpText = INetURLObject::decode( pIMapObj->GetURL(), '%', INetURLObject::DECODE_WITH_CHARSET );
     914             :             }
     915             :         }
     916             :     }
     917           0 :     else if (!mpDocSh->ISA(GraphicDocShell) && mpDoc->GetAnimationInfo(pObj))
     918             :     {
     919           0 :         SdAnimationInfo* pInfo = mpDoc->GetAnimationInfo(pObj);
     920             : 
     921           0 :         switch (pInfo->meClickAction)
     922             :         {
     923             :             case presentation::ClickAction_PREVPAGE:
     924             :             {
     925             :                 // jump to the prior page
     926           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_PREVPAGE));
     927             :             }
     928           0 :             break;
     929             : 
     930             :             case presentation::ClickAction_NEXTPAGE:
     931             :             {
     932             :                 // jump to the next page
     933           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_NEXTPAGE));
     934             :             }
     935           0 :             break;
     936             : 
     937             :             case presentation::ClickAction_FIRSTPAGE:
     938             :             {
     939             :                 // jump to the first page
     940           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_FIRSTPAGE));
     941             :             }
     942           0 :             break;
     943             : 
     944             :             case presentation::ClickAction_LASTPAGE:
     945             :             {
     946             :                 // jump to the last page
     947           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_LASTPAGE));
     948             :             }
     949           0 :             break;
     950             : 
     951             :             case presentation::ClickAction_BOOKMARK:
     952             :             {
     953             :                 // jump to object/page
     954           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_BOOKMARK));
     955           0 :                 aHelpText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ": " ) );
     956           0 :                 aHelpText.Append( String(INetURLObject::decode( pInfo->GetBookmark(), '%', INetURLObject::DECODE_WITH_CHARSET ) ));
     957             :             }
     958           0 :             break;
     959             : 
     960             :             case presentation::ClickAction_DOCUMENT:
     961             :             {
     962             :                 // jump to document (object/page)
     963           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_DOCUMENT));
     964           0 :                 aHelpText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ": " ) );
     965           0 :                 aHelpText.Append( String(INetURLObject::decode( pInfo->GetBookmark(), '%', INetURLObject::DECODE_WITH_CHARSET ) ));
     966             :             }
     967           0 :             break;
     968             : 
     969             :             case presentation::ClickAction_PROGRAM:
     970             :             {
     971             :                 // execute program
     972           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_PROGRAM));
     973           0 :                 aHelpText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ": " ) );
     974           0 :                 aHelpText.Append( String(INetURLObject::decode( pInfo->GetBookmark(), '%', INetURLObject::DECODE_WITH_CHARSET ) ));
     975             :             }
     976           0 :             break;
     977             : 
     978             :             case presentation::ClickAction_MACRO:
     979             :             {
     980             :                 // execute program
     981           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_MACRO));
     982           0 :                 aHelpText.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ": " ) );
     983             : 
     984           0 :                 if ( SfxApplication::IsXScriptURL( pInfo->GetBookmark() ) )
     985             :                 {
     986           0 :                     aHelpText.Append( pInfo->GetBookmark() );
     987             :                 }
     988             :                 else
     989             :                 {
     990           0 :                     String sBookmark( pInfo->GetBookmark() );
     991           0 :                     sal_Unicode cToken = '.';
     992           0 :                     aHelpText.Append( sBookmark.GetToken( 2, cToken ) );
     993           0 :                     aHelpText.Append( cToken );
     994           0 :                     aHelpText.Append( sBookmark.GetToken( 1, cToken ) );
     995           0 :                     aHelpText.Append( cToken );
     996           0 :                     aHelpText.Append( sBookmark.GetToken( 0, cToken ) );
     997             :                 }
     998             :             }
     999           0 :             break;
    1000             : 
    1001             :             case presentation::ClickAction_SOUND:
    1002             :             {
    1003             :                 // play-back sound
    1004           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_SOUND));
    1005             :             }
    1006           0 :             break;
    1007             : 
    1008             :             case presentation::ClickAction_VERB:
    1009             :             {
    1010             :                 // execute OLE-verb
    1011           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_VERB));
    1012             :             }
    1013           0 :             break;
    1014             : 
    1015             :             case presentation::ClickAction_STOPPRESENTATION:
    1016             :             {
    1017             :                 // quit presentation
    1018           0 :                 aHelpText = String(SdResId(STR_CLICK_ACTION_STOPPRESENTATION));
    1019             :             }
    1020           0 :             break;
    1021             :             default:
    1022           0 :                 break;
    1023             :         }
    1024             :     }
    1025           0 :     else if (rVEvt.pURLField)
    1026             :     {
    1027             :         /**************************************************************
    1028             :         * URL-Field
    1029             :         **************************************************************/
    1030           0 :         aHelpText = INetURLObject::decode( rVEvt.pURLField->GetURL(), '%', INetURLObject::DECODE_WITH_CHARSET );
    1031             :     }
    1032             : 
    1033           0 :     if (aHelpText.Len())
    1034             :     {
    1035           0 :         bSet = sal_True;
    1036           0 :         Rectangle aLogicPix = mpWindow->LogicToPixel(pObj->GetLogicRect());
    1037           0 :         Rectangle aScreenRect(mpWindow->OutputToScreenPixel(aLogicPix.TopLeft()),
    1038           0 :                               mpWindow->OutputToScreenPixel(aLogicPix.BottomRight()));
    1039             : 
    1040           0 :         if (Help::IsBalloonHelpEnabled())
    1041           0 :             Help::ShowBalloon( (Window*)mpWindow, rPosPixel, aScreenRect, aHelpText);
    1042           0 :         else if (Help::IsQuickHelpEnabled())
    1043           0 :             Help::ShowQuickHelp( (Window*)mpWindow, aScreenRect, aHelpText);
    1044             :     }
    1045             : 
    1046           0 :     return bSet;
    1047             : }
    1048             : 
    1049             : 
    1050             : /** is called when the currenct function should be aborted. <p>
    1051             :     This is used when a function gets a KEY_ESCAPE but can also
    1052             :     be called directly.
    1053             : 
    1054             :     @returns true if a active function was aborted
    1055             : */
    1056           0 : bool FuDraw::cancel()
    1057             : {
    1058           0 :     bool bReturn = false;
    1059             : 
    1060           0 :     if ( mpView->IsAction() )
    1061             :     {
    1062           0 :         mpView->BrkAction();
    1063           0 :         bReturn = true;
    1064             :     }
    1065           0 :     else if ( mpView->IsTextEdit() )
    1066             :     {
    1067           0 :         mpView->SdrEndTextEdit();
    1068           0 :         bReturn = true;
    1069             : 
    1070           0 :         SfxBindings& rBindings = mpViewShell->GetViewFrame()->GetBindings();
    1071           0 :         rBindings.Invalidate( SID_PARASPACE_INCREASE );
    1072           0 :         rBindings.Invalidate( SID_PARASPACE_DECREASE );
    1073             :     }
    1074           0 :     else if ( mpView->AreObjectsMarked() )
    1075             :     {
    1076           0 :         const SdrHdlList& rHdlList = mpView->GetHdlList();
    1077           0 :         SdrHdl* pHdl = rHdlList.GetFocusHdl();
    1078             : 
    1079           0 :         if(pHdl)
    1080             :         {
    1081           0 :             ((SdrHdlList&)rHdlList).ResetFocusHdl();
    1082             :         }
    1083             :         else
    1084             :         {
    1085           0 :             mpView->UnmarkAll();
    1086             :         }
    1087             : 
    1088             :         // Switch to FuSelect.
    1089             :         mpViewShell->GetViewFrame()->GetDispatcher()->Execute(
    1090             :             SID_OBJECT_SELECT,
    1091           0 :             SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
    1092             : 
    1093           0 :         bReturn = true;
    1094             :     }
    1095             : 
    1096           0 :     return bReturn;
    1097             : }
    1098             : 
    1099           9 : } // end of namespace sd
    1100             : 
    1101             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10