LCOV - code coverage report
Current view: top level - sw/source/core/edit - editsh.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 113 563 20.1 %
Date: 2014-11-03 Functions: 11 58 19.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 <vcl/cmdevt.hxx>
      22             : #include <unotools/charclass.hxx>
      23             : #include <comphelper/processfactory.hxx>
      24             : #include <comphelper/string.hxx>
      25             : #include <unotools/transliterationwrapper.hxx>
      26             : #include <swwait.hxx>
      27             : #include <fmtsrnd.hxx>
      28             : #include <fmtinfmt.hxx>
      29             : #include <txtinet.hxx>
      30             : #include <frmfmt.hxx>
      31             : #include <charfmt.hxx>
      32             : #include <doc.hxx>
      33             : #include <IDocumentUndoRedo.hxx>
      34             : #include <IDocumentSettingAccess.hxx>
      35             : #include <IDocumentLinksAdministration.hxx>
      36             : #include <IDocumentFieldsAccess.hxx>
      37             : #include <IDocumentStatistics.hxx>
      38             : #include <IDocumentState.hxx>
      39             : #include <docary.hxx>
      40             : #include <editsh.hxx>
      41             : #include <frame.hxx>
      42             : #include <cntfrm.hxx>
      43             : #include <pam.hxx>
      44             : #include <ndtxt.hxx>
      45             : #include <grfatr.hxx>
      46             : #include <flyfrm.hxx>
      47             : #include <swtable.hxx>
      48             : #include <swundo.hxx>
      49             : #include <calc.hxx>
      50             : #include <edimp.hxx>
      51             : #include <ndgrf.hxx>
      52             : #include <ndole.hxx>
      53             : #include <txtfrm.hxx>
      54             : #include <rootfrm.hxx>
      55             : #include <extinput.hxx>
      56             : #include <crsskip.hxx>
      57             : #include <scriptinfo.hxx>
      58             : #include <unocrsrhelper.hxx>
      59             : #include <section.hxx>
      60             : #include <unochart.hxx>
      61             : #include <numrule.hxx>
      62             : #include <SwNodeNum.hxx>
      63             : #include <unocrsr.hxx>
      64             : #include <switerator.hxx>
      65             : 
      66             : using namespace com::sun::star;
      67             : 
      68           0 : void SwEditShell::Insert( sal_Unicode c, bool bOnlyCurrCrsr )
      69             : {
      70           0 :     StartAllAction();
      71           0 :     FOREACHPAM_START(GetCrsr())
      72             : 
      73           0 :         const bool bSuccess = GetDoc()->getIDocumentContentOperations().InsertString(*PCURCRSR, OUString(c));
      74             :         OSL_ENSURE( bSuccess, "Doc->Insert() failed." );
      75             :         (void) bSuccess;
      76             : 
      77           0 :         SaveTblBoxCntnt( PCURCRSR->GetPoint() );
      78           0 :         if( bOnlyCurrCrsr )
      79           0 :             break;
      80             : 
      81           0 :     FOREACHPAM_END()
      82             : 
      83           0 :     EndAllAction();
      84           0 : }
      85             : 
      86          18 : void SwEditShell::Insert2(const OUString &rStr, const bool bForceExpandHints )
      87             : {
      88          18 :     StartAllAction();
      89             :     {
      90             :         const enum IDocumentContentOperations::InsertFlags nInsertFlags =
      91             :             (bForceExpandHints)
      92             :             ? static_cast<IDocumentContentOperations::InsertFlags>(
      93             :                     IDocumentContentOperations::INS_FORCEHINTEXPAND |
      94             :                     IDocumentContentOperations::INS_EMPTYEXPAND)
      95          18 :             : IDocumentContentOperations::INS_EMPTYEXPAND;
      96             : 
      97          18 :         SwPaM *_pStartCrsr = getShellCrsr( true ), *__pStartCrsr = _pStartCrsr;
      98          18 :         do {
      99             :             //OPT: GetSystemCharSet
     100             :             const bool bSuccess =
     101          18 :                 GetDoc()->getIDocumentContentOperations().InsertString(*_pStartCrsr, rStr, nInsertFlags);
     102             :             OSL_ENSURE( bSuccess, "Doc->Insert() failed." );
     103             : 
     104          18 :             if (bSuccess)
     105             :             {
     106          18 :                 GetDoc()->UpdateRsid( *_pStartCrsr, rStr.getLength() );
     107             : 
     108             :                 // Set paragraph rsid if beginning of paragraph
     109             :                 SwTxtNode *const pTxtNode =
     110          18 :                     _pStartCrsr->GetPoint()->nNode.GetNode().GetTxtNode();
     111          18 :                 if( pTxtNode && pTxtNode->Len() == 1)
     112           4 :                     GetDoc()->UpdateParRsid( pTxtNode );
     113             :             }
     114             : 
     115          18 :             SaveTblBoxCntnt( _pStartCrsr->GetPoint() );
     116             : 
     117          18 :         } while( (_pStartCrsr=(SwPaM *)_pStartCrsr->GetNext()) != __pStartCrsr );
     118             :     }
     119             : 
     120             :     // calculate cursor bidi level
     121          18 :     SwCursor* pTmpCrsr = _GetCrsr();
     122          18 :     const bool bDoNotSetBidiLevel = ! pTmpCrsr ||
     123          36 :                                 ( 0 != dynamic_cast<SwUnoCrsr*>(pTmpCrsr) );
     124             : 
     125          18 :     if ( ! bDoNotSetBidiLevel )
     126             :     {
     127          18 :         SwNode& rNode = pTmpCrsr->GetPoint()->nNode.GetNode();
     128          18 :         if ( rNode.IsTxtNode() )
     129             :         {
     130          18 :             SwIndex& rIdx = pTmpCrsr->GetPoint()->nContent;
     131          18 :             sal_Int32 nPos = rIdx.GetIndex();
     132          18 :             sal_Int32 nPrevPos = nPos;
     133          18 :             if ( nPrevPos )
     134          18 :                 --nPrevPos;
     135             : 
     136          18 :             SwScriptInfo* pSI = SwScriptInfo::GetScriptInfo( ((SwTxtNode&)rNode), true );
     137             : 
     138          18 :             sal_uInt8 nLevel = 0;
     139          18 :             if ( ! pSI )
     140             :             {
     141             :                 // seems to be an empty paragraph.
     142          12 :                 Point aPt;
     143             :                 SwCntntFrm* pFrm =
     144          12 :                         ((SwTxtNode&)rNode).getLayoutFrm( GetLayout(), &aPt, pTmpCrsr->GetPoint(),
     145          12 :                                                     false );
     146             : 
     147          12 :                 SwScriptInfo aScriptInfo;
     148          12 :                 aScriptInfo.InitScriptInfo( (SwTxtNode&)rNode, pFrm->IsRightToLeft() );
     149          12 :                 nLevel = aScriptInfo.DirType( nPrevPos );
     150             :             }
     151             :             else
     152             :             {
     153           6 :                 if ( COMPLETE_STRING != pSI->GetInvalidityA() )
     154           6 :                     pSI->InitScriptInfo( (SwTxtNode&)rNode );
     155           6 :                 nLevel = pSI->DirType( nPrevPos );
     156             :             }
     157             : 
     158          18 :             pTmpCrsr->SetCrsrBidiLevel( nLevel );
     159             :         }
     160             :     }
     161             : 
     162          18 :     SetInFrontOfLabel( false ); // #i27615#
     163             : 
     164          18 :     EndAllAction();
     165          18 : }
     166             : 
     167           0 : void SwEditShell::Overwrite(const OUString &rStr)
     168             : {
     169           0 :     StartAllAction();
     170           0 :     FOREACHPAM_START(GetCrsr())
     171           0 :         if( !GetDoc()->getIDocumentContentOperations().Overwrite(*PCURCRSR, rStr ) )
     172             :         {
     173             :             OSL_FAIL( "Doc->getIDocumentContentOperations().Overwrite(Str) failed." );
     174             :         }
     175           0 :         SaveTblBoxCntnt( PCURCRSR->GetPoint() );
     176           0 :     FOREACHPAM_END()
     177           0 :     EndAllAction();
     178           0 : }
     179             : 
     180          12 : long SwEditShell::SplitNode( bool bAutoFormat, bool bCheckTableStart )
     181             : {
     182          12 :     StartAllAction();
     183          12 :     GetDoc()->GetIDocumentUndoRedo().StartUndo(UNDO_EMPTY, NULL);
     184             : 
     185          24 :     FOREACHPAM_START(GetCrsr())
     186             :         // Here, a table cell becomes a normal text cell.
     187          12 :         GetDoc()->ClearBoxNumAttrs( PCURCRSR->GetPoint()->nNode );
     188          12 :         GetDoc()->getIDocumentContentOperations().SplitNode( *PCURCRSR->GetPoint(), bCheckTableStart );
     189          12 :     FOREACHPAM_END()
     190             : 
     191          12 :     GetDoc()->GetIDocumentUndoRedo().EndUndo(UNDO_EMPTY, NULL);
     192             : 
     193          12 :     if( bAutoFormat )
     194           0 :         AutoFmtBySplitNode();
     195             : 
     196          12 :     ClearTblBoxCntnt();
     197             : 
     198          12 :     EndAllAction();
     199          12 :     return(1L);
     200             : }
     201             : 
     202           0 : bool SwEditShell::AppendTxtNode()
     203             : {
     204           0 :     bool bRet = false;
     205           0 :     StartAllAction();
     206           0 :     GetDoc()->GetIDocumentUndoRedo().StartUndo(UNDO_EMPTY, NULL);
     207             : 
     208           0 :     FOREACHPAM_START(GetCrsr())
     209           0 :         GetDoc()->ClearBoxNumAttrs( PCURCRSR->GetPoint()->nNode );
     210           0 :         bRet = GetDoc()->getIDocumentContentOperations().AppendTxtNode( *PCURCRSR->GetPoint()) || bRet;
     211           0 :     FOREACHPAM_END()
     212             : 
     213           0 :     GetDoc()->GetIDocumentUndoRedo().EndUndo(UNDO_EMPTY, NULL);
     214             : 
     215           0 :     ClearTblBoxCntnt();
     216             : 
     217           0 :     EndAllAction();
     218           0 :     return bRet;
     219             : }
     220             : 
     221             : // the returned SwGrfNode pointer is used in GetGraphic() and GetGraphicSize()
     222           0 : SwGrfNode * SwEditShell::_GetGrfNode() const
     223             : {
     224           0 :     SwGrfNode *pGrfNode = 0;
     225           0 :     SwPaM* pCrsr = GetCrsr();
     226           0 :     if( !pCrsr->HasMark() ||
     227           0 :         pCrsr->GetPoint()->nNode == pCrsr->GetMark()->nNode )
     228           0 :         pGrfNode = pCrsr->GetPoint()->nNode.GetNode().GetGrfNode();
     229             : 
     230           0 :     return pGrfNode;
     231             : }
     232             : 
     233             : // returns a Graphic pointer if CurCrsr->GetPoint() points to a SwGrfNode and
     234             : // GetMark is not set or points to the same Graphic
     235           0 : const Graphic* SwEditShell::GetGraphic( bool bWait ) const
     236             : {
     237           0 :     SwGrfNode* pGrfNode = _GetGrfNode();
     238           0 :     const Graphic* pGrf( 0L );
     239           0 :     if ( pGrfNode )
     240             :     {
     241           0 :         pGrf = &(pGrfNode->GetGrf());
     242             :         // --> #i73788#
     243             :         // no load of linked graphic, if its not needed now (bWait = sal_False).
     244           0 :         if ( bWait )
     245             :         {
     246           0 :             if( pGrf->IsSwapOut() ||
     247           0 :                 ( pGrfNode->IsLinkedFile() && GRAPHIC_DEFAULT == pGrf->GetType() ) )
     248             :             {
     249           0 :                 bool const bResult = pGrfNode->SwapIn(bWait);
     250             :                 OSL_ENSURE(bResult || !bWait, "Graphic could not be loaded" );
     251             :                 (void) bResult; // unused in non-debug
     252             :             }
     253             :         }
     254             :         else
     255             :         {
     256           0 :             if ( pGrf->IsSwapOut() && !pGrfNode->IsLinkedFile() )
     257             :             {
     258           0 :                 bool const bResult = pGrfNode->SwapIn(bWait);
     259             :                 OSL_ENSURE(bResult || !bWait, "Graphic could not be loaded" );
     260             :                 (void) bResult; // unused in non-debug
     261             :             }
     262             :         }
     263             :     }
     264           0 :     return pGrf;
     265             : }
     266             : 
     267           0 : bool SwEditShell::IsGrfSwapOut( bool bOnlyLinked ) const
     268             : {
     269           0 :     SwGrfNode *pGrfNode = _GetGrfNode();
     270           0 :     return pGrfNode &&
     271           0 :         (bOnlyLinked ? ( pGrfNode->IsLinkedFile() &&
     272           0 :                         ( GRAPHIC_DEFAULT == pGrfNode->GetGrfObj().GetType()||
     273           0 :                           pGrfNode->GetGrfObj().IsSwappedOut()))
     274           0 :                      : pGrfNode->GetGrfObj().IsSwappedOut());
     275             : }
     276             : 
     277           0 : const GraphicObject* SwEditShell::GetGraphicObj() const
     278             : {
     279           0 :     SwGrfNode* pGrfNode = _GetGrfNode();
     280           0 :     return pGrfNode ? &(pGrfNode->GetGrfObj()) : 0L;
     281             : }
     282             : 
     283           0 : sal_uInt16 SwEditShell::GetGraphicType() const
     284             : {
     285           0 :     SwGrfNode *pGrfNode = _GetGrfNode();
     286           0 :     return static_cast<sal_uInt16>(pGrfNode ? pGrfNode->GetGrfObj().GetType() : GRAPHIC_NONE);
     287             : }
     288             : 
     289             : // returns the size of a graphic in <rSz> if CurCrsr->GetPoint() points to a SwGrfNode and
     290             : // GetMark is not set or points to the same graphic
     291           0 : bool SwEditShell::GetGrfSize(Size& rSz) const
     292             : {
     293             :     SwNoTxtNode* pNoTxtNd;
     294           0 :     SwPaM* pCurrentCrsr = GetCrsr();
     295           0 :     if( ( !pCurrentCrsr->HasMark()
     296           0 :          || pCurrentCrsr->GetPoint()->nNode == pCurrentCrsr->GetMark()->nNode )
     297           0 :          && 0 != ( pNoTxtNd = pCurrentCrsr->GetNode().GetNoTxtNode() ) )
     298             :     {
     299           0 :         rSz = pNoTxtNd->GetTwipSize();
     300           0 :         return true;
     301             :     }
     302           0 :     return false;
     303             : 
     304             : }
     305             : 
     306             : /// Read again if graphic is not OK and replace old one
     307           0 : void SwEditShell::ReRead( const OUString& rGrfName, const OUString& rFltName,
     308             :                     const Graphic* pGraphic, const GraphicObject* pGrfObj )
     309             : {
     310           0 :     StartAllAction();
     311           0 :     mpDoc->getIDocumentContentOperations().ReRead( *GetCrsr(), rGrfName, rFltName, pGraphic, pGrfObj );
     312           0 :     EndAllAction();
     313           0 : }
     314             : 
     315             : /// Returns the name and the filter name of a graphic if the pointer is on a graphic.
     316             : /// If a String-pointer is != 0 then return corresponding name.
     317           0 : void SwEditShell::GetGrfNms( OUString* pGrfName, OUString* pFltName,
     318             :                             const SwFlyFrmFmt* pFmt ) const
     319             : {
     320             :     OSL_ENSURE( pGrfName || pFltName, "No parameters" );
     321           0 :     if( pFmt )
     322           0 :         GetDoc()->GetGrfNms( *pFmt, pGrfName, pFltName );
     323             :     else
     324             :     {
     325           0 :         SwGrfNode *pGrfNode = _GetGrfNode();
     326           0 :         if( pGrfNode && pGrfNode->IsLinkedFile() )
     327           0 :             pGrfNode->GetFileFilterNms( pGrfName, pFltName );
     328             :     }
     329           0 : }
     330             : 
     331           0 : const tools::PolyPolygon *SwEditShell::GetGraphicPolygon() const
     332             : {
     333           0 :     SwNoTxtNode *pNd = GetCrsr()->GetNode().GetNoTxtNode();
     334           0 :     return pNd->HasContour();
     335             : }
     336             : 
     337           0 : void SwEditShell::SetGraphicPolygon( const tools::PolyPolygon *pPoly )
     338             : {
     339           0 :     SwNoTxtNode *pNd = GetCrsr()->GetNode().GetNoTxtNode();
     340           0 :     StartAllAction();
     341           0 :     pNd->SetContour( pPoly );
     342           0 :     SwFlyFrm *pFly = (SwFlyFrm*)pNd->getLayoutFrm(GetLayout())->GetUpper();
     343           0 :     const SwFmtSurround &rSur = pFly->GetFmt()->GetSurround();
     344           0 :     pFly->GetFmt()->NotifyClients( (SwFmtSurround*)&rSur, (SwFmtSurround*)&rSur );
     345           0 :     GetDoc()->getIDocumentState().SetModified();
     346           0 :     EndAllAction();
     347           0 : }
     348             : 
     349           0 : void SwEditShell::ClearAutomaticContour()
     350             : {
     351           0 :     SwNoTxtNode *pNd = GetCrsr()->GetNode().GetNoTxtNode();
     352             :     OSL_ENSURE( pNd, "is no NoTxtNode!" );
     353           0 :     if( pNd->HasAutomaticContour() )
     354             :     {
     355           0 :         StartAllAction();
     356           0 :         pNd->SetContour( NULL, false );
     357           0 :         SwFlyFrm *pFly = (SwFlyFrm*)pNd->getLayoutFrm(GetLayout())->GetUpper();
     358           0 :         const SwFmtSurround &rSur = pFly->GetFmt()->GetSurround();
     359           0 :         pFly->GetFmt()->NotifyClients( (SwFmtSurround*)&rSur, (SwFmtSurround*)&rSur );
     360           0 :         GetDoc()->getIDocumentState().SetModified();
     361           0 :         EndAllAction();
     362             :     }
     363           0 : }
     364             : 
     365             : /** Get OLE object at pointer.
     366             :  *
     367             :  * Returns a pointer to a SvInPlaceObjectRef if CurCrsr->GetPoint() points to a SwOLENode and
     368             :  * GetMark is not set or points to the same object reference. Gets this pointer from the Doc
     369             :  * if the object should be searched by name.
     370             :  */
     371           0 : svt::EmbeddedObjectRef& SwEditShell::GetOLEObject() const
     372             : {
     373             :     OSL_ENSURE(  CNT_OLE == GetCntType(), "GetOLEObj: no OLENode." );
     374             :     OSL_ENSURE( !GetCrsr()->HasMark() ||
     375             :             (GetCrsr()->HasMark() &&
     376             :                 GetCrsr()->GetPoint()->nNode == GetCrsr()->GetMark()->nNode),
     377             :             "GetOLEObj: no OLENode." );
     378             : 
     379           0 :     SwOLENode *pOLENode = GetCrsr()->GetNode().GetOLENode();
     380             :     OSL_ENSURE( pOLENode, "GetOLEObj: no OLENode." );
     381           0 :     SwOLEObj& rOObj = pOLENode->GetOLEObj();
     382           0 :     return rOObj.GetObject();
     383             : }
     384             : 
     385           0 : bool SwEditShell::HasOLEObj( const OUString &rName ) const
     386             : {
     387             :     SwStartNode *pStNd;
     388           0 :     SwNodeIndex aIdx( *GetNodes().GetEndOfAutotext().StartOfSectionNode(), 1 );
     389           0 :     while ( 0 != (pStNd = aIdx.GetNode().GetStartNode()) )
     390             :     {
     391           0 :         ++aIdx;
     392           0 :         SwNode& rNd = aIdx.GetNode();
     393           0 :         if( rNd.IsOLENode() &&
     394           0 :             rName == ((SwOLENode&)rNd).GetChartTblName() &&
     395           0 :             ((SwOLENode&)rNd).getLayoutFrm( GetLayout() ) )
     396           0 :             return true;
     397             : 
     398           0 :         aIdx.Assign( *pStNd->EndOfSectionNode(), + 1 );
     399             :     }
     400           0 :     return false;
     401             : }
     402             : 
     403           0 : void SwEditShell::SetChartName( const OUString &rName )
     404             : {
     405           0 :     SwOLENode *pONd = GetCrsr()->GetNode().GetOLENode();
     406             :     OSL_ENSURE( pONd, "ChartNode not found" );
     407           0 :     pONd->SetChartTblName( rName );
     408           0 : }
     409             : 
     410           0 : void SwEditShell::UpdateCharts( const OUString &rName )
     411             : {
     412           0 :     GetDoc()->UpdateCharts( rName );
     413           0 : }
     414             : 
     415             : /// change table name
     416           0 : void SwEditShell::SetTableName( SwFrmFmt& rTblFmt, const OUString &rNewName )
     417             : {
     418           0 :     GetDoc()->SetTableName( rTblFmt, rNewName );
     419           0 : }
     420             : 
     421             : /// request current word
     422           0 : OUString SwEditShell::GetCurWord()
     423             : {
     424           0 :     const SwPaM& rPaM = *GetCrsr();
     425           0 :     const SwTxtNode* pNd = rPaM.GetNode().GetTxtNode();
     426             :     OUString aString = pNd ?
     427           0 :                      pNd->GetCurWord(rPaM.GetPoint()->nContent.GetIndex()) :
     428           0 :                      OUString();
     429           0 :     return aString;
     430             : }
     431             : 
     432           0 : void SwEditShell::UpdateDocStat( )
     433             : {
     434           0 :     StartAllAction();
     435           0 :     GetDoc()->getIDocumentStatistics().UpdateDocStat( false, true );
     436           0 :     EndAllAction();
     437           0 : }
     438             : 
     439           0 : const SwDocStat& SwEditShell::GetUpdatedDocStat()
     440             : {
     441           0 :     StartAllAction();
     442           0 :     const SwDocStat &rRet = GetDoc()->getIDocumentStatistics().GetUpdatedDocStat( false, true );
     443           0 :     EndAllAction();
     444           0 :     return rRet;
     445             : }
     446             : 
     447             : // OPT: eddocinl.cxx
     448             : 
     449             : /// get the reference of a given name in the Doc
     450           0 : const SwFmtRefMark* SwEditShell::GetRefMark( const OUString& rName ) const
     451             : {
     452           0 :     return GetDoc()->GetRefMark( rName );
     453             : }
     454             : 
     455             : /// get the names of all references in a Doc
     456         162 : sal_uInt16 SwEditShell::GetRefMarks( std::vector<OUString>* pStrings ) const
     457             : {
     458         162 :     return GetDoc()->GetRefMarks( pStrings );
     459             : }
     460             : 
     461           0 : OUString SwEditShell::GetDropTxt( const sal_uInt16 nChars ) const
     462             : {
     463             :     /*
     464             :      * pb: made changes for #i74939#
     465             :      *
     466             :      * always return a string even though there is a selection
     467             :      */
     468             : 
     469           0 :     OUString aTxt;
     470           0 :     SwPaM* pCrsr = GetCrsr();
     471           0 :     if ( IsMultiSelection() )
     472             :     {
     473             :         // if a multi selection exists, search for the first line
     474             :         // -> it is the cursor with the lowest index
     475           0 :         sal_uLong nIndex = pCrsr->GetMark()->nNode.GetIndex();
     476           0 :         bool bPrev = true;
     477           0 :         SwPaM* pLast = pCrsr;
     478           0 :         SwPaM* pTemp = pCrsr;
     479           0 :         while ( bPrev )
     480             :         {
     481           0 :             SwPaM* pPrev2 = dynamic_cast< SwPaM* >( pTemp->GetPrev() );
     482           0 :             bPrev = ( pPrev2 && pPrev2 != pLast );
     483           0 :             if ( bPrev )
     484             :             {
     485           0 :                 pTemp = pPrev2;
     486           0 :                 sal_uLong nTemp = pPrev2->GetMark()->nNode.GetIndex();
     487           0 :                 if ( nTemp < nIndex )
     488             :                 {
     489           0 :                     nIndex = nTemp;
     490           0 :                     pCrsr = pPrev2;
     491             :                 }
     492             :             }
     493             :         }
     494             :     }
     495             : 
     496           0 :     SwTxtNode* pTxtNd = pCrsr->GetNode( !pCrsr->HasMark() ).GetTxtNode();
     497           0 :     if( pTxtNd )
     498             :     {
     499           0 :         sal_Int32 nDropLen = pTxtNd->GetDropLen( nChars );
     500           0 :         if( nDropLen )
     501           0 :             aTxt = pTxtNd->GetTxt().copy(0, nDropLen);
     502             :     }
     503             : 
     504           0 :     return aTxt;
     505             : }
     506             : 
     507           0 : void SwEditShell::ReplaceDropTxt( const OUString &rStr, SwPaM* pPaM )
     508             : {
     509           0 :     SwPaM* pCrsr = pPaM ? pPaM : GetCrsr();
     510           0 :     if( pCrsr->GetPoint()->nNode == pCrsr->GetMark()->nNode &&
     511           0 :         pCrsr->GetNode().GetTxtNode()->IsTxtNode() )
     512             :     {
     513           0 :         StartAllAction();
     514             : 
     515           0 :         const SwNodeIndex& rNd = pCrsr->GetPoint()->nNode;
     516           0 :         SwPaM aPam( rNd, rStr.getLength(), rNd, 0 );
     517           0 :         if( !GetDoc()->getIDocumentContentOperations().Overwrite( aPam, rStr ) )
     518             :         {
     519             :             OSL_FAIL( "Doc->getIDocumentContentOperations().Overwrite(Str) failed." );
     520             :         }
     521             : 
     522           0 :         EndAllAction();
     523             :     }
     524           0 : }
     525             : 
     526           0 : OUString SwEditShell::Calculate()
     527             : {
     528           0 :     OUString  aFormel;                    // the final formula
     529           0 :     SwPaM     *pPaMLast = (SwPaM*)GetCrsr()->GetNext(),
     530           0 :               *pPaM = pPaMLast;           // cursor pointers
     531           0 :     SwCalc    aCalc( *GetDoc() );
     532           0 :     const CharClass& rCC = GetAppCharClass();
     533             : 
     534           0 :     do {
     535           0 :         SwTxtNode* pTxtNd = pPaM->GetNode().GetTxtNode();
     536           0 :         if(pTxtNd)
     537             :         {
     538           0 :             const SwPosition *pStart = pPaM->Start(), *pEnd = pPaM->End();
     539           0 :             const sal_Int32 nStt = pStart->nContent.GetIndex();
     540             :             OUString aStr = pTxtNd->GetExpandTxt( nStt, pEnd->nContent.
     541           0 :                                                 GetIndex() - nStt );
     542             : 
     543           0 :             aStr = rCC.lowercase( aStr );
     544             : 
     545             :             sal_Unicode ch;
     546           0 :             bool bValidFlds = false;
     547           0 :             sal_Int32 nPos = 0;
     548             : 
     549           0 :             while( nPos < aStr.getLength() )
     550             :             {
     551           0 :                 ch = aStr[ nPos++ ];
     552           0 :                 if( rCC.isLetter( aStr, nPos-1 ) || ch == '_' )
     553             :                 {
     554           0 :                     sal_Int32 nTmpStt = nPos-1;
     555           0 :                     while(  nPos < aStr.getLength() &&
     556           0 :                             0 != ( ch = aStr[ nPos++ ]) &&
     557           0 :                            (rCC.isLetterNumeric( aStr, nPos - 1 ) ||
     558           0 :                                ch == '_'|| ch == '.' ))
     559             :                         ;
     560             : 
     561           0 :                     if( nPos < aStr.getLength() )
     562           0 :                         --nPos;
     563             : 
     564           0 :                     OUString sVar = aStr.copy( nTmpStt, nPos - nTmpStt );
     565           0 :                     if( !::FindOperator( sVar ) &&
     566           0 :                         (::Find( sVar, aCalc.GetVarTable(),TBLSZ) ||
     567           0 :                          aCalc.VarLook( sVar )) )
     568             :                     {
     569           0 :                         if( !bValidFlds )
     570             :                         {
     571           0 :                             GetDoc()->getIDocumentFieldsAccess().FldsToCalc( aCalc,
     572             :                                                   pStart->nNode.GetIndex(),
     573           0 :                                                   pStart->nContent.GetIndex() );
     574           0 :                             bValidFlds = true;
     575             :                         }
     576           0 :                         aFormel += "(" + aCalc.GetStrResult( aCalc.VarLook( sVar )->nValue ) + ")";
     577             :                     }
     578             :                     else
     579           0 :                         aFormel += sVar;
     580             :                 }
     581             :                 else
     582           0 :                     aFormel += OUString(ch);
     583           0 :             }
     584             :         }
     585           0 :     } while( pPaMLast != (pPaM = (SwPaM*)pPaM->GetNext()) );
     586             : 
     587           0 :     return aCalc.GetStrResult( aCalc.Calculate(aFormel) );
     588             : }
     589             : 
     590          22 : sfx2::LinkManager& SwEditShell::GetLinkManager()
     591             : {
     592          22 :     return mpDoc->getIDocumentLinksAdministration().GetLinkManager();
     593             : }
     594             : 
     595           0 : void *SwEditShell::GetIMapInventor() const
     596             : {
     597             :     // The node on which the cursor points should be sufficient as a unique identifier
     598           0 :     return (void*)&(GetCrsr()->GetNode());
     599             : }
     600             : 
     601             : // #i73788#
     602           0 : Graphic SwEditShell::GetIMapGraphic() const
     603             : {
     604             :     // returns always a graphic if the cursor is in a Fly
     605           0 :     SET_CURR_SHELL( (SwViewShell*)this );
     606           0 :     Graphic aRet;
     607           0 :     SwPaM* pCrsr = GetCrsr();
     608           0 :     if ( !pCrsr->HasMark() )
     609             :     {
     610           0 :         SwNode& rNd =pCrsr->GetNode();
     611           0 :         if( rNd.IsGrfNode() )
     612             :         {
     613           0 :             SwGrfNode & rGrfNode(static_cast<SwGrfNode&>(rNd));
     614           0 :             const Graphic& rGrf = rGrfNode.GetGrf();
     615           0 :             if( rGrf.IsSwapOut() || ( rGrfNode.IsLinkedFile() &&
     616           0 :                                     GRAPHIC_DEFAULT == rGrf.GetType() ) )
     617             :             {
     618           0 :                 bool const bResult = rGrfNode.SwapIn(true);
     619             :                 OSL_ENSURE(bResult, "Graphic could not be loaded" );
     620             :                 (void) bResult; // unused in non-debug
     621             :             }
     622           0 :             aRet = rGrf;
     623             :         }
     624           0 :         else if ( rNd.IsOLENode() )
     625             :         {
     626           0 :             aRet = *((SwOLENode&)rNd).GetGraphic();
     627             :         }
     628             :         else
     629             :         {
     630           0 :             SwFlyFrm* pFlyFrm = rNd.GetCntntNode()->getLayoutFrm( GetLayout() )->FindFlyFrm();
     631           0 :             if(pFlyFrm)
     632           0 :                 aRet = pFlyFrm->GetFmt()->MakeGraphic();
     633             :         }
     634             :     }
     635           0 :     return aRet;
     636             : }
     637             : 
     638           0 : bool SwEditShell::InsertURL( const SwFmtINetFmt& rFmt, const OUString& rStr, bool bKeepSelection )
     639             : {
     640             :     // URL and hint text (directly or via selection) necessary
     641           0 :     if( rFmt.GetValue().isEmpty() || ( rStr.isEmpty() && !HasSelection() ) )
     642           0 :         return false;
     643           0 :     StartAllAction();
     644           0 :     GetDoc()->GetIDocumentUndoRedo().StartUndo( UNDO_UI_INSERT_URLTXT, NULL);
     645           0 :     bool bInsTxt = true;
     646             : 
     647           0 :     if( !rStr.isEmpty() )
     648             :     {
     649           0 :         SwPaM* pCrsr = GetCrsr();
     650           0 :         if( pCrsr->HasMark() && *pCrsr->GetPoint() != *pCrsr->GetMark() )
     651             :         {
     652             :             // Selection existent, multi selection?
     653           0 :             bool bDelTxt = true;
     654           0 :             if( pCrsr->GetNext() == pCrsr )
     655             :             {
     656             :                 // einfach Selection -> Text ueberpruefen
     657           0 :                 const OUString sTxt(comphelper::string::stripEnd(GetSelTxt(), ' '));
     658           0 :                 if( sTxt == rStr )
     659           0 :                     bDelTxt = bInsTxt = false;
     660             :             }
     661           0 :             else if( rFmt.GetValue() == rStr ) // Are Name and URL equal?
     662           0 :                 bDelTxt = bInsTxt = false;
     663             : 
     664           0 :             if( bDelTxt )
     665           0 :                 Delete();
     666             :         }
     667           0 :         else if( pCrsr->GetNext() != pCrsr && rFmt.GetValue() == rStr )
     668           0 :             bInsTxt = false;
     669             : 
     670           0 :         if( bInsTxt )
     671             :         {
     672           0 :             Insert2( rStr );
     673           0 :             SetMark();
     674           0 :             ExtendSelection( false, rStr.getLength() );
     675             :         }
     676             :     }
     677             :     else
     678           0 :         bInsTxt = false;
     679             : 
     680           0 :     SetAttrItem( rFmt );
     681           0 :     if (bInsTxt && !IsCrsrPtAtEnd())
     682           0 :         SwapPam();
     683           0 :     if(!bKeepSelection)
     684           0 :         ClearMark();
     685           0 :     if( bInsTxt )
     686           0 :         DontExpandFmt();
     687           0 :     GetDoc()->GetIDocumentUndoRedo().EndUndo( UNDO_UI_INSERT_URLTXT, NULL );
     688           0 :     EndAllAction();
     689           0 :     return true;
     690             : }
     691             : 
     692         162 : sal_uInt16 SwEditShell::GetINetAttrs( SwGetINetAttrs& rArr )
     693             : {
     694         162 :     rArr.clear();
     695             : 
     696             :     const SwTxtNode* pTxtNd;
     697         162 :     const SwCharFmts* pFmts = GetDoc()->GetCharFmts();
     698         348 :     for( sal_uInt16 n = pFmts->size(); 1 < n; )
     699             :     {
     700          24 :         SwIterator<SwTxtINetFmt,SwCharFmt> aIter(*(*pFmts)[--n]);
     701          24 :         for( SwTxtINetFmt* pFnd = aIter.First(); pFnd; pFnd = aIter.Next() )
     702             :         {
     703           0 :             if( 0 != ( pTxtNd = pFnd->GetpTxtNode()) &&
     704           0 :                 pTxtNd->GetNodes().IsDocNodes() )
     705             :             {
     706           0 :                 SwTxtINetFmt& rAttr = *pFnd;
     707           0 :                 OUString sTxt( pTxtNd->GetExpandTxt( rAttr.GetStart(),
     708           0 :                                     *rAttr.GetEnd() - rAttr.GetStart() ) );
     709             : 
     710           0 :                 sTxt = comphelper::string::remove(sTxt, 0x0a);
     711           0 :                 sTxt = comphelper::string::strip(sTxt, ' ');
     712             : 
     713           0 :                 if( !sTxt.isEmpty() )
     714             :                 {
     715           0 :                     SwGetINetAttr* pNew = new SwGetINetAttr( sTxt, rAttr );
     716           0 :                     rArr.push_back( pNew );
     717           0 :                 }
     718             :             }
     719             :         }
     720          24 :     }
     721         162 :     return rArr.size();
     722             : }
     723             : 
     724             : /// If the cursor is in a INetAttribute then it will be deleted completely (incl. hint text, the
     725             : /// latter is needed for drag & drop)
     726           0 : bool SwEditShell::DelINetAttrWithText()
     727             : {
     728           0 :     bool bRet = SelectTxtAttr( RES_TXTATR_INETFMT, false );
     729           0 :     if( bRet )
     730           0 :         DeleteSel( *GetCrsr() );
     731           0 :     return bRet;
     732             : }
     733             : 
     734             : /// Set the DontExpand flag at the text character attributes
     735           0 : bool SwEditShell::DontExpandFmt()
     736             : {
     737           0 :     bool bRet = false;
     738           0 :     if( !IsTableMode() && GetDoc()->DontExpandFmt( *GetCrsr()->GetPoint() ))
     739             :     {
     740           0 :         bRet = true;
     741           0 :         CallChgLnk();
     742             :     }
     743           0 :     return bRet;
     744             : }
     745             : 
     746           0 : SvNumberFormatter* SwEditShell::GetNumberFormatter()
     747             : {
     748           0 :     return GetDoc()->GetNumberFormatter();
     749             : }
     750             : 
     751          10 : bool SwEditShell::ConvertFieldsToText()
     752             : {
     753          10 :     StartAllAction();
     754          10 :     bool bRet = GetDoc()->ConvertFieldsToText();
     755          10 :     EndAllAction();
     756          10 :     return bRet;
     757             : }
     758             : 
     759          10 : void SwEditShell::SetNumberingRestart()
     760             : {
     761          10 :     StartAllAction();
     762          10 :     Push();
     763             :     // iterate over all text contents - body, frames, header, footer, footnote text
     764          10 :     SwPaM* pCrsr = GetCrsr();
     765          30 :     for(sal_uInt16 i = 0; i < 2; i++)
     766             :     {
     767          20 :         if(!i)
     768          10 :             MakeFindRange(DOCPOS_START, DOCPOS_END, pCrsr); // body content
     769             :         else
     770          10 :             MakeFindRange(DOCPOS_OTHERSTART, DOCPOS_OTHEREND, pCrsr); // extra content
     771          20 :         SwPosition* pSttPos = pCrsr->Start(), *pEndPos = pCrsr->End();
     772          20 :         sal_uLong nCurrNd = pSttPos->nNode.GetIndex();
     773          20 :         sal_uLong nEndNd = pEndPos->nNode.GetIndex();
     774          20 :         if( nCurrNd <= nEndNd )
     775             :         {
     776             :             SwCntntFrm* pCntFrm;
     777          20 :             bool bGoOn = true;
     778             :             // iterate over all paragraphs
     779         224 :             while( bGoOn )
     780             :             {
     781         184 :                 SwNode* pNd = GetDoc()->GetNodes()[ nCurrNd ];
     782         184 :                 switch( pNd->GetNodeType() )
     783             :                 {
     784             :                 case ND_TEXTNODE:
     785         106 :                     if( 0 != ( pCntFrm = ((SwTxtNode*)pNd)->getLayoutFrm( GetLayout() )) )
     786             :                     {
     787             :                         // skip hidden frames - ignore protection!
     788         106 :                         if( !((SwTxtFrm*)pCntFrm)->IsHiddenNow() )
     789             :                         {
     790             :                             // if the node is numbered and the starting value of the numbering equals the
     791             :                             // start value of the numbering rule then set this value as hard starting value
     792             : 
     793             :                             // get the node num
     794             :                             // OD 2005-11-09
     795         104 :                             SwTxtNode* pTxtNd( static_cast<SwTxtNode*>(pNd) );
     796         104 :                             SwNumRule* pNumRule( pTxtNd->GetNumRule() );
     797             : 
     798             :                             bool bIsNodeNum =
     799           0 :                                ( pNumRule && pTxtNd->GetNum() &&
     800           0 :                                  ( pTxtNd->HasNumber() || pTxtNd->HasBullet() ) &&
     801         104 :                                  pTxtNd->IsCountedInList() &&
     802         104 :                                  !pTxtNd->IsListRestart() );
     803         104 :                             if (bIsNodeNum)
     804             :                             {
     805           0 :                                 int nListLevel = pTxtNd->GetActualListLevel();
     806             : 
     807           0 :                                 if (nListLevel < 0)
     808           0 :                                     nListLevel = 0;
     809             : 
     810           0 :                                 if (nListLevel >= MAXLEVEL)
     811           0 :                                     nListLevel = MAXLEVEL - 1;
     812             : 
     813           0 :                                  bIsNodeNum = pTxtNd->GetNum()->GetNumber() ==
     814           0 :                                     pNumRule->Get( static_cast<sal_uInt16>(nListLevel) ).GetStart();
     815             :                             }
     816         104 :                             if (bIsNodeNum)
     817             :                             {
     818             :                                 // now set a the start value as attribute
     819           0 :                                 SwPosition aCurrentNode(*pNd);
     820           0 :                                 GetDoc()->SetNumRuleStart( aCurrentNode, true );
     821             :                             }
     822             :                         }
     823             :                     }
     824         106 :                     break;
     825             :                 case ND_SECTIONNODE:
     826             :                     // skip hidden sections  - ignore protection!
     827          10 :                     if(((SwSectionNode*)pNd)->GetSection().IsHidden() )
     828           0 :                         nCurrNd = pNd->EndOfSectionIndex();
     829          10 :                     break;
     830             :                 case ND_ENDNODE:
     831             :                     {
     832          36 :                         break;
     833             :                     }
     834             :                 }
     835             : 
     836         184 :                 bGoOn = nCurrNd < nEndNd;
     837         184 :                 ++nCurrNd;
     838             :             }
     839             :         }
     840             :     }
     841             : 
     842          10 :     Pop(false);
     843          10 :     EndAllAction();
     844          10 : }
     845             : 
     846           0 : sal_uInt16 SwEditShell::GetLineCount( bool bActPos )
     847             : {
     848           0 :     sal_uInt16 nRet = 0;
     849           0 :     CalcLayout();
     850           0 :     SwPaM* pPam = GetCrsr();
     851           0 :     SwNodeIndex& rPtIdx = pPam->GetPoint()->nNode;
     852           0 :     SwNodeIndex aStart( rPtIdx );
     853             :     SwCntntNode* pCNd;
     854           0 :     SwCntntFrm *pCntFrm = 0;
     855             :     sal_uLong nTmpPos;
     856             : 
     857           0 :     if( !bActPos )
     858           0 :         aStart = 0;
     859           0 :     else if( rPtIdx > ( nTmpPos = GetDoc()->GetNodes().GetEndOfExtras().GetIndex()) )
     860             :         // BodyArea => Start is EndOfIcons + 1
     861           0 :         aStart = nTmpPos + 1;
     862             :     else
     863             :     {
     864           0 :         if( 0 != ( pCNd = pPam->GetCntntNode() ) &&
     865           0 :             0 != ( pCntFrm = pCNd->getLayoutFrm( GetLayout() ) ) )
     866             :         {
     867             :             const SwStartNode *pTmp;
     868           0 :             if( pCntFrm->IsInFly() )                        // Fly
     869           0 :                 pTmp = pCNd->FindFlyStartNode();
     870           0 :             else if( pCntFrm->IsInFtn() )                   // Footnote
     871           0 :                 pTmp = pCNd->FindFootnoteStartNode();
     872             :             else
     873             :             {                                               // Footer/Header
     874           0 :                 const sal_uInt16 nTyp = FRM_HEADER | FRM_FOOTER;
     875           0 :                 SwFrm* pFrm = pCntFrm;
     876           0 :                 while( pFrm && !(pFrm->GetType() & nTyp) )
     877           0 :                     pFrm = pFrm->GetUpper();
     878             :                 OSL_ENSURE( pFrm, "Wo bin ich?" );
     879           0 :                 if( pFrm && ( pFrm->GetType() & FRM_FOOTER ) )
     880           0 :                     pTmp = pCNd->FindFooterStartNode();
     881             :                 else
     882           0 :                     pTmp = pCNd->FindHeaderStartNode();
     883             :             }
     884             :             OSL_ENSURE( pTmp, "Missing StartNode" );
     885           0 :             aStart  = *pTmp;
     886             :         }
     887             :         OSL_ENSURE( pCNd && pCntFrm, "Missing Layout-Information" );
     888             :     }
     889             : 
     890           0 :     while( 0 != ( pCNd = GetDoc()->GetNodes().GoNextSection(
     891           0 :                 &aStart, true, false )) && ( !bActPos || aStart <= rPtIdx ) )
     892             :     {
     893           0 :         if( 0 != ( pCntFrm = pCNd->getLayoutFrm( GetLayout() ) ) && pCntFrm->IsTxtFrm() )
     894             :         {
     895           0 :             sal_Int32 nActPos = bActPos && aStart == rPtIdx ?
     896           0 :                 pPam->GetPoint()->nContent.GetIndex() : USHRT_MAX;
     897           0 :             nRet = nRet + ((SwTxtFrm*)pCntFrm)->GetLineCount( nActPos );
     898             :         }
     899             :     }
     900           0 :     return nRet;
     901             : }
     902             : 
     903           0 : long SwEditShell::CompareDoc( const SwDoc& rDoc )
     904             : {
     905           0 :     StartAllAction();
     906           0 :     long nRet = GetDoc()->CompareDoc( rDoc );
     907           0 :     EndAllAction();
     908           0 :     return nRet;
     909             : }
     910             : 
     911           0 : long SwEditShell::MergeDoc( const SwDoc& rDoc )
     912             : {
     913           0 :     StartAllAction();
     914           0 :     long nRet = GetDoc()->MergeDoc( rDoc );
     915           0 :     EndAllAction();
     916           0 :     return nRet;
     917             : }
     918             : 
     919           0 : const SwFtnInfo& SwEditShell::GetFtnInfo() const
     920             : {
     921           0 :     return GetDoc()->GetFtnInfo();
     922             : }
     923             : 
     924           0 : void SwEditShell::SetFtnInfo(const SwFtnInfo& rInfo)
     925             : {
     926           0 :     StartAllAction();
     927           0 :     SET_CURR_SHELL( this );
     928           0 :     GetDoc()->SetFtnInfo(rInfo);
     929           0 :     CallChgLnk();
     930           0 :     EndAllAction();
     931           0 : }
     932             : 
     933           0 : const SwEndNoteInfo& SwEditShell::GetEndNoteInfo() const
     934             : {
     935           0 :     return GetDoc()->GetEndNoteInfo();
     936             : }
     937             : 
     938           0 : void SwEditShell::SetEndNoteInfo(const SwEndNoteInfo& rInfo)
     939             : {
     940           0 :     StartAllAction();
     941           0 :     SET_CURR_SHELL( this );
     942           0 :     GetDoc()->SetEndNoteInfo(rInfo);
     943           0 :     EndAllAction();
     944           0 : }
     945             : 
     946           0 : const SwLineNumberInfo& SwEditShell::GetLineNumberInfo() const
     947             : {
     948           0 :     return GetDoc()->GetLineNumberInfo();
     949             : }
     950             : 
     951           0 : void SwEditShell::SetLineNumberInfo(const SwLineNumberInfo& rInfo)
     952             : {
     953           0 :     StartAllAction();
     954           0 :     SET_CURR_SHELL( this );
     955           0 :     GetDoc()->SetLineNumberInfo(rInfo);
     956           0 :     AddPaintRect( GetLayout()->Frm() );
     957           0 :     EndAllAction();
     958           0 : }
     959             : 
     960           0 : sal_uInt16 SwEditShell::GetLinkUpdMode(bool bDocSettings) const
     961             : {
     962           0 :     return getIDocumentSettingAccess()->getLinkUpdateMode( !bDocSettings );
     963             : }
     964             : 
     965           0 : void SwEditShell::SetLinkUpdMode( sal_uInt16 nMode )
     966             : {
     967           0 :     getIDocumentSettingAccess()->setLinkUpdateMode( nMode );
     968           0 : }
     969             : 
     970             : // Interface for TextInputData - (for text input of japanese/chinese characters)
     971           0 : SwExtTextInput* SwEditShell::CreateExtTextInput(LanguageType eInputLanguage)
     972             : {
     973           0 :     SwExtTextInput* pRet = GetDoc()->CreateExtTextInput( *GetCrsr() );
     974           0 :     pRet->SetLanguage(eInputLanguage);
     975           0 :     pRet->SetOverwriteCursor( SwCrsrShell::IsOverwriteCrsr() );
     976           0 :     return pRet;
     977             : }
     978             : 
     979           0 : OUString SwEditShell::DeleteExtTextInput( SwExtTextInput* pDel, bool bInsText )
     980             : {
     981           0 :     if( !pDel )
     982             :     {
     983           0 :         const SwPosition& rPos = *GetCrsr()->GetPoint();
     984           0 :         pDel = GetDoc()->GetExtTextInput( rPos.nNode.GetNode(),
     985           0 :                                           rPos.nContent.GetIndex() );
     986           0 :         if( !pDel )
     987             :         {
     988             :             //JP 25.10.2001: under UNIX the cursor is moved before the Input-
     989             :             //              Engine event comes in. So take any - normally there
     990             :             //              exist only one at the time. -- Task 92016
     991           0 :             pDel = GetDoc()->GetExtTextInput();
     992             :         }
     993             :     }
     994           0 :     OUString sRet;
     995           0 :     if( pDel )
     996             :     {
     997           0 :         OUString sTmp;
     998           0 :         SwUnoCursorHelper::GetTextFromPam(*pDel, sTmp);
     999           0 :         sRet = sTmp;
    1000           0 :         SET_CURR_SHELL( this );
    1001           0 :         StartAllAction();
    1002           0 :         pDel->SetInsText( bInsText );
    1003           0 :         SetOverwriteCrsr( pDel->IsOverwriteCursor() );
    1004           0 :         const SwPosition aPos( *pDel->GetPoint() );
    1005           0 :         GetDoc()->DeleteExtTextInput( pDel );
    1006             : 
    1007             :         // In this case, the "replace" function did not set the cursor
    1008             :         // to the original position. Therefore we have to do this manually.
    1009           0 :         if ( ! bInsText && IsOverwriteCrsr() )
    1010           0 :             *GetCrsr()->GetPoint() = aPos;
    1011             : 
    1012           0 :         EndAllAction();
    1013             :     }
    1014           0 :     return sRet;
    1015             : }
    1016             : 
    1017           0 : void SwEditShell::SetExtTextInputData( const CommandExtTextInputData& rData )
    1018             : {
    1019           0 :     const SwPosition& rPos = *GetCrsr()->GetPoint();
    1020           0 :     SwExtTextInput* pInput = GetDoc()->GetExtTextInput( rPos.nNode.GetNode() );
    1021           0 :     if( pInput )
    1022             :     {
    1023           0 :         StartAllAction();
    1024           0 :         SET_CURR_SHELL( this );
    1025             : 
    1026           0 :         if( !rData.IsOnlyCursorChanged() )
    1027           0 :             pInput->SetInputData( rData );
    1028             :         // position cursor
    1029           0 :         const SwPosition& rStt = *pInput->Start();
    1030           0 :         const sal_Int32 nNewCrsrPos = rStt.nContent.GetIndex() + rData.GetCursorPos();
    1031             : 
    1032             :         // ugly but works
    1033           0 :         ShowCrsr();
    1034           0 :         const sal_Int32 nDiff = nNewCrsrPos - rPos.nContent.GetIndex();
    1035           0 :         if( 0 > nDiff )
    1036           0 :             Left( (sal_Int32)-nDiff, CRSR_SKIP_CHARS );
    1037           0 :         else if( 0 < nDiff )
    1038           0 :             Right( (sal_Int32)nDiff, CRSR_SKIP_CHARS );
    1039             : 
    1040           0 :         SetOverwriteCrsr( rData.IsCursorOverwrite() );
    1041             : 
    1042           0 :         EndAllAction();
    1043             : 
    1044           0 :         if( !rData.IsCursorVisible() )  // must be called after the EndAction
    1045           0 :             HideCrsr();
    1046             :     }
    1047           0 : }
    1048             : 
    1049           0 : void SwEditShell::TransliterateText( sal_uInt32 nType )
    1050             : {
    1051           0 :     utl::TransliterationWrapper aTrans( ::comphelper::getProcessComponentContext(), nType );
    1052           0 :     StartAllAction();
    1053           0 :     SET_CURR_SHELL( this );
    1054             : 
    1055           0 :     SwPaM* pCrsr = GetCrsr();
    1056           0 :     if( pCrsr->GetNext() != pCrsr )
    1057             :     {
    1058           0 :         GetDoc()->GetIDocumentUndoRedo().StartUndo(UNDO_EMPTY, NULL);
    1059           0 :         FOREACHPAM_START(GetCrsr())
    1060             : 
    1061           0 :         if( PCURCRSR->HasMark() )
    1062           0 :             GetDoc()->getIDocumentContentOperations().TransliterateText( *PCURCRSR, aTrans );
    1063             : 
    1064           0 :         FOREACHPAM_END()
    1065           0 :         GetDoc()->GetIDocumentUndoRedo().EndUndo(UNDO_EMPTY, NULL);
    1066             :     }
    1067             :     else
    1068           0 :         GetDoc()->getIDocumentContentOperations().TransliterateText( *pCrsr, aTrans );
    1069             : 
    1070           0 :     EndAllAction();
    1071           0 : }
    1072             : 
    1073        1055 : void SwEditShell::CountWords( SwDocStat& rStat ) const
    1074             : {
    1075        2122 :     FOREACHPAM_START(GetCrsr())
    1076             : 
    1077        1067 :         if( PCURCRSR->HasMark() )
    1078          16 :             GetDoc()->CountWords( *PCURCRSR, rStat );
    1079             : 
    1080        1067 :     FOREACHPAM_END()
    1081        1055 : }
    1082             : 
    1083        1732 : void SwEditShell::ApplyViewOptions( const SwViewOption &rOpt )
    1084             : {
    1085        1732 :     SwCrsrShell::StartAction();
    1086        1732 :     SwViewShell::ApplyViewOptions( rOpt );
    1087        1732 :     SwEditShell::EndAction();
    1088        2002 : }
    1089             : 
    1090             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10