LCOV - code coverage report
Current view: top level - sc/source/ui/drawfunc - fudraw.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 6 331 1.8 %
Date: 2015-06-13 12:38:46 Functions: 4 19 21.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             : #include <editeng/editeng.hxx>
      21             : #include <editeng/outlobj.hxx>
      22             : #include <svx/svdobj.hxx>
      23             : #include <svx/svdoole2.hxx>
      24             : #include <svx/svdouno.hxx>
      25             : #include <svx/svdocapt.hxx>
      26             : #include <svx/svdpage.hxx>
      27             : #include <svx/svditer.hxx>
      28             : #include <svx/svdundo.hxx>
      29             : #include <sfx2/dispatch.hxx>
      30             : #include <sfx2/viewfrm.hxx>
      31             : 
      32             : #include "sc.hrc"
      33             : #include "fudraw.hxx"
      34             : #include "futext.hxx"
      35             : #include "tabvwsh.hxx"
      36             : #include "drwlayer.hxx"
      37             : #include "scresid.hxx"
      38             : #include "userdat.hxx"
      39             : #include "docsh.hxx"
      40             : #include "postit.hxx"
      41             : #include "globstr.hrc"
      42             : #include "drawview.hxx"
      43             : 
      44             : /*************************************************************************
      45             : |*
      46             : |* base class for draw module specific functions
      47             : |*
      48             : \************************************************************************/
      49             : 
      50         348 : FuDraw::FuDraw(ScTabViewShell* pViewSh, vcl::Window* pWin, ScDrawView* pViewP,
      51             :                SdrModel* pDoc, SfxRequest& rReq) :
      52             :     FuPoor      (pViewSh, pWin, pViewP, pDoc, rReq),
      53             :     aNewPointer ( PointerStyle::Arrow ),
      54         348 :     aOldPointer ( PointerStyle::Arrow )
      55             : {
      56         348 : }
      57             : 
      58             : /*************************************************************************
      59             : |*
      60             : |* destructor
      61             : |*
      62             : \************************************************************************/
      63             : 
      64         345 : FuDraw::~FuDraw()
      65             : {
      66         345 : }
      67             : 
      68             : /*************************************************************************
      69             : |*
      70             : |* evaluate modifier keys
      71             : |*
      72             : \************************************************************************/
      73             : 
      74           0 : void FuDraw::DoModifiers(const MouseEvent& rMEvt)
      75             : {
      76             :     //  Shift   = Ortho and AngleSnap
      77             :     //  Control = Snap (Toggle)
      78             :     //  Alt     = centric
      79             : 
      80           0 :     bool bShift = rMEvt.IsShift();
      81           0 :     bool bAlt   = rMEvt.IsMod2();
      82             : 
      83           0 :     bool bOrtho     = bShift;
      84           0 :     bool bAngleSnap = bShift;
      85           0 :     bool bCenter    = bAlt;
      86             : 
      87             :     // #i33136#
      88           0 :     if(doConstructOrthogonal())
      89             :     {
      90           0 :         bOrtho = !bShift;
      91             :     }
      92             : 
      93           0 :     if (pView->IsOrtho() != bOrtho)
      94           0 :         pView->SetOrtho(bOrtho);
      95           0 :     if (pView->IsAngleSnapEnabled() != bAngleSnap)
      96           0 :         pView->SetAngleSnapEnabled(bAngleSnap);
      97             : 
      98           0 :     if (pView->IsCreate1stPointAsCenter() != bCenter)
      99           0 :         pView->SetCreate1stPointAsCenter(bCenter);
     100           0 :     if (pView->IsResizeAtCenter() != bCenter)
     101           0 :         pView->SetResizeAtCenter(bCenter);
     102             : 
     103           0 : }
     104             : 
     105           0 : void FuDraw::ResetModifiers()
     106             : {
     107           0 :     if (!pView)
     108           0 :         return;
     109             : 
     110           0 :     ScViewData& rViewData = pViewShell->GetViewData();
     111           0 :     const ScViewOptions& rOpt = rViewData.GetOptions();
     112           0 :     const ScGridOptions& rGrid = rOpt.GetGridOptions();
     113           0 :     bool bGridOpt = rGrid.GetUseGridSnap();
     114             : 
     115           0 :     if (pView->IsOrtho())
     116           0 :         pView->SetOrtho(false);
     117           0 :     if (pView->IsAngleSnapEnabled())
     118           0 :         pView->SetAngleSnapEnabled(false);
     119             : 
     120           0 :     if (pView->IsGridSnap() != bGridOpt)
     121           0 :         pView->SetGridSnap(bGridOpt);
     122           0 :     if (pView->IsSnapEnabled() != bGridOpt)
     123           0 :         pView->SetSnapEnabled(bGridOpt);
     124             : 
     125           0 :     if (pView->IsCreate1stPointAsCenter())
     126           0 :         pView->SetCreate1stPointAsCenter(false);
     127           0 :     if (pView->IsResizeAtCenter())
     128           0 :         pView->SetResizeAtCenter(false);
     129             : }
     130             : 
     131             : /*************************************************************************
     132             : |*
     133             : |* MouseButtonDown-event
     134             : |*
     135             : \************************************************************************/
     136             : 
     137           0 : bool FuDraw::MouseButtonDown(const MouseEvent& rMEvt)
     138             : {
     139             :     // remember button state for creation of own MouseEvents
     140           0 :     SetMouseButtonCode(rMEvt.GetButtons());
     141             : 
     142           0 :     DoModifiers( rMEvt );
     143           0 :     return false;
     144             : }
     145             : 
     146             : /*************************************************************************
     147             : |*
     148             : |* MouseMove-event
     149             : |*
     150             : \************************************************************************/
     151             : 
     152           0 : bool FuDraw::MouseMove(const MouseEvent& rMEvt)
     153             : {
     154             :     //  evaluate modifiers only if in a drawing layer action
     155             :     //  (don't interfere with keyboard shortcut handling)
     156           0 :     if (pView->IsAction())
     157           0 :         DoModifiers( rMEvt );
     158             : 
     159           0 :     return false;
     160             : }
     161             : 
     162             : /*************************************************************************
     163             : |*
     164             : |* MouseButtonUp-event
     165             : |*
     166             : \************************************************************************/
     167             : 
     168           0 : bool FuDraw::MouseButtonUp(const MouseEvent& rMEvt)
     169             : {
     170             :     // remember button state for creation of own MouseEvents
     171           0 :     SetMouseButtonCode(rMEvt.GetButtons());
     172             : 
     173           0 :     ResetModifiers();
     174           0 :     return false;
     175             : }
     176             : 
     177             : /*************************************************************************
     178             : |*
     179             : |* process keyboard events
     180             : |*
     181             : |* if a keyevent is processed -> returns sal_True
     182             : |*                            -> else  FALSE
     183             : |*
     184             : \************************************************************************/
     185             : 
     186           0 : static bool lcl_KeyEditMode( SdrObject* pObj, ScTabViewShell* pViewShell, const KeyEvent* pInitialKey )
     187             : {
     188           0 :     bool bReturn = false;
     189           0 :     if ( pObj && pObj->ISA(SdrTextObj) && !pObj->ISA(SdrUnoObj) )
     190             :     {
     191             :         // start text edit - like FuSelection::MouseButtonUp,
     192             :         // but with bCursorToEnd instead of mouse position
     193             : 
     194           0 :         OutlinerParaObject* pOPO = pObj->GetOutlinerParaObject();
     195           0 :         bool bVertical = ( pOPO && pOPO->IsVertical() );
     196           0 :         sal_uInt16 nTextSlotId = bVertical ? SID_DRAW_TEXT_VERTICAL : SID_DRAW_TEXT;
     197             : 
     198             :         // don't switch shells if text shell is already active
     199           0 :         FuPoor* pPoor = pViewShell->GetViewData().GetView()->GetDrawFuncPtr();
     200           0 :         if ( !pPoor || pPoor->GetSlotID() != nTextSlotId )
     201             :         {
     202           0 :             pViewShell->GetViewData().GetDispatcher().
     203           0 :                 Execute(nTextSlotId, SfxCallMode::SYNCHRON | SfxCallMode::RECORD);
     204             :         }
     205             : 
     206             :         // get the resulting FuText and set in edit mode
     207           0 :         pPoor = pViewShell->GetViewData().GetView()->GetDrawFuncPtr();
     208           0 :         if ( pPoor && pPoor->GetSlotID() == nTextSlotId )    // no RTTI
     209             :         {
     210           0 :             FuText* pText = static_cast<FuText*>(pPoor);
     211           0 :             pText->SetInEditMode( pObj, NULL, true, pInitialKey );
     212             :             //! set cursor to end of text
     213             :         }
     214           0 :         bReturn = true;
     215             :     }
     216           0 :     return bReturn;
     217             : }
     218             : 
     219           0 : bool FuDraw::KeyInput(const KeyEvent& rKEvt)
     220             : {
     221           0 :     bool bReturn = false;
     222           0 :     ScViewData& rViewData = pViewShell->GetViewData();
     223             : 
     224           0 :     switch ( rKEvt.GetKeyCode().GetCode() )
     225             :     {
     226             :         case KEY_ESCAPE:
     227           0 :             if ( pViewShell->IsDrawTextShell() || aSfxRequest.GetSlot() == SID_DRAW_NOTEEDIT )
     228             :             {
     229             :                 // if object selected -> normal draw-shell, else turn off drawing
     230           0 :                 rViewData.GetDispatcher().Execute(aSfxRequest.GetSlot(), SfxCallMode::SLOT | SfxCallMode::RECORD);
     231           0 :                 bReturn = true;
     232             :             }
     233           0 :             else if ( pViewShell->IsDrawSelMode() )
     234             :             {
     235           0 :                 pView->UnmarkAll();
     236           0 :                 rViewData.GetDispatcher().Execute(SID_OBJECT_SELECT, SfxCallMode::SLOT | SfxCallMode::RECORD);
     237           0 :                 bReturn = true;
     238             :             }
     239           0 :             else if ( pView->AreObjectsMarked() )
     240             :             {
     241             :                 // III
     242           0 :                 SdrHdlList& rHdlList = const_cast< SdrHdlList& >( pView->GetHdlList() );
     243           0 :                 if( rHdlList.GetFocusHdl() )
     244           0 :                     rHdlList.ResetFocusHdl();
     245             :                 else
     246           0 :                     pView->UnmarkAll();
     247             : 
     248             :                 //  while bezier editing, object is selected
     249           0 :                 if (!pView->AreObjectsMarked())
     250           0 :                     pViewShell->SetDrawShell( false );
     251             : 
     252           0 :                 bReturn = true;
     253             :             }
     254           0 :             break;
     255             : 
     256             :         case KEY_DELETE:                    //! via accelerator
     257           0 :             pView->DeleteMarked();
     258           0 :             bReturn = true;
     259           0 :         break;
     260             : 
     261             :         case KEY_RETURN:
     262             :         {
     263           0 :             if( rKEvt.GetKeyCode().GetModifier() == 0 )
     264             :             {
     265             :                 // activate OLE object on RETURN for selected object
     266             :                 // put selected text object in edit mode
     267           0 :                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
     268           0 :                 if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
     269             :                 {
     270           0 :                     bool bOle = pViewShell->GetViewFrame()->GetFrame().IsInPlace();
     271           0 :                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
     272           0 :                     if( pObj && pObj->ISA( SdrOle2Obj ) && !bOle )
     273             :                     {
     274           0 :                         pViewShell->ActivateObject( static_cast< SdrOle2Obj* >( pObj ), 0 );
     275             : 
     276             :                         // consumed
     277           0 :                         bReturn = true;
     278             :                     }
     279           0 :                     else if ( lcl_KeyEditMode( pObj, pViewShell, NULL ) )       // start text edit for suitable object
     280           0 :                         bReturn = true;
     281             :                 }
     282             :             }
     283             :         }
     284           0 :         break;
     285             : 
     286             :         case KEY_F2:
     287             :         {
     288           0 :             if( rKEvt.GetKeyCode().GetModifier() == 0 )
     289             :             {
     290             :                 // put selected text object in edit mode
     291             :                 // (this is not SID_SETINPUTMODE, but F2 hardcoded, like in Writer)
     292           0 :                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
     293           0 :                 if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() )
     294             :                 {
     295           0 :                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
     296           0 :                     if ( lcl_KeyEditMode( pObj, pViewShell, NULL ) )            // start text edit for suitable object
     297           0 :                         bReturn = true;
     298             :                 }
     299             :             }
     300             :         }
     301           0 :         break;
     302             : 
     303             :         // #97016#
     304             :         case KEY_TAB:
     305             :         {
     306             :             // in calc do NOT start draw object selection using TAB/SHIFT-TAB when
     307             :             // there is not yet a object selected
     308           0 :             if(pView->AreObjectsMarked())
     309             :             {
     310           0 :                 vcl::KeyCode aCode = rKEvt.GetKeyCode();
     311             : 
     312           0 :                 if ( !aCode.IsMod1() && !aCode.IsMod2() )
     313             :                 {
     314             :                     // changeover to the next object
     315           0 :                     if(!pView->MarkNextObj( !aCode.IsShift() ))
     316             :                     {
     317             :                         //If there is only one object, don't do the UnmarkAlllObj() & MarkNextObj().
     318           0 :                         if ( pView->GetMarkableObjCount() > 1 && pView->HasMarkableObj() )
     319             :                         {
     320             :                             // No next object: go over open end and
     321             :                             // get first from the other side
     322           0 :                             pView->UnmarkAllObj();
     323           0 :                             pView->MarkNextObj(!aCode.IsShift());
     324             :                         }
     325             :                     }
     326             : 
     327             :                     // II
     328           0 :                     if(pView->AreObjectsMarked())
     329           0 :                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
     330             : 
     331           0 :                     bReturn = true;
     332             :                 }
     333             : 
     334             :                 // handle Mod1 and Mod2 to get travelling running on different systems
     335           0 :                 if(rKEvt.GetKeyCode().IsMod1() || rKEvt.GetKeyCode().IsMod2())
     336             :                 {
     337             :                     // II do something with a selected handle?
     338           0 :                     const SdrHdlList& rHdlList = pView->GetHdlList();
     339           0 :                     bool bForward(!rKEvt.GetKeyCode().IsShift());
     340             : 
     341           0 :                     ((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);
     342             : 
     343             :                     // guarantee visibility of focused handle
     344           0 :                     SdrHdl* pHdl = rHdlList.GetFocusHdl();
     345             : 
     346           0 :                     if(pHdl)
     347             :                     {
     348           0 :                         Point aHdlPosition(pHdl->GetPos());
     349           0 :                         Rectangle aVisRect(aHdlPosition - Point(100, 100), Size(200, 200));
     350           0 :                         pView->MakeVisible(aVisRect, *pWindow);
     351             :                     }
     352             : 
     353             :                     // consumed
     354           0 :                     bReturn = true;
     355             :                 }
     356             :             }
     357             :         }
     358           0 :         break;
     359             : 
     360             :         // #97016#
     361             :         case KEY_END:
     362             :         {
     363             :             // in calc do NOT select the last draw object when
     364             :             // there is not yet a object selected
     365           0 :             if(pView->AreObjectsMarked())
     366             :             {
     367           0 :                 vcl::KeyCode aCode = rKEvt.GetKeyCode();
     368             : 
     369           0 :                 if ( aCode.IsMod1() )
     370             :                 {
     371             :                     // mark last object
     372           0 :                     pView->UnmarkAllObj();
     373           0 :                     pView->MarkNextObj(false);
     374             : 
     375             :                     // II
     376           0 :                     if(pView->AreObjectsMarked())
     377           0 :                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
     378             : 
     379           0 :                     bReturn = true;
     380             :                 }
     381             :             }
     382             :         }
     383           0 :         break;
     384             : 
     385             :         // #97016#
     386             :         case KEY_HOME:
     387             :         {
     388             :             // in calc do NOT select the first draw object when
     389             :             // there is not yet a object selected
     390           0 :             if(pView->AreObjectsMarked())
     391             :             {
     392           0 :                 vcl::KeyCode aCode = rKEvt.GetKeyCode();
     393             : 
     394           0 :                 if ( aCode.IsMod1() )
     395             :                 {
     396             :                     // mark first object
     397           0 :                     pView->UnmarkAllObj();
     398           0 :                     pView->MarkNextObj(true);
     399             : 
     400             :                     // II
     401           0 :                     if(pView->AreObjectsMarked())
     402           0 :                         pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
     403             : 
     404           0 :                     bReturn = true;
     405             :                 }
     406             :             }
     407             :         }
     408           0 :         break;
     409             : 
     410             :         // #97016#
     411             :         case KEY_UP:
     412             :         case KEY_DOWN:
     413             :         case KEY_LEFT:
     414             :         case KEY_RIGHT:
     415             :         {
     416             :             // in calc do cursor travelling of draw objects only when
     417             :             // there is a object selected yet
     418           0 :             if(pView->AreObjectsMarked())
     419             :             {
     420             : 
     421           0 :                 const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
     422           0 :                 if(rMarkList.GetMarkCount() == 1)
     423             :                 {
     424             :                     // disable cursor travelling on note objects as the tail connector position
     425             :                     // must not move.
     426           0 :                     SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
     427           0 :                     if( ScDrawLayer::IsNoteCaption( pObj ) )
     428           0 :                         break;
     429             :                 }
     430             : 
     431           0 :                 long nX = 0;
     432           0 :                 long nY = 0;
     433           0 :                 sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
     434             : 
     435           0 :                 if (nCode == KEY_UP)
     436             :                 {
     437             :                     // scroll up
     438           0 :                     nX = 0;
     439           0 :                     nY =-1;
     440             :                 }
     441           0 :                 else if (nCode == KEY_DOWN)
     442             :                 {
     443             :                     // scroll down
     444           0 :                     nX = 0;
     445           0 :                     nY = 1;
     446             :                 }
     447           0 :                 else if (nCode == KEY_LEFT)
     448             :                 {
     449             :                     // scroll left
     450           0 :                     nX =-1;
     451           0 :                     nY = 0;
     452             :                 }
     453           0 :                 else if (nCode == KEY_RIGHT)
     454             :                 {
     455             :                     // scroll right
     456           0 :                     nX = 1;
     457           0 :                     nY = 0;
     458             :                 }
     459             : 
     460           0 :                 bool bReadOnly = rViewData.GetDocShell()->IsReadOnly();
     461             : 
     462           0 :                 if(!rKEvt.GetKeyCode().IsMod1() && !bReadOnly)
     463             :                 {
     464           0 :                     if(rKEvt.GetKeyCode().IsMod2())
     465             :                     {
     466             :                         // move in 1 pixel distance
     467           0 :                         Size aLogicSizeOnePixel = (pWindow) ? pWindow->PixelToLogic(Size(1,1)) : Size(100, 100);
     468           0 :                         nX *= aLogicSizeOnePixel.Width();
     469           0 :                         nY *= aLogicSizeOnePixel.Height();
     470             :                     }
     471           0 :                     else if(rKEvt.GetKeyCode().IsShift()) // #i121236# Support for shift key in calc
     472             :                     {
     473           0 :                         nX *= 1000;
     474           0 :                         nY *= 1000;
     475             :                     }
     476             :                     else
     477             :                     {
     478             :                         // old, fixed move distance
     479           0 :                         nX *= 100;
     480           0 :                         nY *= 100;
     481             :                     }
     482             : 
     483             :                     // is there a movement to do?
     484           0 :                     if(0 != nX || 0 != nY)
     485             :                     {
     486             :                         // II
     487           0 :                         const SdrHdlList& rHdlList = pView->GetHdlList();
     488           0 :                         SdrHdl* pHdl = rHdlList.GetFocusHdl();
     489             : 
     490           0 :                         if(0L == pHdl)
     491             :                         {
     492             :                             // only take action when move is allowed
     493           0 :                             if(pView->IsMoveAllowed())
     494             :                             {
     495             :                                 // restrict movement to WorkArea
     496           0 :                                 const Rectangle& rWorkArea = pView->GetWorkArea();
     497             : 
     498           0 :                                 if(!rWorkArea.IsEmpty())
     499             :                                 {
     500           0 :                                     Rectangle aMarkRect(pView->GetMarkedObjRect());
     501           0 :                                     aMarkRect.Move(nX, nY);
     502             : 
     503           0 :                                     if(!aMarkRect.IsInside(rWorkArea))
     504             :                                     {
     505           0 :                                         if(aMarkRect.Left() < rWorkArea.Left())
     506             :                                         {
     507           0 :                                             nX += rWorkArea.Left() - aMarkRect.Left();
     508             :                                         }
     509             : 
     510           0 :                                         if(aMarkRect.Right() > rWorkArea.Right())
     511             :                                         {
     512           0 :                                             nX -= aMarkRect.Right() - rWorkArea.Right();
     513             :                                         }
     514             : 
     515           0 :                                         if(aMarkRect.Top() < rWorkArea.Top())
     516             :                                         {
     517           0 :                                             nY += rWorkArea.Top() - aMarkRect.Top();
     518             :                                         }
     519             : 
     520           0 :                                         if(aMarkRect.Bottom() > rWorkArea.Bottom())
     521             :                                         {
     522           0 :                                             nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
     523             :                                         }
     524             :                                     }
     525             :                                 }
     526             : 
     527             :                                 // now move the selected draw objects
     528           0 :                                 pView->MoveAllMarked(Size(nX, nY));
     529             : 
     530             :                                 // II
     531           0 :                                 pView->MakeVisible(pView->GetAllMarkedRect(), *pWindow);
     532             : 
     533           0 :                                 bReturn = true;
     534             :                             }
     535             :                         }
     536             :                         else
     537             :                         {
     538             :                             // move handle with index nHandleIndex
     539           0 :                             if(pHdl && (nX || nY))
     540             :                             {
     541             :                                 // now move the Handle (nX, nY)
     542           0 :                                 Point aStartPoint(pHdl->GetPos());
     543           0 :                                 Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
     544           0 :                                 const SdrDragStat& rDragStat = pView->GetDragStat();
     545             : 
     546             :                                 // start dragging
     547           0 :                                 pView->BegDragObj(aStartPoint, 0, pHdl, 0);
     548             : 
     549           0 :                                 if(pView->IsDragObj())
     550             :                                 {
     551           0 :                                     bool bWasNoSnap = rDragStat.IsNoSnap();
     552           0 :                                     bool bWasSnapEnabled = pView->IsSnapEnabled();
     553             : 
     554             :                                     // switch snapping off
     555           0 :                                     if(!bWasNoSnap)
     556           0 :                                         ((SdrDragStat&)rDragStat).SetNoSnap(true);
     557           0 :                                     if(bWasSnapEnabled)
     558           0 :                                         pView->SetSnapEnabled(false);
     559             : 
     560           0 :                                     pView->MovAction(aEndPoint);
     561           0 :                                     pView->EndDragObj();
     562             : 
     563             :                                     // restore snap
     564           0 :                                     if(!bWasNoSnap)
     565           0 :                                         ((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
     566           0 :                                     if(bWasSnapEnabled)
     567           0 :                                         pView->SetSnapEnabled(bWasSnapEnabled);
     568             :                                 }
     569             : 
     570             :                                 // make moved handle visible
     571           0 :                                 Rectangle aVisRect(aEndPoint - Point(100, 100), Size(200, 200));
     572           0 :                                 pView->MakeVisible(aVisRect, *pWindow);
     573             : 
     574           0 :                                 bReturn = true;
     575             :                             }
     576             :                         }
     577             :                     }
     578             :                 }
     579             :             }
     580             :         }
     581           0 :         break;
     582             : 
     583             :         // #97016#
     584             :         case KEY_SPACE:
     585             :         {
     586             :             // in calc do only something when draw objects are selected
     587           0 :             if(pView->AreObjectsMarked())
     588             :             {
     589           0 :                 const SdrHdlList& rHdlList = pView->GetHdlList();
     590           0 :                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
     591             : 
     592           0 :                 if(pHdl)
     593             :                 {
     594           0 :                     if(pHdl->GetKind() == HDL_POLY)
     595             :                     {
     596             :                         // rescue ID of point with focus
     597           0 :                         sal_uInt32 nPol(pHdl->GetPolyNum());
     598           0 :                         sal_uInt32 nPnt(pHdl->GetPointNum());
     599             : 
     600           0 :                         if(pView->IsPointMarked(*pHdl))
     601             :                         {
     602           0 :                             if(rKEvt.GetKeyCode().IsShift())
     603             :                             {
     604           0 :                                 pView->UnmarkPoint(*pHdl);
     605             :                             }
     606             :                         }
     607             :                         else
     608             :                         {
     609           0 :                             if(!rKEvt.GetKeyCode().IsShift())
     610             :                             {
     611           0 :                                 pView->UnmarkAllPoints();
     612             :                             }
     613             : 
     614           0 :                             pView->MarkPoint(*pHdl);
     615             :                         }
     616             : 
     617           0 :                         if(0L == rHdlList.GetFocusHdl())
     618             :                         {
     619             :                             // restore point with focus
     620           0 :                             SdrHdl* pNewOne = 0L;
     621             : 
     622           0 :                             for(size_t a = 0; !pNewOne && a < rHdlList.GetHdlCount(); ++a)
     623             :                             {
     624           0 :                                 SdrHdl* pAct = rHdlList.GetHdl(a);
     625             : 
     626           0 :                                 if(pAct
     627           0 :                                     && pAct->GetKind() == HDL_POLY
     628           0 :                                     && pAct->GetPolyNum() == nPol
     629           0 :                                     && pAct->GetPointNum() == nPnt)
     630             :                                 {
     631           0 :                                     pNewOne = pAct;
     632             :                                 }
     633             :                             }
     634             : 
     635           0 :                             if(pNewOne)
     636             :                             {
     637           0 :                                 ((SdrHdlList&)rHdlList).SetFocusHdl(pNewOne);
     638             :                             }
     639             :                         }
     640             : 
     641           0 :                         bReturn = true;
     642             :                     }
     643             :                 }
     644             :             }
     645             :         }
     646           0 :         break;
     647             :     }
     648             : 
     649           0 :     if (!bReturn)
     650             :     {
     651           0 :         bReturn = FuPoor::KeyInput(rKEvt);
     652             :     }
     653             : 
     654           0 :     if (!bReturn)
     655             :     {
     656             :         // allow direct typing into a selected text object
     657             : 
     658           0 :         const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
     659           0 :         if( !pView->IsTextEdit() && 1 == rMarkList.GetMarkCount() && EditEngine::IsSimpleCharInput(rKEvt) )
     660             :         {
     661           0 :             SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
     662             : 
     663             :             // start text edit for suitable object, pass key event to OutlinerView
     664           0 :             if ( lcl_KeyEditMode( pObj, pViewShell, &rKEvt ) )
     665           0 :                 bReturn = true;
     666             :         }
     667             :     }
     668             : 
     669           0 :     return bReturn;
     670             : }
     671             : 
     672             : // II
     673           0 : void FuDraw::SelectionHasChanged()
     674             : {
     675           0 :     const SdrHdlList& rHdlList = pView->GetHdlList();
     676           0 :     ((SdrHdlList&)rHdlList).ResetFocusHdl();
     677           0 : }
     678             : 
     679             : /*************************************************************************
     680             : |*
     681             : |* enable function
     682             : |*
     683             : \************************************************************************/
     684             : 
     685           0 : void FuDraw::Activate()
     686             : {
     687           0 :     FuPoor::Activate();
     688           0 : }
     689             : 
     690             : /*************************************************************************
     691             : |*
     692             : |* disable function
     693             : |*
     694             : \************************************************************************/
     695             : 
     696           0 : void FuDraw::Deactivate()
     697             : {
     698           0 :     FuPoor::Deactivate();
     699           0 : }
     700             : 
     701             : /*************************************************************************
     702             : |*
     703             : |* toggle mouse-pointer
     704             : |*
     705             : \************************************************************************/
     706             : 
     707           0 : static bool lcl_UrlHit( SdrView* pView, const Point& rPosPixel, vcl::Window* pWindow )
     708             : {
     709           0 :     SdrViewEvent aVEvt;
     710           0 :     MouseEvent aMEvt( rPosPixel, 1, MouseEventModifiers::NONE, MOUSE_LEFT );
     711           0 :     SdrHitKind eHit = pView->PickAnything( aMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt );
     712             : 
     713           0 :     if ( eHit != SDRHIT_NONE && aVEvt.pObj != NULL )
     714             :     {
     715           0 :         if ( ScDrawLayer::GetIMapInfo( aVEvt.pObj ) && ScDrawLayer::GetHitIMapObject(
     716           0 :                                 aVEvt.pObj, pWindow->PixelToLogic(rPosPixel), *pWindow ) )
     717           0 :             return true;
     718             : 
     719           0 :         if ( aVEvt.eEvent == SDREVENT_EXECUTEURL )
     720           0 :             return true;
     721             :     }
     722             : 
     723           0 :     return false;
     724             : }
     725             : 
     726           0 : void FuDraw::ForcePointer(const MouseEvent* pMEvt)
     727             : {
     728           0 :     if ( !pView->IsAction() )
     729             :     {
     730           0 :         Point aPosPixel = pWindow->GetPointerPosPixel();
     731           0 :         bool bAlt       = pMEvt && pMEvt->IsMod2();
     732           0 :         Point aPnt      = pWindow->PixelToLogic( aPosPixel );
     733           0 :         SdrHdl* pHdl    = pView->PickHandle(aPnt);
     734             :         SdrObject* pObj;
     735             :         SdrPageView* pPV;
     736             : 
     737           0 :         ScMacroInfo* pInfo = 0;
     738           0 :         if ( pView->PickObj(aPnt, pView->getHitTolLog(), pObj, pPV, SdrSearchOptions::ALSOONMASTER) )
     739             :         {
     740           0 :             if ( pObj->IsGroupObject() )
     741             :             {
     742           0 :                 SdrObject* pHit = 0;
     743           0 :                 if ( pView->PickObj(aMDPos, pView->getHitTolLog(), pHit, pPV, SdrSearchOptions::DEEP ) )
     744           0 :                     pObj = pHit;
     745             :             }
     746           0 :             pInfo = ScDrawLayer::GetMacroInfo( pObj );
     747             :         }
     748             : 
     749           0 :         if ( pView->IsTextEdit() )
     750             :         {
     751           0 :             pViewShell->SetActivePointer(Pointer(PointerStyle::Text));        // can't be ?
     752             :         }
     753           0 :         else if ( pHdl )
     754             :         {
     755             :             pViewShell->SetActivePointer(
     756           0 :                 pView->GetPreferredPointer( aPnt, pWindow ) );
     757             :         }
     758           0 :         else if ( pView->IsMarkedHit(aPnt) )
     759             :         {
     760           0 :             pViewShell->SetActivePointer( Pointer(PointerStyle::Move) );
     761             :         }
     762           0 :         else if ( !bAlt && ( !pMEvt || !pMEvt->GetButtons() )
     763           0 :                         && lcl_UrlHit( pView, aPosPixel, pWindow ) )
     764             :         {
     765             :             //  could be suppressed with ALT
     766           0 :             pWindow->SetPointer( Pointer( PointerStyle::RefHand ) );          // Text-URL / ImageMap
     767             :         }
     768           0 :         else if ( !bAlt && pView->PickObj(aPnt, pView->getHitTolLog(), pObj, pPV, SdrSearchOptions::PICKMACRO) )
     769             :         {
     770             :             //  could be suppressed with ALT
     771           0 :             SdrObjMacroHitRec aHitRec;  //! something missing ????
     772           0 :             pViewShell->SetActivePointer( pObj->GetMacroPointer(aHitRec) );
     773             :         }
     774           0 :         else if ( !bAlt && pInfo && (!pInfo->GetMacro().isEmpty() || !pInfo->GetHlink().isEmpty()) )
     775           0 :             pWindow->SetPointer( Pointer( PointerStyle::RefHand ) );
     776           0 :         else if ( IsDetectiveHit( aPnt ) )
     777           0 :             pViewShell->SetActivePointer( Pointer( PointerStyle::Detective ) );
     778             :         else
     779           0 :             pViewShell->SetActivePointer( aNewPointer );            //! in Gridwin?
     780             :     }
     781           0 : }
     782             : 
     783           0 : bool FuDraw::IsEditingANote() const
     784             : {
     785           0 :     const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
     786           0 :     const size_t backval=rMarkList.GetMarkCount();
     787           0 :     for (size_t nlv1=0; nlv1<backval; ++nlv1)
     788             :     {
     789           0 :         SdrObject* pObj = rMarkList.GetMark( nlv1 )->GetMarkedSdrObj();
     790           0 :         if ( ScDrawLayer::IsNoteCaption( pObj ) )
     791             :         {
     792           0 :             return true;
     793             :         }
     794             :     }
     795           0 :     return false;
     796             : }
     797             : 
     798           0 : bool FuDraw::IsSizingOrMovingNote( const MouseEvent& rMEvt ) const
     799             : {
     800           0 :     bool bIsSizingOrMoving = false;
     801           0 :     if ( rMEvt.IsLeft() )
     802             :     {
     803           0 :         const SdrMarkList& rNoteMarkList = pView->GetMarkedObjectList();
     804           0 :         if(rNoteMarkList.GetMarkCount() == 1)
     805             :         {
     806           0 :             SdrObject* pObj = rNoteMarkList.GetMark( 0 )->GetMarkedSdrObj();
     807           0 :             if ( ScDrawLayer::IsNoteCaption( pObj ) )
     808             :             {
     809           0 :                 Point aMPos = pWindow->PixelToLogic( rMEvt.GetPosPixel() );
     810             :                 bIsSizingOrMoving =
     811           0 :                     pView->PickHandle( aMPos ) ||      // handles to resize the note
     812           0 :                     pView->IsTextEditFrameHit( aMPos );         // frame for moving the note
     813             :             }
     814             :         }
     815             :     }
     816           0 :     return bIsSizingOrMoving;
     817         156 : }
     818             : 
     819             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11