LCOV - code coverage report
Current view: top level - sw/source/core/undo - unattr.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 550 0.0 %
Date: 2014-04-14 Functions: 0 69 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 <UndoAttribute.hxx>
      21             : #include <svl/itemiter.hxx>
      22             : #include <editeng/tstpitem.hxx>
      23             : #include <svx/svdmodel.hxx>
      24             : #include <svx/svdpage.hxx>
      25             : #include <hintids.hxx>
      26             : #include <fmtflcnt.hxx>
      27             : #include <txtftn.hxx>
      28             : #include <fmtornt.hxx>
      29             : #include <fmtanchr.hxx>
      30             : #include <fmtfsize.hxx>
      31             : #include <frmfmt.hxx>
      32             : #include <fmtcntnt.hxx>
      33             : #include <ftnidx.hxx>
      34             : #include <doc.hxx>
      35             : #include <IDocumentUndoRedo.hxx>
      36             : #include <IShellCursorSupplier.hxx>
      37             : #include <docary.hxx>
      38             : #include <swundo.hxx>
      39             : #include <pam.hxx>
      40             : #include <ndtxt.hxx>
      41             : #include <swtable.hxx>
      42             : #include <swtblfmt.hxx>
      43             : #include <UndoCore.hxx>
      44             : #include <hints.hxx>
      45             : #include <rolbck.hxx>
      46             : #include <ndnotxt.hxx>
      47             : #include <dcontact.hxx>
      48             : #include <ftninfo.hxx>
      49             : #include <redline.hxx>
      50             : #include <section.hxx>
      51             : #include <charfmt.hxx>
      52             : #include <switerator.hxx>
      53             : 
      54           0 : SwUndoFmtAttrHelper::SwUndoFmtAttrHelper( SwFmt& rFmt, bool bSvDrwPt )
      55             :     : SwClient( &rFmt )
      56             :     , m_pUndo( 0 )
      57           0 :     , m_bSaveDrawPt( bSvDrwPt )
      58             : {
      59           0 : }
      60             : 
      61           0 : void SwUndoFmtAttrHelper::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
      62             : {
      63           0 :     if( pOld )
      64             :     {
      65           0 :         if ( pOld->Which() == RES_OBJECTDYING )
      66             :         {
      67           0 :             CheckRegistration( pOld, pNew );
      68             :         }
      69           0 :         else if ( pNew )
      70             :         {
      71           0 :             if( POOLATTR_END >= pOld->Which() )
      72             :             {
      73           0 :                 if ( GetUndo() )
      74             :                 {
      75           0 :                     m_pUndo->PutAttr( *pOld );
      76             :                 }
      77             :                 else
      78             :                 {
      79             :                     m_pUndo.reset( new SwUndoFmtAttr( *pOld,
      80           0 :                             *static_cast<SwFmt*>(GetRegisteredInNonConst()), m_bSaveDrawPt ) );
      81             :                 }
      82             :             }
      83           0 :             else if ( RES_ATTRSET_CHG == pOld->Which() )
      84             :             {
      85           0 :                 if ( GetUndo() )
      86             :                 {
      87             :                     SfxItemIter aIter(
      88           0 :                             *(static_cast<const SwAttrSetChg*>(pOld))->GetChgSet() );
      89           0 :                     const SfxPoolItem* pItem = aIter.GetCurItem();
      90           0 :                     while ( pItem )
      91             :                     {
      92           0 :                         m_pUndo->PutAttr( *pItem );
      93           0 :                         if( aIter.IsAtEnd() )
      94           0 :                             break;
      95           0 :                         pItem = aIter.NextItem();
      96           0 :                     }
      97             :                 }
      98             :                 else
      99             :                 {
     100             :                     m_pUndo.reset( new SwUndoFmtAttr(
     101           0 :                             *static_cast<const SwAttrSetChg*>(pOld)->GetChgSet(),
     102           0 :                             *static_cast<SwFmt*>(GetRegisteredInNonConst()), m_bSaveDrawPt ) );
     103             :                 }
     104             :             }
     105             :         }
     106             :     }
     107           0 : }
     108             : 
     109           0 : SwUndoFmtAttr::SwUndoFmtAttr( const SfxItemSet& rOldSet,
     110             :                               SwFmt& rChgFmt,
     111             :                               bool bSaveDrawPt )
     112             :     : SwUndo( UNDO_INSFMTATTR )
     113             :     , m_pFmt( &rChgFmt )
     114             :       // #i56253#
     115           0 :     , m_pOldSet( new SfxItemSet( rOldSet ) )
     116             :     , m_nNodeIndex( 0 )
     117           0 :     , m_nFmtWhich( rChgFmt.Which() )
     118           0 :     , m_bSaveDrawPt( bSaveDrawPt )
     119             : {
     120           0 :     Init();
     121           0 : }
     122             : 
     123           0 : SwUndoFmtAttr::SwUndoFmtAttr( const SfxPoolItem& rItem, SwFmt& rChgFmt,
     124             :                               bool bSaveDrawPt )
     125             :     : SwUndo( UNDO_INSFMTATTR )
     126             :     , m_pFmt( &rChgFmt )
     127           0 :     , m_pOldSet( m_pFmt->GetAttrSet().Clone( false ) )
     128             :     , m_nNodeIndex( 0 )
     129           0 :     , m_nFmtWhich( rChgFmt.Which() )
     130           0 :     , m_bSaveDrawPt( bSaveDrawPt )
     131             : {
     132           0 :     m_pOldSet->Put( rItem );
     133           0 :     Init();
     134           0 : }
     135             : 
     136           0 : void SwUndoFmtAttr::Init()
     137             : {
     138             :     // treat change of anchor specially
     139           0 :     if ( SFX_ITEM_SET == m_pOldSet->GetItemState( RES_ANCHOR, false ))
     140             :     {
     141           0 :         SaveFlyAnchor( m_bSaveDrawPt );
     142             :     }
     143           0 :     else if ( RES_FRMFMT == m_nFmtWhich )
     144             :     {
     145           0 :         SwDoc* pDoc = m_pFmt->GetDoc();
     146           0 :         if ( pDoc->GetTblFrmFmts()->Contains(static_cast<const SwFrmFmt*>(m_pFmt)))
     147             :         {
     148             :             // Table Format: save table position, table formats are volatile!
     149           0 :             SwTable * pTbl = SwIterator<SwTable,SwFmt>::FirstElement( *m_pFmt );
     150           0 :             if ( pTbl )
     151             :             {
     152           0 :                 m_nNodeIndex = pTbl->GetTabSortBoxes()[ 0 ]->GetSttNd()
     153           0 :                     ->FindTableNode()->GetIndex();
     154             :             }
     155             :         }
     156           0 :         else if ( pDoc->GetSections().Contains(static_cast<const SwSectionFmt*>(m_pFmt)))
     157             :         {
     158           0 :             m_nNodeIndex = m_pFmt->GetCntnt().GetCntntIdx()->GetIndex();
     159             :         }
     160           0 :         else if ( 0 != dynamic_cast< SwTableBoxFmt* >( m_pFmt ) )
     161             :         {
     162           0 :             SwTableBox * pTblBox = SwIterator<SwTableBox,SwFmt>::FirstElement( *m_pFmt );
     163           0 :             if ( pTblBox )
     164             :             {
     165           0 :                 m_nNodeIndex = pTblBox->GetSttIdx();
     166             :             }
     167             :         }
     168             :     }
     169           0 : }
     170             : 
     171           0 : SwUndoFmtAttr::~SwUndoFmtAttr()
     172             : {
     173           0 : }
     174             : 
     175           0 : void SwUndoFmtAttr::UndoImpl(::sw::UndoRedoContext & rContext)
     176             : {
     177             :     // OD 2004-10-26 #i35443#
     178             :     // Important note: <Undo(..)> also called by <ReDo(..)>
     179             : 
     180           0 :     if ( !m_pOldSet.get() || !m_pFmt || !IsFmtInDoc( &rContext.GetDoc() ))
     181           0 :         return;
     182             : 
     183             :     // #i35443# - If anchor attribute has been successful
     184             :     // restored, all other attributes are also restored.
     185             :     // Thus, keep track of its restoration
     186           0 :     bool bAnchorAttrRestored( false );
     187           0 :     if ( SFX_ITEM_SET == m_pOldSet->GetItemState( RES_ANCHOR, false ))
     188             :     {
     189           0 :         bAnchorAttrRestored = RestoreFlyAnchor(rContext);
     190           0 :         if ( bAnchorAttrRestored )
     191             :         {
     192             :             // Anchor attribute successful restored.
     193             :             // Thus, keep anchor position for redo
     194           0 :             SaveFlyAnchor();
     195             :         }
     196             :         else
     197             :         {
     198             :             // Anchor attribute not restored due to invalid anchor position.
     199             :             // Thus, delete anchor attribute.
     200           0 :             m_pOldSet->ClearItem( RES_ANCHOR );
     201             :         }
     202             :     }
     203             : 
     204           0 :     if ( !bAnchorAttrRestored )
     205             :     {
     206           0 :         SwUndoFmtAttrHelper aTmp( *m_pFmt, m_bSaveDrawPt );
     207           0 :         m_pFmt->SetFmtAttr( *m_pOldSet );
     208           0 :         if ( aTmp.GetUndo() )
     209             :         {
     210             :             // transfer ownership of helper object's old set
     211           0 :             m_pOldSet = aTmp.GetUndo()->m_pOldSet;
     212             :         }
     213             :         else
     214             :         {
     215           0 :             m_pOldSet->ClearItem();
     216             :         }
     217             : 
     218           0 :         if ( RES_FLYFRMFMT == m_nFmtWhich || RES_DRAWFRMFMT == m_nFmtWhich )
     219             :         {
     220           0 :             rContext.SetSelections(static_cast<SwFrmFmt*>(m_pFmt), 0);
     221           0 :         }
     222             :     }
     223             : }
     224             : 
     225           0 : bool SwUndoFmtAttr::IsFmtInDoc( SwDoc* pDoc )
     226             : {
     227             :     // search for the Format in the Document; if it does not exist any more,
     228             :     // the attribute is not restored!
     229           0 :     sal_uInt16 nPos = USHRT_MAX;
     230           0 :     switch ( m_nFmtWhich )
     231             :     {
     232             :         case RES_TXTFMTCOLL:
     233             :             nPos = pDoc->GetTxtFmtColls()->GetPos(
     234           0 :                     static_cast<const SwTxtFmtColl*>(m_pFmt) );
     235           0 :             break;
     236             : 
     237             :         case RES_GRFFMTCOLL:
     238             :             nPos = pDoc->GetGrfFmtColls()->GetPos(
     239           0 :                     static_cast<const SwGrfFmtColl*>(m_pFmt) );
     240           0 :             break;
     241             : 
     242             :         case RES_CHRFMT:
     243             :             nPos = pDoc->GetCharFmts()->GetPos(
     244           0 :                     static_cast<SwCharFmt*>(m_pFmt) );
     245           0 :             break;
     246             : 
     247             :         case RES_FRMFMT:
     248           0 :             if ( m_nNodeIndex && (m_nNodeIndex < pDoc->GetNodes().Count()) )
     249             :             {
     250           0 :                 SwNode* pNd = pDoc->GetNodes()[ m_nNodeIndex ];
     251           0 :                 if ( pNd->IsTableNode() )
     252             :                 {
     253             :                     m_pFmt =
     254           0 :                         static_cast<SwTableNode*>(pNd)->GetTable().GetFrmFmt();
     255           0 :                     nPos = 0;
     256           0 :                     break;
     257             :                 }
     258           0 :                 else if ( pNd->IsSectionNode() )
     259             :                 {
     260             :                     m_pFmt =
     261           0 :                         static_cast<SwSectionNode*>(pNd)->GetSection().GetFmt();
     262           0 :                     nPos = 0;
     263           0 :                     break;
     264             :                 }
     265           0 :                 else if ( pNd->IsStartNode() && (SwTableBoxStartNode ==
     266           0 :                     static_cast< SwStartNode* >(pNd)->GetStartNodeType()) )
     267             :                 {
     268           0 :                     SwTableNode* pTblNode = pNd->FindTableNode();
     269           0 :                     if ( pTblNode )
     270             :                     {
     271             :                         SwTableBox* pBox =
     272           0 :                             pTblNode->GetTable().GetTblBox( m_nNodeIndex );
     273           0 :                         if ( pBox )
     274             :                         {
     275           0 :                             m_pFmt = pBox->GetFrmFmt();
     276           0 :                             nPos = 0;
     277           0 :                             break;
     278             :                         }
     279             :                     }
     280             :                 }
     281             :             }
     282             :             // no break!
     283             :         case RES_DRAWFRMFMT:
     284             :         case RES_FLYFRMFMT:
     285             :             nPos = pDoc->GetSpzFrmFmts()->GetPos(
     286           0 :                     static_cast<const SwFrmFmt*>(m_pFmt) );
     287           0 :             if ( USHRT_MAX == nPos )
     288             :             {
     289             :                 nPos = pDoc->GetFrmFmts()->GetPos(
     290           0 :                     static_cast<const SwFrmFmt*>(m_pFmt) );
     291             :             }
     292           0 :             break;
     293             :     }
     294             : 
     295           0 :     if ( USHRT_MAX == nPos )
     296             :     {
     297             :         // Format does not exist; reset
     298           0 :         m_pFmt = 0;
     299             :     }
     300             : 
     301           0 :     return 0 != m_pFmt;
     302             : }
     303             : 
     304             : // Check if it is still in Doc
     305           0 : SwFmt* SwUndoFmtAttr::GetFmt( SwDoc& rDoc )
     306             : {
     307           0 :     return m_pFmt && IsFmtInDoc( &rDoc ) ? m_pFmt : 0;
     308             : }
     309             : 
     310           0 : void SwUndoFmtAttr::RedoImpl(::sw::UndoRedoContext & rContext)
     311             : {
     312             :     // #i35443# - Because the undo stores the attributes for
     313             :     // redo, the same code as for <Undo(..)> can be applied for <Redo(..)>
     314           0 :     UndoImpl(rContext);
     315           0 : }
     316             : 
     317           0 : void SwUndoFmtAttr::RepeatImpl(::sw::RepeatContext & rContext)
     318             : {
     319           0 :     if ( !m_pOldSet.get() )
     320           0 :         return;
     321             : 
     322           0 :     SwDoc & rDoc(rContext.GetDoc());
     323             : 
     324           0 :     switch ( m_nFmtWhich )
     325             :     {
     326             :     case RES_GRFFMTCOLL:
     327             :         {
     328             :             SwNoTxtNode *const pNd =
     329           0 :                 rContext.GetRepeatPaM().GetNode()->GetNoTxtNode();
     330           0 :             if( pNd )
     331             :             {
     332           0 :                 rDoc.SetAttr( m_pFmt->GetAttrSet(), *pNd->GetFmtColl() );
     333             :             }
     334             :         }
     335           0 :         break;
     336             : 
     337             :     case RES_TXTFMTCOLL:
     338             :         {
     339             :             SwTxtNode *const pNd =
     340           0 :                 rContext.GetRepeatPaM().GetNode()->GetTxtNode();
     341           0 :             if( pNd )
     342             :             {
     343           0 :                 rDoc.SetAttr( m_pFmt->GetAttrSet(), *pNd->GetFmtColl() );
     344             :             }
     345             :         }
     346           0 :         break;
     347             : 
     348             :     case RES_FLYFRMFMT:
     349             :         {
     350             :             // Check if the cursor is in a flying frame
     351             :             // Steps: search in all FlyFrmFormats for the FlyCntnt attribute
     352             :             // and validate if the cursor is in the respective section
     353             :             SwFrmFmt *const pFly =
     354           0 :                 rContext.GetRepeatPaM().GetNode()->GetFlyFmt();
     355           0 :             if( pFly )
     356             :             {
     357             :                 // Bug 43672: do not set all attributes!
     358           0 :                 if (SFX_ITEM_SET ==
     359           0 :                         m_pFmt->GetAttrSet().GetItemState( RES_CNTNT ))
     360             :                 {
     361           0 :                     SfxItemSet aTmpSet( m_pFmt->GetAttrSet() );
     362           0 :                     aTmpSet.ClearItem( RES_CNTNT );
     363           0 :                     if( aTmpSet.Count() )
     364             :                     {
     365           0 :                         rDoc.SetAttr( aTmpSet, *pFly );
     366           0 :                     }
     367             :                 }
     368             :                 else
     369             :                 {
     370           0 :                     rDoc.SetAttr( m_pFmt->GetAttrSet(), *pFly );
     371             :                 }
     372             :             }
     373           0 :             break;
     374             :         }
     375             :     }
     376             : }
     377             : 
     378           0 : SwRewriter SwUndoFmtAttr::GetRewriter() const
     379             : {
     380           0 :     SwRewriter aRewriter;
     381             : 
     382           0 :     if (m_pFmt)
     383             :     {
     384           0 :         aRewriter.AddRule(UndoArg1, m_pFmt->GetName());
     385             :     }
     386             : 
     387           0 :     return aRewriter;
     388             : }
     389             : 
     390           0 : void SwUndoFmtAttr::PutAttr( const SfxPoolItem& rItem )
     391             : {
     392           0 :     m_pOldSet->Put( rItem );
     393           0 :     if ( RES_ANCHOR == rItem.Which() )
     394             :     {
     395           0 :         SaveFlyAnchor( m_bSaveDrawPt );
     396             :     }
     397           0 : }
     398             : 
     399           0 : void SwUndoFmtAttr::SaveFlyAnchor( bool bSvDrwPt )
     400             : {
     401             :     // Format is valid, otherwise you would not reach this point here
     402           0 :     if( bSvDrwPt )
     403             :     {
     404           0 :         if ( RES_DRAWFRMFMT == m_pFmt->Which() )
     405             :         {
     406           0 :             Point aPt( static_cast<SwFrmFmt*>(m_pFmt)->FindSdrObject()
     407           0 :                             ->GetRelativePos() );
     408             :             // store old value as attribute, to keep SwUndoFmtAttr small
     409           0 :             m_pOldSet->Put( SwFmtFrmSize( ATT_VAR_SIZE, aPt.X(), aPt.Y() ) );
     410             :         }
     411             :     }
     412             : 
     413             :     const SwFmtAnchor& rAnchor =
     414           0 :         static_cast<const SwFmtAnchor&>( m_pOldSet->Get( RES_ANCHOR, false ) );
     415           0 :     if( !rAnchor.GetCntntAnchor() )
     416           0 :         return;
     417             : 
     418           0 :     sal_Int32 nCntnt = 0;
     419           0 :     switch( rAnchor.GetAnchorId() )
     420             :     {
     421             :     case FLY_AS_CHAR:
     422             :     case FLY_AT_CHAR:
     423           0 :         nCntnt = rAnchor.GetCntntAnchor()->nContent.GetIndex();
     424             :         // fallthrough
     425             :     case FLY_AT_PARA:
     426             :     case FLY_AT_FLY:
     427           0 :         m_nNodeIndex = rAnchor.GetCntntAnchor()->nNode.GetIndex();
     428           0 :         break;
     429             :     default:
     430           0 :         return;
     431             :     }
     432             : 
     433           0 :     SwFmtAnchor aAnchor( rAnchor.GetAnchorId(), nCntnt );
     434           0 :     m_pOldSet->Put( aAnchor );
     435             : }
     436             : 
     437             : // #i35443# - Add return value, type <bool>.
     438             : // Return value indicates, if anchor attribute is restored.
     439             : // Note: If anchor attribute is restored, all other existing attributes
     440             : //       are also restored.
     441           0 : bool SwUndoFmtAttr::RestoreFlyAnchor(::sw::UndoRedoContext & rContext)
     442             : {
     443           0 :     SwDoc *const pDoc = & rContext.GetDoc();
     444           0 :     SwFlyFrmFmt* pFrmFmt = static_cast<SwFlyFrmFmt*>(m_pFmt);
     445             :     const SwFmtAnchor& rAnchor =
     446           0 :         static_cast<const SwFmtAnchor&>( m_pOldSet->Get( RES_ANCHOR, false ) );
     447             : 
     448           0 :     SwFmtAnchor aNewAnchor( rAnchor.GetAnchorId() );
     449           0 :     if (FLY_AT_PAGE != rAnchor.GetAnchorId())
     450             :     {
     451           0 :         SwNode* pNd = pDoc->GetNodes()[ m_nNodeIndex  ];
     452             : 
     453           0 :         if (  (FLY_AT_FLY == rAnchor.GetAnchorId())
     454           0 :             ? ( !pNd->IsStartNode() || (SwFlyStartNode !=
     455           0 :                     static_cast<SwStartNode*>(pNd)->GetStartNodeType()) )
     456           0 :             : !pNd->IsTxtNode() )
     457             :         {
     458             :             // #i35443# - invalid position.
     459             :             // Thus, anchor attribute not restored
     460           0 :             return false;
     461             :         }
     462             : 
     463           0 :         SwPosition aPos( *pNd );
     464           0 :         if ((FLY_AS_CHAR == rAnchor.GetAnchorId()) ||
     465           0 :             (FLY_AT_CHAR == rAnchor.GetAnchorId()))
     466             :         {
     467           0 :             aPos.nContent.Assign( (SwTxtNode*)pNd, rAnchor.GetPageNum() );
     468           0 :             if ( aPos.nContent.GetIndex() >
     469           0 :                     static_cast<SwTxtNode*>(pNd)->GetTxt().getLength())
     470             :             {
     471             :                 // #i35443# - invalid position.
     472             :                 // Thus, anchor attribute not restored
     473           0 :                 return false;
     474             :             }
     475             :         }
     476           0 :         aNewAnchor.SetAnchor( &aPos );
     477             :     }
     478             :     else
     479           0 :         aNewAnchor.SetPageNum( rAnchor.GetPageNum() );
     480             : 
     481           0 :     Point aDrawSavePt, aDrawOldPt;
     482           0 :     if( pDoc->GetCurrentViewShell() )
     483             :     {
     484           0 :         if( RES_DRAWFRMFMT == pFrmFmt->Which() )
     485             :         {
     486             :             // get the old cached value
     487             :             const SwFmtFrmSize& rOldSize = static_cast<const SwFmtFrmSize&>(
     488           0 :                     m_pOldSet->Get( RES_FRM_SIZE ) );
     489           0 :             aDrawSavePt.X() = rOldSize.GetWidth();
     490           0 :             aDrawSavePt.Y() = rOldSize.GetHeight();
     491           0 :             m_pOldSet->ClearItem( RES_FRM_SIZE );
     492             : 
     493             :             // write the current value into cache
     494           0 :             aDrawOldPt = pFrmFmt->FindSdrObject()->GetRelativePos();
     495             :         }
     496             :         else
     497             :         {
     498           0 :             pFrmFmt->DelFrms();         // delete Frms
     499             :         }
     500             :     }
     501             : 
     502           0 :     const SwFmtAnchor &rOldAnch = pFrmFmt->GetAnchor();
     503             :     // #i54336#
     504             :     // Consider case, that as-character anchored object has moved its anchor position.
     505           0 :     if (FLY_AS_CHAR == rOldAnch.GetAnchorId())
     506             :     {
     507             :         // With InCntnts it's tricky: the text attribute needs to be deleted.
     508             :         // Unfortunately, this not only destroys the Frms but also the format.
     509             :         // To prevent that, first detach the connection between attribute and
     510             :         // format.
     511           0 :         const SwPosition *pPos = rOldAnch.GetCntntAnchor();
     512           0 :         SwTxtNode *pTxtNode = (SwTxtNode*)&pPos->nNode.GetNode();
     513             :         OSL_ENSURE( pTxtNode->HasHints(), "Missing FlyInCnt-Hint." );
     514           0 :         const sal_Int32 nIdx = pPos->nContent.GetIndex();
     515             :         SwTxtAttr * const pHnt =
     516           0 :             pTxtNode->GetTxtAttrForCharAt( nIdx, RES_TXTATR_FLYCNT );
     517             :         OSL_ENSURE( pHnt && pHnt->Which() == RES_TXTATR_FLYCNT,
     518             :                     "Missing FlyInCnt-Hint." );
     519             :         OSL_ENSURE( pHnt && pHnt->GetFlyCnt().GetFrmFmt() == pFrmFmt,
     520             :                     "Wrong TxtFlyCnt-Hint." );
     521           0 :         const_cast<SwFmtFlyCnt&>(pHnt->GetFlyCnt()).SetFlyFmt();
     522             : 
     523             :         // Connection is now detached, therefore the attribute can be deleted
     524           0 :         pTxtNode->DeleteAttributes( RES_TXTATR_FLYCNT, nIdx, nIdx );
     525             :     }
     526             : 
     527             :     {
     528           0 :         m_pOldSet->Put( aNewAnchor );
     529           0 :         SwUndoFmtAttrHelper aTmp( *m_pFmt, m_bSaveDrawPt );
     530           0 :         m_pFmt->SetFmtAttr( *m_pOldSet );
     531           0 :         if ( aTmp.GetUndo() )
     532             :         {
     533           0 :             m_nNodeIndex = aTmp.GetUndo()->m_nNodeIndex;
     534             :             // transfer ownership of helper object's old set
     535           0 :             m_pOldSet = aTmp.GetUndo()->m_pOldSet;
     536             :         }
     537             :         else
     538             :         {
     539           0 :             m_pOldSet->ClearItem();
     540           0 :         }
     541             :     }
     542             : 
     543           0 :     if ( RES_DRAWFRMFMT == pFrmFmt->Which() )
     544             :     {
     545             :         SwDrawContact *pCont =
     546           0 :             static_cast<SwDrawContact*>(pFrmFmt->FindContactObj());
     547             :         // The Draw model also prepared an Undo object for its right positioning
     548             :         // which unfortunately is relative. Therefore block here a position
     549             :         // change of the Contact object by setting the anchor.
     550           0 :         SdrObject* pObj = pCont->GetMaster();
     551             : 
     552           0 :         if( pCont->GetAnchorFrm() && !pObj->IsInserted() )
     553             :         {
     554             :             OSL_ENSURE( pDoc->GetDrawModel(), "RestoreFlyAnchor without DrawModel" );
     555           0 :             pDoc->GetDrawModel()->GetPage( 0 )->InsertObject( pObj );
     556             :         }
     557           0 :         pObj->SetRelativePos( aDrawSavePt );
     558             : 
     559             :         // cache the old value again
     560             :         m_pOldSet->Put(
     561           0 :             SwFmtFrmSize( ATT_VAR_SIZE, aDrawOldPt.X(), aDrawOldPt.Y() ) );
     562             :     }
     563             : 
     564           0 :     if (FLY_AS_CHAR == aNewAnchor.GetAnchorId())
     565             :     {
     566           0 :         const SwPosition* pPos = aNewAnchor.GetCntntAnchor();
     567           0 :         SwTxtNode* pTxtNd = pPos->nNode.GetNode().GetTxtNode();
     568             :         OSL_ENSURE( pTxtNd, "no Text Node at position." );
     569           0 :         SwFmtFlyCnt aFmt( pFrmFmt );
     570           0 :         pTxtNd->InsertItem( aFmt, pPos->nContent.GetIndex(), 0 );
     571             :     }
     572             : 
     573           0 :     if( RES_DRAWFRMFMT != pFrmFmt->Which() )
     574           0 :         pFrmFmt->MakeFrms();
     575             : 
     576           0 :     rContext.SetSelections(pFrmFmt, 0);
     577             : 
     578             :     // #i35443# - anchor attribute restored.
     579           0 :     return true;
     580             : }
     581             : 
     582           0 : SwUndoFmtResetAttr::SwUndoFmtResetAttr( SwFmt& rChangedFormat,
     583             :                                         const sal_uInt16 nWhichId )
     584             :     : SwUndo( UNDO_RESETATTR )
     585             :     , m_pChangedFormat( &rChangedFormat )
     586             :     , m_nWhichId( nWhichId )
     587           0 :     , m_pOldItem( 0 )
     588             : {
     589           0 :     const SfxPoolItem* pItem = 0;
     590           0 :     if (rChangedFormat.GetItemState( nWhichId, sal_False, &pItem ) == SFX_ITEM_SET)
     591             :     {
     592           0 :         m_pOldItem.reset( pItem->Clone() );
     593             :     }
     594           0 : }
     595             : 
     596           0 : SwUndoFmtResetAttr::~SwUndoFmtResetAttr()
     597             : {
     598           0 : }
     599             : 
     600           0 : void SwUndoFmtResetAttr::UndoImpl(::sw::UndoRedoContext &)
     601             : {
     602           0 :     if ( m_pOldItem.get() )
     603             :     {
     604           0 :         m_pChangedFormat->SetFmtAttr( *m_pOldItem );
     605             :     }
     606           0 : }
     607             : 
     608           0 : void SwUndoFmtResetAttr::RedoImpl(::sw::UndoRedoContext &)
     609             : {
     610           0 :     if ( m_pOldItem.get() )
     611             :     {
     612           0 :         m_pChangedFormat->ResetFmtAttr( m_nWhichId );
     613             :     }
     614           0 : }
     615             : 
     616           0 : SwUndoResetAttr::SwUndoResetAttr( const SwPaM& rRange, sal_uInt16 nFmtId )
     617             :     : SwUndo( UNDO_RESETATTR ), SwUndRng( rRange )
     618           0 :     , m_pHistory( new SwHistory )
     619           0 :     , m_nFormatId( nFmtId )
     620             : {
     621           0 : }
     622             : 
     623           0 : SwUndoResetAttr::SwUndoResetAttr( const SwPosition& rPos, sal_uInt16 nFmtId )
     624             :     : SwUndo( UNDO_RESETATTR )
     625           0 :     , m_pHistory( new SwHistory )
     626           0 :     , m_nFormatId( nFmtId )
     627             : {
     628           0 :     nSttNode = nEndNode = rPos.nNode.GetIndex();
     629           0 :     nSttCntnt = nEndCntnt = rPos.nContent.GetIndex();
     630           0 : }
     631             : 
     632           0 : SwUndoResetAttr::~SwUndoResetAttr()
     633             : {
     634           0 : }
     635             : 
     636           0 : void SwUndoResetAttr::UndoImpl(::sw::UndoRedoContext & rContext)
     637             : {
     638             :     // reset old values
     639           0 :     SwDoc & rDoc = rContext.GetDoc();
     640           0 :     m_pHistory->TmpRollback( &rDoc, 0 );
     641           0 :     m_pHistory->SetTmpEnd( m_pHistory->Count() );
     642             : 
     643           0 :     if ((RES_CONDTXTFMTCOLL == m_nFormatId) &&
     644           0 :         (nSttNode == nEndNode) && (nSttCntnt == nEndCntnt))
     645             :     {
     646           0 :         SwTxtNode* pTNd = rDoc.GetNodes()[ nSttNode ]->GetTxtNode();
     647           0 :         if( pTNd )
     648             :         {
     649           0 :             SwIndex aIdx( pTNd, nSttCntnt );
     650           0 :             pTNd->DontExpandFmt( aIdx, false );
     651             :         }
     652             :     }
     653             : 
     654           0 :     AddUndoRedoPaM(rContext);
     655           0 : }
     656             : 
     657           0 : void SwUndoResetAttr::RedoImpl(::sw::UndoRedoContext & rContext)
     658             : {
     659           0 :     SwDoc & rDoc = rContext.GetDoc();
     660           0 :     SwPaM & rPam = AddUndoRedoPaM(rContext);
     661             : 
     662           0 :     switch ( m_nFormatId )
     663             :     {
     664             :     case RES_CHRFMT:
     665           0 :         rDoc.RstTxtAttrs(rPam);
     666           0 :         break;
     667             :     case RES_TXTFMTCOLL:
     668           0 :         rDoc.ResetAttrs(rPam, false, m_Ids );
     669           0 :         break;
     670             :     case RES_CONDTXTFMTCOLL:
     671           0 :         rDoc.ResetAttrs(rPam, true, m_Ids );
     672             : 
     673           0 :         break;
     674             :     case RES_TXTATR_TOXMARK:
     675             :         // special treatment for TOXMarks
     676             :         {
     677           0 :             SwTOXMarks aArr;
     678           0 :             SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode );
     679           0 :             SwPosition aPos( aIdx, SwIndex( aIdx.GetNode().GetCntntNode(),
     680           0 :                                                                 nSttCntnt ));
     681             : 
     682           0 :             sal_uInt16 nCnt = rDoc.GetCurTOXMark( aPos, aArr );
     683           0 :             if( nCnt )
     684             :             {
     685           0 :                 if( 1 < nCnt )
     686             :                 {
     687             :                     // search for the right one
     688           0 :                     SwHistoryHint* pHHint = (GetHistory())[ 0 ];
     689           0 :                     if( pHHint && HSTRY_SETTOXMARKHNT == pHHint->Which() )
     690             :                     {
     691           0 :                         while( nCnt )
     692             :                         {
     693           0 :                             if ( static_cast<SwHistorySetTOXMark*>(pHHint)
     694           0 :                                     ->IsEqual( *aArr[ --nCnt ] ) )
     695             :                             {
     696           0 :                                 ++nCnt;
     697           0 :                                 break;
     698             :                             }
     699             :                         }
     700             :                     }
     701             :                     else
     702           0 :                         nCnt = 0;
     703             :                 }
     704             :                 // found one, thus delete it
     705           0 :                 if( nCnt-- )
     706             :                 {
     707           0 :                     rDoc.DeleteTOXMark( aArr[ nCnt ] );
     708             :                 }
     709           0 :             }
     710             :         }
     711           0 :         break;
     712             :     }
     713           0 : }
     714             : 
     715           0 : void SwUndoResetAttr::RepeatImpl(::sw::RepeatContext & rContext)
     716             : {
     717           0 :     if (m_nFormatId < RES_FMT_BEGIN)
     718             :     {
     719           0 :         return;
     720             :     }
     721             : 
     722           0 :     switch ( m_nFormatId )
     723             :     {
     724             :     case RES_CHRFMT:
     725           0 :         rContext.GetDoc().RstTxtAttrs(rContext.GetRepeatPaM());
     726           0 :         break;
     727             :     case RES_TXTFMTCOLL:
     728           0 :         rContext.GetDoc().ResetAttrs(rContext.GetRepeatPaM(), false, m_Ids);
     729           0 :         break;
     730             :     case RES_CONDTXTFMTCOLL:
     731           0 :         rContext.GetDoc().ResetAttrs(rContext.GetRepeatPaM(), true, m_Ids);
     732           0 :         break;
     733             :     }
     734             : }
     735             : 
     736           0 : void SwUndoResetAttr::SetAttrs( const std::set<sal_uInt16> &rAttrs )
     737             : {
     738           0 :     m_Ids.clear();
     739           0 :     m_Ids.insert( rAttrs.begin(), rAttrs.end() );
     740           0 : }
     741             : 
     742           0 : SwUndoAttr::SwUndoAttr( const SwPaM& rRange, const SfxPoolItem& rAttr,
     743             :                         const SetAttrMode nFlags )
     744             :     : SwUndo( UNDO_INSATTR ), SwUndRng( rRange )
     745           0 :     , m_AttrSet( rRange.GetDoc()->GetAttrPool(), rAttr.Which(), rAttr.Which() )
     746           0 :     , m_pHistory( new SwHistory )
     747             :     , m_pRedlineData( 0 )
     748             :     , m_pRedlineSaveData( 0 )
     749             :     , m_nNodeIndex( ULONG_MAX )
     750           0 :     , m_nInsertFlags( nFlags )
     751             : {
     752           0 :     m_AttrSet.Put( rAttr );
     753           0 : }
     754             : 
     755           0 : SwUndoAttr::SwUndoAttr( const SwPaM& rRange, const SfxItemSet& rSet,
     756             :                         const SetAttrMode nFlags )
     757             :     : SwUndo( UNDO_INSATTR ), SwUndRng( rRange )
     758             :     , m_AttrSet( rSet )
     759           0 :     , m_pHistory( new SwHistory )
     760             :     , m_pRedlineData( 0 )
     761             :     , m_pRedlineSaveData( 0 )
     762             :     , m_nNodeIndex( ULONG_MAX )
     763           0 :     , m_nInsertFlags( nFlags )
     764             : {
     765           0 : }
     766             : 
     767           0 : SwUndoAttr::~SwUndoAttr()
     768             : {
     769           0 : }
     770             : 
     771           0 : void SwUndoAttr::SaveRedlineData( const SwPaM& rPam, sal_Bool bIsCntnt )
     772             : {
     773           0 :     SwDoc* pDoc = rPam.GetDoc();
     774           0 :     if ( pDoc->IsRedlineOn() )
     775             :     {
     776             :         m_pRedlineData.reset( new SwRedlineData( bIsCntnt
     777             :                                     ? nsRedlineType_t::REDLINE_INSERT
     778             :                                     : nsRedlineType_t::REDLINE_FORMAT,
     779           0 :                                 pDoc->GetRedlineAuthor() ) );
     780             :     }
     781             : 
     782           0 :     m_pRedlineSaveData.reset( new SwRedlineSaveDatas );
     783           0 :     if ( !FillSaveDataForFmt( rPam, *m_pRedlineSaveData ))
     784             :     {
     785           0 :         m_pRedlineSaveData.reset(0);
     786             :     }
     787             : 
     788           0 :     SetRedlineMode( pDoc->GetRedlineMode() );
     789           0 :     if ( bIsCntnt )
     790             :     {
     791           0 :         m_nNodeIndex = rPam.GetPoint()->nNode.GetIndex();
     792             :     }
     793           0 : }
     794             : 
     795           0 : void SwUndoAttr::UndoImpl(::sw::UndoRedoContext & rContext)
     796             : {
     797           0 :     SwDoc *const pDoc = & rContext.GetDoc();
     798             : 
     799           0 :     RemoveIdx( *pDoc );
     800             : 
     801           0 :     if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
     802             :     {
     803           0 :         SwPaM aPam(pDoc->GetNodes().GetEndOfContent());
     804           0 :         if ( ULONG_MAX != m_nNodeIndex )
     805             :         {
     806           0 :             aPam.DeleteMark();
     807           0 :             aPam.GetPoint()->nNode = m_nNodeIndex;
     808           0 :             aPam.GetPoint()->nContent.Assign( aPam.GetCntntNode(), nSttCntnt );
     809           0 :             aPam.SetMark();
     810           0 :             aPam.GetPoint()->nContent++;
     811           0 :             pDoc->DeleteRedline(aPam, false, USHRT_MAX);
     812             :         }
     813             :         else
     814             :         {
     815             :             // remove all format redlines, will be recreated if needed
     816           0 :             SetPaM(aPam);
     817           0 :             pDoc->DeleteRedline(aPam, false, nsRedlineType_t::REDLINE_FORMAT);
     818           0 :             if ( m_pRedlineSaveData.get() )
     819             :             {
     820           0 :                 SetSaveData( *pDoc, *m_pRedlineSaveData );
     821             :             }
     822           0 :         }
     823             :     }
     824             : 
     825           0 :     const bool bToLast =  (1 == m_AttrSet.Count())
     826           0 :                        && (RES_TXTATR_FIELD <= *m_AttrSet.GetRanges())
     827           0 :                        && (*m_AttrSet.GetRanges() <= RES_TXTATR_ANNOTATION);
     828             : 
     829             :     // restore old values
     830           0 :     m_pHistory->TmpRollback( pDoc, 0, !bToLast );
     831           0 :     m_pHistory->SetTmpEnd( m_pHistory->Count() );
     832             : 
     833             :     // set cursor onto Undo area
     834           0 :     AddUndoRedoPaM(rContext);
     835           0 : }
     836             : 
     837           0 : void SwUndoAttr::RepeatImpl(::sw::RepeatContext & rContext)
     838             : {
     839             :     // RefMarks are not repeat capable
     840           0 :     if ( SFX_ITEM_SET != m_AttrSet.GetItemState( RES_TXTATR_REFMARK, false ) )
     841             :     {
     842           0 :         rContext.GetDoc().InsertItemSet( rContext.GetRepeatPaM(),
     843           0 :                                            m_AttrSet, m_nInsertFlags );
     844             :     }
     845           0 :     else if ( 1 < m_AttrSet.Count() )
     846             :     {
     847           0 :         SfxItemSet aTmpSet( m_AttrSet );
     848           0 :         aTmpSet.ClearItem( RES_TXTATR_REFMARK );
     849           0 :         rContext.GetDoc().InsertItemSet( rContext.GetRepeatPaM(),
     850           0 :                                            aTmpSet, m_nInsertFlags );
     851             :     }
     852           0 : }
     853             : 
     854           0 : void SwUndoAttr::RedoImpl(::sw::UndoRedoContext & rContext)
     855             : {
     856           0 :     SwDoc & rDoc = rContext.GetDoc();
     857           0 :     SwPaM & rPam = AddUndoRedoPaM(rContext);
     858             : 
     859           0 :     if ( m_pRedlineData.get() &&
     860           0 :          IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
     861             :     {
     862           0 :         RedlineMode_t eOld = rDoc.GetRedlineMode();
     863             :         rDoc.SetRedlineMode_intern(static_cast<RedlineMode_t>(
     864           0 :                     eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
     865           0 :         rDoc.InsertItemSet( rPam, m_AttrSet, m_nInsertFlags );
     866             : 
     867           0 :         if ( ULONG_MAX != m_nNodeIndex )
     868             :         {
     869           0 :             rPam.SetMark();
     870           0 :             if ( rPam.Move( fnMoveBackward ) )
     871             :             {
     872           0 :                 rDoc.AppendRedline( new SwRangeRedline( *m_pRedlineData, rPam ),
     873           0 :                         true);
     874             :             }
     875           0 :             rPam.DeleteMark();
     876             :         }
     877             :         else
     878             :         {
     879           0 :             rDoc.AppendRedline( new SwRangeRedline( *m_pRedlineData, rPam ), true);
     880             :         }
     881             : 
     882           0 :         rDoc.SetRedlineMode_intern( eOld );
     883             :     }
     884             :     else
     885             :     {
     886           0 :         rDoc.InsertItemSet( rPam, m_AttrSet, m_nInsertFlags );
     887             :     }
     888           0 : }
     889             : 
     890           0 : void SwUndoAttr::RemoveIdx( SwDoc& rDoc )
     891             : {
     892           0 :     if ( SFX_ITEM_SET != m_AttrSet.GetItemState( RES_TXTATR_FTN, false ))
     893           0 :         return ;
     894             : 
     895             :     SwHistoryHint* pHstHnt;
     896           0 :     SwNodes& rNds = rDoc.GetNodes();
     897           0 :     for ( sal_uInt16 n = 0; n < m_pHistory->Count(); ++n )
     898             :     {
     899           0 :         sal_Int32 nCntnt = 0;
     900           0 :         sal_uLong nNode = 0;
     901           0 :         pHstHnt = (*m_pHistory)[ n ];
     902           0 :         switch ( pHstHnt->Which() )
     903             :         {
     904             :             case HSTRY_RESETTXTHNT:
     905             :                 {
     906             :                     SwHistoryResetTxt * pHistoryHint
     907           0 :                         = static_cast<SwHistoryResetTxt*>(pHstHnt);
     908           0 :                     if ( RES_TXTATR_FTN == pHistoryHint->GetWhich() )
     909             :                     {
     910           0 :                         nNode = pHistoryHint->GetNode();
     911           0 :                         nCntnt = pHistoryHint->GetCntnt();
     912             :                     }
     913             :                 }
     914           0 :                 break;
     915             : 
     916             :             case HSTRY_RESETATTRSET:
     917             :                 {
     918             :                     SwHistoryResetAttrSet * pHistoryHint
     919           0 :                         = static_cast<SwHistoryResetAttrSet*>(pHstHnt);
     920           0 :                     nCntnt = pHistoryHint->GetCntnt();
     921           0 :                     if ( COMPLETE_STRING != nCntnt )
     922             :                     {
     923           0 :                         const std::vector<sal_uInt16>& rArr = pHistoryHint->GetArr();
     924           0 :                         for ( sal_uInt16 i = rArr.size(); i; )
     925             :                         {
     926           0 :                             if ( RES_TXTATR_FTN == rArr[ --i ] )
     927             :                             {
     928           0 :                                 nNode = pHistoryHint->GetNode();
     929           0 :                                 break;
     930             :                             }
     931             :                         }
     932             :                     }
     933             :                 }
     934           0 :                 break;
     935             : 
     936             :             default:
     937           0 :                 break;
     938             :         }
     939             : 
     940           0 :         if( nNode )
     941             :         {
     942           0 :             SwTxtNode* pTxtNd = rNds[ nNode ]->GetTxtNode();
     943           0 :             if( pTxtNd )
     944             :             {
     945             :                 SwTxtAttr *const pTxtHt =
     946           0 :                     pTxtNd->GetTxtAttrForCharAt(nCntnt, RES_TXTATR_FTN);
     947           0 :                 if( pTxtHt )
     948             :                 {
     949             :                     // ok, so get values
     950           0 :                     SwTxtFtn* pFtn = static_cast<SwTxtFtn*>(pTxtHt);
     951           0 :                     RemoveIdxFromSection( rDoc, pFtn->GetStartNode()->GetIndex() );
     952           0 :                     return ;
     953             :                 }
     954             :             }
     955             :         }
     956             :     }
     957             : }
     958             : 
     959           0 : SwUndoDefaultAttr::SwUndoDefaultAttr( const SfxItemSet& rSet )
     960             :     : SwUndo( UNDO_SETDEFTATTR )
     961             :     , m_pOldSet( 0 )
     962           0 :     , m_pTabStop( 0 )
     963             : {
     964             :     const SfxPoolItem* pItem;
     965           0 :     if( SFX_ITEM_SET == rSet.GetItemState( RES_PARATR_TABSTOP, false, &pItem ) )
     966             :     {
     967             :         // store separately, because it may change!
     968           0 :         m_pTabStop.reset( static_cast<SvxTabStopItem*>(pItem->Clone()) );
     969           0 :         if ( 1 != rSet.Count() ) // are there more attributes?
     970             :         {
     971           0 :             m_pOldSet.reset( new SfxItemSet( rSet ) );
     972             :         }
     973             :     }
     974             :     else
     975             :     {
     976           0 :         m_pOldSet.reset( new SfxItemSet( rSet ) );
     977             :     }
     978           0 : }
     979             : 
     980           0 : SwUndoDefaultAttr::~SwUndoDefaultAttr()
     981             : {
     982           0 : }
     983             : 
     984           0 : void SwUndoDefaultAttr::UndoImpl(::sw::UndoRedoContext & rContext)
     985             : {
     986           0 :     SwDoc & rDoc = rContext.GetDoc();
     987           0 :     if ( m_pOldSet.get() )
     988             :     {
     989             :         SwUndoFmtAttrHelper aTmp(
     990           0 :                 *const_cast<SwTxtFmtColl*>(rDoc.GetDfltTxtFmtColl()) );
     991           0 :         rDoc.SetDefault( *m_pOldSet );
     992           0 :         m_pOldSet.reset( 0 );
     993           0 :         if ( aTmp.GetUndo() )
     994             :         {
     995             :             // transfer ownership of helper object's old set
     996           0 :             m_pOldSet = aTmp.GetUndo()->m_pOldSet;
     997           0 :         }
     998             :     }
     999           0 :     if ( m_pTabStop.get() )
    1000             :     {
    1001             :         SvxTabStopItem* pOld = static_cast<SvxTabStopItem*>(
    1002           0 :                 rDoc.GetDefault( RES_PARATR_TABSTOP ).Clone() );
    1003           0 :         rDoc.SetDefault( *m_pTabStop );
    1004           0 :         m_pTabStop.reset( pOld );
    1005             :     }
    1006           0 : }
    1007             : 
    1008           0 : void SwUndoDefaultAttr::RedoImpl(::sw::UndoRedoContext & rContext)
    1009             : {
    1010           0 :     UndoImpl(rContext);
    1011           0 : }
    1012             : 
    1013           0 : SwUndoMoveLeftMargin::SwUndoMoveLeftMargin(
    1014             :             const SwPaM& rPam, sal_Bool bFlag, bool bMod )
    1015             :     : SwUndo( bFlag ? UNDO_INC_LEFTMARGIN : UNDO_DEC_LEFTMARGIN )
    1016             :     , SwUndRng( rPam )
    1017           0 :     , m_pHistory( new SwHistory )
    1018           0 :     , m_bModulus( bMod )
    1019             : {
    1020           0 : }
    1021             : 
    1022           0 : SwUndoMoveLeftMargin::~SwUndoMoveLeftMargin()
    1023             : {
    1024           0 : }
    1025             : 
    1026           0 : void SwUndoMoveLeftMargin::UndoImpl(::sw::UndoRedoContext & rContext)
    1027             : {
    1028           0 :     SwDoc & rDoc = rContext.GetDoc();
    1029             : 
    1030             :     // restore old values
    1031           0 :     m_pHistory->TmpRollback( & rDoc, 0 );
    1032           0 :     m_pHistory->SetTmpEnd( m_pHistory->Count() );
    1033             : 
    1034           0 :     AddUndoRedoPaM(rContext);
    1035           0 : }
    1036             : 
    1037           0 : void SwUndoMoveLeftMargin::RedoImpl(::sw::UndoRedoContext & rContext)
    1038             : {
    1039           0 :     SwDoc & rDoc = rContext.GetDoc();
    1040           0 :     SwPaM & rPam = AddUndoRedoPaM(rContext);
    1041             : 
    1042             :     rDoc.MoveLeftMargin( rPam,
    1043           0 :             GetId() == UNDO_INC_LEFTMARGIN, m_bModulus );
    1044           0 : }
    1045             : 
    1046           0 : void SwUndoMoveLeftMargin::RepeatImpl(::sw::RepeatContext & rContext)
    1047             : {
    1048           0 :     SwDoc & rDoc = rContext.GetDoc();
    1049           0 :     rDoc.MoveLeftMargin(rContext.GetRepeatPaM(), GetId() == UNDO_INC_LEFTMARGIN,
    1050           0 :             m_bModulus );
    1051           0 : }
    1052             : 
    1053           0 : SwUndoChangeFootNote::SwUndoChangeFootNote(
    1054             :             const SwPaM& rRange, const OUString& rTxt,
    1055             :             sal_uInt16 nNum, bool bIsEndNote )
    1056             :     : SwUndo( UNDO_CHGFTN ), SwUndRng( rRange )
    1057           0 :     , m_pHistory( new SwHistory() )
    1058             :     , m_Text( rTxt )
    1059             :     , m_nNumber( nNum )
    1060           0 :     , m_bEndNote( bIsEndNote )
    1061             : {
    1062           0 : }
    1063             : 
    1064           0 : SwUndoChangeFootNote::~SwUndoChangeFootNote()
    1065             : {
    1066           0 : }
    1067             : 
    1068           0 : void SwUndoChangeFootNote::UndoImpl(::sw::UndoRedoContext & rContext)
    1069             : {
    1070           0 :     SwDoc & rDoc = rContext.GetDoc();
    1071             : 
    1072           0 :     m_pHistory->TmpRollback( &rDoc, 0 );
    1073           0 :     m_pHistory->SetTmpEnd( m_pHistory->Count() );
    1074             : 
    1075           0 :     rDoc.GetFtnIdxs().UpdateAllFtn();
    1076             : 
    1077           0 :     AddUndoRedoPaM(rContext);
    1078           0 : }
    1079             : 
    1080           0 : void SwUndoChangeFootNote::RedoImpl(::sw::UndoRedoContext & rContext)
    1081             : {
    1082           0 :     SwDoc & rDoc( rContext.GetDoc() );
    1083           0 :     SwPaM & rPaM = AddUndoRedoPaM(rContext);
    1084           0 :     rDoc.SetCurFtn(rPaM, m_Text, m_nNumber, m_bEndNote);
    1085           0 :     SetPaM(rPaM);
    1086           0 : }
    1087             : 
    1088           0 : void SwUndoChangeFootNote::RepeatImpl(::sw::RepeatContext & rContext)
    1089             : {
    1090           0 :     SwDoc & rDoc = rContext.GetDoc();
    1091           0 :     rDoc.SetCurFtn( rContext.GetRepeatPaM(), m_Text, m_nNumber, m_bEndNote );
    1092           0 : }
    1093             : 
    1094           0 : SwUndoFootNoteInfo::SwUndoFootNoteInfo( const SwFtnInfo &rInfo )
    1095             :     : SwUndo( UNDO_FTNINFO )
    1096           0 :     , m_pFootNoteInfo( new SwFtnInfo( rInfo ) )
    1097             : {
    1098           0 : }
    1099             : 
    1100           0 : SwUndoFootNoteInfo::~SwUndoFootNoteInfo()
    1101             : {
    1102           0 : }
    1103             : 
    1104           0 : void SwUndoFootNoteInfo::UndoImpl(::sw::UndoRedoContext & rContext)
    1105             : {
    1106           0 :     SwDoc & rDoc = rContext.GetDoc();
    1107           0 :     SwFtnInfo *pInf = new SwFtnInfo( rDoc.GetFtnInfo() );
    1108           0 :     rDoc.SetFtnInfo( *m_pFootNoteInfo );
    1109           0 :     m_pFootNoteInfo.reset( pInf );
    1110           0 : }
    1111             : 
    1112           0 : void SwUndoFootNoteInfo::RedoImpl(::sw::UndoRedoContext & rContext)
    1113             : {
    1114           0 :     SwDoc & rDoc = rContext.GetDoc();
    1115           0 :     SwFtnInfo *pInf = new SwFtnInfo( rDoc.GetFtnInfo() );
    1116           0 :     rDoc.SetFtnInfo( *m_pFootNoteInfo );
    1117           0 :     m_pFootNoteInfo.reset( pInf );
    1118           0 : }
    1119             : 
    1120           0 : SwUndoEndNoteInfo::SwUndoEndNoteInfo( const SwEndNoteInfo &rInfo )
    1121             :     : SwUndo( UNDO_FTNINFO )
    1122           0 :     , m_pEndNoteInfo( new SwEndNoteInfo( rInfo ) )
    1123             : {
    1124           0 : }
    1125             : 
    1126           0 : SwUndoEndNoteInfo::~SwUndoEndNoteInfo()
    1127             : {
    1128           0 : }
    1129             : 
    1130           0 : void SwUndoEndNoteInfo::UndoImpl(::sw::UndoRedoContext & rContext)
    1131             : {
    1132           0 :     SwDoc & rDoc = rContext.GetDoc();
    1133           0 :     SwEndNoteInfo *pInf = new SwEndNoteInfo( rDoc.GetEndNoteInfo() );
    1134           0 :     rDoc.SetEndNoteInfo( *m_pEndNoteInfo );
    1135           0 :     m_pEndNoteInfo.reset( pInf );
    1136           0 : }
    1137             : 
    1138           0 : void SwUndoEndNoteInfo::RedoImpl(::sw::UndoRedoContext & rContext)
    1139             : {
    1140           0 :     SwDoc & rDoc = rContext.GetDoc();
    1141           0 :     SwEndNoteInfo *pInf = new SwEndNoteInfo( rDoc.GetEndNoteInfo() );
    1142           0 :     rDoc.SetEndNoteInfo( *m_pEndNoteInfo );
    1143           0 :     m_pEndNoteInfo.reset( pInf );
    1144           0 : }
    1145             : 
    1146           0 : SwUndoDontExpandFmt::SwUndoDontExpandFmt( const SwPosition& rPos )
    1147             :     : SwUndo( UNDO_DONTEXPAND )
    1148           0 :     , m_nNodeIndex( rPos.nNode.GetIndex() )
    1149           0 :     , m_nContentIndex( rPos.nContent.GetIndex() )
    1150             : {
    1151           0 : }
    1152             : 
    1153           0 : void SwUndoDontExpandFmt::UndoImpl(::sw::UndoRedoContext & rContext)
    1154             : {
    1155           0 :     SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
    1156           0 :     SwDoc *const pDoc = & rContext.GetDoc();
    1157             : 
    1158           0 :     SwPosition& rPos = *pPam->GetPoint();
    1159           0 :     rPos.nNode = m_nNodeIndex;
    1160           0 :     rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), m_nContentIndex);
    1161           0 :     pDoc->DontExpandFmt( rPos, false );
    1162           0 : }
    1163             : 
    1164           0 : void SwUndoDontExpandFmt::RedoImpl(::sw::UndoRedoContext & rContext)
    1165             : {
    1166           0 :     SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
    1167           0 :     SwDoc *const pDoc = & rContext.GetDoc();
    1168             : 
    1169           0 :     SwPosition& rPos = *pPam->GetPoint();
    1170           0 :     rPos.nNode = m_nNodeIndex;
    1171           0 :     rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), m_nContentIndex);
    1172           0 :     pDoc->DontExpandFmt( rPos );
    1173           0 : }
    1174             : 
    1175           0 : void SwUndoDontExpandFmt::RepeatImpl(::sw::RepeatContext & rContext)
    1176             : {
    1177           0 :     SwPaM & rPam = rContext.GetRepeatPaM();
    1178           0 :     SwDoc & rDoc = rContext.GetDoc();
    1179           0 :     rDoc.DontExpandFmt( *rPam.GetPoint() );
    1180           0 : }
    1181             : 
    1182             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10