LCOV - code coverage report
Current view: top level - sw/source/uibase/wrtsh - move.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 91 340 26.8 %
Date: 2014-11-03 Functions: 18 47 38.3 %
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 <sfx2/bindings.hxx>
      21             : #include <wrtsh.hxx>
      22             : #include <view.hxx>
      23             : #include <viewopt.hxx>
      24             : #include <crsskip.hxx>
      25             : 
      26             : /**
      27             :    Always:
      28             :     -   Reset of the cursor stack
      29             :     -   retrigger timer
      30             :     -   if applicable: GCAttr
      31             : 
      32             :     on selection
      33             :     -   SttSelect()
      34             : 
      35             :     else
      36             :     -   EndSelect()
      37             :  */
      38             : 
      39             : const long nReadOnlyScrollOfst = 10;
      40             : 
      41             : class ShellMoveCrsr
      42             : {
      43             :     SwWrtShell* pSh;
      44             :     bool bAct;
      45             : public:
      46         160 :     inline ShellMoveCrsr( SwWrtShell* pWrtSh, bool bSel )
      47             :     {
      48         160 :         bAct = !pWrtSh->ActionPend() && (pWrtSh->GetFrmType(0,false) & FRMTYPE_FLY_ANY);
      49         160 :         ( pSh = pWrtSh )->MoveCrsr( bSel );
      50         160 :         pWrtSh->GetView().GetViewFrame()->GetBindings().Invalidate(SID_HYPERLINK_GETLINK);
      51         160 :     }
      52         160 :     inline ~ShellMoveCrsr()
      53             :     {
      54         160 :         if( bAct )
      55             :         {
      56             :             // The action is used for scrolling in "single paragraph"
      57             :             // frames with fixed height.
      58           0 :             pSh->StartAllAction();
      59           0 :             pSh->EndAllAction();
      60             :         }
      61         160 :     }
      62             : };
      63             : 
      64         160 : void SwWrtShell::MoveCrsr( bool bWithSelect )
      65             : {
      66         160 :     ResetCursorStack();
      67         160 :     if ( IsGCAttr() )
      68             :     {
      69           0 :         GCAttr();
      70           0 :         ClearGCAttr();
      71             :     }
      72         160 :     if ( bWithSelect )
      73          48 :         SttSelect();
      74             :     else
      75             :     {
      76         112 :         EndSelect();
      77         112 :         (this->*fnKillSel)( 0, false );
      78             :     }
      79         160 : }
      80             : 
      81           0 : bool SwWrtShell::SimpleMove( FNSimpleMove FnSimpleMove, bool bSelect )
      82             : {
      83             :     bool nRet;
      84           0 :     if( bSelect )
      85             :     {
      86           0 :         SttCrsrMove();
      87           0 :         MoveCrsr( true );
      88           0 :         nRet = (this->*FnSimpleMove)();
      89           0 :         EndCrsrMove();
      90             :     }
      91           0 :     else if( ( nRet = (this->*FnSimpleMove)() ) )
      92           0 :         MoveCrsr( false );
      93           0 :     return nRet;
      94             : }
      95             : 
      96          20 : bool SwWrtShell::Left( sal_uInt16 nMode, bool bSelect,
      97             :                             sal_uInt16 nCount, bool bBasicCall, bool bVisual )
      98             : {
      99          20 :     if ( !bSelect && !bBasicCall && IsCrsrReadonly()  && !GetViewOptions()->IsSelectionInReadonly())
     100             :     {
     101           0 :         Point aTmp( VisArea().Pos() );
     102           0 :         aTmp.X() -= VisArea().Width() * nReadOnlyScrollOfst / 100;
     103           0 :         rView.SetVisArea( aTmp );
     104           0 :         return true;
     105             :     }
     106             :     else
     107             :     {
     108          20 :         ShellMoveCrsr aTmp( this, bSelect );
     109          20 :         return SwCrsrShell::Left( nCount, nMode, bVisual );
     110             :     }
     111             : }
     112             : 
     113          32 : bool SwWrtShell::Right( sal_uInt16 nMode, bool bSelect,
     114             :                             sal_uInt16 nCount, bool bBasicCall, bool bVisual )
     115             : {
     116          32 :     if ( !bSelect && !bBasicCall && IsCrsrReadonly() && !GetViewOptions()->IsSelectionInReadonly() )
     117             :     {
     118           0 :         Point aTmp( VisArea().Pos() );
     119           0 :         aTmp.X() += VisArea().Width() * nReadOnlyScrollOfst / 100;
     120           0 :         aTmp.X() = rView.SetHScrollMax( aTmp.X() );
     121           0 :         rView.SetVisArea( aTmp );
     122           0 :         return true;
     123             :     }
     124             :     else
     125             :     {
     126          32 :         ShellMoveCrsr aTmp( this, bSelect );
     127          32 :         return SwCrsrShell::Right( nCount, nMode, bVisual );
     128             :     }
     129             : }
     130             : 
     131           0 : bool SwWrtShell::Up( bool bSelect, sal_uInt16 nCount, bool bBasicCall )
     132             : {
     133           0 :     if ( !bSelect && !bBasicCall && IsCrsrReadonly()  && !GetViewOptions()->IsSelectionInReadonly())
     134             :     {
     135           0 :         Point aTmp( VisArea().Pos() );
     136           0 :         aTmp.Y() -= VisArea().Height() * nReadOnlyScrollOfst / 100;
     137           0 :         rView.SetVisArea( aTmp );
     138           0 :         return true;
     139             :     }
     140             : 
     141           0 :     ShellMoveCrsr aTmp( this, bSelect );
     142           0 :     return SwCrsrShell::Up( nCount );
     143             : }
     144             : 
     145           0 : bool SwWrtShell::Down( bool bSelect, sal_uInt16 nCount, bool bBasicCall )
     146             : {
     147           0 :     if ( !bSelect && !bBasicCall && IsCrsrReadonly() && !GetViewOptions()->IsSelectionInReadonly())
     148             :     {
     149           0 :         Point aTmp( VisArea().Pos() );
     150           0 :         aTmp.Y() += VisArea().Height() * nReadOnlyScrollOfst / 100;
     151           0 :         aTmp.Y() = rView.SetVScrollMax( aTmp.Y() );
     152           0 :         rView.SetVisArea( aTmp );
     153           0 :         return true;
     154             :     }
     155             : 
     156           0 :     ShellMoveCrsr aTmp( this, bSelect );
     157           0 :     return SwCrsrShell::Down( nCount );
     158             : }
     159             : 
     160           0 : bool SwWrtShell::LeftMargin( bool bSelect, bool bBasicCall )
     161             : {
     162           0 :     if ( !bSelect && !bBasicCall && IsCrsrReadonly() )
     163             :     {
     164           0 :         Point aTmp( VisArea().Pos() );
     165           0 :         aTmp.X() = DOCUMENTBORDER;
     166           0 :         rView.SetVisArea( aTmp );
     167           0 :         return true;
     168             :     }
     169             :     else
     170             :     {
     171           0 :         ShellMoveCrsr aTmp( this, bSelect );
     172           0 :         return SwCrsrShell::LeftMargin();
     173             :     }
     174             : }
     175             : 
     176           0 : bool SwWrtShell::RightMargin( bool bSelect, bool bBasicCall  )
     177             : {
     178           0 :     if ( !bSelect && !bBasicCall && IsCrsrReadonly() )
     179             :     {
     180           0 :         Point aTmp( VisArea().Pos() );
     181           0 :         aTmp.X() = GetDocSize().Width() - VisArea().Width() + DOCUMENTBORDER;
     182           0 :         if( DOCUMENTBORDER > aTmp.X() )
     183           0 :             aTmp.X() = DOCUMENTBORDER;
     184           0 :         rView.SetVisArea( aTmp );
     185           0 :         return true;
     186             :     }
     187             :     else
     188             :     {
     189           0 :         ShellMoveCrsr aTmp( this, bSelect );
     190           0 :         return SwCrsrShell::RightMargin(bBasicCall);
     191             :     }
     192             : }
     193             : 
     194          34 : bool SwWrtShell::GoStart( bool bKeepArea, bool *pMoveTable,
     195             :                           bool bSelect, bool bDontMoveRegion )
     196             : {
     197          34 :     if ( IsCrsrInTbl() )
     198             :     {
     199          14 :         const bool bBoxSelection = HasBoxSelection();
     200          14 :         if( !bBlockMode )
     201             :         {
     202          14 :             if ( !bSelect )
     203          14 :                 EnterStdMode();
     204             :             else
     205           0 :                 SttSelect();
     206             :         }
     207             :             // Table cell ?
     208          26 :         if ( !bBoxSelection && (MoveSection( fnSectionCurr, fnSectionStart)
     209          12 :                 || bDontMoveRegion))
     210             :         {
     211          12 :             if ( pMoveTable )
     212          12 :                 *pMoveTable = false;
     213          12 :             return true;
     214             :         }
     215           2 :         if( MoveTable( fnTableCurr, fnTableStart ) || bDontMoveRegion )
     216             :         {
     217           0 :             if ( pMoveTable )
     218           0 :                 *pMoveTable = true;
     219           0 :             return true;
     220             :         }
     221           2 :         else if( bBoxSelection && pMoveTable )
     222             :         {
     223             :             // JP 09.01.96: We have a box selection (or a empty cell)
     224             :             //              and we want select (pMoveTable will be
     225             :             //              set in SelAll). Then the table must not
     226             :             //              be left, otherwise there is no selection
     227             :             //              of the entire table possible!
     228           2 :             *pMoveTable = true;
     229           2 :             return true;
     230             :         }
     231             :     }
     232             : 
     233          20 :     if( !bBlockMode )
     234             :     {
     235          20 :         if ( !bSelect )
     236          20 :             EnterStdMode();
     237             :         else
     238           0 :             SttSelect();
     239             :     }
     240          20 :     const sal_uInt16 nFrmType = GetFrmType(0,false);
     241          20 :     if ( FRMTYPE_FLY_ANY & nFrmType )
     242             :     {
     243           0 :         if( MoveSection( fnSectionCurr, fnSectionStart ) )
     244           0 :             return true;
     245           0 :         else if ( FRMTYPE_FLY_FREE & nFrmType || bDontMoveRegion )
     246           0 :             return false;
     247             :     }
     248          20 :     if(( FRMTYPE_HEADER | FRMTYPE_FOOTER | FRMTYPE_FOOTNOTE ) & nFrmType )
     249             :     {
     250           0 :         if ( MoveSection( fnSectionCurr, fnSectionStart ) )
     251           0 :             return true;
     252           0 :         else if ( bKeepArea )
     253           0 :             return true;
     254             :     }
     255             :     // Regions ???
     256          40 :     return SwCrsrShell::MoveRegion( fnRegionCurrAndSkip, fnRegionStart ) ||
     257          40 :            SwCrsrShell::SttEndDoc(true);
     258             : }
     259             : 
     260          34 : bool SwWrtShell::GoEnd(bool bKeepArea, bool *pMoveTable)
     261             : {
     262          34 :     if ( pMoveTable && *pMoveTable )
     263           2 :         return MoveTable( fnTableCurr, fnTableEnd );
     264             : 
     265          32 :     if ( IsCrsrInTbl() )
     266             :     {
     267          14 :         if ( MoveSection( fnSectionCurr, fnSectionEnd ) ||
     268           0 :              MoveTable( fnTableCurr, fnTableEnd ) )
     269          14 :             return true;
     270             :     }
     271             :     else
     272             :     {
     273          18 :         const sal_uInt16 nFrmType = GetFrmType(0,false);
     274          18 :         if ( FRMTYPE_FLY_ANY & nFrmType )
     275             :         {
     276           0 :             if ( MoveSection( fnSectionCurr, fnSectionEnd ) )
     277           0 :                 return true;
     278           0 :             else if ( FRMTYPE_FLY_FREE & nFrmType )
     279           0 :                 return false;
     280             :         }
     281          18 :         if(( FRMTYPE_HEADER | FRMTYPE_FOOTER | FRMTYPE_FOOTNOTE ) & nFrmType )
     282             :         {
     283           0 :             if ( MoveSection( fnSectionCurr, fnSectionEnd) )
     284           0 :                 return true;
     285           0 :             else if ( bKeepArea )
     286           0 :                 return true;
     287             :         }
     288             :     }
     289             :     // Regions ???
     290          36 :     return SwCrsrShell::MoveRegion( fnRegionCurrAndSkip, fnRegionEnd ) ||
     291          36 :            SwCrsrShell::SttEndDoc(false);
     292             : }
     293             : 
     294          16 : bool SwWrtShell::SttDoc( bool bSelect )
     295             : {
     296          16 :     ShellMoveCrsr aTmp( this, bSelect );
     297          16 :     return GoStart(false, 0, bSelect );
     298             : }
     299             : 
     300          16 : bool SwWrtShell::EndDoc( bool bSelect)
     301             : {
     302          16 :     ShellMoveCrsr aTmp( this, bSelect );
     303          16 :     return GoEnd();
     304             : }
     305             : 
     306           2 : bool SwWrtShell::SttNxtPg( bool bSelect )
     307             : {
     308           2 :     ShellMoveCrsr aTmp( this, bSelect );
     309           2 :     return MovePage( fnPageNext, fnPageStart );
     310             : }
     311             : 
     312           0 : bool SwWrtShell::SttPrvPg( bool bSelect )
     313             : {
     314           0 :     ShellMoveCrsr aTmp( this, bSelect );
     315           0 :     return MovePage( fnPagePrev, fnPageStart );
     316             : }
     317             : 
     318           0 : bool SwWrtShell::EndNxtPg( bool bSelect )
     319             : {
     320           0 :     ShellMoveCrsr aTmp( this, bSelect );
     321           0 :     return MovePage( fnPageNext, fnPageEnd );
     322             : }
     323             : 
     324           2 : bool SwWrtShell::EndPrvPg( bool bSelect )
     325             : {
     326           2 :     ShellMoveCrsr aTmp( this, bSelect );
     327           2 :     return MovePage( fnPagePrev, fnPageEnd );
     328             : }
     329             : 
     330          64 : bool SwWrtShell::SttPg( bool bSelect )
     331             : {
     332          64 :     ShellMoveCrsr aTmp( this, bSelect );
     333          64 :     return MovePage( fnPageCurr, fnPageStart );
     334             : }
     335             : 
     336           2 : bool SwWrtShell::EndPg( bool bSelect )
     337             : {
     338           2 :     ShellMoveCrsr aTmp( this, bSelect );
     339           2 :     return MovePage( fnPageCurr, fnPageEnd );
     340             : }
     341             : 
     342           0 : bool SwWrtShell::SttPara( bool bSelect )
     343             : {
     344           0 :     ShellMoveCrsr aTmp( this, bSelect );
     345           0 :     return MovePara( fnParaCurr, fnParaStart );
     346             : }
     347             : 
     348           0 : bool SwWrtShell::EndPara( bool bSelect )
     349             : {
     350           0 :     ShellMoveCrsr aTmp( this, bSelect );
     351           0 :     return MovePara(fnParaCurr,fnParaEnd);
     352             : }
     353             : 
     354             : // Column-by-jumping.
     355             : // SSelection with or without
     356             : // returns success or failure
     357             : 
     358           0 : bool SwWrtShell::StartOfColumn( bool bSelect )
     359             : {
     360           0 :     ShellMoveCrsr aTmp( this, bSelect);
     361           0 :     return MoveColumn(fnColumnCurr, fnColumnStart);
     362             : }
     363             : 
     364           0 : bool SwWrtShell::EndOfColumn( bool bSelect )
     365             : {
     366           0 :     ShellMoveCrsr aTmp( this, bSelect);
     367           0 :     return MoveColumn(fnColumnCurr, fnColumnEnd);
     368             : }
     369             : 
     370           0 : bool SwWrtShell::StartOfNextColumn( bool bSelect )
     371             : {
     372           0 :     ShellMoveCrsr aTmp( this, bSelect);
     373           0 :     return MoveColumn( fnColumnNext, fnColumnStart);
     374             : }
     375             : 
     376           0 : bool SwWrtShell::EndOfNextColumn( bool bSelect )
     377             : {
     378           0 :     ShellMoveCrsr aTmp( this, bSelect);
     379           0 :     return MoveColumn(fnColumnNext, fnColumnEnd);
     380             : }
     381             : 
     382           0 : bool SwWrtShell::StartOfPrevColumn( bool bSelect )
     383             : {
     384           0 :     ShellMoveCrsr aTmp( this, bSelect);
     385           0 :     return MoveColumn(fnColumnPrev, fnColumnStart);
     386             : }
     387             : 
     388           0 : bool SwWrtShell::EndOfPrevColumn( bool bSelect )
     389             : {
     390           0 :     ShellMoveCrsr aTmp( this, bSelect);
     391           0 :     return MoveColumn(fnColumnPrev, fnColumnEnd);
     392             : }
     393             : 
     394           0 : bool SwWrtShell::PushCrsr(SwTwips lOffset, bool bSelect)
     395             : {
     396           0 :     bool bDiff = false;
     397           0 :     SwRect aOldRect( GetCharRect() ), aTmpArea( VisArea() );
     398             : 
     399             :     // bDestOnStack indicates if I could not set the coursor at the current
     400             :     // position, because in this region is no content.
     401           0 :     if( !bDestOnStack )
     402             :     {
     403           0 :         Point aPt( aOldRect.Center() );
     404             : 
     405           0 :         if( !IsCrsrVisible() )
     406             :             // set CrsrPos to top-/bottom left pos. So the pagescroll is not
     407             :             // be dependent on the current cursor, but on the visarea.
     408           0 :             aPt.Y() = aTmpArea.Top() + aTmpArea.Height() / 2;
     409             : 
     410           0 :         aPt.Y() += lOffset;
     411           0 :         aDest = GetCntntPos(aPt,lOffset > 0);
     412           0 :         aDest.X() = aPt.X();
     413           0 :         bDestOnStack = true;
     414             :     }
     415             : 
     416             :     // If we had a frame selection, it must be removed after the fnSetCrsr
     417             :     // and we have to remember the position on the stack to return to it later.
     418           0 :     bool bIsFrmSel = false;
     419             : 
     420             :     //Target position is now within the viewable region -->
     421             :     //Place the cursor at the target position; remember that no target
     422             :     //position is longer on the stack.
     423             :     //The new visible region is to be determined beforehand.
     424           0 :     aTmpArea.Pos().Y() += lOffset;
     425           0 :     if( aTmpArea.IsInside(aDest) )
     426             :     {
     427           0 :         if( bSelect )
     428           0 :             SttSelect();
     429             :         else
     430           0 :             EndSelect();
     431             : 
     432           0 :         bIsFrmSel = IsFrmSelected();
     433           0 :         bool bIsObjSel = 0 != IsObjSelected();
     434             : 
     435             :         // unselect frame
     436           0 :         if( bIsFrmSel || bIsObjSel )
     437             :         {
     438           0 :             UnSelectFrm();
     439           0 :             LeaveSelFrmMode();
     440           0 :             if ( bIsObjSel )
     441             :             {
     442           0 :                 GetView().SetDrawFuncPtr( NULL );
     443           0 :                 GetView().LeaveDrawCreate();
     444             :             }
     445             : 
     446           0 :             CallChgLnk();
     447             :         }
     448             : 
     449           0 :         (this->*fnSetCrsr)( &aDest, true );
     450             : 
     451           0 :         bDiff = aOldRect != GetCharRect();
     452             : 
     453           0 :         if( bIsFrmSel )
     454             :         {
     455             :             // In frames take only the upper corner
     456             :             // so that it can be re-selected.
     457           0 :             aOldRect.SSize( 5, 5 );
     458             :         }
     459             : 
     460             :             // reset Dest. SPoint Flags
     461           0 :         bDestOnStack = false;
     462             :     }
     463             : 
     464             :     // Position into the stack; bDiff indicates if there is a
     465             :     // difference between the old and the new cursor position.
     466             :     pCrsrStack = new CrsrStack( bDiff, bIsFrmSel, aOldRect.Center(),
     467           0 :                                 lOffset, pCrsrStack );
     468           0 :     return !bDestOnStack && bDiff;
     469             : }
     470             : 
     471        4706 : bool SwWrtShell::PopCrsr(bool bUpdate, bool bSelect)
     472             : {
     473        4706 :     if( 0 == pCrsrStack)
     474        4706 :         return false;
     475             : 
     476           0 :     const bool bValidPos = pCrsrStack->bValidCurPos;
     477           0 :     if( bUpdate && bValidPos )
     478             :     {
     479             :             // If a predecessor is on the stack,
     480             :             // use the flag for a valid position.
     481           0 :         SwRect aTmpArea(VisArea());
     482           0 :         aTmpArea.Pos().Y() -= pCrsrStack->lOffset;
     483           0 :         if( aTmpArea.IsInside( pCrsrStack->aDocPos ) )
     484             :         {
     485           0 :             if( bSelect )
     486           0 :                 SttSelect();
     487             :             else
     488           0 :                 EndSelect();
     489             : 
     490           0 :             (this->*fnSetCrsr)(&pCrsrStack->aDocPos, !pCrsrStack->bIsFrmSel);
     491           0 :             if( pCrsrStack->bIsFrmSel && IsObjSelectable(pCrsrStack->aDocPos))
     492             :             {
     493           0 :                 HideCrsr();
     494           0 :                 SelectObj( pCrsrStack->aDocPos );
     495           0 :                 EnterSelFrmMode( &pCrsrStack->aDocPos );
     496             :             }
     497             :         }
     498             :             // If a discrepancy between the visible range and the
     499             :             // remembered cursor position occurs, all of the remembered
     500             :             // positions are thrown away.
     501             :         else
     502             :         {
     503           0 :             _ResetCursorStack();
     504           0 :             return false;
     505             :         }
     506             :     }
     507           0 :     CrsrStack *pTmp = pCrsrStack;
     508           0 :     pCrsrStack = pCrsrStack->pNext;
     509           0 :     delete pTmp;
     510           0 :     if( 0 == pCrsrStack )
     511             :     {
     512           0 :         ePageMove = MV_NO;
     513           0 :         bDestOnStack = false;
     514             :     }
     515           0 :     return bValidPos;
     516             : }
     517             : 
     518             : // Reset of all pushed cursor positions; these will
     519             : // not be displayed ( --> No Start-/EndAction!!)
     520             : 
     521           0 : void SwWrtShell::_ResetCursorStack()
     522             : {
     523           0 :     CrsrStack *pTmp = pCrsrStack;
     524           0 :     while(pCrsrStack)
     525             :     {
     526           0 :         pTmp = pCrsrStack->pNext;
     527           0 :         delete pCrsrStack;
     528           0 :         pCrsrStack = pTmp;
     529             :     }
     530           0 :     ePageMove = MV_NO;
     531           0 :     bDestOnStack = false;
     532           0 : }
     533             : /**
     534             :     if no stack exists --> cancel selection
     535             :     if stack && change of direction
     536             :         --> pop cursor and return
     537             :     else
     538             :         --> push cursor
     539             :             transpose cursor
     540             : */
     541             : 
     542           0 : bool SwWrtShell::PageCrsr(SwTwips lOffset, bool bSelect)
     543             : {
     544             :     // Do nothing if an offset of 0 was indicated
     545           0 :     if(!lOffset) return false;
     546             :         // Was once used to force a reformat of the layout.
     547             :         // This has not work that way, because the cursor was not set
     548             :         // because this does not happen within a
     549             :         // Start-/EndActionParentheses.
     550             :         // Because only SwViewShell::EndAction() is called at the end,
     551             :         // no updating of the display of the cursor position takes place.
     552             :         // The CrsrShell-Actionparentheses cannot be used, because it
     553             :         // always leads to displaying the cursor, thus also,
     554             :         // if after the scroll scrolled in a region without a valid postition.
     555             :         // SwViewShell::StartAction();
     556           0 :     PageMove eDir = lOffset > 0? MV_PAGE_DOWN: MV_PAGE_UP;
     557             :         // Change of direction and stack present
     558           0 :     if( eDir != ePageMove && ePageMove != MV_NO && PopCrsr( true, bSelect ))
     559           0 :         return true;
     560             : 
     561           0 :     const bool bRet = PushCrsr(lOffset, bSelect);
     562           0 :     ePageMove = eDir;
     563           0 :     return bRet;
     564             : }
     565             : 
     566           6 : bool SwWrtShell::GotoPage(sal_uInt16 nPage, bool bRecord)
     567             : {
     568           6 :     ShellMoveCrsr aTmp( this, false);
     569           6 :     if( SwCrsrShell::GotoPage(nPage) && bRecord)
     570             :     {
     571           6 :         if(IsSelFrmMode())
     572             :         {
     573           0 :             UnSelectFrm();
     574           0 :             LeaveSelFrmMode();
     575             :         }
     576           6 :         return true;
     577             :     }
     578           0 :     return false;
     579             : }
     580             : 
     581           0 : bool SwWrtShell::GotoMark( const ::sw::mark::IMark* const pMark, bool bSelect, bool bStart )
     582             : {
     583           0 :     ShellMoveCrsr aTmp( this, bSelect );
     584           0 :     SwPosition aPos = *GetCrsr()->GetPoint();
     585           0 :     bool bRet = SwCrsrShell::GotoMark( pMark, bStart );
     586           0 :     if (bRet)
     587           0 :         aNavigationMgr.addEntry(aPos);
     588           0 :     return bRet;
     589             : }
     590             : 
     591           0 : bool SwWrtShell::GotoFly( const OUString& rName, FlyCntType eType, bool bSelFrame )
     592             : {
     593           0 :     SwPosition aPos = *GetCrsr()->GetPoint();
     594           0 :     bool bRet = SwFEShell::GotoFly(rName, eType, bSelFrame);
     595           0 :     if (bRet)
     596           0 :         aNavigationMgr.addEntry(aPos);
     597           0 :     return bRet;
     598             : }
     599             : 
     600           0 : bool SwWrtShell::GotoINetAttr( const SwTxtINetFmt& rAttr )
     601             : {
     602           0 :     SwPosition aPos = *GetCrsr()->GetPoint();
     603           0 :     bool bRet = SwCrsrShell::GotoINetAttr(rAttr);
     604           0 :     if (bRet)
     605           0 :         aNavigationMgr.addEntry(aPos);
     606           0 :     return bRet;
     607             : }
     608             : 
     609           0 : void SwWrtShell::GotoOutline( sal_uInt16 nIdx )
     610             : {
     611           0 :     addCurrentPosition();
     612           0 :     SwCrsrShell::GotoOutline (nIdx);
     613           0 : }
     614             : 
     615           0 : bool SwWrtShell::GotoOutline( const OUString& rName )
     616             : {
     617           0 :     SwPosition aPos = *GetCrsr()->GetPoint();
     618           0 :     bool bRet = SwCrsrShell::GotoOutline (rName);
     619           0 :     if (bRet)
     620           0 :         aNavigationMgr.addEntry(aPos);
     621           0 :     return bRet;
     622             : }
     623             : 
     624           0 : bool SwWrtShell::GotoRegion( const OUString& rName )
     625             : {
     626           0 :     SwPosition aPos = *GetCrsr()->GetPoint();
     627           0 :     bool bRet = SwCrsrShell::GotoRegion (rName);
     628           0 :     if (bRet)
     629           0 :         aNavigationMgr.addEntry(aPos);
     630           0 :     return bRet;
     631             :  }
     632             : 
     633           0 : bool SwWrtShell::GotoRefMark( const OUString& rRefMark, sal_uInt16 nSubType,
     634             :                                     sal_uInt16 nSeqNo )
     635             : {
     636           0 :     SwPosition aPos = *GetCrsr()->GetPoint();
     637           0 :     bool bRet = SwCrsrShell::GotoRefMark(rRefMark, nSubType, nSeqNo);
     638           0 :     if (bRet)
     639           0 :         aNavigationMgr.addEntry(aPos);
     640           0 :     return bRet;
     641             : }
     642             : 
     643           0 : bool SwWrtShell::GotoNextTOXBase( const OUString* pName )
     644             : {
     645           0 :     SwPosition aPos = *GetCrsr()->GetPoint();
     646           0 :     bool bRet = SwCrsrShell::GotoNextTOXBase(pName);
     647           0 :     if (bRet)
     648           0 :         aNavigationMgr.addEntry(aPos);
     649           0 :     return bRet;
     650             : }
     651             : 
     652          18 : bool SwWrtShell::GotoTable( const OUString& rName )
     653             : {
     654          18 :    SwPosition aPos = *GetCrsr()->GetPoint();
     655          18 :     bool bRet = SwCrsrShell::GotoTable(rName);
     656          18 :     if (bRet)
     657          18 :         aNavigationMgr.addEntry(aPos);
     658          18 :     return bRet;
     659             : }
     660             : 
     661           0 : bool SwWrtShell::GotoFld( const SwFmtFld& rFld ) {
     662           0 :     SwPosition aPos = *GetCrsr()->GetPoint();
     663           0 :     bool bRet = SwCrsrShell::GotoFld(rFld);
     664           0 :     if (bRet)
     665           0 :         aNavigationMgr.addEntry(aPos);
     666           0 :     return bRet;
     667             : }
     668             : 
     669           0 : const SwRangeRedline* SwWrtShell::GotoRedline( sal_uInt16 nArrPos, bool bSelect ) {
     670           0 :     SwPosition aPos = *GetCrsr()->GetPoint();
     671           0 :     const SwRangeRedline *pRedline = SwCrsrShell::GotoRedline(nArrPos, bSelect);
     672           0 :     if (pRedline)
     673           0 :         aNavigationMgr.addEntry(aPos);
     674           0 :     return pRedline;
     675             : }
     676             : 
     677           0 : bool SwWrtShell::SelectTxtAttr( sal_uInt16 nWhich, const SwTxtAttr* pAttr )
     678             : {
     679             :     bool bRet;
     680             :     {
     681           0 :         SwMvContext aMvContext(this);
     682           0 :         SttSelect();
     683           0 :         bRet = SwCrsrShell::SelectTxtAttr( nWhich, false, pAttr );
     684             :     }
     685           0 :     EndSelect();
     686           0 :     return bRet;
     687         270 : }
     688             : 
     689             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10