1 files changed, 88 insertions, 84 deletions

diff --git a/sw/source/core/undo/unnum.cxx b/sw/source/core/undo/unnum.cxx
index f6706bbc4666..eb44150f5715 100644
--- a/sw/source/core/undo/unnum.cxx
+++ b/sw/source/core/undo/unnum.cxx
@@ -28,21 +28,22 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <UndoNumbering.hxx>
 
 #include <hintids.hxx>
 #include <editeng/lrspitem.hxx>
 #include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
 #include <swundo.hxx>           // fuer die UndoIds
 #include <pam.hxx>
 #include <ndtxt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
 #include <rolbck.hxx>
 
 
 SV_DECL_PTRARR_DEL( _SfxPoolItems, SfxPoolItem*, 16, 16 )
 SV_IMPL_PTRARR( _SfxPoolItems, SfxPoolItem* );
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
 
 SwUndoInsNum::SwUndoInsNum( const SwNumRule& rOldRule,
                             const SwNumRule& rNewRule,
@@ -87,14 +88,9 @@ SwRewriter SwUndoInsNum::GetRewriter() const
     return aResult;
 }
 
-void SwUndoInsNum::Undo( SwUndoIter& rUndoIter )
+void SwUndoInsNum::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
-    if( nSttNode )
-        SetPaM( rUndoIter );
-
-    sal_Bool bUndo = rDoc.DoesUndo();
-    rDoc.DoUndo( sal_False );
+    SwDoc & rDoc = rContext.GetDoc();
 
     if( pOldNumRule )
         rDoc.ChgNumRuleFmts( *pOldNumRule );
@@ -134,29 +130,31 @@ void SwUndoInsNum::Undo( SwUndoIter& rUndoIter )
         pHistory->SetTmpEnd( pHistory->Count() );
     }
 
-    if( nSttNode )
-        SetPaM( rUndoIter );
-    rDoc.DoUndo( bUndo );
+    if (nSttNode)
+    {
+        AddUndoRedoPaM(rContext);
+    }
 }
 
-
-void SwUndoInsNum::Redo( SwUndoIter& rUndoIter )
+void SwUndoInsNum::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     if( pOldNumRule )
         rDoc.ChgNumRuleFmts( aNumRule );
     else if( pHistory )
     {
-        SetPaM( rUndoIter );
+        SwPaM & rPam( AddUndoRedoPaM(rContext) );
         if( sReplaceRule.Len() )
-            rDoc.ReplaceNumRule( *rUndoIter.pAktPam->GetPoint(),
+        {
+            rDoc.ReplaceNumRule(*rPam.GetPoint(),
                                 sReplaceRule, aNumRule.GetName() );
+        }
         else
         {
             // --> OD 2005-02-25 #i42921# - adapt to changed signature
             // --> OD 2008-03-18 #refactorlists#
-            rDoc.SetNumRule( *rUndoIter.pAktPam, aNumRule, false );
+            rDoc.SetNumRule(rPam, aNumRule, false);
             // <--
         }
     }
@@ -168,20 +166,23 @@ void SwUndoInsNum::SetLRSpaceEndPos()
         nLRSavePos = pHistory->Count();
 }
 
-void SwUndoInsNum::Repeat( SwUndoIter& rUndoIter )
+void SwUndoInsNum::RepeatImpl(::sw::RepeatContext & rContext)
 {
+    SwDoc & rDoc(rContext.GetDoc());
     if( nSttNode )
     {
         if( !sReplaceRule.Len() )
         {
             // --> OD 2005-02-25 #i42921# - adapt to changed signature
             // --> OD 2008-03-18 #refactorlists#
-            rUndoIter.GetDoc().SetNumRule( *rUndoIter.pAktPam, aNumRule, false );
+            rDoc.SetNumRule(rContext.GetRepeatPaM(), aNumRule, false);
             // <--
         }
     }
     else
-        rUndoIter.GetDoc().ChgNumRuleFmts( aNumRule );
+    {
+        rDoc.ChgNumRuleFmts( aNumRule );
+    }
 }
 
 SwHistory* SwUndoInsNum::GetHistory()
@@ -207,20 +208,14 @@ SwUndoDelNum::SwUndoDelNum( const SwPaM& rPam )
     pHistory = new SwHistory;
 }
 
-
 SwUndoDelNum::~SwUndoDelNum()
 {
     delete pHistory;
 }
 
-
-void SwUndoDelNum::Undo( SwUndoIter& rUndoIter )
+void SwUndoDelNum::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
-    SetPaM( rUndoIter );
-
-    sal_Bool bUndo = rDoc.DoesUndo();
-    rDoc.DoUndo( sal_False );
+    SwDoc & rDoc = rContext.GetDoc();
 
     pHistory->TmpRollback( &rDoc, 0 );
     pHistory->SetTmpEnd( pHistory->Count() );
