LCOV - code coverage report
Current view: top level - basctl/source/dlged - dlgedfunc.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 276 0.0 %
Date: 2014-04-14 Functions: 0 22 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <vcl/scrbar.hxx>
      21             : #include <svx/svdview.hxx>
      22             : #include "dlgedfunc.hxx"
      23             : #include "dlged.hxx"
      24             : #include "dlgedview.hxx"
      25             : #include <vcl/seleng.hxx>
      26             : 
      27             : namespace basctl
      28             : {
      29             : 
      30           0 : IMPL_LINK_INLINE_START( DlgEdFunc, ScrollTimeout, Timer *, pTimer )
      31             : {
      32             :     (void)pTimer;
      33           0 :     Window& rWindow = rParent.GetWindow();
      34           0 :     Point aPos = rWindow.ScreenToOutputPixel( rWindow.GetPointerPosPixel() );
      35           0 :     aPos = rWindow.PixelToLogic( aPos );
      36           0 :     ForceScroll( aPos );
      37           0 :     return 0;
      38             : }
      39           0 : IMPL_LINK_INLINE_END( DlgEdFunc, ScrollTimeout, Timer *, pTimer )
      40             : 
      41           0 : void DlgEdFunc::ForceScroll( const Point& rPos )
      42             : {
      43           0 :     aScrollTimer.Stop();
      44             : 
      45           0 :     Window& rWindow  = rParent.GetWindow();
      46             : 
      47           0 :     static Point aDefPoint;
      48           0 :     Rectangle aOutRect( aDefPoint, rWindow.GetOutputSizePixel() );
      49           0 :     aOutRect = rWindow.PixelToLogic( aOutRect );
      50             : 
      51           0 :     ScrollBar* pHScroll = rParent.GetHScroll();
      52           0 :     ScrollBar* pVScroll = rParent.GetVScroll();
      53           0 :     long nDeltaX = pHScroll->GetLineSize();
      54           0 :     long nDeltaY = pVScroll->GetLineSize();
      55             : 
      56           0 :     if( !aOutRect.IsInside( rPos ) )
      57             :     {
      58           0 :         if( rPos.X() < aOutRect.Left() )
      59           0 :             nDeltaX = -nDeltaX;
      60           0 :         else if( rPos.X() <= aOutRect.Right() )
      61           0 :             nDeltaX = 0;
      62             : 
      63           0 :         if( rPos.Y() < aOutRect.Top() )
      64           0 :             nDeltaY = -nDeltaY;
      65           0 :         else if( rPos.Y() <= aOutRect.Bottom() )
      66           0 :             nDeltaY = 0;
      67             : 
      68           0 :         if( nDeltaX )
      69           0 :             pHScroll->SetThumbPos( pHScroll->GetThumbPos() + nDeltaX );
      70           0 :         if( nDeltaY )
      71           0 :             pVScroll->SetThumbPos( pVScroll->GetThumbPos() + nDeltaY );
      72             : 
      73           0 :         if( nDeltaX )
      74           0 :             rParent.DoScroll( pHScroll );
      75           0 :         if( nDeltaY )
      76           0 :             rParent.DoScroll( pVScroll );
      77             :     }
      78             : 
      79           0 :     aScrollTimer.Start();
      80           0 : }
      81             : 
      82           0 : DlgEdFunc::DlgEdFunc (DlgEditor& rParent_) :
      83           0 :     rParent(rParent_)
      84             : {
      85           0 :     aScrollTimer.SetTimeoutHdl( LINK( this, DlgEdFunc, ScrollTimeout ) );
      86           0 :     aScrollTimer.SetTimeout( SELENG_AUTOREPEAT_INTERVAL );
      87           0 : }
      88             : 
      89           0 : DlgEdFunc::~DlgEdFunc()
      90             : {
      91           0 : }
      92             : 
      93           0 : bool DlgEdFunc::MouseButtonDown( const MouseEvent& )
      94             : {
      95           0 :     return true;
      96             : }
      97             : 
      98           0 : bool DlgEdFunc::MouseButtonUp( const MouseEvent& )
      99             : {
     100           0 :     aScrollTimer.Stop();
     101           0 :     return true;
     102             : }
     103             : 
     104           0 : bool DlgEdFunc::MouseMove( const MouseEvent& )
     105             : {
     106           0 :     return true;
     107             : }
     108             : 
     109           0 : bool DlgEdFunc::KeyInput( const KeyEvent& rKEvt )
     110             : {
     111           0 :     bool bReturn = false;
     112             : 
     113           0 :     SdrView& rView = rParent.GetView();
     114           0 :     Window& rWindow = rParent.GetWindow();
     115             : 
     116           0 :     KeyCode aCode = rKEvt.GetKeyCode();
     117           0 :     sal_uInt16 nCode = aCode.GetCode();
     118             : 
     119           0 :     switch ( nCode )
     120             :     {
     121             :         case KEY_ESCAPE:
     122             :         {
     123           0 :             if ( rView.IsAction() )
     124             :             {
     125           0 :                 rView.BrkAction();
     126           0 :                 bReturn = true;
     127             :             }
     128           0 :             else if ( rView.AreObjectsMarked() )
     129             :             {
     130           0 :                 const SdrHdlList& rHdlList = rView.GetHdlList();
     131           0 :                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
     132           0 :                 if ( pHdl )
     133           0 :                     const_cast<SdrHdlList&>(rHdlList).ResetFocusHdl();
     134             :                 else
     135           0 :                     rView.UnmarkAll();
     136             : 
     137           0 :                 bReturn = true;
     138             :             }
     139             :         }
     140           0 :         break;
     141             :         case KEY_TAB:
     142             :         {
     143           0 :             if ( !aCode.IsMod1() && !aCode.IsMod2() )
     144             :             {
     145             :                 // mark next object
     146           0 :                 if ( !rView.MarkNextObj( !aCode.IsShift() ) )
     147             :                 {
     148             :                     // if no next object, mark first/last
     149           0 :                     rView.UnmarkAllObj();
     150           0 :                     rView.MarkNextObj( !aCode.IsShift() );
     151             :                 }
     152             : 
     153           0 :                 if ( rView.AreObjectsMarked() )
     154           0 :                     rView.MakeVisible( rView.GetAllMarkedRect(), rWindow );
     155             : 
     156           0 :                 bReturn = true;
     157             :             }
     158           0 :             else if ( aCode.IsMod1() )
     159             :             {
     160             :                 // selected handle
     161           0 :                 const SdrHdlList& rHdlList = rView.GetHdlList();
     162           0 :                 const_cast<SdrHdlList&>(rHdlList).TravelFocusHdl( !aCode.IsShift() );
     163             : 
     164             :                 // guarantee visibility of focused handle
     165           0 :                 if (SdrHdl* pHdl = rHdlList.GetFocusHdl())
     166             :                 {
     167           0 :                     Point aHdlPosition( pHdl->GetPos() );
     168           0 :                     Rectangle aVisRect( aHdlPosition - Point( 100, 100 ), Size( 200, 200 ) );
     169           0 :                     rView.MakeVisible( aVisRect, rWindow );
     170             :                 }
     171             : 
     172           0 :                 bReturn = true;
     173             :             }
     174             :         }
     175           0 :         break;
     176             :         case KEY_UP:
     177             :         case KEY_DOWN:
     178             :         case KEY_LEFT:
     179             :         case KEY_RIGHT:
     180             :         {
     181           0 :             long nX = 0;
     182           0 :             long nY = 0;
     183             : 
     184           0 :             if ( nCode == KEY_UP )
     185             :             {
     186             :                 // scroll up
     187           0 :                 nX =  0;
     188           0 :                 nY = -1;
     189             :             }
     190           0 :             else if ( nCode == KEY_DOWN )
     191             :             {
     192             :                 // scroll down
     193           0 :                 nX =  0;
     194           0 :                 nY =  1;
     195             :             }
     196           0 :             else if ( nCode == KEY_LEFT )
     197             :             {
     198             :                 // scroll left
     199           0 :                 nX = -1;
     200           0 :                 nY =  0;
     201             :             }
     202           0 :             else if ( nCode == KEY_RIGHT )
     203             :             {
     204             :                 // scroll right
     205           0 :                 nX =  1;
     206           0 :                 nY =  0;
     207             :             }
     208             : 
     209           0 :             if ( rView.AreObjectsMarked() && !aCode.IsMod1() )
     210             :             {
     211           0 :                 if ( aCode.IsMod2() )
     212             :                 {
     213             :                     // move in 1 pixel distance
     214           0 :                     Size aPixelSize = rWindow.PixelToLogic(Size(1, 1));
     215           0 :                     nX *= aPixelSize.Width();
     216           0 :                     nY *= aPixelSize.Height();
     217             :                 }
     218             :                 else
     219             :                 {
     220             :                     // move in 1 mm distance
     221           0 :                     nX *= 100;
     222           0 :                     nY *= 100;
     223             :                 }
     224             : 
     225           0 :                 const SdrHdlList& rHdlList = rView.GetHdlList();
     226           0 :                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
     227             : 
     228           0 :                 if ( pHdl == 0 )
     229             :                 {
     230             :                     // no handle selected
     231           0 :                     if ( rView.IsMoveAllowed() )
     232             :                     {
     233             :                         // restrict movement to work area
     234           0 :                         const Rectangle& rWorkArea = rView.GetWorkArea();
     235             : 
     236           0 :                         if ( !rWorkArea.IsEmpty() )
     237             :                         {
     238           0 :                             Rectangle aMarkRect( rView.GetMarkedObjRect() );
     239           0 :                             aMarkRect.Move( nX, nY );
     240             : 
     241           0 :                             if ( !rWorkArea.IsInside( aMarkRect ) )
     242             :                             {
     243           0 :                                 if ( aMarkRect.Left() < rWorkArea.Left() )
     244           0 :                                     nX += rWorkArea.Left() - aMarkRect.Left();
     245             : 
     246           0 :                                 if ( aMarkRect.Right() > rWorkArea.Right() )
     247           0 :                                     nX -= aMarkRect.Right() - rWorkArea.Right();
     248             : 
     249           0 :                                 if ( aMarkRect.Top() < rWorkArea.Top() )
     250           0 :                                     nY += rWorkArea.Top() - aMarkRect.Top();
     251             : 
     252           0 :                                 if ( aMarkRect.Bottom() > rWorkArea.Bottom() )
     253           0 :                                     nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
     254             :                             }
     255             :                         }
     256             : 
     257           0 :                         if ( nX != 0 || nY != 0 )
     258             :                         {
     259           0 :                             rView.MoveAllMarked( Size( nX, nY ) );
     260           0 :                             rView.MakeVisible( rView.GetAllMarkedRect(), rWindow );
     261             :                         }
     262             :                     }
     263             :                 }
     264             :                 else
     265             :                 {
     266             :                     // move the handle
     267           0 :                     if ( pHdl && ( nX || nY ) )
     268             :                     {
     269           0 :                         Point aStartPoint( pHdl->GetPos() );
     270           0 :                         Point aEndPoint( pHdl->GetPos() + Point( nX, nY ) );
     271           0 :                         const SdrDragStat& rDragStat = rView.GetDragStat();
     272             : 
     273             :                         // start dragging
     274           0 :                         rView.BegDragObj( aStartPoint, 0, pHdl, 0 );
     275             : 
     276           0 :                         if ( rView.IsDragObj() )
     277             :                         {
     278           0 :                             bool const bWasNoSnap = rDragStat.IsNoSnap();
     279           0 :                             bool const bWasSnapEnabled = rView.IsSnapEnabled();
     280             : 
     281             :                             // switch snapping off
     282           0 :                             if ( !bWasNoSnap )
     283           0 :                                 const_cast<SdrDragStat&>(rDragStat).SetNoSnap(true);
     284           0 :                             if ( bWasSnapEnabled )
     285           0 :                                 rView.SetSnapEnabled(false);
     286             : 
     287           0 :                             rView.MovAction( aEndPoint );
     288           0 :                             rView.EndDragObj();
     289             : 
     290             :                             // restore snap
     291           0 :                             if ( !bWasNoSnap )
     292           0 :                                 const_cast<SdrDragStat&>(rDragStat).SetNoSnap( bWasNoSnap );
     293           0 :                             if ( bWasSnapEnabled )
     294           0 :                                 rView.SetSnapEnabled( bWasSnapEnabled );
     295             :                         }
     296             : 
     297             :                         // make moved handle visible
     298           0 :                         Rectangle aVisRect( aEndPoint - Point( 100, 100 ), Size( 200, 200 ) );
     299           0 :                         rView.MakeVisible( aVisRect, rWindow );
     300             :                     }
     301             :                 }
     302             :             }
     303             :             else
     304             :             {
     305             :                 // scroll page
     306           0 :                 ScrollBar* pScrollBar = ( nX != 0 ) ? rParent.GetHScroll() : rParent.GetVScroll();
     307           0 :                 if ( pScrollBar )
     308             :                 {
     309           0 :                     long nRangeMin = pScrollBar->GetRangeMin();
     310           0 :                     long nRangeMax = pScrollBar->GetRangeMax();
     311           0 :                     long nThumbPos = pScrollBar->GetThumbPos() + ( ( nX != 0 ) ? nX : nY ) * pScrollBar->GetLineSize();
     312           0 :                     if ( nThumbPos < nRangeMin )
     313           0 :                         nThumbPos = nRangeMin;
     314           0 :                     if ( nThumbPos > nRangeMax )
     315           0 :                         nThumbPos = nRangeMax;
     316           0 :                     pScrollBar->SetThumbPos( nThumbPos );
     317           0 :                     rParent.DoScroll( pScrollBar );
     318             :                 }
     319             :             }
     320             : 
     321           0 :             bReturn = true;
     322             :         }
     323           0 :         break;
     324             :         default:
     325             :         {
     326             :         }
     327           0 :         break;
     328             :     }
     329             : 
     330           0 :     if ( bReturn )
     331           0 :         rWindow.ReleaseMouse();
     332             : 
     333           0 :     return bReturn;
     334             : }
     335             : 
     336           0 : DlgEdFuncInsert::DlgEdFuncInsert (DlgEditor& rParent_) :
     337           0 :     DlgEdFunc(rParent_)
     338             : {
     339           0 :     rParent.GetView().SetCreateMode(true);
     340           0 : }
     341             : 
     342           0 : DlgEdFuncInsert::~DlgEdFuncInsert()
     343             : {
     344           0 :     rParent.GetView().SetEditMode( true );
     345           0 : }
     346             : 
     347           0 : bool DlgEdFuncInsert::MouseButtonDown( const MouseEvent& rMEvt )
     348             : {
     349           0 :     if( !rMEvt.IsLeft() )
     350           0 :         return true;
     351             : 
     352           0 :     SdrView& rView  = rParent.GetView();
     353           0 :     Window& rWindow = rParent.GetWindow();
     354           0 :     rView.SetActualWin(&rWindow);
     355             : 
     356           0 :     Point aPos = rWindow.PixelToLogic( rMEvt.GetPosPixel() );
     357           0 :     sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
     358           0 :     sal_uInt16 nDrgLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
     359             : 
     360           0 :     rWindow.CaptureMouse();
     361             : 
     362           0 :     if ( rMEvt.IsLeft() && rMEvt.GetClicks() == 1 )
     363             :     {
     364           0 :         SdrHdl* pHdl = rView.PickHandle(aPos);
     365             : 
     366             :         // if selected object was hit, drag object
     367           0 :         if ( pHdl!=NULL || rView.IsMarkedHit(aPos, nHitLog) )
     368           0 :             rView.BegDragObj(aPos, (OutputDevice*) NULL, pHdl, nDrgLog);
     369           0 :         else if ( rView.AreObjectsMarked() )
     370           0 :             rView.UnmarkAll();
     371             : 
     372             :         // if no action, create object
     373           0 :         if ( !rView.IsAction() )
     374           0 :             rView.BegCreateObj(aPos);
     375             :     }
     376           0 :     else if ( rMEvt.IsLeft() && rMEvt.GetClicks() == 2 )
     377             :     {
     378             :         // if object was hit, show property browser
     379           0 :         if ( rView.IsMarkedHit(aPos, nHitLog) && rParent.GetMode() != DlgEditor::READONLY )
     380           0 :             rParent.ShowProperties();
     381             :     }
     382             : 
     383           0 :     return true;
     384             : }
     385             : 
     386           0 : bool DlgEdFuncInsert::MouseButtonUp( const MouseEvent& rMEvt )
     387             : {
     388           0 :     DlgEdFunc::MouseButtonUp( rMEvt );
     389             : 
     390           0 :     SdrView& rView  = rParent.GetView();
     391           0 :     Window& rWindow = rParent.GetWindow();
     392           0 :     rView.SetActualWin(&rWindow);
     393             : 
     394           0 :     rWindow.ReleaseMouse();
     395             : 
     396             :     // object creation active?
     397           0 :     if ( rView.IsCreateObj() )
     398             :     {
     399           0 :         rView.EndCreateObj(SDRCREATE_FORCEEND);
     400             : 
     401           0 :         if ( !rView.AreObjectsMarked() )
     402             :         {
     403           0 :             sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
     404           0 :             Point aPos( rWindow.PixelToLogic( rMEvt.GetPosPixel() ) );
     405           0 :             rView.MarkObj(aPos, nHitLog);
     406             :         }
     407             : 
     408           0 :         return rView.AreObjectsMarked();
     409             :     }
     410             :     else
     411             :     {
     412           0 :         if ( rView.IsDragObj() )
     413           0 :             rView.EndDragObj( rMEvt.IsMod1() );
     414           0 :         return true;
     415             :     }
     416             : }
     417             : 
     418           0 : bool DlgEdFuncInsert::MouseMove( const MouseEvent& rMEvt )
     419             : {
     420           0 :     SdrView& rView  = rParent.GetView();
     421           0 :     Window& rWindow = rParent.GetWindow();
     422           0 :     rView.SetActualWin(&rWindow);
     423             : 
     424           0 :     Point aPos = rWindow.PixelToLogic(rMEvt.GetPosPixel());
     425           0 :     sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
     426             : 
     427           0 :     if (rView.IsAction())
     428             :     {
     429           0 :         ForceScroll(aPos);
     430           0 :         rView.MovAction(aPos);
     431             :     }
     432             : 
     433           0 :     rWindow.SetPointer( rView.GetPreferredPointer( aPos, &rWindow, nHitLog ) );
     434             : 
     435           0 :     return true;
     436             : }
     437             : 
     438           0 : DlgEdFuncSelect::DlgEdFuncSelect (DlgEditor& rParent_) :
     439             :     DlgEdFunc(rParent_),
     440           0 :     bMarkAction(false)
     441             : {
     442           0 : }
     443             : 
     444           0 : DlgEdFuncSelect::~DlgEdFuncSelect()
     445             : {
     446           0 : }
     447             : 
     448           0 : bool DlgEdFuncSelect::MouseButtonDown( const MouseEvent& rMEvt )
     449             : {
     450             :     // get view from parent
     451           0 :     SdrView& rView  = rParent.GetView();
     452           0 :     Window& rWindow = rParent.GetWindow();
     453           0 :     rView.SetActualWin(&rWindow);
     454             : 
     455           0 :     sal_uInt16 nDrgLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
     456           0 :     sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
     457           0 :     Point aMDPos = rWindow.PixelToLogic(rMEvt.GetPosPixel());
     458             : 
     459           0 :     if ( rMEvt.IsLeft() && rMEvt.GetClicks() == 1 )
     460             :     {
     461           0 :         SdrHdl* pHdl = rView.PickHandle(aMDPos);
     462             :         SdrObject* pObj;
     463             :         SdrPageView* pPV;
     464             : 
     465             :         // hit selected object?
     466           0 :         if ( pHdl!=NULL || rView.IsMarkedHit(aMDPos, nHitLog) )
     467             :         {
     468           0 :             rView.BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl, nDrgLog);
     469             :         }
     470             :         else
     471             :         {
     472             :             // if not multi selection, unmark all
     473           0 :             if ( !rMEvt.IsShift() )
     474           0 :                 rView.UnmarkAll();
     475             :             else
     476             :             {
     477           0 :                 if( rView.PickObj( aMDPos, nHitLog, pObj, pPV ) )
     478             :                 {
     479             :                     //if (dynamic_cast<DlgEdForm*>(pObj))
     480             :                     //  rView.UnmarkAll();
     481             :                     //else
     482             :                     //  rParent.UnmarkDialog();
     483             :                 }
     484             :             }
     485             : 
     486           0 :             if ( rView.MarkObj(aMDPos, nHitLog) )
     487             :             {
     488             :                 // drag object
     489           0 :                 pHdl = rView.PickHandle(aMDPos);
     490           0 :                 rView.BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl, nDrgLog);
     491             :             }
     492             :             else
     493             :             {
     494             :                 // select object
     495           0 :                 rView.BegMarkObj(aMDPos);
     496           0 :                 bMarkAction = true;
     497             :             }
     498             :         }
     499             :     }
     500           0 :     else if ( rMEvt.IsLeft() && rMEvt.GetClicks() == 2 )
     501             :     {
     502             :         // if object was hit, show property browser
     503           0 :         if ( rView.IsMarkedHit(aMDPos, nHitLog) && rParent.GetMode() != DlgEditor::READONLY )
     504           0 :             rParent.ShowProperties();
     505             :     }
     506             : 
     507           0 :     return true;
     508             : }
     509             : 
     510           0 : bool DlgEdFuncSelect::MouseButtonUp( const MouseEvent& rMEvt )
     511             : {
     512           0 :     DlgEdFunc::MouseButtonUp( rMEvt );
     513             : 
     514             :     // get view from parent
     515           0 :     SdrView& rView  = rParent.GetView();
     516           0 :     Window& rWindow = rParent.GetWindow();
     517           0 :     rView.SetActualWin(&rWindow);
     518             : 
     519           0 :     Point aPnt = rWindow.PixelToLogic(rMEvt.GetPosPixel());
     520           0 :     sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
     521             : 
     522           0 :     if ( rMEvt.IsLeft() )
     523             :     {
     524           0 :         if (rView.IsDragObj())
     525             :         {
     526             :             // object was dragged
     527           0 :             rView.EndDragObj( rMEvt.IsMod1() );
     528           0 :             rView.ForceMarkedToAnotherPage();
     529             :         }
     530           0 :         else if (rView.IsAction())
     531             :         {
     532           0 :             rView.EndAction();
     533             :         }
     534             :     }
     535             : 
     536           0 :     bMarkAction = false;
     537             : 
     538           0 :     rWindow.SetPointer( rView.GetPreferredPointer( aPnt, &rWindow, nHitLog ) );
     539           0 :     rWindow.ReleaseMouse();
     540             : 
     541           0 :     return true;
     542             : }
     543             : 
     544           0 : bool DlgEdFuncSelect::MouseMove( const MouseEvent& rMEvt )
     545             : {
     546           0 :     SdrView& rView  = rParent.GetView();
     547           0 :     Window& rWindow = rParent.GetWindow();
     548           0 :     rView.SetActualWin(&rWindow);
     549             : 
     550           0 :     Point aPnt = rWindow.PixelToLogic(rMEvt.GetPosPixel());
     551           0 :     sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
     552             : 
     553           0 :     if ( rView.IsAction() )
     554             :     {
     555           0 :         Point aPix = rMEvt.GetPosPixel();
     556           0 :         Point aPnt_ = rWindow.PixelToLogic(aPix);
     557             : 
     558           0 :         ForceScroll(aPnt_);
     559           0 :         rView.MovAction(aPnt_);
     560             :     }
     561             : 
     562           0 :     rWindow.SetPointer( rView.GetPreferredPointer( aPnt, &rWindow, nHitLog ) );
     563             : 
     564           0 :     return true;
     565             : }
     566             : 
     567             : } // namespace basctl
     568             : 
     569             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10