LCOV - code coverage report
Current view: top level - sw/source/core/crsr - crstrvl.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1211 0.0 %
Date: 2014-04-14 Functions: 0 46 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 <hintids.hxx>
      21             : #include <comphelper/string.hxx>
      22             : #include <svl/itemiter.hxx>
      23             : #include <editeng/lrspitem.hxx>
      24             : #include <editeng/adjustitem.hxx>
      25             : #include <editeng/formatbreakitem.hxx>
      26             : #include <svx/svdobj.hxx>
      27             : #include <crsrsh.hxx>
      28             : #include <doc.hxx>
      29             : #include <IDocumentUndoRedo.hxx>
      30             : #include <pagefrm.hxx>
      31             : #include <cntfrm.hxx>
      32             : #include <rootfrm.hxx>
      33             : #include <pam.hxx>
      34             : #include <ndtxt.hxx>
      35             : #include <fldbas.hxx>
      36             : #include <swtable.hxx>
      37             : #include <docary.hxx>
      38             : #include <txtfld.hxx>
      39             : #include <fmtfld.hxx>
      40             : #include <txtftn.hxx>
      41             : #include <txtinet.hxx>
      42             : #include <fmtinfmt.hxx>
      43             : #include <txttxmrk.hxx>
      44             : #include <frmfmt.hxx>
      45             : #include <flyfrm.hxx>
      46             : #include <viscrs.hxx>
      47             : #include <callnk.hxx>
      48             : #include <doctxm.hxx>
      49             : #include <docfld.hxx>
      50             : #include <expfld.hxx>
      51             : #include <reffld.hxx>
      52             : #include <flddat.hxx>
      53             : #include <cellatr.hxx>
      54             : #include <swundo.hxx>
      55             : #include <redline.hxx>
      56             : #include <fmtcntnt.hxx>
      57             : #include <fmthdft.hxx>
      58             : #include <pagedesc.hxx>
      59             : #include <fesh.hxx>
      60             : #include <charfmt.hxx>
      61             : #include <fmturl.hxx>
      62             : #include "txtfrm.hxx"
      63             : #include <wrong.hxx>
      64             : #include <switerator.hxx>
      65             : #include <vcl/window.hxx>
      66             : #include <docufld.hxx>
      67             : 
      68             : using namespace ::com::sun::star;
      69             : 
      70           0 : void SwCrsrShell::MoveCrsrToNum()
      71             : {
      72           0 :     SwCallLink aLk( *this ); // watch Crsr-Moves
      73           0 :     SwCrsrSaveState aSaveState( *m_pCurCrsr );
      74           0 :     if( ActionPend() )
      75           0 :         return;
      76           0 :     SET_CURR_SHELL( this );
      77             :     // try to set cursor onto this position, at half of the char-
      78             :     // SRectangle's height
      79           0 :     Point aPt( m_pCurCrsr->GetPtPos() );
      80           0 :     SwCntntFrm * pFrm = m_pCurCrsr->GetCntntNode()->getLayoutFrm( GetLayout(), &aPt,
      81           0 :                                                 m_pCurCrsr->GetPoint() );
      82           0 :     pFrm->GetCharRect( m_aCharRect, *m_pCurCrsr->GetPoint() );
      83           0 :     pFrm->Calc();
      84           0 :     if( pFrm->IsVertical() )
      85             :     {
      86           0 :         aPt.setX(m_aCharRect.Center().getX());
      87           0 :         aPt.setY(pFrm->Frm().Top() + m_nUpDownX);
      88             :     }
      89             :     else
      90             :     {
      91           0 :         aPt.setY(m_aCharRect.Center().getY());
      92           0 :         aPt.setX(pFrm->Frm().Left() + m_nUpDownX);
      93             :     }
      94           0 :     pFrm->GetCrsrOfst( m_pCurCrsr->GetPoint(), aPt );
      95           0 :     if ( !m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_TOGGLE |
      96           0 :                                 nsSwCursorSelOverFlags::SELOVER_CHANGEPOS ))
      97             :     {
      98             :         UpdateCrsr(SwCrsrShell::UPDOWN |
      99             :                 SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
     100           0 :                 SwCrsrShell::READONLY );
     101           0 :     }
     102             : }
     103             : 
     104             : /// go to next/previous point on the same level
     105           0 : bool SwCrsrShell::GotoNextNum()
     106             : {
     107           0 :     if (!GetDoc()->GotoNextNum( *m_pCurCrsr->GetPoint() ))
     108           0 :         return false;
     109           0 :     MoveCrsrToNum();
     110           0 :     return true;
     111             : }
     112             : 
     113           0 : bool SwCrsrShell::GotoPrevNum()
     114             : {
     115           0 :     if (!GetDoc()->GotoPrevNum( *m_pCurCrsr->GetPoint() ))
     116           0 :         return false;
     117           0 :     MoveCrsrToNum();
     118           0 :     return true;
     119             : }
     120             : 
     121             : /// jump from content to header
     122           0 : sal_Bool SwCrsrShell::GotoHeaderTxt()
     123             : {
     124           0 :     const SwFrm* pFrm = GetCurrFrm()->FindPageFrm();
     125           0 :     while( pFrm && !pFrm->IsHeaderFrm() )
     126           0 :         pFrm = pFrm->GetLower();
     127             :     // found header, search 1. content frame
     128           0 :     while( pFrm && !pFrm->IsCntntFrm() )
     129           0 :         pFrm = pFrm->GetLower();
     130             : 
     131           0 :     if( pFrm )
     132             :     {
     133           0 :         SET_CURR_SHELL( this );
     134             :         // get header frame
     135           0 :         SwCallLink aLk( *this ); // watch Crsr-Moves
     136           0 :         SwCursor *pTmpCrsr = getShellCrsr( true );
     137           0 :         SwCrsrSaveState aSaveState( *pTmpCrsr );
     138           0 :         pFrm->Calc();
     139           0 :         Point aPt( pFrm->Frm().Pos() + pFrm->Prt().Pos() );
     140           0 :         pFrm->GetCrsrOfst( pTmpCrsr->GetPoint(), aPt );
     141           0 :         if( !pTmpCrsr->IsSelOvr() )
     142           0 :             UpdateCrsr();
     143             :         else
     144           0 :             pFrm = 0;
     145             :     }
     146           0 :     return 0 != pFrm;
     147             : }
     148             : 
     149             : /// jump from content to footer
     150           0 : sal_Bool SwCrsrShell::GotoFooterTxt()
     151             : {
     152           0 :     const SwPageFrm* pFrm = GetCurrFrm()->FindPageFrm();
     153           0 :     if( pFrm )
     154             :     {
     155           0 :         const SwFrm* pLower = pFrm->GetLastLower();
     156             : 
     157           0 :         while( pLower && !pLower->IsFooterFrm() )
     158           0 :             pLower = pLower->GetLower();
     159             :         // found footer, search 1. content frame
     160           0 :         while( pLower && !pLower->IsCntntFrm() )
     161           0 :             pLower = pLower->GetLower();
     162             : 
     163           0 :         if( pLower )
     164             :         {
     165           0 :             SwCursor *pTmpCrsr = getShellCrsr( true );
     166           0 :             SET_CURR_SHELL( this );
     167             :             // get position in footer
     168           0 :             SwCallLink aLk( *this ); // watch Crsr-Moves
     169           0 :             SwCrsrSaveState aSaveState( *pTmpCrsr );
     170           0 :             pLower->Calc();
     171           0 :             Point aPt( pLower->Frm().Pos() + pLower->Prt().Pos() );
     172           0 :             pLower->GetCrsrOfst( pTmpCrsr->GetPoint(), aPt );
     173           0 :             if( !pTmpCrsr->IsSelOvr() )
     174           0 :                 UpdateCrsr();
     175             :             else
     176           0 :                 pFrm = 0;
     177             :         }
     178             :         else
     179           0 :             pFrm = 0;
     180             :     }
     181             :     else
     182           0 :         pFrm = 0;
     183           0 :     return 0 != pFrm;
     184             : }
     185             : 
     186           0 : sal_Bool SwCrsrShell::SetCrsrInHdFt( sal_uInt16 nDescNo, sal_Bool bInHeader )
     187             : {
     188           0 :     sal_Bool bRet = sal_False;
     189           0 :     SwDoc *pMyDoc = GetDoc();
     190             : 
     191           0 :     SET_CURR_SHELL( this );
     192             : 
     193           0 :     if( USHRT_MAX == nDescNo )
     194             :     {
     195             :         // take the current one
     196           0 :         const SwPageFrm* pPage = GetCurrFrm()->FindPageFrm();
     197           0 :         if( pPage )
     198           0 :             for( sal_uInt16 i = 0; i < pMyDoc->GetPageDescCnt(); ++i )
     199           0 :                 if( pPage->GetPageDesc() == &pMyDoc->GetPageDesc( i ) )
     200             :                 {
     201           0 :                     nDescNo = i;
     202           0 :                     break;
     203             :                 }
     204             :     }
     205             : 
     206           0 :     if( USHRT_MAX != nDescNo && nDescNo < pMyDoc->GetPageDescCnt() )
     207             :     {
     208             :         // check if the attribute exists
     209             :         const SwPageDesc& rDesc = const_cast<const SwDoc *>(pMyDoc)
     210           0 :             ->GetPageDesc( nDescNo );
     211           0 :         const SwFmtCntnt* pCnt = 0;
     212           0 :         if( bInHeader )
     213             :         {
     214             :             // mirrored pages? ignore for now
     215           0 :             const SwFmtHeader& rHd = rDesc.GetMaster().GetHeader();
     216           0 :             if( rHd.GetHeaderFmt() )
     217           0 :                 pCnt = &rHd.GetHeaderFmt()->GetCntnt();
     218             :         }
     219             :         else
     220             :         {
     221           0 :             const SwFmtFooter& rFt = rDesc.GetMaster().GetFooter();
     222           0 :             if( rFt.GetFooterFmt() )
     223           0 :                 pCnt = &rFt.GetFooterFmt()->GetCntnt();
     224             :         }
     225             : 
     226           0 :         if( pCnt && pCnt->GetCntntIdx() )
     227             :         {
     228           0 :             SwNodeIndex aIdx( *pCnt->GetCntntIdx(), 1 );
     229           0 :             SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
     230           0 :             if( !pCNd )
     231           0 :                 pCNd = pMyDoc->GetNodes().GoNext( &aIdx );
     232             : 
     233           0 :             Point aPt( m_pCurCrsr->GetPtPos() );
     234             : 
     235           0 :             if( pCNd && 0 != pCNd->getLayoutFrm( GetLayout(), &aPt, 0, false ) )
     236             :             {
     237             :                 // then we can set the cursor in here
     238           0 :                 SwCallLink aLk( *this ); // watch Crsr-Moves
     239           0 :                 SwCrsrSaveState aSaveState( *m_pCurCrsr );
     240             : 
     241           0 :                 ClearMark();
     242             : 
     243           0 :                 SwPosition& rPos = *m_pCurCrsr->GetPoint();
     244           0 :                 rPos.nNode = *pCNd;
     245           0 :                 rPos.nContent.Assign( pCNd, 0 );
     246             : 
     247           0 :                 bRet = !m_pCurCrsr->IsSelOvr();
     248           0 :                 if( bRet )
     249             :                     UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
     250           0 :                                 SwCrsrShell::READONLY );
     251           0 :             }
     252             :         }
     253             :     }
     254           0 :     return bRet;
     255             : }
     256             : 
     257             : /// jump to the next index
     258           0 : sal_Bool SwCrsrShell::GotoNextTOXBase( const OUString* pName )
     259             : {
     260           0 :     sal_Bool bRet = sal_False;
     261             : 
     262           0 :     const SwSectionFmts& rFmts = GetDoc()->GetSections();
     263           0 :     SwCntntNode* pFnd = 0;
     264           0 :     for( sal_uInt16 n = rFmts.size(); n; )
     265             :     {
     266           0 :         const SwSection* pSect = rFmts[ --n ]->GetSection();
     267           0 :         if (TOX_CONTENT_SECTION == pSect->GetType())
     268             :         {
     269             :             SwSectionNode const*const pSectNd(
     270           0 :                     pSect->GetFmt()->GetSectionNode());
     271           0 :             if (   pSectNd
     272           0 :                 && m_pCurCrsr->GetPoint()->nNode < pSectNd->GetIndex()
     273           0 :                 && (!pFnd  || pFnd->GetIndex() > pSectNd->GetIndex())
     274           0 :                 && (!pName || *pName ==
     275           0 :                     static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName()))
     276             :             {
     277           0 :                 SwNodeIndex aIdx(*pSectNd, 1);
     278           0 :                 SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
     279           0 :                 if (!pCNd)
     280           0 :                     pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
     281           0 :                 if (pCNd &&
     282           0 :                     pCNd->EndOfSectionIndex() <= pSectNd->EndOfSectionIndex())
     283             :                 {
     284             :                     SwCntntFrm const*const pCFrm(
     285           0 :                             pCNd->getLayoutFrm(GetLayout()));
     286           0 :                     if (pCFrm &&
     287           0 :                         (IsReadOnlyAvailable() || !pCFrm->IsProtected()))
     288             :                     {
     289           0 :                         pFnd = pCNd;
     290             :                     }
     291           0 :                 }
     292             :             }
     293             :         }
     294             :     }
     295           0 :     if( pFnd )
     296             :     {
     297           0 :         SwCallLink aLk( *this ); // watch Crsr-Moves
     298           0 :         SwCrsrSaveState aSaveState( *m_pCurCrsr );
     299           0 :         m_pCurCrsr->GetPoint()->nNode = *pFnd;
     300           0 :         m_pCurCrsr->GetPoint()->nContent.Assign( pFnd, 0 );
     301           0 :         bRet = !m_pCurCrsr->IsSelOvr();
     302           0 :         if( bRet )
     303           0 :             UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
     304             :     }
     305           0 :     return bRet;
     306             : }
     307             : 
     308             : /// jump to previous index
     309           0 : sal_Bool SwCrsrShell::GotoPrevTOXBase( const OUString* pName )
     310             : {
     311           0 :     sal_Bool bRet = sal_False;
     312             : 
     313           0 :     const SwSectionFmts& rFmts = GetDoc()->GetSections();
     314           0 :     SwCntntNode* pFnd = 0;
     315           0 :     for( sal_uInt16 n = rFmts.size(); n; )
     316             :     {
     317           0 :         const SwSection* pSect = rFmts[ --n ]->GetSection();
     318           0 :         if (TOX_CONTENT_SECTION == pSect->GetType())
     319             :         {
     320             :             SwSectionNode const*const pSectNd(
     321           0 :                     pSect->GetFmt()->GetSectionNode());
     322           0 :             if (   pSectNd
     323           0 :                 && m_pCurCrsr->GetPoint()->nNode > pSectNd->EndOfSectionIndex()
     324           0 :                 && (!pFnd  || pFnd->GetIndex() < pSectNd->GetIndex())
     325           0 :                 && (!pName || *pName ==
     326           0 :                     static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName()))
     327             :             {
     328           0 :                 SwNodeIndex aIdx(*pSectNd, 1);
     329           0 :                 SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
     330           0 :                 if (!pCNd)
     331           0 :                     pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
     332           0 :                 if (pCNd &&
     333           0 :                     pCNd->EndOfSectionIndex() <= pSectNd->EndOfSectionIndex())
     334             :                 {
     335             :                     SwCntntFrm const*const pCFrm(
     336           0 :                             pCNd->getLayoutFrm(GetLayout()));
     337           0 :                     if (pCFrm &&
     338           0 :                         (IsReadOnlyAvailable() || !pCFrm->IsProtected()))
     339             :                     {
     340           0 :                         pFnd = pCNd;
     341             :                     }
     342           0 :                 }
     343             :             }
     344             :         }
     345             :     }
     346             : 
     347           0 :     if( pFnd )
     348             :     {
     349           0 :         SwCallLink aLk( *this ); // watch Crsr-Moves
     350           0 :         SwCrsrSaveState aSaveState( *m_pCurCrsr );
     351           0 :         m_pCurCrsr->GetPoint()->nNode = *pFnd;
     352           0 :         m_pCurCrsr->GetPoint()->nContent.Assign( pFnd, 0 );
     353           0 :         bRet = !m_pCurCrsr->IsSelOvr();
     354           0 :         if( bRet )
     355           0 :             UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
     356             :     }
     357           0 :     return bRet;
     358             : }
     359             : 
     360             : /// jump to index of TOXMark
     361           0 : sal_Bool SwCrsrShell::GotoTOXMarkBase()
     362             : {
     363           0 :     sal_Bool bRet = sal_False;
     364             : 
     365           0 :     SwTOXMarks aMarks;
     366           0 :     sal_uInt16 nCnt = GetDoc()->GetCurTOXMark( *m_pCurCrsr->GetPoint(), aMarks );
     367           0 :     if( nCnt )
     368             :     {
     369             :         // Take the 1. and get the index type. Search in its dependency list
     370             :         // for the actual index
     371           0 :         const SwTOXType* pType = aMarks[0]->GetTOXType();
     372           0 :         SwIterator<SwTOXBase,SwTOXType> aIter( *pType );
     373             :         const SwSectionNode* pSectNd;
     374             :         const SwSectionFmt* pSectFmt;
     375             : 
     376           0 :         for( SwTOXBase* pTOX = aIter.First(); pTOX; pTOX = aIter.Next() )
     377             :         {
     378           0 :             if( pTOX->ISA( SwTOXBaseSection ) &&
     379           0 :                 0 != ( pSectFmt = ((SwTOXBaseSection*)pTOX)->GetFmt() ) &&
     380             :                 0 != ( pSectNd = pSectFmt->GetSectionNode() ))
     381             :             {
     382           0 :                 SwNodeIndex aIdx( *pSectNd, 1 );
     383           0 :                 SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
     384           0 :                 if( !pCNd )
     385           0 :                     pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
     386             :                 const SwCntntFrm* pCFrm;
     387           0 :                 if( pCNd &&
     388           0 :                     pCNd->EndOfSectionIndex() < pSectNd->EndOfSectionIndex() &&
     389           0 :                     0 != ( pCFrm = pCNd->getLayoutFrm( GetLayout() ) ) &&
     390           0 :                     ( IsReadOnlyAvailable() || !pCFrm->IsProtected() ))
     391             :                 {
     392           0 :                     SwCallLink aLk( *this ); // watch Crsr-Moves
     393           0 :                     SwCrsrSaveState aSaveState( *m_pCurCrsr );
     394           0 :                     m_pCurCrsr->GetPoint()->nNode = *pCNd;
     395           0 :                     m_pCurCrsr->GetPoint()->nContent.Assign( pCNd, 0 );
     396           0 :                     bRet = !m_pCurCrsr->IsInProtectTable() &&
     397           0 :                             !m_pCurCrsr->IsSelOvr();
     398           0 :                     if( bRet )
     399           0 :                         UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
     400           0 :                     break;
     401           0 :                 }
     402             :             }
     403           0 :     }
     404             :     }
     405           0 :     return bRet;
     406             : }
     407             : 
     408             : /// Jump to next/previous table formula
     409             : /// Optionally it is possible to also jump to broken formulas
     410           0 : sal_Bool SwCrsrShell::GotoNxtPrvTblFormula( sal_Bool bNext, sal_Bool bOnlyErrors )
     411             : {
     412           0 :     if( IsTableMode() )
     413           0 :         return sal_False;
     414             : 
     415           0 :     sal_Bool bFnd = sal_False;
     416           0 :     SwPosition& rPos = *m_pCurCrsr->GetPoint();
     417             : 
     418           0 :     Point aPt;
     419           0 :     SwPosition aFndPos( GetDoc()->GetNodes().GetEndOfContent() );
     420           0 :     if( !bNext )
     421           0 :         aFndPos.nNode = 0;
     422           0 :     _SetGetExpFld aFndGEF( aFndPos ), aCurGEF( rPos );
     423             : 
     424             :     {
     425           0 :         const SwNode* pSttNd = rPos.nNode.GetNode().FindTableBoxStartNode();
     426           0 :         if( pSttNd )
     427             :         {
     428           0 :             const SwTableBox* pTBox = pSttNd->FindTableNode()->GetTable().
     429           0 :                                         GetTblBox( pSttNd->GetIndex() );
     430           0 :             if( pTBox )
     431           0 :                 aCurGEF = _SetGetExpFld( *pTBox );
     432             :         }
     433             :     }
     434             : 
     435           0 :     if( rPos.nNode < GetDoc()->GetNodes().GetEndOfExtras() )
     436             :         // also at collection use only the first frame
     437           0 :         aCurGEF.SetBodyPos( *rPos.nNode.GetNode().GetCntntNode()->getLayoutFrm( GetLayout(),
     438           0 :                                 &aPt, &rPos, false ) );
     439             :     {
     440             :         const SfxPoolItem* pItem;
     441             :         const SwTableBox* pTBox;
     442           0 :         sal_uInt32 n, nMaxItems = GetDoc()->GetAttrPool().GetItemCount2( RES_BOXATR_FORMULA );
     443             : 
     444           0 :         for( n = 0; n < nMaxItems; ++n )
     445           0 :             if( 0 != (pItem = GetDoc()->GetAttrPool().GetItem2(
     446           0 :                                         RES_BOXATR_FORMULA, n ) ) &&
     447           0 :                 0 != (pTBox = ((SwTblBoxFormula*)pItem)->GetTableBox() ) &&
     448           0 :                 pTBox->GetSttNd() &&
     449           0 :                 pTBox->GetSttNd()->GetNodes().IsDocNodes() &&
     450           0 :                 ( !bOnlyErrors ||
     451           0 :                   !((SwTblBoxFormula*)pItem)->HasValidBoxes() ) )
     452             :             {
     453             :                 const SwCntntFrm* pCFrm;
     454           0 :                 SwNodeIndex aIdx( *pTBox->GetSttNd() );
     455           0 :                 const SwCntntNode* pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
     456           0 :                 if( pCNd && 0 != ( pCFrm = pCNd->getLayoutFrm( GetLayout(), &aPt, 0, false ) ) &&
     457           0 :                     (IsReadOnlyAvailable() || !pCFrm->IsProtected() ))
     458             :                 {
     459           0 :                     _SetGetExpFld aCmp( *pTBox );
     460           0 :                     aCmp.SetBodyPos( *pCFrm );
     461             : 
     462           0 :                     if( bNext ? ( aCurGEF < aCmp && aCmp < aFndGEF )
     463           0 :                               : ( aCmp < aCurGEF && aFndGEF < aCmp ))
     464             :                     {
     465           0 :                         aFndGEF = aCmp;
     466           0 :                         bFnd = sal_True;
     467             :                     }
     468           0 :                 }
     469             :             }
     470             :     }
     471             : 
     472           0 :     if( bFnd )
     473             :     {
     474           0 :         SET_CURR_SHELL( this );
     475           0 :         SwCallLink aLk( *this ); // watch Crsr-Moves
     476           0 :         SwCrsrSaveState aSaveState( *m_pCurCrsr );
     477             : 
     478           0 :         aFndGEF.GetPosOfContent( rPos );
     479           0 :         m_pCurCrsr->DeleteMark();
     480             : 
     481           0 :         bFnd = !m_pCurCrsr->IsSelOvr();
     482           0 :         if( bFnd )
     483             :             UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
     484           0 :                         SwCrsrShell::READONLY );
     485             :     }
     486           0 :     return bFnd;
     487             : }
     488             : 
     489             : /// jump to next/previous index marker
     490           0 : sal_Bool SwCrsrShell::GotoNxtPrvTOXMark( sal_Bool bNext )
     491             : {
     492           0 :     if( IsTableMode() )
     493           0 :         return sal_False;
     494             : 
     495           0 :     sal_Bool bFnd = sal_False;
     496           0 :     SwPosition& rPos = *m_pCurCrsr->GetPoint();
     497             : 
     498           0 :     Point aPt;
     499           0 :     SwPosition aFndPos( GetDoc()->GetNodes().GetEndOfContent() );
     500           0 :     if( !bNext )
     501           0 :         aFndPos.nNode = 0;
     502           0 :     _SetGetExpFld aFndGEF( aFndPos ), aCurGEF( rPos );
     503             : 
     504           0 :     if( rPos.nNode.GetIndex() < GetDoc()->GetNodes().GetEndOfExtras().GetIndex() )
     505             :         // also at collection use only the first frame
     506           0 :         aCurGEF.SetBodyPos( *rPos.nNode.GetNode().
     507           0 :                         GetCntntNode()->getLayoutFrm( GetLayout(), &aPt, &rPos, false ) );
     508             : 
     509             :     {
     510             :         const SfxPoolItem* pItem;
     511             :         const SwCntntFrm* pCFrm;
     512             :         const SwTxtNode* pTxtNd;
     513             :         const SwTxtTOXMark* pTxtTOX;
     514           0 :         sal_uInt32 n, nMaxItems = GetDoc()->GetAttrPool().GetItemCount2( RES_TXTATR_TOXMARK );
     515             : 
     516           0 :         for( n = 0; n < nMaxItems; ++n )
     517           0 :             if( 0 != (pItem = GetDoc()->GetAttrPool().GetItem2(
     518           0 :                                         RES_TXTATR_TOXMARK, n ) ) &&
     519           0 :                 0 != (pTxtTOX = ((SwTOXMark*)pItem)->GetTxtTOXMark() ) &&
     520           0 :                 ( pTxtNd = &pTxtTOX->GetTxtNode())->GetNodes().IsDocNodes() &&
     521           0 :                 0 != ( pCFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt, 0, false )) &&
     522           0 :                 ( IsReadOnlyAvailable() || !pCFrm->IsProtected() ))
     523             :             {
     524           0 :                 SwNodeIndex aNdIndex( *pTxtNd ); // UNIX needs this object
     525           0 :                 _SetGetExpFld aCmp( aNdIndex, *pTxtTOX, 0 );
     526           0 :                 aCmp.SetBodyPos( *pCFrm );
     527             : 
     528           0 :                 if( bNext ? ( aCurGEF < aCmp && aCmp < aFndGEF )
     529           0 :                           : ( aCmp < aCurGEF && aFndGEF < aCmp ))
     530             :                 {
     531           0 :                     aFndGEF = aCmp;
     532           0 :                     bFnd = sal_True;
     533           0 :                 }
     534             :             }
     535             :     }
     536             : 
     537           0 :     if( bFnd )
     538             :     {
     539           0 :         SET_CURR_SHELL( this );
     540           0 :         SwCallLink aLk( *this ); // watch Crsr-Moves
     541           0 :         SwCrsrSaveState aSaveState( *m_pCurCrsr );
     542             : 
     543           0 :         aFndGEF.GetPosOfContent( rPos );
     544             : 
     545           0 :         bFnd = !m_pCurCrsr->IsSelOvr();
     546           0 :         if( bFnd )
     547             :             UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
     548           0 :                         SwCrsrShell::READONLY );
     549             :     }
     550           0 :     return bFnd;
     551             : }
     552             : 
     553             : /// traveling between marks
     554           0 : const SwTOXMark& SwCrsrShell::GotoTOXMark( const SwTOXMark& rStart,
     555             :                                             SwTOXSearch eDir )
     556             : {
     557           0 :     SET_CURR_SHELL( this );
     558           0 :     SwCallLink aLk( *this ); // watch Crsr-Moves
     559           0 :     SwCrsrSaveState aSaveState( *m_pCurCrsr );
     560             : 
     561             :     const SwTOXMark& rNewMark = GetDoc()->GotoTOXMark( rStart, eDir,
     562           0 :                                                     IsReadOnlyAvailable() );
     563             :     // set position
     564           0 :     SwPosition& rPos = *GetCrsr()->GetPoint();
     565           0 :     rPos.nNode = rNewMark.GetTxtTOXMark()->GetTxtNode();
     566           0 :     rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(),
     567           0 :                          *rNewMark.GetTxtTOXMark()->GetStart() );
     568             : 
     569           0 :     if( !m_pCurCrsr->IsSelOvr() )
     570             :         UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
     571           0 :                     SwCrsrShell::READONLY );
     572             : 
     573           0 :     return rNewMark;
     574             : }
     575             : 
     576             : /// jump to next/previous field type
     577           0 : void lcl_MakeFldLst(
     578             :     _SetGetExpFlds& rLst,
     579             :     const SwFieldType& rFldType,
     580             :     const bool bInReadOnly,
     581             :     const bool bChkInpFlag = false )
     582             : {
     583             :     // always search the 1. frame
     584           0 :     Point aPt;
     585           0 :     SwTxtFld* pTxtFld = NULL;
     586           0 :     SwIterator<SwFmtFld,SwFieldType> aIter(rFldType);
     587           0 :     for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() )
     588             :     {
     589           0 :         pTxtFld = pFmtFld->GetTxtFld();
     590           0 :         if ( pTxtFld != NULL
     591           0 :              && ( !bChkInpFlag
     592           0 :                   || ((SwSetExpField*)pTxtFld->GetFmtFld().GetField())->GetInputFlag() ) )
     593             :         {
     594           0 :             const SwTxtNode& rTxtNode = pTxtFld->GetTxtNode();
     595             :             const SwCntntFrm* pCFrm =
     596           0 :                 rTxtNode.getLayoutFrm( rTxtNode.GetDoc()->GetCurrentLayout(), &aPt, 0, false );
     597           0 :             if ( pCFrm != NULL
     598           0 :                  && ( bInReadOnly || !pCFrm->IsProtected() ) )
     599             :             {
     600           0 :                 _SetGetExpFld* pNew = new _SetGetExpFld( SwNodeIndex( rTxtNode ), pTxtFld );
     601           0 :                 pNew->SetBodyPos( *pCFrm );
     602           0 :                 rLst.insert( pNew );
     603             :             }
     604             :         }
     605           0 :     }
     606           0 : }
     607             : 
     608           0 : sal_Bool SwCrsrShell::MoveFldType(
     609             :     const SwFieldType* pFldType,
     610             :     const bool bNext,
     611             :     const sal_uInt16 nResType,
     612             :     const bool bAddSetExpressionFldsToInputFlds )
     613             : {
     614             :     // sorted list of all fields
     615           0 :     _SetGetExpFlds aSrtLst;
     616             : 
     617           0 :     if ( pFldType )
     618             :     {
     619           0 :         if( RES_INPUTFLD != pFldType->Which() && !pFldType->GetDepends() )
     620             :         {
     621           0 :             return sal_False;
     622             :         }
     623             : 
     624             :         // found Modify object, add all fields to array
     625           0 :         ::lcl_MakeFldLst( aSrtLst, *pFldType, ( IsReadOnlyAvailable() ? true : false ) );
     626             : 
     627           0 :         if( RES_INPUTFLD == pFldType->Which() && bAddSetExpressionFldsToInputFlds )
     628             :         {
     629             :             // there are hidden input fields in the set exp. fields
     630           0 :             const SwFldTypes& rFldTypes = *mpDoc->GetFldTypes();
     631           0 :             const size_t nSize = rFldTypes.size();
     632           0 :             for( size_t i=0; i < nSize; ++i )
     633             :             {
     634           0 :                 pFldType = rFldTypes[ i ];
     635           0 :                 if ( RES_SETEXPFLD == pFldType->Which() )
     636             :                 {
     637           0 :                     ::lcl_MakeFldLst( aSrtLst, *pFldType, ( IsReadOnlyAvailable() ? true : false ), true );
     638             :                 }
     639             :             }
     640             :         }
     641             :     }
     642             :     else
     643             :     {
     644           0 :         const SwFldTypes& rFldTypes = *mpDoc->GetFldTypes();
     645           0 :         const size_t nSize = rFldTypes.size();
     646           0 :         for( size_t i=0; i < nSize; ++i )
     647             :         {
     648           0 :             pFldType = rFldTypes[ i ];
     649           0 :             if( nResType == pFldType->Which() )
     650             :             {
     651           0 :                 ::lcl_MakeFldLst( aSrtLst, *pFldType, ( IsReadOnlyAvailable() ? true : false ) );
     652             :             }
     653             :         }
     654             :     }
     655             : 
     656             :     // found no fields?
     657           0 :     if( aSrtLst.empty() )
     658           0 :         return sal_False;
     659             : 
     660           0 :     _SetGetExpFlds::const_iterator it;
     661           0 :     SwCursor* pCrsr = getShellCrsr( true );
     662             :     {
     663             :         // (1998): Always use field for search so that the right one is found as
     664             :         // well some are in frames that are anchored to a paragraph that has a
     665             :         // field
     666           0 :         const SwPosition& rPos = *pCrsr->GetPoint();
     667             : 
     668           0 :         SwTxtNode* pTNd = rPos.nNode.GetNode().GetTxtNode();
     669             :         OSL_ENSURE( pTNd, "No CntntNode" );
     670             : 
     671           0 :         SwTxtFld * pTxtFld = pTNd->GetFldTxtAttrAt( rPos.nContent.GetIndex(), true );
     672           0 :         const bool bDelFld = ( pTxtFld == NULL );
     673           0 :         if( bDelFld )
     674             :         {
     675             :             // create dummy for the search
     676             :             SwFmtFld* pFmtFld = new SwFmtFld( SwDateTimeField(
     677           0 :                 (SwDateTimeFieldType*)mpDoc->GetSysFldType( RES_DATETIMEFLD ) ) );
     678             : 
     679           0 :             pTxtFld = new SwTxtFld( *pFmtFld, rPos.nContent.GetIndex(),
     680           0 :                         mpDoc->IsClipBoard() );
     681           0 :             pTxtFld->ChgTxtNode( pTNd );
     682             :         }
     683             : 
     684           0 :         _SetGetExpFld aSrch( rPos.nNode, pTxtFld, &rPos.nContent );
     685           0 :         if( rPos.nNode.GetIndex() < mpDoc->GetNodes().GetEndOfExtras().GetIndex() )
     686             :         {
     687             :             // also at collection use only the first frame
     688           0 :             Point aPt;
     689           0 :             aSrch.SetBodyPos( *pTNd->getLayoutFrm( GetLayout(), &aPt, &rPos, false ) );
     690             :         }
     691             : 
     692           0 :         it = aSrtLst.lower_bound( &aSrch );
     693           0 :         if( bDelFld )
     694             :         {
     695           0 :             delete (SwFmtFld*)&pTxtFld->GetAttr();
     696           0 :             delete pTxtFld;
     697             :         }
     698             : 
     699           0 :         if( it != aSrtLst.end() && **it == aSrch ) // found
     700             :         {
     701           0 :             if( bNext )
     702             :             {
     703           0 :                 if( ++it == aSrtLst.end() )
     704           0 :                     return sal_False; // already at the end
     705             :             }
     706             :             else
     707             :             {
     708           0 :                 if( it == aSrtLst.begin() )
     709           0 :                     return sal_False; // no more steps backward possible
     710           0 :                 --it;
     711             :             }
     712             :         }
     713             :         else // not found
     714             :         {
     715           0 :             if( bNext )
     716             :             {
     717           0 :                 if( it == aSrtLst.end() )
     718           0 :                     return sal_False;
     719             :             }
     720             :             else
     721             :             {
     722           0 :                 if( it == aSrtLst.begin() )
     723           0 :                     return sal_False; // no more steps backward possible
     724           0 :                 --it;
     725             :             }
     726             :         }
     727             :     }
     728           0 :     const _SetGetExpFld& rFnd = **it;
     729             : 
     730           0 :     SET_CURR_SHELL( this );
     731           0 :     SwCallLink aLk( *this ); // watch Crsr-Moves
     732           0 :     SwCrsrSaveState aSaveState( *pCrsr );
     733             : 
     734           0 :     rFnd.GetPosOfContent( *pCrsr->GetPoint() );
     735             :     sal_Bool bRet = !m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION |
     736           0 :                                      nsSwCursorSelOverFlags::SELOVER_TOGGLE );
     737           0 :     if( bRet )
     738           0 :         UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
     739           0 :     return bRet;
     740             : }
     741             : 
     742           0 : sal_Bool SwCrsrShell::GotoFld( const SwFmtFld& rFld )
     743             : {
     744           0 :     sal_Bool bRet = sal_False;
     745           0 :     if( rFld.GetTxtFld() )
     746             :     {
     747           0 :         SET_CURR_SHELL( this );
     748           0 :         SwCallLink aLk( *this ); // watch Crsr-Moves
     749             : 
     750           0 :         SwCursor* pCrsr = getShellCrsr( true );
     751           0 :         SwCrsrSaveState aSaveState( *pCrsr );
     752             : 
     753           0 :         SwTxtNode* pTNd = (SwTxtNode*)rFld.GetTxtFld()->GetpTxtNode();
     754           0 :         pCrsr->GetPoint()->nNode = *pTNd;
     755           0 :         pCrsr->GetPoint()->nContent.Assign( pTNd, *rFld.GetTxtFld()->GetStart() );
     756             : 
     757           0 :         bRet = !pCrsr->IsSelOvr();
     758           0 :         if( bRet )
     759           0 :             UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
     760             :     }
     761           0 :     return bRet;
     762             : }
     763             : 
     764           0 : SwTxtFld * SwCrsrShell::GetTxtFldAtPos(
     765             :     const SwPosition* pPos,
     766             :     const bool bIncludeInputFldAtStart ) const
     767             : {
     768           0 :     SwTxtFld* pTxtFld = NULL;
     769             : 
     770           0 :     SwTxtNode * const pNode = pPos->nNode.GetNode().GetTxtNode();
     771           0 :     if ( pNode != NULL )
     772             :     {
     773           0 :         pTxtFld = pNode->GetFldTxtAttrAt( pPos->nContent.GetIndex(), bIncludeInputFldAtStart );
     774             :     }
     775             : 
     776           0 :     return pTxtFld;
     777             : }
     778             : 
     779           0 : SwField* SwCrsrShell::GetFieldAtCrsr(
     780             :     const SwPaM* pCrsr,
     781             :     const bool bIncludeInputFldAtStart ) const
     782             : {
     783           0 :     SwField* pFieldAtCrsr = NULL;
     784             : 
     785           0 :     SwTxtFld* pTxtFld = GetTxtFldAtPos( pCrsr->Start(), bIncludeInputFldAtStart );
     786           0 :     if ( pTxtFld != NULL
     787           0 :         && pCrsr->Start()->nNode == pCrsr->End()->nNode )
     788             :     {
     789             :         const sal_Int32 nTxtFldLength =
     790           0 :             pTxtFld->End() != NULL
     791           0 :             ? *(pTxtFld->End()) - *(pTxtFld->GetStart())
     792           0 :             : 1;
     793           0 :         if ( ( pCrsr->End()->nContent.GetIndex() - pCrsr->Start()->nContent.GetIndex() ) <= nTxtFldLength )
     794             :         {
     795           0 :             pFieldAtCrsr = (SwField*)pTxtFld->GetFmtFld().GetField();
     796             :         }
     797             :     }
     798             : 
     799           0 :     return pFieldAtCrsr;
     800             : }
     801             : 
     802           0 : SwField* SwCrsrShell::GetCurFld( const bool bIncludeInputFldAtStart ) const
     803             : {
     804           0 :     SwPaM* pCrsr = GetCrsr();
     805           0 :     if ( pCrsr->GetNext() != pCrsr )
     806             :     {
     807             :         // multi selection not handled.
     808           0 :         return NULL;
     809             :     }
     810             : 
     811           0 :     SwField* pCurFld = GetFieldAtCrsr( pCrsr, bIncludeInputFldAtStart );;
     812           0 :     if ( pCurFld != NULL
     813           0 :          && RES_TABLEFLD == pCurFld->GetTyp()->Which() )
     814             :     {
     815             :         // TabellenFormel ? wandel internen in externen Namen um
     816           0 :         const SwTableNode* pTblNd = IsCrsrInTbl();
     817           0 :         ((SwTblField*)pCurFld)->PtrToBoxNm( pTblNd ? &pTblNd->GetTable() : 0 );
     818             :     }
     819             : 
     820           0 :     return pCurFld;
     821             : }
     822             : 
     823           0 : bool SwCrsrShell::CrsrInsideInputFld() const
     824             : {
     825           0 :     bool bCrsrInsideInputFld = false;
     826             : 
     827           0 :     const SwPaM* pCrsr = GetCrsr();
     828           0 :     const SwPaM* pFirst = pCrsr;
     829           0 :     do
     830             :     {
     831           0 :         bCrsrInsideInputFld = dynamic_cast<const SwInputField*>(GetFieldAtCrsr( pCrsr, false )) != NULL;
     832             : 
     833           0 :         pCrsr = static_cast<SwPaM*>(pCrsr->GetNext());
     834           0 :     } while ( !bCrsrInsideInputFld
     835           0 :               && pCrsr != pFirst );
     836             : 
     837           0 :     return bCrsrInsideInputFld;
     838             : }
     839             : 
     840           0 : bool SwCrsrShell::PosInsideInputFld( const SwPosition& rPos ) const
     841             : {
     842           0 :     return dynamic_cast<const SwTxtInputFld*>(GetTxtFldAtPos( &rPos, false )) != NULL;
     843             : }
     844             : 
     845           0 : bool SwCrsrShell::DocPtInsideInputFld( const Point& rDocPt ) const
     846             : {
     847           0 :     SwPosition aPos( *(GetCrsr()->Start()) );
     848           0 :     Point aDocPt( rDocPt );
     849           0 :     if ( GetLayout()->GetCrsrOfst( &aPos, aDocPt ) )
     850             :     {
     851           0 :         return PosInsideInputFld( aPos );
     852             :     }
     853           0 :     return false;
     854             : }
     855             : 
     856           0 : sal_Int32 SwCrsrShell::StartOfInputFldAtPos( const SwPosition& rPos ) const
     857             : {
     858           0 :     const SwTxtInputFld* pTxtInputFld = dynamic_cast<const SwTxtInputFld*>(GetTxtFldAtPos( &rPos, true ));
     859           0 :     if ( pTxtInputFld == NULL )
     860             :     {
     861             :         OSL_ENSURE( false, "<SwEditShell::StartOfInputFldAtPos(..)> - no Input Field at given position" );
     862           0 :         return 0;
     863             :     }
     864           0 :     return *(pTxtInputFld->GetStart());
     865             : }
     866             : 
     867           0 : sal_Int32 SwCrsrShell::EndOfInputFldAtPos( const SwPosition& rPos ) const
     868             : {
     869           0 :     const SwTxtInputFld* pTxtInputFld = dynamic_cast<const SwTxtInputFld*>(GetTxtFldAtPos( &rPos, true ));
     870           0 :     if ( pTxtInputFld == NULL )
     871             :     {
     872             :         OSL_ENSURE( false, "<SwEditShell::EndOfInputFldAtPos(..)> - no Input Field at given position" );
     873           0 :         return 0;
     874             :     }
     875           0 :     return *(pTxtInputFld->End());
     876             : }
     877             : 
     878           0 : void SwCrsrShell::GotoOutline( sal_uInt16 nIdx )
     879             : {
     880           0 :     SwCursor* pCrsr = getShellCrsr( true );
     881             : 
     882           0 :     SET_CURR_SHELL( this );
     883           0 :     SwCallLink aLk( *this ); // watch Crsr-Moves
     884           0 :     SwCrsrSaveState aSaveState( *pCrsr );
     885             : 
     886           0 :     const SwNodes& rNds = GetDoc()->GetNodes();
     887           0 :     SwTxtNode* pTxtNd = (SwTxtNode*)rNds.GetOutLineNds()[ nIdx ]->GetTxtNode();
     888           0 :     pCrsr->GetPoint()->nNode = *pTxtNd;
     889           0 :     pCrsr->GetPoint()->nContent.Assign( pTxtNd, 0 );
     890             : 
     891           0 :     if( !pCrsr->IsSelOvr() )
     892           0 :         UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
     893           0 : }
     894             : 
     895           0 : bool SwCrsrShell::GotoOutline( const OUString& rName )
     896             : {
     897           0 :     SwCursor* pCrsr = getShellCrsr( true );
     898             : 
     899           0 :     SET_CURR_SHELL( this );
     900           0 :     SwCallLink aLk( *this ); // watch Crsr-Moves
     901           0 :     SwCrsrSaveState aSaveState( *pCrsr );
     902             : 
     903           0 :     bool bRet = false;
     904           0 :     if( mpDoc->GotoOutline( *pCrsr->GetPoint(), rName ) && !pCrsr->IsSelOvr() )
     905             :     {
     906           0 :         UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
     907           0 :         bRet = true;
     908             :     }
     909           0 :     return bRet;
     910             : }
     911             : 
     912             : /// jump to next node with outline num.
     913           0 : sal_Bool SwCrsrShell::GotoNextOutline()
     914             : {
     915           0 :     SwCursor* pCrsr = getShellCrsr( true );
     916           0 :     const SwNodes& rNds = GetDoc()->GetNodes();
     917             : 
     918           0 :     SwNode* pNd = pCrsr->GetNode();
     919             :     sal_uInt16 nPos;
     920           0 :     if( rNds.GetOutLineNds().Seek_Entry( pNd, &nPos ))
     921           0 :         ++nPos;
     922             : 
     923           0 :     if( nPos == rNds.GetOutLineNds().size() )
     924           0 :         return sal_False;
     925             : 
     926           0 :     pNd = rNds.GetOutLineNds()[ nPos ];
     927             : 
     928           0 :     SET_CURR_SHELL( this );
     929           0 :     SwCallLink aLk( *this ); // watch Crsr-Moves
     930           0 :     SwCrsrSaveState aSaveState( *pCrsr );
     931           0 :     pCrsr->GetPoint()->nNode = *pNd;
     932           0 :     pCrsr->GetPoint()->nContent.Assign( (SwTxtNode*)pNd, 0 );
     933             : 
     934           0 :     sal_Bool bRet = !pCrsr->IsSelOvr();
     935           0 :     if( bRet )
     936           0 :         UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
     937           0 :     return bRet;
     938             : }
     939             : 
     940             : /// jump to previous node with outline num.
     941           0 : sal_Bool SwCrsrShell::GotoPrevOutline()
     942             : {
     943           0 :     SwCursor* pCrsr = getShellCrsr( true );
     944           0 :     const SwNodes& rNds = GetDoc()->GetNodes();
     945             : 
     946           0 :     SwNode* pNd = pCrsr->GetNode();
     947             :     sal_uInt16 nPos;
     948           0 :     rNds.GetOutLineNds().Seek_Entry( pNd, &nPos );
     949             : 
     950           0 :     sal_Bool bRet = sal_False;
     951           0 :     if( nPos )
     952             :     {
     953           0 :         --nPos; // before
     954             : 
     955           0 :         pNd = rNds.GetOutLineNds()[ nPos ];
     956           0 :         if( pNd->GetIndex() > pCrsr->GetPoint()->nNode.GetIndex() )
     957           0 :             return sal_False;
     958             : 
     959           0 :         SET_CURR_SHELL( this );
     960           0 :         SwCallLink aLk( *this ); // watch Crsr-Moves
     961           0 :         SwCrsrSaveState aSaveState( *pCrsr );
     962           0 :         pCrsr->GetPoint()->nNode = *pNd;
     963           0 :         pCrsr->GetPoint()->nContent.Assign( (SwTxtNode*)pNd, 0 );
     964             : 
     965           0 :         bRet = !pCrsr->IsSelOvr();
     966           0 :         if( bRet )
     967           0 :             UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
     968             :     }
     969           0 :     return bRet;
     970             : }
     971             : 
     972             : /// search "outline position" before previous outline node at given level
     973           0 : sal_uInt16 SwCrsrShell::GetOutlinePos( sal_uInt8 nLevel )
     974             : {
     975           0 :     SwPaM* pCrsr = getShellCrsr( true );
     976           0 :     const SwNodes& rNds = GetDoc()->GetNodes();
     977             : 
     978           0 :     SwNode* pNd = pCrsr->GetNode();
     979             :     sal_uInt16 nPos;
     980           0 :     if( rNds.GetOutLineNds().Seek_Entry( pNd, &nPos ))
     981           0 :         nPos++; // is at correct position; take next for while
     982             : 
     983           0 :     while( nPos-- ) // check the one in front of the current
     984             :     {
     985           0 :         pNd = rNds.GetOutLineNds()[ nPos ];
     986             : 
     987           0 :         if( ((SwTxtNode*)pNd)->GetAttrOutlineLevel()-1 <= nLevel )
     988           0 :             return nPos;
     989             : 
     990             :     }
     991           0 :     return USHRT_MAX; // no more left
     992             : }
     993             : 
     994           0 : sal_Bool SwCrsrShell::MakeOutlineSel( sal_uInt16 nSttPos, sal_uInt16 nEndPos,
     995             :                                     sal_Bool bWithChildren )
     996             : {
     997           0 :     const SwNodes& rNds = GetDoc()->GetNodes();
     998           0 :     const SwOutlineNodes& rOutlNds = rNds.GetOutLineNds();
     999           0 :     if( rOutlNds.empty() )
    1000           0 :         return sal_False;
    1001             : 
    1002           0 :     SET_CURR_SHELL( this );
    1003           0 :     SwCallLink aLk( *this ); // watch Crsr-Moves
    1004             : 
    1005           0 :     if( nSttPos > nEndPos ) // parameters switched?
    1006             :     {
    1007             :         OSL_ENSURE( !this, "Start > End for array access" );
    1008           0 :         sal_uInt16 nTmp = nSttPos;
    1009           0 :         nSttPos = nEndPos;
    1010           0 :         nEndPos = nTmp;
    1011             :     }
    1012             : 
    1013           0 :     SwNode* pSttNd = rOutlNds[ nSttPos ];
    1014           0 :     SwNode* pEndNd = rOutlNds[ nEndPos ];
    1015             : 
    1016           0 :     if( bWithChildren )
    1017             :     {
    1018           0 :         const int nLevel = pEndNd->GetTxtNode()->GetAttrOutlineLevel()-1;
    1019           0 :         for( ++nEndPos; nEndPos < rOutlNds.size(); ++nEndPos )
    1020             :         {
    1021           0 :             pEndNd = rOutlNds[ nEndPos ];
    1022           0 :             const int nNxtLevel = pEndNd->GetTxtNode()->GetAttrOutlineLevel()-1;
    1023           0 :             if( nNxtLevel <= nLevel )
    1024           0 :                 break; // EndPos is now on the next one
    1025             :         }
    1026             :     }
    1027             :     // if without children then set onto next one
    1028           0 :     else if( ++nEndPos < rOutlNds.size() )
    1029           0 :         pEndNd = rOutlNds[ nEndPos ];
    1030             : 
    1031           0 :     if( nEndPos == rOutlNds.size() ) // no end found
    1032           0 :         pEndNd = &rNds.GetEndOfContent();
    1033             : 
    1034           0 :     KillPams();
    1035             : 
    1036           0 :     SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1037             : 
    1038             :     // set end to the end of the previous content node
    1039           0 :     m_pCurCrsr->GetPoint()->nNode = *pSttNd;
    1040           0 :     m_pCurCrsr->GetPoint()->nContent.Assign( pSttNd->GetCntntNode(), 0 );
    1041           0 :     m_pCurCrsr->SetMark();
    1042           0 :     m_pCurCrsr->GetPoint()->nNode = *pEndNd;
    1043           0 :     m_pCurCrsr->Move( fnMoveBackward, fnGoNode ); // end of predecessor
    1044             : 
    1045             :     // and everything is already selected
    1046           0 :     sal_Bool bRet = !m_pCurCrsr->IsSelOvr();
    1047           0 :     if( bRet )
    1048           0 :         UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
    1049           0 :     return bRet;
    1050             : }
    1051             : 
    1052             : /// jump to reference marker
    1053           0 : sal_Bool SwCrsrShell::GotoRefMark( const OUString& rRefMark, sal_uInt16 nSubType,
    1054             :                                     sal_uInt16 nSeqNo )
    1055             : {
    1056           0 :     SET_CURR_SHELL( this );
    1057           0 :     SwCallLink aLk( *this ); // watch Crsr-Moves
    1058           0 :     SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1059             : 
    1060           0 :     sal_Int32 nPos = -1;
    1061             :     SwTxtNode* pTxtNd = SwGetRefFieldType::FindAnchor( GetDoc(), rRefMark,
    1062           0 :                                                     nSubType, nSeqNo, &nPos );
    1063           0 :     if( pTxtNd && pTxtNd->GetNodes().IsDocNodes() )
    1064             :     {
    1065           0 :         m_pCurCrsr->GetPoint()->nNode = *pTxtNd;
    1066           0 :         m_pCurCrsr->GetPoint()->nContent.Assign( pTxtNd, nPos );
    1067             : 
    1068           0 :         if( !m_pCurCrsr->IsSelOvr() )
    1069             :         {
    1070           0 :             UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
    1071           0 :             return sal_True;
    1072             :         }
    1073             :     }
    1074           0 :     return sal_False;
    1075             : }
    1076             : 
    1077           0 : sal_Bool SwCrsrShell::IsPageAtPos( const Point &rPt ) const
    1078             : {
    1079           0 :     if( GetLayout() )
    1080           0 :         return 0 != GetLayout()->GetPageAtPos( rPt );
    1081           0 :     return sal_False;
    1082             : }
    1083             : 
    1084           0 : sal_Bool SwCrsrShell::GetContentAtPos( const Point& rPt,
    1085             :                                    SwContentAtPos& rCntntAtPos,
    1086             :                                    sal_Bool bSetCrsr,
    1087             :                                    SwRect* pFldRect )
    1088             : {
    1089           0 :     SET_CURR_SHELL( this );
    1090           0 :     sal_Bool bRet = sal_False;
    1091             : 
    1092           0 :     if( !IsTableMode() )
    1093             :     {
    1094           0 :         Point aPt( rPt );
    1095           0 :         SwPosition aPos( *m_pCurCrsr->GetPoint() );
    1096             : 
    1097             :         SwTxtNode* pTxtNd;
    1098           0 :         SwCntntFrm *pFrm(0);
    1099             :         SwTxtAttr* pTxtAttr;
    1100           0 :         SwCrsrMoveState aTmpState;
    1101           0 :         aTmpState.bFieldInfo = sal_True;
    1102           0 :         aTmpState.bExactOnly = !( SwContentAtPos::SW_OUTLINE & rCntntAtPos.eCntntAtPos );
    1103           0 :         aTmpState.bCntntCheck = (SwContentAtPos::SW_CONTENT_CHECK & rCntntAtPos.eCntntAtPos) ?  sal_True : sal_False;
    1104           0 :         aTmpState.bSetInReadOnly = IsReadOnlyAvailable();
    1105             : 
    1106           0 :         SwSpecialPos aSpecialPos;
    1107           0 :         aTmpState.pSpecialPos = ( SwContentAtPos::SW_SMARTTAG & rCntntAtPos.eCntntAtPos ) ?
    1108           0 :                                 &aSpecialPos : 0;
    1109             : 
    1110           0 :         const bool bCrsrFoundExact = GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState );
    1111           0 :         pTxtNd = aPos.nNode.GetNode().GetTxtNode();
    1112             : 
    1113           0 :         const SwNodes& rNds = GetDoc()->GetNodes();
    1114           0 :         if( pTxtNd
    1115           0 :             && SwContentAtPos::SW_OUTLINE & rCntntAtPos.eCntntAtPos
    1116           0 :             && !rNds.GetOutLineNds().empty() )
    1117             :         {
    1118           0 :             const SwTxtNode* pONd = pTxtNd->FindOutlineNodeOfLevel( MAXLEVEL-1);
    1119           0 :             if( pONd )
    1120             :             {
    1121           0 :                 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_OUTLINE;
    1122           0 :                 rCntntAtPos.sStr = pONd->GetExpandTxt( 0, -1, true, true );
    1123           0 :                 bRet = sal_True;
    1124             :             }
    1125             :         }
    1126           0 :         else if ( SwContentAtPos::SW_CONTENT_CHECK & rCntntAtPos.eCntntAtPos
    1127           0 :                   && bCrsrFoundExact )
    1128             :         {
    1129           0 :             bRet = sal_True;
    1130             :         }
    1131           0 :         else if( pTxtNd
    1132           0 :                  && SwContentAtPos::SW_NUMLABEL & rCntntAtPos.eCntntAtPos)
    1133             :         {
    1134           0 :             bRet = aTmpState.bInNumPortion;
    1135           0 :             rCntntAtPos.aFnd.pNode = pTxtNd;
    1136             : 
    1137           0 :             Size aSizeLogic(aTmpState.nInNumPostionOffset, 0);
    1138           0 :             Size aSizePixel = GetWin()->LogicToPixel(aSizeLogic);
    1139           0 :             rCntntAtPos.nDist = aSizePixel.Width();
    1140             :         }
    1141           0 :         else if( bCrsrFoundExact && pTxtNd )
    1142             :         {
    1143           0 :             if( !aTmpState.bPosCorr )
    1144             :             {
    1145           0 :                 if ( !bRet
    1146           0 :                      && SwContentAtPos::SW_SMARTTAG & rCntntAtPos.eCntntAtPos
    1147           0 :                      && !aTmpState.bFtnNoInfo )
    1148             :                 {
    1149           0 :                     const SwWrongList* pSmartTagList = pTxtNd->GetSmartTags();
    1150           0 :                     sal_Int32 nCurrent = aPos.nContent.GetIndex();
    1151           0 :                     const sal_Int32 nBegin = nCurrent;
    1152           0 :                     sal_Int32 nLen = 1;
    1153             : 
    1154           0 :                     if ( pSmartTagList && pSmartTagList->InWrongWord( nCurrent, nLen ) && !pTxtNd->IsSymbol(nBegin) )
    1155             :                     {
    1156           0 :                         const sal_uInt16 nIndex = pSmartTagList->GetWrongPos( nBegin );
    1157           0 :                         const SwWrongList* pSubList = pSmartTagList->SubList( nIndex );
    1158           0 :                         if ( pSubList )
    1159             :                         {
    1160           0 :                             nCurrent = aTmpState.pSpecialPos->nCharOfst;
    1161             : 
    1162           0 :                             if ( pSubList->InWrongWord( nCurrent, nLen ) )
    1163           0 :                                 bRet = sal_True;
    1164             :                         }
    1165             :                         else
    1166           0 :                             bRet = sal_True;
    1167             : 
    1168           0 :                         if( bRet && bSetCrsr )
    1169             :                         {
    1170           0 :                             SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1171           0 :                             SwCallLink aLk( *this ); // watch Crsr-Moves
    1172           0 :                             m_pCurCrsr->DeleteMark();
    1173           0 :                             *m_pCurCrsr->GetPoint() = aPos;
    1174           0 :                             if( m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION | nsSwCursorSelOverFlags::SELOVER_TOGGLE) )
    1175           0 :                                 bRet = sal_False;
    1176             :                             else
    1177           0 :                                 UpdateCrsr();
    1178             :                         }
    1179           0 :                         if( bRet )
    1180             :                         {
    1181           0 :                             rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_SMARTTAG;
    1182             : 
    1183           0 :                             if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) )
    1184           0 :                                 pFrm->GetCharRect( *pFldRect, aPos, &aTmpState );
    1185             :                         }
    1186             :                     }
    1187             :                 }
    1188             : 
    1189           0 :                 if ( !bRet
    1190           0 :                      && ( SwContentAtPos::SW_FIELD | SwContentAtPos::SW_CLICKFIELD ) & rCntntAtPos.eCntntAtPos
    1191           0 :                      && !aTmpState.bFtnNoInfo )
    1192             :                 {
    1193           0 :                     pTxtAttr = pTxtNd->GetFldTxtAttrAt( aPos.nContent.GetIndex() );
    1194             :                     const SwField* pFld = pTxtAttr != NULL
    1195           0 :                                           ? pTxtAttr->GetFmtFld().GetField()
    1196           0 :                                           : 0;
    1197           0 :                     if ( SwContentAtPos::SW_CLICKFIELD & rCntntAtPos.eCntntAtPos
    1198           0 :                          && pFld && !pFld->HasClickHdl() )
    1199             :                     {
    1200           0 :                         pFld = 0;
    1201             :                     }
    1202             : 
    1203           0 :                     if ( pFld )
    1204             :                     {
    1205           0 :                         if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) )
    1206           0 :                             pFrm->GetCharRect( *pFldRect, aPos, &aTmpState );
    1207             : 
    1208           0 :                         if( bSetCrsr )
    1209             :                         {
    1210           0 :                             SwCallLink aLk( *this ); // watch Crsr-Moves
    1211           0 :                             SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1212           0 :                             m_pCurCrsr->DeleteMark();
    1213           0 :                             *m_pCurCrsr->GetPoint() = aPos;
    1214           0 :                             if( m_pCurCrsr->IsSelOvr() )
    1215             :                             {
    1216             :                                 // allow click fields in protected sections
    1217             :                                 // only placeholder is not possible
    1218           0 :                                 if( SwContentAtPos::SW_FIELD & rCntntAtPos.eCntntAtPos
    1219           0 :                                     || RES_JUMPEDITFLD == pFld->Which() )
    1220           0 :                                     pFld = 0;
    1221             :                             }
    1222             :                             else
    1223           0 :                                 UpdateCrsr();
    1224             :                         }
    1225           0 :                         else if( RES_TABLEFLD == pFld->Which() &&
    1226           0 :                             ((SwTblField*)pFld)->IsIntrnlName() )
    1227             :                         {
    1228             :                             // create from internal (for CORE) the external
    1229             :                             // (for UI) formula
    1230           0 :                             const SwTableNode* pTblNd = pTxtNd->FindTableNode();
    1231           0 :                             if( pTblNd )        // steht in einer Tabelle
    1232           0 :                                 ((SwTblField*)pFld)->PtrToBoxNm( &pTblNd->GetTable() );
    1233             :                         }
    1234             :                     }
    1235             : 
    1236           0 :                     if( pFld )
    1237             :                     {
    1238           0 :                         rCntntAtPos.aFnd.pFld = pFld;
    1239           0 :                         rCntntAtPos.pFndTxtAttr = pTxtAttr;
    1240           0 :                         rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_FIELD;
    1241           0 :                         bRet = sal_True;
    1242             :                     }
    1243             :                 }
    1244             : 
    1245           0 :                 if( !bRet && SwContentAtPos::SW_FORMCTRL & rCntntAtPos.eCntntAtPos )
    1246             :                 {
    1247           0 :                     IDocumentMarkAccess* pMarksAccess = GetDoc()->getIDocumentMarkAccess( );
    1248           0 :                     sw::mark::IFieldmark* pFldBookmark = pMarksAccess->getFieldmarkFor( aPos );
    1249           0 :                     if( bCrsrFoundExact && pTxtNd && pFldBookmark) {
    1250           0 :                         rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_FORMCTRL;
    1251           0 :                         rCntntAtPos.aFnd.pFldmark = pFldBookmark;
    1252           0 :                         bRet=sal_True;
    1253             :                     }
    1254             :                 }
    1255             : 
    1256           0 :                 if( !bRet && SwContentAtPos::SW_FTN & rCntntAtPos.eCntntAtPos )
    1257             :                 {
    1258           0 :                     if( aTmpState.bFtnNoInfo )
    1259             :                     {
    1260             :                         // over the footnote's char
    1261           0 :                         bRet = sal_True;
    1262           0 :                         if( bSetCrsr )
    1263             :                         {
    1264           0 :                             *m_pCurCrsr->GetPoint() = aPos;
    1265           0 :                             if( !GotoFtnAnchor() )
    1266           0 :                                 bRet = sal_False;
    1267             :                         }
    1268           0 :                         if( bRet )
    1269           0 :                             rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_FTN;
    1270             :                     }
    1271           0 :                     else if ( 0 != ( pTxtAttr = pTxtNd->GetTxtAttrForCharAt(
    1272           0 :                         aPos.nContent.GetIndex(), RES_TXTATR_FTN )) )
    1273             :                     {
    1274           0 :                         bRet = sal_True;
    1275           0 :                         if( bSetCrsr )
    1276             :                         {
    1277           0 :                             SwCallLink aLk( *this ); // watch Crsr-Moves
    1278           0 :                             SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1279           0 :                             m_pCurCrsr->GetPoint()->nNode = *((SwTxtFtn*)pTxtAttr)->GetStartNode();
    1280           0 :                             SwCntntNode* pCNd = GetDoc()->GetNodes().GoNextSection(
    1281           0 :                                 &m_pCurCrsr->GetPoint()->nNode,
    1282           0 :                                 true, !IsReadOnlyAvailable() );
    1283             : 
    1284           0 :                             if( pCNd )
    1285             :                             {
    1286           0 :                                 m_pCurCrsr->GetPoint()->nContent.Assign( pCNd, 0 );
    1287           0 :                                 if( m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION |
    1288           0 :                                     nsSwCursorSelOverFlags::SELOVER_TOGGLE ))
    1289           0 :                                     bRet = sal_False;
    1290             :                                 else
    1291           0 :                                     UpdateCrsr();
    1292             :                             }
    1293             :                             else
    1294           0 :                                 bRet = sal_False;
    1295             :                         }
    1296             : 
    1297           0 :                         if( bRet )
    1298             :                         {
    1299           0 :                             rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_FTN;
    1300           0 :                             rCntntAtPos.pFndTxtAttr = pTxtAttr;
    1301           0 :                             rCntntAtPos.aFnd.pAttr = &pTxtAttr->GetAttr();
    1302             : 
    1303           0 :                             if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) )
    1304           0 :                                 pFrm->GetCharRect( *pFldRect, aPos, &aTmpState );
    1305             :                         }
    1306             :                     }
    1307             :                 }
    1308             : 
    1309           0 :                 if( !bRet
    1310           0 :                     && ( SwContentAtPos::SW_TOXMARK | SwContentAtPos::SW_REFMARK ) & rCntntAtPos.eCntntAtPos
    1311           0 :                     && !aTmpState.bFtnNoInfo )
    1312             :                 {
    1313           0 :                     pTxtAttr = 0;
    1314           0 :                     if( SwContentAtPos::SW_TOXMARK & rCntntAtPos.eCntntAtPos )
    1315             :                     {
    1316             :                         ::std::vector<SwTxtAttr *> const marks(
    1317             :                             pTxtNd->GetTxtAttrsAt(
    1318           0 :                                aPos.nContent.GetIndex(), RES_TXTATR_TOXMARK));
    1319           0 :                         if (marks.size())
    1320             :                         {   // hmm... can only return 1 here
    1321           0 :                             pTxtAttr = *marks.begin();
    1322           0 :                         }
    1323             :                     }
    1324             : 
    1325           0 :                     if( !pTxtAttr &&
    1326           0 :                         SwContentAtPos::SW_REFMARK & rCntntAtPos.eCntntAtPos )
    1327             :                     {
    1328             :                         ::std::vector<SwTxtAttr *> const marks(
    1329             :                             pTxtNd->GetTxtAttrsAt(
    1330           0 :                                aPos.nContent.GetIndex(), RES_TXTATR_REFMARK));
    1331           0 :                         if (marks.size())
    1332             :                         {   // hmm... can only return 1 here
    1333           0 :                             pTxtAttr = *marks.begin();
    1334           0 :                         }
    1335             :                     }
    1336             : 
    1337           0 :                     if( pTxtAttr )
    1338             :                     {
    1339           0 :                         bRet = sal_True;
    1340           0 :                         if( bSetCrsr )
    1341             :                         {
    1342           0 :                             SwCallLink aLk( *this ); // watch Crsr-Moves
    1343           0 :                             SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1344           0 :                             m_pCurCrsr->DeleteMark();
    1345           0 :                             *m_pCurCrsr->GetPoint() = aPos;
    1346           0 :                             if( m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION | nsSwCursorSelOverFlags::SELOVER_TOGGLE ) )
    1347           0 :                                 bRet = sal_False;
    1348             :                             else
    1349           0 :                                 UpdateCrsr();
    1350             :                         }
    1351             : 
    1352           0 :                         if( bRet )
    1353             :                         {
    1354           0 :                             const sal_Int32* pEnd = pTxtAttr->GetEnd();
    1355           0 :                             if( pEnd )
    1356           0 :                                 rCntntAtPos.sStr =
    1357           0 :                                     pTxtNd->GetExpandTxt( *pTxtAttr->GetStart(), *pEnd - *pTxtAttr->GetStart() );
    1358           0 :                             else if( RES_TXTATR_TOXMARK == pTxtAttr->Which())
    1359           0 :                                 rCntntAtPos.sStr =
    1360           0 :                                     pTxtAttr->GetTOXMark().GetAlternativeText();
    1361             : 
    1362             :                             rCntntAtPos.eCntntAtPos =
    1363           0 :                                 RES_TXTATR_TOXMARK == pTxtAttr->Which()
    1364             :                                 ? SwContentAtPos::SW_TOXMARK
    1365           0 :                                 : SwContentAtPos::SW_REFMARK;
    1366           0 :                             rCntntAtPos.pFndTxtAttr = pTxtAttr;
    1367           0 :                             rCntntAtPos.aFnd.pAttr = &pTxtAttr->GetAttr();
    1368             : 
    1369           0 :                             if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) )
    1370           0 :                                 pFrm->GetCharRect( *pFldRect, aPos, &aTmpState );
    1371             :                         }
    1372             :                     }
    1373             :                 }
    1374             : 
    1375           0 :                 if ( !bRet
    1376           0 :                      && SwContentAtPos::SW_INETATTR & rCntntAtPos.eCntntAtPos
    1377           0 :                      && !aTmpState.bFtnNoInfo )
    1378             :                 {
    1379             :                     pTxtAttr = pTxtNd->GetTxtAttrAt(
    1380           0 :                             aPos.nContent.GetIndex(), RES_TXTATR_INETFMT);
    1381             :                     // "detect" only INetAttrs with URLs
    1382           0 :                     if( pTxtAttr && !pTxtAttr->GetINetFmt().GetValue().isEmpty() )
    1383             :                     {
    1384           0 :                         bRet = sal_True;
    1385           0 :                         if( bSetCrsr )
    1386             :                         {
    1387           0 :                             SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1388           0 :                             SwCallLink aLk( *this ); // watch Crsr-Moves
    1389           0 :                             m_pCurCrsr->DeleteMark();
    1390           0 :                             *m_pCurCrsr->GetPoint() = aPos;
    1391           0 :                             if( m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION |
    1392           0 :                                 nsSwCursorSelOverFlags::SELOVER_TOGGLE) )
    1393           0 :                                 bRet = sal_False;
    1394             :                             else
    1395           0 :                                 UpdateCrsr();
    1396             :                         }
    1397           0 :                         if( bRet )
    1398             :                         {
    1399           0 :                             rCntntAtPos.sStr = pTxtNd->GetExpandTxt(
    1400           0 :                                 *pTxtAttr->GetStart(),
    1401           0 :                                 *pTxtAttr->GetEnd() - *pTxtAttr->GetStart() );
    1402             : 
    1403           0 :                             rCntntAtPos.aFnd.pAttr = &pTxtAttr->GetAttr();
    1404           0 :                             rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_INETATTR;
    1405           0 :                             rCntntAtPos.pFndTxtAttr = pTxtAttr;
    1406             : 
    1407           0 :                             if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) )
    1408           0 :                                 pFrm->GetCharRect( *pFldRect, aPos, &aTmpState );
    1409             :                         }
    1410             :                     }
    1411             :                 }
    1412             : 
    1413           0 :                 if( !bRet && SwContentAtPos::SW_REDLINE & rCntntAtPos.eCntntAtPos )
    1414             :                 {
    1415           0 :                     const SwRangeRedline* pRedl = GetDoc()->GetRedline(aPos, NULL);
    1416           0 :                     if( pRedl )
    1417             :                     {
    1418           0 :                         rCntntAtPos.aFnd.pRedl = pRedl;
    1419           0 :                         rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_REDLINE;
    1420           0 :                         rCntntAtPos.pFndTxtAttr = 0;
    1421           0 :                         bRet = sal_True;
    1422             : 
    1423           0 :                         if( pFldRect && 0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt ) ) )
    1424           0 :                             pFrm->GetCharRect( *pFldRect, aPos, &aTmpState );
    1425             :                     }
    1426             :                 }
    1427             :             }
    1428             : 
    1429           0 :             if( !bRet
    1430           0 :                  && ( SwContentAtPos::SW_TABLEBOXFML & rCntntAtPos.eCntntAtPos
    1431             : #ifdef DBG_UTIL
    1432             :                       || SwContentAtPos::SW_TABLEBOXVALUE & rCntntAtPos.eCntntAtPos
    1433             : #endif
    1434             :                 ) )
    1435             :             {
    1436             :                 const SwTableNode* pTblNd;
    1437             :                 const SwTableBox* pBox;
    1438           0 :                 const SwStartNode* pSttNd = pTxtNd->FindTableBoxStartNode();
    1439             :                 const SfxPoolItem* pItem;
    1440           0 :                 if( pSttNd && 0 != ( pTblNd = pTxtNd->FindTableNode()) &&
    1441           0 :                     0 != ( pBox = pTblNd->GetTable().GetTblBox(
    1442           0 :                     pSttNd->GetIndex() )) &&
    1443             : #ifdef DBG_UTIL
    1444             :                     ( SFX_ITEM_SET == pBox->GetFrmFmt()->GetItemState(
    1445             :                     RES_BOXATR_FORMULA, sal_False, &pItem ) ||
    1446             :                     SFX_ITEM_SET == pBox->GetFrmFmt()->GetItemState(
    1447             :                     RES_BOXATR_VALUE, sal_False, &pItem ))
    1448             : #else
    1449           0 :                     SFX_ITEM_SET == pBox->GetFrmFmt()->GetItemState(
    1450           0 :                     RES_BOXATR_FORMULA, sal_False, &pItem )
    1451             : #endif
    1452             :                     )
    1453             :                 {
    1454           0 :                     SwFrm* pF = pTxtNd->getLayoutFrm( GetLayout(), &aPt );
    1455           0 :                     if( pF )
    1456             :                     {
    1457             :                         // then the CellFrame
    1458           0 :                         pFrm = (SwCntntFrm*)pF;
    1459           0 :                         while( pF && !pF->IsCellFrm() )
    1460           0 :                             pF = pF->GetUpper();
    1461             :                     }
    1462             : 
    1463           0 :                     if( aTmpState.bPosCorr )
    1464             :                     {
    1465           0 :                         if( pF && !pF->Frm().IsInside( aPt ))
    1466           0 :                             pF = 0;
    1467             :                     }
    1468           0 :                     else if( !pF )
    1469           0 :                         pF = pFrm;
    1470             : 
    1471           0 :                     if( pF ) // only then it is valid
    1472             :                     {
    1473             :                         // create from internal (for CORE) the external
    1474             :                         // (for UI) formula
    1475           0 :                         rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_TABLEBOXFML;
    1476             : #ifdef DBG_UTIL
    1477             :                         if( RES_BOXATR_VALUE == pItem->Which() )
    1478             :                             rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_TABLEBOXVALUE;
    1479             :                         else
    1480             : #endif
    1481           0 :                             ((SwTblBoxFormula*)pItem)->PtrToBoxNm( &pTblNd->GetTable() );
    1482             : 
    1483           0 :                         bRet = sal_True;
    1484           0 :                         if( bSetCrsr )
    1485             :                         {
    1486           0 :                             SwCallLink aLk( *this ); // watch Crsr-Moves
    1487           0 :                             SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1488           0 :                             *m_pCurCrsr->GetPoint() = aPos;
    1489           0 :                             if( m_pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION |
    1490           0 :                                 nsSwCursorSelOverFlags::SELOVER_TOGGLE) )
    1491           0 :                                 bRet = sal_False;
    1492             :                             else
    1493           0 :                                 UpdateCrsr();
    1494             :                         }
    1495             : 
    1496           0 :                         if( bRet )
    1497             :                         {
    1498           0 :                             if( pFldRect )
    1499             :                             {
    1500           0 :                                 *pFldRect = pF->Prt();
    1501           0 :                                 *pFldRect += pF->Frm().Pos();
    1502             :                             }
    1503           0 :                             rCntntAtPos.pFndTxtAttr = 0;
    1504           0 :                             rCntntAtPos.aFnd.pAttr = pItem;
    1505             :                         }
    1506             :                     }
    1507             :                 }
    1508             :             }
    1509             : 
    1510             : #ifdef DBG_UTIL
    1511             :             if( !bRet && SwContentAtPos::SW_CURR_ATTRS & rCntntAtPos.eCntntAtPos )
    1512             :             {
    1513             :                 const sal_Int32 n = aPos.nContent.GetIndex();
    1514             :                 SfxItemSet aSet( GetDoc()->GetAttrPool(), POOLATTR_BEGIN,
    1515             :                     POOLATTR_END - 1 );
    1516             :                 if( pTxtNd->GetpSwpHints() )
    1517             :                 {
    1518             :                     for( sal_uInt16 i = 0; i < pTxtNd->GetSwpHints().Count(); ++i )
    1519             :                     {
    1520             :                         const SwTxtAttr* pHt = pTxtNd->GetSwpHints()[i];
    1521             :                         const sal_Int32 nAttrStart = *pHt->GetStart();
    1522             :                         if( nAttrStart > n ) // over the section
    1523             :                             break;
    1524             : 
    1525             :                         if( 0 != pHt->End() && (
    1526             :                             ( nAttrStart < n &&
    1527             :                             ( pHt->DontExpand() ? n < *pHt->End()
    1528             :                             : n <= *pHt->End() )) ||
    1529             :                             ( n == nAttrStart &&
    1530             :                             ( nAttrStart == *pHt->End() || !n ))) )
    1531             :                         {
    1532             :                             aSet.Put( pHt->GetAttr() );
    1533             :                         }
    1534             :                     }
    1535             :                     if( pTxtNd->HasSwAttrSet() &&
    1536             :                         pTxtNd->GetpSwAttrSet()->Count() )
    1537             :                     {
    1538             :                         SfxItemSet aFmtSet( pTxtNd->GetSwAttrSet() );
    1539             :                         // remove all from format set that are also in TextSet
    1540             :                         aFmtSet.Differentiate( aSet );
    1541             :                         // now merge all together
    1542             :                         aSet.Put( aFmtSet );
    1543             :                     }
    1544             :                 }
    1545             :                 else
    1546             :                     pTxtNd->SwCntntNode::GetAttr( aSet );
    1547             : 
    1548             :                 rCntntAtPos.sStr = "Pos: (";
    1549             :                 rCntntAtPos.sStr += OUString::number( aPos.nNode.GetIndex());
    1550             :                 rCntntAtPos.sStr += ":";
    1551             :                 rCntntAtPos.sStr += OUString::number( aPos.nContent.GetIndex());
    1552             :                 rCntntAtPos.sStr += ")";
    1553             :                 rCntntAtPos.sStr += "\nAbs.Vorl.: "; // translation *might be* "paragraph template"
    1554             :                 rCntntAtPos.sStr += pTxtNd->GetFmtColl()->GetName();
    1555             :                 if( pTxtNd->GetCondFmtColl() )
    1556             :                 {
    1557             :                      // translation *might be* "conditional template"
    1558             :                     rCntntAtPos.sStr += "\nBed.Vorl.: " + pTxtNd->GetCondFmtColl()->GetName();
    1559             :                 }
    1560             : 
    1561             :                 if( aSet.Count() )
    1562             :                 {
    1563             :                     OUString sAttrs;
    1564             :                     SfxItemIter aIter( aSet );
    1565             :                     const SfxPoolItem* pItem = aIter.FirstItem();
    1566             :                     while( true )
    1567             :                     {
    1568             :                         if( !IsInvalidItem( pItem ))
    1569             :                         {
    1570             :                             OUString aStr;
    1571             :                             GetDoc()->GetAttrPool().GetPresentation( *pItem,
    1572             :                                 SFX_ITEM_PRESENTATION_COMPLETE,
    1573             :                                 SFX_MAPUNIT_CM, aStr );
    1574             :                             if (!sAttrs.isEmpty())
    1575             :                                 sAttrs += ", ";
    1576             :                             sAttrs += aStr;
    1577             :                         }
    1578             :                         if( aIter.IsAtEnd() )
    1579             :                             break;
    1580             :                         pItem = aIter.NextItem();
    1581             :                     }
    1582             :                     if (!sAttrs.isEmpty())
    1583             :                     {
    1584             :                         if( !rCntntAtPos.sStr.isEmpty() )
    1585             :                             rCntntAtPos.sStr += "\n";
    1586             :                         rCntntAtPos.sStr += "Attr: " + sAttrs;
    1587             :                     }
    1588             :                 }
    1589             :                 bRet = sal_True;
    1590             :                 rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_CURR_ATTRS;
    1591             :             }
    1592             : #endif
    1593           0 :         }
    1594             :     }
    1595             : 
    1596           0 :     if( !bRet )
    1597             :     {
    1598           0 :         rCntntAtPos.eCntntAtPos = SwContentAtPos::SW_NOTHING;
    1599           0 :         rCntntAtPos.aFnd.pFld = 0;
    1600             :     }
    1601           0 :     return bRet;
    1602             : }
    1603             : 
    1604             : // #i90516#
    1605           0 : const SwPostItField* SwCrsrShell::GetPostItFieldAtCursor() const
    1606             : {
    1607           0 :     const SwPostItField* pPostItFld = 0;
    1608             : 
    1609           0 :     if ( !IsTableMode() )
    1610             :     {
    1611           0 :         const SwPosition* pCursorPos = _GetCrsr()->GetPoint();
    1612           0 :         const SwTxtNode* pTxtNd = pCursorPos->nNode.GetNode().GetTxtNode();
    1613           0 :         if ( pTxtNd )
    1614             :         {
    1615           0 :             SwTxtAttr* pTxtAttr = pTxtNd->GetFldTxtAttrAt( pCursorPos->nContent.GetIndex() );
    1616           0 :             const SwField* pFld = pTxtAttr != NULL ? pTxtAttr->GetFmtFld().GetField() : 0;
    1617           0 :             if ( pFld && pFld->Which()== RES_POSTITFLD )
    1618             :             {
    1619           0 :                 pPostItFld = static_cast<const SwPostItField*>(pFld);
    1620             :             }
    1621             :         }
    1622             :     }
    1623             : 
    1624           0 :     return pPostItFld;
    1625             : }
    1626             : 
    1627             : /// is the node in a protected section?
    1628           0 : bool SwContentAtPos::IsInProtectSect() const
    1629             : {
    1630           0 :     const SwTxtNode* pNd = 0;
    1631           0 :     if( pFndTxtAttr )
    1632             :     {
    1633           0 :         switch( eCntntAtPos )
    1634             :         {
    1635             :         case SW_FIELD:
    1636             :         case SW_CLICKFIELD:
    1637           0 :             pNd = ((SwTxtFld*)pFndTxtAttr)->GetpTxtNode();
    1638           0 :             break;
    1639             : 
    1640             :         case SW_FTN:
    1641           0 :             pNd = &((SwTxtFtn*)pFndTxtAttr)->GetTxtNode();
    1642           0 :             break;
    1643             : 
    1644             :         case SW_INETATTR:
    1645           0 :             pNd = ((SwTxtINetFmt*)pFndTxtAttr)->GetpTxtNode();
    1646           0 :             break;
    1647             : 
    1648             :         default:
    1649           0 :             break;
    1650             :         }
    1651             :     }
    1652             : 
    1653             :     const SwCntntFrm* pFrm;
    1654           0 :     return pNd && ( pNd->IsInProtectSect() ||
    1655           0 :                     ( 0 != ( pFrm = pNd->getLayoutFrm( pNd->GetDoc()->GetCurrentLayout(), 0, 0, false)) &&
    1656           0 :                         pFrm->IsProtected() ));
    1657             : }
    1658             : 
    1659           0 : bool SwContentAtPos::IsInRTLText()const
    1660             : {
    1661           0 :     bool bRet = false;
    1662           0 :     const SwTxtNode* pNd = 0;
    1663           0 :     if (pFndTxtAttr && (eCntntAtPos == SW_FTN))
    1664             :     {
    1665           0 :         const SwTxtFtn* pTxtFtn = static_cast<const SwTxtFtn*>(pFndTxtAttr);
    1666           0 :         if(pTxtFtn->GetStartNode())
    1667             :         {
    1668           0 :             SwStartNode* pSttNd = pTxtFtn->GetStartNode()->GetNode().GetStartNode();
    1669           0 :             SwPaM aTemp( *pSttNd );
    1670           0 :             aTemp.Move(fnMoveForward, fnGoNode);
    1671           0 :             SwCntntNode* pCntntNode = aTemp.GetCntntNode();
    1672           0 :             if(pCntntNode && pCntntNode->IsTxtNode())
    1673           0 :                 pNd = static_cast<SwTxtNode*>(pCntntNode);
    1674             :         }
    1675             :     }
    1676           0 :     if(pNd)
    1677             :     {
    1678           0 :         SwIterator<SwTxtFrm,SwTxtNode> aIter(*pNd);
    1679           0 :         SwTxtFrm* pTmpFrm = aIter.First();
    1680           0 :         while( pTmpFrm )
    1681             :         {
    1682           0 :                 if ( !pTmpFrm->IsFollow())
    1683             :                 {
    1684           0 :                     bRet = pTmpFrm->IsRightToLeft();
    1685           0 :                     break;
    1686             :                 }
    1687           0 :             pTmpFrm = aIter.Next();
    1688           0 :         }
    1689             :     }
    1690           0 :     return bRet;
    1691             : }
    1692             : 
    1693           0 : sal_Bool SwCrsrShell::SelectTxt( const sal_Int32 nStart,
    1694             :                                  const sal_Int32 nEnd )
    1695             : {
    1696           0 :     SET_CURR_SHELL( this );
    1697           0 :     sal_Bool bRet = sal_False;
    1698             : 
    1699           0 :     SwCallLink aLk( *this );
    1700           0 :     SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1701             : 
    1702           0 :     SwPosition& rPos = *m_pCurCrsr->GetPoint();
    1703           0 :     m_pCurCrsr->DeleteMark();
    1704           0 :     rPos.nContent = nStart;
    1705           0 :     m_pCurCrsr->SetMark();
    1706           0 :     rPos.nContent = nEnd;
    1707             : 
    1708           0 :     if( !m_pCurCrsr->IsSelOvr() )
    1709             :     {
    1710           0 :         UpdateCrsr();
    1711           0 :         bRet = sal_True;
    1712             :     }
    1713             : 
    1714           0 :     return bRet;
    1715             : }
    1716             : 
    1717           0 : sal_Bool SwCrsrShell::SelectTxtAttr( sal_uInt16 nWhich,
    1718             :                                      sal_Bool bExpand,
    1719             :                                      const SwTxtAttr* pTxtAttr )
    1720             : {
    1721           0 :     SET_CURR_SHELL( this );
    1722           0 :     sal_Bool bRet = sal_False;
    1723             : 
    1724           0 :     if( !IsTableMode() )
    1725             :     {
    1726           0 :         if( !pTxtAttr )
    1727             :         {
    1728           0 :             SwPosition& rPos = *m_pCurCrsr->GetPoint();
    1729           0 :             SwTxtNode* pTxtNd = rPos.nNode.GetNode().GetTxtNode();
    1730             :             pTxtAttr = (pTxtNd)
    1731             :                 ? pTxtNd->GetTxtAttrAt(rPos.nContent.GetIndex(),
    1732             :                         static_cast<RES_TXTATR>(nWhich),
    1733           0 :                         (bExpand) ? SwTxtNode::EXPAND : SwTxtNode::DEFAULT)
    1734           0 :                 : 0;
    1735             :         }
    1736             : 
    1737           0 :         if( pTxtAttr )
    1738             :         {
    1739           0 :             const sal_Int32* pEnd = pTxtAttr->End();
    1740           0 :             bRet = SelectTxt( *pTxtAttr->GetStart(), ( pEnd ? *pEnd : *pTxtAttr->GetStart() + 1 ) );
    1741             :         }
    1742             :     }
    1743           0 :     return bRet;
    1744             : }
    1745             : 
    1746           0 : bool SwCrsrShell::GotoINetAttr( const SwTxtINetFmt& rAttr )
    1747             : {
    1748           0 :     bool bRet = false;
    1749           0 :     if( rAttr.GetpTxtNode() )
    1750             :     {
    1751           0 :         SwCursor* pCrsr = getShellCrsr( true );
    1752             : 
    1753           0 :         SET_CURR_SHELL( this );
    1754           0 :         SwCallLink aLk( *this ); // watch Crsr-Moves
    1755           0 :         SwCrsrSaveState aSaveState( *pCrsr );
    1756             : 
    1757           0 :         pCrsr->GetPoint()->nNode = *rAttr.GetpTxtNode();
    1758           0 :         pCrsr->GetPoint()->nContent.Assign( (SwTxtNode*)rAttr.GetpTxtNode(),
    1759           0 :                                             *rAttr.GetStart() );
    1760           0 :         bRet = !pCrsr->IsSelOvr();
    1761           0 :         if( bRet )
    1762           0 :             UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
    1763             :     }
    1764           0 :     return bRet;
    1765             : }
    1766             : 
    1767           0 : const SwFmtINetFmt* SwCrsrShell::FindINetAttr( const OUString& rName ) const
    1768             : {
    1769           0 :     return mpDoc->FindINetAttr( rName );
    1770             : }
    1771             : 
    1772           0 : sal_Bool SwCrsrShell::GetShadowCrsrPos( const Point& rPt, SwFillMode eFillMode,
    1773             :                                 SwRect& rRect, sal_Int16& rOrient )
    1774             : {
    1775             : 
    1776           0 :     SET_CURR_SHELL( this );
    1777           0 :     sal_Bool bRet = sal_False;
    1778             : 
    1779           0 :     if (!IsTableMode() && !HasSelection()
    1780           0 :         && GetDoc()->GetIDocumentUndoRedo().DoesUndo())
    1781             :     {
    1782           0 :         Point aPt( rPt );
    1783           0 :         SwPosition aPos( *m_pCurCrsr->GetPoint() );
    1784             : 
    1785           0 :         SwFillCrsrPos aFPos( eFillMode );
    1786           0 :         SwCrsrMoveState aTmpState( &aFPos );
    1787             : 
    1788           0 :         if( GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState ) &&
    1789           0 :             !aPos.nNode.GetNode().IsProtect())
    1790             :         {
    1791             :             // start position in protected section?
    1792           0 :             rRect = aFPos.aCrsr;
    1793           0 :             rOrient = aFPos.eOrient;
    1794           0 :             bRet = sal_True;
    1795           0 :         }
    1796             :     }
    1797           0 :     return bRet;
    1798             : }
    1799             : 
    1800           0 : sal_Bool SwCrsrShell::SetShadowCrsrPos( const Point& rPt, SwFillMode eFillMode )
    1801             : {
    1802           0 :     SET_CURR_SHELL( this );
    1803           0 :     sal_Bool bRet = sal_False;
    1804             : 
    1805           0 :     if (!IsTableMode() && !HasSelection()
    1806           0 :         && GetDoc()->GetIDocumentUndoRedo().DoesUndo())
    1807             :     {
    1808           0 :         Point aPt( rPt );
    1809           0 :         SwPosition aPos( *m_pCurCrsr->GetPoint() );
    1810             : 
    1811           0 :         SwFillCrsrPos aFPos( eFillMode );
    1812           0 :         SwCrsrMoveState aTmpState( &aFPos );
    1813             : 
    1814           0 :         if( GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState ) )
    1815             :         {
    1816           0 :             SwCallLink aLk( *this ); // watch Crsr-Moves
    1817           0 :             StartAction();
    1818             : 
    1819           0 :             SwCntntNode* pCNd = aPos.nNode.GetNode().GetCntntNode();
    1820           0 :             SwUndoId nUndoId = UNDO_INS_FROM_SHADOWCRSR;
    1821             :             // If only the paragraph attributes "Adjust" or "LRSpace" are set,
    1822             :             // then the following should not delete those again.
    1823           0 :             if( 0 == aFPos.nParaCnt + aFPos.nColumnCnt &&
    1824           0 :                 ( FILL_INDENT == aFPos.eMode ||
    1825           0 :                   ( text::HoriOrientation::NONE != aFPos.eOrient &&
    1826           0 :                     0 == aFPos.nTabCnt + aFPos.nSpaceCnt )) &&
    1827           0 :                 pCNd && pCNd->Len() )
    1828           0 :                 nUndoId = UNDO_EMPTY;
    1829             : 
    1830           0 :             GetDoc()->GetIDocumentUndoRedo().StartUndo( nUndoId, NULL );
    1831             : 
    1832           0 :             SwTxtFmtColl* pNextFmt = 0;
    1833           0 :             SwTxtNode* pTNd = pCNd ? pCNd->GetTxtNode() : NULL;
    1834           0 :             if( pTNd )
    1835           0 :                 pNextFmt = &pTNd->GetTxtColl()->GetNextTxtFmtColl();
    1836             : 
    1837           0 :             const SwSectionNode* pSectNd = pCNd ? pCNd->FindSectionNode() : NULL;
    1838           0 :             if( pSectNd && aFPos.nParaCnt )
    1839             :             {
    1840           0 :                 SwNodeIndex aEnd( aPos.nNode, 1 );
    1841           0 :                 while( aEnd.GetNode().IsEndNode() &&
    1842           0 :                         (const SwNode*)&aEnd.GetNode() !=
    1843           0 :                         pSectNd->EndOfSectionNode() )
    1844           0 :                     ++aEnd;
    1845             : 
    1846           0 :                 if( aEnd.GetNode().IsEndNode() &&
    1847           0 :                     pCNd->Len() == aPos.nContent.GetIndex() )
    1848           0 :                     aPos.nNode = *pSectNd->EndOfSectionNode();
    1849             :             }
    1850             : 
    1851           0 :             for( sal_uInt16 n = 0; n < aFPos.nParaCnt + aFPos.nColumnCnt; ++n )
    1852             :             {
    1853           0 :                 GetDoc()->AppendTxtNode( aPos );
    1854           0 :                 if( !n && pNextFmt )
    1855             :                 {
    1856           0 :                     *m_pCurCrsr->GetPoint() = aPos;
    1857           0 :                     GetDoc()->SetTxtFmtColl( *m_pCurCrsr, pNextFmt, false );
    1858             :                 }
    1859           0 :                 if( n < aFPos.nColumnCnt )
    1860             :                 {
    1861           0 :                     *m_pCurCrsr->GetPoint() = aPos;
    1862           0 :                     GetDoc()->InsertPoolItem( *m_pCurCrsr,
    1863           0 :                             SvxFmtBreakItem( SVX_BREAK_COLUMN_BEFORE, RES_BREAK ), 0);
    1864             :                 }
    1865             :             }
    1866             : 
    1867           0 :             *m_pCurCrsr->GetPoint() = aPos;
    1868           0 :             switch( aFPos.eMode )
    1869             :             {
    1870             :             case FILL_INDENT:
    1871           0 :                 if( 0 != (pCNd = aPos.nNode.GetNode().GetCntntNode() ))
    1872             :                 {
    1873           0 :                     SfxItemSet aSet( GetDoc()->GetAttrPool(),
    1874             :                                     RES_LR_SPACE, RES_LR_SPACE,
    1875             :                                     RES_PARATR_ADJUST, RES_PARATR_ADJUST,
    1876           0 :                                     0 );
    1877             :                     SvxLRSpaceItem aLR( (SvxLRSpaceItem&)
    1878           0 :                                         pCNd->GetAttr( RES_LR_SPACE ) );
    1879           0 :                     aLR.SetTxtLeft( aFPos.nTabCnt );
    1880           0 :                     aLR.SetTxtFirstLineOfst( 0 );
    1881           0 :                     aSet.Put( aLR );
    1882             : 
    1883             :                     const SvxAdjustItem& rAdj = (SvxAdjustItem&)pCNd->
    1884           0 :                                         GetAttr( RES_PARATR_ADJUST );
    1885           0 :                     if( SVX_ADJUST_LEFT != rAdj.GetAdjust() )
    1886           0 :                         aSet.Put( SvxAdjustItem( SVX_ADJUST_LEFT, RES_PARATR_ADJUST ) );
    1887             : 
    1888           0 :                     GetDoc()->InsertItemSet( *m_pCurCrsr, aSet, 0 );
    1889             :                 }
    1890             :                 else {
    1891             :                     OSL_ENSURE( !this, "No CntntNode" );
    1892             :                 }
    1893           0 :                 break;
    1894             : 
    1895             :             case FILL_TAB:
    1896             :             case FILL_SPACE:
    1897             :                 {
    1898           0 :                     OUStringBuffer sInsert;
    1899           0 :                     if (aFPos.nTabCnt)
    1900           0 :                         comphelper::string::padToLength(sInsert, aFPos.nTabCnt, '\t');
    1901           0 :                     if (aFPos.nSpaceCnt)
    1902           0 :                         comphelper::string::padToLength(sInsert, sInsert.getLength() + aFPos.nSpaceCnt, ' ');
    1903           0 :                     if (!sInsert.isEmpty())
    1904           0 :                         GetDoc()->InsertString( *m_pCurCrsr, sInsert.makeStringAndClear());
    1905             :                 }
    1906             :                 // no break - still need to set orientation
    1907             :             case FILL_MARGIN:
    1908           0 :                 if( text::HoriOrientation::NONE != aFPos.eOrient )
    1909             :                 {
    1910           0 :                     SvxAdjustItem aAdj( SVX_ADJUST_LEFT, RES_PARATR_ADJUST );
    1911           0 :                     switch( aFPos.eOrient )
    1912             :                     {
    1913             :                     case text::HoriOrientation::CENTER:
    1914           0 :                         aAdj.SetAdjust( SVX_ADJUST_CENTER );
    1915           0 :                         break;
    1916             :                     case text::HoriOrientation::RIGHT:
    1917           0 :                         aAdj.SetAdjust( SVX_ADJUST_RIGHT );
    1918           0 :                         break;
    1919             :                     default:
    1920           0 :                         break;
    1921             :                     }
    1922           0 :                     GetDoc()->InsertPoolItem( *m_pCurCrsr, aAdj, 0 );
    1923             :                 }
    1924           0 :                 break;
    1925             :             }
    1926             : 
    1927           0 :             GetDoc()->GetIDocumentUndoRedo().EndUndo( nUndoId, NULL );
    1928           0 :             EndAction();
    1929             : 
    1930           0 :             bRet = sal_True;
    1931           0 :         }
    1932             :     }
    1933           0 :     return bRet;
    1934             : }
    1935             : 
    1936           0 : const SwRangeRedline* SwCrsrShell::SelNextRedline()
    1937             : {
    1938           0 :     const SwRangeRedline* pFnd = 0;
    1939           0 :     if( !IsTableMode() )
    1940             :     {
    1941           0 :         SET_CURR_SHELL( this );
    1942           0 :         SwCallLink aLk( *this ); // watch Crsr-Moves
    1943           0 :         SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1944             : 
    1945           0 :         pFnd = GetDoc()->SelNextRedline( *m_pCurCrsr );
    1946           0 :         if( pFnd && !m_pCurCrsr->IsInProtectTable() && !m_pCurCrsr->IsSelOvr() )
    1947           0 :             UpdateCrsr( SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
    1948             :         else
    1949           0 :             pFnd = 0;
    1950             :     }
    1951           0 :     return pFnd;
    1952             : }
    1953             : 
    1954           0 : const SwRangeRedline* SwCrsrShell::SelPrevRedline()
    1955             : {
    1956           0 :     const SwRangeRedline* pFnd = 0;
    1957           0 :     if( !IsTableMode() )
    1958             :     {
    1959           0 :         SET_CURR_SHELL( this );
    1960           0 :         SwCallLink aLk( *this ); // watch Crsr-Moves
    1961           0 :         SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1962             : 
    1963           0 :         pFnd = GetDoc()->SelPrevRedline( *m_pCurCrsr );
    1964           0 :         if( pFnd && !m_pCurCrsr->IsInProtectTable() && !m_pCurCrsr->IsSelOvr() )
    1965           0 :             UpdateCrsr( SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
    1966             :         else
    1967           0 :             pFnd = 0;
    1968             :     }
    1969           0 :     return pFnd;
    1970             : }
    1971             : 
    1972           0 : const SwRangeRedline* SwCrsrShell::_GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect )
    1973             : {
    1974           0 :     const SwRangeRedline* pFnd = 0;
    1975           0 :     SwCallLink aLk( *this ); // watch Crsr-Moves
    1976           0 :     SwCrsrSaveState aSaveState( *m_pCurCrsr );
    1977             : 
    1978           0 :     pFnd = GetDoc()->GetRedlineTbl()[ nArrPos ];
    1979           0 :     if( pFnd )
    1980             :     {
    1981           0 :         *m_pCurCrsr->GetPoint() = *pFnd->Start();
    1982             : 
    1983             :         SwCntntNode* pCNd;
    1984           0 :         SwNodeIndex* pIdx = &m_pCurCrsr->GetPoint()->nNode;
    1985           0 :         if( !pIdx->GetNode().IsCntntNode() &&
    1986           0 :             0 != ( pCNd = GetDoc()->GetNodes().GoNextSection( pIdx,
    1987           0 :                                     true, IsReadOnlyAvailable() )) )
    1988             :         {
    1989           0 :             if( *pIdx <= pFnd->End()->nNode )
    1990           0 :                 m_pCurCrsr->GetPoint()->nContent.Assign( pCNd, 0 );
    1991             :             else
    1992           0 :                 pFnd = 0;
    1993             :         }
    1994             : 
    1995           0 :         if( pFnd && bSelect )
    1996             :         {
    1997           0 :             m_pCurCrsr->SetMark();
    1998           0 :             if( nsRedlineType_t::REDLINE_FMTCOLL == pFnd->GetType() )
    1999             :             {
    2000           0 :                 pCNd = pIdx->GetNode().GetCntntNode();
    2001           0 :                 m_pCurCrsr->GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
    2002           0 :                 m_pCurCrsr->GetMark()->nContent.Assign( pCNd, 0 );
    2003             :             }
    2004             :             else
    2005           0 :                 *m_pCurCrsr->GetPoint() = *pFnd->End();
    2006             : 
    2007           0 :             pIdx = &m_pCurCrsr->GetPoint()->nNode;
    2008           0 :             if( !pIdx->GetNode().IsCntntNode() &&
    2009           0 :                 0 != ( pCNd = GetDoc()->GetNodes().GoPrevSection( pIdx,
    2010           0 :                                             true, IsReadOnlyAvailable() )) )
    2011             :             {
    2012           0 :                 if( *pIdx >= m_pCurCrsr->GetMark()->nNode )
    2013           0 :                     m_pCurCrsr->GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
    2014             :                 else
    2015           0 :                     pFnd = 0;
    2016             :             }
    2017             :         }
    2018             : 
    2019           0 :         if( !pFnd )
    2020             :         {
    2021           0 :             m_pCurCrsr->DeleteMark();
    2022           0 :             m_pCurCrsr->RestoreSavePos();
    2023             :         }
    2024           0 :         else if( bSelect && *m_pCurCrsr->GetMark() == *m_pCurCrsr->GetPoint() )
    2025           0 :             m_pCurCrsr->DeleteMark();
    2026             : 
    2027           0 :         if( pFnd && !m_pCurCrsr->IsInProtectTable() && !m_pCurCrsr->IsSelOvr() )
    2028             :             UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE
    2029           0 :                         | SwCrsrShell::READONLY );
    2030             :         else
    2031             :         {
    2032           0 :             pFnd = 0;
    2033           0 :             if( bSelect )
    2034           0 :                 m_pCurCrsr->DeleteMark();
    2035             :         }
    2036             :     }
    2037           0 :     return pFnd;
    2038             : }
    2039             : 
    2040           0 : const SwRangeRedline* SwCrsrShell::GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect )
    2041             : {
    2042           0 :     const SwRangeRedline* pFnd = 0;
    2043           0 :     if( !IsTableMode() )
    2044             :     {
    2045           0 :         SET_CURR_SHELL( this );
    2046             : 
    2047           0 :         const SwRedlineTbl& rTbl = GetDoc()->GetRedlineTbl();
    2048           0 :         const SwRangeRedline* pTmp = rTbl[ nArrPos ];
    2049           0 :         sal_uInt16 nSeqNo = pTmp->GetSeqNo();
    2050           0 :         if( nSeqNo && bSelect )
    2051             :         {
    2052           0 :             bool bCheck = false;
    2053           0 :             int nLoopCnt = 2;
    2054           0 :             sal_uInt16 nArrSavPos = nArrPos;
    2055             : 
    2056           0 :             do {
    2057           0 :                 pTmp = _GotoRedline( nArrPos, sal_True );
    2058             : 
    2059           0 :                 if( !pFnd )
    2060           0 :                     pFnd = pTmp;
    2061             : 
    2062           0 :                 if( pTmp && bCheck )
    2063             :                 {
    2064             :                     // Check for overlaps. These can happen when FmtColl-
    2065             :                     // Redlines were streched over a whole paragraph
    2066           0 :                     SwPaM* pCur = m_pCurCrsr;
    2067           0 :                     SwPaM* pNextPam = (SwPaM*)pCur->GetNext();
    2068           0 :                     SwPosition* pCStt = pCur->Start(), *pCEnd = pCur->End();
    2069           0 :                     while( pCur != pNextPam )
    2070             :                     {
    2071           0 :                         const SwPosition *pNStt = pNextPam->Start(),
    2072           0 :                                          *pNEnd = pNextPam->End();
    2073             : 
    2074           0 :                         bool bDel = true;
    2075           0 :                         switch( ::ComparePosition( *pCStt, *pCEnd,
    2076           0 :                                                    *pNStt, *pNEnd ))
    2077             :                         {
    2078             :                         case POS_INSIDE:         // Pos1 is completely in Pos2
    2079           0 :                             if( !pCur->HasMark() )
    2080             :                             {
    2081           0 :                                 pCur->SetMark();
    2082           0 :                                 *pCur->GetMark() = *pNStt;
    2083             :                             }
    2084             :                             else
    2085           0 :                                 *pCStt = *pNStt;
    2086           0 :                             *pCEnd = *pNEnd;
    2087           0 :                             break;
    2088             : 
    2089             :                         case POS_OUTSIDE:        // Pos2 is completely in Pos1
    2090             :                         case POS_EQUAL:          // Pos1 has same size as Pos2
    2091           0 :                             break;
    2092             : 
    2093             :                         case POS_OVERLAP_BEFORE: // Pos1 overlaps Pos2 at beginning
    2094           0 :                             if( !pCur->HasMark() )
    2095           0 :                                 pCur->SetMark();
    2096           0 :                             *pCEnd = *pNEnd;
    2097           0 :                             break;
    2098             :                         case POS_OVERLAP_BEHIND: // Pos1 overlaps Pos2 at end
    2099           0 :                             if( !pCur->HasMark() )
    2100             :                             {
    2101           0 :                                 pCur->SetMark();
    2102           0 :                                 *pCur->GetMark() = *pNStt;
    2103             :                             }
    2104             :                             else
    2105           0 :                                 *pCStt = *pNStt;
    2106           0 :                             break;
    2107             : 
    2108             :                         default:
    2109           0 :                             bDel = false;
    2110             :                         }
    2111             : 
    2112           0 :                         if( bDel )
    2113             :                         {
    2114             :                             // not needed anymore
    2115           0 :                             SwPaM* pPrevPam = (SwPaM*)pNextPam->GetPrev();
    2116           0 :                             delete pNextPam;
    2117           0 :                             pNextPam = pPrevPam;
    2118             :                         }
    2119           0 :                         pNextPam = (SwPaM*)pNextPam->GetNext();
    2120             :                     }
    2121             :                 }
    2122             : 
    2123             :                 sal_uInt16 nFndPos = 2 == nLoopCnt
    2124           0 :                                     ? rTbl.FindNextOfSeqNo( nArrPos )
    2125           0 :                                     : rTbl.FindPrevOfSeqNo( nArrPos );
    2126           0 :                 if( USHRT_MAX != nFndPos ||
    2127           0 :                     ( 0 != ( --nLoopCnt ) && USHRT_MAX != (
    2128           0 :                             nFndPos = rTbl.FindPrevOfSeqNo( nArrSavPos ))) )
    2129             :                 {
    2130           0 :                     if( pTmp )
    2131             :                     {
    2132             :                         // create new cursor
    2133           0 :                         CreateCrsr();
    2134           0 :                         bCheck = true;
    2135             :                     }
    2136           0 :                     nArrPos = nFndPos;
    2137             :                 }
    2138             :                 else
    2139           0 :                     nLoopCnt = 0;
    2140             : 
    2141           0 :             } while( nLoopCnt );
    2142             :         }
    2143             :         else
    2144           0 :             pFnd = _GotoRedline( nArrPos, bSelect );
    2145             :     }
    2146           0 :     return pFnd;
    2147             : }
    2148             : 
    2149           0 : bool SwCrsrShell::SelectNxtPrvHyperlink( bool bNext )
    2150             : {
    2151           0 :     SwNodes& rNds = GetDoc()->GetNodes();
    2152           0 :     const SwNode* pBodyEndNd = &rNds.GetEndOfContent();
    2153           0 :     const SwNode* pBodySttNd = pBodyEndNd->StartOfSectionNode();
    2154           0 :     sal_uLong nBodySttNdIdx = pBodySttNd->GetIndex();
    2155           0 :     Point aPt;
    2156             : 
    2157           0 :     _SetGetExpFld aCmpPos( SwPosition( bNext ? *pBodyEndNd : *pBodySttNd ) );
    2158           0 :     _SetGetExpFld aCurPos( bNext ? *m_pCurCrsr->End() : *m_pCurCrsr->Start() );
    2159           0 :     if( aCurPos.GetNode() < nBodySttNdIdx )
    2160             :     {
    2161           0 :         const SwCntntNode* pCNd = aCurPos.GetNodeFromCntnt()->GetCntntNode();
    2162             :         SwCntntFrm* pFrm;
    2163           0 :         if( pCNd && 0 != ( pFrm = pCNd->getLayoutFrm( GetLayout(), &aPt )) )
    2164           0 :             aCurPos.SetBodyPos( *pFrm );
    2165             :     }
    2166             : 
    2167             :     // check first all the hyperlink fields
    2168             :     {
    2169             :         const SwTxtNode* pTxtNd;
    2170           0 :         const SwCharFmts* pFmts = GetDoc()->GetCharFmts();
    2171           0 :         for( sal_uInt16 n = pFmts->size(); 1 < n; )
    2172             :         {
    2173           0 :             SwIterator<SwTxtINetFmt,SwCharFmt> aIter(*(*pFmts)[--n]);
    2174             : 
    2175           0 :             for( SwTxtINetFmt* pFnd = aIter.First(); pFnd; pFnd = aIter.Next() )
    2176           0 :                 if( 0 != ( pTxtNd = pFnd->GetpTxtNode()) &&
    2177           0 :                     pTxtNd->GetNodes().IsDocNodes() )
    2178             :                 {
    2179           0 :                     SwTxtINetFmt& rAttr = *pFnd;
    2180           0 :                     SwPosition aTmpPos( *pTxtNd );
    2181           0 :                     _SetGetExpFld aPos( aTmpPos.nNode, rAttr );
    2182             :                     SwCntntFrm* pFrm;
    2183           0 :                     if( pTxtNd->GetIndex() < nBodySttNdIdx &&
    2184           0 :                         0 != ( pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt )) )
    2185           0 :                         aPos.SetBodyPos( *pFrm );
    2186             : 
    2187           0 :                     if( bNext
    2188           0 :                         ? ( aPos < aCmpPos && aCurPos < aPos )
    2189           0 :                         : ( aCmpPos < aPos && aPos < aCurPos ))
    2190             :                     {
    2191           0 :                         OUString sTxt( pTxtNd->GetExpandTxt( *rAttr.GetStart(),
    2192           0 :                                         *rAttr.GetEnd() - *rAttr.GetStart() ) );
    2193             : 
    2194           0 :                         sTxt = comphelper::string::remove(sTxt, 0x0a);
    2195           0 :                         sTxt = comphelper::string::strip(sTxt, ' ');
    2196             : 
    2197           0 :                         if( !sTxt.isEmpty() )
    2198           0 :                             aCmpPos = aPos;
    2199           0 :                     }
    2200             :                 }
    2201           0 :         }
    2202             :     }
    2203             : 
    2204             :     // then check all the Flys with a URL or imapge map
    2205             :     {
    2206           0 :         const SwFrmFmts* pFmts = GetDoc()->GetSpzFrmFmts();
    2207           0 :         for( sal_uInt16 n = 0, nEnd = pFmts->size(); n < nEnd; ++n )
    2208             :         {
    2209           0 :             SwFlyFrmFmt* pFmt = (SwFlyFrmFmt*)(*pFmts)[ n ];
    2210           0 :             const SwFmtURL& rURLItem = pFmt->GetURL();
    2211           0 :             if( rURLItem.GetMap() || !rURLItem.GetURL().isEmpty() )
    2212             :             {
    2213           0 :                 SwFlyFrm* pFly = pFmt->GetFrm( &aPt, sal_False );
    2214           0 :                 SwPosition aTmpPos( *pBodySttNd );
    2215           0 :                 if( pFly &&
    2216           0 :                     GetBodyTxtNode( *GetDoc(), aTmpPos, *pFly->GetLower() ) )
    2217             :                 {
    2218           0 :                     _SetGetExpFld aPos( *pFmt, &aTmpPos );
    2219             : 
    2220           0 :                     if( bNext
    2221           0 :                             ? ( aPos < aCmpPos && aCurPos < aPos )
    2222           0 :                             : ( aCmpPos < aPos && aPos < aCurPos ))
    2223           0 :                         aCmpPos = aPos;
    2224           0 :                 }
    2225             :             }
    2226             :         }
    2227             :     }
    2228             : 
    2229             :     // found any URL ?
    2230           0 :     bool bRet = false;
    2231           0 :     const SwTxtINetFmt* pFndAttr = aCmpPos.GetINetFmt();
    2232           0 :     const SwFlyFrmFmt* pFndFmt = aCmpPos.GetFlyFmt();
    2233           0 :     if( pFndAttr || pFndFmt )
    2234             :     {
    2235           0 :         SET_CURR_SHELL( this );
    2236           0 :         SwCallLink aLk( *this );
    2237             : 
    2238             :         // found a text attribute ?
    2239           0 :         if( pFndAttr )
    2240             :         {
    2241           0 :             SwCrsrSaveState aSaveState( *m_pCurCrsr );
    2242             : 
    2243           0 :             aCmpPos.GetPosOfContent( *m_pCurCrsr->GetPoint() );
    2244           0 :             m_pCurCrsr->DeleteMark();
    2245           0 :             m_pCurCrsr->SetMark();
    2246           0 :             m_pCurCrsr->GetPoint()->nContent = *pFndAttr->End();
    2247             : 
    2248           0 :             if( !m_pCurCrsr->IsInProtectTable() && !m_pCurCrsr->IsSelOvr() )
    2249             :             {
    2250             :                 UpdateCrsr( SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|
    2251           0 :                                     SwCrsrShell::READONLY );
    2252           0 :                 bRet = true;
    2253           0 :             }
    2254             :         }
    2255             :         // found a draw object ?
    2256           0 :         else if( RES_DRAWFRMFMT == pFndFmt->Which() )
    2257             :         {
    2258           0 :             const SdrObject* pSObj = pFndFmt->FindSdrObject();
    2259           0 :             ((SwFEShell*)this)->SelectObj( pSObj->GetCurrentBoundRect().Center() );
    2260           0 :             MakeSelVisible();
    2261           0 :             bRet = true;
    2262             :         }
    2263             :         else // then is it a fly
    2264             :         {
    2265           0 :             SwFlyFrm* pFly = pFndFmt->GetFrm(&aPt, sal_False );
    2266           0 :             if( pFly )
    2267             :             {
    2268           0 :                 ((SwFEShell*)this)->SelectFlyFrm( *pFly, sal_True );
    2269           0 :                 MakeSelVisible();
    2270           0 :                 bRet = true;
    2271             :             }
    2272           0 :         }
    2273             :     }
    2274           0 :     return bRet;
    2275             : }
    2276             : 
    2277             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10