@@ -235,22 +230,18 @@ void SwUndoDelNum::Undo( SwUndoIter& rUndoIter )
             pNd->ChkCondColl();
     }
 
-    SetPaM( rUndoIter );
-    rDoc.DoUndo( bUndo );
+    AddUndoRedoPaM(rContext);
 }
 
-
-void SwUndoDelNum::Redo( SwUndoIter& rUndoIter )
+void SwUndoDelNum::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetPaM( rUndoIter );
-    rUndoIter.GetDoc().DelNumRules( *rUndoIter.pAktPam );
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().DelNumRules(rPam);
 }
 
-
-void SwUndoDelNum::Repeat( SwUndoIter& rUndoIter )
+void SwUndoDelNum::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SetPaM( rUndoIter );
-    rUndoIter.GetDoc().DelNumRules( *rUndoIter.pAktPam );
+    rContext.GetDoc().DelNumRules(rContext.GetRepeatPaM());
 }
 
 void SwUndoDelNum::AddNode( const SwTxtNode& rNd, sal_Bool )
@@ -277,8 +268,7 @@ SwUndoMoveNum::SwUndoMoveNum( const SwPaM& rPam, long nOff, sal_Bool bIsOutlMv )
     //          nach oben   => -1
 }
 
-
-void SwUndoMoveNum::Undo( SwUndoIter& rUndoIter )
+void SwUndoMoveNum::UndoImpl(::sw::UndoRedoContext & rContext)
 {
     sal_uLong nTmpStt = nSttNode, nTmpEnd = nEndNode;
 
@@ -295,33 +285,35 @@ void SwUndoMoveNum::Undo( SwUndoIter& rUndoIter )
 //  SetPaM( rUndoIter );
 //  RemoveIdxFromRange( *rUndoIter.pAktPam, sal_True );
 
-    SetPaM( rUndoIter );
-    rUndoIter.GetDoc().MoveParagraph( *rUndoIter.pAktPam, -nOffset,
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().MoveParagraph( rPam, -nOffset,
                                         UNDO_OUTLINE_UD == GetId() );
     nSttNode = nTmpStt;
     nEndNode = nTmpEnd;
 }
 
-
-void SwUndoMoveNum::Redo( SwUndoIter& rUndoIter )
+void SwUndoMoveNum::RedoImpl(::sw::UndoRedoContext & rContext)
 {
 //JP 22.06.95: wird wollen die Bookmarks/Verzeichnisse behalten, oder?
 //  SetPaM( rUndoIter );
 //  RemoveIdxFromRange( *rUndoIter.pAktPam, sal_True );
 
-    SetPaM( rUndoIter );
-    rUndoIter.GetDoc().MoveParagraph( *rUndoIter.pAktPam, nOffset,
-                                        UNDO_OUTLINE_UD == GetId() );
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().MoveParagraph(rPam, nOffset, UNDO_OUTLINE_UD == GetId());
 }
 
-
-void SwUndoMoveNum::Repeat( SwUndoIter& rUndoIter )
+void SwUndoMoveNum::RepeatImpl(::sw::RepeatContext & rContext)
 {
+    SwDoc & rDoc = rContext.GetDoc();
     if( UNDO_OUTLINE_UD == GetId() )
-        rUndoIter.GetDoc().MoveOutlinePara( *rUndoIter.pAktPam,
+    {
+        rDoc.MoveOutlinePara(rContext.GetRepeatPaM(),
                                             0 < nOffset ? 1 : -1 );
+    }
     else
-        rUndoIter.GetDoc().MoveParagraph( *rUndoIter.pAktPam, nOffset, sal_False );
+    {
+        rDoc.MoveParagraph(rContext.GetRepeatPaM(), nOffset, FALSE);
+    }
 }
 
 /*  */
@@ -335,24 +327,21 @@ SwUndoNumUpDown::SwUndoNumUpDown( const SwPaM& rPam, short nOff )
     //          Up      => -1
 }
 
-
-void SwUndoNumUpDown::Undo( SwUndoIter& rUndoIter )
+void SwUndoNumUpDown::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetPaM( rUndoIter );
-    rUndoIter.GetDoc().NumUpDown( *rUndoIter.pAktPam, 1 != nOffset );
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().NumUpDown(rPam, 1 != nOffset );
 }
 
-
-void SwUndoNumUpDown::Redo( SwUndoIter& rUndoIter )
+void SwUndoNumUpDown::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetPaM( rUndoIter );
-    rUndoIter.GetDoc().NumUpDown( *rUndoIter.pAktPam, 1 == nOffset );
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().NumUpDown(rPam, 1 == nOffset);
 }
 
-
-void SwUndoNumUpDown::Repeat( SwUndoIter& rUndoIter )
+void SwUndoNumUpDown::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    rUndoIter.GetDoc().NumUpDown( *rUndoIter.pAktPam, 1 == nOffset );
+    rContext.GetDoc().NumUpDown(rContext.GetRepeatPaM(), 1 == nOffset);
 }
 
 /*  */
@@ -366,9 +355,9 @@ SwUndoNumOrNoNum::SwUndoNumOrNoNum( const SwNodeIndex& rIdx, sal_Bool bOldNum,
 }
 
 // #115901#, #i40034#
-void SwUndoNumOrNoNum::Undo( SwUndoIter& rUndoIter )
+void SwUndoNumOrNoNum::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwNodeIndex aIdx( rUndoIter.GetDoc().GetNodes(), nIdx );
+    SwNodeIndex aIdx( rContext.GetDoc().GetNodes(), nIdx );
     SwTxtNode * pTxtNd = aIdx.GetNode().GetTxtNode();
 
     if (NULL != pTxtNd)
@@ -378,9 +367,9 @@ void SwUndoNumOrNoNum::Undo( SwUndoIter& rUndoIter )
 }
 
 // #115901#, #i40034#
-void SwUndoNumOrNoNum::Redo( SwUndoIter& rUndoIter )
+void SwUndoNumOrNoNum::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwNodeIndex aIdx( rUndoIter.GetDoc().GetNodes(), nIdx );
+    SwNodeIndex aIdx( rContext.GetDoc().GetNodes(), nIdx );
     SwTxtNode * pTxtNd = aIdx.GetNode().GetTxtNode();
 
     if (NULL != pTxtNd)
@@ -390,15 +379,17 @@ void SwUndoNumOrNoNum::Redo( SwUndoIter& rUndoIter )
 }
 
 // #115901#
-void SwUndoNumOrNoNum::Repeat( SwUndoIter& rUndoIter )
+void SwUndoNumOrNoNum::RepeatImpl(::sw::RepeatContext & rContext)
 {
-
+    SwDoc & rDoc = rContext.GetDoc();
     if (mbOldNum && ! mbNewNum)
-        rUndoIter.GetDoc().NumOrNoNum( rUndoIter.pAktPam->GetPoint()->nNode,
-                                       sal_False);
+    {
+        rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, sal_False);
+    }
     else if ( ! mbOldNum && mbNewNum )
-        rUndoIter.GetDoc().NumOrNoNum( rUndoIter.pAktPam->GetPoint()->nNode,
-                                       sal_True);
+    {
+        rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, sal_True);
+    }
 }
 
 /*  */
@@ -432,34 +423,47 @@ SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, sal_uInt16 nStt
 }
 
 
-void SwUndoNumRuleStart::Undo( SwUndoIter& rUndoIter )
+void SwUndoNumRuleStart::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPosition aPos( *rUndoIter.GetDoc().GetNodes()[ nIdx ] );
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPosition const aPos( *rDoc.GetNodes()[ nIdx ] );
     if( bSetSttValue )
-        rUndoIter.GetDoc().SetNodeNumStart( aPos, nOldStt );
+    {
+        rDoc.SetNodeNumStart( aPos, nOldStt );
+    }
     else
-        rUndoIter.GetDoc().SetNumRuleStart( aPos, !bFlag );
+    {
+        rDoc.SetNumRuleStart( aPos, !bFlag );
+    }
 }
 
 
-void SwUndoNumRuleStart::Redo( SwUndoIter& rUndoIter )
+void SwUndoNumRuleStart::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
-
-    SwPosition aPos( *rDoc.GetNodes()[ nIdx ] );
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPosition const aPos( *rDoc.GetNodes()[ nIdx ] );
     if( bSetSttValue )
+    {
         rDoc.SetNodeNumStart( aPos, nNewStt );
+    }
     else
+    {
         rDoc.SetNumRuleStart( aPos, bFlag );
+    }
 }
 
 
-void SwUndoNumRuleStart::Repeat( SwUndoIter& rUndoIter )
+void SwUndoNumRuleStart::RepeatImpl(::sw::RepeatContext & rContext)
 {
+    SwDoc & rDoc = rContext.GetDoc();
     if( bSetSttValue )
-        rUndoIter.GetDoc().SetNodeNumStart( *rUndoIter.pAktPam->GetPoint(), nNewStt );
+    {
+        rDoc.SetNodeNumStart(*rContext.GetRepeatPaM().GetPoint(), nNewStt);
+    }
     else
-        rUndoIter.GetDoc().SetNumRuleStart( *rUndoIter.pAktPam->GetPoint(), bFlag );
+    {
+        rDoc.SetNumRuleStart(*rContext.GetRepeatPaM().GetPoint(), bFlag);
+    }
 }