Merge remote-tracking branch 'origin/integration/dev300_m101'

Conflicts:
	starmath/source/symbol.cxx
	sw/source/core/doc/docnew.cxx
	sw/source/core/doc/docnum.cxx
	sw/source/core/draw/dview.cxx
	sw/source/core/fields/docufld.cxx
	sw/source/core/layout/calcmove.cxx
	sw/source/filter/html/swhtml.cxx
	sw/source/filter/rtf/rtftbl.cxx
	sw/source/ui/config/modcfg.cxx
	sw/source/ui/dialog/docstdlg.cxx
	sw/source/ui/dialog/docstdlg.src
	sw/source/ui/fldui/flddb.cxx
	sw/source/ui/fldui/flddinf.cxx
	sw/source/ui/fldui/flddok.cxx
	sw/source/ui/fldui/fldfunc.cxx
	sw/source/ui/fldui/fldmgr.cxx
	sw/source/ui/fldui/fldpage.hxx
	sw/source/ui/fldui/fldref.cxx
	sw/source/ui/fldui/fldvar.cxx
	sw/source/ui/fldui/fldvar.hxx
	sw/source/ui/fldui/fldwrap.cxx
	sw/source/ui/fldui/xfldui.cxx
	sw/source/ui/inc/docstdlg.hxx
	sw/source/ui/shells/langhelper.cxx
	sw/source/ui/shells/txtattr.cxx
	sw/source/ui/shells/txtcrsr.cxx
	sw/source/ui/table/tabledlg.cxx

27 files changed, 2023 insertions, 2821 deletions

diff --git a/sw/source/core/undo/SwUndoField.cxx b/sw/source/core/undo/SwUndoField.cxx
index 7bb38c30d8..0e70e6f4d2 100644
--- a/sw/source/core/undo/SwUndoField.cxx
+++ b/sw/source/core/undo/SwUndoField.cxx
@@ -28,10 +28,13 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
+
 #include <tools/rtti.hxx>
+
 #include <SwUndoField.hxx>
 #include <swundo.hxx>
 #include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
 #include <txtfld.hxx>
 #include <fldbas.hxx>
 #include <ndtxt.hxx>
@@ -66,7 +69,7 @@ SwPosition SwUndoField::GetPosition()
 SwUndoFieldFromDoc::SwUndoFieldFromDoc(const SwPosition & rPos,
                          const SwField & rOldField,
                          const SwField & rNewField,
-                         SwMsgPoolItem * _pHnt, BOOL _bUpdate, SwUndoId _nId)
+                         SwMsgPoolItem * _pHnt, sal_Bool _bUpdate, SwUndoId _nId)
     : SwUndoField(rPos,_nId)
     , pOldField(rOldField.CopyField())
     , pNewField(rNewField.CopyField())
@@ -84,7 +87,7 @@ SwUndoFieldFromDoc::~SwUndoFieldFromDoc()
     delete pNewField;
 }
 
-void SwUndoFieldFromDoc::Undo( SwUndoIter& )
+void SwUndoFieldFromDoc::UndoImpl(::sw::UndoRedoContext &)
 {
     SwTxtFld * pTxtFld = SwDoc::GetTxtFld(GetPosition());
 
@@ -92,41 +95,39 @@ void SwUndoFieldFromDoc::Undo( SwUndoIter& )
 
     if (pField)
     {
-        BOOL bUndo = pDoc->DoesUndo();
-
-        pDoc->DoUndo(FALSE);
         pDoc->UpdateFld(pTxtFld, *pOldField, pHnt, bUpdate);
-        pDoc->DoUndo(bUndo);
     }
 }
 
-void SwUndoFieldFromDoc::Redo( SwUndoIter& )
+void SwUndoFieldFromDoc::DoImpl()
 {
     SwTxtFld * pTxtFld = SwDoc::GetTxtFld(GetPosition());
     const SwField * pField = pTxtFld ? pTxtFld->GetFld().GetFld() : NULL;
 
     if (pField)
     {
-        BOOL bUndo = pDoc->DoesUndo();
-
-        pDoc->DoUndo(FALSE);
         pDoc->UpdateFld(pTxtFld, *pNewField, pHnt, bUpdate);
         SwFmtFld* pDstFmtFld = (SwFmtFld*)&pTxtFld->GetFld();
 
         if ( pDoc->GetFldType(RES_POSTITFLD, aEmptyStr,false) == pDstFmtFld->GetFld()->GetTyp() )
             pDoc->GetDocShell()->Broadcast( SwFmtFldHint( pDstFmtFld, SWFMTFLD_INSERTED ) );
-        pDoc->DoUndo(bUndo);
     }
 }
 
-void SwUndoFieldFromDoc::Repeat(SwUndoIter & rIt)
+void SwUndoFieldFromDoc::RedoImpl(::sw::UndoRedoContext &)
 {
-    Redo(rIt);
+    DoImpl();
+}
+
+void SwUndoFieldFromDoc::RepeatImpl(::sw::RepeatContext &)
+{
+    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
+    DoImpl();
 }
 
 SwUndoFieldFromAPI::SwUndoFieldFromAPI(const SwPosition & rPos,
                                        const Any & rOldVal, const Any & rNewVal,
-                                       USHORT _nWhich)
+                                       sal_uInt16 _nWhich)
     : SwUndoField(rPos), aOldVal(rOldVal), aNewVal(rNewVal), nWhich(_nWhich)
 {
 }
@@ -135,7 +136,7 @@ SwUndoFieldFromAPI::~SwUndoFieldFromAPI()
 {
 }
 
-void SwUndoFieldFromAPI::Undo( SwUndoIter& )
+void SwUndoFieldFromAPI::UndoImpl(::sw::UndoRedoContext &)
 {
     SwField * pField = SwDoc::GetField(GetPosition());
 
@@ -143,7 +144,7 @@ void SwUndoFieldFromAPI::Undo( SwUndoIter& )
         pField->PutValue(aOldVal, nWhich);
 }
 
-void SwUndoFieldFromAPI::Redo( SwUndoIter& )
+void SwUndoFieldFromAPI::DoImpl()
 {
     SwField * pField = SwDoc::GetField(GetPosition());
 
@@ -151,10 +152,14 @@ void SwUndoFieldFromAPI::Redo( SwUndoIter& )
         pField->PutValue(aNewVal, nWhich);
 }
 
+void SwUndoFieldFromAPI::RedoImpl(::sw::UndoRedoContext &)
+{
+    DoImpl();
+}
 
-void SwUndoFieldFromAPI::Repeat(SwUndoIter & rIter)
+void SwUndoFieldFromAPI::RepeatImpl(::sw::RepeatContext &)
 {
-    Redo(rIter);
+    DoImpl();
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/undo/SwUndoFmt.cxx b/sw/source/core/undo/SwUndoFmt.cxx
index d123f7514b..3225349280 100644
--- a/sw/source/core/undo/SwUndoFmt.cxx
+++ b/sw/source/core/undo/SwUndoFmt.cxx
@@ -30,6 +30,8 @@
 #include "precompiled_sw.hxx"
 
 #include <tools/resid.hxx>
+#include <tools/string.hxx>
+
 #include <poolfmt.hxx>
 #include <charfmt.hxx>
 #include <frmfmt.hxx>
@@ -38,14 +40,14 @@
 #include <swundo.hxx>
 #include <undobj.hxx>
 #include <fmtcol.hxx>
-#include <tools/string.hxx>
 #include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
 #include <comcore.hrc>
 
 SwUndoFmtCreate::SwUndoFmtCreate
 (SwUndoId nUndoId, SwFmt * _pNew, SwFmt * _pDerivedFrom, SwDoc * _pDoc)
     : SwUndo(nUndoId), pNew(_pNew),
-      pDoc(_pDoc), pNewSet(NULL), nId(0), bAuto(FALSE)
+      pDoc(_pDoc), pNewSet(NULL), nId(0), bAuto(sal_False)
 {
     if (_pDerivedFrom)
         sDerivedFrom = _pDerivedFrom->GetName();
@@ -55,7 +57,7 @@ SwUndoFmtCreate::~SwUndoFmtCreate()
 {
 }
 
-void SwUndoFmtCreate::Undo(SwUndoIter &)
+void SwUndoFmtCreate::UndoImpl(::sw::UndoRedoContext &)
 {
     if (pNew)
     {
@@ -71,20 +73,13 @@ void SwUndoFmtCreate::Undo(SwUndoIter &)
             nId = pNew->GetPoolFmtId() & COLL_GET_RANGE_BITS;
             bAuto = pNew->IsAuto();
 
-            BOOL bDoesUndo = pDoc->DoesUndo();
-
-            pDoc->DoUndo(FALSE);
             Delete();
-            pDoc->DoUndo(bDoesUndo);
         }
     }
 }
 
-void SwUndoFmtCreate::Redo(SwUndoIter &)
+void SwUndoFmtCreate::RedoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
     SwFmt * pDerivedFrom = Find(sDerivedFrom);
     SwFmt * pFmt = Create(pDerivedFrom);
 
@@ -100,8 +95,6 @@ void SwUndoFmtCreate::Redo(SwUndoIter &)
     }
     else
         pNew = NULL;
-
-    pDoc->DoUndo(bDoesUndo);
 }
 
 SwRewriter SwUndoFmtCreate::GetRewriter() const
@@ -131,12 +124,8 @@ SwUndoFmtDelete::~SwUndoFmtDelete()
 {
 }
 
-void SwUndoFmtDelete::Undo(SwUndoIter &)
+void SwUndoFmtDelete::UndoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-
     SwFmt * pDerivedFrom = Find(sDerivedFrom);
 
     SwFmt * pFmt = Create(pDerivedFrom);
@@ -148,23 +137,16 @@ void SwUndoFmtDelete::Undo(SwUndoIter &)
         pFmt->SetPoolFmtId((pFmt->GetPoolFmtId() &
                                 ~COLL_GET_RANGE_BITS)
                                | nId);
-
     }
-
-    pDoc->DoUndo(bDoesUndo);
 }
 
-void SwUndoFmtDelete::Redo(SwUndoIter &)
+void SwUndoFmtDelete::RedoImpl(::sw::UndoRedoContext &)
 {
     SwFmt * pOld = Find(sOldName);
 
     if (pOld)
     {
-        BOOL bDoesUndo = pDoc->DoesUndo();
-
-        pDoc->DoUndo(FALSE);
         Delete(pOld);
-        pDoc->DoUndo(bDoesUndo);
     }
 }
 
@@ -191,31 +173,23 @@ SwUndoRenameFmt::~SwUndoRenameFmt()
 {
 }
 
-void SwUndoRenameFmt::Undo(SwUndoIter &)
+void SwUndoRenameFmt::UndoImpl(::sw::UndoRedoContext &)
 {
     SwFmt * pFmt = Find(sNewName);
 
     if (pFmt)
     {
-        BOOL bDoesUndo = pDoc->DoesUndo();
-
-        pDoc->DoUndo(FALSE);
-        pDoc->RenameFmt(*pFmt, sOldName, TRUE);
-        pDoc->DoUndo(bDoesUndo);
+        pDoc->RenameFmt(*pFmt, sOldName, sal_True);
     }
 }
 
-void SwUndoRenameFmt::Redo(SwUndoIter &)
+void SwUndoRenameFmt::RedoImpl(::sw::UndoRedoContext &)
 {
     SwFmt *  pFmt = Find(sOldName);
 
     if (pFmt)
     {
-        BOOL bDoesUndo = pDoc->DoesUndo();
-
-        pDoc->DoUndo(FALSE);
-        pDoc->RenameFmt(*pFmt, sNewName, TRUE);
-        pDoc->DoUndo(bDoesUndo);
+        pDoc->RenameFmt(*pFmt, sNewName, sal_True);
     }
 }
 
@@ -238,12 +212,12 @@ SwUndoTxtFmtCollCreate::SwUndoTxtFmtCollCreate
 
 SwFmt * SwUndoTxtFmtCollCreate::Create(SwFmt * pDerivedFrom)
 {
-    return pDoc->MakeTxtFmtColl(sNewName, (SwTxtFmtColl *)pDerivedFrom, TRUE);
+    return pDoc->MakeTxtFmtColl(sNewName, (SwTxtFmtColl *)pDerivedFrom, sal_True);
 }
 
 void SwUndoTxtFmtCollCreate::Delete()
 {
-    pDoc->DelTxtFmtColl((SwTxtFmtColl *) pNew, TRUE);
+    pDoc->DelTxtFmtColl((SwTxtFmtColl *) pNew, sal_True);
 }
 
 SwFmt * SwUndoTxtFmtCollCreate::Find(const String & rName) const
@@ -259,12 +233,12 @@ SwUndoTxtFmtCollDelete::SwUndoTxtFmtCollDelete(SwTxtFmtColl * _pOld,
 
 SwFmt * SwUndoTxtFmtCollDelete::Create(SwFmt * pDerivedFrom)
 {
-    return pDoc->MakeTxtFmtColl(sOldName, (SwTxtFmtColl *) pDerivedFrom, TRUE);
+    return pDoc->MakeTxtFmtColl(sOldName, (SwTxtFmtColl *) pDerivedFrom, sal_True);
 }
 
 void SwUndoTxtFmtCollDelete::Delete(SwFmt * pOld)
 {
-    pDoc->DelTxtFmtColl((SwTxtFmtColl *) pOld, TRUE);
+    pDoc->DelTxtFmtColl((SwTxtFmtColl *) pOld, sal_True);
 }
 
 SwFmt * SwUndoTxtFmtCollDelete::Find(const String & rName) const
@@ -293,12 +267,12 @@ SwUndoCharFmtCreate::SwUndoCharFmtCreate(SwCharFmt * pNewFmt,
 
 SwFmt * SwUndoCharFmtCreate::Create(SwFmt * pDerivedFrom)
 {
-    return pDoc->MakeCharFmt(sNewName, (SwCharFmt *) pDerivedFrom, TRUE);
+    return pDoc->MakeCharFmt(sNewName, (SwCharFmt *) pDerivedFrom, sal_True);
 }
 
 void SwUndoCharFmtCreate::Delete()
 {
-    pDoc->DelCharFmt((SwCharFmt *) pNew, TRUE);
+    pDoc->DelCharFmt((SwCharFmt *) pNew, sal_True);
 }
 
 SwFmt * SwUndoCharFmtCreate::Find(const String & rName) const
@@ -313,12 +287,12 @@ SwUndoCharFmtDelete::SwUndoCharFmtDelete(SwCharFmt * pOld, SwDoc * pDocument)
 
 SwFmt * SwUndoCharFmtDelete::Create(SwFmt * pDerivedFrom)
 {
-    return pDoc->MakeCharFmt(sOldName, (SwCharFmt *) pDerivedFrom, TRUE);
+    return pDoc->MakeCharFmt(sOldName, (SwCharFmt *) pDerivedFrom, sal_True);
 }
 
 void SwUndoCharFmtDelete::Delete(SwFmt * pFmt)
 {
-    pDoc->DelCharFmt((SwCharFmt *) pFmt, TRUE);
+    pDoc->DelCharFmt((SwCharFmt *) pFmt, sal_True);
 }
 
 SwFmt * SwUndoCharFmtDelete::Find(const String & rName) const
@@ -348,12 +322,12 @@ SwUndoFrmFmtCreate::SwUndoFrmFmtCreate(SwFrmFmt * pNewFmt,
 
 SwFmt * SwUndoFrmFmtCreate::Create(SwFmt * pDerivedFrom)
 {
-    return pDoc->MakeFrmFmt(sNewName, (SwFrmFmt *) pDerivedFrom, TRUE, bAuto);
+    return pDoc->MakeFrmFmt(sNewName, (SwFrmFmt *) pDerivedFrom, sal_True, bAuto);
 }
 
 void SwUndoFrmFmtCreate::Delete()
 {
-    pDoc->DelFrmFmt((SwFrmFmt *) pNew, TRUE);
+    pDoc->DelFrmFmt((SwFrmFmt *) pNew, sal_True);
 }
 
 SwFmt * SwUndoFrmFmtCreate::Find(const String & rName) const
@@ -368,12 +342,12 @@ SwUndoFrmFmtDelete::SwUndoFrmFmtDelete(SwFrmFmt * pOld, SwDoc * pDocument)
 
 SwFmt * SwUndoFrmFmtDelete::Create(SwFmt * pDerivedFrom)
 {
-    return pDoc->MakeFrmFmt(sOldName, (SwFrmFmt *) pDerivedFrom, TRUE);
+    return pDoc->MakeFrmFmt(sOldName, (SwFrmFmt *) pDerivedFrom, sal_True);
 }
 
 void SwUndoFrmFmtDelete::Delete(SwFmt * pFmt)
 {
-    pDoc->DelFrmFmt((SwFrmFmt *) pFmt, TRUE);
+    pDoc->DelFrmFmt((SwFrmFmt *) pFmt, sal_True);
 }
 
 SwFmt * SwUndoFrmFmtDelete::Find(const String & rName) const
@@ -400,29 +374,20 @@ SwUndoNumruleCreate::SwUndoNumruleCreate(const SwNumRule * _pNew,
 {
 }
 
-void SwUndoNumruleCreate::Undo(SwUndoIter &)
+void SwUndoNumruleCreate::UndoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-
     if (! bInitialized)
     {
         aNew = *pNew;
         bInitialized = true;
     }
 
-    pDoc->DelNumRule(aNew.GetName(), TRUE);
-    pDoc->DoUndo(bDoesUndo);
+    pDoc->DelNumRule(aNew.GetName(), sal_True);
 }
 
-void SwUndoNumruleCreate::Redo(SwUndoIter &)
+void SwUndoNumruleCreate::RedoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-    pDoc->MakeNumRule(aNew.GetName(), &aNew, TRUE);
-    pDoc->DoUndo(bDoesUndo);
+    pDoc->MakeNumRule(aNew.GetName(), &aNew, sal_True);
 }
 
 SwRewriter SwUndoNumruleCreate::GetRewriter() const
@@ -446,22 +411,14 @@ SwUndoNumruleDelete::SwUndoNumruleDelete(const SwNumRule & rRule,
 {
 }
 
-void SwUndoNumruleDelete::Undo(SwUndoIter &)
+void SwUndoNumruleDelete::UndoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-    pDoc->MakeNumRule(aOld.GetName(), &aOld, TRUE);
-    pDoc->DoUndo(bDoesUndo);
+    pDoc->MakeNumRule(aOld.GetName(), &aOld, sal_True);
 }
 
-void SwUndoNumruleDelete::Redo(SwUndoIter &)
+void SwUndoNumruleDelete::RedoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-    pDoc->DelNumRule(aOld.GetName(), TRUE);
-    pDoc->DoUndo(bDoesUndo);
+    pDoc->DelNumRule(aOld.GetName(), sal_True);
 }
 
 SwRewriter SwUndoNumruleDelete::GetRewriter() const
@@ -481,22 +438,14 @@ SwUndoNumruleRename::SwUndoNumruleRename(const String & _aOldName,
 {
 }
 
-void SwUndoNumruleRename::Undo(SwUndoIter &)
+void SwUndoNumruleRename::UndoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-    pDoc->RenameNumRule(aNewName, aOldName, TRUE);
-    pDoc->DoUndo(bDoesUndo);
+    pDoc->RenameNumRule(aNewName, aOldName, sal_True);
 }
 
-void SwUndoNumruleRename::Redo(SwUndoIter &)
+void SwUndoNumruleRename::RedoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-    pDoc->RenameNumRule(aOldName, aNewName, TRUE);
-    pDoc->DoUndo(bDoesUndo);
+    pDoc->RenameNumRule(aOldName, aNewName, sal_True);
 }
 
 SwRewriter SwUndoNumruleRename::GetRewriter() const
diff --git a/sw/source/core/undo/SwUndoPageDesc.cxx b/sw/source/core/undo/SwUndoPageDesc.cxx
index 29959bd292..28289d3c2c 100644
--- a/sw/source/core/undo/SwUndoPageDesc.cxx
+++ b/sw/source/core/undo/SwUndoPageDesc.cxx
@@ -31,6 +31,7 @@
 
 #include <tools/resid.hxx>
 #include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
 #include <swundo.hxx>
 #include <pagedesc.hxx>
 #include <SwUndoPageDesc.hxx>
@@ -49,10 +50,10 @@
 // Pure debug help function to have a quick look at the header/footer attributes.
 void DebugHeaderFooterContent( const SwPageDesc& rPageDesc )
 {
-    ULONG nHeaderMaster = ULONG_MAX;
-    ULONG nHeaderLeft = ULONG_MAX;
-    ULONG nFooterMaster = ULONG_MAX;
-    ULONG nFooterLeft = ULONG_MAX;
+    sal_uLong nHeaderMaster = ULONG_MAX;
+    sal_uLong nHeaderLeft = ULONG_MAX;
+    sal_uLong nFooterMaster = ULONG_MAX;
+    sal_uLong nFooterLeft = ULONG_MAX;
 
     SwFmtHeader& rHead = (SwFmtHeader&)rPageDesc.GetMaster().GetHeader();
     SwFmtFooter& rFoot = (SwFmtFooter&)rPageDesc.GetMaster().GetFooter();
@@ -240,7 +241,7 @@ void SwUndoPageDesc::ExchangeContentNodes( SwPageDesc& rSource, SwPageDesc &rDes
         // Let the destination page descrition point to the source node position,
         // from now on this descriptor is responsible for the content nodes!
         const SfxPoolItem* pItem;
-        rDest.GetMaster().GetAttrSet().GetItemState( RES_HEADER, FALSE, &pItem );
+        rDest.GetMaster().GetAttrSet().GetItemState( RES_HEADER, sal_False, &pItem );
         SfxPoolItem *pNewItem = pItem->Clone();
         SwFrmFmt* pNewFmt = ((SwFmtHeader*)pNewItem)->GetHeaderFmt();
 #ifdef DEBUG
@@ -254,7 +255,7 @@ void SwUndoPageDesc::ExchangeContentNodes( SwPageDesc& rSource, SwPageDesc &rDes
 
         // Let the source page description point to zero node position,
         // it loses the responsible and can be destroyed without removing the content nodes.
-        rSource.GetMaster().GetAttrSet().GetItemState( RES_HEADER, FALSE, &pItem );
+        rSource.GetMaster().GetAttrSet().GetItemState( RES_HEADER, sal_False, &pItem );
         pNewItem = pItem->Clone();
         pNewFmt = ((SwFmtHeader*)pNewItem)->GetHeaderFmt();
         pNewFmt->SetFmtAttr( SwFmtCntnt() );
@@ -264,7 +265,7 @@ void SwUndoPageDesc::ExchangeContentNodes( SwPageDesc& rSource, SwPageDesc &rDes
         {
             // Same procedure for unshared header..
             const SwFmtHeader& rSourceLeftHead = rSource.GetLeft().GetHeader();
-            rDest.GetLeft().GetAttrSet().GetItemState( RES_HEADER, FALSE, &pItem );
+            rDest.GetLeft().GetAttrSet().GetItemState( RES_HEADER, sal_False, &pItem );
             pNewItem = pItem->Clone();
             pNewFmt = ((SwFmtHeader*)pNewItem)->GetHeaderFmt();
 #ifdef DEBUG
@@ -275,7 +276,7 @@ void SwUndoPageDesc::ExchangeContentNodes( SwPageDesc& rSource, SwPageDesc &rDes
 #endif
             pNewFmt->SetFmtAttr( rSourceLeftHead.GetHeaderFmt()->GetCntnt() );
             delete pNewItem;
-            rSource.GetLeft().GetAttrSet().GetItemState( RES_HEADER, FALSE, &pItem );
+            rSource.GetLeft().GetAttrSet().GetItemState( RES_HEADER, sal_False, &pItem );
             pNewItem = pItem->Clone();
             pNewFmt = ((SwFmtHeader*)pNewItem)->GetHeaderFmt();
             pNewFmt->SetFmtAttr( SwFmtCntnt() );
@@ -288,7 +289,7 @@ void SwUndoPageDesc::ExchangeContentNodes( SwPageDesc& rSource, SwPageDesc &rDes
     if( rDestFoot.IsActive() )
     {
         const SfxPoolItem* pItem;
-        rDest.GetMaster().GetAttrSet().GetItemState( RES_FOOTER, FALSE, &pItem );
+        rDest.GetMaster().GetAttrSet().GetItemState( RES_FOOTER, sal_False, &pItem );
         SfxPoolItem *pNewItem = pItem->Clone();
         SwFrmFmt *pNewFmt = ((SwFmtFooter*)pNewItem)->GetFooterFmt();
         pNewFmt->SetFmtAttr( rSourceFoot.GetFooterFmt()->GetCntnt() );
@@ -300,7 +301,7 @@ void SwUndoPageDesc::ExchangeContentNodes( SwPageDesc& rSource, SwPageDesc &rDes
         const SwFmtCntnt& rFooterDestCntnt = rDestFoot.GetFooterFmt()->GetCntnt();
         (void)rFooterDestCntnt;
 #endif
-        rSource.GetMaster().GetAttrSet().GetItemState( RES_FOOTER, FALSE, &pItem );
+        rSource.GetMaster().GetAttrSet().GetItemState( RES_FOOTER, sal_False, &pItem );
         pNewItem = pItem->Clone();
         pNewFmt = ((SwFmtFooter*)pNewItem)->GetFooterFmt();
         pNewFmt->SetFmtAttr( SwFmtCntnt() );
@@ -316,12 +317,12 @@ void SwUndoPageDesc::ExchangeContentNodes( SwPageDesc& rSource, SwPageDesc &rDes
             (void)rFooterSourceCntnt2;
             (void)rFooterDestCntnt2;
 #endif
-            rDest.GetLeft().GetAttrSet().GetItemState( RES_FOOTER, FALSE, &pItem );
+            rDest.GetLeft().GetAttrSet().GetItemState( RES_FOOTER, sal_False, &pItem );
             pNewItem = pItem->Clone();
             pNewFmt = ((SwFmtFooter*)pNewItem)->GetFooterFmt();
             pNewFmt->SetFmtAttr( rSourceLeftFoot.GetFooterFmt()->GetCntnt() );
             delete pNewItem;
-            rSource.GetLeft().GetAttrSet().GetItemState( RES_FOOTER, FALSE, &pItem );
+            rSource.GetLeft().GetAttrSet().GetItemState( RES_FOOTER, sal_False, &pItem );
             pNewItem = pItem->Clone();
             pNewFmt = ((SwFmtFooter*)pNewItem)->GetFooterFmt();
             pNewFmt->SetFmtAttr( SwFmtCntnt() );
@@ -330,34 +331,20 @@ void SwUndoPageDesc::ExchangeContentNodes( SwPageDesc& rSource, SwPageDesc &rDes
     }
 }
 
-void SwUndoPageDesc::Undo(SwUndoIter &)
+void SwUndoPageDesc::UndoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-
     // Move (header/footer)content node responsibility from new page descriptor to old one again.
     if( bExchange )
         ExchangeContentNodes( (SwPageDesc&)aNew, (SwPageDesc&)aOld );
     pDoc->ChgPageDesc(aOld.GetName(), aOld);
-    pDoc->DoUndo(bUndo);
 }
 
-void SwUndoPageDesc::Redo(SwUndoIter &)
+void SwUndoPageDesc::RedoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-
     // Move (header/footer)content node responsibility from old page descriptor to new one again.
     if( bExchange )
         ExchangeContentNodes( (SwPageDesc&)aOld, (SwPageDesc&)aNew );
     pDoc->ChgPageDesc(aNew.GetName(), aNew);
-    pDoc->DoUndo(bUndo);
-}
-
-void SwUndoPageDesc::Repeat(SwUndoIter &)
-{
 }
 
 SwRewriter SwUndoPageDesc::GetRewriter() const
@@ -384,12 +371,8 @@ SwUndoPageDescCreate::~SwUndoPageDescCreate()
 {
 }
 
-void SwUndoPageDescCreate::Undo(SwUndoIter &)
+void SwUndoPageDescCreate::UndoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-
     // -> #116530#
     if (pDesc)
     {
@@ -398,26 +381,24 @@ void SwUndoPageDescCreate::Undo(SwUndoIter &)
     }
     // <- #116530#
 
-    pDoc->DelPageDesc(aNew.GetName(), TRUE);
-    pDoc->DoUndo(bUndo);
+    pDoc->DelPageDesc(aNew.GetName(), sal_True);
 }
 
-
-void SwUndoPageDescCreate::Redo(SwUndoIter &)
+void SwUndoPageDescCreate::DoImpl()
 {
-    BOOL bUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-
     SwPageDesc aPageDesc = aNew;
-    pDoc->MakePageDesc(aNew.GetName(), &aPageDesc, FALSE, TRUE); // #116530#
+    pDoc->MakePageDesc(aNew.GetName(), &aPageDesc, sal_False, sal_True); // #116530#
+}
 
-    pDoc->DoUndo(bUndo);
+void SwUndoPageDescCreate::RedoImpl(::sw::UndoRedoContext &)
+{
+    DoImpl();
 }
 
-void SwUndoPageDescCreate::Repeat(SwUndoIter & rIt)
+void SwUndoPageDescCreate::RepeatImpl(::sw::RepeatContext &)
 {
-    Redo(rIt);
+    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
+    DoImpl();
 }
 
 SwRewriter SwUndoPageDescCreate::GetRewriter() const
@@ -444,29 +425,26 @@ SwUndoPageDescDelete::~SwUndoPageDescDelete()
 {
 }
 
-void SwUndoPageDescDelete::Undo(SwUndoIter &)
+void SwUndoPageDescDelete::UndoImpl(::sw::UndoRedoContext &)
 {
-    BOOL bUndo = pDoc->DoesUndo();
-
-    pDoc->DoUndo(FALSE);
-
     SwPageDesc aPageDesc = aOld;
-    pDoc->MakePageDesc(aOld.GetName(), &aPageDesc, FALSE, TRUE); // #116530#
-    pDoc->DoUndo(bUndo);
+    pDoc->MakePageDesc(aOld.GetName(), &aPageDesc, sal_False, sal_True); // #116530#
 }
 
-void SwUndoPageDescDelete::Redo(SwUndoIter &)
+void SwUndoPageDescDelete::DoImpl()
 {
-    BOOL bUndo = pDoc->DoesUndo();
+    pDoc->DelPageDesc(aOld.GetName(), sal_True); // #116530#
+}
 
-    pDoc->DoUndo(FALSE);
-    pDoc->DelPageDesc(aOld.GetName(), TRUE); // #116530#
-    pDoc->DoUndo(bUndo);
+void SwUndoPageDescDelete::RedoImpl(::sw::UndoRedoContext &)
+{
+    DoImpl();
 }
 
-void SwUndoPageDescDelete::Repeat(SwUndoIter & rIt)
+void SwUndoPageDescDelete::RepeatImpl(::sw::RepeatContext &)
 {
-    Redo(rIt);
+    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
+    DoImpl();
 }
 
 SwRewriter SwUndoPageDescDelete::GetRewriter() const
diff --git a/sw/source/core/undo/SwUndoTOXChange.cxx b/sw/source/core/undo/SwUndoTOXChange.cxx
index a6d56fce5a..a05cf6f002 100644
--- a/sw/source/core/undo/SwUndoTOXChange.cxx
+++ b/sw/source/core/undo/SwUndoTOXChange.cxx
@@ -28,6 +28,7 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
+
 #include <SwUndoTOXChange.hxx>
 #include <swundo.hxx>
 #include <doctxm.hxx>
@@ -46,29 +47,33 @@ void SwUndoTOXChange::UpdateTOXBaseSection()
     if (pTOX->ISA(SwTOXBaseSection))
     {
         SwTOXBaseSection * pTOXBase = static_cast<SwTOXBaseSection *>(pTOX);
-        
         pTOXBase->Update();
         pTOXBase->UpdatePageNum();
     }
 }
 
-void SwUndoTOXChange::Undo(SwUndoIter &)
+void SwUndoTOXChange::UndoImpl(::sw::UndoRedoContext &)
 {
     *pTOX = aOld;
 
     UpdateTOXBaseSection();
 }
 
-void SwUndoTOXChange::Redo(SwUndoIter &)
+void SwUndoTOXChange::DoImpl()
 {
     *pTOX = aNew;
 
     UpdateTOXBaseSection();
 }
 
-void SwUndoTOXChange::Repeat(SwUndoIter & rIter)
+void SwUndoTOXChange::RedoImpl(::sw::UndoRedoContext &)
+{
+    DoImpl();
+}
+
+void SwUndoTOXChange::RepeatImpl(::sw::RepeatContext &)
 {
-    Redo(rIter);
+    DoImpl();
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/undo/docundo.cxx b/sw/source/core/undo/docundo.cxx
index 8b2cd0d88c..6bfc32e962 100644
--- a/sw/source/core/undo/docundo.cxx
+++ b/sw/source/core/undo/docundo.cxx
@@ -29,993 +29,553 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
-#include <svx/svdmodel.hxx>
+#include <UndoManager.hxx>
+
+#include <unotools/undoopt.hxx>
 
 #include <vcl/wrkwin.hxx>
+
+#include <svx/svdmodel.hxx>
+
+#include <swmodule.hxx>
 #include <doc.hxx>
+#include <ndarr.hxx>
 #include <pam.hxx>
 #include <ndtxt.hxx>
-#include <swundo.hxx>		// fuer die UndoIds
-#include <undobj.hxx>
+#include <swundo.hxx>
+#include <UndoCore.hxx>
 #include <rolbck.hxx>
-#include <docary.hxx>
 #include <undo.hrc>
+#include <editsh.hxx>
+#include <unobaseclass.hxx>
 
+#include <limits>
 
 using namespace ::com::sun::star;
 
 
-USHORT SwDoc::nUndoActions = UNDO_ACTION_COUNT;		// anzahl von Undo-Action
-
 // the undo array should never grow beyond this limit:
 #define UNDO_ACTION_LIMIT (USHRT_MAX - 1000)
 
 
-SV_IMPL_PTRARR( SwUndoIds, SwUndoIdAndNamePtr )
-
-//#define _SHOW_UNDORANGE
-#ifdef _SHOW_UNDORANGE
+// UndoManager ///////////////////////////////////////////////////////////
 
+namespace sw {
 
-class UndoArrStatus : public WorkWindow
+UndoManager::UndoManager(::std::auto_ptr<SwNodes> pUndoNodes,
+            IDocumentDrawModelAccess & rDrawModelAccess,
+            IDocumentRedlineAccess & rRedlineAccess,
+            IDocumentState & rState)
+    :   m_rDrawModelAccess(rDrawModelAccess)
+    ,   m_rRedlineAccess(rRedlineAccess)
+    ,   m_rState(rState)
+    ,   m_pUndoNodes(pUndoNodes)
+    ,   m_bGroupUndo(true)
+    ,   m_bDrawUndo(true)
+    ,   m_bLockUndoNoModifiedPosition(false)
+    ,   m_UndoSaveMark(MARK_INVALID)
 {
-    USHORT nUndo, nUndoNds;
-    virtual void Paint( const Rectangle& );
-public:
-    UndoArrStatus();
-    void Set( USHORT, USHORT );
-};
-static UndoArrStatus* pUndoMsgWin = 0;
-
-
-UndoArrStatus::UndoArrStatus()
-    : WorkWindow( APP_GETAPPWINDOW() ), nUndo(0), nUndoNds(0)
-{
-    SetSizePixel( Size( 200, 100 ));
-    SetFont( Font( "Courier", Size( 0, 10 )) );
-    Show();
+    OSL_ASSERT(m_pUndoNodes.get());
+    // writer expects it to be disabled initially
+    // Undo is enabled by SwEditShell constructor
+    SfxUndoManager::EnableUndo(false);
 }
 
-
-void UndoArrStatus::Set( USHORT n1, USHORT n2 )
+SwNodes const& UndoManager::GetUndoNodes() const
 {
-    nUndo = n1; nUndoNds = n2;
-    Invalidate();
+    return *m_pUndoNodes;
 }
 
-
-void UndoArrStatus::Paint( const Rectangle& )
+SwNodes      & UndoManager::GetUndoNodes()
 {
-    String s;
-    DrawRect( Rectangle( Point(0,0), GetOutputSize() ));
-    ( s = "Undos: " ) += nUndo;
-    DrawText( Point( 0, 0 ), s );
-    ( s = "UndoNodes: " ) += nUndoNds;
-    DrawText( Point( 0, 15 ), s );
+    return *m_pUndoNodes;
 }
 
-#endif
-
-void SwDoc::SetUndoNoResetModified()
+bool UndoManager::IsUndoNodes(SwNodes const& rNodes) const
 {
-    nUndoSavePos = USHRT_MAX;
+    return & rNodes == m_pUndoNodes.get();
 }
 
-bool SwDoc::IsUndoNoResetModified() const
+void UndoManager::DoUndo(bool const bDoUndo)
 {
-    return USHRT_MAX == nUndoSavePos;
-}
+    EnableUndo(bDoUndo);
 
-void SwDoc::DoUndo(bool bUn)
-{
-    mbUndo = bUn;
-
-    SdrModel* pSdrModel = GetDrawModel();
+    SdrModel *const pSdrModel = m_rDrawModelAccess.GetDrawModel();
     if( pSdrModel )
-        pSdrModel->EnableUndo(bUn);
+    {
+        pSdrModel->EnableUndo(bDoUndo);
+    }
 }
 
-bool SwDoc::DoesUndo() const
+bool UndoManager::DoesUndo() const
 {
-    return mbUndo;
+    return IsUndoEnabled();
 }
 
-void SwDoc::DoGroupUndo(bool bUn)
+void UndoManager::DoGroupUndo(bool const bDoUndo)
 {
-    mbGroupUndo = bUn;
+    m_bGroupUndo = bDoUndo;
 }
 
-bool SwDoc::DoesGroupUndo() const
+bool UndoManager::DoesGroupUndo() const
 {
-    return mbGroupUndo;
+    return m_bGroupUndo;
 }
 
-sal_uInt16 SwDoc::GetUndoActionCount()
+void UndoManager::DoDrawUndo(bool const bDoUndo)
 {
-    return nUndoActions;
+    m_bDrawUndo = bDoUndo;
 }
 
-void SwDoc::SetUndoActionCount( sal_uInt16 nNew )
+bool UndoManager::DoesDrawUndo() const
 {
-    nUndoActions = nNew;
+    return m_bDrawUndo;
 }
 
-const SwNodes* SwDoc::GetUndoNds() const
+
+bool UndoManager::IsUndoNoResetModified() const
 {
-    return &aUndoNodes;
+    return MARK_INVALID == m_UndoSaveMark;
 }
 
-void SwDoc::AppendUndo( SwUndo* pUndo )
+void UndoManager::SetUndoNoResetModified()
 {
-    if( nsRedlineMode_t::REDLINE_NONE == pUndo->GetRedlineMode() )
-        pUndo->SetRedlineMode( GetRedlineMode() );
-
-    // Unfortunately, the silly SvPtrArr can only store a little less than
-    // USHRT_MAX elements. Of course it doesn't see any necessity for asserting
-    // or even doing error handling. pUndos should definitely be replaced by an
-    // STL container that doesn't have this problem. cf #95884#
-    DBG_ASSERT( pUndos->Count() < USHRT_MAX - 16,
-                "Writer will crash soon. I apologize for the inconvenience." );
-
-    pUndos->Insert( pUndo, nUndoPos );
-    ++nUndoPos;
-    switch( pUndo->GetId() )
-    {
-    case UNDO_START:		++nUndoSttEnd;
-                            break;
-
-    case UNDO_END:		    OSL_ENSURE( nUndoSttEnd, "Undo-Ende ohne Start" );
-                            --nUndoSttEnd;
-                            // kein break !!!
-    default:
-        if( pUndos->Count() != nUndoPos && UNDO_END != pUndo->GetId() )
-            ClearRedo();
-        else {
-            OSL_ENSURE( pUndos->Count() == nUndoPos || UNDO_END == pUndo->GetId(),
-                    "Redo history not deleted!" );
-        }
-        if( !nUndoSttEnd )
-            ++nUndoCnt;
-        break;
-    }
-
-#ifdef _SHOW_UNDORANGE
-    // zur Anzeige der aktuellen Undo-Groessen
-    if( !pUndoMsgWin )
-            pUndoMsgWin = new UndoArrStatus;
-    pUndoMsgWin->Set( pUndos->Count(), aUndoNodes.Count() );
-#endif
-
-    // noch eine offene Klammerung, kann man sich den Rest schenken
-    if( nUndoSttEnd )
-        return;
-
-    // folgende Array-Grenzen muessen ueberwacht werden:
-    //	- Undo,				Grenze: fester Wert oder USHRT_MAX - 1000
-    //	- UndoNodes,		Grenze:  USHRT_MAX - 1000
-    //	- AttrHistory       Grenze:  USHRT_MAX - 1000
-    // (defined in UNDO_ACTION_LIMIT at the top of this file)
-
-    USHORT nEnde = UNDO_ACTION_LIMIT;
-
-// nur zum Testen der neuen DOC-Member
-#if OSL_DEBUG_LEVEL > 1
-{
-    SwUndoId nId = UNDO_EMPTY;
-    USHORT nUndosCnt = 0, nSttEndCnt = 0;
-    for( USHORT nCnt = 0; nCnt < nUndoPos; ++nCnt )
-    {
-        if( UNDO_START == ( nId = (*pUndos)[ nCnt ]->GetId()) )
-            ++nSttEndCnt;
-        else if( UNDO_END == nId )
-            --nSttEndCnt;
-        if( !nSttEndCnt )
-            ++nUndosCnt;
-    }
-    OSL_ENSURE( nSttEndCnt == nUndoSttEnd, "Start-Ende Count ungleich" );
-    OSL_ENSURE( nUndosCnt == nUndoCnt, "Undo Count ungleich" );
-}
-#endif
-
-    if( SwDoc::nUndoActions < nUndoCnt )
-        // immer 1/10 loeschen
-        //JP 23.09.95: oder wenn neu eingestellt wurde um die Differenz
-        //JP 29.5.2001: Task #83891#: remove only the overlapping actions
-        DelUndoObj( nUndoCnt - SwDoc::nUndoActions );
-    else
+    if (MARK_INVALID != m_UndoSaveMark)
     {
-        USHORT nUndosCnt = nUndoCnt;
-            // immer 1/10 loeschen bis der "Ausloeser" behoben ist
-        while( aUndoNodes.Count() && nEnde < aUndoNodes.Count() )
-            DelUndoObj( nUndosCnt / 10 );
+        RemoveMark(m_UndoSaveMark);
+        m_UndoSaveMark = MARK_INVALID;
     }
 }
 
-
-
-void SwDoc::ClearRedo()
+void UndoManager::SetUndoNoModifiedPosition()
 {
-    if( DoesUndo() && nUndoPos != pUndos->Count() )
+    if (!m_bLockUndoNoModifiedPosition)
     {
-//?? why ??		if( !nUndoSttEnd )
-        {
-            // setze UndoCnt auf den neuen Wert
-            SwUndo* pUndo;
-            for( USHORT nCnt = pUndos->Count(); nUndoPos < nCnt; --nUndoCnt )
-                // Klammerung ueberspringen
-                if( UNDO_END == (pUndo = (*pUndos)[ --nCnt ])->GetId() )
-                    nCnt = nCnt - ((SwUndoEnd*)pUndo)->GetSttOffset();
-        }
-
-        // loesche die Undo-Aktionen (immer von hinten !)
-        pUndos->DeleteAndDestroy( nUndoPos, pUndos->Count() - nUndoPos );
+        m_UndoSaveMark = MarkTopUndoAction();
     }
 }
 
-
-    // loescht die gesamten UndoObjecte
-void SwDoc::DelAllUndoObj()
+void UndoManager::LockUndoNoModifiedPosition()
 {
-    ClearRedo();
-
-    DoUndo( FALSE );
-
-    // Offene Undo-Klammerungen erhalten !!
-    SwUndo* pUndo;
-    USHORT nSize = pUndos->Count();
-    while( nSize )
-        if( UNDO_START != ( pUndo = (*pUndos)[ --nSize ] )->GetId() ||
-            ((SwUndoStart*)pUndo)->GetEndOffset() )
-            // keine offenen Gruppierung ?
-            pUndos->DeleteAndDestroy( nSize, 1 );
-
-    nUndoCnt = 0;
-    nUndoPos = pUndos->Count();
-
-/*
-    while( nUndoPos )
-        aUndos.DelDtor( --nUndoPos, 1 );
-    nUndoCnt = nUndoSttEnd = nUndoPos = 0;
-*/
-    nUndoSavePos = USHRT_MAX;
-    DoUndo( TRUE );
+    m_bLockUndoNoModifiedPosition = true;
 }
 
-
-    // loescht alle UndoObjecte vom Anfang bis zum angegebenen Ende
-BOOL SwDoc::DelUndoObj( USHORT nEnde )
+void UndoManager::UnLockUndoNoModifiedPosition()
 {
-    if( !nEnde )					// sollte mal 0 uebergeben werden,
-    {
-        if( !pUndos->Count() )
-            return FALSE;
-        ++nEnde;            		// dann korrigiere es auf 1
-    }
-
-    DoUndo( FALSE );
-
-    // pruefe erstmal, wo das Ende steht
-    SwUndoId nId = UNDO_EMPTY;
-    USHORT nSttEndCnt = 0;
-    USHORT nCnt;
-
-    for( nCnt = 0; nEnde && nCnt < nUndoPos; ++nCnt )
-    {
-        if( UNDO_START == ( nId = (*pUndos)[ nCnt ]->GetId() ))
-            ++nSttEndCnt;
-        else if( UNDO_END == nId )
-            --nSttEndCnt;
-        if( !nSttEndCnt )
-            --nEnde, --nUndoCnt;
-    }
-
-    OSL_ENSURE( nCnt < nUndoPos || nUndoPos == pUndos->Count(),
-            "Undo-Del-Ende liegt in einer Redo-Aktion" );
-
-    // dann setze ab Ende bis Undo-Ende bei allen Undo-Objecte die Werte um
-    nSttEndCnt = nCnt;			// Position merken
-    if( nUndoSavePos < nSttEndCnt )		// SavePos wird aufgegeben
-        nUndoSavePos = USHRT_MAX;
-    else if( nUndoSavePos != USHRT_MAX )
-        nUndoSavePos = nUndoSavePos - nSttEndCnt;
-
-    while( nSttEndCnt )
-        pUndos->DeleteAndDestroy( --nSttEndCnt, 1 );
-    nUndoPos = pUndos->Count();
-
-    DoUndo( TRUE );
-    return TRUE;
+    m_bLockUndoNoModifiedPosition = false;
 }
 
-/**************** UNDO ******************/
 
-void SwDoc::setUndoNoModifiedPosition( SwUndoNoModifiedPosition nNew )
+SwUndo* UndoManager::GetLastUndo()
 {
-    nUndoSavePos = nNew;
-    if( !pUndos->Count() || nUndoSavePos > pUndos->Count() - 1 )
-        nUndoSavePos = USHRT_MAX;
+    if (!SfxUndoManager::GetUndoActionCount(CurrentLevel))
+    {
+        return 0;
+    }
+    SfxUndoAction *const pAction( SfxUndoManager::GetUndoAction(0) );
+    return dynamic_cast<SwUndo*>(pAction);
 }
 
-SwUndoNoModifiedPosition SwDoc::getUndoNoModifiedPosition() const
+void UndoManager::AppendUndo(SwUndo *const pUndo)
 {
-    return nUndoSavePos;
+    AddUndoAction(pUndo);
 }
 
-
-bool SwDoc::HasUndoId(SwUndoId eId) const
+void UndoManager::ClearRedo()
 {
-    USHORT nSize = nUndoPos;
-    SwUndo * pUndo;
-    while( nSize-- )
-        if( ( pUndo = (*pUndos)[nSize])->GetId() == eId ||
-            ( UNDO_START == pUndo->GetId() &&
-                ((SwUndoStart*)pUndo)->GetUserId() == eId )
-            || ( UNDO_END == pUndo->GetId() &&
-                ((SwUndoEnd*)pUndo)->GetUserId() == eId ) )
-        {
-            return TRUE;
-        }
-
-    return FALSE;
+    return SfxUndoManager::ImplClearRedo_NoLock(TopLevel);
 }
 
-
-bool SwDoc::Undo( SwUndoIter& rUndoIter )
+void UndoManager::DelAllUndoObj()
 {
-    if ( (rUndoIter.GetId()!=0) && (!HasUndoId(rUndoIter.GetId())) )
-    {
-        rUndoIter.bWeiter = FALSE;
-        return FALSE;
-    }
-    if( !nUndoPos )
-    {
-        rUndoIter.bWeiter = FALSE;
-        return FALSE;
-    }
-
-    SwUndo *pUndo = (*pUndos)[ --nUndoPos ];
-
-    RedlineMode_t eOld = GetRedlineMode();
-    RedlineMode_t eTmpMode = (RedlineMode_t)pUndo->GetRedlineMode();
-    if( (nsRedlineMode_t::REDLINE_SHOW_MASK & eTmpMode) != (nsRedlineMode_t::REDLINE_SHOW_MASK & eOld) &&
-        UNDO_START != pUndo->GetId() && UNDO_END != pUndo->GetId() )
-        SetRedlineMode( eTmpMode );
-
-    SetRedlineMode_intern((RedlineMode_t)(eTmpMode | nsRedlineMode_t::REDLINE_IGNORE));
-    // Undo ausfuehren
-
-    // zum spaeteren ueberpruefen
-    SwUndoId nAktId = pUndo->GetId();
-    //JP 11.05.98: FlyFormate ueber die EditShell selektieren, nicht aus dem
-    //				Undo heraus
-    switch( nAktId )
-    {
-    case UNDO_START:
-    case UNDO_END:
-    case UNDO_INSDRAWFMT:
-        break;
-
-    default:
-        rUndoIter.ClearSelections();
-    }
-
-    pUndo->Undo( rUndoIter );
-
-    SetRedlineMode( eOld );
-
-    // Besonderheit von Undo-Replace (interne History)
-    if( UNDO_REPLACE == nAktId && ((SwUndoReplace*)pUndo)->nAktPos )
-    {
-        ++nUndoPos;
-        return TRUE;
-    }
-
-    // Objekt aus History entfernen und zerstoeren
-    if( nUndoPos && !rUndoIter.bWeiter &&
-        UNDO_START == ( pUndo = (*pUndos)[ nUndoPos-1 ] )->GetId() )
-        --nUndoPos;
+    ::sw::UndoGuard const undoGuard(*this);
 
-    // JP 29.10.96: Start und End setzen kein Modify-Flag.
-    //				Sonst gibt es Probleme mit der autom. Aufnahme von Ausnahmen
-    //				bei der Autokorrektur
-    if( UNDO_START != nAktId && UNDO_END != nAktId )
-        SetModified();		// default: immer setzen, kann zurueck gesetzt werden
+    SfxUndoManager::ClearAllLevels();
 
-    // ist die History leer und wurde nicht wegen Speichermangel
-    // verworfen, so kann das Dokument als unveraendert gelten
-    if( nUndoSavePos == nUndoPos )
-        ResetModified();
-
-    return TRUE;
+    m_UndoSaveMark = MARK_INVALID;
 }
 
 
-// setzt Undoklammerung auf, liefert nUndoId der Klammerung
-
+/**************** UNDO ******************/
 
-SwUndoId SwDoc::StartUndo( SwUndoId eUndoId, const SwRewriter * pRewriter )
+SwUndoId
+UndoManager::StartUndo(SwUndoId const i_eUndoId,
+        SwRewriter const*const pRewriter)
 {
-    if( !mbUndo )
+    if (!IsUndoEnabled())
+    {
         return UNDO_EMPTY;
+    }
 
-    if( !eUndoId )
-        eUndoId = UNDO_START;
-
-    SwUndoStart * pUndo = new SwUndoStart( eUndoId );
+    SwUndoId const eUndoId( (0 == i_eUndoId) ? UNDO_START : i_eUndoId );
 
+    OSL_ASSERT(UNDO_END != eUndoId);
+    String comment( (UNDO_START == eUndoId)
+        ?   String("??", RTL_TEXTENCODING_ASCII_US)
+        :   String(SW_RES(UNDO_BASE + eUndoId)) );
     if (pRewriter)
-        pUndo->SetRewriter(*pRewriter);
+    {
+        OSL_ASSERT(UNDO_START != eUndoId);
+        comment = pRewriter->Apply(comment);
+    }
 
-    AppendUndo(pUndo);
+    SfxUndoManager::EnterListAction(comment, comment, eUndoId);
 
     return eUndoId;
 }
-// schliesst Klammerung der nUndoId, nicht vom UI benutzt
 
 
-SwUndoId SwDoc::EndUndo(SwUndoId eUndoId, const SwRewriter * pRewriter)
+SwUndoId
+UndoManager::EndUndo(SwUndoId const i_eUndoId, SwRewriter const*const pRewriter)
 {
-    USHORT nSize = nUndoPos;
-    if( !mbUndo || !nSize-- )
-        return UNDO_EMPTY;
-
-    if( UNDO_START == eUndoId || !eUndoId )
-        eUndoId = UNDO_END;
-
-    SwUndo* pUndo = (*pUndos)[ nSize ];
-    if( UNDO_START == pUndo->GetId() )
+    if (!IsUndoEnabled())
     {
-        // leere Start/End-Klammerung ??
-        pUndos->DeleteAndDestroy( nSize );
-        --nUndoPos;
-        --nUndoSttEnd;
         return UNDO_EMPTY;
     }
 
-    // exist above any redo objects? If yes, delete them
-    if( nUndoPos != pUndos->Count() )
-    {
-        // setze UndoCnt auf den neuen Wert
-        for( USHORT nCnt = pUndos->Count(); nUndoPos < nCnt; --nUndoCnt )
-            // Klammerung ueberspringen
-            if( UNDO_END == (pUndo = (*pUndos)[ --nCnt ])->GetId() )
-                nCnt = nCnt - ((SwUndoEnd*)pUndo)->GetSttOffset();
-
-        pUndos->DeleteAndDestroy( nUndoPos, pUndos->Count() - nUndoPos );
-    }
-
-    // suche den Anfang dieser Klammerung
-    SwUndoId nId = UNDO_EMPTY;
-    while( nSize )
-        if( UNDO_START == ( nId = (pUndo = (*pUndos)[ --nSize ] )->GetId()) &&
-            !((SwUndoStart*)pUndo)->GetEndOffset() )
-            break;		// Start gefunden
-
-    if( nId != UNDO_START )
-    {
-        // kann eigentlich nur beim Abspielen von Macros passieren, die
-        // Undo/Redo/Repeat benutzen und die eine exitierende Selection
-        // durch Einfuegen loeschen
-        OSL_ENSURE( !this, "kein entsprechendes Ende gefunden" );
-        // kein entsprechenden Start gefunden -> Ende nicht einfuegen
-        // und die Member am Doc updaten
+    SwUndoId const eUndoId( ((0 == i_eUndoId) || (UNDO_START == i_eUndoId))
+            ? UNDO_END : i_eUndoId );
+    OSL_ENSURE(!((UNDO_END == eUndoId) && pRewriter),
+                "EndUndo(): no Undo ID, but rewriter given?");
 
-        nUndoSttEnd = 0;
-        nUndoCnt = 0;
-        // setze UndoCnt auf den neuen Wert
-        SwUndo* pTmpUndo;
-        for( USHORT nCnt = 0; nCnt < pUndos->Count(); ++nCnt, ++nUndoCnt )
-            // Klammerung ueberspringen
-            if( UNDO_START == (pTmpUndo = (*pUndos)[ nCnt ])->GetId() )
-                nCnt = nCnt + ((SwUndoStart*)pTmpUndo)->GetEndOffset();
-        return UNDO_EMPTY;
+    SfxUndoAction *const pLastUndo(
+        (0 == SfxUndoManager::GetUndoActionCount(CurrentLevel))
+            ? 0 : SfxUndoManager::GetUndoAction(0) );
 
-    }
+    int const nCount = LeaveListAction();
 
-    // Klammerung um eine einzelne Action muss nicht sein!
-    // Aussnahme: es ist eine eigene ID definiert
-    if(  2 == pUndos->Count() - nSize &&
-        (UNDO_END == eUndoId || eUndoId == (*pUndos)[ nSize+1 ]->GetId() ))
+    if (nCount) // otherwise: empty list action not inserted!
     {
-        pUndos->DeleteAndDestroy( nSize );
-        nUndoPos = pUndos->Count();
-        if( !--nUndoSttEnd )
+        OSL_ASSERT(pLastUndo);
+        OSL_ASSERT(UNDO_START != eUndoId);
+        SfxUndoAction *const pUndoAction(SfxUndoManager::GetUndoAction(0));
+        SfxListUndoAction *const pListAction(
+            dynamic_cast<SfxListUndoAction*>(pUndoAction));
+        OSL_ASSERT(pListAction);
+        if (pListAction)
         {
-            ++nUndoCnt;
-            if( SwDoc::nUndoActions < nUndoCnt )
-                // immer 1/10 loeschen
-                //JP 23.09.95: oder wenn neu eingestellt wurde um die Differenz
-                //JP 29.5.2001: Task #83891#: remove only the overlapping actions
-                DelUndoObj( nUndoCnt - SwDoc::nUndoActions );
+            if (UNDO_END != eUndoId)
+            {
+                OSL_ENSURE(pListAction->GetId() == eUndoId,
+                        "EndUndo(): given ID different from StartUndo()");
+                // comment set by caller of EndUndo
+                String comment = String(SW_RES(UNDO_BASE + eUndoId));
+                if (pRewriter)
+                {
+                    comment = pRewriter->Apply(comment);
+                }
+                pListAction->SetComment(comment);
+            }
+            else if ((UNDO_START != pListAction->GetId()))
+            {
+                // comment set by caller of StartUndo: nothing to do here
+            }
+            else if (pLastUndo)
+            {
+                // comment was not set at StartUndo or EndUndo:
+                // take comment of last contained action
+                // (note that this works recursively, i.e. the last contained
+                // action may be a list action created by StartUndo/EndUndo)
+                String const comment(pLastUndo->GetComment());
+                pListAction->SetComment(comment);
+            }
             else
             {
-                USHORT nEnde = USHRT_MAX - 1000;
-                USHORT nUndosCnt = nUndoCnt;
-                    // immer 1/10 loeschen bis der "Ausloeser" behoben ist
-                while( aUndoNodes.Count() && nEnde < aUndoNodes.Count() )
-                    DelUndoObj( nUndosCnt / 10 );
+                OSL_ENSURE(false, "EndUndo(): no comment?");
             }
         }
-        return eUndoId;
     }
 
-    // setze die Klammerung am Start/End-Undo
-    nSize = pUndos->Count() - nSize;
-    ((SwUndoStart*)pUndo)->SetEndOffset( nSize );
-
-    SwUndoEnd* pUndoEnd = new SwUndoEnd( eUndoId );
-    pUndoEnd->SetSttOffset( nSize );
+    return eUndoId;
+}
 
-// nur zum Testen der Start/End-Verpointerung vom Start/End Undo
-#if OSL_DEBUG_LEVEL > 1
+bool
+UndoManager::GetLastUndoInfo(
+        ::rtl::OUString *const o_pStr, SwUndoId *const o_pId) const
+{
+    // this is actually expected to work on the current level,
+    // but that was really not obvious from the previous implementation...
+    if (!SfxUndoManager::GetUndoActionCount(CurrentLevel))
     {
-        USHORT nEndCnt = 1, nCnt = pUndos->Count();
-        SwUndoId nTmpId = UNDO_EMPTY;
-        while( nCnt )
-        {
-            if( UNDO_START == ( nTmpId = (*pUndos)[ --nCnt ]->GetId()) )
-            {
-                if( !nEndCnt ) // falls mal ein Start ohne Ende vorhanden ist
-                    continue;
-                --nEndCnt;
-                if( !nEndCnt )		// hier ist der Anfang
-                    break;
-            }
-            else if( UNDO_END == nTmpId )
-                ++nEndCnt;
-            else if( !nEndCnt )
-                break;
-        }
-        OSL_ENSURE( nCnt == pUndos->Count() - nSize,
-                "Start-Ende falsch geklammert" );
+        return false;
     }
-#endif
 
-    if (pRewriter)
+    SfxUndoAction *const pAction( SfxUndoManager::GetUndoAction(0) );
+    if (o_pStr)
     {
-        ((SwUndoStart *) pUndo)->SetRewriter(*pRewriter);
-        pUndoEnd->SetRewriter(*pRewriter);
+        *o_pStr = pAction->GetComment();
+    }
+    if (o_pId)
+    {
+        sal_uInt16 const nId(pAction->GetId());
+        *o_pId = static_cast<SwUndoId>(nId);
     }
-    else
-        pUndoEnd->SetRewriter(((SwUndoStart *) pUndo)->GetRewriter());
 
-    AppendUndo( pUndoEnd );
-    return eUndoId;
+    return true;
 }
 
-// liefert die Id der letzten Undofaehigen Aktion zurueck oder 0
-// fuellt ggf. VARARR mit User-UndoIds
-
-String SwDoc::GetUndoIdsStr( String* pStr, SwUndoIds *pUndoIds) const
+SwUndoComments_t UndoManager::GetUndoComments() const
 {
-    String aTmpStr;
+    OSL_ENSURE(!SfxUndoManager::IsInListAction(),
+            "GetUndoComments() called while in list action?");
 
-    if (pStr != NULL)
+    SwUndoComments_t ret;
+    sal_uInt16 const nUndoCount(SfxUndoManager::GetUndoActionCount(TopLevel));
+    for (sal_uInt16 n = 0; n < nUndoCount; ++n)
     {
-        GetUndoIds( pStr, pUndoIds);
-        aTmpStr = *pStr;
+        ::rtl::OUString const comment(
+                SfxUndoManager::GetUndoActionComment(n, TopLevel));
+        ret.push_back(comment);
     }
-    else
-        GetUndoIds( &aTmpStr, pUndoIds);
 
-    return aTmpStr;
+    return ret;
 }
 
-sal_Bool SwDoc::RestoreInvisibleContent()
+
+/**************** REDO ******************/
+bool UndoManager::GetFirstRedoInfo(::rtl::OUString *const o_pStr) const
 {
-    sal_Bool bRet = sal_False;
-    if(nUndoPos > 0 )
+    if (!SfxUndoManager::GetRedoActionCount(CurrentLevel))
     {
-        SwUndo * pUndo = (*pUndos)[ nUndoPos - 1 ];
-        if( ( pUndo->GetId() == UNDO_END &&
-            static_cast<SwUndoEnd *>(pUndo)->GetUserId() == UNDO_UI_DELETE_INVISIBLECNTNT) )
-        {
-            SwPaM aPam( GetNodes().GetEndOfPostIts() );
-            SwUndoIter aUndoIter( &aPam );
-            do
-            {
-                Undo( aUndoIter );
-            }
-            while ( aUndoIter.IsNextUndo() );
-            ClearRedo();
-            bRet = sal_True;
-        }
+        return false;
     }
-    return bRet;
-}
-
-
-/**
-   Returns id and comment for a certain undo object in an undo stack.
-
-   Remark: In the following the object type referred to is always the
-   effective object type. If an UNDO_START or UNDO_END has a user type
-   it is referred to as this type.
-
-   If the queried object is an UNDO_END and has no user id the result
-   is taken from the first object that is not an UNDO_END nor an
-   UNDO_START preceeding the queried object.
-
-   If the queried object is an UNDO_START and has no user id the
-   result is taken from the first object that is not an UNDO_END nor
-   an UNDO_START preceeding the UNDO_END object belonging to the
-   queried object.
-
-   In all other cases the result is taken from the queried object.
 
-   @param rUndos           the undo stack
-   @param nPos             position of the undo object to query
-
-   @return SwUndoIdAndName object containing the query result
- */
-SwUndoIdAndName * lcl_GetUndoIdAndName(const SwUndos & rUndos, sal_uInt16 nPos )
-{
-    SwUndo * pUndo = rUndos[ nPos ];
-    SwUndoId nId = UNDO_EMPTY;
-    String sStr("??", RTL_TEXTENCODING_ASCII_US);
-
-    OSL_ENSURE( nPos < rUndos.Count(), "nPos out of range");
-
-    switch (pUndo->GetId())
+    if (o_pStr)
     {
-    case UNDO_START:
-        {
-            SwUndoStart * pUndoStart = (SwUndoStart *) pUndo;
-            nId = pUndoStart->GetUserId();
-
-            if (nId <= UNDO_END)
-            {
-                /**
-                   Start at the according UNDO_END.  Search backwards
-                   for first objects that is not a UNDO_END.
-                 */
-                int nTmpPos = nPos + pUndoStart->GetEndOffset();
-                if ( nTmpPos > 0 ) // #i105457# Segmentation Fault opening graphics placeholder
-                {
-                    int nSubstitute = -1;
-                    SwUndo * pTmpUndo;
-                    do
-                    {
-                        nTmpPos--;
-                        pTmpUndo = rUndos[ static_cast<USHORT>(nTmpPos) ];
-
-                        if (pTmpUndo->GetEffectiveId() > UNDO_END)
-                            nSubstitute = nTmpPos;
-                    }
-                    while (nSubstitute < 0 && nTmpPos > nPos);
-
-                    if (nSubstitute >= 0)
-                    {
-                        SwUndo * pSubUndo = rUndos[ static_cast<USHORT>(nSubstitute) ];
-                        nId = pSubUndo->GetEffectiveId();
-                        sStr = pSubUndo->GetComment();
-                    }
-                }
-            }
-            else
-                sStr = pUndo->GetComment();
-        }
-
-        break;
-
-    case UNDO_END:
-        {
-            SwUndoEnd * pUndoEnd = (SwUndoEnd *) pUndo;
-            nId = pUndoEnd->GetUserId();
-
-            if (nId <= UNDO_END)
-            {
-                /**
-                   Start at this UNDO_END.  Search backwards
-                   for first objects that is not a UNDO_END.
-                 */
-
-                int nTmpPos = nPos;
-
-                if (nTmpPos > 0)
-                {
-                    int nUndoStart = nTmpPos - pUndoEnd->GetSttOffset();
-                    int nSubstitute = -1;
-                    SwUndo * pTmpUndo;
-
-                    do
-                    {
-                        nTmpPos--;
-                        pTmpUndo = rUndos[ static_cast<USHORT>(nTmpPos) ];
-
-                        if (pTmpUndo->GetEffectiveId() > UNDO_END)
-                            nSubstitute = nTmpPos;
-                    }
-                    while (nSubstitute < 0 && nTmpPos > nUndoStart);
-
-                    if (nSubstitute >= 0)
-                    {
-                        SwUndo * pSubUndo = rUndos[ static_cast<USHORT>(nSubstitute) ];
-                        nId = pSubUndo->GetEffectiveId();
-                        sStr = pSubUndo->GetComment();
-                    }
-                }
-            }
-            else
-                sStr = pUndo->GetComment();
-        }
-
-        break;
-
-    default:
-        nId = pUndo->GetId();
-        sStr = pUndo->GetComment();
+        *o_pStr = SfxUndoManager::GetRedoActionComment(0, CurrentLevel);
     }
 
-    return new SwUndoIdAndName(nId, &sStr);
+    return true;
 }
 
-SwUndoId SwDoc::GetUndoIds( String* pStr, SwUndoIds *pUndoIds) const
+
+SwUndoComments_t UndoManager::GetRedoComments() const
 {
-    int nTmpPos = nUndoPos - 1;
-    SwUndoId nId = UNDO_EMPTY;
+    OSL_ENSURE(!SfxUndoManager::IsInListAction(),
+            "GetRedoComments() called while in list action?");
 
-    while (nTmpPos >= 0)
+    SwUndoComments_t ret;
+    sal_uInt16 const nRedoCount(SfxUndoManager::GetRedoActionCount(TopLevel));
+    for (sal_uInt16 n = 0; n < nRedoCount; ++n)
     {
-        SwUndo * pUndo = (*pUndos)[ static_cast<USHORT>(nTmpPos) ];
-
-        SwUndoIdAndName * pIdAndName = lcl_GetUndoIdAndName( *pUndos, static_cast<sal_uInt16>(nTmpPos) );
-
-        if (nTmpPos == nUndoPos - 1)
-        {
-            nId = pIdAndName->GetUndoId();
-
-            if (pStr)
-                *pStr = *pIdAndName->GetUndoStr();
-        }
-
-        if (pUndoIds)
-            pUndoIds->Insert(pIdAndName, pUndoIds->Count());
-        else
-            break;
-
-        if (pUndo->GetId() == UNDO_END)
-            nTmpPos -= ((SwUndoEnd *) pUndo)->GetSttOffset();
-
-        nTmpPos--;
+        ::rtl::OUString const comment(
+                SfxUndoManager::GetRedoActionComment(n, TopLevel));
+        ret.push_back(comment);
     }
 
-    return nId;
+    return ret;
 }
 
-bool SwDoc::HasTooManyUndos() const
-{
-    // AppendUndo checks the UNDO_ACTION_LIMIT, unless there's a nested undo.
-    // So HasTooManyUndos() may only occur when undos are nested; else
-    // AppendUndo has some sort of bug.
-    DBG_ASSERT( (nUndoSttEnd != 0) || (pUndos->Count() < UNDO_ACTION_LIMIT),
-                "non-nested undos should have been handled in AppendUndo" );
-    return (pUndos->Count() >= UNDO_ACTION_LIMIT);
-}
-
-
-/**************** REDO ******************/
-
+/**************** REPEAT ******************/
 
-bool SwDoc::Redo( SwUndoIter& rUndoIter )
+SwUndoId UndoManager::GetRepeatInfo(::rtl::OUString *const o_pStr) const
 {
-    if( rUndoIter.GetId() && !HasUndoId( rUndoIter.GetId() ) )
+    SwUndoId nRepeatId(UNDO_EMPTY);
+    GetLastUndoInfo(o_pStr, & nRepeatId);
+    if( REPEAT_START <= nRepeatId && REPEAT_END > nRepeatId )
     {
-        rUndoIter.bWeiter = FALSE;
-        return FALSE;
+        return nRepeatId;
     }
-    if( nUndoPos == pUndos->Count() )
+    if (o_pStr) // not repeatable -> clear comment
     {
-        rUndoIter.bWeiter = FALSE;
-        return FALSE;
+        *o_pStr = String();
     }
+    return UNDO_EMPTY;
+}
 
-    SwUndo *pUndo = (*pUndos)[ nUndoPos++ ];
-
-    RedlineMode_t eOld = GetRedlineMode();
-    RedlineMode_t eTmpMode = (RedlineMode_t)pUndo->GetRedlineMode();
-    if( (nsRedlineMode_t::REDLINE_SHOW_MASK & eTmpMode) != (nsRedlineMode_t::REDLINE_SHOW_MASK & eOld) &&
-        UNDO_START != pUndo->GetId() && UNDO_END != pUndo->GetId() )
-        SetRedlineMode( eTmpMode );
-    SetRedlineMode_intern( (RedlineMode_t)(eTmpMode | nsRedlineMode_t::REDLINE_IGNORE));
-
-    //JP 11.05.98: FlyFormate ueber die EditShell selektieren, nicht aus dem
-    //				Undo heraus
-    if( UNDO_START != pUndo->GetId() && UNDO_END != pUndo->GetId() )
-        rUndoIter.ClearSelections();
-
-    pUndo->Redo( rUndoIter );
-
-    SetRedlineMode( eOld );
-
-    // Besonderheit von Undo-Replace (interne History)
-    if( UNDO_REPLACE == pUndo->GetId() &&
-        USHRT_MAX != ((SwUndoReplace*)pUndo)->nAktPos )
+SwUndo * UndoManager::RemoveLastUndo()
+{
+    if (SfxUndoManager::GetRedoActionCount(CurrentLevel) ||
+        SfxUndoManager::GetRedoActionCount(TopLevel))
     {
-        --nUndoPos;
-        return TRUE;
+        OSL_ENSURE(false, "RemoveLastUndoAction(): there are Redo actions?");
+        return 0;
     }
-
-    if( rUndoIter.bWeiter && nUndoPos >= pUndos->Count() )
-        rUndoIter.bWeiter = FALSE;
-
-    // ist die History leer und wurde nicht wegen Speichermangel
-    // verworfen, so kann das Dokument als unveraendert gelten
-    if( nUndoSavePos == nUndoPos )
-        ResetModified();
-    else
-        SetModified();
-    return TRUE;
+    if (!SfxUndoManager::GetUndoActionCount(CurrentLevel))
+    {
+        OSL_ENSURE(false, "RemoveLastUndoAction(): no Undo actions");
+        return 0;
+    }
+    SfxUndoAction *const pLastUndo(GetUndoAction(0));
+    SfxUndoManager::RemoveLastUndoAction();
+    return dynamic_cast<SwUndo *>(pLastUndo);
 }
 
+// svl::IUndoManager /////////////////////////////////////////////////////
 
-// liefert die Id der letzten Redofaehigen Aktion zurueck oder 0
-// fuellt ggf. VARARR mit User-RedoIds
-
-String SwDoc::GetRedoIdsStr( String* pStr, SwUndoIds *pRedoIds ) const
+void UndoManager::EnableUndo(bool bEnable)
 {
-    String aTmpStr;
-
-    if (pStr != NULL)
+    // UGLY: SfxUndoManager has a counter to match enable/disable calls
+    //       but the writer code expects that a single call switches
+    while (IsUndoEnabled() != bEnable)
     {
-        GetRedoIds( pStr, pRedoIds );
-        aTmpStr = *pStr;
+        SfxUndoManager::EnableUndo(bEnable);
     }
-    else
-        GetRedoIds( &aTmpStr, pRedoIds );
-
-
-    return aTmpStr;
 }
 
-
-SwUndoId SwDoc::GetRedoIds( String* pStr, SwUndoIds *pRedoIds ) const
+void UndoManager::AddUndoAction(SfxUndoAction *pAction, sal_Bool bTryMerge)
 {
-    sal_uInt16 nTmpPos = nUndoPos;
-    SwUndoId nId = UNDO_EMPTY;
-
-    while (nTmpPos < pUndos->Count())
+    SwUndo *const pUndo( dynamic_cast<SwUndo *>(pAction) );
+    if (pUndo)
     {
-        SwUndo * pUndo = (*pUndos)[nTmpPos];
-
-        SwUndoIdAndName * pIdAndName = lcl_GetUndoIdAndName(*pUndos, nTmpPos);
-
-        if (nTmpPos == nUndoPos)
+        if (nsRedlineMode_t::REDLINE_NONE == pUndo->GetRedlineMode())
         {
-            nId = pIdAndName->GetUndoId();
-
-            if (pStr)
-                *pStr = *pIdAndName->GetUndoStr();
+            pUndo->SetRedlineMode( m_rRedlineAccess.GetRedlineMode() );
         }
-
-        if (pRedoIds)
-            pRedoIds->Insert(pIdAndName, pRedoIds->Count());
-        else
-            break;
-
-        if (pUndo->GetId() == UNDO_START)
-            nTmpPos = nTmpPos + ((SwUndoStart *) pUndo)->GetEndOffset();
-
-        nTmpPos++;
     }
-
-    return nId;
+    SfxUndoManager::AddUndoAction(pAction, bTryMerge);
+    // if the undo nodes array is too large, delete some actions
+    while (UNDO_ACTION_LIMIT < GetUndoNodes().Count())
+    {
+        RemoveOldestUndoActions(1);
+    }
 }
 
-/**************** REPEAT ******************/
-
-
-bool SwDoc::Repeat( SwUndoIter& rUndoIter, sal_uInt16 nRepeatCnt )
+class CursorGuard
 {
-    if( rUndoIter.GetId() && !HasUndoId( rUndoIter.GetId() ) )
+public:
+    CursorGuard(SwEditShell & rShell, bool const bSave)
+        : m_rShell(rShell)
+        , m_bSaveCursor(bSave)
     {
-        rUndoIter.bWeiter = FALSE;
-        return FALSE;
+        if (m_bSaveCursor)
+        {
+            m_rShell.Push(); // prevent modification of current cursor
+        }
     }
-    USHORT nSize = nUndoPos;
-    if( !nSize )
+    ~CursorGuard()
     {
-        rUndoIter.bWeiter = FALSE;
-        return FALSE;
+        if (m_bSaveCursor)
+        {
+            m_rShell.Pop();
+        }
     }
+private:
+    SwEditShell & m_rShell;
+    bool const m_bSaveCursor;
+};
 
-    // dann suche jetzt ueber die End/Start-Gruppen die gueltige Repeat-Aktion
-    SwUndo *pUndo = (*pUndos)[ --nSize ];
-    if( UNDO_END == pUndo->GetId() )
-        nSize = nSize - ((SwUndoEnd*)pUndo)->GetSttOffset();
+bool UndoManager::impl_DoUndoRedo(UndoOrRedo_t const undoOrRedo)
+{
+    SwDoc & rDoc(*GetUndoNodes().GetDoc());
 
-    USHORT nEndCnt = nUndoPos;
-    BOOL bOneUndo = nSize + 1 == nUndoPos;
+    UnoActionContext c(& rDoc); // exception-safe StartAllAction/EndAllAction
 
-    SwPaM* pTmpCrsr = rUndoIter.pAktPam;
-    SwUndoId nId = UNDO_EMPTY;
+    SwEditShell *const pEditShell( rDoc.GetEditShell() );
 
-    if( pTmpCrsr != pTmpCrsr->GetNext() || !bOneUndo )	// Undo-Klammerung aufbauen
+    OSL_ENSURE(pEditShell, "sw::UndoManager needs a SwEditShell!");
+    if (!pEditShell)
     {
-        if (pUndo->GetId() == UNDO_END)
-        {
-            SwUndoStart * pStartUndo =
-                (SwUndoStart *) (*pUndos)[nSize];
-
-            nId = pStartUndo->GetUserId();
-        }
-
-        StartUndo( nId, NULL );
+        throw uno::RuntimeException();
     }
-    do {		// dann durchlaufe mal den gesamten Ring
-        for( USHORT nRptCnt = nRepeatCnt; nRptCnt > 0; --nRptCnt )
-        {
-            rUndoIter.pLastUndoObj = 0;
-            for( USHORT nCnt = nSize; nCnt < nEndCnt; ++nCnt )
-                (*pUndos)[ nCnt ]->Repeat( rUndoIter );		// Repeat ausfuehren
-        }
-    } while( pTmpCrsr !=
-        ( rUndoIter.pAktPam = (SwPaM*)rUndoIter.pAktPam->GetNext() ));
-    if( pTmpCrsr != pTmpCrsr->GetNext() || !bOneUndo )
-        EndUndo( nId, NULL );
 
-    return TRUE;
-}
+    // in case the model has controllers locked, the Undo should not
+    // change the view cursors!
+    bool const bSaveCursors(pEditShell->CursorsLocked());
+    CursorGuard(*pEditShell, bSaveCursors);
+    if (!bSaveCursors)
+    {
+        // (in case Undo was called via API) clear the cursors:
+        pEditShell->KillPams();
+        pEditShell->SetMark();
+        pEditShell->ClearMark();
+    }
 
-// liefert die Id der letzten Repeatfaehigen Aktion zurueck oder 0
-// fuellt ggf. VARARR mit User-RedoIds
+    bool bRet(false);
 
-String SwDoc::GetRepeatIdsStr(String* pStr, SwUndoIds *pRepeatIds) const
-{
-    String aTmpStr;
-    SwUndoId nId;
+    ::sw::UndoRedoContext context(rDoc, *pEditShell);
 
-    if ( pStr != NULL)
+    // N.B. these may throw!
+    if (UNDO == undoOrRedo)
     {
-        nId = GetRepeatIds(pStr, pRepeatIds);
-        aTmpStr = *pStr;
+        bRet = SfxUndoManager::UndoWithContext(context);
     }
     else
-        nId = GetRepeatIds(&aTmpStr, pRepeatIds);
+    {
+        bRet = SfxUndoManager::RedoWithContext(context);
+    }
 
-    if (nId <= UNDO_END)
-        return String();
+    if (bRet)
+    {
+        // if we are at the "last save" position, the document is not modified
+        if (SfxUndoManager::HasTopUndoActionMark(m_UndoSaveMark))
+        {
+            m_rState.ResetModified();
+        }
+        else
+        {
+            m_rState.SetModified();
+        }
+    }
+
+    pEditShell->HandleUndoRedoContext(context);
 
-    return aTmpStr;
+    return bRet;
 }
 
-SwUndoId SwDoc::GetRepeatIds(String* pStr, SwUndoIds *pRepeatIds) const
+sal_Bool UndoManager::Undo()
 {
-    SwUndoId nRepeatId = GetUndoIds( pStr, pRepeatIds );
-    if( REPEAT_START <= nRepeatId && REPEAT_END > nRepeatId )
-        return nRepeatId;
-    return UNDO_EMPTY;
+    bool const bRet = impl_DoUndoRedo(UNDO);
+    return bRet;
 }
 
+sal_Bool UndoManager::Redo()
+{
+    bool const bRet = impl_DoUndoRedo(REDO);
+    return bRet;
+}
 
-SwUndo* SwDoc::RemoveLastUndo( SwUndoId eUndoId )
+/** N.B.: this does _not_ call SfxUndoManager::Repeat because it is not
+          possible to wrap a list action around it:
+          calling EnterListAction here will cause SfxUndoManager::Repeat
+          to repeat the list action!
+ */
+bool
+UndoManager::Repeat(::sw::RepeatContext & rContext,
+        sal_uInt16 const nRepeatCount)
 {
-    SwUndo* pUndo = (*pUndos)[ nUndoPos - 1 ];
-    if( eUndoId == pUndo->GetId() && nUndoPos == pUndos->Count() )
+    if (SfxUndoManager::IsInListAction())
     {
-        if( !nUndoSttEnd )
-            --nUndoCnt;
-        --nUndoPos;
-        pUndos->Remove( nUndoPos, 1 );
+        OSL_ENSURE(false, "repeat in open list action???");
+        return false;
     }
-    else
+    if (!SfxUndoManager::GetUndoActionCount(TopLevel))
     {
-        pUndo = 0;
-        OSL_ENSURE( !this, "falsches Undo-Object" );
+        return false;
+    }
+    SfxUndoAction *const pRepeatAction(GetUndoAction(0));
+    OSL_ASSERT(pRepeatAction);
+    if (!pRepeatAction || !pRepeatAction->CanRepeat(rContext))
+    {
+        return false;
     }
-    return pUndo;
-}
 
-SwUndoIdAndName::SwUndoIdAndName( SwUndoId nId, const String* pStr )
-    : eUndoId( nId ), pUndoStr( pStr ? new String( *pStr ) : 0 )
-{
-}
+    ::rtl::OUString const comment(pRepeatAction->GetComment());
+    ::rtl::OUString const rcomment(pRepeatAction->GetRepeatComment(rContext));
+    sal_uInt16 const nId(pRepeatAction->GetId());
+    if (DoesUndo())
+    {
+        EnterListAction(comment, rcomment, nId);
+    }
 
-SwUndoIdAndName::~SwUndoIdAndName()
-{
-    delete pUndoStr;
-}
+    SwPaM *const pFirstCursor(& rContext.GetRepeatPaM());
+    do {    // iterate over ring
+        for (sal_uInt16 nRptCnt = nRepeatCount; nRptCnt > 0; --nRptCnt)
+        {
+            pRepeatAction->Repeat(rContext);
+        }
+        rContext.m_bDeleteRepeated = false; // reset for next PaM
+        rContext.m_pCurrentPaM =
+            static_cast<SwPaM*>(rContext.m_pCurrentPaM->GetNext());
+    } while (pFirstCursor != & rContext.GetRepeatPaM());
 
+    if (DoesUndo())
+    {
+        LeaveListAction();
+    }
+    return true;
+}
 
+} // namespace sw
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/undo/makefile.mk b/sw/source/core/undo/makefile.mk
deleted file mode 100644
index d48ec2d4bb..0000000000
--- a/sw/source/core/undo/makefile.mk
+++ /dev/null
@@ -1,81 +0,0 @@
-#*************************************************************************
-#
-# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
-# 
-# Copyright 2000, 2010 Oracle and/or its affiliates.
-#
-# OpenOffice.org - a multi-platform office productivity suite
-#
-# This file is part of OpenOffice.org.
-#
-# OpenOffice.org is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License version 3
-# only, as published by the Free Software Foundation.
-#
-# OpenOffice.org is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License version 3 for more details
-# (a copy is included in the LICENSE file that accompanied this code).
-#
-# You should have received a copy of the GNU Lesser General Public License
-# version 3 along with OpenOffice.org.  If not, see
-# <http://www.openoffice.org/license.html>
-# for a copy of the LGPLv3 License.
-#
-#*************************************************************************
-
-PRJ=..$/..$/..
-
-PRJNAME=sw
-TARGET=undo
-
-AUTOSEG=true
-
-# --- Settings -----------------------------------------------------
-
-.INCLUDE :  $(PRJ)$/inc$/swpre.mk
-.INCLUDE :  settings.mk
-.INCLUDE :  $(PRJ)$/inc$/sw.mk
-
-# --- Files --------------------------------------------------------
-
-SRS1NAME=$(TARGET)
-SRC1FILES =  \
-        undo.src
-
-EXCEPTIONSFILES = \
-        $(SLO)$/SwRewriter.obj \
-        $(SLO)$/SwUndoField.obj \
-        $(SLO)$/SwUndoFmt.obj \
-        $(SLO)$/SwUndoPageDesc.obj \
-        $(SLO)$/SwUndoTOXChange.obj \
-        $(SLO)$/docundo.obj \
-        $(SLO)$/rolbck.obj \
-        $(SLO)$/unattr.obj \
-        $(SLO)$/unbkmk.obj \
-        $(SLO)$/undel.obj \
-        $(SLO)$/undobj.obj \
-        $(SLO)$/undobj1.obj \
-        $(SLO)$/undoflystrattr.obj \
-        $(SLO)$/undraw.obj \
-        $(SLO)$/unfmco.obj \
-        $(SLO)$/unins.obj \
-        $(SLO)$/unmove.obj \
-        $(SLO)$/unnum.obj \
-        $(SLO)$/unoutl.obj \
-        $(SLO)$/unovwr.obj \
-        $(SLO)$/unredln.obj \
-        $(SLO)$/unsect.obj \
-        $(SLO)$/unsort.obj \
-        $(SLO)$/unspnd.obj \
-        $(SLO)$/untbl.obj \
-        $(SLO)$/untblk.obj
-
-SLOFILES =	\
-        $(EXCEPTIONSFILES)
-
-# --- Tagets -------------------------------------------------------
-
-.INCLUDE :  target.mk
-
diff --git a/sw/source/core/undo/rolbck.cxx b/sw/source/core/undo/rolbck.cxx
index 7c757b65dd..d606e1f0d5 100644
--- a/sw/source/core/undo/rolbck.cxx
+++ b/sw/source/core/undo/rolbck.cxx
@@ -29,9 +29,16 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <rolbck.hxx>
+
+#include <tools/resid.hxx>
 
-#include <hintids.hxx>
 #include <svl/itemiter.hxx>
+
+#include <editeng/brkitem.hxx>
+
+#include <hints.hxx>
+#include <hintids.hxx>
 #include <fmtftn.hxx>
 #include <fchrfmt.hxx>
 #include <fmtflcnt.hxx>
@@ -48,6 +55,7 @@
 #include <frmfmt.hxx>
 #include <ftnidx.hxx>
 #include <doc.hxx>              // SwDoc.GetNodes()
+#include <IDocumentUndoRedo.hxx>
 #include <docary.hxx>
 #include <ndtxt.hxx>			// SwTxtNode
 #include <paratr.hxx>			//
@@ -55,15 +63,12 @@
 #include <fldbas.hxx>			// fuer Felder
 #include <pam.hxx>				// fuer SwPaM
 #include <swtable.hxx>
-#include <rolbck.hxx>
 #include <ndgrf.hxx>			// SwGrfNode
-#include <undobj.hxx>			// fuer UndoDelete
+#include <UndoCore.hxx>
 #include <IMark.hxx> 			// fuer SwBookmark
 #include <charfmt.hxx> // #i27615#
 #include <comcore.hrc>
-#include <tools/resid.hxx>
 #include <undo.hrc>
-#include <editeng/brkitem.hxx>
 #include <bookmrk.hxx>
 
 SV_IMPL_PTRARR( SwpHstry, SwHistoryHintPtr)
@@ -74,7 +79,7 @@ String SwHistoryHint::GetDescription() const
 }
 
 
-SwHistorySetFmt::SwHistorySetFmt( const SfxPoolItem* pFmtHt, ULONG nNd )
+SwHistorySetFmt::SwHistorySetFmt( const SfxPoolItem* pFmtHt, sal_uLong nNd )
     :  SwHistoryHint( HSTRY_SETFMTHNT )
     ,  m_pAttr( pFmtHt->Clone() )
     ,  m_nNodeIndex( nNd )
@@ -118,7 +123,7 @@ String SwHistorySetFmt::GetDescription() const
 {
     String aResult ;
 
-    USHORT nWhich = m_pAttr->Which();
+    sal_uInt16 nWhich = m_pAttr->Which();
     switch (nWhich)
     {
     case RES_BREAK:
@@ -184,7 +189,7 @@ SwHistorySetFmt::~SwHistorySetFmt()
 }
 
 
-SwHistoryResetFmt::SwHistoryResetFmt(const SfxPoolItem* pFmtHt, ULONG nNodeIdx)
+SwHistoryResetFmt::SwHistoryResetFmt(const SfxPoolItem* pFmtHt, sal_uLong nNodeIdx)
     : SwHistoryHint( HSTRY_RESETFMTHNT )
     , m_nNodeIndex( nNodeIdx )
     , m_nWhich( pFmtHt->Which() )
@@ -207,7 +212,7 @@ void SwHistoryResetFmt::SetInDoc( SwDoc* pDoc, bool )
 }
 
 
-SwHistorySetTxt::SwHistorySetTxt( SwTxtAttr* pTxtHt, ULONG nNodePos )
+SwHistorySetTxt::SwHistorySetTxt( SwTxtAttr* pTxtHt, sal_uLong nNodePos )
     : SwHistoryHint( HSTRY_SETTXTHNT )
     , m_nNodeIndex( nNodePos )
     , m_nStart( *pTxtHt->GetStart() )
@@ -219,7 +224,7 @@ SwHistorySetTxt::SwHistorySetTxt( SwTxtAttr* pTxtHt, ULONG nNodePos )
 
     // ein bisschen kompliziert, aber ist Ok so: erst vom default
     // eine Kopie und dann die Werte aus dem Text Attribut zuweisen
-    USHORT nWhich = pTxtHt->Which();
+    sal_uInt16 nWhich = pTxtHt->Which();
     if ( RES_TXTATR_CHARFMT == nWhich )
     {
         m_pAttr.reset( new SwFmtCharFmt( pTxtHt->GetCharFmt().GetCharFmt() ) );
@@ -261,7 +266,7 @@ void SwHistorySetTxt::SetInDoc( SwDoc* pDoc, bool )
 }
 
 
-SwHistorySetTxtFld::SwHistorySetTxtFld( SwTxtFld* pTxtFld, ULONG nNodePos )
+SwHistorySetTxtFld::SwHistorySetTxtFld( SwTxtFld* pTxtFld, sal_uLong nNodePos )
     : SwHistoryHint( HSTRY_SETTXTFLDHNT )
     , m_pFldType( 0 )
     , m_pFld( new SwFmtFld( *pTxtFld->GetFld().GetFld() ) )
@@ -323,7 +328,7 @@ void SwHistorySetTxtFld::SetInDoc( SwDoc* pDoc, bool )
 
 
 
-SwHistorySetRefMark::SwHistorySetRefMark( SwTxtRefMark* pTxtHt, ULONG nNodePos )
+SwHistorySetRefMark::SwHistorySetRefMark( SwTxtRefMark* pTxtHt, sal_uLong nNodePos )
     : SwHistoryHint( HSTRY_SETREFMARKHNT )
     , m_RefName( pTxtHt->GetRefMark().GetRefName() )
     , m_nNodeIndex( nNodePos )
@@ -352,7 +357,7 @@ void SwHistorySetRefMark::SetInDoc( SwDoc* pDoc, bool )
 }
 
 
-SwHistorySetTOXMark::SwHistorySetTOXMark( SwTxtTOXMark* pTxtHt, ULONG nNodePos )
+SwHistorySetTOXMark::SwHistorySetTOXMark( SwTxtTOXMark* pTxtHt, sal_uLong nNodePos )
     : SwHistoryHint( HSTRY_SETTOXMARKHNT )
     , m_TOXMark( pTxtHt->GetTOXMark() )
     , m_TOXName( m_TOXMark.GetTOXType()->GetTypeName() )
@@ -373,9 +378,9 @@ void SwHistorySetTOXMark::SetInDoc( SwDoc* pDoc, bool )
         return;
 
     // search for respective TOX type
-    USHORT nCnt = pDoc->GetTOXTypeCount( m_eTOXTypes );
+    sal_uInt16 nCnt = pDoc->GetTOXTypeCount( m_eTOXTypes );
     SwTOXType* pToxType = 0;
-    for ( USHORT n = 0; n < nCnt; ++n )
+    for ( sal_uInt16 n = 0; n < nCnt; ++n )
     {
         pToxType = const_cast<SwTOXType*>(pDoc->GetTOXType( m_eTOXTypes, n ));
         if ( pToxType->GetTypeName() == m_TOXName )
@@ -410,8 +415,8 @@ int SwHistorySetTOXMark::IsEqual( const SwTOXMark& rCmp ) const
 }
 
 
-SwHistoryResetTxt::SwHistoryResetTxt( USHORT nWhich,
-            xub_StrLen nAttrStart, xub_StrLen nAttrEnd, ULONG nNodePos )
+SwHistoryResetTxt::SwHistoryResetTxt( sal_uInt16 nWhich,
+            xub_StrLen nAttrStart, xub_StrLen nAttrEnd, sal_uLong nNodePos )
     : SwHistoryHint( HSTRY_RESETTXTHNT )
     , m_nNodeIndex( nNodePos ), m_nStart( nAttrStart ), m_nEnd( nAttrEnd )
     , m_nAttr( nWhich )
@@ -430,7 +435,7 @@ void SwHistoryResetTxt::SetInDoc( SwDoc* pDoc, bool )
 }
 
 
-SwHistorySetFootnote::SwHistorySetFootnote( SwTxtFtn* pTxtFtn, ULONG nNodePos )
+SwHistorySetFootnote::SwHistorySetFootnote( SwTxtFtn* pTxtFtn, sal_uLong nNodePos )
     : SwHistoryHint( HSTRY_SETFTNHNT )
     , m_pUndo( new SwUndoSaveSection )
     , m_FootnoteNumber( pTxtFtn->GetFtn().GetNumStr() )
@@ -449,7 +454,7 @@ SwHistorySetFootnote::SwHistorySetFootnote( SwTxtFtn* pTxtFtn, ULONG nNodePos )
     //Pointer auf StartNode der FtnSection merken und erstmal den Pointer im
     //Attribut zuruecksetzen -> Damit werden automatisch die Frms vernichtet.
     SwNodeIndex aSttIdx( *pTxtFtn->GetStartNode() );
-    pTxtFtn->SetStartNode( 0, FALSE );
+    pTxtFtn->SetStartNode( 0, sal_False );
 
     m_pUndo->SaveSection( pDoc, aSttIdx );
     m_nNodeIndex = pSaveNd->GetIndex();
@@ -524,8 +529,8 @@ void SwHistorySetFootnote::SetInDoc( SwDoc* pDoc, bool )
 }
 
 
-SwHistoryChangeFmtColl::SwHistoryChangeFmtColl( SwFmtColl* pFmtColl, ULONG nNd,
-                            BYTE nNodeWhich )
+SwHistoryChangeFmtColl::SwHistoryChangeFmtColl( SwFmtColl* pFmtColl, sal_uLong nNd,
+                            sal_uInt8 nNodeWhich )
     : SwHistoryHint( HSTRY_CHGFMTCOLL )
     , m_pColl( pFmtColl )
     , m_nNodeIndex( nNd )
@@ -564,7 +569,7 @@ SwHistoryTxtFlyCnt::SwHistoryTxtFlyCnt( SwFrmFmt* const pFlyFmt )
     , m_pUndo( new SwUndoDelLayFmt( pFlyFmt ) )
 {
     OSL_ENSURE( pFlyFmt, "SwHistoryTxtFlyCnt: no Format" );
-    m_pUndo->ChgShowSel( FALSE );
+    m_pUndo->ChgShowSel( sal_False );
 }
 
 
@@ -575,9 +580,10 @@ SwHistoryTxtFlyCnt::~SwHistoryTxtFlyCnt()
 
 void SwHistoryTxtFlyCnt::SetInDoc( SwDoc* pDoc, bool )
 {
-    SwPaM aPam( pDoc->GetNodes().GetEndOfPostIts() );
-    SwUndoIter aUndoIter( &aPam );
-    m_pUndo->Undo( aUndoIter );
+    ::sw::IShellCursorSupplier *const pISCS(pDoc->GetIShellCursorSupplier());
+    OSL_ASSERT(pISCS);
+    ::sw::UndoRedoContext context(*pDoc, *pISCS);
+    m_pUndo->UndoImpl(context);
 }
 
 
@@ -621,8 +627,7 @@ SwHistoryBookmark::SwHistoryBookmark(
 
 void SwHistoryBookmark::SetInDoc( SwDoc* pDoc, bool )
 {
-    bool bDoesUndo = pDoc->DoesUndo();
-    pDoc->DoUndo(false);
+    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
 
     SwNodes& rNds = pDoc->GetNodes();
     IDocumentMarkAccess* pMarkAccess = pDoc->getIDocumentMarkAccess();
@@ -693,7 +698,6 @@ void SwHistoryBookmark::SetInDoc( SwDoc* pDoc, bool )
             }
         }
     }
-    pDoc->DoUndo(bDoesUndo);
 }
 
 
@@ -713,7 +717,7 @@ const ::rtl::OUString& SwHistoryBookmark::GetName() const
 
 
 SwHistorySetAttrSet::SwHistorySetAttrSet( const SfxItemSet& rSet,
-                        ULONG nNodePos, const SvUShortsSort& rSetArr )
+                        sal_uLong nNodePos, const SvUShortsSort& rSetArr )
     : SwHistoryHint( HSTRY_SETATTRSET )
     , m_OldSet( rSet )
     , m_ResetArray( 0, 4 )
@@ -783,13 +787,12 @@ SwHistorySetAttrSet::SwHistorySetAttrSet( const SfxItemSet& rSet,
             break;
         pItem = aIter.NextItem();
         pOrigItem = aOrigIter.NextItem();
-    } while( TRUE );
+    } while( sal_True );
 }
 
 void SwHistorySetAttrSet::SetInDoc( SwDoc* pDoc, bool )
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-    pDoc->DoUndo( FALSE );
+    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
 
     SwNode * pNode = pDoc->GetNodes()[ m_nNodeIndex ];
     if ( pNode->IsCntntNode() )
@@ -810,25 +813,23 @@ void SwHistorySetAttrSet::SetInDoc( SwDoc* pDoc, bool )
             rFmt.ResetFmtAttr( *m_ResetArray.GetData() );
         }
     }
-
-    pDoc->DoUndo( bDoesUndo );
 }
 
 /*************************************************************************/
 
 
 SwHistoryResetAttrSet::SwHistoryResetAttrSet( const SfxItemSet& rSet,
-                    ULONG nNodePos, xub_StrLen nAttrStt, xub_StrLen nAttrEnd )
+                    sal_uLong nNodePos, xub_StrLen nAttrStt, xub_StrLen nAttrEnd )
     : SwHistoryHint( HSTRY_RESETATTRSET )
     , m_nNodeIndex( nNodePos ), m_nStart( nAttrStt ), m_nEnd( nAttrEnd )
-    , m_Array( (BYTE)rSet.Count() )
+    , m_Array( (sal_uInt8)rSet.Count() )
 {
     SfxItemIter aIter( rSet );
     bool bAutoStyle = false;
 
-    while( TRUE )
+    while( sal_True )
     {
-        const USHORT nWhich = aIter.GetCurItem()->Which();
+        const sal_uInt16 nWhich = aIter.GetCurItem()->Which();
 
 #ifndef PRODUCT
         switch (nWhich)
@@ -874,19 +875,18 @@ SwHistoryResetAttrSet::SwHistoryResetAttrSet( const SfxItemSet& rSet,
 
 void SwHistoryResetAttrSet::SetInDoc( SwDoc* pDoc, bool )
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-    pDoc->DoUndo( FALSE );
+    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
 
     SwCntntNode * pCntntNd = pDoc->GetNodes()[ m_nNodeIndex ]->GetCntntNode();
     OSL_ENSURE( pCntntNd, "SwHistoryResetAttrSet: no CntntNode" );
 
     if (pCntntNd)
     {
-        const USHORT* pArr = m_Array.GetData();
+        const sal_uInt16* pArr = m_Array.GetData();
         if ( USHRT_MAX == m_nEnd && USHRT_MAX == m_nStart )
         {
             // no area: use ContentNode
-            for ( USHORT n = m_Array.Count(); n; --n, ++pArr )
+            for ( sal_uInt16 n = m_Array.Count(); n; --n, ++pArr )
             {
                 pCntntNd->ResetAttr( *pArr );
             }
@@ -894,15 +894,13 @@ void SwHistoryResetAttrSet::SetInDoc( SwDoc* pDoc, bool )
         else
         {
             // area: use TextNode
-            for ( USHORT n = m_Array.Count(); n; --n, ++pArr )
+            for ( sal_uInt16 n = m_Array.Count(); n; --n, ++pArr )
             {
                 static_cast<SwTxtNode*>(pCntntNd)->
                     DeleteAttributes( *pArr, m_nStart, m_nEnd );
             }
         }
     }
-
-    pDoc->DoUndo( bDoesUndo );
 }
 
 
@@ -922,10 +920,9 @@ SwHistoryChangeFlyAnchor::SwHistoryChangeFlyAnchor( SwFrmFmt& rFmt )
 
 void SwHistoryChangeFlyAnchor::SetInDoc( SwDoc* pDoc, bool )
 {
-    BOOL bDoesUndo = pDoc->DoesUndo();
-    pDoc->DoUndo( FALSE );
+    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
 
-    USHORT nPos = pDoc->GetSpzFrmFmts()->GetPos( &m_rFmt );
+    sal_uInt16 nPos = pDoc->GetSpzFrmFmts()->GetPos( &m_rFmt );
     if ( USHRT_MAX != nPos )    // Format does still exist
     {
         SwFmtAnchor aTmp( m_rFmt.GetAnchor() );
@@ -944,14 +941,13 @@ void SwHistoryChangeFlyAnchor::SetInDoc( SwDoc* pDoc, bool )
         aTmp.SetAnchor( &aPos );
 
         // so the Layout does not get confused
-        if ( !pCNd || !pCNd->GetFrm( 0, 0, FALSE ) )
+        if ( !pCNd || !pCNd->GetFrm( 0, 0, sal_False ) )
         {
             m_rFmt.DelFrms();
         }
 
         m_rFmt.SetFmtAttr( aTmp );
     }
-    pDoc->DoUndo( bDoesUndo );
 }
 
 
@@ -1021,8 +1017,8 @@ void SwHistoryChangeCharFmt::SetInDoc(SwDoc * pDoc, bool )
 /*  */
 
 
-SwHistory::SwHistory( USHORT nInitSz, USHORT nGrowSz )
-    : m_SwpHstry( (BYTE)nInitSz, (BYTE)nGrowSz )
+SwHistory::SwHistory( sal_uInt16 nInitSz, sal_uInt16 nGrowSz )
+    : m_SwpHstry( (sal_uInt8)nInitSz, (sal_uInt8)nGrowSz )
     , m_nEndDiff( 0 )
 {}
 
@@ -1042,11 +1038,11 @@ SwHistory::~SwHistory()
 *************************************************************************/
 
 void SwHistory::Add( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue,
-                     ULONG nNodeIdx )
+                     sal_uLong nNodeIdx )
 {
     OSL_ENSURE( !m_nEndDiff, "History was not deleted after REDO" );
 
-    USHORT nWhich = pNewValue->Which();
+    sal_uInt16 nWhich = pNewValue->Which();
     if( (nWhich >= POOLATTR_END) || (nWhich == RES_TXTATR_FIELD) )
         return;
 
@@ -1064,12 +1060,12 @@ void SwHistory::Add( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue,
 }
 
 
-void SwHistory::Add( SwTxtAttr* pHint, ULONG nNodeIdx, bool bNewAttr )
+void SwHistory::Add( SwTxtAttr* pHint, sal_uLong nNodeIdx, bool bNewAttr )
 {
     OSL_ENSURE( !m_nEndDiff, "History was not deleted after REDO" );
 
     SwHistoryHint * pHt;
-    USHORT nAttrWhich = pHint->Which();
+    sal_uInt16 nAttrWhich = pHint->Which();
 
     if( !bNewAttr )
     {
@@ -1109,7 +1105,7 @@ void SwHistory::Add( SwTxtAttr* pHint, ULONG nNodeIdx, bool bNewAttr )
 }
 
 
-void SwHistory::Add( SwFmtColl* pColl, ULONG nNodeIdx, BYTE nWhichNd )
+void SwHistory::Add( SwFmtColl* pColl, sal_uLong nNodeIdx, sal_uInt8 nWhichNd )
 {
     OSL_ENSURE( !m_nEndDiff, "History was not deleted after REDO" );
 
@@ -1134,19 +1130,19 @@ void SwHistory::Add( SwFrmFmt& rFmt )
     m_SwpHstry.Insert( pHt, Count() );
 }
 
-void SwHistory::Add( SwFlyFrmFmt& rFmt, USHORT& rSetPos )
+void SwHistory::Add( SwFlyFrmFmt& rFmt, sal_uInt16& rSetPos )
 {
     OSL_ENSURE( !m_nEndDiff, "History was not deleted after REDO" );
 
     SwHistoryHint * pHint;
-    const USHORT nWh = rFmt.Which();
+    const sal_uInt16 nWh = rFmt.Which();
     if( RES_FLYFRMFMT == nWh || RES_DRAWFRMFMT == nWh )
     {
         pHint = new SwHistoryTxtFlyCnt( &rFmt );
         m_SwpHstry.Insert( pHint, Count() );
 
         const SwFmtChain* pChainItem;
-        if( SFX_ITEM_SET == rFmt.GetItemState( RES_CHAIN, FALSE,
+        if( SFX_ITEM_SET == rFmt.GetItemState( RES_CHAIN, sal_False,
             (const SfxPoolItem**)&pChainItem ))
         {
             if( pChainItem->GetNext() || pChainItem->GetPrev() )
@@ -1187,20 +1183,20 @@ void SwHistory::Add(const SfxItemSet & rSet, const SwCharFmt & rFmt)
 
 /*************************************************************************
 |*
-|*    BOOL SwHistory::Rollback()
+|*    sal_Bool SwHistory::Rollback()
 |*
 |*    Beschreibung		Dokument 1.0
 |*
 *************************************************************************/
 
 
-bool SwHistory::Rollback( SwDoc* pDoc, USHORT nStart )
+bool SwHistory::Rollback( SwDoc* pDoc, sal_uInt16 nStart )
 {
     if ( !Count() )
         return false;
 
     SwHistoryHint * pHHt;
-    USHORT i;
+    sal_uInt16 i;
     for ( i = Count(); i > nStart ; )
     {
         pHHt = m_SwpHstry[ --i ];
@@ -1214,9 +1210,9 @@ bool SwHistory::Rollback( SwDoc* pDoc, USHORT nStart )
 
 
 
-bool SwHistory::TmpRollback( SwDoc* pDoc, USHORT nStart, bool bToFirst )
+bool SwHistory::TmpRollback( SwDoc* pDoc, sal_uInt16 nStart, bool bToFirst )
 {
-    USHORT nEnd = Count() - m_nEndDiff;
+    sal_uInt16 nEnd = Count() - m_nEndDiff;
     if ( !Count() || !nEnd || nStart >= nEnd )
         return false;
 
@@ -1241,9 +1237,9 @@ bool SwHistory::TmpRollback( SwDoc* pDoc, USHORT nStart, bool bToFirst )
 }
 
 
-void SwHistory::Delete( USHORT nStart )
+void SwHistory::Delete( sal_uInt16 nStart )
 {
-    for ( USHORT n = Count(); n > nStart; )
+    for ( sal_uInt16 n = Count(); n > nStart; )
     {
         m_SwpHstry.DeleteAndDestroy( --n, 1 );
     }
@@ -1251,28 +1247,28 @@ void SwHistory::Delete( USHORT nStart )
 }
 
 
-USHORT SwHistory::SetTmpEnd( USHORT nNewTmpEnd )
+sal_uInt16 SwHistory::SetTmpEnd( sal_uInt16 nNewTmpEnd )
 {
     OSL_ENSURE( nNewTmpEnd <= Count(),  "SwHistory::SetTmpEnd: out of bounds" );
 
-    USHORT nOld = Count() - m_nEndDiff;
+    sal_uInt16 nOld = Count() - m_nEndDiff;
     m_nEndDiff = Count() - nNewTmpEnd;
 
     // for every SwHistoryFlyCnt, call the Redo of its UndoObject.
     // this saves the formats of the flys!
-    for ( USHORT n = nOld; n < nNewTmpEnd; n++ )
+    for ( sal_uInt16 n = nOld; n < nNewTmpEnd; n++ )
     {
         if ( HSTRY_FLYCNT == (*this)[ n ]->Which() )
         {
             static_cast<SwHistoryTxtFlyCnt*>((*this)[ n ])
-                ->GetUDelLFmt()->Redo();
+                ->GetUDelLFmt()->RedoForRollback();
         }
     }
 
     return nOld;
 }
 
-void SwHistory::CopyFmtAttr( const SfxItemSet& rSet, ULONG nNodeIdx )
+void SwHistory::CopyFmtAttr( const SfxItemSet& rSet, sal_uLong nNodeIdx )
 {
     if( rSet.Count() )
     {
@@ -1286,11 +1282,11 @@ void SwHistory::CopyFmtAttr( const SfxItemSet& rSet, ULONG nNodeIdx )
             if( aIter.IsAtEnd() )
                 break;
             aIter.NextItem();
-        } while( TRUE );
+        } while( sal_True );
     }
 }
 
-void SwHistory::CopyAttr( SwpHints* pHts, ULONG nNodeIdx,
+void SwHistory::CopyAttr( SwpHints* pHts, sal_uLong nNodeIdx,
                           xub_StrLen nStart, xub_StrLen nEnd, bool bFields )
 {
     if( !pHts  )
@@ -1300,7 +1296,7 @@ void SwHistory::CopyAttr( SwpHints* pHts, ULONG nNodeIdx,
     SwTxtAttr* pHt;
     xub_StrLen nAttrStt;
     const xub_StrLen * pEndIdx;
-    for( USHORT n = 0; n < pHts->Count(); n++ )
+    for( sal_uInt16 n = 0; n < pHts->Count(); n++ )
     {
         // BP: nAttrStt muss auch bei !pEndIdx gesetzt werden
         pHt = pHts->GetTextHint(n);
@@ -1311,17 +1307,17 @@ void SwHistory::CopyAttr( SwpHints* pHts, ULONG nNodeIdx,
             break;
 
         // Flys und Ftn nie kopieren !!
-        BOOL bNextAttr = FALSE;
+        sal_Bool bNextAttr = sal_False;
         switch( pHt->Which() )
         {
         case RES_TXTATR_FIELD:
             // keine Felder, .. kopieren ??
             if( !bFields )
-                bNextAttr = TRUE;
+                bNextAttr = sal_True;
             break;
         case RES_TXTATR_FLYCNT:
         case RES_TXTATR_FTN:
-            bNextAttr = TRUE;
+            bNextAttr = sal_True;
             break;
         }
 
@@ -1378,7 +1374,13 @@ SwRegHistory::SwRegHistory( const SwNode& rNd, SwHistory* pHst )
 
 void SwRegHistory::Modify( SfxPoolItem* pOld, SfxPoolItem* pNew )
 {
-    if ( m_pHistory && ( pOld || pNew ) )
+    // --> OD 2010-10-05 #i114861#
+    // Do not handle a "noop" modify 
+    // - e.g. <SwTxtNode::NumRuleChgd()> uses such a "noop" modify
+//    if ( m_pHistory && ( pOld || pNew ) )
+    if ( m_pHistory && ( pOld || pNew ) &&
+         pOld != pNew )
+    // <--
     {
         if ( pNew->Which() < POOLATTR_END )
         {
@@ -1499,8 +1501,8 @@ void SwRegHistory::_MakeSetWhichIds()
         if( pSet && pSet->Count() )
         {
             SfxItemIter aIter( *pSet );
-            USHORT nW = aIter.FirstItem()->Which();
-            while( TRUE )
+            sal_uInt16 nW = aIter.FirstItem()->Which();
+            while( sal_True )
             {
                 m_WhichIdSet.Insert( nW );
                 if( aIter.IsAtEnd() )
diff --git a/sw/source/core/undo/unattr.cxx b/sw/source/core/undo/unattr.cxx
index ae02d2e6b8..63c0039a2e 100644
--- a/sw/source/core/undo/unattr.cxx
+++ b/sw/source/core/undo/unattr.cxx
@@ -29,16 +29,18 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
-
 #define _SVSTDARR_USHORTS
 #define _SVSTDARR_USHORTSSORT
-#include <hintids.hxx>
-#include <svx/svdmodel.hxx>
-#include <editeng/tstpitem.hxx>
-#include <svx/svdpage.hxx>
+#include <UndoAttribute.hxx>
+
 #include <svl/itemiter.hxx>
 
+#include <editeng/tstpitem.hxx>
 
+#include <svx/svdmodel.hxx>
+#include <svx/svdpage.hxx>
+
+#include <hintids.hxx>
 #include <fmtflcnt.hxx>
 #include <txtftn.hxx>
 #include <fmtornt.hxx>
@@ -48,13 +50,16 @@
 #include <fmtcntnt.hxx>
 #include <ftnidx.hxx>
 #include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
+#include <IShellCursorSupplier.hxx>
 #include <docary.hxx>
 #include <swundo.hxx>			// fuer die UndoIds
 #include <pam.hxx>
 #include <ndtxt.hxx>
 #include <swtable.hxx>
 #include <swtblfmt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
+#include <hints.hxx>
 #include <rolbck.hxx>
 #include <ndnotxt.hxx>
 #include <dcontact.hxx>
@@ -65,9 +70,6 @@
 
 
 
-inline SwDoc& SwUndoIter::GetDoc() const
-{ return *pAktPam->GetDoc(); }
-
 // -----------------------------------------------------
 
 SwUndoFmtAttrHelper::SwUndoFmtAttrHelper( SwFmt& rFmt, bool bSvDrwPt )
@@ -143,7 +145,7 @@ SwUndoFmtAttr::SwUndoFmtAttr( const SfxPoolItem& rItem, SwFmt& rChgFmt,
                               bool bSaveDrawPt )
     : SwUndo( UNDO_INSFMTATTR )
     , m_pFmt( &rChgFmt )
-    , m_pOldSet( m_pFmt->GetAttrSet().Clone( FALSE ) )
+    , m_pOldSet( m_pFmt->GetAttrSet().Clone( sal_False ) )
     , m_nNodeIndex( 0 )
     , m_nFmtWhich( rChgFmt.Which() )
     , m_bSaveDrawPt( bSaveDrawPt )
@@ -155,7 +157,7 @@ SwUndoFmtAttr::SwUndoFmtAttr( const SfxPoolItem& rItem, SwFmt& rChgFmt,
 void SwUndoFmtAttr::Init()
 {
     // treat change of anchor specially
-    if ( SFX_ITEM_SET == m_pOldSet->GetItemState( RES_ANCHOR, FALSE ))
+    if ( SFX_ITEM_SET == m_pOldSet->GetItemState( RES_ANCHOR, sal_False ))
     {
         SaveFlyAnchor( m_bSaveDrawPt );
     }
@@ -195,21 +197,21 @@ SwUndoFmtAttr::~SwUndoFmtAttr()
 {
 }
 
-void SwUndoFmtAttr::Undo( SwUndoIter& rUndoIter)
+void SwUndoFmtAttr::UndoImpl(::sw::UndoRedoContext & rContext)
 {
     // OD 2004-10-26 #i35443#
     // Important note: <Undo(..)> also called by <ReDo(..)>
 
-    if ( !m_pOldSet.get() || !m_pFmt || !IsFmtInDoc( &rUndoIter.GetDoc() ))
+    if ( !m_pOldSet.get() || !m_pFmt || !IsFmtInDoc( &rContext.GetDoc() ))
         return;
 
     // --> OD 2004-10-26 #i35443# - If anchor attribute has been successfull
     // restored, all other attributes are also restored.
     // Thus, keep track of its restoration
     bool bAnchorAttrRestored( false );
-    if ( SFX_ITEM_SET == m_pOldSet->GetItemState( RES_ANCHOR, FALSE ))
+    if ( SFX_ITEM_SET == m_pOldSet->GetItemState( RES_ANCHOR, sal_False ))
     {
-        bAnchorAttrRestored = RestoreFlyAnchor( rUndoIter );
+        bAnchorAttrRestored = RestoreFlyAnchor(rContext);
         if ( bAnchorAttrRestored )
         {
             // Anchor attribute successfull restored.
@@ -241,7 +243,7 @@ void SwUndoFmtAttr::Undo( SwUndoIter& rUndoIter)
 
         if ( RES_FLYFRMFMT == m_nFmtWhich || RES_DRAWFRMFMT == m_nFmtWhich )
         {
-            rUndoIter.pSelFmt = static_cast<SwFrmFmt*>(m_pFmt);
+            rContext.SetSelections(static_cast<SwFrmFmt*>(m_pFmt), 0);
         }
     }
 }
@@ -250,7 +252,7 @@ bool SwUndoFmtAttr::IsFmtInDoc( SwDoc* pDoc )
 {
     // search for the Format in the Document; if it does not exist any more,
     // the attribute is not restored!
-    USHORT nPos = USHRT_MAX;
+    sal_uInt16 nPos = USHRT_MAX;
     switch ( m_nFmtWhich )
     {
         case RES_TXTFMTCOLL:
@@ -331,49 +333,41 @@ SwFmt* SwUndoFmtAttr::GetFmt( SwDoc& rDoc )
     return m_pFmt && IsFmtInDoc( &rDoc ) ? m_pFmt : 0;
 }
 
-void SwUndoFmtAttr::Redo( SwUndoIter& rUndoIter)
+void SwUndoFmtAttr::RedoImpl(::sw::UndoRedoContext & rContext)
 {
     // --> OD 2004-10-26 #i35443# - Because the undo stores the attributes for
     // redo, the same code as for <Undo(..)> can be applied for <Redo(..)>
-    Undo( rUndoIter );
+    UndoImpl(rContext);
     // <--
 }
 
-void SwUndoFmtAttr::Repeat( SwUndoIter& rUndoIter)
+void SwUndoFmtAttr::RepeatImpl(::sw::RepeatContext & rContext)
 {
     if ( !m_pOldSet.get() )
         return;
 
-    if ( UNDO_INSFMTATTR == rUndoIter.GetLastUndoId())
-    {
-        SwUndoFmtAttr* pLast
-            = static_cast<SwUndoFmtAttr*>(rUndoIter.pLastUndoObj);
-        if (pLast->m_pOldSet.get() && pLast->m_pFmt)
-        {
-            return;
-        }
-    }
+    SwDoc & rDoc(rContext.GetDoc());
 
     switch ( m_nFmtWhich )
     {
     case RES_GRFFMTCOLL:
         {
-            SwNoTxtNode * pNd = rUndoIter.pAktPam->GetNode()->GetNoTxtNode();
+            SwNoTxtNode *const pNd =
+                rContext.GetRepeatPaM().GetNode()->GetNoTxtNode();
             if( pNd )
             {
-                rUndoIter.GetDoc().SetAttr( m_pFmt->GetAttrSet(),
-                                            *pNd->GetFmtColl() );
+                rDoc.SetAttr( m_pFmt->GetAttrSet(), *pNd->GetFmtColl() );
             }
         }
         break;
 
     case RES_TXTFMTCOLL:
         {
-            SwTxtNode * pNd = rUndoIter.pAktPam->GetNode()->GetTxtNode();
+            SwTxtNode *const pNd =
+                rContext.GetRepeatPaM().GetNode()->GetTxtNode();
             if( pNd )
             {
-                rUndoIter.GetDoc().SetAttr( m_pFmt->GetAttrSet(),
-                                            *pNd->GetFmtColl() );
+                rDoc.SetAttr( m_pFmt->GetAttrSet(), *pNd->GetFmtColl() );
             }
         }
         break;
@@ -387,7 +381,8 @@ void SwUndoFmtAttr::Repeat( SwUndoIter& rUndoIter)
             // Rahmen steht. Der Weg ist: suche in allen FlyFrmFormaten
             // nach dem FlyCntnt-Attribut und teste ob der Cursor in der
             // entsprechenden Section liegt.
-            SwFrmFmt* pFly = rUndoIter.pAktPam->GetNode()->GetFlyFmt();
+            SwFrmFmt *const pFly =
+                rContext.GetRepeatPaM().GetNode()->GetFlyFmt();
             if( pFly )
             {
                 // Bug 43672: es duerfen nicht alle Attribute gesetzt werden!
@@ -397,18 +392,18 @@ void SwUndoFmtAttr::Repeat( SwUndoIter& rUndoIter)
                     SfxItemSet aTmpSet( m_pFmt->GetAttrSet() );
                     aTmpSet.ClearItem( RES_CNTNT );
                     if( aTmpSet.Count() )
-                        rUndoIter.GetDoc().SetAttr( aTmpSet, *pFly );
+                    {
+                        rDoc.SetAttr( aTmpSet, *pFly );
+                    }
                 }
                 else
                 {
-                    rUndoIter.GetDoc().SetAttr( m_pFmt->GetAttrSet(), *pFly );
+                    rDoc.SetAttr( m_pFmt->GetAttrSet(), *pFly );
                 }
             }
             break;
         }
     }
-
-    rUndoIter.pLastUndoObj = this;
 }
 
 SwRewriter SwUndoFmtAttr::GetRewriter() const
@@ -452,7 +447,7 @@ void SwUndoFmtAttr::SaveFlyAnchor( bool bSvDrwPt )
 */	}
 
     const SwFmtAnchor& rAnchor =
-        static_cast<const SwFmtAnchor&>( m_pOldSet->Get( RES_ANCHOR, FALSE ) );
+        static_cast<const SwFmtAnchor&>( m_pOldSet->Get( RES_ANCHOR, sal_False ) );
     if( !rAnchor.GetCntntAnchor() )
         return;
 
@@ -478,12 +473,12 @@ void SwUndoFmtAttr::SaveFlyAnchor( bool bSvDrwPt )
 // Return value indicates, if anchor attribute is restored.
 // Note: If anchor attribute is restored, all other existing attributes
 //       are also restored.
-bool SwUndoFmtAttr::RestoreFlyAnchor( SwUndoIter& rIter )
+bool SwUndoFmtAttr::RestoreFlyAnchor(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rIter.GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
     SwFlyFrmFmt* pFrmFmt = static_cast<SwFlyFrmFmt*>(m_pFmt);
     const SwFmtAnchor& rAnchor =
-        static_cast<const SwFmtAnchor&>( m_pOldSet->Get( RES_ANCHOR, FALSE ) );
+        static_cast<const SwFmtAnchor&>( m_pOldSet->Get( RES_ANCHOR, sal_False ) );
 
     SwFmtAnchor aNewAnchor( rAnchor.GetAnchorId() );
     if (FLY_AT_PAGE != rAnchor.GetAnchorId())
@@ -623,7 +618,7 @@ bool SwUndoFmtAttr::RestoreFlyAnchor( SwUndoIter& rIter )
     if( RES_DRAWFRMFMT != pFrmFmt->Which() )
         pFrmFmt->MakeFrms();
 
-    rIter.pSelFmt = pFrmFmt;
+    rContext.SetSelections(pFrmFmt, 0);
 
     // --> OD 2004-10-26 #i35443# - anchor attribute restored.
     return true;
@@ -632,14 +627,14 @@ bool SwUndoFmtAttr::RestoreFlyAnchor( SwUndoIter& rIter )
 
 // -----------------------------------------------------
 SwUndoFmtResetAttr::SwUndoFmtResetAttr( SwFmt& rChangedFormat,
-                                        const USHORT nWhichId )
+                                        const sal_uInt16 nWhichId )
     : SwUndo( UNDO_RESETATTR )
     , m_pChangedFormat( &rChangedFormat )
     , m_nWhichId( nWhichId )
     , m_pOldItem( 0 )
 {
     const SfxPoolItem* pItem = 0;
-    if (rChangedFormat.GetItemState( nWhichId, FALSE, &pItem ) == SFX_ITEM_SET)
+    if (rChangedFormat.GetItemState( nWhichId, sal_False, &pItem ) == SFX_ITEM_SET)
     {
         m_pOldItem.reset( pItem->Clone() );
     }
@@ -649,7 +644,7 @@ SwUndoFmtResetAttr::~SwUndoFmtResetAttr()
 {
 }
 
-void SwUndoFmtResetAttr::Undo( SwUndoIter& )
+void SwUndoFmtResetAttr::UndoImpl(::sw::UndoRedoContext &)
 {
     if ( m_pOldItem.get() )
     {
@@ -657,7 +652,7 @@ void SwUndoFmtResetAttr::Undo( SwUndoIter& )
     }
 }
 
-void SwUndoFmtResetAttr::Redo( SwUndoIter& )
+void SwUndoFmtResetAttr::RedoImpl(::sw::UndoRedoContext &)
 {
     if ( m_pOldItem.get() )
     {
@@ -668,14 +663,14 @@ void SwUndoFmtResetAttr::Redo( SwUndoIter& )
 
 // -----------------------------------------------------
 
-SwUndoResetAttr::SwUndoResetAttr( const SwPaM& rRange, USHORT nFmtId )
+SwUndoResetAttr::SwUndoResetAttr( const SwPaM& rRange, sal_uInt16 nFmtId )
     : SwUndo( UNDO_RESETATTR ), SwUndRng( rRange )
     , m_pHistory( new SwHistory )
     , m_nFormatId( nFmtId )
 {
 }
 
-SwUndoResetAttr::SwUndoResetAttr( const SwPosition& rPos, USHORT nFmtId )
+SwUndoResetAttr::SwUndoResetAttr( const SwPosition& rPos, sal_uInt16 nFmtId )
     : SwUndo( UNDO_RESETATTR )
     , m_pHistory( new SwHistory )
     , m_nFormatId( nFmtId )
@@ -688,10 +683,10 @@ SwUndoResetAttr::~SwUndoResetAttr()
 {
 }
 
-void SwUndoResetAttr::Undo( SwUndoIter& rUndoIter )
+void SwUndoResetAttr::UndoImpl(::sw::UndoRedoContext & rContext)
 {
     // reset old values
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     m_pHistory->TmpRollback( &rDoc, 0 );
     m_pHistory->SetTmpEnd( m_pHistory->Count() );
 
@@ -702,32 +697,29 @@ void SwUndoResetAttr::Undo( SwUndoIter& rUndoIter )
         if( pTNd )
         {
             SwIndex aIdx( pTNd, nSttCntnt );
-            pTNd->DontExpandFmt( aIdx, FALSE );
+            pTNd->DontExpandFmt( aIdx, sal_False );
         }
     }
 
-    // setze noch den Cursor auf den Undo-Bereich
-    SetPaM( rUndoIter );
+    AddUndoRedoPaM(rContext);
 }
 
-void SwUndoResetAttr::Redo( SwUndoIter& rUndoIter )
+void SwUndoResetAttr::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    // setze Attribut in dem Bereich:
-    SetPaM( rUndoIter );
-    SwDoc& rDoc = rUndoIter.GetDoc();
-    rUndoIter.pLastUndoObj = 0;
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPaM & rPam = AddUndoRedoPaM(rContext);
     SvUShortsSort* pIdArr = m_Ids.Count() ? &m_Ids : 0;
 
     switch ( m_nFormatId )
     {
     case RES_CHRFMT:
-        rUndoIter.GetDoc().RstTxtAttrs( *rUndoIter.pAktPam );
+        rDoc.RstTxtAttrs(rPam);
         break;
     case RES_TXTFMTCOLL:
-        rUndoIter.GetDoc().ResetAttrs( *rUndoIter.pAktPam, FALSE, pIdArr );
+        rDoc.ResetAttrs(rPam, sal_False, pIdArr );
         break;
     case RES_CONDTXTFMTCOLL:
-        rUndoIter.GetDoc().ResetAttrs( *rUndoIter.pAktPam, TRUE, pIdArr );
+        rDoc.ResetAttrs(rPam, sal_True, pIdArr );
 
         break;
     case RES_TXTATR_TOXMARK:
@@ -738,7 +730,7 @@ void SwUndoResetAttr::Redo( SwUndoIter& rUndoIter )
             SwPosition aPos( aIdx, SwIndex( aIdx.GetNode().GetCntntNode(),
                                                                 nSttCntnt ));
 
-            USHORT nCnt = rDoc.GetCurTOXMark( aPos, aArr );
+            sal_uInt16 nCnt = rDoc.GetCurTOXMark( aPos, aArr );
             if( nCnt )
             {
                 if( 1 < nCnt )
@@ -769,15 +761,11 @@ void SwUndoResetAttr::Redo( SwUndoIter& rUndoIter )
         }
         break;
     }
-    rUndoIter.pLastUndoObj = 0;
 }
 
-void SwUndoResetAttr::Repeat( SwUndoIter& rUndoIter )
+void SwUndoResetAttr::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    if ( (RES_FMT_BEGIN > m_nFormatId) ||
-         ( (UNDO_RESETATTR == rUndoIter.GetLastUndoId()) &&
-           (m_nFormatId == static_cast<SwUndoResetAttr*>(rUndoIter.pLastUndoObj)
-                            ->m_nFormatId) ) )
+    if (m_nFormatId < RES_FMT_BEGIN)
     {
         return;
     }
@@ -786,16 +774,15 @@ void SwUndoResetAttr::Repeat( SwUndoIter& rUndoIter )
     switch ( m_nFormatId )
     {
     case RES_CHRFMT:
-        rUndoIter.GetDoc().RstTxtAttrs( *rUndoIter.pAktPam );
+        rContext.GetDoc().RstTxtAttrs(rContext.GetRepeatPaM());
         break;
     case RES_TXTFMTCOLL:
-        rUndoIter.GetDoc().ResetAttrs( *rUndoIter.pAktPam, FALSE, pIdArr );
+        rContext.GetDoc().ResetAttrs(rContext.GetRepeatPaM(), false, pIdArr);
         break;
     case RES_CONDTXTFMTCOLL:
-        rUndoIter.GetDoc().ResetAttrs( *rUndoIter.pAktPam, TRUE, pIdArr );
+        rContext.GetDoc().ResetAttrs(rContext.GetRepeatPaM(), true, pIdArr);
         break;
     }
-    rUndoIter.pLastUndoObj = this;
 }
 
 
@@ -840,7 +827,7 @@ SwUndoAttr::~SwUndoAttr()
 {
 }
 
-void SwUndoAttr::SaveRedlineData( const SwPaM& rPam, BOOL bIsCntnt )
+void SwUndoAttr::SaveRedlineData( const SwPaM& rPam, sal_Bool bIsCntnt )
 {
     SwDoc* pDoc = rPam.GetDoc();
     if ( pDoc->IsRedlineOn() )
@@ -864,29 +851,29 @@ void SwUndoAttr::SaveRedlineData( const SwPaM& rPam, BOOL bIsCntnt )
     }
 }
 
-void SwUndoAttr::Undo( SwUndoIter& rUndoIter )
+void SwUndoAttr::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rUndoIter.GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
 
     RemoveIdx( *pDoc );
 
     if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
     {
-        SwPaM& rPam = *rUndoIter.pAktPam;
+        SwPaM aPam(pDoc->GetNodes().GetEndOfContent());
         if ( ULONG_MAX != m_nNodeIndex )
         {
-            rPam.DeleteMark();
-            rPam.GetPoint()->nNode = m_nNodeIndex;
-            rPam.GetPoint()->nContent.Assign( rPam.GetCntntNode(), nSttCntnt );
-            rPam.SetMark();
-            rPam.GetPoint()->nContent++;
-            pDoc->DeleteRedline( rPam, false, USHRT_MAX );
+            aPam.DeleteMark();
+            aPam.GetPoint()->nNode = m_nNodeIndex;
+            aPam.GetPoint()->nContent.Assign( aPam.GetCntntNode(), nSttCntnt );
+            aPam.SetMark();
+            aPam.GetPoint()->nContent++;
+            pDoc->DeleteRedline(aPam, false, USHRT_MAX);
         }
         else
         {
             // alle Format-Redlines entfernen, werden ggfs. neu gesetzt
-            SetPaM( rUndoIter );
-            pDoc->DeleteRedline( rPam, false, nsRedlineType_t::REDLINE_FORMAT );
+            SetPaM(aPam);
+            pDoc->DeleteRedline(aPam, false, nsRedlineType_t::REDLINE_FORMAT);
             if ( m_pRedlineSaveData.get() )
             {
                 SetSaveData( *pDoc, *m_pRedlineSaveData );
@@ -903,67 +890,30 @@ void SwUndoAttr::Undo( SwUndoIter& rUndoIter )
     m_pHistory->SetTmpEnd( m_pHistory->Count() );
 
     // set cursor onto Undo area
-    SetPaM( rUndoIter );
+    AddUndoRedoPaM(rContext);
 }
 
-int lcl_HasEqualItems( const SfxItemSet& rSet1, const SfxItemSet& rSet2 )
+void SwUndoAttr::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    int nRet = -1;
-    SfxItemIter aIter1( rSet1 ), aIter2( rSet2 );
-    const SfxPoolItem *pI1 = aIter1.FirstItem(), *pI2 = aIter2.FirstItem();
-
-    while( pI1 && pI2 )
-    {
-        if( pI1->Which() != pI2->Which() ||
-            aIter1.IsAtEnd() != aIter2.IsAtEnd() )
-        {
-            nRet = 0;
-            break;
-        }
-        if( aIter1.IsAtEnd() )
-            break;
-        pI1 = aIter1.NextItem();
-        pI2 = aIter2.NextItem();
-    }
-    return nRet;
-}
-
-void SwUndoAttr::Repeat( SwUndoIter& rUndoIter )
-{
-    if ( UNDO_INSATTR == rUndoIter.GetLastUndoId() )
-    {
-        SwUndoAttr* pLast = static_cast<SwUndoAttr*>(rUndoIter.pLastUndoObj);
-        if ((pLast->m_AttrSet.Count() == m_AttrSet.Count()) &&
-            (pLast->m_nInsertFlags    == m_nInsertFlags   ) &&
-            lcl_HasEqualItems( m_AttrSet, pLast->m_AttrSet ))
-        {
-            return;
-        }
-    }
-
-
     // RefMarks are not repeat capable
-    if ( SFX_ITEM_SET != m_AttrSet.GetItemState( RES_TXTATR_REFMARK, FALSE ) )
+    if ( SFX_ITEM_SET != m_AttrSet.GetItemState( RES_TXTATR_REFMARK, sal_False ) )
     {
-        rUndoIter.GetDoc().InsertItemSet( *rUndoIter.pAktPam,
+        rContext.GetDoc().InsertItemSet( rContext.GetRepeatPaM(),
                                            m_AttrSet, m_nInsertFlags );
     }
     else if ( 1 < m_AttrSet.Count() )
     {
         SfxItemSet aTmpSet( m_AttrSet );
         aTmpSet.ClearItem( RES_TXTATR_REFMARK );
-        rUndoIter.GetDoc().InsertItemSet( *rUndoIter.pAktPam,
+        rContext.GetDoc().InsertItemSet( rContext.GetRepeatPaM(),
                                            aTmpSet, m_nInsertFlags );
     }
-    rUndoIter.pLastUndoObj = this;
 }
 
-void SwUndoAttr::Redo( SwUndoIter& rUndoIter )
+void SwUndoAttr::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    // setze Attribut in dem Bereich:
-    SetPaM( rUndoIter );
-    SwPaM& rPam = *rUndoIter.pAktPam;
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPaM & rPam = AddUndoRedoPaM(rContext);
 
     if ( m_pRedlineData.get() &&
          IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
@@ -994,22 +944,20 @@ void SwUndoAttr::Redo( SwUndoIter& rUndoIter )
     {
         rDoc.InsertItemSet( rPam, m_AttrSet, m_nInsertFlags );
     }
-
-    rUndoIter.pLastUndoObj = 0;
 }
 
 
 void SwUndoAttr::RemoveIdx( SwDoc& rDoc )
 {
-    if ( SFX_ITEM_SET != m_AttrSet.GetItemState( RES_TXTATR_FTN, FALSE ))
+    if ( SFX_ITEM_SET != m_AttrSet.GetItemState( RES_TXTATR_FTN, sal_False ))
         return ;
 
     SwHistoryHint* pHstHnt;
     SwNodes& rNds = rDoc.GetNodes();
-    for ( USHORT n = 0; n < m_pHistory->Count(); ++n )
+    for ( sal_uInt16 n = 0; n < m_pHistory->Count(); ++n )
     {
         xub_StrLen nCntnt = 0;
-        ULONG nNode = 0;
+        sal_uLong nNode = 0;
         pHstHnt = (*m_pHistory)[ n ];
         switch ( pHstHnt->Which() )
         {
@@ -1033,7 +981,7 @@ void SwUndoAttr::RemoveIdx( SwDoc& rDoc )
                     if ( STRING_MAXLEN != nCntnt )
                     {
                         const SvUShorts& rArr = pHistoryHint->GetArr();
-                        for ( USHORT i = rArr.Count(); i; )
+                        for ( sal_uInt16 i = rArr.Count(); i; )
                         {
                             if ( RES_TXTATR_FTN == rArr[ --i ] )
                             {
@@ -1076,7 +1024,7 @@ SwUndoDefaultAttr::SwUndoDefaultAttr( const SfxItemSet& rSet )
     , m_pTabStop( 0 )
 {
     const SfxPoolItem* pItem;
-    if( SFX_ITEM_SET == rSet.GetItemState( RES_PARATR_TABSTOP, FALSE, &pItem ) )
+    if( SFX_ITEM_SET == rSet.GetItemState( RES_PARATR_TABSTOP, sal_False, &pItem ) )
     {
         // store separately, because it may change!
         m_pTabStop.reset( static_cast<SvxTabStopItem*>(pItem->Clone()) );
@@ -1095,9 +1043,9 @@ SwUndoDefaultAttr::~SwUndoDefaultAttr()
 {
 }
 
-void SwUndoDefaultAttr::Undo( SwUndoIter& rUndoIter)
+void SwUndoDefaultAttr::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     if ( m_pOldSet.get() )
     {
         SwUndoFmtAttrHelper aTmp(
@@ -1119,15 +1067,15 @@ void SwUndoDefaultAttr::Undo( SwUndoIter& rUndoIter)
     }
 }
 
-void SwUndoDefaultAttr::Redo( SwUndoIter& rUndoIter)
+void SwUndoDefaultAttr::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    Undo( rUndoIter );
+    UndoImpl(rContext);
 }
 
 // -----------------------------------------------------
 
 SwUndoMoveLeftMargin::SwUndoMoveLeftMargin(
-            const SwPaM& rPam, BOOL bFlag, BOOL bMod )
+            const SwPaM& rPam, sal_Bool bFlag, sal_Bool bMod )
     : SwUndo( bFlag ? UNDO_INC_LEFTMARGIN : UNDO_DEC_LEFTMARGIN )
     , SwUndRng( rPam )
     , m_pHistory( new SwHistory )
@@ -1139,41 +1087,38 @@ SwUndoMoveLeftMargin::~SwUndoMoveLeftMargin()
 {
 }
 
-void SwUndoMoveLeftMargin::Undo( SwUndoIter& rIter )
+void SwUndoMoveLeftMargin::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rIter.GetDoc();
-    BOOL bUndo = pDoc->DoesUndo();
-    pDoc->DoUndo( FALSE );
+    SwDoc & rDoc = rContext.GetDoc();
 
     // restore old values
-    m_pHistory->TmpRollback( pDoc, 0 );
+    m_pHistory->TmpRollback( & rDoc, 0 );
     m_pHistory->SetTmpEnd( m_pHistory->Count() );
 
-    pDoc->DoUndo( bUndo );
-    SetPaM( rIter );
+    AddUndoRedoPaM(rContext);
 }
 
-void SwUndoMoveLeftMargin::Redo( SwUndoIter& rIter )
+void SwUndoMoveLeftMargin::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rIter.GetDoc();
-    SetPaM( rIter );
-    pDoc->MoveLeftMargin( *rIter.pAktPam, GetId() == UNDO_INC_LEFTMARGIN,
-            m_bModulus );
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPaM & rPam = AddUndoRedoPaM(rContext);
+
+    rDoc.MoveLeftMargin( rPam,
+            GetId() == UNDO_INC_LEFTMARGIN, m_bModulus );
 }
 
-void SwUndoMoveLeftMargin::Repeat( SwUndoIter& rIter )
+void SwUndoMoveLeftMargin::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwDoc* pDoc = &rIter.GetDoc();
-    pDoc->MoveLeftMargin( *rIter.pAktPam, GetId() == UNDO_INC_LEFTMARGIN,
+    SwDoc & rDoc = rContext.GetDoc();
+    rDoc.MoveLeftMargin(rContext.GetRepeatPaM(), GetId() == UNDO_INC_LEFTMARGIN,
             m_bModulus );
-    rIter.pLastUndoObj = this;
 }
 
 // -----------------------------------------------------
 
 SwUndoChangeFootNote::SwUndoChangeFootNote(
             const SwPaM& rRange, const String& rTxt,
-            USHORT nNum, bool bIsEndNote )
+            sal_uInt16 nNum, bool bIsEndNote )
     : SwUndo( UNDO_CHGFTN ), SwUndRng( rRange )
     , m_pHistory( new SwHistory() )
     , m_Text( rTxt )
@@ -1186,35 +1131,30 @@ SwUndoChangeFootNote::~SwUndoChangeFootNote()
 {
 }
 
-void SwUndoChangeFootNote::Undo( SwUndoIter& rIter )
+void SwUndoChangeFootNote::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
-    SetPaM( rIter );
-
-    BOOL bUndo = rDoc.DoesUndo();
-    rDoc.DoUndo( FALSE );
+    SwDoc & rDoc = rContext.GetDoc();
 
     m_pHistory->TmpRollback( &rDoc, 0 );
     m_pHistory->SetTmpEnd( m_pHistory->Count() );
 
     rDoc.GetFtnIdxs().UpdateAllFtn();
 
-    SetPaM( rIter );
-    rDoc.DoUndo( bUndo );
+    AddUndoRedoPaM(rContext);
 }
 
-void SwUndoChangeFootNote::Redo( SwUndoIter& rIter )
+void SwUndoChangeFootNote::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetPaM( rIter );
-    rIter.GetDoc().SetCurFtn( *rIter.pAktPam, m_Text, m_nNumber, m_bEndNote );
-    SetPaM( rIter );
+    SwDoc & rDoc( rContext.GetDoc() );
+    SwPaM & rPaM = AddUndoRedoPaM(rContext);
+    rDoc.SetCurFtn(rPaM, m_Text, m_nNumber, m_bEndNote);
+    SetPaM(rPaM);
 }
 
-void SwUndoChangeFootNote::Repeat( SwUndoIter& rIter )
+void SwUndoChangeFootNote::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
-    rDoc.SetCurFtn( *rIter.pAktPam, m_Text, m_nNumber, m_bEndNote );
-    rIter.pLastUndoObj = this;
+    SwDoc & rDoc = rContext.GetDoc();
+    rDoc.SetCurFtn( rContext.GetRepeatPaM(), m_Text, m_nNumber, m_bEndNote );
 }
 
 
@@ -1231,17 +1171,17 @@ SwUndoFootNoteInfo::~SwUndoFootNoteInfo()
 {
 }
 
-void SwUndoFootNoteInfo::Undo( SwUndoIter &rIter )
+void SwUndoFootNoteInfo::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc &rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwFtnInfo *pInf = new SwFtnInfo( rDoc.GetFtnInfo() );
     rDoc.SetFtnInfo( *m_pFootNoteInfo );
     m_pFootNoteInfo.reset( pInf );
 }
 
-void SwUndoFootNoteInfo::Redo( SwUndoIter &rIter )
+void SwUndoFootNoteInfo::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc &rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwFtnInfo *pInf = new SwFtnInfo( rDoc.GetFtnInfo() );
     rDoc.SetFtnInfo( *m_pFootNoteInfo );
     m_pFootNoteInfo.reset( pInf );
@@ -1260,17 +1200,17 @@ SwUndoEndNoteInfo::~SwUndoEndNoteInfo()
 {
 }
 
-void SwUndoEndNoteInfo::Undo( SwUndoIter &rIter )
+void SwUndoEndNoteInfo::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc &rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwEndNoteInfo *pInf = new SwEndNoteInfo( rDoc.GetEndNoteInfo() );
     rDoc.SetEndNoteInfo( *m_pEndNoteInfo );
     m_pEndNoteInfo.reset( pInf );
 }
 
-void SwUndoEndNoteInfo::Redo( SwUndoIter &rIter )
+void SwUndoEndNoteInfo::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc &rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwEndNoteInfo *pInf = new SwEndNoteInfo( rDoc.GetEndNoteInfo() );
     rDoc.SetEndNoteInfo( *m_pEndNoteInfo );
     m_pEndNoteInfo.reset( pInf );
@@ -1285,22 +1225,22 @@ SwUndoDontExpandFmt::SwUndoDontExpandFmt( const SwPosition& rPos )
 {
 }
 
-void SwUndoDontExpandFmt::Undo( SwUndoIter& rIter )
+void SwUndoDontExpandFmt::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
+    SwDoc *const pDoc = & rContext.GetDoc();
 
     SwPosition& rPos = *pPam->GetPoint();
     rPos.nNode = m_nNodeIndex;
     rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), m_nContentIndex);
-    pDoc->DontExpandFmt( rPos, FALSE );
+    pDoc->DontExpandFmt( rPos, sal_False );
 }
 
 
-void SwUndoDontExpandFmt::Redo( SwUndoIter& rIter )
+void SwUndoDontExpandFmt::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
+    SwDoc *const pDoc = & rContext.GetDoc();
 
     SwPosition& rPos = *pPam->GetPoint();
     rPos.nNode = m_nNodeIndex;
@@ -1308,11 +1248,11 @@ void SwUndoDontExpandFmt::Redo( SwUndoIter& rIter )
     pDoc->DontExpandFmt( rPos );
 }
 
-void SwUndoDontExpandFmt::Repeat( SwUndoIter& rIter )
+void SwUndoDontExpandFmt::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
-    pDoc->DontExpandFmt( *pPam->GetPoint() );
+    SwPaM & rPam = rContext.GetRepeatPaM();
+    SwDoc & rDoc = rContext.GetDoc();
+    rDoc.DontExpandFmt( *rPam.GetPoint() );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/undo/unbkmk.cxx b/sw/source/core/undo/unbkmk.cxx
index 817f5d242a..2da644670b 100644
--- a/sw/source/core/undo/unbkmk.cxx
+++ b/sw/source/core/undo/unbkmk.cxx
@@ -29,22 +29,20 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <UndoBookmark.hxx>
 
 #include "doc.hxx"
 #include "docary.hxx"
 #include "swundo.hxx"			// fuer die UndoIds
 #include "pam.hxx"
 
-#include "undobj.hxx"
+#include <UndoCore.hxx>
 #include "IMark.hxx"
 #include "rolbck.hxx"
 
 #include "SwRewriter.hxx"
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
-
 SwUndoBookmark::SwUndoBookmark( SwUndoId nUndoId,
             const ::sw::mark::IMark& rBkmk )
     : SwUndo( nUndoId )
@@ -61,7 +59,6 @@ void SwUndoBookmark::SetInDoc( SwDoc* pDoc )
     m_pHistoryBookmark->SetInDoc( pDoc, false );
 }
 
-
 void SwUndoBookmark::ResetInDoc( SwDoc* pDoc )
 {
     IDocumentMarkAccess* const pMarkAccess = pDoc->getIDocumentMarkAccess();
@@ -96,16 +93,15 @@ SwUndoInsBookmark::SwUndoInsBookmark( const ::sw::mark::IMark& rBkmk )
 }
 
 
-void SwUndoInsBookmark::Undo( SwUndoIter& rUndoIter )
+void SwUndoInsBookmark::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    ResetInDoc( &rUndoIter.GetDoc() );
+    ResetInDoc( &rContext.GetDoc() );
 }
 
-
-void SwUndoInsBookmark::Redo( SwUndoIter& rUndoIter )
+void SwUndoInsBookmark::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetInDoc( &rUndoIter.GetDoc() );
+    SetInDoc( &rContext.GetDoc() );
 }
 
 
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
\ No newline at end of file
diff --git a/sw/source/core/undo/undel.cxx b/sw/source/core/undo/undel.cxx
index 5f9101368d..8a128857aa 100644
--- a/sw/source/core/undo/undel.cxx
+++ b/sw/source/core/undo/undel.cxx
@@ -29,6 +29,7 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <UndoDelete.hxx>
 #include <hintids.hxx>
 #include <unotools/charclass.hxx>
 #include <editeng/brkitem.hxx>
@@ -36,11 +37,12 @@
 #include <frmfmt.hxx>
 #include <fmtanchr.hxx>
 #include <doc.hxx>
+#include <UndoManager.hxx>
 #include <swtable.hxx>
 #include <swundo.hxx>			// fuer die UndoIds
 #include <pam.hxx>
 #include <ndtxt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
 #include <rolbck.hxx>
 #include <poolfmt.hxx>
 #include <mvsave.hxx>
@@ -53,21 +55,19 @@
 #include <comcore.hrc> // #111827#
 #include <undo.hrc>
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 
 // DELETE
 /*  lcl_MakeAutoFrms has to call MakeFrms for objects bounded "AtChar" ( == AUTO ),
     if the anchor frame has be moved via _MoveNodes(..) and DelFrms(..)
 */
 
-void lcl_MakeAutoFrms( const SwSpzFrmFmts& rSpzArr, ULONG nMovedIndex )
+void lcl_MakeAutoFrms( const SwSpzFrmFmts& rSpzArr, sal_uLong nMovedIndex )
 {
     if( rSpzArr.Count() )
     {
         SwFlyFrmFmt* pFmt;
         const SwFmtAnchor* pAnchor;
-        for( USHORT n = 0; n < rSpzArr.Count(); ++n )
+        for( sal_uInt16 n = 0; n < rSpzArr.Count(); ++n )
         {
             pFmt = (SwFlyFrmFmt*)rSpzArr[n];
             pAnchor = &pFmt->GetAnchor();
@@ -103,12 +103,12 @@ section and the end paragraph not. Then we have to move the paragraph into this
 record this in nSectDiff.
 */
 
-SwUndoDelete::SwUndoDelete( SwPaM& rPam, BOOL bFullPara, BOOL bCalledByTblCpy )
+SwUndoDelete::SwUndoDelete( SwPaM& rPam, sal_Bool bFullPara, sal_Bool bCalledByTblCpy )
     : SwUndo(UNDO_DELETE), SwUndRng( rPam ),
     pMvStt( 0 ), pSttStr(0), pEndStr(0), pRedlData(0), pRedlSaveData(0),
     nNode(0), nNdDiff(0), nSectDiff(0), nReplaceDummy(0), nSetPos(0),
-    bGroup( FALSE ), bBackSp( FALSE ), bJoinNext( FALSE ), bTblDelLastNd( FALSE ),
-    bDelFullPara( bFullPara ), bResetPgDesc( FALSE ), bResetPgBrk( FALSE ),
+    bGroup( sal_False ), bBackSp( sal_False ), bJoinNext( sal_False ), bTblDelLastNd( sal_False ),
+    bDelFullPara( bFullPara ), bResetPgDesc( sal_False ), bResetPgBrk( sal_False ),
     bFromTableCopy( bCalledByTblCpy )
 {
     bDelFullPara = bFullPara; // This is set e.g. if an empty paragraph before a table is deleted
@@ -140,10 +140,8 @@ SwUndoDelete::SwUndoDelete( SwPaM& rPam, BOOL bFullPara, BOOL bCalledByTblCpy )
         DelCntntIndex( *rPam.GetMark(), *rPam.GetPoint(),
                         DelCntntType(nsDelCntntType::DELCNT_ALL | nsDelCntntType::DELCNT_CHKNOCNTNT) );
 
-        BOOL bDoesUndo = pDoc->DoesUndo();
-        pDoc->DoUndo( FALSE );
+        ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
         _DelBookmarks(pStt->nNode, pEnd->nNode);
-        pDoc->DoUndo( bDoesUndo );
     }
     else
         DelCntntIndex( *rPam.GetMark(), *rPam.GetPoint() );
@@ -165,8 +163,8 @@ SwUndoDelete::SwUndoDelete( SwPaM& rPam, BOOL bFullPara, BOOL bCalledByTblCpy )
                     : pEnd->nNode.GetNode().GetTxtNode();
     }
 
-    BOOL bMoveNds = *pStt == *pEnd      // noch ein Bereich vorhanden ??
-                ? FALSE
+    sal_Bool bMoveNds = *pStt == *pEnd      // noch ein Bereich vorhanden ??
+                ? sal_False
                 : ( SaveCntnt( pStt, pEnd, pSttTxtNd, pEndTxtNd ) || bFromTableCopy );
 
     if( pSttTxtNd && pEndTxtNd && pSttTxtNd != pEndTxtNd )
@@ -186,11 +184,11 @@ SwUndoDelete::SwUndoDelete( SwPaM& rPam, BOOL bFullPara, BOOL bCalledByTblCpy )
             {
                 SwRegHistory aRegHist( *pEndTxtNd, pHistory );
                 if( SFX_ITEM_SET == pEndTxtNd->GetpSwAttrSet()->GetItemState(
-                        RES_BREAK, FALSE ) )
+                        RES_BREAK, sal_False ) )
                     pEndTxtNd->ResetAttr( RES_BREAK );
                 if( pEndTxtNd->HasSwAttrSet() &&
                     SFX_ITEM_SET == pEndTxtNd->GetpSwAttrSet()->GetItemState(
-                        RES_PAGEDESC, FALSE ) )
+                        RES_PAGEDESC, sal_False ) )
                     pEndTxtNd->ResetAttr( RES_PAGEDESC );
             }
         }
@@ -213,7 +211,7 @@ SwUndoDelete::SwUndoDelete( SwPaM& rPam, BOOL bFullPara, BOOL bCalledByTblCpy )
 
     if( bMoveNds )		// sind noch Nodes zu verschieben ?
     {
-        SwNodes& rNds = (SwNodes&)*pDoc->GetUndoNds();
+        SwNodes& rNds = pDoc->GetUndoManager().GetUndoNodes();
         SwNodes& rDocNds = pDoc->GetNodes();
         SwNodeRange aRg( rDocNds, nSttNode - nNdDiff,
                          rDocNds, nEndNode - nNdDiff );
@@ -246,11 +244,9 @@ SwUndoDelete::SwUndoDelete( SwPaM& rPam, BOOL bFullPara, BOOL bCalledByTblCpy )
                     ++nReplaceDummy;
                     SwNodeRange aMvRg( *pEndTxtNd, 0, *pEndTxtNd, 1 );
                     SwPosition aSplitPos( *pEndTxtNd );
-                    BOOL bDoesUndo = pDoc->DoesUndo();
-                    pDoc->DoUndo( FALSE );
+                    ::sw::UndoGuard const ug(pDoc->GetIDocumentUndoRedo());
                     pDoc->SplitNode( aSplitPos, false );
-                    rDocNds._MoveNodes( aMvRg, rDocNds, aRg.aEnd, TRUE );
-                    pDoc->DoUndo( bDoesUndo );
+                    rDocNds._MoveNodes( aMvRg, rDocNds, aRg.aEnd, sal_True );
                     aRg.aEnd--;
                 }
                 else
@@ -272,11 +268,9 @@ SwUndoDelete::SwUndoDelete( SwPaM& rPam, BOOL bFullPara, BOOL bCalledByTblCpy )
                 {
                     SwNodeRange aMvRg( *pSttTxtNd, 0, *pSttTxtNd, 1 );
                     SwPosition aSplitPos( *pSttTxtNd );
-                    BOOL bDoesUndo = pDoc->DoesUndo();
-                    pDoc->DoUndo( FALSE );
+                    ::sw::UndoGuard const ug(pDoc->GetIDocumentUndoRedo());
                     pDoc->SplitNode( aSplitPos, false );
-                    rDocNds._MoveNodes( aMvRg, rDocNds, aRg.aStart, TRUE );
-                    pDoc->DoUndo( bDoesUndo );
+                    rDocNds._MoveNodes( aMvRg, rDocNds, aRg.aStart, sal_True );
                     aRg.aStart--;
                 }
             }
@@ -312,12 +306,12 @@ SwUndoDelete::SwUndoDelete( SwPaM& rPam, BOOL bFullPara, BOOL bCalledByTblCpy )
                 if( bJoinNext )
                 {
                     SwNodeRange aMvRg( *pEndTxtNd, 0, *pEndTxtNd, 1 );
-                    rDocNds._MoveNodes( aMvRg, rDocNds, aRg.aStart, TRUE );
+                    rDocNds._MoveNodes( aMvRg, rDocNds, aRg.aStart, sal_True );
                 }
                 else
                 {
                     SwNodeRange aMvRg( *pSttTxtNd, 0, *pSttTxtNd, 1 );
-                    rDocNds._MoveNodes( aMvRg, rDocNds, aRg.aEnd, TRUE );
+                    rDocNds._MoveNodes( aMvRg, rDocNds, aRg.aEnd, sal_True );
                 }
             }
         }
@@ -350,14 +344,14 @@ SwUndoDelete::SwUndoDelete( SwPaM& rPam, BOOL bFullPara, BOOL bCalledByTblCpy )
         DELETEZ( pHistory );
 }
 
-BOOL SwUndoDelete::SaveCntnt( const SwPosition* pStt, const SwPosition* pEnd,
+sal_Bool SwUndoDelete::SaveCntnt( const SwPosition* pStt, const SwPosition* pEnd,
                     SwTxtNode* pSttTxtNd, SwTxtNode* pEndTxtNd )
 {
-    ULONG nNdIdx = pStt->nNode.GetIndex();
+    sal_uLong nNdIdx = pStt->nNode.GetIndex();
     // 1 - kopiere den Anfang in den Start-String
     if( pSttTxtNd )
     {
-        BOOL bOneNode = nSttNode == nEndNode;
+        sal_Bool bOneNode = nSttNode == nEndNode;
         xub_StrLen nLen = bOneNode ? nEndCntnt - nSttCntnt
                                 : pSttTxtNd->GetTxt().Len() - nSttCntnt;
         SwRegHistory aRHst( *pSttTxtNd, pHistory );
@@ -390,7 +384,7 @@ BOOL SwUndoDelete::SaveCntnt( const SwPosition* pStt, const SwPosition* pEnd,
         }
 
         if( bOneNode )
-            return FALSE;           // keine Nodes mehr verschieben
+            return sal_False;           // keine Nodes mehr verschieben
     }
 
 
@@ -428,21 +422,21 @@ BOOL SwUndoDelete::SaveCntnt( const SwPosition* pStt, const SwPosition* pEnd,
 
     // sind es nur zwei Nodes, dann ist schon alles erledigt.
     if( ( pSttTxtNd || pEndTxtNd ) && nSttNode + 1 == nEndNode )
-        return FALSE;           // keine Nodes mehr verschieben
+        return sal_False;           // keine Nodes mehr verschieben
 
-    return TRUE;                // verschiebe die dazwischen liegenden Nodes
+    return sal_True;                // verschiebe die dazwischen liegenden Nodes
 }
 
 
-BOOL SwUndoDelete::CanGrouping( SwDoc* pDoc, const SwPaM& rDelPam )
+sal_Bool SwUndoDelete::CanGrouping( SwDoc* pDoc, const SwPaM& rDelPam )
 {
     // ist das Undo groesser als 1 Node ? (sprich: Start und EndString)
-    if( pSttStr ? !pSttStr->Len() || pEndStr : TRUE )
-        return FALSE;
+    if( pSttStr ? !pSttStr->Len() || pEndStr : sal_True )
+        return sal_False;
 
     // es kann nur das Loeschen von einzelnen char's zusammengefasst werden
     if( nSttNode != nEndNode || ( !bGroup && nSttCntnt+1 != nEndCntnt ))
-        return FALSE;
+        return sal_False;
 
     const SwPosition *pStt = rDelPam.Start(),
                     *pEnd = rDelPam.GetPoint() == pStt
@@ -452,26 +446,26 @@ BOOL SwUndoDelete::CanGrouping( SwDoc* pDoc, const SwPaM& rDelPam )
     if( pStt->nNode != pEnd->nNode ||
         pStt->nContent.GetIndex()+1 != pEnd->nContent.GetIndex() ||
         pEnd->nNode != nSttNode )
-        return FALSE;
+        return sal_False;
 
     // untercheide zwischen BackSpace und Delete. Es muss dann das
     // Undo-Array unterschiedlich aufgebaut werden !!
     if( pEnd->nContent == nSttCntnt )
     {
-        if( bGroup && !bBackSp ) return FALSE;
-        bBackSp = TRUE;
+        if( bGroup && !bBackSp ) return sal_False;
+        bBackSp = sal_True;
     }
     else if( pStt->nContent == nSttCntnt )
     {
-        if( bGroup && bBackSp ) return FALSE;
-        bBackSp = FALSE;
+        if( bGroup && bBackSp ) return sal_False;
+        bBackSp = sal_False;
     }
     else
-        return FALSE;
+        return sal_False;
 
     // sind die beiden Nodes (Nodes-/Undo-Array) ueberhaupt TextNodes?
     SwTxtNode * pDelTxtNd = pStt->nNode.GetNode().GetTxtNode();
-    if( !pDelTxtNd ) return FALSE;
+    if( !pDelTxtNd ) return sal_False;
 
     xub_StrLen nUChrPos = bBackSp ? 0 : pSttStr->Len()-1;
     sal_Unicode cDelChar = pDelTxtNd->GetTxt().GetChar( pStt->nContent.GetIndex() );
@@ -479,19 +473,19 @@ BOOL SwUndoDelete::CanGrouping( SwDoc* pDoc, const SwPaM& rDelPam )
     if( ( CH_TXTATR_BREAKWORD == cDelChar || CH_TXTATR_INWORD == cDelChar ) ||
         rCC.isLetterNumeric( String( cDelChar ), 0 ) !=
         rCC.isLetterNumeric( *pSttStr, nUChrPos ) )
-        return FALSE;
+        return sal_False;
 
     {
         SwRedlineSaveDatas* pTmpSav = new SwRedlineSaveDatas;
-        if( !FillSaveData( rDelPam, *pTmpSav, FALSE ))
+        if( !FillSaveData( rDelPam, *pTmpSav, sal_False ))
             delete pTmpSav, pTmpSav = 0;
 
-        BOOL bOk = ( !pRedlSaveData && !pTmpSav ) ||
+        sal_Bool bOk = ( !pRedlSaveData && !pTmpSav ) ||
                    ( pRedlSaveData && pTmpSav &&
                 SwUndo::CanRedlineGroup( *pRedlSaveData, *pTmpSav, bBackSp ));
         delete pTmpSav;
         if( !bOk )
-            return FALSE;
+            return sal_False;
 
         pDoc->DeleteRedline( rDelPam, false, USHRT_MAX );
     }
@@ -508,8 +502,8 @@ BOOL SwUndoDelete::CanGrouping( SwDoc* pDoc, const SwPaM& rDelPam )
     pSttStr->Insert( cDelChar, nUChrPos );
     pDelTxtNd->EraseText( pStt->nContent, 1 );
 
-    bGroup = TRUE;
-    return TRUE;
+    bGroup = sal_True;
+    return sal_True;
 }
 
 
@@ -534,7 +528,7 @@ static SwRewriter lcl_RewriterFromHistory(SwHistory & rHistory)
 
     bool bDone = false;
 
-    for ( USHORT n = 0; n < rHistory.Count(); n++)
+    for ( sal_uInt16 n = 0; n < rHistory.Count(); n++)
     {
         String aDescr = rHistory[n]->GetDescription();
 
@@ -616,14 +610,14 @@ SwRewriter SwUndoDelete::GetRewriter() const
 }
 
 // Every object, anchored "AtCntnt" will be reanchored at rPos
-void lcl_ReAnchorAtCntntFlyFrames( const SwSpzFrmFmts& rSpzArr, SwPosition &rPos, ULONG nOldIdx )
+void lcl_ReAnchorAtCntntFlyFrames( const SwSpzFrmFmts& rSpzArr, SwPosition &rPos, sal_uLong nOldIdx )
 {
     if( rSpzArr.Count() )
     {
         SwFlyFrmFmt* pFmt;
         const SwFmtAnchor* pAnchor;
         const SwPosition* pAPos;
-        for( USHORT n = 0; n < rSpzArr.Count(); ++n )
+        for( sal_uInt16 n = 0; n < rSpzArr.Count(); ++n )
         {
             pFmt = (SwFlyFrmFmt*)rSpzArr[n];
             pAnchor = &pFmt->GetAnchor();
@@ -641,13 +635,11 @@ void lcl_ReAnchorAtCntntFlyFrames( const SwSpzFrmFmts& rSpzArr, SwPosition &rPos
     }
 }
 
-void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
+void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rUndoIter.GetDoc();
-    BOOL bUndo = pDoc->DoesUndo();
-    pDoc->DoUndo( FALSE );
+    SwDoc *const pDoc = & rContext.GetDoc();
 
-    ULONG nCalcStt = nSttNode - nNdDiff;
+    sal_uLong nCalcStt = nSttNode - nNdDiff;
 
     if( nSectDiff && bBackSp )
         nCalcStt += nSectDiff;
@@ -679,8 +671,7 @@ void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
         else
             pInsNd = 0;			// Node nicht loeschen !!
 
-        SwNodes* pUNds = (SwNodes*)pDoc->GetUndoNds();
-        BOOL bNodeMove = 0 != nNode;
+        sal_Bool bNodeMove = 0 != nNode;
 
         if( pEndStr )
         {
@@ -695,7 +686,7 @@ void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
 
             if( pSttStr && !bFromTableCopy )
             {
-                ULONG nOldIdx = aPos.nNode.GetIndex();
+                sal_uLong nOldIdx = aPos.nNode.GetIndex();
                 pDoc->SplitNode( aPos, false );
                 // After the split all objects are anchored at the first paragraph,
                 // but the pHistory of the fly frame formats relies on anchoring at
@@ -719,7 +710,7 @@ void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
             {
                 if( nSttCntnt < pNd->GetTxt().Len() )
                 {
-                    ULONG nOldIdx = aPos.nNode.GetIndex();
+                    sal_uLong nOldIdx = aPos.nNode.GetIndex();
                     pDoc->SplitNode( aPos, false );
                     if( bBackSp )
                         lcl_ReAnchorAtCntntFlyFrames( *pDoc->GetSpzFrmFmts(), aPos, nOldIdx );
@@ -731,7 +722,7 @@ void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
         SwNode* pMovedNode = NULL;
         if( nSectDiff )
         {
-            ULONG nMoveIndex = aPos.nNode.GetIndex();
+            sal_uLong nMoveIndex = aPos.nNode.GetIndex();
             int nDiff = 0;
             if( bJoinNext )
             {
@@ -748,7 +739,7 @@ void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
             aPos.nNode--;
             if( !bJoinNext )
                 pMovedNode = &aPos.nNode.GetNode();
-            pDoc->GetNodes()._MoveNodes( aRg, pDoc->GetNodes(), aMvIdx, TRUE );
+            pDoc->GetNodes()._MoveNodes( aRg, pDoc->GetNodes(), aMvIdx, sal_True );
             aPos.nNode++;
         }
 
@@ -756,11 +747,11 @@ void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
         {
             SwNodeRange aRange( *pMvStt, 0, *pMvStt, nNode );
             SwNodeIndex aCopyIndex( aPos.nNode, -1 );
-            pUNds->_Copy( aRange, aPos.nNode );
+            pDoc->GetUndoManager().GetUndoNodes()._Copy( aRange, aPos.nNode );
 
             if( nReplaceDummy )
             {
-                ULONG nMoveIndex;
+                sal_uLong nMoveIndex;
                 if( bJoinNext )
                 {
                     nMoveIndex = nEndNode - nNdDiff;
@@ -774,7 +765,7 @@ void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
                 SwNodeIndex aMvIdx( pDoc->GetNodes(), nMoveIndex );
                 SwNodeRange aRg( aPos.nNode, 0, aPos.nNode, 1 );
                 pMovedNode = &aPos.nNode.GetNode();
-                pDoc->GetNodes()._MoveNodes( aRg, pDoc->GetNodes(), aMvIdx, TRUE );
+                pDoc->GetNodes()._MoveNodes( aRg, pDoc->GetNodes(), aMvIdx, sal_True );
                 pDoc->GetNodes().Delete( aMvIdx, 1 );
             }
         }
@@ -831,8 +822,8 @@ void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
 
         if( bResetPgDesc || bResetPgBrk )
         {
-            USHORT nStt = static_cast<USHORT>( bResetPgDesc ? RES_PAGEDESC : RES_BREAK );
-            USHORT nEnd = static_cast<USHORT>( bResetPgBrk ? RES_BREAK : RES_PAGEDESC );
+            sal_uInt16 nStt = static_cast<sal_uInt16>( bResetPgDesc ? RES_PAGEDESC : RES_BREAK );
+            sal_uInt16 nEnd = static_cast<sal_uInt16>( bResetPgBrk ? RES_BREAK : RES_PAGEDESC );
 
             SwNode* pNode = pDoc->GetNodes()[ nEndNode + 1 ];
             if( pNode->IsCntntNode() )
@@ -847,22 +838,17 @@ void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
     if( pRedlSaveData )
         SetSaveData( *pDoc, *pRedlSaveData );
 
-    pDoc->DoUndo( bUndo );			// Undo wieder einschalten
-    SetPaM( rUndoIter, TRUE );
+    AddUndoRedoPaM(rContext, true);
 }
 
-void SwUndoDelete::Redo( SwUndoIter& rUndoIter )
+void SwUndoDelete::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    rUndoIter.SetUpdateAttr( TRUE );
-
-    SwPaM& rPam = *rUndoIter.pAktPam;
+    SwPaM & rPam = AddUndoRedoPaM(rContext);
     SwDoc& rDoc = *rPam.GetDoc();
 
-    SetPaM( rPam );
-
     if( pRedlSaveData )
     {
-        bool bSuccess = FillSaveData(rPam, *pRedlSaveData, TRUE);
+        bool bSuccess = FillSaveData(rPam, *pRedlSaveData, sal_True);
         OSL_ENSURE(bSuccess,
             "SwUndoDelete::Redo: used to have redline data, but now none?");
         if (!bSuccess)
@@ -874,7 +860,7 @@ void SwUndoDelete::Redo( SwUndoIter& rUndoIter )
     if( !bDelFullPara )
     {
         SwUndRng aTmpRng( rPam );
-        RemoveIdxFromRange( rPam, FALSE );
+        RemoveIdxFromRange( rPam, sal_False );
         aTmpRng.SetPaM( rPam );
 
         if( !bJoinNext )            // Dann Selektion von unten nach oben
@@ -940,11 +926,11 @@ void SwUndoDelete::Redo( SwUndoIter& rUndoIter )
 
                 const SfxPoolItem *pItem;
                 if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_PAGEDESC,
-                    FALSE, &pItem ) )
+                    sal_False, &pItem ) )
                     pNextNd->SetAttr( *pItem );
 
                 if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_BREAK,
-                    FALSE, &pItem ) )
+                    sal_False, &pItem ) )
                     pNextNd->SetAttr( *pItem );
             }
             pTblNd->DelFrms();
@@ -974,15 +960,16 @@ void SwUndoDelete::Redo( SwUndoIter& rUndoIter )
         rDoc.DeleteAndJoin( rPam );
 }
 
-void SwUndoDelete::Repeat( SwUndoIter& rUndoIter )
+void SwUndoDelete::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    if( UNDO_DELETE == rUndoIter.GetLastUndoId() )
+    // this action does not seem idempotent,
+    // so make sure it is only executed once on repeat
+    if (rContext.m_bDeleteRepeated)
         return;
 
-    SwPaM& rPam = *rUndoIter.pAktPam;
+    SwPaM & rPam = rContext.GetRepeatPaM();
     SwDoc& rDoc = *rPam.GetDoc();
-    BOOL bGroupUndo = rDoc.DoesGroupUndo();
-    rDoc.DoGroupUndo( FALSE );
+    ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
     if( !rPam.HasMark() )
     {
         rPam.SetMark();
@@ -992,8 +979,7 @@ void SwUndoDelete::Repeat( SwUndoIter& rUndoIter )
         rDoc.DelFullPara( rPam );
     else
         rDoc.DeleteAndJoin( rPam );
-    rDoc.DoGroupUndo( bGroupUndo );
-    rUndoIter.pLastUndoObj = this;
+    rContext.m_bDeleteRepeated = true;
 }
 
 
diff --git a/sw/source/core/undo/undo.src b/sw/source/core/undo/undo.src
index 4ad1e70b78..928c38e494 100644
--- a/sw/source/core/undo/undo.src
+++ b/sw/source/core/undo/undo.src
@@ -394,7 +394,7 @@ String STR_UNDO_SETRUBYATTR
 {
     Text [ en-US ] = "Ruby Setting";
 };
-#102505#
+// #102505#
 String STR_UNDO_TMPAUTOCORR
 {
     Text [ en-US ] = "AutoCorrect" ;
diff --git a/sw/source/core/undo/undobj.cxx b/sw/source/core/undo/undobj.cxx
index f57b4407b5..f28e5973c6 100644
--- a/sw/source/core/undo/undobj.cxx
+++ b/sw/source/core/undo/undobj.cxx
@@ -30,16 +30,18 @@
 #include "precompiled_sw.hxx"
 
 
+#include <IShellCursorSupplier.hxx>
 #include <txtftn.hxx>
 #include <fmtanchr.hxx>
 #include <ftnidx.hxx>
 #include <frmfmt.hxx>
 #include <doc.hxx>
+#include <UndoManager.hxx>
 #include <docary.hxx>
 #include <swundo.hxx>			// fuer die UndoIds
 #include <pam.hxx>
 #include <ndtxt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
 #include <rolbck.hxx>
 #include <ndnotxt.hxx>
 #include <IMark.hxx>
@@ -56,35 +58,23 @@ class SwRedlineSaveData : public SwUndRng, public SwRedlineData,
 public:
     SwRedlineSaveData( SwComparePosition eCmpPos,
                         const SwPosition& rSttPos, const SwPosition& rEndPos,
-                        SwRedline& rRedl, BOOL bCopyNext );
+                        SwRedline& rRedl, sal_Bool bCopyNext );
     ~SwRedlineSaveData();
     void RedlineToDoc( SwPaM& rPam );
     SwNodeIndex* GetMvSttIdx() const
         { return SwUndoSaveSection::GetMvSttIdx(); }
 
 #if OSL_DEBUG_LEVEL > 1
-    USHORT nRedlineCount;
+    sal_uInt16 nRedlineCount;
 #endif
 };
 
-SV_IMPL_PTRARR( SwUndos, SwUndo*)
 SV_IMPL_PTRARR( SwRedlineSaveDatas, SwRedlineSaveDataPtr )
 
-SwUndoIter::SwUndoIter( SwPaM* pPam, SwUndoId nId )
-{
-    nUndoId = nId;
-    bWeiter = nId ? TRUE : FALSE;
-    bUpdateAttr = FALSE;
-    pAktPam = pPam;
-    nEndCnt = 0;
-    pSelFmt = 0;
-    pMarkList = 0;
-}
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
 
 //------------------------------------------------------------
 
-// Diese Klasse speichert den Pam als USHORT's und kann diese wieder zu
+// Diese Klasse speichert den Pam als sal_uInt16's und kann diese wieder zu
 
 // einem PaM zusammensetzen
 SwUndRng::SwUndRng()
@@ -116,7 +106,7 @@ void SwUndRng::SetValues( const SwPaM& rPam )
     nSttCntnt = pStt->nContent.GetIndex();
 }
 
-void SwUndRng::SetPaM( SwPaM & rPam, BOOL bCorrToCntnt ) const
+void SwUndRng::SetPaM( SwPaM & rPam, sal_Bool bCorrToCntnt ) const
 {
     rPam.DeleteMark();
     rPam.GetPoint()->nNode = nSttNode;
@@ -144,26 +134,29 @@ void SwUndRng::SetPaM( SwPaM & rPam, BOOL bCorrToCntnt ) const
         rPam.GetPoint()->nContent.Assign( 0, 0 );
 }
 
-void SwUndRng::SetPaM( SwUndoIter& rIter, BOOL bCorrToCntnt ) const
+SwPaM & SwUndRng::AddUndoRedoPaM(
+        ::sw::UndoRedoContext & rContext, bool bCorrToCntnt) const
 {
-    if( rIter.pAktPam )
-        SetPaM( *rIter.pAktPam, bCorrToCntnt );
+    SwPaM & rPaM( rContext.GetCursorSupplier().CreateNewShellCursor() );
+    SetPaM( rPaM, bCorrToCntnt );
+    return rPaM;
 }
 
+
 //------------------------------------------------------------
 
 
-void SwUndo::RemoveIdxFromSection( SwDoc& rDoc, ULONG nSttIdx,
-                                    ULONG* pEndIdx )
+void SwUndo::RemoveIdxFromSection( SwDoc& rDoc, sal_uLong nSttIdx,
+                                    sal_uLong* pEndIdx )
 {
     SwNodeIndex aIdx( rDoc.GetNodes(), nSttIdx );
     SwNodeIndex aEndIdx( rDoc.GetNodes(), pEndIdx ? *pEndIdx
                                     : aIdx.GetNode().EndOfSectionIndex() );
     SwPosition aPos( rDoc.GetNodes().GetEndOfPostIts() );
-    rDoc.CorrAbs( aIdx, aEndIdx, aPos, TRUE );
+    rDoc.CorrAbs( aIdx, aEndIdx, aPos, sal_True );
 }
 
-void SwUndo::RemoveIdxFromRange( SwPaM& rPam, BOOL bMoveNext )
+void SwUndo::RemoveIdxFromRange( SwPaM& rPam, sal_Bool bMoveNext )
 {
     const SwPosition* pEnd = rPam.End();
     if( bMoveNext )
@@ -184,13 +177,13 @@ void SwUndo::RemoveIdxFromRange( SwPaM& rPam, BOOL bMoveNext )
             }
         }
 
-        rPam.GetDoc()->CorrAbs( aStt, aEnd, *rPam.GetPoint(), TRUE );
+        rPam.GetDoc()->CorrAbs( aStt, aEnd, *rPam.GetPoint(), sal_True );
     }
     else
-        rPam.GetDoc()->CorrAbs( rPam, *pEnd, TRUE );
+        rPam.GetDoc()->CorrAbs( rPam, *pEnd, sal_True );
 }
 
-void SwUndo::RemoveIdxRel( ULONG nIdx, const SwPosition& rPos )
+void SwUndo::RemoveIdxRel( sal_uLong nIdx, const SwPosition& rPos )
 {
     // nur die Crsr verschieben; die Bookmarks/TOXMarks/.. werden vom
     // entsp. JoinNext/JoinPrev erledigt!
@@ -198,8 +191,8 @@ void SwUndo::RemoveIdxRel( ULONG nIdx, const SwPosition& rPos )
     ::PaMCorrRel( aIdx, rPos );
 }
 
-SwUndo::SwUndo( SwUndoId nI )
-    : nId(nI), nOrigRedlineMode(nsRedlineMode_t::REDLINE_NONE),
+SwUndo::SwUndo(SwUndoId const nId)
+    : m_nId(nId), nOrigRedlineMode(nsRedlineMode_t::REDLINE_NONE),
       bCacheComment(true), pComment(NULL)
 {
 }
@@ -215,9 +208,89 @@ SwUndo::~SwUndo()
     delete pComment;
 }
 
-void SwUndo::Repeat( SwUndoIter& rIter )
+
+class UndoRedoRedlineGuard
+{
+public:
+    UndoRedoRedlineGuard(::sw::UndoRedoContext & rContext, SwUndo & rUndo)
+        : m_rRedlineAccess(rContext.GetDoc())
+        , m_eMode(m_rRedlineAccess.GetRedlineMode())
+    {
+        RedlineMode_t const eTmpMode =
+            static_cast<RedlineMode_t>(rUndo.GetRedlineMode());
+        if ((nsRedlineMode_t::REDLINE_SHOW_MASK & eTmpMode) !=
+            (nsRedlineMode_t::REDLINE_SHOW_MASK & m_eMode))
+        {
+            m_rRedlineAccess.SetRedlineMode( eTmpMode );
+        }
+        m_rRedlineAccess.SetRedlineMode_intern( static_cast<RedlineMode_t>(
+                eTmpMode | nsRedlineMode_t::REDLINE_IGNORE) );
+    }
+    ~UndoRedoRedlineGuard()
+    {
+        m_rRedlineAccess.SetRedlineMode(m_eMode);
+    }
+private:
+    IDocumentRedlineAccess & m_rRedlineAccess;
+    RedlineMode_t const m_eMode;
+};
+
+void SwUndo::Undo()
 {
-    rIter.pLastUndoObj = this;
+    OSL_ENSURE(false, "SwUndo::Undo(): ERROR: must call Undo(context) instead");
+}
+
+void SwUndo::Redo()
+{
+    OSL_ENSURE(false, "SwUndo::Redo(): ERROR: must call Redo(context) instead");
+}
+
+void SwUndo::UndoWithContext(SfxUndoContext & rContext)
+{
+    ::sw::UndoRedoContext *const pContext(
+            dynamic_cast< ::sw::UndoRedoContext * >(& rContext));
+    OSL_ASSERT(pContext);
+    if (!pContext) { return; }
+    UndoRedoRedlineGuard(*pContext, *this);
+    UndoImpl(*pContext);
+}
+
+void SwUndo::RedoWithContext(SfxUndoContext & rContext)
+{
+    ::sw::UndoRedoContext *const pContext(
+            dynamic_cast< ::sw::UndoRedoContext * >(& rContext));
+    OSL_ASSERT(pContext);
+    if (!pContext) { return; }
+    UndoRedoRedlineGuard(*pContext, *this);
+    RedoImpl(*pContext);
+}
+
+void SwUndo::Repeat(SfxRepeatTarget & rContext)
+{
+    ::sw::RepeatContext *const pRepeatContext(
+            dynamic_cast< ::sw::RepeatContext * >(& rContext));
+    OSL_ASSERT(pRepeatContext);
+    if (!pRepeatContext) { return; }
+    RepeatImpl(*pRepeatContext);
+}
+
+sal_Bool SwUndo::CanRepeat(SfxRepeatTarget & rContext) const
+{
+    ::sw::RepeatContext *const pRepeatContext(
+            dynamic_cast< ::sw::RepeatContext * >(& rContext));
+    OSL_ASSERT(pRepeatContext);
+    if (!pRepeatContext) { return false; }
+    return CanRepeatImpl(*pRepeatContext);
+}
+
+void SwUndo::RepeatImpl( ::sw::RepeatContext & )
+{
+}
+
+bool SwUndo::CanRepeatImpl( ::sw::RepeatContext & ) const
+{
+//    return false;
+    return ((REPEAT_START <= GetId()) && (GetId() < REPEAT_END));
 }
 
 String SwUndo::GetComment() const
@@ -228,7 +301,7 @@ String SwUndo::GetComment() const
     {
         if (! pComment)
         {
-            pComment = new String(SW_RES(UNDO_BASE + nId));
+            pComment = new String(SW_RES(UNDO_BASE + GetId()));
 
             SwRewriter aRewriter = GetRewriter();
 
@@ -239,7 +312,7 @@ String SwUndo::GetComment() const
     }
     else
     {
-        aResult = String(SW_RES(UNDO_BASE + nId));
+        aResult = String(SW_RES(UNDO_BASE + GetId()));
 
         SwRewriter aRewriter = GetRewriter();
 
@@ -249,11 +322,6 @@ String SwUndo::GetComment() const
     return aResult;
 }
 
-SwUndoId SwUndo::GetEffectiveId() const
-{
-    return GetId();
-}
-
 SwRewriter SwUndo::GetRewriter() const
 {
     SwRewriter aResult;
@@ -261,6 +329,7 @@ SwRewriter SwUndo::GetRewriter() const
     return aResult;
 }
 
+
 //------------------------------------------------------------
 
 SwUndoSaveCntnt::SwUndoSaveCntnt()
@@ -283,16 +352,15 @@ SwUndoSaveCntnt::~SwUndoSaveCntnt()
     //			aufgerufen. Dann soll die gesamte Section verschoben werden.
 
 void SwUndoSaveCntnt::MoveToUndoNds( SwPaM& rPaM, SwNodeIndex* pNodeIdx,
-                    SwIndex* pCntIdx, ULONG* pEndNdIdx, xub_StrLen* pEndCntIdx )
+                    SwIndex* pCntIdx, sal_uLong* pEndNdIdx, xub_StrLen* pEndCntIdx )
 {
     SwDoc& rDoc = *rPaM.GetDoc();
-    BOOL bUndo = rDoc.DoesUndo();
-    rDoc.DoUndo( FALSE );
+    ::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
 
     SwNoTxtNode* pCpyNd = rPaM.GetNode()->GetNoTxtNode();
 
     // jetzt kommt das eigentliche Loeschen(Verschieben)
-    SwNodes& rNds = (SwNodes&)*rDoc.GetUndoNds();
+    SwNodes & rNds = rDoc.GetUndoManager().GetUndoNodes();
     SwPosition aPos( pEndNdIdx ? rNds.GetEndOfPostIts()
                                : rNds.GetEndOfExtras() );
     aPos.nNode--;
@@ -311,14 +379,14 @@ void SwUndoSaveCntnt::MoveToUndoNds( SwPaM& rPaM, SwNodeIndex* pNodeIdx,
     else
         aPos.nNode.GetNode().GetCntntNode()->MakeEndIndex( &aPos.nContent );
 
-    // als USHORT merken; die Indizies verschieben sich !!
-    ULONG nTmpMvNode = aPos.nNode.GetIndex();
+    // als sal_uInt16 merken; die Indizies verschieben sich !!
+    sal_uLong nTmpMvNode = aPos.nNode.GetIndex();
     xub_StrLen nTmpMvCntnt = aPos.nContent.GetIndex();
 
     if( pCpyNd || pEndNdIdx )
     {
         SwNodeRange aRg( pStt->nNode, 0, pEnd->nNode, 1 );
-        rDoc.GetNodes()._MoveNodes( aRg, rNds, aPos.nNode, FALSE );
+        rDoc.GetNodes()._MoveNodes( aRg, rNds, aPos.nNode, sal_False );
         aPos.nContent = 0;
         aPos.nNode--;
     }
@@ -368,21 +436,18 @@ void SwUndoSaveCntnt::MoveToUndoNds( SwPaM& rPaM, SwNodeIndex* pNodeIdx,
         else
             pCntIdx->Assign( 0, 0 );
     }
-
-    rDoc.DoUndo( bUndo );
 }
 
-void SwUndoSaveCntnt::MoveFromUndoNds( SwDoc& rDoc, ULONG nNodeIdx,
+void SwUndoSaveCntnt::MoveFromUndoNds( SwDoc& rDoc, sal_uLong nNodeIdx,
                             xub_StrLen nCntIdx, SwPosition& rInsPos,
-                            ULONG* pEndNdIdx, xub_StrLen* pEndCntIdx )
+                            sal_uLong* pEndNdIdx, xub_StrLen* pEndCntIdx )
 {
     // jetzt kommt das wiederherstellen
-    SwNodes& rNds = (SwNodes&)*rDoc.GetUndoNds();
+    SwNodes & rNds = rDoc.GetUndoManager().GetUndoNodes();
     if( nNodeIdx == rNds.GetEndOfPostIts().GetIndex() )
         return;		// nichts gespeichert
 
-    BOOL bUndo = rDoc.DoesUndo();
-    rDoc.DoUndo( FALSE );
+    ::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
 
     SwPaM aPaM( rInsPos );
     if( pEndNdIdx )			// dann hole aus diesem den Bereich
@@ -435,10 +500,8 @@ void SwUndoSaveCntnt::MoveFromUndoNds( SwDoc& rDoc, ULONG nNodeIdx,
 
     }
     else {
-        OSL_ENSURE( FALSE, "was ist es denn nun?" );
+        OSL_ENSURE( sal_False, "was ist es denn nun?" );
     }
-
-    rDoc.DoUndo( bUndo );
 }
 
 // diese beiden Methoden bewegen den Point vom Pam zurueck/vor. Damit
@@ -446,21 +509,21 @@ void SwUndoSaveCntnt::MoveFromUndoNds( SwDoc& rDoc, ULONG nNodeIdx,
 // Point liegt dann vor dem manipuliertem Bereich !!)
 // Das Flag gibt an, ob noch vorm Point Inhalt steht.
 
-BOOL SwUndoSaveCntnt::MovePtBackward( SwPaM& rPam )
+sal_Bool SwUndoSaveCntnt::MovePtBackward( SwPaM& rPam )
 {
     rPam.SetMark();
     if( rPam.Move( fnMoveBackward ))
-        return TRUE;
+        return sal_True;
 
     // gibt es nach vorne keinen Inhalt mehr, so setze den Point einfach
     // auf die vorherige Position (Node und Content, damit der Content
     // abgemeldet wird !!)
     rPam.GetPoint()->nNode--;
     rPam.GetPoint()->nContent.Assign( 0, 0 );
-    return FALSE;
+    return sal_False;
 }
 
-void SwUndoSaveCntnt::MovePtForward( SwPaM& rPam, BOOL bMvBkwrd )
+void SwUndoSaveCntnt::MovePtForward( SwPaM& rPam, sal_Bool bMvBkwrd )
 {
     // gab es noch Inhalt vor der Position ?
     if( bMvBkwrd )
@@ -498,8 +561,7 @@ void SwUndoSaveCntnt::DelCntntIndex( const SwPosition& rMark,
 
     SwDoc* pDoc = rMark.nNode.GetNode().GetDoc();
 
-    BOOL bDoesUndo = pDoc->DoesUndo();
-    pDoc->DoUndo( FALSE );
+    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
 
     // 1. Fussnoten
     if( nsDelCntntType::DELCNT_FTN & nDelCntntType )
@@ -508,7 +570,7 @@ void SwUndoSaveCntnt::DelCntntIndex( const SwPosition& rMark,
         if( rFtnArr.Count() )
         {
             const SwNode* pFtnNd;
-            USHORT nPos;
+            sal_uInt16 nPos;
             rFtnArr.SeekEntry( pStt->nNode, &nPos );
             SwTxtFtn* pSrch;
 
@@ -571,14 +633,14 @@ void SwUndoSaveCntnt::DelCntntIndex( const SwPosition& rMark,
     // 2. Flys
     if( nsDelCntntType::DELCNT_FLY & nDelCntntType )
     {
-        USHORT nChainInsPos = pHistory ? pHistory->Count() : 0;
+        sal_uInt16 nChainInsPos = pHistory ? pHistory->Count() : 0;
         const SwSpzFrmFmts& rSpzArr = *pDoc->GetSpzFrmFmts();
         if( rSpzArr.Count() )
         {
-            const BOOL bDelFwrd = rMark.nNode.GetIndex() <= rPoint.nNode.GetIndex();
+            const sal_Bool bDelFwrd = rMark.nNode.GetIndex() <= rPoint.nNode.GetIndex();
             SwFlyFrmFmt* pFmt;
             const SwFmtAnchor* pAnchor;
-            USHORT n = rSpzArr.Count();
+            sal_uInt16 n = rSpzArr.Count();
             const SwPosition* pAPos;
 
             while( n && rSpzArr.Count() )
@@ -596,7 +658,8 @@ void SwUndoSaveCntnt::DelCntntIndex( const SwPosition& rMark,
                     {
                         if( !pHistory )
                             pHistory = new SwHistory;
-                        SwTxtNode* pTxtNd = pDoc->GetNodes()[ pAPos->nNode]->GetTxtNode();
+                        SwTxtNode *const pTxtNd =
+                            pAPos->nNode.GetNode().GetTxtNode();
                         SwTxtAttr* const pFlyHnt = pTxtNd->GetTxtAttrForCharAt(
                             pAPos->nContent.GetIndex());
                         OSL_ENSURE( pFlyHnt, "kein FlyAttribut" );
@@ -711,7 +774,7 @@ void SwUndoSaveCntnt::DelCntntIndex( const SwPosition& rMark,
         if( pMarkAccess->getMarksCount() )
         {
 
-            for( USHORT n = 0; n < pMarkAccess->getMarksCount(); ++n )
+            for( sal_uInt16 n = 0; n < pMarkAccess->getMarksCount(); ++n )
             {
                 // --> OD 2007-10-17 #i81002#
                 bool bSavePos = false;
@@ -810,8 +873,6 @@ void SwUndoSaveCntnt::DelCntntIndex( const SwPosition& rMark,
             }
         }
     }
-
-    pDoc->DoUndo( bDoesUndo );
 }
 
 
@@ -850,7 +911,7 @@ void SwUndoSaveSection::SaveSection( SwDoc* , const SwNodeRange& rRange )
     DelCntntIndex( *aPam.GetMark(), *aPam.GetPoint() );
 
     pRedlSaveData = new SwRedlineSaveDatas;
-    if( !SwUndo::FillSaveData( aPam, *pRedlSaveData, TRUE, TRUE ))
+    if( !SwUndo::FillSaveData( aPam, *pRedlSaveData, sal_True, sal_True ))
         delete pRedlSaveData, pRedlSaveData = 0;
 
     nStartPos = rRange.aStart.GetIndex();
@@ -858,29 +919,29 @@ void SwUndoSaveSection::SaveSection( SwDoc* , const SwNodeRange& rRange )
     aPam.GetPoint()->nNode--;
     aPam.GetMark()->nNode++;
 
-    SwCntntNode* pCNd = aPam.GetCntntNode( FALSE );
+    SwCntntNode* pCNd = aPam.GetCntntNode( sal_False );
     if( pCNd )
         aPam.GetMark()->nContent.Assign( pCNd, 0 );
-    if( 0 != ( pCNd = aPam.GetCntntNode( TRUE )) )
+    if( 0 != ( pCNd = aPam.GetCntntNode( sal_True )) )
         aPam.GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
 
     // Positionen als SwIndex merken, damit im DTOR dieser Bereich
     // entfernt werden kann !!
-    ULONG nEnd;
+    sal_uLong nEnd;
     pMvStt = new SwNodeIndex( rRange.aStart );
     MoveToUndoNds( aPam, pMvStt, 0, &nEnd, 0 );
     nMvLen = nEnd - pMvStt->GetIndex() + 1;
 }
 
 void SwUndoSaveSection::RestoreSection( SwDoc* pDoc, SwNodeIndex* pIdx,
-                                        USHORT nSectType )
+                                        sal_uInt16 nSectType )
 {
     if( ULONG_MAX != nStartPos )		// gab es ueberhaupt Inhalt ?
     {
         // ueberpruefe, ob der Inhalt an der alten Position steht
         SwNodeIndex aSttIdx( pDoc->GetNodes(), nStartPos );
-        OSL_ENSURE( !pDoc->GetNodes()[ aSttIdx ]->GetCntntNode(),
-                "Position in irgendeiner Section" );
+//        OSL_ENSURE( !pDoc->GetNodes()[ aSttIdx ]->GetCntntNode(),
+//                "RestoreSection(): Position on content node");
 
         // move den Inhalt aus dem UndoNodes-Array in den Fly
         SwStartNode* pSttNd = pDoc->GetNodes().MakeEmptySection( aSttIdx,
@@ -898,7 +959,7 @@ void SwUndoSaveSection::RestoreSection( SwDoc* pDoc, const SwNodeIndex& rInsPos
     if( ULONG_MAX != nStartPos )		// gab es ueberhaupt Inhalt ?
     {
         SwPosition aInsPos( rInsPos );
-        ULONG nEnd = pMvStt->GetIndex() + nMvLen - 1;
+        sal_uLong nEnd = pMvStt->GetIndex() + nMvLen - 1;
         MoveFromUndoNds( *pDoc, pMvStt->GetIndex(), 0, aInsPos, &nEnd, 0 );
 
         // Indizies wieder zerstoren, Inhalt ist aus dem UndoNodes-Array
@@ -914,135 +975,13 @@ void SwUndoSaveSection::RestoreSection( SwDoc* pDoc, const SwNodeIndex& rInsPos
     }
 }
 
-// START
-SwUndoStart::SwUndoStart( SwUndoId nInitId )
-    : SwUndo( UNDO_START ), nUserId( nInitId ), nEndOffset( 0 )
-{
-}
-
-void SwUndoStart::Undo( SwUndoIter& rUndoIter )
-{
-    if( !( --rUndoIter.nEndCnt ) && rUndoIter.bWeiter &&
-        ( rUndoIter.GetId() ? ( rUndoIter.GetId() == nUserId ||
-        ( UNDO_END == rUndoIter.GetId() && UNDO_START == GetId() )) : TRUE ))
-        rUndoIter.bWeiter = FALSE;
-}
-
-void SwUndoStart::Redo( SwUndoIter& rUndoIter )
-{
-    rUndoIter.bWeiter = TRUE;
-    ++rUndoIter.nEndCnt;
-}
-
-void SwUndoStart::Repeat( SwUndoIter& rUndoIter )
-{
-    rUndoIter.bWeiter = FALSE;
-}
-
-String SwUndoStart::GetComment() const
-{
-    String sResult;
-
-    switch (nUserId)
-    {
-    case UNDO_START:
-    case UNDO_END:
-        sResult = String("??", RTL_TEXTENCODING_ASCII_US);
-
-        break;
-
-    default:
-        sResult = String(SW_RES(UNDO_BASE + nUserId));
-        sResult = GetRewriter().Apply(sResult);
-    }
-
-    return sResult;
-}
-
-SwRewriter SwUndoStart::GetRewriter() const
-{
-    return mRewriter;
-}
-
-SwUndoId SwUndoStart::GetEffectiveId() const
-{
-    return GetUserId();
-}
-
-void SwUndoStart::SetRewriter(const SwRewriter & rRewriter)
-{
-    mRewriter = rRewriter;
-}
-
-// END
-SwUndoEnd::SwUndoEnd( SwUndoId nInitId )
-    : SwUndo( UNDO_END ), nUserId( nInitId ), nSttOffset( 0 )
-{
-}
-
-void SwUndoEnd::Undo( SwUndoIter& rUndoIter )
-{
-    if( rUndoIter.GetId() == GetId() || !rUndoIter.GetId() )
-        rUndoIter.bWeiter = TRUE;
-    if( rUndoIter.bWeiter )
-        ++rUndoIter.nEndCnt;
-}
-
-void SwUndoEnd::Redo( SwUndoIter& rUndoIter )
-{
-    if( !( --rUndoIter.nEndCnt ) && rUndoIter.bWeiter &&
-        ( rUndoIter.GetId() ? ( rUndoIter.GetId() == nUserId ||
-        ( UNDO_END == rUndoIter.GetId() && UNDO_START == GetId() )) : TRUE ))
-        rUndoIter.bWeiter = FALSE;
-}
-
-void SwUndoEnd::Repeat( SwUndoIter& rUndoIter )
-{
-    rUndoIter.bWeiter = FALSE;
-}
-
-String SwUndoEnd::GetComment() const
-{
-    String sResult;
-
-    switch (nUserId)
-    {
-    case UNDO_START:
-    case UNDO_END:
-        sResult = String("??", RTL_TEXTENCODING_ASCII_US);
-
-        break;
-    default:
-        sResult = SW_RES(UNDO_BASE + nUserId);
-        sResult = GetRewriter().Apply(sResult);
-    }
-
-    return sResult;
-}
-
-void SwUndoEnd::SetRewriter(const SwRewriter & rRewriter)
-{
-    mRewriter = rRewriter;
-}
-
-SwUndoId SwUndoEnd::GetEffectiveId() const
-{
-    return GetUserId();
-}
-
-SwRewriter SwUndoEnd::GetRewriter() const
-{
-    return mRewriter;
-}
-
-/*  */
         // sicher und setze die RedlineDaten
 
 SwRedlineSaveData::SwRedlineSaveData( SwComparePosition eCmpPos,
                                         const SwPosition& rSttPos,
                                         const SwPosition& rEndPos,
                                         SwRedline& rRedl,
-                                        BOOL bCopyNext )
+                                        sal_Bool bCopyNext )
     : SwUndRng( rRedl ),
     SwRedlineData( rRedl.GetRedlineData(), bCopyNext )
 {
@@ -1126,8 +1065,8 @@ void SwRedlineSaveData::RedlineToDoc( SwPaM& rPam )
     rDoc.SetRedlineMode_intern( eOld );
 }
 
-BOOL SwUndo::FillSaveData( const SwPaM& rRange, SwRedlineSaveDatas& rSData,
-                            BOOL bDelRange, BOOL bCopyNext )
+sal_Bool SwUndo::FillSaveData( const SwPaM& rRange, SwRedlineSaveDatas& rSData,
+                            sal_Bool bDelRange, sal_Bool bCopyNext )
 {
     if( rSData.Count() )
         rSData.DeleteAndDestroy( 0, rSData.Count() );
@@ -1135,7 +1074,7 @@ BOOL SwUndo::FillSaveData( const SwPaM& rRange, SwRedlineSaveDatas& rSData,
     SwRedlineSaveData* pNewData;
     const SwPosition *pStt = rRange.Start(), *pEnd = rRange.End();
     const SwRedlineTbl& rTbl = rRange.GetDoc()->GetRedlineTbl();
-    USHORT n = 0;
+    sal_uInt16 n = 0;
     rRange.GetDoc()->GetRedline( *pStt, &n );
     for( ; n < rTbl.Count(); ++n )
     {
@@ -1156,7 +1095,7 @@ BOOL SwUndo::FillSaveData( const SwPaM& rRange, SwRedlineSaveDatas& rSData,
     return 0 != rSData.Count();
 }
 
-BOOL SwUndo::FillSaveDataForFmt( const SwPaM& rRange, SwRedlineSaveDatas& rSData )
+sal_Bool SwUndo::FillSaveDataForFmt( const SwPaM& rRange, SwRedlineSaveDatas& rSData )
 {
     if( rSData.Count() )
         rSData.DeleteAndDestroy( 0, rSData.Count() );
@@ -1164,7 +1103,7 @@ BOOL SwUndo::FillSaveDataForFmt( const SwPaM& rRange, SwRedlineSaveDatas& rSData
     SwRedlineSaveData* pNewData;
     const SwPosition *pStt = rRange.Start(), *pEnd = rRange.End();
     const SwRedlineTbl& rTbl = rRange.GetDoc()->GetRedlineTbl();
-    USHORT n = 0;
+    sal_uInt16 n = 0;
     rRange.GetDoc()->GetRedline( *pStt, &n );
     for( ; n < rTbl.Count(); ++n )
     {
@@ -1178,7 +1117,7 @@ BOOL SwUndo::FillSaveDataForFmt( const SwPaM& rRange, SwRedlineSaveDatas& rSData
                 POS_COLLIDE_END != eCmpPos && POS_COLLIDE_START != eCmpPos )
             {
                 pNewData = new SwRedlineSaveData( eCmpPos, *pStt, *pEnd,
-                                                    *pRedl, TRUE );
+                                                    *pRedl, sal_True );
                 rSData.Insert( pNewData, rSData.Count() );
             }
 
@@ -1194,7 +1133,7 @@ void SwUndo::SetSaveData( SwDoc& rDoc, const SwRedlineSaveDatas& rSData )
     rDoc.SetRedlineMode_intern( (RedlineMode_t)(( eOld & ~nsRedlineMode_t::REDLINE_IGNORE) | nsRedlineMode_t::REDLINE_ON ));
     SwPaM aPam( rDoc.GetNodes().GetEndOfContent() );
 
-    for( USHORT n = rSData.Count(); n; )
+    for( sal_uInt16 n = rSData.Count(); n; )
         rSData[ --n ]->RedlineToDoc( aPam );
 
 #if OSL_DEBUG_LEVEL > 1
@@ -1207,23 +1146,23 @@ void SwUndo::SetSaveData( SwDoc& rDoc, const SwRedlineSaveDatas& rSData )
     rDoc.SetRedlineMode_intern( eOld );
 }
 
-BOOL SwUndo::HasHiddenRedlines( const SwRedlineSaveDatas& rSData )
+sal_Bool SwUndo::HasHiddenRedlines( const SwRedlineSaveDatas& rSData )
 {
-    for( USHORT n = rSData.Count(); n; )
+    for( sal_uInt16 n = rSData.Count(); n; )
         if( rSData[ --n ]->GetMvSttIdx() )
-            return TRUE;
-    return FALSE;
+            return sal_True;
+    return sal_False;
 }
 
-BOOL SwUndo::CanRedlineGroup( SwRedlineSaveDatas& rCurr,
-                        const SwRedlineSaveDatas& rCheck, BOOL bCurrIsEnd )
+sal_Bool SwUndo::CanRedlineGroup( SwRedlineSaveDatas& rCurr,
+                        const SwRedlineSaveDatas& rCheck, sal_Bool bCurrIsEnd )
 {
-    BOOL bRet = FALSE;
-    USHORT n;
+    sal_Bool bRet = sal_False;
+    sal_uInt16 n;
 
     if( rCurr.Count() == rCheck.Count() )
     {
-        bRet = TRUE;
+        bRet = sal_True;
         for( n = 0; n < rCurr.Count(); ++n )
         {
             const SwRedlineSaveData& rSet = *rCurr[ n ];
@@ -1234,7 +1173,7 @@ BOOL SwUndo::CanRedlineGroup( SwRedlineSaveDatas& rCurr,
                              : rSet.nEndCntnt != rGet.nSttCntnt ) ||
                 !rGet.CanCombine( rSet ) )
             {
-                bRet = FALSE;
+                bRet = sal_False;
                 break;
             }
         }
diff --git a/sw/source/core/undo/undobj1.cxx b/sw/source/core/undo/undobj1.cxx
index 7e8f6d7331..da93282b0d 100644
--- a/sw/source/core/undo/undobj1.cxx
+++ b/sw/source/core/undo/undobj1.cxx
@@ -29,16 +29,18 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <svl/itemiter.hxx>
 
 #include <hintids.hxx>
-#include <svl/itemiter.hxx>
+#include <hints.hxx>
 #include <fmtflcnt.hxx>
 #include <fmtanchr.hxx>
 #include <fmtcntnt.hxx>
 #include <txtflcnt.hxx>
 #include <frmfmt.hxx>
 #include <flyfrm.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
+#include <UndoDraw.hxx>
 #include <rolbck.hxx>	  	// fuer die Attribut History
 #include <doc.hxx>
 #include <docary.hxx>
@@ -50,10 +52,9 @@
 #include <dcontact.hxx>
 #include <ndole.hxx>
 
-// Inline Methode vom UndoIter
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
 
 //---------------------------------------------------------------------
+// SwUndoLayBase /////////////////////////////////////////////////////////
 
 SwUndoFlyBase::SwUndoFlyBase( SwFrmFmt* pFormat, SwUndoId nUndoId )
     : SwUndo( nUndoId ), pFrmFmt( pFormat )
@@ -66,9 +67,9 @@ SwUndoFlyBase::~SwUndoFlyBase()
         delete pFrmFmt;
 }
 
-void SwUndoFlyBase::InsFly( SwUndoIter& rUndoIter, BOOL bShowSelFrm )
+void SwUndoFlyBase::InsFly(::sw::UndoRedoContext & rContext, bool bShowSelFrm)
 {
-    SwDoc* pDoc = &rUndoIter.GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
 
     // ins Array wieder eintragen
     SwSpzFrmFmts& rFlyFmts = *(SwSpzFrmFmts*)pDoc->GetSpzFrmFmts();
@@ -93,11 +94,11 @@ void SwUndoFlyBase::InsFly( SwUndoIter& rUndoIter, BOOL bShowSelFrm )
 
     if (FLY_AT_PAGE == nRndId)
     {
-        aAnchor.SetPageNum( (USHORT)nNdPgPos );
+        aAnchor.SetPageNum( (sal_uInt16)nNdPgPos );
     }
     else
     {
-        SwPosition aNewPos( *rUndoIter.pAktPam->GetPoint() );
+        SwPosition aNewPos(pDoc->GetNodes().GetEndOfContent());
         aNewPos.nNode = nNdPgPos;
         if ((FLY_AS_CHAR == nRndId) || (FLY_AT_CHAR == nRndId))
         {
@@ -133,7 +134,9 @@ void SwUndoFlyBase::InsFly( SwUndoIter& rUndoIter, BOOL bShowSelFrm )
     pFrmFmt->MakeFrms();
 
     if( bShowSelFrm )
-        rUndoIter.pSelFmt = pFrmFmt;
+    {
+        rContext.SetSelections(pFrmFmt, 0);
+    }
 
     if( GetHistory() )
         GetHistory()->Rollback( pDoc );
@@ -158,12 +161,12 @@ void SwUndoFlyBase::InsFly( SwUndoIter& rUndoIter, BOOL bShowSelFrm )
     case FLY_AT_PAGE:
         break;
     }
-    bDelFmt =  FALSE;
+    bDelFmt =  sal_False;
 }
 
 void SwUndoFlyBase::DelFly( SwDoc* pDoc )
 {
-    bDelFmt = TRUE; 					// im DTOR das Format loeschen
+    bDelFmt = sal_True; 					// im DTOR das Format loeschen
     pFrmFmt->DelFrms(); 				// Frms vernichten.
 
     // alle Uno-Objecte sollten sich jetzt abmelden
@@ -195,12 +198,12 @@ void SwUndoFlyBase::DelFly( SwDoc* pDoc )
     const SwFmtAnchor& rAnchor = pFrmFmt->GetAnchor();
     const SwPosition* pPos = rAnchor.GetCntntAnchor();
     // die Positionen im Nodes-Array haben sich verschoben
-    nRndId = static_cast<USHORT>(rAnchor.GetAnchorId());
+    nRndId = static_cast<sal_uInt16>(rAnchor.GetAnchorId());
     if (FLY_AS_CHAR == nRndId)
     {
         nNdPgPos = pPos->nNode.GetIndex();
         nCntPos = pPos->nContent.GetIndex();
-        SwTxtNode *pTxtNd = pDoc->GetNodes()[ pPos->nNode ]->GetTxtNode();
+        SwTxtNode *const pTxtNd = pPos->nNode.GetNode().GetTxtNode();
         OSL_ENSURE( pTxtNd, "Kein Textnode gefunden" );
         SwTxtFlyCnt* const pAttr = static_cast<SwTxtFlyCnt*>(
             pTxtNd->GetTxtAttrForCharAt( nCntPos, RES_TXTATR_FLYCNT ) );
@@ -235,16 +238,16 @@ void SwUndoFlyBase::DelFly( SwDoc* pDoc )
     rFlyFmts.Remove( rFlyFmts.GetPos( pFrmFmt ));
 }
 
-// ----- Undo-InsertFly ------
+// SwUndoInsLayFmt ///////////////////////////////////////////////////////
 
-SwUndoInsLayFmt::SwUndoInsLayFmt( SwFrmFmt* pFormat, ULONG nNodeIdx, xub_StrLen nCntIdx )
+SwUndoInsLayFmt::SwUndoInsLayFmt( SwFrmFmt* pFormat, sal_uLong nNodeIdx, xub_StrLen nCntIdx )
     : SwUndoFlyBase( pFormat, RES_DRAWFRMFMT == pFormat->Which() ?
                                             UNDO_INSDRAWFMT : UNDO_INSLAYFMT ),
     mnCrsrSaveIndexPara( nNodeIdx ), mnCrsrSaveIndexPos( nCntIdx )
 {
     const SwFmtAnchor& rAnchor = pFrmFmt->GetAnchor();
-    nRndId = static_cast<USHORT>(rAnchor.GetAnchorId());
-    bDelFmt = FALSE;
+    nRndId = static_cast<sal_uInt16>(rAnchor.GetAnchorId());
+    bDelFmt = sal_False;
     switch( nRndId )
     {
     case FLY_AT_PAGE:
@@ -263,7 +266,7 @@ SwUndoInsLayFmt::SwUndoInsLayFmt( SwFrmFmt* pFormat, ULONG nNodeIdx, xub_StrLen
         }
         break;
     default:
-        OSL_ENSURE( FALSE, "Was denn fuer ein FlyFrame?" );
+        OSL_ENSURE( sal_False, "Was denn fuer ein FlyFrame?" );
     }
 }
 
@@ -271,52 +274,52 @@ SwUndoInsLayFmt::~SwUndoInsLayFmt()
 {
 }
 
-void SwUndoInsLayFmt::Undo( SwUndoIter& rUndoIter )
+void SwUndoInsLayFmt::UndoImpl(::sw::UndoRedoContext & rContext)
 {
+    SwDoc & rDoc(rContext.GetDoc());
     const SwFmtCntnt& rCntnt = pFrmFmt->GetCntnt();
     if( rCntnt.GetCntntIdx() ) 	// kein Inhalt
     {
         bool bRemoveIdx = true;
         if( mnCrsrSaveIndexPara > 0 )
         {
-            SwTxtNode *pNode = rUndoIter.GetDoc().GetNodes()[mnCrsrSaveIndexPara]->GetTxtNode();
+            SwTxtNode *const pNode =
+                rDoc.GetNodes()[mnCrsrSaveIndexPara]->GetTxtNode();
             if( pNode )
             {
-                SwNodeIndex aIdx( rUndoIter.GetDoc().GetNodes(), rCntnt.GetCntntIdx()->GetIndex() );
-                SwNodeIndex aEndIdx( rUndoIter.GetDoc().GetNodes(), aIdx.GetNode().EndOfSectionIndex() );
+                SwNodeIndex aIdx( rDoc.GetNodes(),
+                        rCntnt.GetCntntIdx()->GetIndex() );
+                SwNodeIndex aEndIdx( rDoc.GetNodes(),
+                        aIdx.GetNode().EndOfSectionIndex() );
                 SwIndex aIndex( pNode, mnCrsrSaveIndexPos );
                 SwPosition aPos( *pNode, aIndex );
-                rUndoIter.GetDoc().CorrAbs( aIdx, aEndIdx, aPos, TRUE );
+                rDoc.CorrAbs( aIdx, aEndIdx, aPos, sal_True );
                 bRemoveIdx = false;
             }
         }
         if( bRemoveIdx )
-            RemoveIdxFromSection( rUndoIter.GetDoc(),
-                                rCntnt.GetCntntIdx()->GetIndex() );
+        {
+            RemoveIdxFromSection( rDoc, rCntnt.GetCntntIdx()->GetIndex() );
+        }
     }
-    DelFly( &rUndoIter.GetDoc() );
+    DelFly(& rDoc);
 }
 
-void SwUndoInsLayFmt::Redo( SwUndoIter& rUndoIter )
+void SwUndoInsLayFmt::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    rUndoIter.pLastUndoObj = 0;
-    InsFly( rUndoIter );
+    InsFly(rContext);
 }
 
-void SwUndoInsLayFmt::Repeat( SwUndoIter& rUndoIter )
+void SwUndoInsLayFmt::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    if( UNDO_INSLAYFMT == rUndoIter.GetLastUndoId() &&
-        pFrmFmt == ((SwUndoInsLayFmt*)rUndoIter.pLastUndoObj)->pFrmFmt )
-        return;
-
-    SwDoc* pDoc = &rUndoIter.GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
     // erfrage und setze den Anker neu
     SwFmtAnchor aAnchor( pFrmFmt->GetAnchor() );
     if ((FLY_AT_PARA == aAnchor.GetAnchorId()) ||
         (FLY_AT_CHAR == aAnchor.GetAnchorId()) ||
         (FLY_AS_CHAR == aAnchor.GetAnchorId()))
     {
-        SwPosition aPos( *rUndoIter.pAktPam->GetPoint() );
+        SwPosition aPos( *rContext.GetRepeatPaM().GetPoint() );
         if (FLY_AT_PARA == aAnchor.GetAnchorId())
         {
             aPos.nContent.Assign( 0, 0 );
@@ -325,7 +328,8 @@ void SwUndoInsLayFmt::Repeat( SwUndoIter& rUndoIter )
     }
     else if( FLY_AT_FLY == aAnchor.GetAnchorId() )
     {
-        const SwStartNode* pSttNd = rUndoIter.pAktPam->GetNode()->FindFlyStartNode();
+        SwStartNode const*const pSttNd =
+            rContext.GetRepeatPaM().GetNode()->FindFlyStartNode();
         if( pSttNd )
         {
             SwPosition aPos( *pSttNd );
@@ -333,23 +337,22 @@ void SwUndoInsLayFmt::Repeat( SwUndoIter& rUndoIter )
         }
         else
         {
-            rUndoIter.pLastUndoObj = this;
             return ;
         }
     }
     else if (FLY_AT_PAGE == aAnchor.GetAnchorId())
     {
-        aAnchor.SetPageNum( pDoc->GetRootFrm()->GetCurrPage(
-                                        rUndoIter.pAktPam ));
+        aAnchor.SetPageNum(
+                pDoc->GetRootFrm()->GetCurrPage(& rContext.GetRepeatPaM()) );
     }
     else {
-        OSL_ENSURE( FALSE, "was fuer ein Anker ist es denn nun?" );
+        OSL_ENSURE( sal_False, "was fuer ein Anker ist es denn nun?" );
     }
 
     SwFrmFmt* pFlyFmt = pDoc->CopyLayoutFmt( *pFrmFmt, aAnchor, true, true );
-    rUndoIter.pSelFmt = pFlyFmt;
-
-    rUndoIter.pLastUndoObj = this;
+    (void) pFlyFmt;
+//FIXME nobody ever did anything with this selection:
+//    rContext.SetSelections(pFlyFmt, 0);
 }
 
 // #111827#
@@ -357,7 +360,12 @@ String SwUndoInsLayFmt::GetComment() const
 {
     String aResult;
 
-    if (! pComment)
+    // HACK: disable caching:
+    // the SfxUndoManager calls GetComment() too early: the pFrmFmt does not
+    // have a SwDrawContact yet, so it will fall back to SwUndo::GetComment(),
+    // which sets pComment to a wrong value.
+//    if (! pComment)
+    if (true)
     {
         /*
           If frame format is present and has an SdrObject use the undo
@@ -384,28 +392,37 @@ String SwUndoInsLayFmt::GetComment() const
     return aResult;
 }
 
-// ----- Undo-DeleteFly ------
+// SwUndoDelLayFmt ///////////////////////////////////////////////////////
 
-SwUndoDelLayFmt::SwUndoDelLayFmt( SwFrmFmt* pFormat )
-    : SwUndoFlyBase( pFormat, UNDO_DELLAYFMT ), bShowSelFrm( TRUE )
+static SwUndoId
+lcl_GetSwUndoId(SwFrmFmt *const pFrmFmt)
 {
-    SwDoc* pDoc = pFormat->GetDoc();
-    DelFly( pDoc );
-
-    SwNodeIndex* pIdx = GetMvSttIdx();
-    SwNode* pNd;
-    if( 1 == GetMvNodeCnt() && pIdx &&
-        ( pNd = (*pDoc->GetUndoNds())[ *pIdx ] )->IsNoTxtNode() )
+    if (RES_DRAWFRMFMT != pFrmFmt->Which())
     {
-        // dann setze eine andere Undo-ID; Grafik oder OLE
-        if( pNd->IsGrfNode() )
-            SetId( UNDO_DELGRF );
-        else if( pNd->IsOLENode() )
-        {
-            SetId( UNDO_DELETE );
+        const SwFmtCntnt& rCntnt = pFrmFmt->GetCntnt();
+        OSL_ENSURE( rCntnt.GetCntntIdx(), "Fly without content" );
 
+        SwNodeIndex firstNode(*rCntnt.GetCntntIdx(), 1);
+        SwNoTxtNode *const pNoTxtNode(firstNode.GetNode().GetNoTxtNode());
+        if (pNoTxtNode && pNoTxtNode->IsGrfNode())
+        {
+            return UNDO_DELGRF;
+        }
+        else if (pNoTxtNode && pNoTxtNode->IsOLENode())
+        {
+            // surprisingly not UNDO_DELOLE, which does not seem to work
+            return UNDO_DELETE;
         }
     }
+    return UNDO_DELLAYFMT;
+}
+
+SwUndoDelLayFmt::SwUndoDelLayFmt( SwFrmFmt* pFormat )
+    : SwUndoFlyBase( pFormat, lcl_GetSwUndoId(pFormat) )
+    , bShowSelFrm( sal_True )
+{
+    SwDoc* pDoc = pFormat->GetDoc();
+    DelFly( pDoc );
 }
 
 SwRewriter SwUndoDelLayFmt::GetRewriter() const
@@ -419,7 +436,7 @@ SwRewriter SwUndoDelLayFmt::GetRewriter() const
         SwNodeIndex* pIdx = GetMvSttIdx();
         if( 1 == GetMvNodeCnt() && pIdx)
         {
-            SwNode * pNd = (*pDoc->GetUndoNds())[ *pIdx ];
+            SwNode *const pNd = & pIdx->GetNode();
 
             if ( pNd->IsNoTxtNode() && pNd->IsOLENode())
             {
@@ -433,22 +450,24 @@ SwRewriter SwUndoDelLayFmt::GetRewriter() const
     return aRewriter;
 }
 
-void SwUndoDelLayFmt::Undo( SwUndoIter& rUndoIter )
+void SwUndoDelLayFmt::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    InsFly( rUndoIter, bShowSelFrm );
+    InsFly( rContext, bShowSelFrm );
 }
 
-void SwUndoDelLayFmt::Redo( SwUndoIter& rUndoIter )
+void SwUndoDelLayFmt::RedoImpl(::sw::UndoRedoContext & rContext)
 {
+    SwDoc & rDoc(rContext.GetDoc());
     const SwFmtCntnt& rCntnt = pFrmFmt->GetCntnt();
     if( rCntnt.GetCntntIdx() ) 	// kein Inhalt
-        RemoveIdxFromSection( rUndoIter.GetDoc(),
-                                rCntnt.GetCntntIdx()->GetIndex() );
+    {
+        RemoveIdxFromSection(rDoc, rCntnt.GetCntntIdx()->GetIndex());
+    }
 
-    DelFly( &rUndoIter.GetDoc() );
+    DelFly(& rDoc);
 }
 
-void SwUndoDelLayFmt::Redo()
+void SwUndoDelLayFmt::RedoForRollback()
 {
     const SwFmtCntnt& rCntnt = pFrmFmt->GetCntnt();
     if( rCntnt.GetCntntIdx() ) 	// kein Inhalt
@@ -458,7 +477,7 @@ void SwUndoDelLayFmt::Redo()
     DelFly( pFrmFmt->GetDoc() );
 }
 
-/*  */
+// SwUndoSetFlyFmt ///////////////////////////////////////////////////////
 
 SwUndoSetFlyFmt::SwUndoSetFlyFmt( SwFrmFmt& rFlyFmt, SwFrmFmt& rNewFrmFmt )
     : SwUndo( UNDO_SETFLYFRMFMT ), SwClient( &rFlyFmt ), pFrmFmt( &rFlyFmt ),
@@ -467,7 +486,7 @@ SwUndoSetFlyFmt::SwUndoSetFlyFmt( SwFrmFmt& rFlyFmt, SwFrmFmt& rNewFrmFmt )
                                 rFlyFmt.GetAttrSet().GetRanges() )),
     nOldNode( 0 ), nNewNode( 0 ),
     nOldCntnt( 0 ), nNewCntnt( 0 ),
-    nOldAnchorTyp( 0 ),	nNewAnchorTyp( 0 ), bAnchorChgd( FALSE )
+    nOldAnchorTyp( 0 ),	nNewAnchorTyp( 0 ), bAnchorChgd( sal_False )
 {
 }
 
@@ -488,7 +507,7 @@ SwUndoSetFlyFmt::~SwUndoSetFlyFmt()
 }
 
 void SwUndoSetFlyFmt::GetAnchor( SwFmtAnchor& rAnchor,
-                                ULONG nNode, xub_StrLen nCntnt )
+                                sal_uLong nNode, xub_StrLen nCntnt )
 {
     RndStdIds nAnchorTyp = rAnchor.GetAnchorId();
     if (FLY_AT_PAGE != nAnchorTyp)
@@ -534,9 +553,9 @@ void SwUndoSetFlyFmt::GetAnchor( SwFmtAnchor& rAnchor,
         rAnchor.SetPageNum( nCntnt );
 }
 
-void SwUndoSetFlyFmt::Undo( SwUndoIter& rIter )
+void SwUndoSetFlyFmt::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     // ist das neue Format noch vorhanden ??
     if( USHRT_MAX != rDoc.GetFrmFmts()->GetPos( (const SwFrmFmtPtr)pOldFmt ) )
@@ -604,13 +623,13 @@ void SwUndoSetFlyFmt::Undo( SwUndoIter& rIter )
 
             pFrmFmt->MakeFrms();
         }
-        rIter.pSelFmt = pFrmFmt;
+        rContext.SetSelections(pFrmFmt, 0);
     }
 }
 
-void SwUndoSetFlyFmt::Redo( SwUndoIter& rIter )
+void SwUndoSetFlyFmt::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     // ist das neue Format noch vorhanden ??
     if( USHRT_MAX != rDoc.GetFrmFmts()->GetPos( (const SwFrmFmtPtr)pNewFmt ) )
@@ -627,11 +646,11 @@ void SwUndoSetFlyFmt::Redo( SwUndoIter& rIter )
         else
             rDoc.SetFrmFmtToFly( *pFrmFmt, *pNewFmt, 0 );
 
-        rIter.pSelFmt = pFrmFmt;
+        rContext.SetSelections(pFrmFmt, 0);
     }
 }
 
-void SwUndoSetFlyFmt::PutAttr( USHORT nWhich, const SfxPoolItem* pItem )
+void SwUndoSetFlyFmt::PutAttr( sal_uInt16 nWhich, const SfxPoolItem* pItem )
 {
     if( pItem && pItem != GetDfltAttr( nWhich ) )
     {
@@ -641,10 +660,10 @@ void SwUndoSetFlyFmt::PutAttr( USHORT nWhich, const SfxPoolItem* pItem )
             // nur den 1. Ankerwechsel vermerken
             OSL_ENSURE( !bAnchorChgd, "mehrfacher Ankerwechsel nicht erlaubt!" );
 
-            bAnchorChgd = TRUE;
+            bAnchorChgd = sal_True;
 
             const SwFmtAnchor* pAnchor = (SwFmtAnchor*)pItem;
-            switch( nOldAnchorTyp = static_cast<USHORT>(pAnchor->GetAnchorId()) )
+            switch( nOldAnchorTyp = static_cast<sal_uInt16>(pAnchor->GetAnchorId()) )
             {
             case FLY_AS_CHAR:
             case FLY_AT_CHAR:
@@ -659,7 +678,7 @@ void SwUndoSetFlyFmt::PutAttr( USHORT nWhich, const SfxPoolItem* pItem )
             }
 
             pAnchor = (SwFmtAnchor*)&pFrmFmt->GetAnchor();
-            switch( nNewAnchorTyp = static_cast<USHORT>(pAnchor->GetAnchorId()) )
+            switch( nNewAnchorTyp = static_cast<sal_uInt16>(pAnchor->GetAnchorId()) )
             {
             case FLY_AS_CHAR:
             case FLY_AT_CHAR:
@@ -684,7 +703,7 @@ void SwUndoSetFlyFmt::Modify( SfxPoolItem* pOld, SfxPoolItem* )
 {
     if( pOld )
     {
-        USHORT nWhich = pOld->Which();
+        sal_uInt16 nWhich = pOld->Which();
 
         if( nWhich < POOLATTR_END )
             PutAttr( nWhich, pOld );
diff --git a/sw/source/core/undo/undoflystrattr.cxx b/sw/source/core/undo/undoflystrattr.cxx
index 072115ec67..a89a21eece 100644
--- a/sw/source/core/undo/undoflystrattr.cxx
+++ b/sw/source/core/undo/undoflystrattr.cxx
@@ -50,7 +50,7 @@ SwUndoFlyStrAttr::~SwUndoFlyStrAttr()
 {
 }
 
-void SwUndoFlyStrAttr::Undo( SwUndoIter& )
+void SwUndoFlyStrAttr::UndoImpl(::sw::UndoRedoContext &)
 {
     switch ( GetId() )
     {
@@ -70,7 +70,7 @@ void SwUndoFlyStrAttr::Undo( SwUndoIter& )
     }
 }
 
-void SwUndoFlyStrAttr::Redo( SwUndoIter& )
+void SwUndoFlyStrAttr::RedoImpl(::sw::UndoRedoContext &)
 {
     switch ( GetId() )
     {
@@ -90,11 +90,6 @@ void SwUndoFlyStrAttr::Redo( SwUndoIter& )
     }
 }
 
-void SwUndoFlyStrAttr::Repeat( SwUndoIter& )
-{
-    // no repeat
-}
-
 SwRewriter SwUndoFlyStrAttr::GetRewriter() const
 {
     SwRewriter aResult;
diff --git a/sw/source/core/undo/undraw.cxx b/sw/source/core/undo/undraw.cxx
index a571e8101f..9d2924f533 100644
--- a/sw/source/core/undo/undraw.cxx
+++ b/sw/source/core/undo/undraw.cxx
@@ -29,25 +29,30 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <UndoDraw.hxx>
+
 #include <rtl/string.h>
 #include <rtl/memory.h>
-#include <hintids.hxx>
 
 #include <svx/svdogrp.hxx>
 #include <svx/svdundo.hxx>
 #include <svx/svdpage.hxx>
 #include <svx/svdmark.hxx>
+
+#include <hintids.hxx>
+#include <hints.hxx>
 #include <fmtanchr.hxx>
 #include <fmtflcnt.hxx>
 #include <txtflcnt.hxx>
 #include <frmfmt.hxx>
 #include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
 #include <docary.hxx>
 #include <frame.hxx>
 #include <swundo.hxx>			// fuer die UndoIds
 #include <pam.hxx>
 #include <ndtxt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
 #include <dcontact.hxx>
 #include <dview.hxx>
 #include <rootfrm.hxx>
@@ -58,34 +63,32 @@ struct SwUndoGroupObjImpl
 {
     SwDrawFrmFmt* pFmt;
     SdrObject* pObj;
-    ULONG nNodeIdx;
+    sal_uLong nNodeIdx;
 
     // OD 2004-04-15 #i26791# - keeping the anchor and the relative position
     // of drawing objects no longer needed
 };
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 // Draw-Objecte
 
 IMPL_LINK( SwDoc, AddDrawUndo, SdrUndoAction *, pUndo )
 {
 #if OSL_DEBUG_LEVEL > 1
-    USHORT nId = pUndo->GetId();
+    sal_uInt16 nId = pUndo->GetId();
     (void)nId;
     String sComment( pUndo->GetComment() );
 #endif
 
-    if( DoesUndo() && !IsNoDrawUndoObj() )
+    if (GetIDocumentUndoRedo().DoesUndo() &&
+        GetIDocumentUndoRedo().DoesDrawUndo())
     {
-        ClearRedo();
         const SdrMarkList* pMarkList = 0;
         ViewShell* pSh = GetRootFrm() ? GetRootFrm()->GetCurrShell() : 0;
         if( pSh && pSh->HasDrawView() )
             pMarkList = &pSh->GetDrawView()->GetMarkedObjectList();
 
-        AppendUndo( new SwSdrUndo( pUndo, pMarkList ) );
+        GetIDocumentUndoRedo().AppendUndo( new SwSdrUndo(pUndo, pMarkList) );
     }
     else
         delete pUndo;
@@ -107,16 +110,16 @@ SwSdrUndo::~SwSdrUndo()
     delete pMarkList;
 }
 
-void SwSdrUndo::Undo( SwUndoIter& rUndoIter )
+void SwSdrUndo::UndoImpl(::sw::UndoRedoContext & rContext)
 {
     pSdrUndo->Undo();
-    rUndoIter.pMarkList = pMarkList;
+    rContext.SetSelections(0, pMarkList);
 }
 
-void SwSdrUndo::Redo( SwUndoIter& rUndoIter )
+void SwSdrUndo::RedoImpl(::sw::UndoRedoContext & rContext)
 {
     pSdrUndo->Redo();
-    rUndoIter.pMarkList = pMarkList;
+    rContext.SetSelections(0, pMarkList);
 }
 
 String SwSdrUndo::GetComment() const
@@ -132,7 +135,7 @@ void lcl_SendRemoveToUno( SwFmt& rFmt )
     rFmt.Modify( &aMsgHint, &aMsgHint );
 }
 
-void lcl_SaveAnchor( SwFrmFmt* pFmt, ULONG& rNodePos )
+void lcl_SaveAnchor( SwFrmFmt* pFmt, sal_uLong& rNodePos )
 {
     const SwFmtAnchor& rAnchor = pFmt->GetAnchor();
     if ((FLY_AT_PARA == rAnchor.GetAnchorId()) ||
@@ -170,7 +173,7 @@ void lcl_SaveAnchor( SwFrmFmt* pFmt, ULONG& rNodePos )
     }
 }
 
-void lcl_RestoreAnchor( SwFrmFmt* pFmt, ULONG& rNodePos )
+void lcl_RestoreAnchor( SwFrmFmt* pFmt, sal_uLong& rNodePos )
 {
     const SwFmtAnchor& rAnchor = pFmt->GetAnchor();
     if ((FLY_AT_PARA == rAnchor.GetAnchorId()) ||
@@ -203,8 +206,8 @@ void lcl_RestoreAnchor( SwFrmFmt* pFmt, ULONG& rNodePos )
     }
 }
 
-SwUndoDrawGroup::SwUndoDrawGroup( USHORT nCnt )
-    : SwUndo( UNDO_DRAWGROUP ), nSize( nCnt + 1 ), bDelFmt( TRUE )
+SwUndoDrawGroup::SwUndoDrawGroup( sal_uInt16 nCnt )
+    : SwUndo( UNDO_DRAWGROUP ), nSize( nCnt + 1 ), bDelFmt( sal_True )
 {
     pObjArr = new SwUndoGroupObjImpl[ nSize ];
 }
@@ -214,7 +217,7 @@ SwUndoDrawGroup::~SwUndoDrawGroup()
     if( bDelFmt )
     {
         SwUndoGroupObjImpl* pTmp = pObjArr + 1;
-        for( USHORT n = 1; n < nSize; ++n, ++pTmp )
+        for( sal_uInt16 n = 1; n < nSize; ++n, ++pTmp )
             delete pTmp->pFmt;
     }
     else
@@ -223,9 +226,9 @@ SwUndoDrawGroup::~SwUndoDrawGroup()
     delete [] pObjArr;
 }
 
-void SwUndoDrawGroup::Undo( SwUndoIter& )
+void SwUndoDrawGroup::UndoImpl(::sw::UndoRedoContext &)
 {
-    bDelFmt = FALSE;
+    bDelFmt = sal_False;
 
     // das Group-Object sichern
     SwDrawFrmFmt* pFmt = pObjArr->pFmt;
@@ -247,7 +250,7 @@ void SwUndoDrawGroup::Undo( SwUndoIter& )
     SwSpzFrmFmts& rFlyFmts = *(SwSpzFrmFmts*)pDoc->GetSpzFrmFmts();
     rFlyFmts.Remove( rFlyFmts.GetPos( pFmt ));
 
-    for( USHORT n = 1; n < nSize; ++n )
+    for( sal_uInt16 n = 1; n < nSize; ++n )
     {
         SwUndoGroupObjImpl& rSave = *( pObjArr + n );
 
@@ -274,16 +277,16 @@ void SwUndoDrawGroup::Undo( SwUndoIter& )
     }
 }
 
-void SwUndoDrawGroup::Redo( SwUndoIter& )
+void SwUndoDrawGroup::RedoImpl(::sw::UndoRedoContext &)
 {
-    bDelFmt = TRUE;
+    bDelFmt = sal_True;
 
     // aus dem Array austragen
     SwDoc* pDoc = pObjArr->pFmt->GetDoc();
     SwSpzFrmFmts& rFlyFmts = *(SwSpzFrmFmts*)pDoc->GetSpzFrmFmts();
     SdrObject* pObj;
 
-    for( USHORT n = 1; n < nSize; ++n )
+    for( sal_uInt16 n = 1; n < nSize; ++n )
     {
         SwUndoGroupObjImpl& rSave = *( pObjArr + n );
 
@@ -324,7 +327,7 @@ void SwUndoDrawGroup::Redo( SwUndoIter& )
     // <--
 }
 
-void SwUndoDrawGroup::AddObj( USHORT nPos, SwDrawFrmFmt* pFmt, SdrObject* pObj )
+void SwUndoDrawGroup::AddObj( sal_uInt16 nPos, SwDrawFrmFmt* pFmt, SdrObject* pObj )
 {
     SwUndoGroupObjImpl& rSave = *( pObjArr + nPos + 1 );
     rSave.pObj = pObj;
@@ -349,9 +352,9 @@ void SwUndoDrawGroup::SetGroupFmt( SwDrawFrmFmt* pFmt )
 // ------------------------------
 
 SwUndoDrawUnGroup::SwUndoDrawUnGroup( SdrObjGroup* pObj )
-    : SwUndo( UNDO_DRAWUNGROUP ), bDelFmt( FALSE )
+    : SwUndo( UNDO_DRAWUNGROUP ), bDelFmt( sal_False )
 {
-    nSize = (USHORT)pObj->GetSubList()->GetObjCount() + 1;
+    nSize = (sal_uInt16)pObj->GetSubList()->GetObjCount() + 1;
     pObjArr = new SwUndoGroupObjImpl[ nSize ];
 
     SwDrawContact *pContact = (SwDrawContact*)GetUserCall(pObj);
@@ -379,7 +382,7 @@ SwUndoDrawUnGroup::~SwUndoDrawUnGroup()
     if( bDelFmt )
     {
         SwUndoGroupObjImpl* pTmp = pObjArr + 1;
-        for( USHORT n = 1; n < nSize; ++n, ++pTmp )
+        for( sal_uInt16 n = 1; n < nSize; ++n, ++pTmp )
             delete pTmp->pFmt;
     }
     else
@@ -388,15 +391,15 @@ SwUndoDrawUnGroup::~SwUndoDrawUnGroup()
     delete [] pObjArr;
 }
 
-void SwUndoDrawUnGroup::Undo( SwUndoIter& rIter )
+void SwUndoDrawUnGroup::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    bDelFmt = TRUE;
+    bDelFmt = sal_True;
 
-    // aus dem Array austragen
-    SwDoc* pDoc = &rIter.GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
     SwSpzFrmFmts& rFlyFmts = *(SwSpzFrmFmts*)pDoc->GetSpzFrmFmts();
 
-    for( USHORT n = 1; n < nSize; ++n )
+    // remove from array
+    for( sal_uInt16 n = 1; n < nSize; ++n )
     {
         SwUndoGroupObjImpl& rSave = *( pObjArr + n );
 
@@ -440,9 +443,9 @@ void SwUndoDrawUnGroup::Undo( SwUndoIter& rIter )
     // <--
 }
 
-void SwUndoDrawUnGroup::Redo( SwUndoIter& )
+void SwUndoDrawUnGroup::RedoImpl(::sw::UndoRedoContext &)
 {
-    bDelFmt = FALSE;
+    bDelFmt = sal_False;
 
     // das Group-Object sichern
     SwDrawFrmFmt* pFmt = pObjArr->pFmt;
@@ -463,7 +466,7 @@ void SwUndoDrawUnGroup::Redo( SwUndoIter& )
     SwSpzFrmFmts& rFlyFmts = *(SwSpzFrmFmts*)pDoc->GetSpzFrmFmts();
     rFlyFmts.Remove( rFlyFmts.GetPos( pFmt ));
 
-    for( USHORT n = 1; n < nSize; ++n )
+    for( sal_uInt16 n = 1; n < nSize; ++n )
     {
         SwUndoGroupObjImpl& rSave = *( pObjArr + n );
 
@@ -492,7 +495,7 @@ void SwUndoDrawUnGroup::Redo( SwUndoIter& )
     }
 }
 
-void SwUndoDrawUnGroup::AddObj( USHORT nPos, SwDrawFrmFmt* pFmt )
+void SwUndoDrawUnGroup::AddObj( sal_uInt16 nPos, SwDrawFrmFmt* pFmt )
 {
     SwUndoGroupObjImpl& rSave = *( pObjArr + nPos + 1 );
     rSave.pFmt = pFmt;
@@ -510,7 +513,8 @@ SwUndoDrawUnGroupConnectToLayout::~SwUndoDrawUnGroupConnectToLayout()
 {
 }
 
-void SwUndoDrawUnGroupConnectToLayout::Undo( SwUndoIter& )
+void
+SwUndoDrawUnGroupConnectToLayout::UndoImpl(::sw::UndoRedoContext &)
 {
     for ( std::vector< SdrObject >::size_type i = 0;
           i < aDrawFmtsAndObjs.size(); ++i )
@@ -529,7 +533,8 @@ void SwUndoDrawUnGroupConnectToLayout::Undo( SwUndoIter& )
     }
 }
 
-void SwUndoDrawUnGroupConnectToLayout::Redo( SwUndoIter& )
+void
+SwUndoDrawUnGroupConnectToLayout::RedoImpl(::sw::UndoRedoContext &)
 {
     for ( std::vector< std::pair< SwDrawFrmFmt*, SdrObject* > >::size_type i = 0;
           i < aDrawFmtsAndObjs.size(); ++i )
@@ -552,8 +557,8 @@ void SwUndoDrawUnGroupConnectToLayout::AddFmtAndObj( SwDrawFrmFmt* pDrawFrmFmt,
 
 //-------------------------------------
 
-SwUndoDrawDelete::SwUndoDrawDelete( USHORT nCnt )
-    : SwUndo( UNDO_DRAWDELETE ), nSize( nCnt ), bDelFmt( TRUE )
+SwUndoDrawDelete::SwUndoDrawDelete( sal_uInt16 nCnt )
+    : SwUndo( UNDO_DRAWDELETE ), nSize( nCnt ), bDelFmt( sal_True )
 {
     pObjArr = new SwUndoGroupObjImpl[ nSize ];
     pMarkLst = new SdrMarkList();
@@ -564,18 +569,18 @@ SwUndoDrawDelete::~SwUndoDrawDelete()
     if( bDelFmt )
     {
         SwUndoGroupObjImpl* pTmp = pObjArr;
-        for( USHORT n = 0; n < pMarkLst->GetMarkCount(); ++n, ++pTmp )
+        for( sal_uInt16 n = 0; n < pMarkLst->GetMarkCount(); ++n, ++pTmp )
             delete pTmp->pFmt;
     }
     delete [] pObjArr;
     delete pMarkLst;
 }
 
-void SwUndoDrawDelete::Undo( SwUndoIter &rIter )
+void SwUndoDrawDelete::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    bDelFmt = FALSE;
-    SwSpzFrmFmts& rFlyFmts = *rIter.GetDoc().GetSpzFrmFmts();
-    for( USHORT n = 0; n < pMarkLst->GetMarkCount(); ++n )
+    bDelFmt = sal_False;
+    SwSpzFrmFmts & rFlyFmts = *rContext.GetDoc().GetSpzFrmFmts();
+    for( sal_uInt16 n = 0; n < pMarkLst->GetMarkCount(); ++n )
     {
         SwUndoGroupObjImpl& rSave = *( pObjArr + n );
         ::lcl_RestoreAnchor( rSave.pFmt, rSave.nNodeIdx );
@@ -597,14 +602,14 @@ void SwUndoDrawDelete::Undo( SwUndoIter &rIter )
         }
         // <--
     }
-    rIter.pMarkList = pMarkLst;
+    rContext.SetSelections(0, pMarkLst);
 }
 
-void SwUndoDrawDelete::Redo( SwUndoIter &rIter )
+void SwUndoDrawDelete::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    bDelFmt = TRUE;
-    SwSpzFrmFmts& rFlyFmts = *rIter.GetDoc().GetSpzFrmFmts();
-    for( USHORT n = 0; n < pMarkLst->GetMarkCount(); ++n )
+    bDelFmt = sal_True;
+    SwSpzFrmFmts & rFlyFmts = *rContext.GetDoc().GetSpzFrmFmts();
+    for( sal_uInt16 n = 0; n < pMarkLst->GetMarkCount(); ++n )
     {
         SwUndoGroupObjImpl& rSave = *( pObjArr + n );
         SdrObject *pObj = rSave.pObj;
@@ -622,7 +627,7 @@ void SwUndoDrawDelete::Redo( SwUndoIter &rIter )
     }
 }
 
-void SwUndoDrawDelete::AddObj( USHORT , SwDrawFrmFmt* pFmt,
+void SwUndoDrawDelete::AddObj( sal_uInt16 , SwDrawFrmFmt* pFmt,
                                 const SdrMark& rMark )
 {
     SwUndoGroupObjImpl& rSave = *( pObjArr + pMarkLst->GetMarkCount() );
diff --git a/sw/source/core/undo/unfmco.cxx b/sw/source/core/undo/unfmco.cxx
index eba1943e4c..620d730df8 100644
--- a/sw/source/core/undo/unfmco.cxx
+++ b/sw/source/core/undo/unfmco.cxx
@@ -36,12 +36,10 @@
 #include "pam.hxx"
 #include "ndtxt.hxx"
 
-#include "undobj.hxx"
+#include <UndoCore.hxx>
 #include "rolbck.hxx"
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 //--------------------------------------------------
 
 
@@ -69,49 +67,43 @@ SwUndoFmtColl::~SwUndoFmtColl()
 }
 
 
-void SwUndoFmtColl::Undo( SwUndoIter& rUndoIter )
+void SwUndoFmtColl::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    // die alten Werte wieder zurueck
-    pHistory->TmpRollback( &rUndoIter.GetDoc(), 0 );
+    // restore old values
+    pHistory->TmpRollback(& rContext.GetDoc(), 0);
     pHistory->SetTmpEnd( pHistory->Count() );
 
-    // setze noch den Cursor auf den Undo-Bereich
-    SetPaM( rUndoIter );
+    // create cursor for undo range
+    AddUndoRedoPaM(rContext);
 }
 
 
-void SwUndoFmtColl::Redo( SwUndoIter& rUndoIter )
+void SwUndoFmtColl::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    // setze Attribut in dem Bereich:
-    SetPaM( rUndoIter );
-    rUndoIter.pLastUndoObj = 0;
-
-    Repeat( rUndoIter );	// Collection setzen
+    SwPaM & rPam = AddUndoRedoPaM(rContext);
 
-    rUndoIter.pLastUndoObj = 0;
+    DoSetFmtColl(rContext.GetDoc(), rPam);
 }
 
-
-void SwUndoFmtColl::Repeat( SwUndoIter& rUndoIter )
+void SwUndoFmtColl::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    if( UNDO_SETFMTCOLL == rUndoIter.GetLastUndoId() &&
-        pFmtColl == ((SwUndoFmtColl*)rUndoIter.pLastUndoObj)->pFmtColl )
-        return;
+    DoSetFmtColl(rContext.GetDoc(), rContext.GetRepeatPaM());
+}
 
+void SwUndoFmtColl::DoSetFmtColl(SwDoc & rDoc, SwPaM & rPaM)
+{
     // es kann nur eine TextFmtColl auf einen Bereich angewendet werden,
     // also erfrage auch nur in dem Array
-    USHORT nPos = rUndoIter.GetDoc().GetTxtFmtColls()->GetPos(
+    sal_uInt16 const nPos = rDoc.GetTxtFmtColls()->GetPos(
                                                      (SwTxtFmtColl*)pFmtColl );
-    // ist das Format ueberhaupt noch vorhanden?
+    // does the format still exist?
     if( USHRT_MAX != nPos )
     {
-        rUndoIter.GetDoc().SetTxtFmtColl( *rUndoIter.pAktPam,
+        rDoc.SetTxtFmtColl(rPaM,
                                           (SwTxtFmtColl*)pFmtColl,
                                           mbReset,
                                           mbResetListAttrs );
     }
-
-    rUndoIter.pLastUndoObj = this;
 }
 
 SwRewriter SwUndoFmtColl::GetRewriter() const
diff --git a/sw/source/core/undo/unins.cxx b/sw/source/core/undo/unins.cxx
index 644ea3291e..68654997c0 100644
--- a/sw/source/core/undo/unins.cxx
+++ b/sw/source/core/undo/unins.cxx
@@ -28,6 +28,9 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
+
+#include <UndoInsert.hxx>
+
 #include <hintids.hxx>
 #include <unotools/charclass.hxx>
 #include <sot/storage.hxx>
@@ -39,10 +42,13 @@
 #include <fmtanchr.hxx>
 #include <frmfmt.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 <UndoDelete.hxx>
+#include <UndoAttribute.hxx>
 #include <rolbck.hxx>
 #include <ndgrf.hxx>
 #include <ndole.hxx>
@@ -62,42 +68,6 @@
 using namespace ::com::sun::star;
 
 
-class _UnReplaceData : private SwUndoSaveCntnt
-{
-    String m_sOld, m_sIns;
-    ULONG m_nSttNd, m_nEndNd, m_nOffset;
-    xub_StrLen m_nSttCnt, m_nEndCnt, m_nSetPos, m_nSelEnd;
-    BOOL m_bSplitNext : 1;
-    BOOL m_bRegExp : 1;
-    // metadata references for paragraph and following para (if m_bSplitNext)
-    ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoStart;
-    ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoEnd;
-
-public:
-    _UnReplaceData( const SwPaM& rPam, const String& rIns, BOOL bRegExp );
-    ~_UnReplaceData();
-
-    void Undo( SwUndoIter& rIter );
-    void Redo( SwUndoIter& rIter );
-    void SetEnd( const SwPaM& rPam );
-
-    const String & GetOld() const { return m_sOld; }
-    const String & GetIns() const { return m_sIns; }
-};
-
-
-SV_IMPL_PTRARR( _UnReplaceDatas, _UnReplaceData* )
-
-//------------------------------------------------------------------
-
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
-// zwei Zugriffs-Funktionen
-inline SwPosition* IterPt( SwUndoIter& rUIter )
-{	return rUIter.pAktPam->GetPoint();	}
-inline SwPosition* IterMk( SwUndoIter& rUIter )
-{	return rUIter.pAktPam->GetMark();	}
-
 //------------------------------------------------------------
 
 // INSERT
@@ -142,10 +112,10 @@ void SwUndoInsert::Init(const SwNodeIndex & rNd)
 SwUndoInsert::SwUndoInsert( const SwNodeIndex& rNd, xub_StrLen nCnt,
             xub_StrLen nL,
             const IDocumentContentOperations::InsertFlags nInsertFlags,
-            BOOL bWDelim )
+            sal_Bool bWDelim )
     : SwUndo(UNDO_TYPING), pPos( 0 ), pTxt( 0 ), pRedlData( 0 ),
         nNode( rNd.GetIndex() ), nCntnt(nCnt), nLen(nL),
-        bIsWordDelim( bWDelim ), bIsAppend( FALSE )
+        bIsWordDelim( bWDelim ), bIsAppend( sal_False )
     , m_nInsertFlags(nInsertFlags)
 {
     Init(rNd);
@@ -155,7 +125,7 @@ SwUndoInsert::SwUndoInsert( const SwNodeIndex& rNd, xub_StrLen nCnt,
 SwUndoInsert::SwUndoInsert( const SwNodeIndex& rNd )
     : SwUndo(UNDO_SPLITNODE), pPos( 0 ), pTxt( 0 ),
         pRedlData( 0 ), nNode( rNd.GetIndex() ), nCntnt(0), nLen(1),
-        bIsWordDelim( FALSE ), bIsAppend( TRUE )
+        bIsWordDelim( sal_False ), bIsAppend( sal_True )
     , m_nInsertFlags(IDocumentContentOperations::INS_EMPTYEXPAND)
 {
     Init(rNd);
@@ -165,7 +135,7 @@ SwUndoInsert::SwUndoInsert( const SwNodeIndex& rNd )
 // werden kann. Wenn ja, dann aender die Laenge und die InsPos.
 // Dann wird von SwDoc::Insert kein neues Object in die Undoliste gestellt.
 
-BOOL SwUndoInsert::CanGrouping( sal_Unicode cIns )
+sal_Bool SwUndoInsert::CanGrouping( sal_Unicode cIns )
 {
     if( !bIsAppend && bIsWordDelim ==
         !GetAppCharClass().isLetterNumeric( String( cIns )) )
@@ -176,14 +146,14 @@ BOOL SwUndoInsert::CanGrouping( sal_Unicode cIns )
         if (pUndoTxt)
             pUndoTxt->Insert(cIns);
 
-        return TRUE;
+        return sal_True;
     }
-    return FALSE;
+    return sal_False;
 }
 
-BOOL SwUndoInsert::CanGrouping( const SwPosition& rPos )
+sal_Bool SwUndoInsert::CanGrouping( const SwPosition& rPos )
 {
-    BOOL bRet = FALSE;
+    sal_Bool bRet = sal_False;
     if( nNode == rPos.nNode.GetIndex() &&
         nCntnt == rPos.nContent.GetIndex() )
     {
@@ -192,7 +162,7 @@ BOOL SwUndoInsert::CanGrouping( const SwPosition& rPos )
         if( ( ~nsRedlineMode_t::REDLINE_SHOW_MASK & rDoc.GetRedlineMode() ) ==
             ( ~nsRedlineMode_t::REDLINE_SHOW_MASK & GetRedlineMode() ) )
         {
-            bRet = TRUE;
+            bRet = sal_True;
 
             // dann war oder ist noch Redline an:
             // pruefe, ob an der InsPosition ein anderer Redline
@@ -204,7 +174,7 @@ BOOL SwUndoInsert::CanGrouping( const SwPosition& rPos )
                 SwRedlineData aRData( nsRedlineType_t::REDLINE_INSERT, rDoc.GetRedlineAuthor() );
                 const SwIndexReg* pIReg = rPos.nContent.GetIdxReg();
                 SwIndex* pIdx;
-                for( USHORT i = 0; i < rTbl.Count(); ++i )
+                for( sal_uInt16 i = 0; i < rTbl.Count(); ++i )
                 {
                     SwRedline* pRedl = rTbl[ i ];
                     if( pIReg == (pIdx = &pRedl->End()->nContent)->GetIdxReg() &&
@@ -213,7 +183,7 @@ BOOL SwUndoInsert::CanGrouping( const SwPosition& rPos )
                         if( !pRedl->HasMark() || !pRedlData ||
                             *pRedl != *pRedlData || *pRedl != aRData )
                         {
-                            bRet = FALSE;
+                            bRet = sal_False;
                             break;
                         }
                     }
@@ -249,13 +219,13 @@ SwUndoInsert::~SwUndoInsert()
 
 
 
-void SwUndoInsert::Undo( SwUndoIter& rUndoIter )
+void SwUndoInsert::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pTmpDoc = &rUndoIter.GetDoc();
+    SwDoc *const pTmpDoc = & rContext.GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 
     if( bIsAppend )
     {
-        SwPaM* pPam = rUndoIter.pAktPam;
         pPam->GetPoint()->nNode = nNode;
 
         if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
@@ -272,7 +242,7 @@ void SwUndoInsert::Undo( SwUndoIter& rUndoIter )
     }
     else
     {
-        ULONG nNd = nNode;
+        sal_uLong nNd = nNode;
         xub_StrLen nCnt = nCntnt;
         if( nLen )
         {
@@ -288,7 +258,7 @@ void SwUndoInsert::Undo( SwUndoIter& rUndoIter )
                 aPaM.GetPoint()->nContent -= nLen;
                 if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
                     pTmpDoc->DeleteRedline( aPaM, true, USHRT_MAX );
-                RemoveIdxFromRange( aPaM, FALSE );
+                RemoveIdxFromRange( aPaM, sal_False );
                 pTxt = new String( pTxtNode->GetTxt().Copy(nCntnt-nLen, nLen) );
                 pTxtNode->EraseText( aPaM.GetPoint()->nContent, nLen );
             }
@@ -297,7 +267,7 @@ void SwUndoInsert::Undo( SwUndoIter& rUndoIter )
                 aPaM.Move(fnMoveBackward);
                 if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
                     pTmpDoc->DeleteRedline( aPaM, true, USHRT_MAX );
-                RemoveIdxFromRange( aPaM, FALSE );
+                RemoveIdxFromRange( aPaM, sal_False );
             }
 
             nNd = aPaM.GetPoint()->nNode.GetIndex();
@@ -312,24 +282,22 @@ void SwUndoInsert::Undo( SwUndoIter& rUndoIter )
             nCntnt = aPaM.GetPoint()->nContent.GetIndex();
         }
 
-        // setze noch den Cursor auf den Undo-Bereich
-        rUndoIter.pAktPam->DeleteMark();
+        // set cursor to Undo range
+        pPam->DeleteMark();
 
-        IterPt(rUndoIter)->nNode = nNd;
-        IterPt(rUndoIter)->nContent.Assign( pTmpDoc->GetNodes()[
-                IterPt(rUndoIter)->nNode ]->GetCntntNode(), nCnt );
-        // SPoint und GetMark auf der gleichen Position
+        pPam->GetPoint()->nNode = nNd;
+        pPam->GetPoint()->nContent.Assign(
+                pPam->GetPoint()->nNode.GetNode().GetCntntNode(), nCnt );
     }
 
     DELETEZ(pUndoTxt);
 }
 
 
-void SwUndoInsert::Redo( SwUndoIter& rUndoIter )
+void SwUndoInsert::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    // setze noch den Cursor auf den Redo-Bereich
-    SwPaM* pPam = rUndoIter.pAktPam;
-    SwDoc* pTmpDoc = pPam->GetDoc();
+    SwDoc *const pTmpDoc = & rContext.GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
     pPam->DeleteMark();
 
     if( bIsAppend )
@@ -357,12 +325,13 @@ void SwUndoInsert::Redo( SwUndoIter& rUndoIter )
     else
     {
         pPam->GetPoint()->nNode = nNode;
-        SwCntntNode* pCNd = pTmpDoc->GetNodes()[ pPam->GetPoint()->nNode ]->GetCntntNode();
+        SwCntntNode *const pCNd =
+            pPam->GetPoint()->nNode.GetNode().GetCntntNode();
         pPam->GetPoint()->nContent.Assign( pCNd, nCntnt );
 
         if( nLen )
         {
-            BOOL bMvBkwrd = MovePtBackward( *pPam );
+            sal_Bool bMvBkwrd = MovePtBackward( *pPam );
 
             if( pTxt )
             {
@@ -375,7 +344,7 @@ void SwUndoInsert::Redo( SwUndoIter& rUndoIter )
             else
             {
                 // Inhalt wieder einfuegen. (erst pPos abmelden !!)
-                ULONG nMvNd = pPos->nNode.GetIndex();
+                sal_uLong nMvNd = pPos->nNode.GetIndex();
                 xub_StrLen nMvCnt = pPos->nContent.GetIndex();
                 DELETEZ( pPos );
                 MoveFromUndoNds( *pTmpDoc, nMvNd, nMvCnt, *pPam->GetMark() );
@@ -384,18 +353,18 @@ void SwUndoInsert::Redo( SwUndoIter& rUndoIter )
             nCntnt = pPam->GetMark()->nContent.GetIndex();
 
             MovePtForward( *pPam, bMvBkwrd );
-            rUndoIter.pAktPam->Exchange();
+            pPam->Exchange();
             if( pRedlData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
             {
                 RedlineMode_t eOld = pTmpDoc->GetRedlineMode();
                 pTmpDoc->SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
                 pTmpDoc->AppendRedline( new SwRedline( *pRedlData,
-                                            *rUndoIter.pAktPam ), true);
+                                            *pPam ), true);
                 pTmpDoc->SetRedlineMode_intern( eOld );
             }
             else if( !( nsRedlineMode_t::REDLINE_IGNORE & GetRedlineMode() ) &&
                     pTmpDoc->GetRedlineTbl().Count() )
-                pTmpDoc->SplitRedline( *rUndoIter.pAktPam );
+                pTmpDoc->SplitRedline(*pPam);
         }
     }
 
@@ -403,13 +372,12 @@ void SwUndoInsert::Redo( SwUndoIter& rUndoIter )
 }
 
 
-void SwUndoInsert::Repeat( SwUndoIter& rUndoIter )
+void SwUndoInsert::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    rUndoIter.pLastUndoObj = this;
     if( !nLen )
         return;
 
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwNodeIndex aNd( rDoc.GetNodes(), nNode );
     SwCntntNode* pCNd = aNd.GetNode().GetCntntNode();;
 
@@ -427,15 +395,15 @@ void SwUndoInsert::Repeat( SwUndoIter& rUndoIter )
     {
     case ND_TEXTNODE:
         if( bIsAppend )
-            rDoc.AppendTxtNode( *rUndoIter.pAktPam->GetPoint() );
+        {
+            rDoc.AppendTxtNode( *rContext.GetRepeatPaM().GetPoint() );
+        }
         else
         {
             String aTxt( ((SwTxtNode*)pCNd)->GetTxt() );
-            BOOL bGroupUndo = rDoc.DoesGroupUndo();
-            rDoc.DoGroupUndo( FALSE );
-            rDoc.InsertString( *rUndoIter.pAktPam,
+            ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
+            rDoc.InsertString( rContext.GetRepeatPaM(),
                 aTxt.Copy( nCntnt - nLen, nLen ) );
-            rDoc.DoGroupUndo( bGroupUndo );
         }
         break;
     case ND_GRFNODE:
@@ -445,7 +413,7 @@ void SwUndoInsert::Repeat( SwUndoIter& rUndoIter )
             if( pGrfNd->IsGrfLink() )
                 pGrfNd->GetFileFilterNms( &sFile, &sFilter );
 
-            rDoc.Insert( *rUndoIter.pAktPam, sFile, sFilter,
+            rDoc.Insert( rContext.GetRepeatPaM(), sFile, sFilter,
                                 &pGrfNd->GetGrf(),
                                 0/* Grafik-Collection*/, NULL, NULL );
         }
@@ -465,7 +433,10 @@ void SwUndoInsert::Repeat( SwUndoIter& rUndoIter )
             if ( aCnt.StoreEmbeddedObject( rSwOLE.GetOleRef(), aName, sal_True ) )
             {
                 uno::Reference < embed::XEmbeddedObject > aNew = aCnt.GetEmbeddedObject( aName );
-                rDoc.Insert( *rUndoIter.pAktPam, svt::EmbeddedObjectRef( aNew, ((SwOLENode*)pCNd)->GetAspect() ), NULL, NULL, NULL );
+                rDoc.Insert( rContext.GetRepeatPaM(),
+                    svt::EmbeddedObjectRef( aNew,
+                        static_cast<SwOLENode*>(pCNd)->GetAspect() ),
+                    NULL, NULL, NULL );
             }
 
             break;
@@ -505,82 +476,85 @@ SwRewriter SwUndoInsert::GetRewriter() const
 }
 
 
-/*  */
+// SwUndoReplace /////////////////////////////////////////////////////////
 
-SwUndoReplace::SwUndoReplace()
-    : SwUndo( UNDO_REPLACE ), nAktPos( USHRT_MAX )
-{
-}
 
-SwUndoReplace::~SwUndoReplace()
+class SwUndoReplace::Impl
+    : private SwUndoSaveCntnt
 {
-}
+    ::rtl::OUString m_sOld;
+    ::rtl::OUString m_sIns;
+    sal_uLong m_nSttNd, m_nEndNd, m_nOffset;
+    xub_StrLen m_nSttCnt, m_nEndCnt, m_nSetPos, m_nSelEnd;
+    bool m_bSplitNext : 1;
+    bool m_bRegExp : 1;
+    // metadata references for paragraph and following para (if m_bSplitNext)
+    ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoStart;
+    ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoEnd;
 
-void SwUndoReplace::Undo( SwUndoIter& rUndoIter )
-{
-    // war dieses nicht die letze Undo-Aktion, dann setze den
-    // Count neu
-    if( rUndoIter.pLastUndoObj != this )
+public:
+    Impl(SwPaM const& rPam, ::rtl::OUString const& rIns, bool const bRegExp);
+    virtual ~Impl()
     {
-        nAktPos = aArr.Count();
-        rUndoIter.pLastUndoObj = this;
-        bOldIterFlag = rUndoIter.bWeiter;
-        rUndoIter.bWeiter = TRUE;
     }
 
-    aArr[ --nAktPos ]->Undo( rUndoIter );
+    virtual void UndoImpl( ::sw::UndoRedoContext & );
+    virtual void RedoImpl( ::sw::UndoRedoContext & );
 
-    if( !nAktPos )		// alten Status wieder zurueck
-        rUndoIter.bWeiter = bOldIterFlag;
-}
+    void SetEnd(SwPaM const& rPam);
+
+    ::rtl::OUString const& GetOld() const { return m_sOld; }
+    ::rtl::OUString const& GetIns() const { return m_sIns; }
+};
 
 
-void SwUndoReplace::Redo( SwUndoIter& rUndoIter )
+SwUndoReplace::SwUndoReplace(SwPaM const& rPam,
+        ::rtl::OUString const& rIns, bool const bRegExp)
+    : SwUndo( UNDO_REPLACE )
+    , m_pImpl(new Impl(rPam, rIns, bRegExp))
 {
-    // war dieses nicht die letze Undo-Aktion, dann setze den
-    // Count neu
-    if( rUndoIter.pLastUndoObj != this )
-    {
-        OSL_ENSURE( !nAktPos, "Redo ohne vorheriges Undo??" );
-        rUndoIter.pLastUndoObj = this;
-        bOldIterFlag = rUndoIter.bWeiter;
-        rUndoIter.bWeiter = TRUE;
-    }
+}
 
-    aArr[ nAktPos ]->Redo( rUndoIter );
+SwUndoReplace::~SwUndoReplace()
+{
+}
 
-    if( ++nAktPos >= aArr.Count() )	// alten Status wieder zurueck
-    {
-        nAktPos = USHRT_MAX;
-        rUndoIter.bWeiter = bOldIterFlag;
-    }
+void SwUndoReplace::UndoImpl(::sw::UndoRedoContext & rContext)
+{
+    m_pImpl->UndoImpl(rContext);
 }
 
-// #111827#
-SwRewriter SwUndoReplace::GetRewriter() const
+void SwUndoReplace::RedoImpl(::sw::UndoRedoContext & rContext)
+{
+    m_pImpl->RedoImpl(rContext);
+}
+
+SwRewriter
+MakeUndoReplaceRewriter(sal_uLong const occurrences,
+        ::rtl::OUString const& sOld, ::rtl::OUString const& sNew)
 {
     SwRewriter aResult;
 
-    if (aArr.Count() > 1)
+    if (1 < occurrences)
     {
-        aResult.AddRule(UNDO_ARG1, String::CreateFromInt32(aArr.Count()));
+        aResult.AddRule(UNDO_ARG1, String::CreateFromInt32(occurrences));
         aResult.AddRule(UNDO_ARG2, String(SW_RES(STR_OCCURRENCES_OF)));
 
         String aTmpStr;
         aTmpStr += String(SW_RES(STR_START_QUOTE));
-        aTmpStr += ShortenString(aArr[0]->GetOld(), nUndoStringLength,
+        aTmpStr += ShortenString(sOld, nUndoStringLength,
                                  SW_RES(STR_LDOTS));
         aTmpStr += String(SW_RES(STR_END_QUOTE));
         aResult.AddRule(UNDO_ARG3, aTmpStr);
     }
-    else if (aArr.Count() == 1)
+    else if (1 == occurrences)
     {
         {
             String aTmpStr;
 
             aTmpStr += String(SW_RES(STR_START_QUOTE));
             // #i33488 #
-            aTmpStr += ShortenString(aArr[0]->GetOld(), nUndoStringLength,
+            aTmpStr += ShortenString(sOld, nUndoStringLength,
                                      SW_RES(STR_LDOTS));
             aTmpStr += String(SW_RES(STR_END_QUOTE));
             aResult.AddRule(UNDO_ARG1, aTmpStr);
@@ -593,7 +567,7 @@ SwRewriter SwUndoReplace::GetRewriter() const
 
             aTmpStr += String(SW_RES(STR_START_QUOTE));
             // #i33488 #
-            aTmpStr += ShortenString(aArr[0]->GetIns(), nUndoStringLength,
+            aTmpStr += ShortenString(sNew, nUndoStringLength,
                                      SW_RES(STR_LDOTS));
             aTmpStr += String(SW_RES(STR_END_QUOTE));
             aResult.AddRule(UNDO_ARG3, aTmpStr);
@@ -603,24 +577,23 @@ SwRewriter SwUndoReplace::GetRewriter() const
     return aResult;
 }
 
-void SwUndoReplace::AddEntry( const SwPaM& rPam, const String& rInsert,
-                                BOOL bRegExp )
+// #111827#
+SwRewriter SwUndoReplace::GetRewriter() const
 {
-    _UnReplaceData* pNew = new _UnReplaceData( rPam, rInsert, bRegExp );
-    aArr.C40_INSERT(_UnReplaceData, pNew, aArr.Count() );
+    return MakeUndoReplaceRewriter(1, m_pImpl->GetOld(), m_pImpl->GetIns());
 }
 
-void SwUndoReplace::SetEntryEnd( const SwPaM& rPam )
+void SwUndoReplace::SetEnd(SwPaM const& rPam)
 {
-    _UnReplaceData* pEntry = aArr[ aArr.Count()-1 ];
-    pEntry->SetEnd( rPam );
+    m_pImpl->SetEnd(rPam);
 }
 
-_UnReplaceData::_UnReplaceData( const SwPaM& rPam, const String& rIns,
-                                BOOL bRgExp )
-    : m_sIns( rIns ), m_nOffset( 0 )
+SwUndoReplace::Impl::Impl(
+        SwPaM const& rPam, ::rtl::OUString const& rIns, bool const bRegExp)
+    : m_sIns( rIns )
+    , m_nOffset( 0 )
+    , m_bRegExp(bRegExp)
 {
-    m_bRegExp = bRgExp;
 
     const SwPosition * pStt( rPam.Start() );
     const SwPosition * pEnd( rPam.End() );
@@ -639,7 +612,7 @@ _UnReplaceData::_UnReplaceData( const SwPaM& rPam, const String& rIns,
 
     m_nSetPos = pHistory->Count();
 
-    ULONG nNewPos = pStt->nNode.GetIndex();
+    sal_uLong nNewPos = pStt->nNode.GetIndex();
     m_nOffset = m_nSttNd - nNewPos;
 
     if ( pNd->GetpSwpHints() )
@@ -655,7 +628,7 @@ _UnReplaceData::_UnReplaceData( const SwPaM& rPam, const String& rIns,
         pHistory->Add( pNd->GetTxtColl(), nNewPos, ND_TEXTNODE );
 
         SwTxtNode* pNext = pEnd->nNode.GetNode().GetTxtNode();
-        ULONG nTmp = pNext->GetIndex();
+        sal_uLong nTmp = pNext->GetIndex();
         pHistory->CopyAttr( pNext->GetpSwpHints(), nTmp, 0,
                             pNext->GetTxt().Len(), true );
         if( pNext->HasSwAttrSet() )
@@ -674,14 +647,10 @@ _UnReplaceData::_UnReplaceData( const SwPaM& rPam, const String& rIns,
     m_sOld = pNd->GetTxt().Copy( m_nSttCnt, nECnt - m_nSttCnt );
 }
 
-_UnReplaceData::~_UnReplaceData()
-{
-}
-
-void _UnReplaceData::Undo( SwUndoIter& rIter )
+void SwUndoReplace::Impl::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rIter.GetDoc();
-    SwPaM& rPam = *rIter.pAktPam;
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM & rPam(rContext.GetCursorSupplier().CreateNewShellCursor());
     rPam.DeleteMark();
 
     SwTxtNode* pNd = pDoc->GetNodes()[ m_nSttNd - m_nOffset ]->GetTxtNode();
@@ -690,18 +659,18 @@ void _UnReplaceData::Undo( SwUndoIter& rIter )
     SwAutoCorrExceptWord* pACEWord = pDoc->GetAutoCorrExceptWord();
     if( pACEWord )
     {
-        if( 1 == m_sIns.Len() && 1 == m_sOld.Len() )
+        if ((1 == m_sIns.getLength()) && (1 == m_sOld.getLength()))
         {
             SwPosition aPos( *pNd ); aPos.nContent.Assign( pNd, m_nSttCnt );
-            pACEWord->CheckChar( aPos, m_sOld.GetChar( 0 ) );
+            pACEWord->CheckChar( aPos, m_sOld[ 0 ] );
         }
         pDoc->SetAutoCorrExceptWord( 0 );
     }
 
-    SwIndex aIdx( pNd, m_nSttCnt );
+    SwIndex aIdx( pNd, sal_uInt16( m_nSttCnt ) );
     if( m_nSttNd == m_nEndNd )
     {
-        pNd->EraseText( aIdx, m_sIns.Len() );
+        pNd->EraseText( aIdx, sal_uInt16( m_sIns.getLength() ) );
     }
     else
     {
@@ -729,7 +698,7 @@ void _UnReplaceData::Undo( SwUndoIter& rIter )
         pNd->RestoreMetadata(m_pMetadataUndoStart);
     }
 
-    if( m_sOld.Len() )
+    if (m_sOld.getLength())
     {
         pNd->InsertText( m_sOld, aIdx );
     }
@@ -763,13 +732,10 @@ void _UnReplaceData::Undo( SwUndoIter& rIter )
     rPam.GetPoint()->nContent = aIdx;
 }
 
-void _UnReplaceData::Redo( SwUndoIter& rIter )
+void SwUndoReplace::Impl::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
-    BOOL bUndo = rDoc.DoesUndo();
-    rDoc.DoUndo( FALSE );
-
-    SwPaM& rPam = *rIter.pAktPam;
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPaM & rPam(rContext.GetCursorSupplier().CreateNewShellCursor());
     rPam.DeleteMark();
     rPam.GetPoint()->nNode = m_nSttNd;
 
@@ -806,21 +772,21 @@ void _UnReplaceData::Redo( SwUndoIter& rIter )
 
     rDoc.ReplaceRange( rPam, m_sIns, m_bRegExp );
     rPam.DeleteMark();
-    rDoc.DoUndo( bUndo );
 }
 
-void _UnReplaceData::SetEnd( const SwPaM& rPam )
+void SwUndoReplace::Impl::SetEnd(SwPaM const& rPam)
 {
     if( rPam.GetPoint()->nNode != rPam.GetMark()->nNode )
     {
-        // es wurden mehrere Absaetze eingefuegt
+        // multiple paragraphs were inserted
         const SwPosition* pEnd = rPam.End();
         m_nEndNd = m_nOffset + pEnd->nNode.GetIndex();
         m_nEndCnt = pEnd->nContent.GetIndex();
     }
 }
 
-/*  */
+
+// SwUndoReRead //////////////////////////////////////////////////////////
 
 
 SwUndoReRead::SwUndoReRead( const SwPaM& rPam, const SwGrfNode& rGrfNd )
@@ -838,9 +804,9 @@ SwUndoReRead::~SwUndoReRead()
 }
 
 
-void SwUndoReRead::SetAndSave( SwUndoIter& rIter )
+void SwUndoReRead::SetAndSave(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwGrfNode* pGrfNd = rDoc.GetNodes()[ nPos ]->GetGrfNode();
 
     if( !pGrfNd )
@@ -850,37 +816,37 @@ void SwUndoReRead::SetAndSave( SwUndoIter& rIter )
     Graphic* pOldGrf = pGrf;
     String* pOldNm = pNm;
     String* pOldFltr = pFltr;
-    USHORT nOldMirr = nMirr;
+    sal_uInt16 nOldMirr = nMirr;
 
     SaveGraphicData( *pGrfNd );
     if( pOldNm )
     {
-        pGrfNd->ReRead( *pOldNm, pFltr ? *pFltr : aEmptyStr, 0, 0, TRUE );
+        pGrfNd->ReRead( *pOldNm, pFltr ? *pFltr : aEmptyStr, 0, 0, sal_True );
         delete pOldNm;
         delete pOldFltr;
     }
     else
     {
-        pGrfNd->ReRead( aEmptyStr, aEmptyStr, pOldGrf, 0, TRUE );
+        pGrfNd->ReRead( aEmptyStr, aEmptyStr, pOldGrf, 0, sal_True );
         delete pOldGrf;
     }
 
     if( RES_MIRROR_GRAPH_DONT != nOldMirr )
         pGrfNd->SetAttr( SwMirrorGrf() );
 
-    rIter.pSelFmt = pGrfNd->GetFlyFmt();
+    rContext.SetSelections(pGrfNd->GetFlyFmt(), 0);
 }
 
 
-void SwUndoReRead::Undo( SwUndoIter& rIter )
+void SwUndoReRead::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetAndSave( rIter );
+    SetAndSave(rContext);
 }
 
 
-void SwUndoReRead::Redo( SwUndoIter& rIter )
+void SwUndoReRead::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetAndSave( rIter );
+    SetAndSave(rContext);
 }
 
 
@@ -895,7 +861,7 @@ void SwUndoReRead::SaveGraphicData( const SwGrfNode& rGrfNd )
     }
     else
     {
-        ((SwGrfNode&)rGrfNd).SwapIn( TRUE );
+        ((SwGrfNode&)rGrfNd).SwapIn( sal_True );
         pGrf = new Graphic( rGrfNd.GetGrf() );
         pNm = pFltr = 0;
     }
@@ -908,10 +874,10 @@ SwUndoInsertLabel::SwUndoInsertLabel( const SwLabelType eTyp,
                                       const String &rTxt,
                                       const String& rSeparator,
                                       const String& rNumberSeparator,
-                                      const BOOL bBef,
-                                      const USHORT nInitId,
+                                      const sal_Bool bBef,
+                                      const sal_uInt16 nInitId,
                                       const String& rCharacterStyle,
-                                      const BOOL bCpyBorder )
+                                      const sal_Bool bCpyBorder )
     : SwUndo( UNDO_INSERTLABEL ),
       sText( rTxt ),
       sSeparator( rSeparator ),
@@ -923,7 +889,7 @@ SwUndoInsertLabel::SwUndoInsertLabel( const SwLabelType eTyp,
       bBefore( bBef ),
       bCpyBrd( bCpyBorder )
 {
-    bUndoKeep = FALSE;
+    bUndoKeep = sal_False;
     OBJECT.pUndoFly = 0;
     OBJECT.pUndoAttr = 0;
 }
@@ -939,9 +905,9 @@ SwUndoInsertLabel::~SwUndoInsertLabel()
         delete NODE.pUndoInsNd;
 }
 
-void SwUndoInsertLabel::Undo( SwUndoIter& rIter )
+void SwUndoInsertLabel::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     if( LTYPE_OBJECT == eType || LTYPE_DRAW == eType )
     {
@@ -953,8 +919,8 @@ void SwUndoInsertLabel::Undo( SwUndoIter& rIter )
             ( LTYPE_DRAW != eType ||
               0 != (pSdrObj = pFmt->FindSdrObject()) ) )
         {
-            OBJECT.pUndoAttr->Undo( rIter );
-            OBJECT.pUndoFly->Undo( rIter );
+            OBJECT.pUndoAttr->UndoImpl(rContext);
+            OBJECT.pUndoFly->UndoImpl(rContext);
             if( LTYPE_DRAW == eType )
             {
                 pSdrObj->SetLayer( nLayerId );
@@ -970,18 +936,18 @@ void SwUndoInsertLabel::Undo( SwUndoIter& rIter )
             if ( pNd )
                 pNd->GetTable().GetFrmFmt()->ResetFmtAttr( RES_KEEP );
         }
-        SwPaM aPam( *rIter.pAktPam->GetPoint() );
+        SwPaM aPam( rDoc.GetNodes().GetEndOfContent() );
         aPam.GetPoint()->nNode = NODE.nNode;
         aPam.SetMark();
         aPam.GetPoint()->nNode = NODE.nNode + 1;
-        NODE.pUndoInsNd = new SwUndoDelete( aPam, TRUE );
+        NODE.pUndoInsNd = new SwUndoDelete( aPam, sal_True );
     }
 }
 
 
-void SwUndoInsertLabel::Redo( SwUndoIter& rIter )
+void SwUndoInsertLabel::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     if( LTYPE_OBJECT == eType || LTYPE_DRAW == eType )
     {
@@ -993,8 +959,8 @@ void SwUndoInsertLabel::Redo( SwUndoIter& rIter )
             ( LTYPE_DRAW != eType ||
               0 != (pSdrObj = pFmt->FindSdrObject()) ) )
         {
-            OBJECT.pUndoFly->Redo( rIter );
-            OBJECT.pUndoAttr->Redo( rIter );
+            OBJECT.pUndoFly->RedoImpl(rContext);
+            OBJECT.pUndoAttr->RedoImpl(rContext);
             if( LTYPE_DRAW == eType )
             {
                 pSdrObj->SetLayer( nLayerId );
@@ -1013,19 +979,19 @@ void SwUndoInsertLabel::Redo( SwUndoIter& rIter )
             SwTableNode *pNd = rDoc.GetNodes()[
                         rDoc.GetNodes()[NODE.nNode-1]->StartOfSectionIndex()]->GetTableNode();
             if ( pNd )
-                pNd->GetTable().GetFrmFmt()->SetFmtAttr( SvxFmtKeepItem(TRUE, RES_KEEP) );
+                pNd->GetTable().GetFrmFmt()->SetFmtAttr( SvxFmtKeepItem(sal_True, RES_KEEP) );
         }
-        NODE.pUndoInsNd->Undo( rIter );
+        NODE.pUndoInsNd->UndoImpl(rContext);
         delete NODE.pUndoInsNd, NODE.pUndoInsNd = 0;
     }
 }
 
-void SwUndoInsertLabel::Repeat( SwUndoIter& rIter )
+void SwUndoInsertLabel::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
-    const SwPosition& rPos = *rIter.pAktPam->GetPoint();
+    SwDoc & rDoc = rContext.GetDoc();
+    const SwPosition& rPos = *rContext.GetRepeatPaM().GetPoint();
 
-    ULONG nIdx = 0;
+    sal_uLong nIdx = 0;
 
     SwCntntNode* pCNd = rPos.nNode.GetNode().GetCntntNode();
     if( pCNd )
@@ -1091,7 +1057,7 @@ void SwUndoInsertLabel::SetFlys( SwFrmFmt& rOldFly, SfxItemSet& rChgSet,
     }
 }
 
-void SwUndoInsertLabel::SetDrawObj( BYTE nLId )
+void SwUndoInsertLabel::SetDrawObj( sal_uInt8 nLId )
 {
     if( LTYPE_DRAW == eType )
     {
diff --git a/sw/source/core/undo/unmove.cxx b/sw/source/core/undo/unmove.cxx
index ccb4819251..87744177e1 100644
--- a/sw/source/core/undo/unmove.cxx
+++ b/sw/source/core/undo/unmove.cxx
@@ -29,17 +29,17 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <UndoSplitMove.hxx>
 
 #include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
 #include <pam.hxx>
 #include <swundo.hxx>			// fuer die UndoIds
 #include <ndtxt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
 #include <rolbck.hxx>
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 // MOVE
 
 SwUndoMove::SwUndoMove( const SwPaM& rRange, const SwPosition& rMvPos )
@@ -48,7 +48,7 @@ SwUndoMove::SwUndoMove( const SwPaM& rRange, const SwPosition& rMvPos )
     nMvDestCntnt( rMvPos.nContent.GetIndex() ),
     bMoveRedlines( false )
 {
-    bMoveRange = bJoinNext = bJoinPrev = FALSE;
+    bMoveRange = bJoinNext = bJoinPrev = sal_False;
 
     // StartNode vorm loeschen von Fussnoten besorgen!
     SwDoc* pDoc = rRange.GetDoc();
@@ -80,7 +80,8 @@ SwUndoMove::SwUndoMove( const SwPaM& rRange, const SwPosition& rMvPos )
             pHistory->CopyFmtAttr( *pEndTxtNd->GetpSwAttrSet(), nEndNode );
     }
 
-    if( 0 != (pTxtNd = rRange.GetDoc()->GetNodes()[ rMvPos.nNode ]->GetTxtNode() ))
+    pTxtNd = rMvPos.nNode.GetNode().GetTxtNode();
+    if (0 != pTxtNd)
     {
         pHistory->Add( pTxtNd->GetTxtColl(), nMvDestNode, ND_TEXTNODE );
         if ( pTxtNd->GetpSwpHints() )
@@ -107,8 +108,8 @@ SwUndoMove::SwUndoMove( SwDoc* pDoc, const SwNodeRange& rRg,
     nMvDestNode( rMvPos.GetIndex() ),
     bMoveRedlines( false )
 {
-    bMoveRange = TRUE;
-    bJoinNext = bJoinPrev = FALSE;
+    bMoveRange = sal_True;
+    bJoinNext = bJoinPrev = sal_False;
 
     nSttCntnt = nEndCntnt = nMvDestCntnt = STRING_MAXLEN;
 
@@ -118,7 +119,7 @@ SwUndoMove::SwUndoMove( SwDoc* pDoc, const SwNodeRange& rRg,
 //	DelFtn( rRange );
 
     // wird aus dem CntntBereich in den Sonderbereich verschoben ?
-    ULONG nCntntStt = pDoc->GetNodes().GetEndOfAutotext().GetIndex();
+    sal_uLong nCntntStt = pDoc->GetNodes().GetEndOfAutotext().GetIndex();
     if( nMvDestNode < nCntntStt && rRg.aStart.GetIndex() > nCntntStt )
     {
         // loesche alle Fussnoten. Diese sind dort nicht erwuenscht.
@@ -143,7 +144,7 @@ SwUndoMove::SwUndoMove( SwDoc* pDoc, const SwNodeRange& rRg,
 
 void SwUndoMove::SetDestRange( const SwPaM& rRange,
                                 const SwPosition& rInsPos,
-                                BOOL bJoin, BOOL bCorrPam )
+                                sal_Bool bJoin, sal_Bool bCorrPam )
 {
     const SwPosition *pStt = rRange.Start(),
                     *pEnd = rRange.GetPoint() == pStt
@@ -188,11 +189,9 @@ void SwUndoMove::SetDestRange( const SwNodeIndex& rStt,
 }
 
 
-void SwUndoMove::Undo( SwUndoIter& rUndoIter )
+void SwUndoMove::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rUndoIter.GetDoc();
-    BOOL bUndo = pDoc->DoesUndo();
-    pDoc->DoUndo( FALSE );
+    SwDoc *const pDoc = & rContext.GetDoc();
 
     // Block, damit aus diesem gesprungen werden kann
     do {
@@ -218,7 +217,7 @@ void SwUndoMove::Undo( SwUndoIter& rUndoIter )
             // #i17764# if redlines are to be moved, we may not remove them before
             //          pDoc->Move gets a chance to handle them
             if( ! bMoveRedlines )
-                RemoveIdxFromRange( aPam, FALSE );
+                RemoveIdxFromRange( aPam, sal_False );
 
             SwPosition aPos( *pDoc->GetNodes()[ nInsPosNode] );
             SwCntntNode* pCNd = aPos.nNode.GetNode().GetCntntNode();
@@ -239,7 +238,7 @@ void SwUndoMove::Undo( SwUndoIter& rUndoIter )
 
             aPam.Exchange();
             aPam.DeleteMark();
-//			pDoc->ResetAttr( aPam, FALSE );
+//			pDoc->ResetAttr( aPam, sal_False );
             if( aPam.GetNode()->IsCntntNode() )
                 aPam.GetNode()->GetCntntNode()->ResetAllAttr();
             // der Pam wird jetzt aufgegeben.
@@ -267,7 +266,7 @@ void SwUndoMove::Undo( SwUndoIter& rUndoIter )
             pTxtNd->JoinNext();
         }
 
-    } while( FALSE );
+    } while( sal_False );
 
     if( pHistory )
     {
@@ -277,18 +276,18 @@ void SwUndoMove::Undo( SwUndoIter& rUndoIter )
         pHistory->SetTmpEnd( pHistory->Count() );
     }
 
-    pDoc->DoUndo( bUndo );
-
     // setze noch den Cursor auf den Undo-Bereich
     if( !bMoveRange )
-        SetPaM( rUndoIter );
+    {
+        AddUndoRedoPaM(rContext);
+    }
 }
 
 
-void SwUndoMove::Redo( SwUndoIter& rUndoIter )
+void SwUndoMove::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pPam = rUndoIter.pAktPam;
-    SwDoc& rDoc = *pPam->GetDoc();
+    SwPaM *const pPam = & AddUndoRedoPaM(rContext);
+    SwDoc & rDoc = rContext.GetDoc();
 
     SwNodes& rNds = rDoc.GetNodes();
     SwNodeIndex aIdx( rNds, nMvDestNode );
@@ -309,10 +308,10 @@ void SwUndoMove::Redo( SwUndoIter& rUndoIter )
                                         nMvDestCntnt ));
 
         DelFtn( aPam );
-        RemoveIdxFromRange( aPam, FALSE );
+        RemoveIdxFromRange( aPam, sal_False );
 
         aIdx = aPam.Start()->nNode;
-        BOOL bJoinTxt = aIdx.GetNode().IsTxtNode();
+        sal_Bool bJoinTxt = aIdx.GetNode().IsTxtNode();
 
         aIdx--;
         rDoc.MoveRange( aPam, aMvPos,
@@ -342,7 +341,7 @@ void SwUndoMove::DelFtn( const SwPaM& rRange )
 {
     // wird aus dem CntntBereich in den Sonderbereich verschoben ?
     SwDoc* pDoc = rRange.GetDoc();
-    ULONG nCntntStt = pDoc->GetNodes().GetEndOfAutotext().GetIndex();
+    sal_uLong nCntntStt = pDoc->GetNodes().GetEndOfAutotext().GetIndex();
     if( nMvDestNode < nCntntStt &&
         rRange.GetPoint()->nNode.GetIndex() >= nCntntStt )
     {
diff --git a/sw/source/core/undo/unnum.cxx b/sw/source/core/undo/unnum.cxx
index f13f94c19c..a6b1461457 100644
--- a/sw/source/core/undo/unnum.cxx
+++ b/sw/source/core/undo/unnum.cxx
@@ -29,21 +29,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,
@@ -88,14 +89,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 );
-
-    BOOL bUndo = rDoc.DoesUndo();
-    rDoc.DoUndo( FALSE );
+    SwDoc & rDoc = rContext.GetDoc();
 
     if( pOldNumRule )
         rDoc.ChgNumRuleFmts( *pOldNumRule );
@@ -105,7 +101,7 @@ void SwUndoInsNum::Undo( SwUndoIter& rUndoIter )
         SwTxtNode* pNd;
         if( ULONG_MAX != nSttSet &&
             0 != ( pNd = rDoc.GetNodes()[ nSttSet ]->GetTxtNode() ))
-                pNd->SetListRestart( TRUE );
+                pNd->SetListRestart( sal_True );
         else
             pNd = 0;
 
@@ -125,28 +121,30 @@ 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
-            rDoc.SetNumRule( *rUndoIter.pAktPam, aNumRule, false );
+            rDoc.SetNumRule(rPam, aNumRule, false);
             // <--
         }
     }
@@ -158,19 +156,22 @@ 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
-            rUndoIter.GetDoc().SetNumRule( *rUndoIter.pAktPam, aNumRule, false );
+            rDoc.SetNumRule(rContext.GetRepeatPaM(), aNumRule, false);
             // <--
         }
     }
     else
-        rUndoIter.GetDoc().ChgNumRuleFmts( aNumRule );
+    {
+        rDoc.ChgNumRuleFmts( aNumRule );
+    }
 }
 
 SwHistory* SwUndoInsNum::GetHistory()
@@ -186,7 +187,7 @@ void SwUndoInsNum::SaveOldNumRule( const SwNumRule& rOld )
         pOldNumRule = new SwNumRule( rOld );
 }
 
-/*  */
+/*  */
 
 
 SwUndoDelNum::SwUndoDelNum( const SwPaM& rPam )
@@ -196,20 +197,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 );
-
-    BOOL bUndo = rDoc.DoesUndo();
-    rDoc.DoUndo( FALSE );
+    SwDoc & rDoc = rContext.GetDoc();
 
     pHistory->TmpRollback( &rDoc, 0 );
     pHistory->SetTmpEnd( pHistory->Count() );
@@ -224,25 +219,21 @@ 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, BOOL )
+void SwUndoDelNum::AddNode( const SwTxtNode& rNd, sal_Bool )
 {
     if( rNd.GetNumRule() )
     {
@@ -251,10 +242,10 @@ void SwUndoDelNum::AddNode( const SwTxtNode& rNd, BOOL )
 }
 
 
-/*  */
+/*  */
 
 
-SwUndoMoveNum::SwUndoMoveNum( const SwPaM& rPam, long nOff, BOOL bIsOutlMv )
+SwUndoMoveNum::SwUndoMoveNum( const SwPaM& rPam, long nOff, sal_Bool bIsOutlMv )
     : SwUndo( bIsOutlMv ? UNDO_OUTLINE_UD : UNDO_MOVENUM ),
     SwUndRng( rPam ),
     nNewStt( 0 ), nOffset( nOff )
@@ -263,10 +254,9 @@ SwUndoMoveNum::SwUndoMoveNum( const SwPaM& rPam, long nOff, BOOL bIsOutlMv )
     //			nach oben	=> -1
 }
 
-
-void SwUndoMoveNum::Undo( SwUndoIter& rUndoIter )
+void SwUndoMoveNum::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    ULONG nTmpStt = nSttNode, nTmpEnd = nEndNode;
+    sal_uLong nTmpStt = nSttNode, nTmpEnd = nEndNode;
 
     if( nEndNode || USHRT_MAX != nEndCntnt )		// Bereich ?
     {
@@ -279,38 +269,40 @@ void SwUndoMoveNum::Undo( SwUndoIter& rUndoIter )
 
 //JP 22.06.95: wird wollen die Bookmarks/Verzeichnisse behalten, oder?
 //	SetPaM( rUndoIter );
-//	RemoveIdxFromRange( *rUndoIter.pAktPam, TRUE );
+//	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, TRUE );
+//	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, FALSE );
+    {
+        rDoc.MoveParagraph(rContext.GetRepeatPaM(), nOffset, sal_False);
+    }
 }
 
-/*  */
+/*  */
 
 
 SwUndoNumUpDown::SwUndoNumUpDown( const SwPaM& rPam, short nOff )
@@ -321,40 +313,37 @@ 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);
 }
 
-/*  */
+/*  */
 
 // #115901#
-SwUndoNumOrNoNum::SwUndoNumOrNoNum( const SwNodeIndex& rIdx, BOOL bOldNum,
-                                    BOOL bNewNum)
+SwUndoNumOrNoNum::SwUndoNumOrNoNum( const SwNodeIndex& rIdx, sal_Bool bOldNum,
+                                    sal_Bool bNewNum)
     : SwUndo( UNDO_NUMORNONUM ), nIdx( rIdx.GetIndex() ), mbNewNum(bNewNum),
       mbOldNum(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)
@@ -364,9 +353,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)
@@ -376,37 +365,39 @@ 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,
-                                       FALSE);
+    {
+        rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, sal_False);
+    }
     else if ( ! mbOldNum && mbNewNum )
-        rUndoIter.GetDoc().NumOrNoNum( rUndoIter.pAktPam->GetPoint()->nNode,
-                                       TRUE);
+    {
+        rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, sal_True);
+    }
 }
 
-/*  */
+/*  */
 
-SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, BOOL bFlg )
+SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, sal_Bool bFlg )
     : SwUndo( UNDO_SETNUMRULESTART ),
     nIdx( rPos.nNode.GetIndex() ), nOldStt( USHRT_MAX ),
-    nNewStt( USHRT_MAX ), bSetSttValue( FALSE ), bFlag( bFlg )
+    nNewStt( USHRT_MAX ), bSetSttValue( sal_False ), bFlag( bFlg )
 {
 }
 
-SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, USHORT nStt )
+SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, sal_uInt16 nStt )
     : SwUndo( UNDO_SETNUMRULESTART ),
     nIdx( rPos.nNode.GetIndex() ),
-    nOldStt( USHRT_MAX ), nNewStt( nStt ), bSetSttValue( TRUE )
+    nOldStt( USHRT_MAX ), nNewStt( nStt ), bSetSttValue( sal_True )
 {
     SwTxtNode* pTxtNd = rPos.nNode.GetNode().GetTxtNode();
     if ( pTxtNd )
     {
         if ( pTxtNd->HasAttrListRestartValue() )
         {
-            nOldStt = static_cast<USHORT>(pTxtNd->GetAttrListRestartValue());
+            nOldStt = static_cast<sal_uInt16>(pTxtNd->GetAttrListRestartValue());
         }
         else
         {
@@ -416,34 +407,47 @@ SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, USHORT 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);
+    }
 }
 
 
diff --git a/sw/source/core/undo/unoutl.cxx b/sw/source/core/undo/unoutl.cxx
index cfdea00be1..11106dd6b1 100644
--- a/sw/source/core/undo/unoutl.cxx
+++ b/sw/source/core/undo/unoutl.cxx
@@ -29,44 +29,36 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
-
-
 #include "doc.hxx"
 #include "swundo.hxx"			// fuer die UndoIds
 #include "pam.hxx"
 #include "ndtxt.hxx"
 
-#include "undobj.hxx"
+#include <UndoCore.hxx>
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 SwUndoOutlineLeftRight::SwUndoOutlineLeftRight( const SwPaM& rPam,
                                                 short nOff )
     : SwUndo( UNDO_OUTLINE_LR ), SwUndRng( rPam ), nOffset( nOff )
 {
 }
 
-
-void SwUndoOutlineLeftRight::Undo( SwUndoIter& rUndoIter )
+void SwUndoOutlineLeftRight::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetPaM( rUndoIter );
-    rUndoIter.GetDoc().OutlineUpDown( *rUndoIter.pAktPam, -nOffset );
+    SwPaM & rPaM( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().OutlineUpDown(rPaM, -nOffset);
 }
 
-
-void SwUndoOutlineLeftRight::Redo( SwUndoIter& rUndoIter )
+void SwUndoOutlineLeftRight::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetPaM( rUndoIter );
-    rUndoIter.GetDoc().OutlineUpDown( *rUndoIter.pAktPam, nOffset );
+    SwPaM & rPaM( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().OutlineUpDown(rPaM,  nOffset);
 }
 
-
-void SwUndoOutlineLeftRight::Repeat( SwUndoIter& rUndoIter )
+void SwUndoOutlineLeftRight::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    rUndoIter.GetDoc().OutlineUpDown( *rUndoIter.pAktPam, nOffset );
+    rContext.GetDoc().OutlineUpDown(rContext.GetRepeatPaM(), nOffset);
 }
 
 
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
\ No newline at end of file
diff --git a/sw/source/core/undo/unovwr.cxx b/sw/source/core/undo/unovwr.cxx
index a9608aaf43..35c1e48cca 100644
--- a/sw/source/core/undo/unovwr.cxx
+++ b/sw/source/core/undo/unovwr.cxx
@@ -29,20 +29,26 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <UndoOverwrite.hxx>
+
+#include <tools/resid.hxx>
 
 #include <unotools/charclass.hxx>
 #include <unotools/transliterationwrapper.hxx>
+
 #include <comphelper/processfactory.hxx>
+
 #include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
+#include <IShellCursorSupplier.hxx>
 #include <swundo.hxx>			// fuer die UndoIds
 #include <pam.hxx>
 #include <ndtxt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
 #include <rolbck.hxx>
 #include <acorrect.hxx>
 #include <docary.hxx>
 
-#include <tools/resid.hxx>
 #include <comcore.hrc> // #111827#
 #include <undo.hrc>
 
@@ -50,33 +56,23 @@ using namespace ::com::sun::star;
 using namespace ::com::sun::star::i18n;
 using namespace ::com::sun::star::uno;
 
-//------------------------------------------------------------------
-
-// zwei Zugriffs-Funktionen
-inline SwPosition* IterPt( SwUndoIter& rUIter )
-{	return rUIter.pAktPam->GetPoint();	}
-inline SwPosition* IterMk( SwUndoIter& rUIter )
-{	return rUIter.pAktPam->GetMark();	}
-
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
 
 //------------------------------------------------------------
 
-
 // OVERWRITE
 
 
 SwUndoOverwrite::SwUndoOverwrite( SwDoc* pDoc, SwPosition& rPos,
                                     sal_Unicode cIns )
     : SwUndo(UNDO_OVERWRITE),
-      pRedlSaveData( 0 ), bGroup( FALSE )
+      pRedlSaveData( 0 ), bGroup( sal_False )
 {
     if( !pDoc->IsIgnoreRedline() && pDoc->GetRedlineTbl().Count() )
     {
         SwPaM aPam( rPos.nNode, rPos.nContent.GetIndex(),
                     rPos.nNode, rPos.nContent.GetIndex()+1 );
         pRedlSaveData = new SwRedlineSaveDatas;
-        if( !FillSaveData( aPam, *pRedlSaveData, FALSE ))
+        if( !FillSaveData( aPam, *pRedlSaveData, sal_False ))
             delete pRedlSaveData, pRedlSaveData = 0;
     }
 
@@ -86,7 +82,7 @@ SwUndoOverwrite::SwUndoOverwrite( SwDoc* pDoc, SwPosition& rPos,
     SwTxtNode* pTxtNd = rPos.nNode.GetNode().GetTxtNode();
     OSL_ENSURE( pTxtNd, "Overwrite nicht im TextNode?" );
 
-    bInsChar = TRUE;
+    bInsChar = sal_True;
     xub_StrLen nTxtNdLen = pTxtNd->GetTxt().Len();
     if( nSttCntnt < nTxtNdLen )		// kein reines Einfuegen ?
     {
@@ -97,11 +93,11 @@ SwUndoOverwrite::SwUndoOverwrite( SwDoc* pDoc, SwPosition& rPos,
         pHistory->CopyAttr( pTxtNd->GetpSwpHints(), nSttNode, 0,
                             nTxtNdLen, false );
         rPos.nContent++;
-        bInsChar = FALSE;
+        bInsChar = sal_False;
     }
 
-    BOOL bOldExpFlg = pTxtNd->IsIgnoreDontExpand();
-    pTxtNd->SetIgnoreDontExpand( TRUE );
+    sal_Bool bOldExpFlg = pTxtNd->IsIgnoreDontExpand();
+    pTxtNd->SetIgnoreDontExpand( sal_True );
 
     pTxtNd->InsertText( cIns, rPos.nContent,
             IDocumentContentOperations::INS_EMPTYEXPAND );
@@ -122,7 +118,7 @@ SwUndoOverwrite::~SwUndoOverwrite()
     delete pRedlSaveData;
 }
 
-BOOL SwUndoOverwrite::CanGrouping( SwDoc* pDoc, SwPosition& rPos,
+sal_Bool SwUndoOverwrite::CanGrouping( SwDoc* pDoc, SwPosition& rPos,
                                     sal_Unicode cIns )
 {
 ///  ?? was ist mit nur eingefuegten Charaktern ???
@@ -130,14 +126,14 @@ BOOL SwUndoOverwrite::CanGrouping( SwDoc* pDoc, SwPosition& rPos,
     // es kann nur das Loeschen von einzelnen char's zusammengefasst werden
     if( rPos.nNode != nSttNode || !aInsStr.Len()  ||
         ( !bGroup && aInsStr.Len() != 1 ))
-        return FALSE;
+        return sal_False;
 
     // ist der Node ueberhaupt ein TextNode?
     SwTxtNode * pDelTxtNd = rPos.nNode.GetNode().GetTxtNode();
     if( !pDelTxtNd ||
         ( pDelTxtNd->GetTxt().Len() != rPos.nContent.GetIndex() &&
             rPos.nContent.GetIndex() != ( nSttCntnt + aInsStr.Len() )))
-        return FALSE;
+        return sal_False;
 
     CharClass& rCC = GetAppCharClass();
 
@@ -145,23 +141,23 @@ BOOL SwUndoOverwrite::CanGrouping( SwDoc* pDoc, SwPosition& rPos,
     if (( CH_TXTATR_BREAKWORD == cIns || CH_TXTATR_INWORD == cIns ) ||
         rCC.isLetterNumeric( String( cIns ), 0 ) !=
         rCC.isLetterNumeric( aInsStr, aInsStr.Len()-1 ) )
-        return FALSE;
+        return sal_False;
 
     {
         SwRedlineSaveDatas* pTmpSav = new SwRedlineSaveDatas;
         SwPaM aPam( rPos.nNode, rPos.nContent.GetIndex(),
                     rPos.nNode, rPos.nContent.GetIndex()+1 );
 
-        if( !FillSaveData( aPam, *pTmpSav, FALSE ))
+        if( !FillSaveData( aPam, *pTmpSav, sal_False ))
             delete pTmpSav, pTmpSav = 0;
 
-        BOOL bOk = ( !pRedlSaveData && !pTmpSav ) ||
+        sal_Bool bOk = ( !pRedlSaveData && !pTmpSav ) ||
                    ( pRedlSaveData && pTmpSav &&
                         SwUndo::CanRedlineGroup( *pRedlSaveData, *pTmpSav,
                             nSttCntnt > rPos.nContent.GetIndex() ));
         delete pTmpSav;
         if( !bOk )
-            return FALSE;
+            return sal_False;
 
         pDoc->DeleteRedline( aPam, false, USHRT_MAX );
     }
@@ -176,11 +172,11 @@ BOOL SwUndoOverwrite::CanGrouping( SwDoc* pDoc, SwPosition& rPos,
             rPos.nContent++;
         }
         else
-            bInsChar = TRUE;
+            bInsChar = sal_True;
     }
 
-    BOOL bOldExpFlg = pDelTxtNd->IsIgnoreDontExpand();
-    pDelTxtNd->SetIgnoreDontExpand( TRUE );
+    sal_Bool bOldExpFlg = pDelTxtNd->IsIgnoreDontExpand();
+    pDelTxtNd->SetIgnoreDontExpand( sal_True );
 
     pDelTxtNd->InsertText( cIns, rPos.nContent,
             IDocumentContentOperations::INS_EMPTYEXPAND );
@@ -193,18 +189,19 @@ BOOL SwUndoOverwrite::CanGrouping( SwDoc* pDoc, SwPosition& rPos,
     }
     pDelTxtNd->SetIgnoreDontExpand( bOldExpFlg );
 
-    bGroup = TRUE;
-    return TRUE;
+    bGroup = sal_True;
+    return sal_True;
 }
 
 
 
 
 
-void SwUndoOverwrite::Undo( SwUndoIter& rUndoIter )
+void SwUndoOverwrite::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pAktPam = rUndoIter.pAktPam;
-    SwDoc* pDoc = pAktPam->GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pAktPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
+
     pAktPam->DeleteMark();
     pAktPam->GetPoint()->nNode = nSttNode;
     SwTxtNode* pTxtNd = pAktPam->GetNode()->GetTxtNode();
@@ -234,8 +231,8 @@ void SwUndoOverwrite::Undo( SwUndoIter& rUndoIter )
         String aTmpStr( '1' );
         sal_Unicode* pTmpStr = aTmpStr.GetBufferAccess();
 
-        BOOL bOldExpFlg = pTxtNd->IsIgnoreDontExpand();
-        pTxtNd->SetIgnoreDontExpand( TRUE );
+        sal_Bool bOldExpFlg = pTxtNd->IsIgnoreDontExpand();
+        pTxtNd->SetIgnoreDontExpand( sal_True );
 
         rIdx++;
         for( xub_StrLen n = 0; n < aDelStr.Len(); n++  )
@@ -267,29 +264,27 @@ void SwUndoOverwrite::Undo( SwUndoIter& rUndoIter )
         SetSaveData( *pDoc, *pRedlSaveData );
 }
 
-void SwUndoOverwrite::Repeat( SwUndoIter& rUndoIter )
+void SwUndoOverwrite::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    rUndoIter.pLastUndoObj = this;
-    SwPaM* pAktPam = rUndoIter.pAktPam;
+    SwPaM *const pAktPam = & rContext.GetRepeatPaM();
     if( !aInsStr.Len() || pAktPam->HasMark() )
         return;
 
-    SwDoc& rDoc = *pAktPam->GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
-    BOOL bGroupUndo = rDoc.DoesGroupUndo();
-    rDoc.DoGroupUndo( FALSE );
-    rDoc.Overwrite( *pAktPam, aInsStr.GetChar( 0 ));
-    rDoc.DoGroupUndo( bGroupUndo );
+    {
+        ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
+        rDoc.Overwrite(*pAktPam, aInsStr.GetChar(0));
+    }
     for( xub_StrLen n = 1; n < aInsStr.Len(); ++n )
         rDoc.Overwrite( *pAktPam, aInsStr.GetChar( n ) );
 }
 
-
-
-void SwUndoOverwrite::Redo( SwUndoIter& rUndoIter )
+void SwUndoOverwrite::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pAktPam = rUndoIter.pAktPam;
-    SwDoc* pDoc = pAktPam->GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pAktPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
+
     pAktPam->DeleteMark();
     pAktPam->GetPoint()->nNode = nSttNode;
     SwTxtNode* pTxtNd = pAktPam->GetNode()->GetTxtNode();
@@ -306,8 +301,8 @@ void SwUndoOverwrite::Redo( SwUndoIter& rUndoIter )
     }
     rIdx.Assign( pTxtNd, aDelStr.Len() ? nSttCntnt+1 : nSttCntnt );
 
-    BOOL bOldExpFlg = pTxtNd->IsIgnoreDontExpand();
-    pTxtNd->SetIgnoreDontExpand( TRUE );
+    sal_Bool bOldExpFlg = pTxtNd->IsIgnoreDontExpand();
+    pTxtNd->SetIgnoreDontExpand( sal_True );
 
     for( xub_StrLen n = 0; n < aInsStr.Len(); n++  )
     {
@@ -356,10 +351,10 @@ struct _UndoTransliterate_Data
     String          sText;
     SwHistory*      pHistory;
     Sequence< sal_Int32 >*  pOffsets;
-    ULONG           nNdIdx;
+    sal_uLong           nNdIdx;
     xub_StrLen      nStart, nLen;
 
-    _UndoTransliterate_Data( ULONG nNd, xub_StrLen nStt, xub_StrLen nStrLen, const String& rTxt )
+    _UndoTransliterate_Data( sal_uLong nNd, xub_StrLen nStt, xub_StrLen nStrLen, const String& rTxt )
         : sText( rTxt ), pHistory( 0 ), pOffsets( 0 ),
         nNdIdx( nNd ), nStart( nStt ), nLen( nStrLen )
     {}
@@ -381,11 +376,9 @@ SwUndoTransliterate::~SwUndoTransliterate()
         delete aChanges[i];
 }
 
-void SwUndoTransliterate::Undo( SwUndoIter& rUndoIter )
+void SwUndoTransliterate::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
-    BOOL bUndo = rDoc.DoesUndo();
-    rDoc.DoUndo( FALSE );
+    SwDoc & rDoc = rContext.GetDoc();
 
     // since the changes were added to the vector from the end of the string/node towards
     // the start, we need to revert them from the start towards the end now to keep the 
@@ -394,27 +387,24 @@ void SwUndoTransliterate::Undo( SwUndoIter& rUndoIter )
     for (sal_Int32 i = aChanges.size() - 1; i >= 0;  --i)
         aChanges[i]->SetChangeAtNode( rDoc );
 
-    rDoc.DoUndo( bUndo );
-    SetPaM( rUndoIter, TRUE );
+    AddUndoRedoPaM(rContext, true);
 }
 
-void SwUndoTransliterate::Redo( SwUndoIter& rUndoIter )
+void SwUndoTransliterate::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-/* ??? */	rUndoIter.SetUpdateAttr( TRUE );
-
-    SetPaM( *rUndoIter.pAktPam );
-    Repeat( rUndoIter );
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    DoTransliterate(rContext.GetDoc(), rPam);
 }
 
-void SwUndoTransliterate::Repeat( SwUndoIter& rUndoIter )
+void SwUndoTransliterate::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwPaM& rPam = *rUndoIter.pAktPam;
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    DoTransliterate(rContext.GetDoc(), rContext.GetRepeatPaM());
+}
 
+void SwUndoTransliterate::DoTransliterate(SwDoc & rDoc, SwPaM & rPam)
+{
     utl::TransliterationWrapper aTrans( ::comphelper::getProcessServiceFactory(), nType );
     rDoc.TransliterateText( rPam, aTrans );
-
-    rUndoIter.pLastUndoObj = this;
 }
 
 void SwUndoTransliterate::AddChanges( SwTxtNode& rTNd,
diff --git a/sw/source/core/undo/unredln.cxx b/sw/source/core/undo/unredln.cxx
index ffb7281559..f3521c343b 100644
--- a/sw/source/core/undo/unredln.cxx
+++ b/sw/source/core/undo/unredln.cxx
@@ -29,6 +29,7 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <UndoRedline.hxx>
 
 #include <hintids.hxx>
 #include <unotools/charclass.hxx>
@@ -36,24 +37,22 @@
 #include <swundo.hxx>			// fuer die UndoIds
 #include <pam.hxx>
 #include <ndtxt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
+#include <UndoDelete.hxx>
 #include <rolbck.hxx>
 #include <redline.hxx>
 #include <docary.hxx>
 #include <sortopt.hxx>
 
-extern void lcl_JoinText( SwPaM& rPam, BOOL bJoinPrev );
-extern void lcl_GetJoinFlags( SwPaM& rPam, BOOL& rJoinTxt, BOOL& rJoinPrev );
+extern void lcl_JoinText( SwPaM& rPam, sal_Bool bJoinPrev );
+extern void lcl_GetJoinFlags( SwPaM& rPam, sal_Bool& rJoinTxt, sal_Bool& rJoinPrev );
 
 //------------------------------------------------------------------
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
-
 SwUndoRedline::SwUndoRedline( SwUndoId nUsrId, const SwPaM& rRange )
     : SwUndo( UNDO_REDLINE ), SwUndRng( rRange ),
     pRedlData( 0 ), pRedlSaveData( 0 ), nUserId( nUsrId ),
-    bHiddenRedlines( FALSE )
+    bHiddenRedlines( sal_False )
 {
     // Redline beachten
     SwDoc& rDoc = *rRange.GetDoc();
@@ -71,10 +70,10 @@ SwUndoRedline::SwUndoRedline( SwUndoId nUsrId, const SwPaM& rRange )
         SetRedlineMode( rDoc.GetRedlineMode() );
     }
 
-    ULONG nEndExtra = rDoc.GetNodes().GetEndOfExtras().GetIndex();
+    sal_uLong nEndExtra = rDoc.GetNodes().GetEndOfExtras().GetIndex();
 
     pRedlSaveData = new SwRedlineSaveDatas;
-    if( !FillSaveData( rRange, *pRedlSaveData, FALSE,
+    if( !FillSaveData( rRange, *pRedlSaveData, sal_False,
                         UNDO_REJECT_REDLINE != nUserId ))
         delete pRedlSaveData, pRedlSaveData = 0;
     else
@@ -95,17 +94,22 @@ SwUndoRedline::~SwUndoRedline()
     delete pRedlSaveData;
 }
 
-void SwUndoRedline::Undo( SwUndoIter& rIter )
+sal_uInt16 SwUndoRedline::GetRedlSaveCount() const
 {
-    SwDoc* pDoc = &rIter.GetDoc();
-    SetPaM( *rIter.pAktPam );
+    return pRedlSaveData ? pRedlSaveData->Count() : 0;
+}
 
-// RedlineMode setzen?
-    _Undo( rIter );
+
+void SwUndoRedline::UndoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+
+    UndoRedlineImpl(*pDoc, rPam);
 
     if( pRedlSaveData )
     {
-        ULONG nEndExtra = pDoc->GetNodes().GetEndOfExtras().GetIndex();
+        sal_uLong nEndExtra = pDoc->GetNodes().GetEndOfExtras().GetIndex();
         SetSaveData( *pDoc, *pRedlSaveData );
         if( bHiddenRedlines )
         {
@@ -115,51 +119,51 @@ void SwUndoRedline::Undo( SwUndoIter& rIter )
             nSttNode += nEndExtra;
             nEndNode += nEndExtra;
         }
-        SetPaM( *rIter.pAktPam, TRUE );
+        SetPaM(rPam, true);
     }
 }
 
 
-void SwUndoRedline::Redo( SwUndoIter& rIter )
+void SwUndoRedline::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rIter.GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
     RedlineMode_t eOld = pDoc->GetRedlineMode();
     pDoc->SetRedlineMode_intern((RedlineMode_t)(( eOld & ~nsRedlineMode_t::REDLINE_IGNORE) | nsRedlineMode_t::REDLINE_ON ));
 
-    SetPaM( *rIter.pAktPam );
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
     if( pRedlSaveData && bHiddenRedlines )
     {
-        ULONG nEndExtra = pDoc->GetNodes().GetEndOfExtras().GetIndex();
-        FillSaveData( *rIter.pAktPam, *pRedlSaveData, FALSE,
+        sal_uLong nEndExtra = pDoc->GetNodes().GetEndOfExtras().GetIndex();
+        FillSaveData(rPam, *pRedlSaveData, sal_False,
                         UNDO_REJECT_REDLINE != nUserId );
 
         nEndExtra -= pDoc->GetNodes().GetEndOfExtras().GetIndex();
         nSttNode -= nEndExtra;
         nEndNode -= nEndExtra;
     }
-    _Redo( rIter );
 
-    SetPaM( *rIter.pAktPam, TRUE );
+    RedoRedlineImpl(*pDoc, rPam);
+
+    SetPaM(rPam, true);
     pDoc->SetRedlineMode_intern( eOld );
 }
 
-// default ist leer
-void SwUndoRedline::_Undo( SwUndoIter& )
+void SwUndoRedline::UndoRedlineImpl(SwDoc &, SwPaM &)
 {
 }
 
-// default ist Redlines entfernen
-void SwUndoRedline::_Redo( SwUndoIter& rIter )
+// default: remove redlines
+void SwUndoRedline::RedoRedlineImpl(SwDoc & rDoc, SwPaM & rPam)
 {
-    rIter.GetDoc().DeleteRedline( *rIter.pAktPam, true, USHRT_MAX );
+    rDoc.DeleteRedline(rPam, true, USHRT_MAX);
 }
 
 
-/*  */
+// SwUndoRedlineDelete ///////////////////////////////////////////////////
 
 SwUndoRedlineDelete::SwUndoRedlineDelete( const SwPaM& rRange, SwUndoId nUsrId )
     : SwUndoRedline( nUsrId = (nUsrId ? nUsrId : UNDO_DELETE), rRange ),
-    bCanGroup( FALSE ), bIsDelim( FALSE ), bIsBackspace( FALSE )
+    bCanGroup( sal_False ), bIsDelim( sal_False ), bIsBackspace( sal_False )
 {
     const SwTxtNode* pTNd;
     if( UNDO_DELETE == nUserId &&
@@ -169,7 +173,7 @@ SwUndoRedlineDelete::SwUndoRedlineDelete( const SwPaM& rRange, SwUndoId nUsrId )
         sal_Unicode cCh = pTNd->GetTxt().GetChar( nSttCntnt );
         if( CH_TXTATR_BREAKWORD != cCh && CH_TXTATR_INWORD != cCh )
         {
-            bCanGroup = TRUE;
+            bCanGroup = sal_True;
             bIsDelim = !GetAppCharClass().isLetterNumeric( pTNd->GetTxt(),
                                                             nSttCntnt );
             bIsBackspace = nSttCntnt == rRange.GetPoint()->nContent.GetIndex();
@@ -179,20 +183,22 @@ SwUndoRedlineDelete::SwUndoRedlineDelete( const SwPaM& rRange, SwUndoId nUsrId )
     bCacheComment = false;
 }
 
-void SwUndoRedlineDelete::_Undo( SwUndoIter& rIter )
+void SwUndoRedlineDelete::UndoRedlineImpl(SwDoc & rDoc, SwPaM & rPam)
 {
-    rIter.GetDoc().DeleteRedline( *rIter.pAktPam, true, USHRT_MAX );
+    rDoc.DeleteRedline(rPam, true, USHRT_MAX);
 }
 
-void SwUndoRedlineDelete::_Redo( SwUndoIter& rIter )
+void SwUndoRedlineDelete::RedoRedlineImpl(SwDoc & rDoc, SwPaM & rPam)
 {
-    if( *rIter.pAktPam->GetPoint() != *rIter.pAktPam->GetMark() )
-        rIter.GetDoc().AppendRedline( new SwRedline( *pRedlData, *rIter.pAktPam ), FALSE );
+    if (rPam.GetPoint() != rPam.GetMark())
+    {
+        rDoc.AppendRedline( new SwRedline(*pRedlData, rPam), sal_False );
+    }
 }
 
-BOOL SwUndoRedlineDelete::CanGrouping( const SwUndoRedlineDelete& rNext )
+sal_Bool SwUndoRedlineDelete::CanGrouping( const SwUndoRedlineDelete& rNext )
 {
-    BOOL bRet = FALSE;
+    sal_Bool bRet = sal_False;
     if( UNDO_DELETE == nUserId && nUserId == rNext.nUserId &&
         bCanGroup == rNext.bCanGroup &&
         bIsDelim == rNext.bIsDelim &&
@@ -218,7 +224,7 @@ BOOL SwUndoRedlineDelete::CanGrouping( const SwUndoRedlineDelete& rNext )
                 nEndCntnt = rNext.nEndCntnt;
             else
                 nSttCntnt = rNext.nSttCntnt;
-            bRet = TRUE;
+            bRet = sal_True;
         }
     }
     return bRet;
@@ -239,17 +245,16 @@ SwUndoRedlineSort::~SwUndoRedlineSort()
     delete pOpt;
 }
 
-void SwUndoRedlineSort::_Undo( SwUndoIter& rIter )
+void SwUndoRedlineSort::UndoRedlineImpl(SwDoc & rDoc, SwPaM & rPam)
 {
-    // im rIter.pAktPam ist der sortiete Bereich,
-    // im aSaveRange steht der kopierte, sprich der originale.
-    SwDoc& rDoc = rIter.GetDoc();
+    // rPam contains the sorted range
+    // aSaveRange contains copied (i.e. original) range
 
-    SwPosition* pStart = rIter.pAktPam->Start();
-    SwPosition* pEnd   = rIter.pAktPam->End();
+    SwPosition *const pStart = rPam.Start();
+    SwPosition *const pEnd   = rPam.End();
 
     SwNodeIndex aPrevIdx( pStart->nNode, -1 );
-    ULONG nOffsetTemp = pEnd->nNode.GetIndex() - pStart->nNode.GetIndex();
+    sal_uLong nOffsetTemp = pEnd->nNode.GetIndex() - pStart->nNode.GetIndex();
 
     if( 0 == ( nsRedlineMode_t::REDLINE_SHOW_DELETE & rDoc.GetRedlineMode()) )
     {
@@ -257,7 +262,7 @@ void SwUndoRedlineSort::_Undo( SwUndoIter& rIter )
         // damit die Nodes wieder uebereinstimmen!
         // das Geloeschte ist versteckt, also suche das INSERT
         // Redline Object. Dahinter steht das Geloeschte
-        USHORT nFnd = rDoc.GetRedlinePos(
+        sal_uInt16 nFnd = rDoc.GetRedlinePos(
                             *rDoc.GetNodes()[ nSttNode + 1 ],
                             nsRedlineType_t::REDLINE_INSERT );
         OSL_ENSURE( USHRT_MAX != nFnd && nFnd+1 < rDoc.GetRedlineTbl().Count(),
@@ -267,7 +272,7 @@ void SwUndoRedlineSort::_Undo( SwUndoIter& rIter )
     }
 
     {
-        SwPaM aTmp( *rIter.pAktPam->GetMark() );
+        SwPaM aTmp( *rPam.GetMark() );
         aTmp.GetMark()->nContent = 0;
         aTmp.SetMark();
         aTmp.GetPoint()->nNode = nSaveEndNode;
@@ -275,9 +280,9 @@ void SwUndoRedlineSort::_Undo( SwUndoIter& rIter )
         rDoc.DeleteRedline( aTmp, true, USHRT_MAX );
     }
 
-    rDoc.DelFullPara( *rIter.pAktPam );
+    rDoc.DelFullPara(rPam);
 
-    SwPaM*  pPam = rIter.pAktPam;
+    SwPaM *const pPam = & rPam;
     pPam->DeleteMark();
     pPam->GetPoint()->nNode.Assign( aPrevIdx.GetNode(), +1 );
     SwCntntNode* pCNd = pPam->GetCntntNode();
@@ -290,22 +295,20 @@ void SwUndoRedlineSort::_Undo( SwUndoIter& rIter )
 
     SetValues( *pPam );
 
-    SetPaM( *rIter.pAktPam );
+    SetPaM(rPam);
 }
 
-void SwUndoRedlineSort::_Redo( SwUndoIter& rIter )
+void SwUndoRedlineSort::RedoRedlineImpl(SwDoc & rDoc, SwPaM & rPam)
 {
-    SwPaM& rPam = *rIter.pAktPam;
-
     SwPaM* pPam = &rPam;
     SwPosition* pStart = pPam->Start();
     SwPosition* pEnd   = pPam->End();
 
     SwNodeIndex aPrevIdx( pStart->nNode, -1 );
-    ULONG nOffsetTemp = pEnd->nNode.GetIndex() - pStart->nNode.GetIndex();
+    sal_uLong nOffsetTemp = pEnd->nNode.GetIndex() - pStart->nNode.GetIndex();
     xub_StrLen nCntStt	= pStart->nContent.GetIndex();
 
-    rIter.GetDoc().SortText( rPam, *pOpt );
+    rDoc.SortText(rPam, *pOpt);
 
     pPam->DeleteMark();
     pPam->GetPoint()->nNode.Assign( aPrevIdx.GetNode(), +1 );
@@ -327,9 +330,9 @@ void SwUndoRedlineSort::_Redo( SwUndoIter& rIter )
     rPam.GetPoint()->nContent.Assign( rPam.GetCntntNode(), nSaveEndCntnt );
 }
 
-void SwUndoRedlineSort::Repeat( SwUndoIter& rIter )
+void SwUndoRedlineSort::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    rIter.GetDoc().SortText( *rIter.pAktPam, *pOpt );
+    rContext.GetDoc().SortText( rContext.GetRepeatPaM(), *pOpt );
 }
 
 void SwUndoRedlineSort::SetSaveRange( const SwPaM& rRange )
@@ -344,21 +347,21 @@ void SwUndoRedlineSort::SetOffset( const SwNodeIndex& rIdx )
     nOffset = rIdx.GetIndex() - nSttNode;
 }
 
-/*  */
+// SwUndoAcceptRedline ///////////////////////////////////////////////////
 
 SwUndoAcceptRedline::SwUndoAcceptRedline( const SwPaM& rRange )
     : SwUndoRedline( UNDO_ACCEPT_REDLINE, rRange )
 {
 }
 
-void SwUndoAcceptRedline::_Redo( SwUndoIter& rIter )
+void SwUndoAcceptRedline::RedoRedlineImpl(SwDoc & rDoc, SwPaM & rPam)
 {
-    rIter.GetDoc().AcceptRedline( *rIter.pAktPam, false );
+    rDoc.AcceptRedline(rPam, false);
 }
 
-void SwUndoAcceptRedline::Repeat( SwUndoIter& rIter )
+void SwUndoAcceptRedline::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    rIter.GetDoc().AcceptRedline( *rIter.pAktPam, true );
+    rContext.GetDoc().AcceptRedline(rContext.GetRepeatPaM(), true);
 }
 
 SwUndoRejectRedline::SwUndoRejectRedline( const SwPaM& rRange )
@@ -366,19 +369,19 @@ SwUndoRejectRedline::SwUndoRejectRedline( const SwPaM& rRange )
 {
 }
 
-void SwUndoRejectRedline::_Redo( SwUndoIter& rIter )
+void SwUndoRejectRedline::RedoRedlineImpl(SwDoc & rDoc, SwPaM & rPam)
 {
-    rIter.GetDoc().RejectRedline( *rIter.pAktPam, false );
+    rDoc.RejectRedline(rPam, false);
 }
 
-void SwUndoRejectRedline::Repeat( SwUndoIter& rIter )
+void SwUndoRejectRedline::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    rIter.GetDoc().RejectRedline( *rIter.pAktPam, true );
+    rContext.GetDoc().RejectRedline(rContext.GetRepeatPaM(), true);
 }
 
-/*  */
+// SwUndoCompDoc /////////////////////////////////////////////////////////
 
-SwUndoCompDoc::SwUndoCompDoc( const SwPaM& rRg, BOOL bIns )
+SwUndoCompDoc::SwUndoCompDoc( const SwPaM& rRg, sal_Bool bIns )
     : SwUndo( UNDO_COMPAREDOC ), SwUndRng( rRg ), pRedlData( 0 ),
     pUnDel( 0 ), pUnDel2( 0 ), pRedlSaveData( 0 ), bInsert( bIns )
 {
@@ -405,7 +408,7 @@ SwUndoCompDoc::SwUndoCompDoc( const SwRedline& rRedl )
     }
 
     pRedlSaveData = new SwRedlineSaveDatas;
-    if( !FillSaveData( rRedl, *pRedlSaveData, FALSE, TRUE ))
+    if( !FillSaveData( rRedl, *pRedlSaveData, sal_False, sal_True ))
         delete pRedlSaveData, pRedlSaveData = 0;
 }
 
@@ -417,12 +420,10 @@ SwUndoCompDoc::~SwUndoCompDoc()
     delete pRedlSaveData;
 }
 
-void SwUndoCompDoc::Undo( SwUndoIter& rIter )
+void SwUndoCompDoc::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
-
-    SetPaM( *pPam );
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pPam( & AddUndoRedoPaM(rContext) );
 
     if( !bInsert )
     {
@@ -435,8 +436,8 @@ void SwUndoCompDoc::Undo( SwUndoIter& rIter )
         pDoc->SetRedlineMode_intern( eOld );
 
         //per definition Point is end (in SwUndRng!)
-        SwCntntNode* pCSttNd = pPam->GetCntntNode( FALSE );
-        SwCntntNode* pCEndNd = pPam->GetCntntNode( TRUE );
+        SwCntntNode* pCSttNd = pPam->GetCntntNode( sal_False );
+        SwCntntNode* pCEndNd = pPam->GetCntntNode( sal_True );
 
         // if start- and end-content is zero, then the doc-compare moves
         // complete nodes into the current doc. And then the selection
@@ -445,10 +446,10 @@ void SwUndoCompDoc::Undo( SwUndoIter& rIter )
         if( !nSttCntnt && !nEndCntnt )
             pPam->Exchange();
 
-        BOOL bJoinTxt, bJoinPrev;
+        sal_Bool bJoinTxt, bJoinPrev;
         ::lcl_GetJoinFlags( *pPam, bJoinTxt, bJoinPrev );
 
-        pUnDel = new SwUndoDelete( *pPam, FALSE );
+        pUnDel = new SwUndoDelete( *pPam, sal_False );
 
         if( bJoinTxt )
             ::lcl_JoinText( *pPam, bJoinPrev );
@@ -456,7 +457,7 @@ void SwUndoCompDoc::Undo( SwUndoIter& rIter )
         if( pCSttNd && !pCEndNd)
         {
             // #112139# Do not step behind the end of content.
-            SwNode * pTmp = pPam->GetNode(TRUE);
+            SwNode * pTmp = pPam->GetNode(sal_True);
             if (pTmp)
             {
                 SwNode * pEnd = pDoc->GetNodes().DocumentSectionEndNode(pTmp);
@@ -465,9 +466,9 @@ void SwUndoCompDoc::Undo( SwUndoIter& rIter )
                 {
                     pPam->SetMark();
                     pPam->GetPoint()->nNode++;
-                    pPam->GetBound( TRUE ).nContent.Assign( 0, 0 );
-                    pPam->GetBound( FALSE ).nContent.Assign( 0, 0 );
-                    pUnDel2 = new SwUndoDelete( *pPam, TRUE );
+                    pPam->GetBound( sal_True ).nContent.Assign( 0, 0 );
+                    pPam->GetBound( sal_False ).nContent.Assign( 0, 0 );
+                    pUnDel2 = new SwUndoDelete( *pPam, sal_True );
                 }
             }
         }
@@ -482,22 +483,17 @@ void SwUndoCompDoc::Undo( SwUndoIter& rIter )
             if( pRedlSaveData )
                 SetSaveData( *pDoc, *pRedlSaveData );
         }
-        SetPaM( rIter, TRUE );
+        SetPaM(*pPam, true);
     }
 }
 
-void SwUndoCompDoc::Redo( SwUndoIter& rIter )
+void SwUndoCompDoc::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    // setze noch den Cursor auf den Redo-Bereich
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
-
-    rIter.pLastUndoObj = 0;
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pPam( & AddUndoRedoPaM(rContext) );
 
     if( bInsert )
     {
-        SetPaM( *pPam );
-
         if( pRedlData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
         {
             SwRedline* pTmp = new SwRedline( *pRedlData, *pPam );
@@ -522,10 +518,10 @@ void SwUndoCompDoc::Redo( SwUndoIter& rIter )
 
         if( pUnDel2 )
         {
-            pUnDel2->Undo( rIter );
+            pUnDel2->UndoImpl(rContext);
             delete pUnDel2, pUnDel2 = 0;
         }
-        pUnDel->Undo( rIter );
+        pUnDel->UndoImpl(rContext);
         delete pUnDel, pUnDel = 0;
 
         SetPaM( *pPam );
@@ -538,8 +534,8 @@ void SwUndoCompDoc::Redo( SwUndoIter& rIter )
 //		pDoc->SetRedlineMode_intern( eOld );
     }
 
-    SetPaM( rIter, TRUE );
+    SetPaM(*pPam, true);
 }
 
 
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
\ No newline at end of file
diff --git a/sw/source/core/undo/unsect.cxx b/sw/source/core/undo/unsect.cxx
index 8d51db6b1a..6eeff58dec 100644
--- a/sw/source/core/undo/unsect.cxx
+++ b/sw/source/core/undo/unsect.cxx
@@ -29,6 +29,7 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <UndoSection.hxx>
 
 #include <sfx2/linkmgr.hxx>
 #include <fmtcntnt.hxx>
@@ -37,7 +38,7 @@
 #include <swundo.hxx>			// fuer die UndoIds
 #include <pam.hxx>
 #include <ndtxt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
 #include <section.hxx>
 #include <rolbck.hxx>
 #include <redline.hxx>
@@ -49,8 +50,6 @@
 #include <calc.hxx>
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 SfxItemSet* lcl_GetAttrSet( const SwSection& rSect )
 {
     // Attribute des Formate sichern (Spalten, Farbe, ... )
@@ -59,7 +58,7 @@ SfxItemSet* lcl_GetAttrSet( const SwSection& rSect )
     SfxItemSet* pAttr = 0;
     if( rSect.GetFmt() )
     {
-        USHORT nCnt = 1;
+        sal_uInt16 nCnt = 1;
         if( rSect.IsProtect() )
             ++nCnt;
 
@@ -123,9 +122,9 @@ SwUndoInsSection::~SwUndoInsSection()
 {
 }
 
-void SwUndoInsSection::Undo( SwUndoIter& rUndoIter )
+void SwUndoInsSection::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     RemoveIdxFromSection( rDoc, m_nSectionNodePos );
 
@@ -168,25 +167,23 @@ void SwUndoInsSection::Undo( SwUndoIter& rUndoIter )
         rDoc.GetFtnIdxs().UpdateFtn( aIdx );
     }
 
-    SetPaM( rUndoIter );
+    AddUndoRedoPaM(rContext);
 }
 
-
-void SwUndoInsSection::Redo( SwUndoIter& rUndoIter )
+void SwUndoInsSection::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
-    SetPaM( rUndoIter );
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
 
     const SwTOXBaseSection* pUpdateTOX = 0;
     if (m_pTOXBase.get())
     {
-        pUpdateTOX = rDoc.InsertTableOf( *rUndoIter.pAktPam->GetPoint(),
+        pUpdateTOX = rDoc.InsertTableOf( *rPam.GetPoint(),
                                         *m_pTOXBase, m_pAttrSet.get(), true);
     }
     else
     {
-        rDoc.InsertSwSection(*rUndoIter.pAktPam,
-                *m_pSectionData, 0, m_pAttrSet.get(), true);
+        rDoc.InsertSwSection(rPam, *m_pSectionData, 0, m_pAttrSet.get(), true);
     }
 
     if (m_pHistory.get())
@@ -225,23 +222,22 @@ void SwUndoInsSection::Redo( SwUndoIter& rUndoIter )
     }
 }
 
-
-void SwUndoInsSection::Repeat( SwUndoIter& rUndoIter )
+void SwUndoInsSection::RepeatImpl(::sw::RepeatContext & rContext)
 {
+    SwDoc & rDoc = rContext.GetDoc();
     if (m_pTOXBase.get())
     {
-        rUndoIter.GetDoc().InsertTableOf( *rUndoIter.pAktPam->GetPoint(),
+        rDoc.InsertTableOf(*rContext.GetRepeatPaM().GetPoint(),
                                         *m_pTOXBase, m_pAttrSet.get(), true);
     }
     else
     {
-        rUndoIter.GetDoc().InsertSwSection( *rUndoIter.pAktPam,
+        rDoc.InsertSwSection(rContext.GetRepeatPaM(),
             *m_pSectionData, 0, m_pAttrSet.get());
     }
 }
 
-
-void SwUndoInsSection::Join( SwDoc& rDoc, ULONG nNode )
+void SwUndoInsSection::Join( SwDoc& rDoc, sal_uLong nNode )
 {
     SwNodeIndex aIdx( rDoc.GetNodes(), nNode );
     SwTxtNode* pTxtNd = aIdx.GetNode().GetTxtNode();
@@ -295,15 +291,17 @@ private:
     ::std::auto_ptr<SwTOXBase> const m_pTOXBase; /// set iff section is TOX
     ::std::auto_ptr<SfxItemSet> const m_pAttrSet;
     ::boost::shared_ptr< ::sfx2::MetadatableUndo > const m_pMetadataUndo;
-    ULONG const m_nStartNode;
-    ULONG const m_nEndNode;
+    sal_uLong const m_nStartNode;
+    sal_uLong const m_nEndNode;
 
 public:
     SwUndoDelSection(
         SwSectionFmt const&, SwSection const&, SwNodeIndex const*const);
+
     virtual ~SwUndoDelSection();
-    virtual void Undo( SwUndoIter& );
-    virtual void Redo( SwUndoIter& );
+
+    virtual void UndoImpl( ::sw::UndoRedoContext & );
+    virtual void RedoImpl( ::sw::UndoRedoContext & );
 };
 
 SW_DLLPRIVATE SwUndo * MakeUndoDelSection(SwSectionFmt const& rFormat)
@@ -331,9 +329,9 @@ SwUndoDelSection::~SwUndoDelSection()
 {
 }
 
-void SwUndoDelSection::Undo( SwUndoIter& rUndoIter )
+void SwUndoDelSection::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     if (m_pTOXBase.get())
     {
@@ -384,9 +382,9 @@ void SwUndoDelSection::Undo( SwUndoIter& rUndoIter )
     }
 }
 
-void SwUndoDelSection::Redo( SwUndoIter& rUndoIter )
+void SwUndoDelSection::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     SwSectionNode *const pNd =
         rDoc.GetNodes()[ m_nStartNode ]->GetSectionNode();
@@ -404,15 +402,17 @@ class SwUndoUpdateSection
 private:
     ::std::auto_ptr<SwSectionData> m_pSectionData;
     ::std::auto_ptr<SfxItemSet> m_pAttrSet;
-    ULONG const m_nStartNode;
+    sal_uLong const m_nStartNode;
     bool const m_bOnlyAttrChanged;
 
 public:
     SwUndoUpdateSection(
         SwSection const&, SwNodeIndex const*const, bool const bOnlyAttr);
+
     virtual ~SwUndoUpdateSection();
-    virtual void Undo( SwUndoIter& );
-    virtual void Redo( SwUndoIter& );
+
+    virtual void UndoImpl( ::sw::UndoRedoContext & );
+    virtual void RedoImpl( ::sw::UndoRedoContext & );
 };
 
 SW_DLLPRIVATE SwUndo *
@@ -437,9 +437,9 @@ SwUndoUpdateSection::~SwUndoUpdateSection()
 {
 }
 
-void SwUndoUpdateSection::Undo( SwUndoIter& rUndoIter )
+void SwUndoUpdateSection::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwSectionNode *const pSectNd =
         rDoc.GetNodes()[ m_nStartNode ]->GetSectionNode();
     OSL_ENSURE( pSectNd, "wo ist mein SectionNode?" );
@@ -453,7 +453,7 @@ void SwUndoUpdateSection::Undo( SwUndoIter& rUndoIter )
         // das Content- und Protect-Item muss bestehen bleiben
         const SfxPoolItem* pItem;
         m_pAttrSet->Put( pFmt->GetFmtAttr( RES_CNTNT ));
-        if( SFX_ITEM_SET == pFmt->GetItemState( RES_PROTECT, TRUE, &pItem ))
+        if( SFX_ITEM_SET == pFmt->GetItemState( RES_PROTECT, sal_True, &pItem ))
         {
             m_pAttrSet->Put( *pItem );
         }
@@ -493,9 +493,9 @@ void SwUndoUpdateSection::Undo( SwUndoIter& rUndoIter )
     }
 }
 
-void SwUndoUpdateSection::Redo( SwUndoIter& rUndoIter )
+void SwUndoUpdateSection::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    Undo( rUndoIter );
+    UndoImpl(rContext);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/undo/unsort.cxx b/sw/source/core/undo/unsort.cxx
index 03aebaa894..9d4a870ac3 100644
--- a/sw/source/core/undo/unsort.cxx
+++ b/sw/source/core/undo/unsort.cxx
@@ -28,18 +28,21 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
+
+#include <UndoSort.hxx>
+
 #include <doc.hxx>
 #include <swundo.hxx>			// fuer die UndoIds
 #include <pam.hxx>
 #include <swtable.hxx>
 #include <ndtxt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
+#include <UndoTable.hxx>
 #include <sortopt.hxx>
 #include <docsort.hxx>
 #include <redline.hxx>
 #include <node2lay.hxx>
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
 
 /*--------------------------------------------------------------------
     Beschreibung:  Undo fuers Sorting
@@ -68,9 +71,8 @@ SwUndoSort::SwUndoSort(const SwPaM& rRg, const SwSortOptions& rOpt)
     pSortOpt = new SwSortOptions(rOpt);
 }
 
-
-SwUndoSort::SwUndoSort( ULONG nStt, ULONG nEnd, const SwTableNode& rTblNd,
-                        const SwSortOptions& rOpt, BOOL bSaveTable )
+SwUndoSort::SwUndoSort( sal_uLong nStt, sal_uLong nEnd, const SwTableNode& rTblNd,
+                        const SwSortOptions& rOpt, sal_Bool bSaveTable )
     : SwUndo(UNDO_SORT_TBL), pUndoTblAttr( 0 ), pRedlData( 0 )
 {
     nSttNode = nStt;
@@ -82,8 +84,6 @@ SwUndoSort::SwUndoSort( ULONG nStt, ULONG nEnd, const SwTableNode& rTblNd,
         pUndoTblAttr = new SwUndoAttrTbl( rTblNd );
 }
 
-
-
 SwUndoSort::~SwUndoSort()
 {
     delete pSortOpt;
@@ -91,18 +91,18 @@ SwUndoSort::~SwUndoSort()
     delete pRedlData;
 }
 
-
-
-void SwUndoSort::Undo( SwUndoIter& rIter)
+void SwUndoSort::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& 	rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     if(pSortOpt->bTable)
     {
         // Undo Tabelle
         RemoveIdxFromSection( rDoc, nSttNode, &nEndNode );
 
         if( pUndoTblAttr )
-            pUndoTblAttr->Undo( rIter );
+        {
+            pUndoTblAttr->UndoImpl(rContext);
+        }
 
         SwTableNode* pTblNd = rDoc.GetNodes()[ nTblNd ]->GetTableNode();
 
@@ -115,7 +115,7 @@ void SwUndoSort::Undo( SwUndoIter& rIter)
         const SwTable& rTbl = pTblNd->GetTable();
 
         SwMovedBoxes aMovedList;
-        for( USHORT i=0; i < aSortList.Count(); i++)
+        for( sal_uInt16 i=0; i < aSortList.Count(); i++)
         {
             const SwTableBox* pSource = rTbl.GetTblBox(
                     *aSortList[i]->SORT_TXT_TBL.TBL.pSource );
@@ -133,23 +133,24 @@ void SwUndoSort::Undo( SwUndoIter& rIter)
         // Restore table frames:
         // --> FME 2004-11-26 #i37739# A simple 'MakeFrms' after the node sorting
         // does not work if the table is inside a frame and has no prev/next.
-        const ULONG nIdx = pTblNd->GetIndex();
+        const sal_uLong nIdx = pTblNd->GetIndex();
         aNode2Layout.RestoreUpperFrms( rDoc.GetNodes(), nIdx, nIdx + 1 );
         // <--
     }
     else
     {
         // Undo Text
-        RemoveIdx( *rIter.pAktPam );
+        SwPaM & rPam( AddUndoRedoPaM(rContext) );
+        RemoveIdxFromRange(rPam, true);
 
         // fuer die sorted Positions einen Index anlegen.
         // JP 25.11.97: Die IndexList muss aber nach SourcePosition
         //				aufsteigend sortiert aufgebaut werden
-        SwUndoSortList aIdxList( (BYTE)aSortList.Count() );
-        USHORT i;
+        SwUndoSortList aIdxList( (sal_uInt8)aSortList.Count() );
+        sal_uInt16 i;
 
         for( i = 0; i < aSortList.Count(); ++i)
-            for( USHORT ii=0; ii < aSortList.Count(); ++ii )
+            for( sal_uInt16 ii=0; ii < aSortList.Count(); ++ii )
                 if( aSortList[ii]->SORT_TXT_TBL.TXT.nSource == nSttNode + i )
                 {
                     SwNodeIndex* pIdx = new SwNodeIndex( rDoc.GetNodes(),
@@ -167,14 +168,13 @@ void SwUndoSort::Undo( SwUndoIter& rIter)
         }
         // Indixes loeschen
         aIdxList.DeleteAndDestroy(0, aIdxList.Count());
-        SetPaM( rIter, TRUE );
+        SetPaM(rPam, true);
     }
 }
 
-
-void SwUndoSort::Redo( SwUndoIter& rIter)
+void SwUndoSort::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     if(pSortOpt->bTable)
     {
@@ -192,7 +192,7 @@ void SwUndoSort::Redo( SwUndoIter& rIter)
         const SwTable& rTbl = pTblNd->GetTable();
 
         SwMovedBoxes aMovedList;
-        for(USHORT i=0; i < aSortList.Count(); ++i)
+        for(sal_uInt16 i=0; i < aSortList.Count(); ++i)
         {
             const SwTableBox* pSource = rTbl.GetTblBox(
                     (const String&) *aSortList[i]->SORT_TXT_TBL.TBL.pSource );
@@ -207,22 +207,26 @@ void SwUndoSort::Redo( SwUndoIter& rIter)
         }
 
         if( pUndoTblAttr )
-            pUndoTblAttr->Redo( rIter );
+        {
+            pUndoTblAttr->RedoImpl(rContext);
+        }
 
         // Restore table frames:
         // --> FME 2004-11-26 #i37739# A simple 'MakeFrms' after the node sorting
         // does not work if the table is inside a frame and has no prev/next.
-        const ULONG nIdx = pTblNd->GetIndex();
+        const sal_uLong nIdx = pTblNd->GetIndex();
         aNode2Layout.RestoreUpperFrms( rDoc.GetNodes(), nIdx, nIdx + 1 );
         // <--
     }
     else
     {
-        // Redo bei Text
-        RemoveIdx( *rIter.pAktPam );
+        // Redo for Text
+        SwPaM & rPam( AddUndoRedoPaM(rContext) );
+        SetPaM(rPam);
+        RemoveIdxFromRange(rPam, true);
 
-        SwUndoSortList aIdxList( (BYTE)aSortList.Count() );
-        USHORT i;
+        SwUndoSortList aIdxList( (sal_uInt8)aSortList.Count() );
+        sal_uInt16 i;
 
         for( i = 0; i < aSortList.Count(); ++i)
         {	// aktuelle Pos ist die Ausgangslage
@@ -240,63 +244,39 @@ void SwUndoSort::Redo( SwUndoIter& rIter)
         }
         // Indixes loeschen
         aIdxList.DeleteAndDestroy(0, aIdxList.Count());
-        SetPaM( rIter, TRUE );
-        const SwTxtNode* pTNd = rIter.pAktPam->GetNode()->GetTxtNode();
+        SetPaM(rPam, true);
+        SwTxtNode const*const pTNd = rPam.GetNode()->GetTxtNode();
         if( pTNd )
-            rIter.pAktPam->GetPoint()->nContent = pTNd->GetTxt().Len();
+        {
+            rPam.GetPoint()->nContent = pTNd->GetTxt().Len();
+        }
     }
 }
 
-
-void SwUndoSort::Repeat(SwUndoIter& rIter)
+void SwUndoSort::RepeatImpl(::sw::RepeatContext & rContext)
 {
+    // table not repeat capable
     if(!pSortOpt->bTable)
     {
-        SwPaM* pPam = rIter.pAktPam;
+        SwPaM *const pPam = & rContext.GetRepeatPaM();
         SwDoc& rDoc = *pPam->GetDoc();
 
         if( !rDoc.IsIdxInTbl( pPam->Start()->nNode ) )
             rDoc.SortText(*pPam, *pSortOpt);
     }
-    // Tabelle ist nicht Repeat-Faehig
-    rIter.pLastUndoObj = this;
-}
-
-
-void SwUndoSort::RemoveIdx( SwPaM& rPam )
-{
-    rPam.DeleteMark();
-    rPam.GetPoint()->nNode = nSttNode;
-
-    SwCntntNode* pCNd = rPam.GetCntntNode();
-    xub_StrLen nLen = pCNd->Len();
-    if( nLen >= nSttCntnt )
-        nLen = nSttCntnt;
-    rPam.GetPoint()->nContent.Assign(pCNd, nLen );
-    rPam.SetMark();
-
-    rPam.GetPoint()->nNode = nEndNode;
-    pCNd = rPam.GetCntntNode();
-    nLen = pCNd->Len();
-    if( nLen >= nEndCntnt )
-        nLen = nEndCntnt;
-    rPam.GetPoint()->nContent.Assign(pCNd, nLen );
-    RemoveIdxFromRange( rPam, TRUE );
 }
 
-
 void SwUndoSort::Insert( const String& rOrgPos, const String& rNewPos)
 {
     SwSortUndoElement* pEle = new SwSortUndoElement(rOrgPos, rNewPos);
     aSortList.C40_INSERT( SwSortUndoElement, pEle, aSortList.Count() );
 }
 
-
-void SwUndoSort::Insert( ULONG nOrgPos, ULONG nNewPos)
+void SwUndoSort::Insert( sal_uLong nOrgPos, sal_uLong nNewPos)
 {
     SwSortUndoElement* pEle = new SwSortUndoElement(nOrgPos, nNewPos);
     aSortList.C40_INSERT( SwSortUndoElement, pEle, aSortList.Count() );
 }
 
 
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
\ No newline at end of file
diff --git a/sw/source/core/undo/unspnd.cxx b/sw/source/core/undo/unspnd.cxx
index 875da9c9bc..3c19d4e787 100644
--- a/sw/source/core/undo/unspnd.cxx
+++ b/sw/source/core/undo/unspnd.cxx
@@ -29,6 +29,7 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <UndoSplitMove.hxx>
 
 #include "doc.hxx"
 #include "pam.hxx"
@@ -38,13 +39,11 @@
 #include <editeng/brkitem.hxx>
 #include <fmtpdsc.hxx>
 #include <frmfmt.hxx>
-#include "undobj.hxx"
+#include <UndoCore.hxx>
 #include "rolbck.hxx"
 #include "redline.hxx"
 #include "docary.hxx"
-
-
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
+#include <IShellCursorSupplier.hxx>
 
 
 //------------------------------------------------------------------
@@ -53,12 +52,12 @@ inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
 
 
 SwUndoSplitNode::SwUndoSplitNode( SwDoc* pDoc, const SwPosition& rPos,
-                                    BOOL bChkTable )
+                                    sal_Bool bChkTable )
     : SwUndo( UNDO_SPLITNODE ), pHistory( 0 ), pRedlData( 0 ), nNode( rPos.nNode.GetIndex() ),
         nCntnt( rPos.nContent.GetIndex() ),
-        bTblFlag( FALSE ), bChkTblStt( bChkTable )
+        bTblFlag( sal_False ), bChkTblStt( bChkTable )
 {
-    SwTxtNode* pTxtNd = pDoc->GetNodes()[ rPos.nNode ]->GetTxtNode();
+    SwTxtNode *const pTxtNd = rPos.nNode.GetNode().GetTxtNode();
     OSL_ENSURE( pTxtNd, "nur beim TextNode rufen!" );
     if( pTxtNd->GetpSwpHints() )
     {
@@ -76,21 +75,16 @@ SwUndoSplitNode::SwUndoSplitNode( SwDoc* pDoc, const SwPosition& rPos,
     }
 }
 
-
-
-
 SwUndoSplitNode::~SwUndoSplitNode()
 {
     delete pHistory;
     delete pRedlData;
 }
 
-
-
-void SwUndoSplitNode::Undo( SwUndoIter& rUndoIter )
+void SwUndoSplitNode::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rUndoIter.GetDoc();
-    SwPaM& rPam = *rUndoIter.pAktPam;
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM & rPam( rContext.GetCursorSupplier().CreateNewShellCursor() );
     rPam.DeleteMark();
     if( bTblFlag )
     {
@@ -109,11 +103,11 @@ void SwUndoSplitNode::Undo( SwUndoIter& rUndoIter )
             if( pNdSet )
             {
                 const SfxPoolItem *pItem;
-                if( SFX_ITEM_SET == pNdSet->GetItemState( RES_PAGEDESC, FALSE,
+                if( SFX_ITEM_SET == pNdSet->GetItemState( RES_PAGEDESC, sal_False,
                     &pItem ) )
                     pTableFmt->SetFmtAttr( *pItem );
 
-                if( SFX_ITEM_SET == pNdSet->GetItemState( RES_BREAK, FALSE,
+                if( SFX_ITEM_SET == pNdSet->GetItemState( RES_BREAK, sal_False,
                      &pItem ) )
                     pTableFmt->SetFmtAttr( *pItem );
             }
@@ -152,7 +146,7 @@ void SwUndoSplitNode::Undo( SwUndoIter& rUndoIter )
                 rPam.SetMark();
                 rPam.GetPoint()->nContent = pTNd->GetTxt().Len();
 
-                pDoc->RstTxtAttrs( rPam, TRUE );
+                pDoc->RstTxtAttrs( rPam, sal_True );
                 pHistory->TmpRollback( pDoc, 0, false );
             }
         }
@@ -164,23 +158,13 @@ void SwUndoSplitNode::Undo( SwUndoIter& rUndoIter )
     rPam.GetPoint()->nContent.Assign( rPam.GetCntntNode(), nCntnt );
 }
 
-
-void SwUndoSplitNode::Repeat( SwUndoIter& rUndoIter )
-{
-    if( UNDO_SPLITNODE == rUndoIter.GetLastUndoId() )
-        return;
-    rUndoIter.GetDoc().SplitNode( *rUndoIter.pAktPam->GetPoint(), bChkTblStt );
-    rUndoIter.pLastUndoObj = this;
-}
-
-
-void SwUndoSplitNode::Redo( SwUndoIter& rUndoIter )
+void SwUndoSplitNode::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM& rPam = *rUndoIter.pAktPam;
-    ULONG nOldNode = rPam.GetPoint()->nNode.GetIndex();
+    SwPaM & rPam( rContext.GetCursorSupplier().CreateNewShellCursor() );
     rPam.GetPoint()->nNode = nNode;
     SwTxtNode * pTNd = rPam.GetNode()->GetTxtNode();
-    if( pTNd )              // sollte eigentlich immer ein TextNode sein !!
+    OSL_ENSURE(pTNd, "SwUndoSplitNode::RedoImpl(): SwTxtNode expected");
+    if (pTNd)
     {
         rPam.GetPoint()->nContent.Assign( pTNd, nCntnt );
 
@@ -211,8 +195,12 @@ void SwUndoSplitNode::Redo( SwUndoIter& rUndoIter )
             rPam.DeleteMark();
         }
     }
-    else
-        rPam.GetPoint()->nNode = nOldNode;
+}
+
+void SwUndoSplitNode::RepeatImpl(::sw::RepeatContext & rContext)
+{
+    rContext.GetDoc().SplitNode(
+        *rContext.GetRepeatPaM().GetPoint(), bChkTblStt );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/core/undo/untbl.cxx b/sw/source/core/undo/untbl.cxx
index 270919571f..7fcf5c15c8 100644
--- a/sw/source/core/undo/untbl.cxx
+++ b/sw/source/core/undo/untbl.cxx
@@ -29,12 +29,19 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
+#include <UndoTable.hxx>
 
+#include <UndoRedline.hxx>
+#include <UndoDelete.hxx>
+#include <UndoSplitMove.hxx>
+#include <UndoCore.hxx>
 #include <hintids.hxx>
+#include <hints.hxx>
 #include <editeng/brkitem.hxx>
 #include <fmtornt.hxx>
 #include <fmtpdsc.hxx>
 #include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
 #include <editsh.hxx>
 #include <docary.hxx>
 #include <ndtxt.hxx>
@@ -43,7 +50,6 @@
 #include <cntfrm.hxx>
 #include <tblsel.hxx>
 #include <swundo.hxx>			// fuer die UndoIds
-#include <undobj.hxx>
 #include <rolbck.hxx>
 #include <ddefld.hxx>
 #include <tabcol.hxx>
@@ -77,7 +83,6 @@
     #define _DEBUG_REDLINE( pDoc )
 #endif
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
 extern void ClearFEShellTabCols();
 
 typedef SfxItemSet* SfxItemSetPtr;
@@ -95,7 +100,7 @@ SV_DECL_PTRARR_DEL( SwTblToTxtSaves, SwTblToTxtSavePtr, 0, 10 )
 
 struct _UndoTblCpyTbl_Entry
 {
-    ULONG nBoxIdx, nOffset;
+    sal_uLong nBoxIdx, nOffset;
     SfxItemSet* pBoxNumAttr;
     SwUndo* pUndo;
 
@@ -120,25 +125,25 @@ class _SaveTable
     const SwTable* pSwTable;
     SfxItemSets aSets;
     SwFrmFmts aFrmFmts;
-    USHORT nLineCount;
-    BOOL bModifyBox : 1;
-    BOOL bSaveFormula : 1;
-    BOOL bNewModel : 1;
+    sal_uInt16 nLineCount;
+    sal_Bool bModifyBox : 1;
+    sal_Bool bSaveFormula : 1;
+    sal_Bool bNewModel : 1;
 
 public:
-    _SaveTable( const SwTable& rTbl, USHORT nLnCnt = USHRT_MAX,
-                BOOL bSaveFml = TRUE );
+    _SaveTable( const SwTable& rTbl, sal_uInt16 nLnCnt = USHRT_MAX,
+                sal_Bool bSaveFml = sal_True );
     ~_SaveTable();
 
-    USHORT AddFmt( SwFrmFmt* pFmt, bool bIsLine );
-    void NewFrmFmt( const SwClient* pLnBx, BOOL bIsLine, USHORT nFmtPos,
+    sal_uInt16 AddFmt( SwFrmFmt* pFmt, bool bIsLine );
+    void NewFrmFmt( const SwClient* pLnBx, sal_Bool bIsLine, sal_uInt16 nFmtPos,
                     SwFrmFmt* pOldFmt );
 
-    void RestoreAttr( SwTable& rTbl, BOOL bModifyBox = FALSE );
+    void RestoreAttr( SwTable& rTbl, sal_Bool bModifyBox = sal_False );
     void SaveCntntAttrs( SwDoc* pDoc );
-    void CreateNew( SwTable& rTbl, BOOL bCreateFrms = TRUE,
-                    BOOL bRestoreChart = TRUE );
-    BOOL IsNewModel() const { return bNewModel; }
+    void CreateNew( SwTable& rTbl, sal_Bool bCreateFrms = sal_True,
+                    sal_Bool bRestoreChart = sal_True );
+    sal_Bool IsNewModel() const { return bNewModel; }
 };
 
 class _SaveLine
@@ -148,7 +153,7 @@ class _SaveLine
 
     _SaveLine* pNext;
     _SaveBox* pBox;
-    USHORT nItemSet;
+    sal_uInt16 nItemSet;
 
 public:
 
@@ -166,9 +171,9 @@ class _SaveBox
     friend class _SaveLine;
 
     _SaveBox* pNext;
-    ULONG nSttNode;
+    sal_uLong nSttNode;
     long nRowSpan;
-    USHORT nItemSet;
+    sal_uInt16 nItemSet;
     union
     {
         SfxItemSets* pCntntAttrs;
@@ -185,8 +190,8 @@ public:
     void CreateNew( SwTable& rTbl, SwTableLine& rParent, _SaveTable& rSTbl );
 };
 
-void InsertSort( SvUShorts& rArr, USHORT nIdx, USHORT* pInsPos = 0 );
-void InsertSort( SvULongs& rArr, ULONG nIdx, USHORT* pInsPos = 0 );
+void InsertSort( SvUShorts& rArr, sal_uInt16 nIdx, sal_uInt16* pInsPos = 0 );
+void InsertSort( SvULongs& rArr, sal_uLong nIdx, sal_uInt16* pInsPos = 0 );
 
 #if OSL_DEBUG_LEVEL > 1
 #include "shellio.hxx"
@@ -204,15 +209,15 @@ So we need to remember not only the start node position but the end node positio
 
 struct SwTblToTxtSave
 {
-    ULONG m_nSttNd;
-    ULONG m_nEndNd;
+    sal_uLong m_nSttNd;
+    sal_uLong m_nEndNd;
     xub_StrLen m_nCntnt;
     SwHistory* m_pHstry;
     // metadata references for first and last paragraph in cell
     ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoStart;
     ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoEnd;
 
-    SwTblToTxtSave( SwDoc& rDoc, ULONG nNd, ULONG nEndIdx, xub_StrLen nCntnt );
+    SwTblToTxtSave( SwDoc& rDoc, sal_uLong nNd, sal_uLong nEndIdx, xub_StrLen nCntnt );
     ~SwTblToTxtSave() { delete m_pHstry; }
 };
 
@@ -222,7 +227,7 @@ SV_IMPL_PTRARR( SwUndoMoves, SwUndoMovePtr )
 SV_IMPL_PTRARR( SwTblToTxtSaves, SwTblToTxtSavePtr )
 SV_IMPL_PTRARR( _UndoTblCpyTbl_Entries, _UndoTblCpyTbl_EntryPtr )
 
-USHORT aSave_BoxCntntSet[] = {
+sal_uInt16 aSave_BoxCntntSet[] = {
     RES_CHRATR_COLOR, RES_CHRATR_CROSSEDOUT,
     RES_CHRATR_FONT, RES_CHRATR_FONTSIZE,
     RES_CHRATR_POSTURE,	RES_CHRATR_POSTURE,
@@ -232,8 +237,8 @@ USHORT aSave_BoxCntntSet[] = {
 
 
 
-SwUndoInsTbl::SwUndoInsTbl( const SwPosition& rPos, USHORT nCl, USHORT nRw,
-                            USHORT nAdj, const SwInsertTableOptions& rInsTblOpts,
+SwUndoInsTbl::SwUndoInsTbl( const SwPosition& rPos, sal_uInt16 nCl, sal_uInt16 nRw,
+                            sal_uInt16 nAdj, const SwInsertTableOptions& rInsTblOpts,
                             const SwTableAutoFmt* pTAFmt,
                             const SvUShorts* pColArr,
                             const String & rName)
@@ -269,9 +274,9 @@ SwUndoInsTbl::~SwUndoInsTbl()
     delete pAutoFmt;
 }
 
-void SwUndoInsTbl::Undo( SwUndoIter& rUndoIter )
+void SwUndoInsTbl::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode );
 
     SwTableNode* pTblNd = aIdx.GetNode().GetTableNode();
@@ -290,11 +295,11 @@ void SwUndoInsTbl::Undo( SwUndoIter& rUndoIter )
         const SfxPoolItem *pItem;
 
         if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_PAGEDESC,
-            FALSE, &pItem ) )
+            sal_False, &pItem ) )
             pNextNd->SetAttr( *pItem );
 
         if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_BREAK,
-            FALSE, &pItem ) )
+            sal_False, &pItem ) )
             pNextNd->SetAttr( *pItem );
     }
 
@@ -307,19 +312,18 @@ void SwUndoInsTbl::Undo( SwUndoIter& rUndoIter )
     rDoc.GetNodes().Delete( aIdx, pTblNd->EndOfSectionIndex() -
                                 aIdx.GetIndex() + 1 );
 
-    rUndoIter.pAktPam->DeleteMark();
-    rUndoIter.pAktPam->GetPoint()->nNode = aIdx;
-    rUndoIter.pAktPam->GetPoint()->nContent.Assign(
-                            rUndoIter.pAktPam->GetCntntNode(), 0 );
+    SwPaM & rPam( rContext.GetCursorSupplier().CreateNewShellCursor() );
+    rPam.DeleteMark();
+    rPam.GetPoint()->nNode = aIdx;
+    rPam.GetPoint()->nContent.Assign( rPam.GetCntntNode(), 0 );
 }
 
 
-void SwUndoInsTbl::Redo( SwUndoIter& rUndoIter )
+void SwUndoInsTbl::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
-    SwPosition aPos( *rUndoIter.pAktPam->GetPoint() );
-    aPos.nNode = nSttNode;
+    SwPosition const aPos(SwNodeIndex(rDoc.GetNodes(), nSttNode));
     const SwTable* pTbl = rDoc.InsertTable( aInsTblOpts, aPos, nRows, nCols,
                                             nAdjust,
                                             pAutoFmt, pColWidth );
@@ -340,7 +344,7 @@ void SwUndoInsTbl::Redo( SwUndoIter& rUndoIter )
             rDoc.GetRedlineTbl().Count() ))
     {
         SwPaM aPam( *pTblNode->EndOfSectionNode(), *pTblNode, 1 );
-        SwCntntNode* pCNd = aPam.GetCntntNode( FALSE );
+        SwCntntNode* pCNd = aPam.GetCntntNode( sal_False );
         if( pCNd )
             aPam.GetMark()->nContent.Assign( pCNd, 0 );
 
@@ -358,11 +362,11 @@ void SwUndoInsTbl::Redo( SwUndoIter& rUndoIter )
 }
 
 
-void SwUndoInsTbl::Repeat( SwUndoIter& rUndoIter )
+void SwUndoInsTbl::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    rUndoIter.GetDoc().InsertTable( aInsTblOpts, *rUndoIter.pAktPam->GetPoint(),
-                                        nRows, nCols, nAdjust,
-                                        pAutoFmt, pColWidth );
+    rContext.GetDoc().InsertTable(
+            aInsTblOpts, *rContext.GetRepeatPaM().GetPoint(),
+            nRows, nCols, nAdjust, pAutoFmt, pColWidth );
 }
 
 SwRewriter SwUndoInsTbl::GetRewriter() const
@@ -378,7 +382,7 @@ SwRewriter SwUndoInsTbl::GetRewriter() const
 
 // -----------------------------------------------------
 
-SwTblToTxtSave::SwTblToTxtSave( SwDoc& rDoc, ULONG nNd, ULONG nEndIdx, xub_StrLen nCnt )
+SwTblToTxtSave::SwTblToTxtSave( SwDoc& rDoc, sal_uLong nNd, sal_uLong nEndIdx, xub_StrLen nCnt )
     : m_nSttNd( nNd ), m_nEndNd( nEndIdx), m_nCntnt( nCnt ), m_pHstry( 0 )
 {
     // Attributierung des gejointen Node merken.
@@ -421,11 +425,11 @@ SwUndoTblToTxt::SwUndoTblToTxt( const SwTable& rTbl, sal_Unicode cCh )
     : SwUndo( UNDO_TABLETOTEXT ),
     sTblNm( rTbl.GetFrmFmt()->GetName() ), pDDEFldType( 0 ), pHistory( 0 ),
     nSttNd( 0 ), nEndNd( 0 ),
-    nAdjust( static_cast<USHORT>(rTbl.GetFrmFmt()->GetHoriOrient().GetHoriOrient()) ),
+    nAdjust( static_cast<sal_uInt16>(rTbl.GetFrmFmt()->GetHoriOrient().GetHoriOrient()) ),
     cTrenner( cCh ), nHdlnRpt( rTbl.GetRowsToRepeat() )
 {
     pTblSave = new _SaveTable( rTbl );
-    pBoxSaves = new SwTblToTxtSaves( (BYTE)rTbl.GetTabSortBoxes().Count() );
+    pBoxSaves = new SwTblToTxtSaves( (sal_uInt8)rTbl.GetTabSortBoxes().Count() );
 
     if( rTbl.IsA( TYPE( SwDDETable ) ) )
         pDDEFldType = (SwDDEFieldType*)((SwDDETable&)rTbl).GetDDEFldType()->Copy();
@@ -434,10 +438,10 @@ SwUndoTblToTxt::SwUndoTblToTxt( const SwTable& rTbl, sal_Unicode cCh )
 
     pHistory = new SwHistory;
     const SwTableNode* pTblNd = rTbl.GetTableNode();
-    ULONG nTblStt = pTblNd->GetIndex(), nTblEnd = pTblNd->EndOfSectionIndex();
+    sal_uLong nTblStt = pTblNd->GetIndex(), nTblEnd = pTblNd->EndOfSectionIndex();
 
     const SwSpzFrmFmts& rFrmFmtTbl = *pTblNd->GetDoc()->GetSpzFrmFmts();
-    for( USHORT n = 0; n < rFrmFmtTbl.Count(); ++n )
+    for( sal_uInt16 n = 0; n < rFrmFmtTbl.Count(); ++n )
     {
         SwFrmFmt* pFmt = rFrmFmtTbl[ n ];
         SwFmtAnchor const*const pAnchor = &pFmt->GetAnchor();
@@ -467,10 +471,10 @@ SwUndoTblToTxt::~SwUndoTblToTxt()
 
 
 
-void SwUndoTblToTxt::Undo( SwUndoIter& rUndoIter )
+void SwUndoTblToTxt::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
-    SwPaM* pPam = rUndoIter.pAktPam;
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 
     SwNodeIndex aFrmIdx( rDoc.GetNodes(), nSttNd );
     SwNodeIndex aEndIdx( rDoc.GetNodes(), nEndNd );
@@ -499,20 +503,20 @@ void SwUndoTblToTxt::Undo( SwUndoIter& rUndoIter )
         SwDDEFieldType* pNewType = (SwDDEFieldType*)rDoc.InsertFldType(
                                                             *pDDEFldType);
         SwDDETable* pDDETbl = new SwDDETable( pTblNd->GetTable(), pNewType );
-        pTblNd->SetNewTable( pDDETbl, FALSE );		// setze die DDE-Tabelle
+        pTblNd->SetNewTable( pDDETbl, sal_False );		// setze die DDE-Tabelle
         delete pDDEFldType, pDDEFldType = 0;
     }
 
     if( bCheckNumFmt )
     {
         SwTableSortBoxes& rBxs = pTblNd->GetTable().GetTabSortBoxes();
-        for( USHORT nBoxes = rBxs.Count(); nBoxes; )
-            rDoc.ChkBoxNumFmt( *rBxs[ --nBoxes ], FALSE );
+        for( sal_uInt16 nBoxes = rBxs.Count(); nBoxes; )
+            rDoc.ChkBoxNumFmt( *rBxs[ --nBoxes ], sal_False );
     }
 
     if( pHistory )
     {
-        USHORT nTmpEnd = pHistory->GetTmpEnd();
+        sal_uInt16 nTmpEnd = pHistory->GetTmpEnd();
         pHistory->TmpRollback( &rDoc, 0 );
         pHistory->SetTmpEnd( nTmpEnd );
     }
@@ -533,7 +537,7 @@ void SwUndoTblToTxt::Undo( SwUndoIter& rUndoIter )
 }
 
     // steht im untbl.cxx und darf nur vom Undoobject gerufen werden
-SwTableNode* SwNodes::UndoTableToText( ULONG nSttNd, ULONG nEndNd,
+SwTableNode* SwNodes::UndoTableToText( sal_uLong nSttNd, sal_uLong nEndNd,
                                 const SwTblToTxtSaves& rSavedData )
 {
     SwNodeIndex aSttIdx( *this, nSttNd );
@@ -548,7 +552,7 @@ SwTableNode* SwNodes::UndoTableToText( ULONG nSttNd, ULONG nEndNd,
        Delete all Frames attached to the nodes in that range. */
     SwNode* pNd;
     {
-        ULONG n, nTmpEnd = aEndIdx.GetIndex();
+        sal_uLong n, nTmpEnd = aEndIdx.GetIndex();
         for( n = pTblNd->GetIndex() + 1; n < nTmpEnd; ++n )
         {
             if( ( pNd = (*this)[ n ] )->IsCntntNode() )
@@ -566,7 +570,7 @@ SwTableNode* SwNodes::UndoTableToText( ULONG nSttNd, ULONG nEndNd,
     pTblNd->GetTable().GetTabLines().C40_INSERT( SwTableLine, pLine, 0 );
 
     SvULongs aBkmkArr( 0, 4 );
-    for( USHORT n = rSavedData.Count(); n; )
+    for( sal_uInt16 n = rSavedData.Count(); n; )
     {
         SwTblToTxtSave* pSave = rSavedData[ --n ];
         // if the start node was merged with last from prev. cell,
@@ -610,7 +614,7 @@ SwTableNode* SwNodes::UndoTableToText( ULONG nSttNd, ULONG nEndNd,
 
         if( pSave->m_pHstry )
         {
-            USHORT nTmpEnd = pSave->m_pHstry->GetTmpEnd();
+            sal_uInt16 nTmpEnd = pSave->m_pHstry->GetTmpEnd();
             pSave->m_pHstry->TmpRollback( GetDoc(), 0 );
             pSave->m_pHstry->SetTmpEnd( nTmpEnd );
         }
@@ -632,7 +636,7 @@ SwTableNode* SwNodes::UndoTableToText( ULONG nSttNd, ULONG nEndNd,
         pSttNd->pStartOfSection = pTblNd;
         new SwEndNode( aEndIdx, *pSttNd );
 
-        for( ULONG i = aSttIdx.GetIndex(); i < aEndIdx.GetIndex()-1; ++i )
+        for( sal_uLong i = aSttIdx.GetIndex(); i < aEndIdx.GetIndex()-1; ++i )
         {
             pNd = (*this)[ i ];
             pNd->pStartOfSection = pSttNd;
@@ -647,11 +651,10 @@ SwTableNode* SwNodes::UndoTableToText( ULONG nSttNd, ULONG nEndNd,
 }
 
 
-void SwUndoTblToTxt::Redo( SwUndoIter& rUndoIter )
+void SwUndoTblToTxt::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
-    SwPaM* pPam = rUndoIter.pAktPam;
-
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 
     pPam->GetPoint()->nNode = nSttNd;
     pPam->GetPoint()->nContent.Assign( 0, 0 );
@@ -674,7 +677,7 @@ void SwUndoTblToTxt::Redo( SwUndoIter& rUndoIter )
     if( !pCNd && 0 == ( pCNd = rDoc.GetNodes().GoNext( &aSaveIdx ) ) &&
         0 == ( pCNd = rDoc.GetNodes().GoPrevious( &aSaveIdx )) )
     {
-        OSL_ENSURE( FALSE, "wo steht denn nun der TextNode" );
+        OSL_ENSURE( sal_False, "wo steht denn nun der TextNode" );
     }
 
     pPam->GetPoint()->nNode = aSaveIdx;
@@ -685,19 +688,19 @@ void SwUndoTblToTxt::Redo( SwUndoIter& rUndoIter )
 }
 
 
-void SwUndoTblToTxt::Repeat( SwUndoIter& rUndoIter )
+void SwUndoTblToTxt::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwTableNode* pTblNd = rUndoIter.pAktPam->GetNode()->FindTableNode();
+    SwPaM *const pPam = & rContext.GetRepeatPaM();
+    SwTableNode *const pTblNd = pPam->GetNode()->FindTableNode();
     if( pTblNd )
     {
-        // bewege den Cursor aus der Tabelle
-        SwPaM* pPam = rUndoIter.pAktPam;
+        // move cursor out of table
         pPam->GetPoint()->nNode = *pTblNd->EndOfSectionNode();
         pPam->Move( fnMoveForward, fnGoCntnt );
         pPam->SetMark();
         pPam->DeleteMark();
 
-        rUndoIter.GetDoc().TableToText( pTblNd, cTrenner );
+        rContext.GetDoc().TableToText( pTblNd, cTrenner );
     }
 }
 
@@ -707,7 +710,7 @@ void SwUndoTblToTxt::SetRange( const SwNodeRange& rRg )
     nEndNd = rRg.aEnd.GetIndex();
 }
 
-void SwUndoTblToTxt::AddBoxPos( SwDoc& rDoc, ULONG nNdIdx, ULONG nEndIdx, xub_StrLen nCntntIdx )
+void SwUndoTblToTxt::AddBoxPos( SwDoc& rDoc, sal_uLong nNdIdx, sal_uLong nEndIdx, xub_StrLen nCntntIdx )
 {
     SwTblToTxtSave* pNew = new SwTblToTxtSave( rDoc, nNdIdx, nEndIdx, nCntntIdx );
     pBoxSaves->Insert( pNew, pBoxSaves->Count() );
@@ -717,7 +720,7 @@ void SwUndoTblToTxt::AddBoxPos( SwDoc& rDoc, ULONG nNdIdx, ULONG nEndIdx, xub_St
 
 SwUndoTxtToTbl::SwUndoTxtToTbl( const SwPaM& rRg,
                                 const SwInsertTableOptions& rInsTblOpts,
-                                sal_Unicode cCh, USHORT nAdj,
+                                sal_Unicode cCh, sal_uInt16 nAdj,
                                 const SwTableAutoFmt* pAFmt )
     : SwUndo( UNDO_TEXTTOTABLE ), SwUndRng( rRg ), aInsTblOpts( rInsTblOpts ),
       pDelBoxes( 0 ), pAutoFmt( 0 ),
@@ -739,15 +742,15 @@ SwUndoTxtToTbl::~SwUndoTxtToTbl()
     delete pAutoFmt;
 }
 
-void SwUndoTxtToTbl::Undo( SwUndoIter& rUndoIter )
+void SwUndoTxtToTbl::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
-    ULONG nTblNd = nSttNode;
+    sal_uLong nTblNd = nSttNode;
     if( nSttCntnt )
         ++nTblNd;		// Node wurde vorher gesplittet
     SwNodeIndex aIdx( rDoc.GetNodes(), nTblNd );
-    SwTableNode* pTNd = rDoc.GetNodes()[ aIdx ]->GetTableNode();
+    SwTableNode *const pTNd = aIdx.GetNode().GetTableNode();
     OSL_ENSURE( pTNd, "keinen Tabellen-Node gefunden" );
 
     RemoveIdxFromSection( rDoc, nTblNd );
@@ -763,11 +766,11 @@ void SwUndoTxtToTbl::Undo( SwUndoIter& rUndoIter )
     if( pDelBoxes )
     {
         SwTable& rTbl = pTNd->GetTable();
-        for( USHORT n = pDelBoxes->Count(); n; )
+        for( sal_uInt16 n = pDelBoxes->Count(); n; )
         {
             SwTableBox* pBox = rTbl.GetTblBox( (*pDelBoxes)[ --n ] );
             if( pBox )
-                ::_DeleteBox( rTbl, pBox, 0, FALSE, FALSE );
+                ::_DeleteBox( rTbl, pBox, 0, sal_False, sal_False );
             else {
                 OSL_ENSURE( !this, "Wo ist die Box geblieben?" );
             }
@@ -777,15 +780,16 @@ void SwUndoTxtToTbl::Undo( SwUndoIter& rUndoIter )
     SwNodeIndex aEndIdx( *pTNd->EndOfSectionNode() );
     rDoc.TableToText( pTNd, 0x0b == cTrenner ? 0x09 : cTrenner );
 
-    // am Start wieder zusammenfuegen ?
-    SwPosition* pPos = rUndoIter.pAktPam->GetPoint();
+    // join again at start?
+    SwPaM aPam(rDoc.GetNodes().GetEndOfContent());
+    SwPosition *const pPos = aPam.GetPoint();
     if( nSttCntnt )
     {
         pPos->nNode = nTblNd;
-        pPos->nContent.Assign( rDoc.GetNodes()[ pPos->nNode ]->GetCntntNode(), 0 );
-        if( rUndoIter.pAktPam->Move( fnMoveBackward, fnGoCntnt))
+        pPos->nContent.Assign(pPos->nNode.GetNode().GetCntntNode(), 0);
+        if (aPam.Move(fnMoveBackward, fnGoCntnt))
         {
-            SwNodeIndex& rIdx = rUndoIter.pAktPam->GetPoint()->nNode;
+            SwNodeIndex & rIdx = aPam.GetPoint()->nNode;
 
             // dann die Crsr/etc. nochmal relativ verschieben
             RemoveIdxRel( rIdx.GetIndex()+1, *pPos );
@@ -794,7 +798,7 @@ void SwUndoTxtToTbl::Undo( SwUndoIter& rUndoIter )
         }
     }
 
-    // am Ende wieder zusammenfuegen ?
+    // join again at end?
     if( bSplitEnd )
     {
         SwNodeIndex& rIdx = pPos->nNode;
@@ -802,8 +806,8 @@ void SwUndoTxtToTbl::Undo( SwUndoIter& rUndoIter )
         SwTxtNode* pTxtNd = rIdx.GetNode().GetTxtNode();
         if( pTxtNd && pTxtNd->CanJoinNext() )
         {
-            rUndoIter.pAktPam->GetMark()->nContent.Assign( 0, 0 );
-            rUndoIter.pAktPam->GetPoint()->nContent.Assign( 0, 0 );
+            aPam.GetMark()->nContent.Assign( 0, 0 );
+            aPam.GetPoint()->nContent.Assign( 0, 0 );
 
             // dann die Crsr/etc. nochmal relativ verschieben
             pPos->nContent.Assign( pTxtNd, pTxtNd->GetTxt().Len() );
@@ -813,30 +817,31 @@ void SwUndoTxtToTbl::Undo( SwUndoIter& rUndoIter )
         }
     }
 
-    SetPaM( rUndoIter );		// manipulierten Bereich selectieren
+    AddUndoRedoPaM(rContext);
 }
 
 
-void SwUndoTxtToTbl::Redo( SwUndoIter& rUndoIter )
+void SwUndoTxtToTbl::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetPaM( rUndoIter );
-    RemoveIdxFromRange( *rUndoIter.pAktPam, FALSE );
-    SetPaM( rUndoIter );
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    RemoveIdxFromRange(rPam, false);
+    SetPaM(rPam);
 
-    const SwTable* pTable = rUndoIter.GetDoc().TextToTable(
-                aInsTblOpts, *rUndoIter.pAktPam, cTrenner,
-                nAdjust, pAutoFmt );
+    SwTable const*const pTable = rContext.GetDoc().TextToTable(
+                aInsTblOpts, rPam, cTrenner, nAdjust, pAutoFmt );
     ((SwFrmFmt*)pTable->GetFrmFmt())->SetName( sTblNm );
 }
 
 
-void SwUndoTxtToTbl::Repeat( SwUndoIter& rUndoIter )
+void SwUndoTxtToTbl::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    // keine TABLE IN TABLE
-    if( !rUndoIter.pAktPam->GetNode()->FindTableNode() )
-        rUndoIter.GetDoc().TextToTable( aInsTblOpts, *rUndoIter.pAktPam,
+    // no Table In Table
+    if (!rContext.GetRepeatPaM().GetNode()->FindTableNode())
+    {
+        rContext.GetDoc().TextToTable( aInsTblOpts, rContext.GetRepeatPaM(),
                                         cTrenner, nAdjust,
                                         pAutoFmt );
+    }
 }
 
 void SwUndoTxtToTbl::AddFillBox( const SwTableBox& rBox )
@@ -855,8 +860,8 @@ SwHistory& SwUndoTxtToTbl::GetHistory()
 
 // -----------------------------------------------------
 
-SwUndoTblHeadline::SwUndoTblHeadline( const SwTable& rTbl, USHORT nOldHdl,
-                                      USHORT nNewHdl )
+SwUndoTblHeadline::SwUndoTblHeadline( const SwTable& rTbl, sal_uInt16 nOldHdl,
+                                      sal_uInt16 nNewHdl )
     : SwUndo( UNDO_TABLEHEADLINE ),
     nOldHeadline( nOldHdl ),
     nNewHeadline( nNewHdl )
@@ -868,20 +873,18 @@ SwUndoTblHeadline::SwUndoTblHeadline( const SwTable& rTbl, USHORT nOldHdl,
     nTblNd = pSttNd->StartOfSectionIndex();
 }
 
-
-void SwUndoTblHeadline::Undo( SwUndoIter& rUndoIter )
+void SwUndoTblHeadline::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwTableNode* pTNd = rDoc.GetNodes()[ nTblNd ]->GetTableNode();
     OSL_ENSURE( pTNd, "keinen Tabellen-Node gefunden" );
 
     rDoc.SetRowsToRepeat( pTNd->GetTable(), nOldHeadline );
 }
 
-
-void SwUndoTblHeadline::Redo( SwUndoIter& rUndoIter )
+void SwUndoTblHeadline::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     SwTableNode* pTNd = rDoc.GetNodes()[ nTblNd ]->GetTableNode();
     OSL_ENSURE( pTNd, "keinen Tabellen-Node gefunden" );
@@ -889,24 +892,25 @@ void SwUndoTblHeadline::Redo( SwUndoIter& rUndoIter )
     rDoc.SetRowsToRepeat( pTNd->GetTable(), nNewHeadline );
 }
 
-
-void SwUndoTblHeadline::Repeat( SwUndoIter& rUndoIter )
+void SwUndoTblHeadline::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwTableNode* pTblNd = rUndoIter.pAktPam->GetNode()->FindTableNode();
+    SwTableNode *const pTblNd =
+        rContext.GetRepeatPaM().GetNode()->FindTableNode();
     if( pTblNd )
-        rUndoIter.GetDoc().SetRowsToRepeat( pTblNd->GetTable(), nNewHeadline );
+    {
+        rContext.GetDoc().SetRowsToRepeat( pTblNd->GetTable(), nNewHeadline );
+    }
 }
 
 
-/*  */
-
+//////////////////////////////////////////////////////////////////////////
 
 
-_SaveTable::_SaveTable( const SwTable& rTbl, USHORT nLnCnt, BOOL bSaveFml )
+_SaveTable::_SaveTable( const SwTable& rTbl, sal_uInt16 nLnCnt, sal_Bool bSaveFml )
     : aTblSet( *rTbl.GetFrmFmt()->GetAttrSet().GetPool(), aTableSetRange ),
     pSwTable( &rTbl ), nLineCount( nLnCnt ), bSaveFormula( bSaveFml )
 {
-    bModifyBox = FALSE;
+    bModifyBox = sal_False;
     bNewModel = rTbl.IsNewModel();
     aTblSet.Put( rTbl.GetFrmFmt()->GetAttrSet() );
     pLine = new _SaveLine( 0, *rTbl.GetTabLines()[ 0 ], *this );
@@ -914,7 +918,7 @@ _SaveTable::_SaveTable( const SwTable& rTbl, USHORT nLnCnt, BOOL bSaveFml )
     _SaveLine* pLn = pLine;
     if( USHRT_MAX == nLnCnt )
         nLnCnt = rTbl.GetTabLines().Count();
-    for( USHORT n = 1; n < nLnCnt; ++n )
+    for( sal_uInt16 n = 1; n < nLnCnt; ++n )
         pLn = new _SaveLine( pLn, *rTbl.GetTabLines()[ n ], *this );
 
     aFrmFmts.Remove( 0, aFrmFmts.Count() );
@@ -928,9 +932,9 @@ _SaveTable::~_SaveTable()
 }
 
 
-USHORT _SaveTable::AddFmt( SwFrmFmt* pFmt, bool bIsLine )
+sal_uInt16 _SaveTable::AddFmt( SwFrmFmt* pFmt, bool bIsLine )
 {
-    USHORT nRet = aFrmFmts.GetPos( pFmt );
+    sal_uInt16 nRet = aFrmFmts.GetPos( pFmt );
     if( USHRT_MAX == nRet )
     {
         // Kopie vom ItemSet anlegen
@@ -942,7 +946,7 @@ USHORT _SaveTable::AddFmt( SwFrmFmt* pFmt, bool bIsLine )
         //				errechnet werden!
         //JP 30.07.98: Bug 54295 - Formeln immer im Klartext speichern
         const SfxPoolItem* pItem;
-        if( SFX_ITEM_SET == pSet->GetItemState( RES_BOXATR_FORMULA, TRUE, &pItem ))
+        if( SFX_ITEM_SET == pSet->GetItemState( RES_BOXATR_FORMULA, sal_True, &pItem ))
         {
             pSet->ClearItem( RES_BOXATR_VALUE );
             if( pSwTable && bSaveFormula )
@@ -961,9 +965,9 @@ USHORT _SaveTable::AddFmt( SwFrmFmt* pFmt, bool bIsLine )
 }
 
 
-void _SaveTable::RestoreAttr( SwTable& rTbl, BOOL bMdfyBox )
+void _SaveTable::RestoreAttr( SwTable& rTbl, sal_Bool bMdfyBox )
 {
-    USHORT n;
+    sal_uInt16 n;
 
     bModifyBox = bMdfyBox;
 
@@ -976,7 +980,7 @@ void _SaveTable::RestoreAttr( SwTable& rTbl, BOOL bMdfyBox )
     if( pFmt->IsInCache() )
     {
         SwFrm::GetCache().Delete( pFmt );
-        pFmt->SetInCache( FALSE );
+        pFmt->SetInCache( sal_False );
     }
 
     // zur Sicherheit alle Tableframes invalidieren
@@ -993,7 +997,7 @@ void _SaveTable::RestoreAttr( SwTable& rTbl, BOOL bMdfyBox )
     for( n = aSets.Count(); n; --n )
         aFrmFmts.Insert( pFmt, aFrmFmts.Count() );
 
-    USHORT nLnCnt = nLineCount;
+    sal_uInt16 nLnCnt = nLineCount;
     if( USHRT_MAX == nLnCnt )
         nLnCnt = rTbl.GetTabLines().Count();
 
@@ -1010,7 +1014,7 @@ void _SaveTable::RestoreAttr( SwTable& rTbl, BOOL bMdfyBox )
     }
 
     aFrmFmts.Remove( 0, aFrmFmts.Count() );
-    bModifyBox = FALSE;
+    bModifyBox = sal_False;
 }
 
 
@@ -1020,10 +1024,10 @@ void _SaveTable::SaveCntntAttrs( SwDoc* pDoc )
 }
 
 
-void _SaveTable::CreateNew( SwTable& rTbl, BOOL bCreateFrms,
-                            BOOL bRestoreChart )
+void _SaveTable::CreateNew( SwTable& rTbl, sal_Bool bCreateFrms,
+                            sal_Bool bRestoreChart )
 {
-    USHORT n;
+    sal_uInt16 n;
 
     _FndBox aTmpBox( 0, 0 );
     //if( bRestoreChart )
@@ -1039,7 +1043,7 @@ void _SaveTable::CreateNew( SwTable& rTbl, BOOL bCreateFrms,
     if( pFmt->IsInCache() )
     {
         SwFrm::GetCache().Delete( pFmt );
-        pFmt->SetInCache( FALSE );
+        pFmt->SetInCache( sal_False );
     }
 
     // SwTableBox muss ein Format haben!!
@@ -1054,7 +1058,7 @@ void _SaveTable::CreateNew( SwTable& rTbl, BOOL bCreateFrms,
     aFrmFmts.Remove( 0, aFrmFmts.Count() );
 
     // die neuen Lines eintragen, die alten loeschen
-    USHORT nOldLines = nLineCount;
+    sal_uInt16 nOldLines = nLineCount;
     if( USHRT_MAX == nLineCount )
         nOldLines = rTbl.GetTabLines().Count();
 
@@ -1070,8 +1074,8 @@ void _SaveTable::CreateNew( SwTable& rTbl, BOOL bCreateFrms,
 
             // TL_CHART2: notify chart about boxes to be removed
             const SwTableBoxes &rBoxes = pOld->GetTabBoxes();
-            USHORT nBoxes = rBoxes.Count();
-            for (USHORT k = 0;  k < nBoxes;  ++k)
+            sal_uInt16 nBoxes = rBoxes.Count();
+            for (sal_uInt16 k = 0;  k < nBoxes;  ++k)
             {
                 SwTableBox *pBox = rBoxes[k];
                 if (pPCD)
@@ -1089,11 +1093,11 @@ void _SaveTable::CreateNew( SwTable& rTbl, BOOL bCreateFrms,
     {
         // remove remaining lines...
 
-        for (USHORT k1 = 0; k1 < nOldLines - n;  ++k1)
+        for (sal_uInt16 k1 = 0; k1 < nOldLines - n;  ++k1)
         {
             const SwTableBoxes &rBoxes = rTbl.GetTabLines()[n + k1]->GetTabBoxes();
-            USHORT nBoxes = rBoxes.Count();
-            for (USHORT k2 = 0;  k2 < nBoxes;  ++k2)
+            sal_uInt16 nBoxes = rBoxes.Count();
+            for (sal_uInt16 k2 = 0;  k2 < nBoxes;  ++k2)
             {
                 SwTableBox *pBox = rBoxes[k2];
                 // TL_CHART2: notify chart about boxes to be removed
@@ -1117,8 +1121,8 @@ void _SaveTable::CreateNew( SwTable& rTbl, BOOL bCreateFrms,
 }
 
 
-void _SaveTable::NewFrmFmt( const SwClient* pLnBx, BOOL bIsLine,
-                            USHORT nFmtPos, SwFrmFmt* pOldFmt )
+void _SaveTable::NewFrmFmt( const SwClient* pLnBx, sal_Bool bIsLine,
+                            sal_uInt16 nFmtPos, SwFrmFmt* pOldFmt )
 {
     SwDoc* pDoc = pOldFmt->GetDoc();
 
@@ -1145,7 +1149,7 @@ void _SaveTable::NewFrmFmt( const SwClient* pLnBx, BOOL bIsLine,
             ((SwFrm*)pLast)->ReinitializeFrmSizeAttrFlags();
             if ( !bIsLine )
             {
-                ((SwCellFrm*)pLast)->SetDerivedVert( FALSE );
+                ((SwCellFrm*)pLast)->SetDerivedVert( sal_False );
                 ((SwCellFrm*)pLast)->CheckDirChange();
             }
         }
@@ -1178,7 +1182,7 @@ _SaveLine::_SaveLine( _SaveLine* pPrev, const SwTableLine& rLine, _SaveTable& rS
 
     pBox = new _SaveBox( 0, *rLine.GetTabBoxes()[ 0 ], rSTbl );
     _SaveBox* pBx = pBox;
-    for( USHORT n = 1; n < rLine.GetTabBoxes().Count(); ++n )
+    for( sal_uInt16 n = 1; n < rLine.GetTabBoxes().Count(); ++n )
         pBx = new _SaveBox( pBx, *rLine.GetTabBoxes()[ n ], rSTbl );
 }
 
@@ -1192,10 +1196,10 @@ _SaveLine::~_SaveLine()
 
 void _SaveLine::RestoreAttr( SwTableLine& rLine, _SaveTable& rSTbl )
 {
-    rSTbl.NewFrmFmt( &rLine, TRUE, nItemSet, rLine.GetFrmFmt() );
+    rSTbl.NewFrmFmt( &rLine, sal_True, nItemSet, rLine.GetFrmFmt() );
 
     _SaveBox* pBx = pBox;
-    for( USHORT n = 0; n < rLine.GetTabBoxes().Count(); ++n, pBx = pBx->pNext )
+    for( sal_uInt16 n = 0; n < rLine.GetTabBoxes().Count(); ++n, pBx = pBx->pNext )
     {
         if( !pBx )
         {
@@ -1264,7 +1268,7 @@ _SaveBox::_SaveBox( _SaveBox* pPrev, const SwTableBox& rBox, _SaveTable& rSTbl )
         Ptrs.pLine = new _SaveLine( 0, *rBox.GetTabLines()[ 0 ], rSTbl );
 
         _SaveLine* pLn = Ptrs.pLine;
-        for( USHORT n = 1; n < rBox.GetTabLines().Count(); ++n )
+        for( sal_uInt16 n = 1; n < rBox.GetTabLines().Count(); ++n )
             pLn = new _SaveLine( pLn, *rBox.GetTabLines()[ n ], rSTbl );
     }
 }
@@ -1282,7 +1286,7 @@ _SaveBox::~_SaveBox()
 
 void _SaveBox::RestoreAttr( SwTableBox& rBox, _SaveTable& rSTbl )
 {
-    rSTbl.NewFrmFmt( &rBox, FALSE, nItemSet, rBox.GetFrmFmt() );
+    rSTbl.NewFrmFmt( &rBox, sal_False, nItemSet, rBox.GetFrmFmt() );
 
     if( ULONG_MAX == nSttNode )		// keine EndBox
     {
@@ -1293,7 +1297,7 @@ void _SaveBox::RestoreAttr( SwTableBox& rBox, _SaveTable& rSTbl )
         else
         {
             _SaveLine* pLn = Ptrs.pLine;
-            for( USHORT n = 0; n < rBox.GetTabLines().Count(); ++n, pLn = pLn->pNext )
+            for( sal_uInt16 n = 0; n < rBox.GetTabLines().Count(); ++n, pLn = pLn->pNext )
             {
                 if( !pLn )
                 {
@@ -1310,9 +1314,9 @@ void _SaveBox::RestoreAttr( SwTableBox& rBox, _SaveTable& rSTbl )
         if( Ptrs.pCntntAttrs )
         {
             SwNodes& rNds = rBox.GetFrmFmt()->GetDoc()->GetNodes();
-            USHORT nSet = 0;
-            ULONG nEnd = rBox.GetSttNd()->EndOfSectionIndex();
-            for( ULONG n = nSttNode + 1; n < nEnd; ++n )
+            sal_uInt16 nSet = 0;
+            sal_uLong nEnd = rBox.GetSttNd()->EndOfSectionIndex();
+            for( sal_uLong n = nSttNode + 1; n < nEnd; ++n )
             {
                 SwCntntNode* pCNd = rNds[ n ]->GetCntntNode();
                 if( pCNd )
@@ -1320,7 +1324,7 @@ void _SaveBox::RestoreAttr( SwTableBox& rBox, _SaveTable& rSTbl )
                     SfxItemSet* pSet = (*Ptrs.pCntntAttrs)[ nSet++ ];
                     if( pSet )
                     {
-                        USHORT *pRstAttr = aSave_BoxCntntSet;
+                        sal_uInt16 *pRstAttr = aSave_BoxCntntSet;
                         while( *pRstAttr )
                         {
                             pCNd->ResetAttr( *pRstAttr, *(pRstAttr+1) );
@@ -1350,9 +1354,9 @@ void _SaveBox::SaveCntntAttrs( SwDoc* pDoc )
     }
     else
     {
-        ULONG nEnd = pDoc->GetNodes()[ nSttNode ]->EndOfSectionIndex();
-        Ptrs.pCntntAttrs = new SfxItemSets( (BYTE)(nEnd - nSttNode - 1 ), 5 );
-        for( ULONG n = nSttNode + 1; n < nEnd; ++n )
+        sal_uLong nEnd = pDoc->GetNodes()[ nSttNode ]->EndOfSectionIndex();
+        Ptrs.pCntntAttrs = new SfxItemSets( (sal_uInt8)(nEnd - nSttNode - 1 ), 5 );
+        for( sal_uLong n = nSttNode + 1; n < nEnd; ++n )
         {
             SwCntntNode* pCNd = pDoc->GetNodes()[ n ]->GetCntntNode();
             if( pCNd )
@@ -1418,12 +1422,12 @@ void _SaveBox::CreateNew( SwTable& rTbl, SwTableLine& rParent, _SaveTable& rSTbl
 }
 
 
-/*  */
+//////////////////////////////////////////////////////////////////////////
 
 // UndoObject fuer Attribut Aenderung an der Tabelle
 
 
-SwUndoAttrTbl::SwUndoAttrTbl( const SwTableNode& rTblNd, BOOL bClearTabCols )
+SwUndoAttrTbl::SwUndoAttrTbl( const SwTableNode& rTblNd, sal_Bool bClearTabCols )
     : SwUndo( UNDO_TABLE_ATTR ),
     nSttNode( rTblNd.GetIndex() )
 {
@@ -1431,17 +1435,14 @@ SwUndoAttrTbl::SwUndoAttrTbl( const SwTableNode& rTblNd, BOOL bClearTabCols )
     pSaveTbl = new _SaveTable( rTblNd.GetTable() );
 }
 
-
 SwUndoAttrTbl::~SwUndoAttrTbl()
 {
     delete pSaveTbl;
 }
 
-
-
-void SwUndoAttrTbl::Undo( SwUndoIter& rUndoIter )
+void SwUndoAttrTbl::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwTableNode* pTblNd = rDoc.GetNodes()[ nSttNode ]->GetTableNode();
     OSL_ENSURE( pTblNd, "kein TabellenNode" );
 
@@ -1457,14 +1458,13 @@ void SwUndoAttrTbl::Undo( SwUndoIter& rUndoIter )
         ClearFEShellTabCols();
 }
 
-
-void SwUndoAttrTbl::Redo( SwUndoIter& rUndoIter )
+void SwUndoAttrTbl::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    Undo( rUndoIter );
+    UndoImpl(rContext);
 }
 
 
-/*  */
+//////////////////////////////////////////////////////////////////////////
 
 // UndoObject fuer AutoFormat an der Tabelle
 
@@ -1472,8 +1472,8 @@ void SwUndoAttrTbl::Redo( SwUndoIter& rUndoIter )
 SwUndoTblAutoFmt::SwUndoTblAutoFmt( const SwTableNode& rTblNd,
                                     const SwTableAutoFmt& rAFmt )
     : SwUndo( UNDO_TABLE_AUTOFMT ),
-    nSttNode( rTblNd.GetIndex() ), pUndos( 0 ),
-    bSaveCntntAttr( FALSE )
+    nSttNode( rTblNd.GetIndex() ),
+    bSaveCntntAttr( sal_False )
 {
     pSaveTbl = new _SaveTable( rTblNd.GetTable() );
 
@@ -1482,29 +1482,26 @@ SwUndoTblAutoFmt::SwUndoTblAutoFmt( const SwTableNode& rTblNd,
         // dann auch noch ueber die ContentNodes der EndBoxen und
         // und alle Absatz-Attribute zusammen sammeln
         pSaveTbl->SaveCntntAttrs( (SwDoc*)rTblNd.GetDoc() );
-        bSaveCntntAttr = TRUE;
+        bSaveCntntAttr = sal_True;
     }
 }
 
-
 SwUndoTblAutoFmt::~SwUndoTblAutoFmt()
 {
-    delete pUndos;
     delete pSaveTbl;
 }
 
 void SwUndoTblAutoFmt::SaveBoxCntnt( const SwTableBox& rBox )
 {
-    SwUndoTblNumFmt* p = new SwUndoTblNumFmt( rBox );
-    if( !pUndos )
-        pUndos = new SwUndos( 8, 8 );
-    pUndos->Insert( p, pUndos->Count() );
+    ::boost::shared_ptr<SwUndoTblNumFmt> const p(new SwUndoTblNumFmt(rBox));
+    m_Undos.push_back(p);
 }
 
 
-void SwUndoTblAutoFmt::UndoRedo( BOOL bUndo, SwUndoIter& rUndoIter )
+void
+SwUndoTblAutoFmt::UndoRedo(bool const bUndo, ::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwTableNode* pTblNd = rDoc.GetNodes()[ nSttNode ]->GetTableNode();
     OSL_ENSURE( pTblNd, "kein TabellenNode" );
 
@@ -1514,37 +1511,39 @@ void SwUndoTblAutoFmt::UndoRedo( BOOL bUndo, SwUndoIter& rUndoIter )
     if( bSaveCntntAttr )
         pOrig->SaveCntntAttrs( &rDoc );
 
-    if( pUndos && bUndo )
-        for( USHORT n = pUndos->Count(); n; )
-            pUndos->GetObject( --n )->Undo( rUndoIter );
+    if (bUndo)
+    {
+        for (size_t n = m_Undos.size(); 0 < n; --n)
+        {
+            m_Undos.at(n-1)->UndoImpl(rContext);
+        }
+    }
 
     pSaveTbl->RestoreAttr( pTblNd->GetTable(), !bUndo );
     delete pSaveTbl;
     pSaveTbl = pOrig;
 }
 
-void SwUndoTblAutoFmt::Undo( SwUndoIter& rUndoIter )
+void SwUndoTblAutoFmt::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    UndoRedo( TRUE, rUndoIter );
+    UndoRedo(true, rContext);
 }
 
-
-void SwUndoTblAutoFmt::Redo( SwUndoIter& rUndoIter )
+void SwUndoTblAutoFmt::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    UndoRedo( FALSE, rUndoIter );
+    UndoRedo(false, rContext);
 }
 
 
-/*  */
-
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoTblNdsChg::SwUndoTblNdsChg( SwUndoId nAction,
                                     const SwSelBoxes& rBoxes,
                                     const SwTableNode& rTblNd,
                                     long nMn, long nMx,
-                                    USHORT nCnt, BOOL bFlg, BOOL bSmHght )
+                                    sal_uInt16 nCnt, sal_Bool bFlg, sal_Bool bSmHght )
     : SwUndo( nAction ),
-    aBoxes( rBoxes.Count() < 255 ? (BYTE)rBoxes.Count() : 255, 10 ),
+    aBoxes( rBoxes.Count() < 255 ? (sal_uInt8)rBoxes.Count() : 255, 10 ),
     nMin( nMn ), nMax( nMx ),
     nSttNode( rTblNd.GetIndex() ), nCurrBox( 0 ),
     nCount( nCnt ), nRelDiff( 0 ), nAbsDiff( 0 ),
@@ -1558,7 +1557,7 @@ SwUndoTblNdsChg::SwUndoTblNdsChg( SwUndoId nAction,
     pSaveTbl = new _SaveTable( rTbl );
 
     // und die Selektion merken
-    for( USHORT n = 0; n < rBoxes.Count(); ++n )
+    for( sal_uInt16 n = 0; n < rBoxes.Count(); ++n )
         aBoxes.Insert( rBoxes[n]->GetSttIdx(), n );
 }
 
@@ -1567,13 +1566,13 @@ SwUndoTblNdsChg::SwUndoTblNdsChg( SwUndoId nAction,
                                     const SwSelBoxes& rBoxes,
                                     const SwTableNode& rTblNd )
     : SwUndo( nAction ),
-    aBoxes( rBoxes.Count() < 255 ? (BYTE)rBoxes.Count() : 255, 10 ),
+    aBoxes( rBoxes.Count() < 255 ? (sal_uInt8)rBoxes.Count() : 255, 10 ),
     nMin( 0 ), nMax( 0 ),
     nSttNode( rTblNd.GetIndex() ), nCurrBox( 0 ),
     nCount( 0 ), nRelDiff( 0 ), nAbsDiff( 0 ),
     nSetColType( USHRT_MAX ),
-    bFlag( FALSE ),
-    bSameHeight( FALSE )
+    bFlag( sal_False ),
+    bSameHeight( sal_False )
 {
     Ptrs.pNewSttNds = 0;
 
@@ -1581,7 +1580,7 @@ SwUndoTblNdsChg::SwUndoTblNdsChg( SwUndoId nAction,
     pSaveTbl = new _SaveTable( rTbl );
 
     // und die Selektion merken
-    for( USHORT n = 0; n < rBoxes.Count(); ++n )
+    for( sal_uInt16 n = 0; n < rBoxes.Count(); ++n )
         aBoxes.Insert( rBoxes[n]->GetSttIdx(), n );
 }
 
@@ -1590,7 +1589,7 @@ void SwUndoTblNdsChg::ReNewBoxes( const SwSelBoxes& rBoxes )
     if( rBoxes.Count() != aBoxes.Count() )
     {
         aBoxes.Remove( 0, aBoxes.Count() );
-        for( USHORT n = 0; n < rBoxes.Count(); ++n )
+        for( sal_uInt16 n = 0; n < rBoxes.Count(); ++n )
             aBoxes.Insert( rBoxes[n]->GetSttIdx(), n );
     }
 }
@@ -1610,11 +1609,11 @@ void SwUndoTblNdsChg::SaveNewBoxes( const SwTableNode& rTblNd,
 {
     const SwTable& rTbl = rTblNd.GetTable();
     const SwTableSortBoxes& rTblBoxes = rTbl.GetTabSortBoxes();
-    USHORT n;
-    USHORT i;
+    sal_uInt16 n;
+    sal_uInt16 i;
 
     OSL_ENSURE( ! IsDelBox(), "falsche Action" );
-    Ptrs.pNewSttNds = new SvULongs( (BYTE)(rTblBoxes.Count() - rOld.Count()), 5 );
+    Ptrs.pNewSttNds = new SvULongs( (sal_uInt8)(rTblBoxes.Count() - rOld.Count()), 5 );
 
     for( n = 0, i = 0; n < rOld.Count(); ++i )
     {
@@ -1640,7 +1639,7 @@ SwTableLine* lcl_FindTableLine( const SwTable& rTable,
                                   rBox.GetUpper()->GetUpper()->GetTabLines()
                                 : rTable.GetTabLines();
     const SwTableLine* pLine = rBox.GetUpper();
-    USHORT nLineNo = rTableLines.C40_GETPOS( SwTableLine, pLine );
+    sal_uInt16 nLineNo = rTableLines.C40_GETPOS( SwTableLine, pLine );
     pRet = rTableLines[nLineNo - 1];
 
     return pRet;
@@ -1667,12 +1666,12 @@ void SwUndoTblNdsChg::SaveNewBoxes( const SwTableNode& rTblNd,
     const SwTableSortBoxes& rTblBoxes = rTbl.GetTabSortBoxes();
 
     OSL_ENSURE( ! IsDelBox(), "falsche Action" );
-    Ptrs.pNewSttNds = new SvULongs( (BYTE)(rTblBoxes.Count() - rOld.Count()), 5 );
+    Ptrs.pNewSttNds = new SvULongs( (sal_uInt8)(rTblBoxes.Count() - rOld.Count()), 5 );
 
     OSL_ENSURE( rTbl.IsNewModel() || rOld.Count() + nCount * rBoxes.Count() == rTblBoxes.Count(),
         "unexpected boxes" );
     OSL_ENSURE( rOld.Count() <= rTblBoxes.Count(), "more unexpected boxes" );
-    for( USHORT n = 0, i = 0; i < rTblBoxes.Count(); ++i )
+    for( sal_uInt16 n = 0, i = 0; i < rTblBoxes.Count(); ++i )
     {
         if( ( n < rOld.Count() ) &&
             ( rOld[ n ] == rTblBoxes[ i ] ) )
@@ -1683,7 +1682,7 @@ void SwUndoTblNdsChg::SaveNewBoxes( const SwTableNode& rTblNd,
         else
         {
             // new box found: insert (obey sort order)
-            USHORT nInsPos;
+            sal_uInt16 nInsPos;
             const SwTableBox* pBox = rTblBoxes[ i ];
             InsertSort( *Ptrs.pNewSttNds, pBox->GetSttIdx(), &nInsPos );
 
@@ -1694,15 +1693,15 @@ void SwUndoTblNdsChg::SaveNewBoxes( const SwTableNode& rTblNd,
             const SwTableBox* pSourceBox = NULL;
             const SwTableBox* pCheckBox = NULL;
             const SwTableLine* pBoxLine = pBox->GetUpper();
-            USHORT nLineDiff = lcl_FindParentLines(rTbl,*pBox).C40_GETPOS(SwTableLine,pBoxLine);
-            USHORT nLineNo = 0;
-            for( USHORT j = 0; j < rBoxes.Count(); ++j )
+            sal_uInt16 nLineDiff = lcl_FindParentLines(rTbl,*pBox).C40_GETPOS(SwTableLine,pBoxLine);
+            sal_uInt16 nLineNo = 0;
+            for( sal_uInt16 j = 0; j < rBoxes.Count(); ++j )
             {
                 pCheckBox = rBoxes[j];
                 if( pCheckBox->GetUpper()->GetUpper() == pBox->GetUpper()->GetUpper() )
                 {
                     const SwTableLine* pCheckLine = pCheckBox->GetUpper();
-                    USHORT nCheckLine = lcl_FindParentLines( rTbl, *pCheckBox ).
+                    sal_uInt16 nCheckLine = lcl_FindParentLines( rTbl, *pCheckBox ).
                     C40_GETPOS( SwTableLine, pCheckLine );
                     if( ( !pSourceBox || nCheckLine > nLineNo ) && nCheckLine < nLineDiff )
                     {
@@ -1718,10 +1717,10 @@ void SwUndoTblNdsChg::SaveNewBoxes( const SwTableNode& rTblNd,
             OSL_ENSURE( pSourceBox, "Splitted source box not found!" );
             // find out how many nodes the source box used to have
             // (to help determine bNodesMoved flag below)
-            USHORT nNdsPos = 0;
+            sal_uInt16 nNdsPos = 0;
             while( rBoxes[ nNdsPos ] != pSourceBox )
                 ++nNdsPos;
-            ULONG nNodes = rNodeCnts[ nNdsPos ];
+            sal_uLong nNodes = rNodeCnts[ nNdsPos ];
 
             // When a new table cell is created, it either gets a new
             // node, or it gets node(s) from elsewhere. The undo must
@@ -1735,7 +1734,7 @@ void SwUndoTblNdsChg::SaveNewBoxes( const SwTableNode& rTblNd,
             // The bNodesMoved flag is stored in a seperate array
             // which mirrors Ptrs.pNewSttNds, i.e. Ptrs.pNewSttNds[i]
             // and aMvBoxes[i] belong together.
-            BOOL bNodesMoved =
+            sal_Bool bNodesMoved =
                 ( nNodes != ( pSourceBox->GetSttNd()->EndOfSectionIndex() -
                               pSourceBox->GetSttIdx() ) )
                 && ( nNodes - 1 > nLineDiff );
@@ -1760,12 +1759,12 @@ void SwUndoTblNdsChg::SaveSection( SwStartNode* pSttNd )
 }
 
 
-void SwUndoTblNdsChg::Undo( SwUndoIter& rUndoIter )
+void SwUndoTblNdsChg::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode );
 
-    SwTableNode* pTblNd = rDoc.GetNodes()[ aIdx ]->GetTableNode();
+    SwTableNode *const pTblNd = aIdx.GetNode().GetTableNode();
     OSL_ENSURE( pTblNd, "kein TabellenNode" );
 
     SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
@@ -1787,7 +1786,7 @@ void SwUndoTblNdsChg::Undo( SwUndoIter& rUndoIter )
         SwTableBoxes& rLnBoxes = pCpyBox->GetUpper()->GetTabBoxes();
 
         // die Sections wieder herstellen
-        for( USHORT n = Ptrs.pDelSects->Count(); n; )
+        for( sal_uInt16 n = Ptrs.pDelSects->Count(); n; )
         {
             SwUndoSaveSection* pSave = (*Ptrs.pDelSects)[ --n ];
             pSave->RestoreSection( &rDoc, &aIdx, SwTableBoxStartNode );
@@ -1807,10 +1806,10 @@ void SwUndoTblNdsChg::Undo( SwUndoIter& rUndoIter )
         aTmp.Insert( Ptrs.pNewSttNds, 0 );
 
         // von hinten anfangen
-        for( USHORT n = aTmp.Count(); n; )
+        for( sal_uInt16 n = aTmp.Count(); n; )
         {
             // Box aus der Tabellen-Struktur entfernen
-            ULONG nIdx = aTmp[ --n ];
+            sal_uLong nIdx = aTmp[ --n ];
             SwTableBox* pBox = pTblNd->GetTable().GetTblBox( nIdx );
             OSL_ENSURE( pBox, "Wo ist meine TabellenBox geblieben?" );
 
@@ -1827,8 +1826,8 @@ void SwUndoTblNdsChg::Undo( SwUndoIter& rUndoIter )
                 SwNodeIndex aInsPos( *(pLine->GetTabBoxes()[0]->GetSttNd()), 2 );
 
                 // alle StartNode Indizies anpassen
-                USHORT i = n;
-                ULONG nSttIdx = aInsPos.GetIndex() - 2,
+                sal_uInt16 i = n;
+                sal_uLong nSttIdx = aInsPos.GetIndex() - 2,
                        nNdCnt = aRg.aEnd.GetIndex() - aRg.aStart.GetIndex();
                 while( i && aTmp[ --i ] > nSttIdx )
                     aTmp[ i ] += nNdCnt;
@@ -1836,7 +1835,7 @@ void SwUndoTblNdsChg::Undo( SwUndoIter& rUndoIter )
                 // erst die Box loeschen
                 delete pBox;
                 // dann die Nodes verschieben,
-                rDoc.GetNodes()._MoveNodes( aRg, rDoc.GetNodes(), aInsPos, FALSE );
+                rDoc.GetNodes()._MoveNodes( aRg, rDoc.GetNodes(), aInsPos, sal_False );
             }
             else
                 rDoc.DeleteSection( rDoc.GetNodes()[ nIdx ] );
@@ -1846,9 +1845,9 @@ void SwUndoTblNdsChg::Undo( SwUndoIter& rUndoIter )
     else
     {
         // Remove nodes from nodes array (backwards!)
-        for( USHORT n = Ptrs.pNewSttNds->Count(); n; )
+        for( sal_uInt16 n = Ptrs.pNewSttNds->Count(); n; )
         {
-            ULONG nIdx = (*Ptrs.pNewSttNds)[ --n ];
+            sal_uLong nIdx = (*Ptrs.pNewSttNds)[ --n ];
             SwTableBox* pBox = pTblNd->GetTable().GetTblBox( nIdx );
             OSL_ENSURE( pBox, "Where's my table box?" );
             // TL_CHART2: notify chart about box to be removed
@@ -1859,7 +1858,7 @@ void SwUndoTblNdsChg::Undo( SwUndoIter& rUndoIter )
         }
     }
     // Remove boxes from table structure
-    for( USHORT n = 0; n < aDelBoxes.size(); ++n )
+    for( sal_uInt16 n = 0; n < aDelBoxes.size(); ++n )
     {
         SwTableBox* pCurrBox = aDelBoxes[n];
         SwTableBoxes* pTBoxes = &pCurrBox->GetUpper()->GetTabBoxes();
@@ -1867,7 +1866,7 @@ void SwUndoTblNdsChg::Undo( SwUndoIter& rUndoIter )
         delete pCurrBox;
     }
 
-    pSaveTbl->CreateNew( pTblNd->GetTable(), TRUE, FALSE );
+    pSaveTbl->CreateNew( pTblNd->GetTable(), sal_True, sal_False );
 
     // TL_CHART2: need to inform chart of probably changed cell names
     rDoc.UpdateCharts( pTblNd->GetTable().GetFrmFmt()->GetName() );
@@ -1879,16 +1878,16 @@ void SwUndoTblNdsChg::Undo( SwUndoIter& rUndoIter )
 }
 
 
-void SwUndoTblNdsChg::Redo( SwUndoIter& rUndoIter )
+void SwUndoTblNdsChg::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     SwTableNode* pTblNd = rDoc.GetNodes()[ nSttNode ]->GetTableNode();
     OSL_ENSURE( pTblNd, "kein TabellenNode" );
     CHECK_TABLE( pTblNd->GetTable() )
 
     SwSelBoxes aSelBoxes;
-    for( USHORT n = 0; n < aBoxes.Count(); ++n )
+    for( sal_uInt16 n = 0; n < aBoxes.Count(); ++n )
     {
         SwTableBox* pBox = pTblNd->GetTable().GetTblBox( aBoxes[ n ] );
         aSelBoxes.Insert( pBox );
@@ -1936,7 +1935,7 @@ void SwUndoTblNdsChg::Redo( SwUndoIter& rUndoIter )
             SwTable &rTable = pTblNd->GetTable();
             if( nMax > nMin && rTable.IsNewModel() )
                 rTable.PrepareDeleteCol( nMin, nMax );
-            rTable.DeleteSel( &rDoc, aSelBoxes, 0, this, TRUE, TRUE );
+            rTable.DeleteSel( &rDoc, aSelBoxes, 0, this, sal_True, sal_True );
         }
         else
         {
@@ -1950,7 +1949,8 @@ void SwUndoTblNdsChg::Redo( SwUndoIter& rUndoIter )
             TblChgMode eOldMode = rTbl.GetTblChgMode();
             rTbl.SetTblChgMode( (TblChgMode)nCount );
 
-            rDoc.DoUndo( TRUE );		// wir brauchen die SaveSections!
+            // need the SaveSections!
+            rDoc.GetIDocumentUndoRedo().DoUndo( true );
             SwUndoTblNdsChg* pUndo = 0;
 
             switch( nSetColType & 0xff )
@@ -1978,7 +1978,7 @@ void SwUndoTblNdsChg::Redo( SwUndoIter& rUndoIter )
 
                 delete pUndo;
             }
-            rDoc.DoUndo( FALSE );
+            rDoc.GetIDocumentUndoRedo().DoUndo( false );
 
             rTbl.SetTblChgMode( eOldMode );
         }
@@ -1992,8 +1992,7 @@ void SwUndoTblNdsChg::Redo( SwUndoIter& rUndoIter )
 }
 
 
-/*  */
-
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoTblMerge::SwUndoTblMerge( const SwPaM& rTblSel )
     : SwUndo( UNDO_TABLE_MERGE ), SwUndRng( rTblSel ), pHistory( 0 )
@@ -2005,7 +2004,6 @@ SwUndoTblMerge::SwUndoTblMerge( const SwPaM& rTblSel )
     nTblNode = pTblNd->GetIndex();
 }
 
-
 SwUndoTblMerge::~SwUndoTblMerge()
 {
     delete pSaveTbl;
@@ -2013,13 +2011,12 @@ SwUndoTblMerge::~SwUndoTblMerge()
     delete pHistory;
 }
 
-
-void SwUndoTblMerge::Undo( SwUndoIter& rUndoIter )
+void SwUndoTblMerge::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwNodeIndex aIdx( rDoc.GetNodes(), nTblNode );
 
-    SwTableNode* pTblNd = rDoc.GetNodes()[ aIdx ]->GetTableNode();
+    SwTableNode *const pTblNd = aIdx.GetNode().GetTableNode();
     OSL_ENSURE( pTblNd, "kein TabellenNode" );
 
     SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
@@ -2041,7 +2038,7 @@ CHECKTABLE(pTblNd->GetTable())
 
     SwSelBoxes aSelBoxes;
     SwTxtFmtColl* pColl = rDoc.GetTxtCollFromPool( RES_POOLCOLL_STANDARD );
-    USHORT n;
+    sal_uInt16 n;
 
     for( n = 0; n < aBoxes.Count(); ++n )
     {
@@ -2063,7 +2060,7 @@ CHECKTABLE(pTblNd->GetTable())
     for( n = aNewSttNds.Count(); n; )
     {
         // Box aus der Tabellen-Struktur entfernen
-        ULONG nIdx = aNewSttNds[ --n ];
+        sal_uLong nIdx = aNewSttNds[ --n ];
 
         if( !nIdx && n )
         {
@@ -2076,17 +2073,17 @@ CHECKTABLE(pTblNd->GetTable())
                     *pBox->GetSttNd()->EndOfSectionNode() ), pColl );
 
             // das war der Trenner, -> die verschobenen herstellen
-            for( USHORT i = pMoves->Count(); i; )
+            for( sal_uInt16 i = pMoves->Count(); i; )
             {
                 SwTxtNode* pTxtNd = 0;
-                USHORT nDelPos = 0;
+                sal_uInt16 nDelPos = 0;
                 SwUndoMove* pUndo = (*pMoves)[ --i ];
                 if( !pUndo->IsMoveRange() )
                 {
                     pTxtNd = rDoc.GetNodes()[ pUndo->GetDestSttNode() ]->GetTxtNode();
                     nDelPos = pUndo->GetDestSttCntnt() - 1;
                 }
-                pUndo->Undo( rUndoIter );
+                pUndo->UndoImpl(rContext);
                 if( pUndo->IsMoveRange() )
                 {
                     // den ueberfluessigen Node loeschen
@@ -2132,7 +2129,7 @@ CHECKTABLE(pTblNd->GetTable())
                 SwNodeIndex aTmpIdx( *pBox->GetSttNd() );
                 rDoc.CorrAbs( SwNodeIndex( aTmpIdx, 1 ),
                             SwNodeIndex( *aTmpIdx.GetNode().EndOfSectionNode() ),
-                            SwPosition( aTmpIdx, SwIndex( 0, 0 )), TRUE );
+                            SwPosition( aTmpIdx, SwIndex( 0, 0 )), sal_True );
             }
 
             delete pBox;
@@ -2142,7 +2139,7 @@ CHECKTABLE(pTblNd->GetTable())
 CHECKTABLE(pTblNd->GetTable())
 
 
-    pSaveTbl->CreateNew( pTblNd->GetTable(), TRUE, FALSE );
+    pSaveTbl->CreateNew( pTblNd->GetTable(), sal_True, sal_False );
 
     // TL_CHART2: need to inform chart of probably changed cell names
     rDoc.UpdateCharts( pTblNd->GetTable().GetFrmFmt()->GetName() );
@@ -2154,7 +2151,7 @@ CHECKTABLE(pTblNd->GetTable())
     }
 //	nTblNode = pTblNd->GetIndex();
 
-    SwPaM* pPam = rUndoIter.pAktPam;
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
     pPam->DeleteMark();
     pPam->GetPoint()->nNode = nSttNode;
     pPam->GetPoint()->nContent.Assign( pPam->GetCntntNode(), nSttCntnt );
@@ -2165,27 +2162,21 @@ CHECKTABLE(pTblNd->GetTable())
     ClearFEShellTabCols();
 }
 
-
-void SwUndoTblMerge::Redo( SwUndoIter& rUndoIter )
+void SwUndoTblMerge::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pPam = rUndoIter.pAktPam;
-    SwDoc& rDoc = *pPam->GetDoc();
-
-    SetPaM( *pPam );
-    rDoc.MergeTbl( *pPam );
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rDoc.MergeTbl(rPam);
 }
 
 void SwUndoTblMerge::MoveBoxCntnt( SwDoc* pDoc, SwNodeRange& rRg, SwNodeIndex& rPos )
 {
     SwNodeIndex aTmp( rRg.aStart, -1 ), aTmp2( rPos, -1 );
     SwUndoMove* pUndo = new SwUndoMove( pDoc, rRg, rPos );
-    sal_Bool bDoesUndo = pDoc->DoesUndo();
-    pDoc->DoUndo( sal_False );
+    ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
     pDoc->MoveNodeRange( rRg, rPos, (pSaveTbl->IsNewModel()) ?
         IDocumentContentOperations::DOC_NO_DELFRMS :
         IDocumentContentOperations::DOC_MOVEDEFAULT );
-    if( bDoesUndo )
-        pDoc->DoUndo( sal_True );
     aTmp++;
     aTmp2++;
     pUndo->SetDestRange( aTmp2, rPos, aTmp );
@@ -2193,15 +2184,14 @@ void SwUndoTblMerge::MoveBoxCntnt( SwDoc* pDoc, SwNodeRange& rRg, SwNodeIndex& r
     pMoves->Insert( pUndo, pMoves->Count() );
 }
 
-
 void SwUndoTblMerge::SetSelBoxes( const SwSelBoxes& rBoxes )
 {
     // die Selektion merken
-    for( USHORT n = 0; n < rBoxes.Count(); ++n )
+    for( sal_uInt16 n = 0; n < rBoxes.Count(); ++n )
         InsertSort( aBoxes, rBoxes[n]->GetSttIdx() );
 
     // als Trennung fuers einfuegen neuer Boxen nach dem Verschieben!
-    aNewSttNds.Insert( (ULONG)0, aNewSttNds.Count() );
+    aNewSttNds.Insert( (sal_uLong)0, aNewSttNds.Count() );
 
      // The new table model does not delete overlapped cells (by row span),
      // so the rBoxes array might be empty even some cells have been merged.
@@ -2224,15 +2214,15 @@ void SwUndoTblMerge::SaveCollection( const SwTableBox& rBox )
         pHistory->CopyFmtAttr( *pCNd->GetpSwAttrSet(), aIdx.GetIndex() );
 }
 
-/*  */
 
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoTblNumFmt::SwUndoTblNumFmt( const SwTableBox& rBox,
                                     const SfxItemSet* pNewSet )
     : SwUndo( UNDO_TBLNUMFMT ),
     pBoxSet( 0 ), pHistory( 0 ), nFmtIdx( NUMBERFORMAT_TEXT )
 {
-    bNewFmt = bNewFml = bNewValue = FALSE;
+    bNewFmt = bNewFml = bNewValue = sal_False;
     nNode = rBox.GetSttIdx();
 
     nNdPos = rBox.IsValidNumTxtNd( 0 == pNewSet );
@@ -2264,21 +2254,21 @@ SwUndoTblNumFmt::SwUndoTblNumFmt( const SwTableBox& rBox,
     {
         const SfxPoolItem* pItem;
         if( SFX_ITEM_SET == pNewSet->GetItemState( RES_BOXATR_FORMAT,
-                FALSE, &pItem ))
+                sal_False, &pItem ))
         {
-            bNewFmt = TRUE;
+            bNewFmt = sal_True;
             nNewFmtIdx = ((SwTblBoxNumFormat*)pItem)->GetValue();
         }
         if( SFX_ITEM_SET == pNewSet->GetItemState( RES_BOXATR_FORMULA,
-                FALSE, &pItem ))
+                sal_False, &pItem ))
         {
-            bNewFml = TRUE;
+            bNewFml = sal_True;
             aNewFml = ((SwTblBoxFormula*)pItem)->GetFormula();
         }
         if( SFX_ITEM_SET == pNewSet->GetItemState( RES_BOXATR_VALUE,
-                FALSE, &pItem ))
+                sal_False, &pItem ))
         {
-            bNewValue = TRUE;
+            bNewValue = sal_True;
             fNewNum = ((SwTblBoxValue*)pItem)->GetValue();
         }
     }
@@ -2288,18 +2278,17 @@ SwUndoTblNumFmt::SwUndoTblNumFmt( const SwTableBox& rBox,
         DELETEZ( pHistory );
 }
 
-
 SwUndoTblNumFmt::~SwUndoTblNumFmt()
 {
     delete pHistory;
     delete pBoxSet;
 }
 
-void SwUndoTblNumFmt::Undo( SwUndoIter& rIter )
+void SwUndoTblNumFmt::UndoImpl(::sw::UndoRedoContext & rContext)
 {
     OSL_ENSURE( pBoxSet, "Where's the stored item set?" );
 
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwStartNode* pSttNd = rDoc.GetNodes()[ nNode ]->
                             FindSttNodeByType( SwTableBoxStartNode );
     OSL_ENSURE( pSttNd, "ohne StartNode kein TabellenBox" );
@@ -2340,12 +2329,12 @@ void SwUndoTblNumFmt::Undo( SwUndoIter& rIter )
 
     if( pHistory )
     {
-        USHORT nTmpEnd = pHistory->GetTmpEnd();
+        sal_uInt16 nTmpEnd = pHistory->GetTmpEnd();
         pHistory->TmpRollback( &rDoc, 0 );
         pHistory->SetTmpEnd( nTmpEnd );
     }
 
-    SwPaM* pPam = rIter.pAktPam;
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
     pPam->DeleteMark();
     pPam->GetPoint()->nNode = nNode + 1;
     pPam->GetPoint()->nContent.Assign( pTxtNd, 0 );
@@ -2388,19 +2377,19 @@ RedlineModeInternGuard::~RedlineModeInternGuard()
 
 
 
-void SwUndoTblNumFmt::Redo( SwUndoIter& rIter )
+void SwUndoTblNumFmt::RedoImpl(::sw::UndoRedoContext & rContext)
 {
     // konnte die Box veraendert werden ?
     if( !pBoxSet )
         return ;
 
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 
-    SwPaM* pPam = rIter.pAktPam;
     pPam->DeleteMark();
     pPam->GetPoint()->nNode = nNode;
 
-    SwNode* pNd = rDoc.GetNodes()[ pPam->GetPoint()->nNode ];
+    SwNode * pNd = & pPam->GetPoint()->nNode.GetNode();
     SwStartNode* pSttNd = pNd->FindSttNodeByType( SwTableBoxStartNode );
     OSL_ENSURE( pSttNd, "ohne StartNode kein TabellenBox" );
     SwTableBox* pBox = pSttNd->FindTableNode()->GetTable().GetTblBox(
@@ -2488,7 +2477,8 @@ void SwUndoTblNumFmt::SetBox( const SwTableBox& rBox )
     nNode = rBox.GetSttIdx();
 }
 
-/*  */
+
+//////////////////////////////////////////////////////////////////////////
 
 _UndoTblCpyTbl_Entry::_UndoTblCpyTbl_Entry( const SwTableBox& rBox )
     : nBoxIdx( rBox.GetSttIdx() ), nOffset( 0 ),
@@ -2515,16 +2505,16 @@ SwUndoTblCpyTbl::~SwUndoTblCpyTbl()
     delete pInsRowUndo;
 }
 
-void SwUndoTblCpyTbl::Undo( SwUndoIter& rIter )
+void SwUndoTblCpyTbl::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     _DEBUG_REDLINE( &rDoc )
 
     SwTableNode* pTblNd = 0;
-    for( USHORT n = pArr->Count(); n; )
+    for( sal_uInt16 n = pArr->Count(); n; )
     {
         _UndoTblCpyTbl_Entry* pEntry = (*pArr)[ --n ];
-        ULONG nSttPos = pEntry->nBoxIdx + pEntry->nOffset;
+        sal_uLong nSttPos = pEntry->nBoxIdx + pEntry->nOffset;
         SwStartNode* pSNd = rDoc.GetNodes()[ nSttPos ]->StartOfSectionNode();
         if( !pTblNd )
             pTblNd = pSNd->FindTableNode();
@@ -2546,23 +2536,29 @@ void SwUndoTblCpyTbl::Undo( SwUndoIter& rIter )
             // There are a couple of different situations to consider during redlining
             if( pEntry->pUndo )
             {
-                SwUndoDelete *pUnDel = (SwUndoDelete*)pEntry->pUndo;
-                if( UNDO_REDLINE == pUnDel->GetId() )
+                SwUndoDelete *const pUndoDelete =
+                    dynamic_cast<SwUndoDelete*>(pEntry->pUndo);
+                SwUndoRedlineDelete *const pUndoRedlineDelete =
+                    dynamic_cast<SwUndoRedlineDelete*>(pEntry->pUndo);
+                OSL_ASSERT(pUndoDelete || pUndoRedlineDelete);
+                if (pUndoRedlineDelete)
                 {
                     // The old content was not empty or he has been merged with the new content
                     bDeleteCompleteParagraph = !pEntry->bJoin; // bJoin is set when merged
                     // Set aTmpIdx to the beginning fo the old content
-                    SwNodeIndex aTmpIdx( *pEndNode, pUnDel->NodeDiff()-1 );
+                    SwNodeIndex aTmpIdx( *pEndNode,
+                            pUndoRedlineDelete->NodeDiff()-1 );
                     SwTxtNode *pTxt = aTmpIdx.GetNode().GetTxtNode();
                     if( pTxt )
                     {
                         aPam.GetPoint()->nNode = *pTxt;
-                        aPam.GetPoint()->nContent.Assign( pTxt, pUnDel->ContentStart() );
+                        aPam.GetPoint()->nContent.Assign( pTxt,
+                                pUndoRedlineDelete->ContentStart() );
                     }
                     else
                         *aPam.GetPoint() = SwPosition( aTmpIdx );
                 }
-                else if( pUnDel->IsDelFullPara() )
+                else if (pUndoDelete && pUndoDelete->IsDelFullPara())
                 {
                     // When the old content was an empty paragraph, but could not be joined
                     // with the new content (e.g. because of a section or table)
@@ -2586,8 +2582,9 @@ void SwUndoTblCpyTbl::Undo( SwUndoIter& rIter )
 
             if( pEntry->pUndo )
             {
-                pEntry->pUndo->Undo( rIter );
+                pEntry->pUndo->UndoImpl(rContext);
                 delete pEntry->pUndo;
+                pEntry->pUndo = 0;
             }
             if( bShiftPam )
             {
@@ -2603,15 +2600,16 @@ void SwUndoTblCpyTbl::Undo( SwUndoIter& rIter )
                 else
                     *aPam.GetPoint() = SwPosition( aTmpIdx );
             }
-            pUndo = new SwUndoDelete( aPam, bDeleteCompleteParagraph, TRUE );
+            pUndo = new SwUndoDelete( aPam, bDeleteCompleteParagraph, sal_True );
         }
         else
         {
             pUndo = new SwUndoDelete( aPam, true );
             if( pEntry->pUndo )
             {
-                pEntry->pUndo->Undo( rIter );
+                pEntry->pUndo->UndoImpl(rContext);
                 delete pEntry->pUndo;
+                pEntry->pUndo = 0;
             }
         }
         pEntry->pUndo = pUndo;
@@ -2647,23 +2645,27 @@ void SwUndoTblCpyTbl::Undo( SwUndoIter& rIter )
     }
 
     if( pInsRowUndo )
-        pInsRowUndo->Undo( rIter );
+    {
+        pInsRowUndo->UndoImpl(rContext);
+    }
     _DEBUG_REDLINE( &rDoc )
 }
 
-void SwUndoTblCpyTbl::Redo( SwUndoIter& rIter )
+void SwUndoTblCpyTbl::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     _DEBUG_REDLINE( &rDoc )
 
     if( pInsRowUndo )
-        pInsRowUndo->Redo( rIter );
+    {
+        pInsRowUndo->RedoImpl(rContext);
+    }
 
     SwTableNode* pTblNd = 0;
-    for( USHORT n = 0; n < pArr->Count(); ++n )
+    for( sal_uInt16 n = 0; n < pArr->Count(); ++n )
     {
         _UndoTblCpyTbl_Entry* pEntry = (*pArr)[ n ];
-        ULONG nSttPos = pEntry->nBoxIdx + pEntry->nOffset;
+        sal_uLong nSttPos = pEntry->nBoxIdx + pEntry->nOffset;
         SwStartNode* pSNd = rDoc.GetNodes()[ nSttPos ]->StartOfSectionNode();
         if( !pTblNd )
             pTblNd = pSNd->FindTableNode();
@@ -2675,10 +2677,10 @@ void SwUndoTblCpyTbl::Redo( SwUndoIter& rIter )
         // b62341295: Redline for copying tables - Start.
         rDoc.GetNodes().MakeTxtNode( aInsIdx, (SwTxtFmtColl*)rDoc.GetDfltTxtFmtColl() );
         SwPaM aPam( aInsIdx.GetNode(), *rBox.GetSttNd()->EndOfSectionNode());
-        SwUndo* pUndo = IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) ? 0 : new SwUndoDelete( aPam, TRUE );
+        SwUndo* pUndo = IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) ? 0 : new SwUndoDelete( aPam, sal_True );
         if( pEntry->pUndo )
         {
-            pEntry->pUndo->Undo( rIter );
+            pEntry->pUndo->UndoImpl(rContext);
             if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
             {
                 // PrepareRedline has to be called with the beginning of the old content
@@ -2686,8 +2688,12 @@ void SwUndoTblCpyTbl::Redo( SwUndoIter& rIter )
                 // by the Undo operation to this point.
                 // Otherwise aInsIdx has been moved during the Undo operation
                 if( pEntry->bJoin )
-                    pUndo = PrepareRedline( &rDoc, rBox, *rIter.pAktPam->GetPoint(),
+                {
+                    SwPaM const& rLastPam =
+                        rContext.GetCursorSupplier().GetCurrentShellCursor();
+                    pUndo = PrepareRedline( &rDoc, rBox, *rLastPam.GetPoint(),
                                             pEntry->bJoin, true );
+                }
                 else
                 {
                     SwPosition aTmpPos( aInsIdx );
@@ -2695,6 +2701,7 @@ void SwUndoTblCpyTbl::Redo( SwUndoIter& rIter )
                 }
             }
             delete pEntry->pUndo;
+            pEntry->pUndo = 0;
         }
         pEntry->pUndo = pUndo;
         // b62341295: Redline for copying tables - End.
@@ -2730,7 +2737,7 @@ void SwUndoTblCpyTbl::Redo( SwUndoIter& rIter )
     _DEBUG_REDLINE( &rDoc )
 }
 
-void SwUndoTblCpyTbl::AddBoxBefore( const SwTableBox& rBox, BOOL bDelCntnt )
+void SwUndoTblCpyTbl::AddBoxBefore( const SwTableBox& rBox, sal_Bool bDelCntnt )
 {
     if( pArr->Count() && !bDelCntnt )
         return;
@@ -2747,7 +2754,7 @@ void SwUndoTblCpyTbl::AddBoxBefore( const SwTableBox& rBox, BOOL bDelCntnt )
         SwPaM aPam( aInsIdx.GetNode(), *rBox.GetSttNd()->EndOfSectionNode() );
 
         if( !pDoc->IsRedlineOn() )
-            pEntry->pUndo = new SwUndoDelete( aPam, TRUE );
+            pEntry->pUndo = new SwUndoDelete( aPam, sal_True );
     }
 
     pEntry->pBoxNumAttr = new SfxItemSet( pDoc->GetAttrPool(),
@@ -2759,7 +2766,7 @@ void SwUndoTblCpyTbl::AddBoxBefore( const SwTableBox& rBox, BOOL bDelCntnt )
     _DEBUG_REDLINE( pDoc )
 }
 
-void SwUndoTblCpyTbl::AddBoxAfter( const SwTableBox& rBox, const SwNodeIndex& rIdx, BOOL bDelCntnt )
+void SwUndoTblCpyTbl::AddBoxAfter( const SwTableBox& rBox, const SwNodeIndex& rIdx, sal_Bool bDelCntnt )
 {
     _UndoTblCpyTbl_Entry* pEntry = (*pArr)[ pArr->Count() - 1 ];
 
@@ -2845,7 +2852,7 @@ SwUndo* SwUndoTblCpyTbl::PrepareRedline( SwDoc* pDoc, const SwTableBox& rBox,
         aCellEnd = SwPosition(
             SwNodeIndex( *rBox.GetSttNd()->EndOfSectionNode() ));
         SwPaM aTmpPam( aDeleteStart, aCellEnd );
-        pUndo = new SwUndoDelete( aTmpPam, TRUE );
+        pUndo = new SwUndoDelete( aTmpPam, sal_True );
     }
     SwPosition aCellStart( SwNodeIndex( *rBox.GetSttNd(), 2 ) );
     pTxt = aCellStart.nNode.GetNode().GetTxtNode();
@@ -2862,18 +2869,18 @@ SwUndo* SwUndoTblCpyTbl::PrepareRedline( SwDoc* pDoc, const SwTableBox& rBox,
 }
 
 
-BOOL SwUndoTblCpyTbl::InsertRow( SwTable& rTbl, const SwSelBoxes& rBoxes,
-                                USHORT nCnt )
+sal_Bool SwUndoTblCpyTbl::InsertRow( SwTable& rTbl, const SwSelBoxes& rBoxes,
+                                sal_uInt16 nCnt )
 {
     SwTableNode* pTblNd = (SwTableNode*)rTbl.GetTabSortBoxes()[0]->
                                 GetSttNd()->FindTableNode();
 
     SwTableSortBoxes aTmpLst( 0, 5 );
     pInsRowUndo = new SwUndoTblNdsChg( UNDO_TABLE_INSROW, rBoxes, *pTblNd,
-                                       0, 0, nCnt, TRUE, FALSE );
+                                       0, 0, nCnt, sal_True, sal_False );
     aTmpLst.Insert( &rTbl.GetTabSortBoxes(), 0, rTbl.GetTabSortBoxes().Count() );
 
-    BOOL bRet = rTbl.InsertRow( rTbl.GetFrmFmt()->GetDoc(), rBoxes, nCnt, TRUE );
+    sal_Bool bRet = rTbl.InsertRow( rTbl.GetFrmFmt()->GetDoc(), rBoxes, nCnt, sal_True );
     if( bRet )
         pInsRowUndo->SaveNewBoxes( *pTblNd, aTmpLst );
     else
@@ -2881,12 +2888,13 @@ BOOL SwUndoTblCpyTbl::InsertRow( SwTable& rTbl, const SwSelBoxes& rBoxes,
     return bRet;
 }
 
-BOOL SwUndoTblCpyTbl::IsEmpty() const
+sal_Bool SwUndoTblCpyTbl::IsEmpty() const
 {
     return !pInsRowUndo && !pArr->Count();
 }
 
-/*  */
+
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoCpyTbl::SwUndoCpyTbl()
     : SwUndo( UNDO_CPYTBL ), pDel( 0 ), nTblNode( 0 )
@@ -2898,9 +2906,9 @@ SwUndoCpyTbl::~SwUndoCpyTbl()
     delete pDel;
 }
 
-void SwUndoCpyTbl::Undo( SwUndoIter& rIter )
+void SwUndoCpyTbl::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwTableNode* pTNd = rDoc.GetNodes()[ nTblNode ]->GetTableNode();
 
     // harte SeitenUmbrueche am nachfolgenden Node verschieben
@@ -2911,29 +2919,29 @@ void SwUndoCpyTbl::Undo( SwUndoIter& rIter )
         const SfxPoolItem *pItem;
 
         if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_PAGEDESC,
-            FALSE, &pItem ) )
+            sal_False, &pItem ) )
             pNextNd->SetAttr( *pItem );
 
         if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_BREAK,
-            FALSE, &pItem ) )
+            sal_False, &pItem ) )
             pNextNd->SetAttr( *pItem );
     }
 
     SwPaM aPam( *pTNd, *pTNd->EndOfSectionNode(), 0 , 1 );
-    pDel = new SwUndoDelete( aPam, TRUE );
+    pDel = new SwUndoDelete( aPam, sal_True );
 }
 
-void SwUndoCpyTbl::Redo( SwUndoIter& rIter )
+void SwUndoCpyTbl::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    pDel->Undo( rIter );
+    pDel->UndoImpl(rContext);
     delete pDel, pDel = 0;
 }
 
 
-/*  */
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoSplitTbl::SwUndoSplitTbl( const SwTableNode& rTblNd,
-    SwSaveRowSpan* pRowSp, USHORT eMode, BOOL bNewSize )
+    SwSaveRowSpan* pRowSp, sal_uInt16 eMode, sal_Bool bNewSize )
     : SwUndo( UNDO_SPLIT_TABLE ),
     nTblNode( rTblNd.GetIndex() ), nOffset( 0 ), mpSaveRowSpan( pRowSp ), pSavTbl( 0 ),
     pHistory( 0 ), nMode( eMode ), nFmlEnd( 0 ), bCalcNewSize( bNewSize )
@@ -2945,7 +2953,7 @@ SwUndoSplitTbl::SwUndoSplitTbl( const SwTableNode& rTblNd,
             // kein break;
     case HEADLINE_BORDERCOPY:
     case HEADLINE_BOXATTRCOPY:
-        pSavTbl = new _SaveTable( rTblNd.GetTable(), 1, FALSE );
+        pSavTbl = new _SaveTable( rTblNd.GetTable(), 1, sal_False );
         break;
     }
 }
@@ -2957,10 +2965,10 @@ SwUndoSplitTbl::~SwUndoSplitTbl()
     delete mpSaveRowSpan;
 }
 
-void SwUndoSplitTbl::Undo( SwUndoIter& rIter )
+void SwUndoSplitTbl::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 
     pPam->DeleteMark();
     SwNodeIndex& rIdx = pPam->GetPoint()->nNode;
@@ -2987,7 +2995,7 @@ void SwUndoSplitTbl::Undo( SwUndoIter& rIter )
     case HEADLINE_BOXATTRCOPY:
     case HEADLINE_BORDERCOPY:
         {
-            pSavTbl->CreateNew( rTbl, FALSE );
+            pSavTbl->CreateNew( rTbl, sal_False );
             pSavTbl->RestoreAttr( rTbl );
         }
         break;
@@ -2997,11 +3005,11 @@ void SwUndoSplitTbl::Undo( SwUndoIter& rIter )
         {
             SwSelBoxes aSelBoxes;
             SwTableBox* pBox = rTbl.GetTblBox( nTblNode + nOffset + 1 );
-            rTbl.SelLineFromBox( pBox, aSelBoxes, TRUE );
+            rTbl.SelLineFromBox( pBox, aSelBoxes, sal_True );
             _FndBox aTmpBox( 0, 0 );
             aTmpBox.SetTableLines( aSelBoxes, rTbl );
             aTmpBox.DelFrms( rTbl );
-            rTbl.DeleteSel( pDoc, aSelBoxes, 0, 0, FALSE, FALSE );
+            rTbl.DeleteSel( pDoc, aSelBoxes, 0, 0, sal_False, sal_False );
         }
         break;
     }
@@ -3022,10 +3030,10 @@ void SwUndoSplitTbl::Undo( SwUndoIter& rIter )
     ClearFEShellTabCols();
 }
 
-void SwUndoSplitTbl::Redo( SwUndoIter& rIter )
+void SwUndoSplitTbl::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 
     pPam->DeleteMark();
     pPam->GetPoint()->nNode = nTblNode;
@@ -3034,10 +3042,10 @@ void SwUndoSplitTbl::Redo( SwUndoIter& rIter )
     ClearFEShellTabCols();
 }
 
-void SwUndoSplitTbl::Repeat( SwUndoIter& rIter )
+void SwUndoSplitTbl::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
+    SwPaM *const pPam = & rContext.GetRepeatPaM();
+    SwDoc *const pDoc = & rContext.GetDoc();
 
     pDoc->SplitTable( *pPam->GetPoint(), nMode, bCalcNewSize );
     ClearFEShellTabCols();
@@ -3052,11 +3060,12 @@ void SwUndoSplitTbl::SaveFormula( SwHistory& rHistory )
     pHistory->Move( 0, &rHistory );
 }
 
-/*  */
+
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoMergeTbl::SwUndoMergeTbl( const SwTableNode& rTblNd,
                                 const SwTableNode& rDelTblNd,
-                                BOOL bWithPrv, USHORT nMd )
+                                sal_Bool bWithPrv, sal_uInt16 nMd )
     : SwUndo( UNDO_MERGE_TABLE ), pSavTbl( 0 ),
     pHistory( 0 ), nMode( nMd ), bWithPrev( bWithPrv )
 {
@@ -3079,10 +3088,10 @@ SwUndoMergeTbl::~SwUndoMergeTbl()
     delete pHistory;
 }
 
-void SwUndoMergeTbl::Undo( SwUndoIter& rIter )
+void SwUndoMergeTbl::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 
     pPam->DeleteMark();
     SwNodeIndex& rIdx = pPam->GetPoint()->nNode;
@@ -3101,7 +3110,7 @@ void SwUndoMergeTbl::Undo( SwUndoIter& rIter )
     aFndBox.DelFrms( *pTbl );
     // ? TL_CHART2: notification or locking of controller required ?
 
-    SwTableNode* pNew = pDoc->GetNodes().SplitTable( rIdx, TRUE, FALSE );
+    SwTableNode* pNew = pDoc->GetNodes().SplitTable( rIdx, sal_True, sal_False );
 
     //Layout updaten
     aFndBox.MakeFrms( *pTbl );
@@ -3117,7 +3126,7 @@ void SwUndoMergeTbl::Undo( SwUndoIter& rIter )
         pTbl = &pNew->GetTable();
     pTbl->GetFrmFmt()->SetName( aName );
 
-//	pSavTbl->CreateNew( *pTbl, FALSE );
+//	pSavTbl->CreateNew( *pTbl, sal_False );
     pSavTbl->RestoreAttr( *pTbl );
 
 
@@ -3146,10 +3155,10 @@ void SwUndoMergeTbl::Undo( SwUndoIter& rIter )
     }
 }
 
-void SwUndoMergeTbl::Redo( SwUndoIter& rIter )
+void SwUndoMergeTbl::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 
     pPam->DeleteMark();
     pPam->GetPoint()->nNode = nTblNode;
@@ -3163,10 +3172,10 @@ void SwUndoMergeTbl::Redo( SwUndoIter& rIter )
     ClearFEShellTabCols();
 }
 
-void SwUndoMergeTbl::Repeat( SwUndoIter& rIter )
+void SwUndoMergeTbl::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwPaM* pPam = rIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pPam = & rContext.GetRepeatPaM();
 
     pDoc->MergeTable( *pPam->GetPoint(), bWithPrev, nMode );
     ClearFEShellTabCols();
@@ -3179,12 +3188,12 @@ void SwUndoMergeTbl::SaveFormula( SwHistory& rHistory )
     pHistory->Move( 0, &rHistory );
 }
 
-/*  */
 
+//////////////////////////////////////////////////////////////////////////
 
-void InsertSort( SvUShorts& rArr, USHORT nIdx, USHORT* pInsPos )
+void InsertSort( SvUShorts& rArr, sal_uInt16 nIdx, sal_uInt16* pInsPos )
 {
-    USHORT nO	= rArr.Count(), nM, nU = 0;
+    sal_uInt16 nO	= rArr.Count(), nM, nU = 0;
     if( nO > 0 )
     {
         nO--;
@@ -3193,7 +3202,7 @@ void InsertSort( SvUShorts& rArr, USHORT nIdx, USHORT* pInsPos )
             nM = nU + ( nO - nU ) / 2;
             if( *(rArr.GetData() + nM) == nIdx )
             {
-                OSL_ENSURE( FALSE, "Index already exists. This should never happen." );
+                OSL_ENSURE( sal_False, "Index already exists. This should never happen." );
                 return;
             }
             if( *(rArr.GetData() + nM) < nIdx )
@@ -3209,9 +3218,9 @@ void InsertSort( SvUShorts& rArr, USHORT nIdx, USHORT* pInsPos )
         *pInsPos = nU;
 }
 
-void InsertSort( SvULongs& rArr, ULONG nIdx, USHORT* pInsPos )
+void InsertSort( SvULongs& rArr, sal_uLong nIdx, sal_uInt16* pInsPos )
 {
-    USHORT nO	= rArr.Count(), nM, nU = 0;
+    sal_uInt16 nO	= rArr.Count(), nM, nU = 0;
     if( nO > 0 )
     {
         nO--;
@@ -3220,7 +3229,7 @@ void InsertSort( SvULongs& rArr, ULONG nIdx, USHORT* pInsPos )
             nM = nU + ( nO - nU ) / 2;
             if( *(rArr.GetData() + nM) == nIdx )
             {
-                OSL_ENSURE( FALSE, "Index ist schon vorhanden, darf nie sein!" );
+                OSL_ENSURE( sal_False, "Index ist schon vorhanden, darf nie sein!" );
                 return;
             }
             if( *(rArr.GetData() + nM) < nIdx )
@@ -3243,7 +3252,7 @@ void CheckTable( const SwTable& rTbl )
 {
     const SwNodes& rNds = rTbl.GetFrmFmt()->GetDoc()->GetNodes();
     const SwTableSortBoxes& rSrtArr = rTbl.GetTabSortBoxes();
-    for( USHORT n = 0; n < rSrtArr.Count(); ++n )
+    for( sal_uInt16 n = 0; n < rSrtArr.Count(); ++n )
     {
         const SwTableBox* pBox = rSrtArr[ n ];
         const SwNode* pNd = pBox->GetSttNd();
diff --git a/sw/source/core/undo/untblk.cxx b/sw/source/core/undo/untblk.cxx
index 7eb48657e9..75a6b8e75f 100644
--- a/sw/source/core/undo/untblk.cxx
+++ b/sw/source/core/undo/untblk.cxx
@@ -29,16 +29,16 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
-
 #include <hintids.hxx>
 #include <fmtanchr.hxx>
 #include <frmfmt.hxx>
 #include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
 #include <docary.hxx>
 #include <swundo.hxx>			// fuer die UndoIds
 #include <pam.hxx>
 #include <ndtxt.hxx>
-#include <undobj.hxx>
+#include <UndoCore.hxx>
 #include <rolbck.hxx>
 #include <redline.hxx>
 
@@ -46,8 +46,8 @@
 
 SwUndoInserts::SwUndoInserts( SwUndoId nUndoId, const SwPaM& rPam )
     : SwUndo( nUndoId ), SwUndRng( rPam ),
-    pTxtFmtColl( 0 ), pLastNdColl(0), pFrmFmts( 0 ), pFlyUndos(0), pRedlData( 0 ),
-    bSttWasTxtNd( TRUE ), nNdDiff( 0 ), pPos( 0 ), nSetPos( 0 )
+    pTxtFmtColl( 0 ), pLastNdColl(0), pFrmFmts( 0 ), pRedlData( 0 ),
+    bSttWasTxtNd( sal_True ), nNdDiff( 0 ), pPos( 0 ), nSetPos( 0 )
 {
     pHistory = new SwHistory;
     SwDoc* pDoc = (SwDoc*)rPam.GetDoc();
@@ -63,8 +63,8 @@ SwUndoInserts::SwUndoInserts( SwUndoId nUndoId, const SwPaM& rPam )
 
         if( !nSttCntnt )	// dann werden Flys mitgenommen !!
         {
-            USHORT nArrLen = pDoc->GetSpzFrmFmts()->Count();
-            for( USHORT n = 0; n < nArrLen; ++n )
+            sal_uInt16 nArrLen = pDoc->GetSpzFrmFmts()->Count();
+            for( sal_uInt16 n = 0; n < nArrLen; ++n )
             {
                 SwFrmFmt* pFmt = (*pDoc->GetSpzFrmFmts())[n];
                 SwFmtAnchor const*const  pAnchor = &pFmt->GetAnchor();
@@ -90,8 +90,8 @@ SwUndoInserts::SwUndoInserts( SwUndoId nUndoId, const SwPaM& rPam )
 
 // setze den Destination-Bereich nach dem Einlesen.
 
-void SwUndoInserts::SetInsertRange( const SwPaM& rPam, BOOL bScanFlys,
-                                    BOOL bSttIsTxtNd )
+void SwUndoInserts::SetInsertRange( const SwPaM& rPam, sal_Bool bScanFlys,
+                                    sal_Bool bSttIsTxtNd )
 {
     const SwPosition* pTmpPos = rPam.End();
     nEndNode = pTmpPos->nNode.GetIndex();
@@ -109,7 +109,7 @@ void SwUndoInserts::SetInsertRange( const SwPaM& rPam, BOOL bScanFlys,
         if( !bSttIsTxtNd )		// wird eine Tabellenselektion eingefuegt,
         {
             ++nSttNode;			// dann stimmt der CopyPam nicht ganz
-            bSttWasTxtNd = FALSE;
+            bSttWasTxtNd = sal_False;
         }
     }
 
@@ -117,9 +117,8 @@ void SwUndoInserts::SetInsertRange( const SwPaM& rPam, BOOL bScanFlys,
     {
         // dann alle neuen Flys zusammen sammeln !!
         SwDoc* pDoc = (SwDoc*)rPam.GetDoc();
-        pFlyUndos = new SwUndos();
-        USHORT nFndPos, nArrLen = pDoc->GetSpzFrmFmts()->Count();
-        for( USHORT n = 0; n < nArrLen; ++n )
+        sal_uInt16 nFndPos, nArrLen = pDoc->GetSpzFrmFmts()->Count();
+        for( sal_uInt16 n = 0; n < nArrLen; ++n )
         {
             SwFrmFmt* pFmt = (*pDoc->GetSpzFrmFmts())[n];
             SwFmtAnchor const*const pAnchor = &pFmt->GetAnchor();
@@ -131,16 +130,15 @@ void SwUndoInserts::SetInsertRange( const SwPaM& rPam, BOOL bScanFlys,
                 if( !pFrmFmts ||
                     USHRT_MAX == ( nFndPos = pFrmFmts->GetPos( pFmt ) ) )
                 {
-                    SwUndoInsLayFmt* pFlyUndo = new SwUndoInsLayFmt( pFmt,0,0 );
-                    pFlyUndos->Insert( pFlyUndo, pFlyUndos->Count() );
+                    ::boost::shared_ptr<SwUndoInsLayFmt> const pFlyUndo(
+                        new SwUndoInsLayFmt(pFmt, 0, 0));
+                    m_FlyUndos.push_back(pFlyUndo);
                 }
                 else
                     pFrmFmts->Remove( nFndPos );
             }
         }
         delete pFrmFmts, pFrmFmts = 0;
-        if( !pFlyUndos->Count() )
-            delete pFlyUndos, pFlyUndos = 0;
     }
 }
 
@@ -167,25 +165,21 @@ SwUndoInserts::~SwUndoInserts()
         delete pPos;
     }
     delete pFrmFmts;
-    delete pFlyUndos;
     delete pRedlData;
 }
 
 
-void SwUndoInserts::Undo( SwUndoIter& rUndoIter )
+void SwUndoInserts::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM * pPam = rUndoIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
-    SetPaM( rUndoIter );
-    BOOL bUndo = pDoc->DoesUndo();
-    pDoc->DoUndo( FALSE );
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pPam = & AddUndoRedoPaM(rContext);
 
     if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
         pDoc->DeleteRedline( *pPam, true, USHRT_MAX );
 
     // sind an Point/Mark 2 unterschiedliche TextNodes, dann muss ein
     // JoinNext ausgefuehrt werden.
-    BOOL bJoinNext = nSttNode != nEndNode &&
+    sal_Bool bJoinNext = nSttNode != nEndNode &&
                 pPam->GetMark()->nNode.GetNode().GetTxtNode() &&
                 pPam->GetPoint()->nNode.GetNode().GetTxtNode();
 
@@ -200,8 +194,8 @@ void SwUndoInserts::Undo( SwUndoIter& rUndoIter )
                 pLastNdColl = pTxtNd->GetTxtColl();
         }
 
-        RemoveIdxFromRange( *pPam, FALSE );
-        SetPaM( rUndoIter );
+        RemoveIdxFromRange( *pPam, sal_False );
+        SetPaM(*pPam);
 
         // sind Fussnoten oder CntntFlyFrames im Text ??
         nSetPos = pHistory->Count();
@@ -219,11 +213,13 @@ void SwUndoInserts::Undo( SwUndoIter& rUndoIter )
         }
     }
 
-    if( pFlyUndos )
+    if (m_FlyUndos.size())
     {
-        ULONG nTmp = pPam->GetPoint()->nNode.GetIndex();
-        for( USHORT n = pFlyUndos->Count(); n; )
-            (*pFlyUndos)[ --n ]->Undo( rUndoIter );
+        sal_uLong nTmp = pPam->GetPoint()->nNode.GetIndex();
+        for (size_t n = m_FlyUndos.size(); 0 < n; --n)
+        {
+            m_FlyUndos[ n-1 ]->UndoImpl(rContext);
+        }
         nNdDiff += nTmp - pPam->GetPoint()->nNode.GetIndex();
     }
 
@@ -269,16 +265,12 @@ void SwUndoInserts::Undo( SwUndoIter& rUndoIter )
             pHistory->TmpRollback( pDoc, 0, false );
         }
     }
-
-    pDoc->DoUndo( bUndo );
-    if( pPam != rUndoIter.pAktPam )
-        delete pPam;
 }
 
-void SwUndoInserts::Redo( SwUndoIter& rUndoIter )
+void SwUndoInserts::RedoImpl(::sw::UndoRedoContext & rContext)
 {
     // setze noch den Cursor auf den Redo-Bereich
-    SwPaM* pPam = rUndoIter.pAktPam;
+    SwPaM *const pPam = & AddUndoRedoPaM(rContext);
     SwDoc* pDoc = pPam->GetDoc();
     pPam->DeleteMark();
     pPam->GetPoint()->nNode = nSttNode - nNdDiff;
@@ -294,10 +286,10 @@ void SwUndoInserts::Redo( SwUndoIter& rUndoIter )
     // alte Anfangs-Position fuers Rollback zurueckholen
     if( ( nSttNode != nEndNode || nSttCntnt != nEndCntnt ) && pPos )
     {
-        BOOL bMvBkwrd = MovePtBackward( *pPam );
+        sal_Bool bMvBkwrd = MovePtBackward( *pPam );
 
         // Inhalt wieder einfuegen. (erst pPos abmelden !!)
-        ULONG nMvNd = pPos->nNode.GetIndex();
+        sal_uLong nMvNd = pPos->nNode.GetIndex();
         xub_StrLen nMvCnt = pPos->nContent.GetIndex();
         DELETEZ( pPos );
         MoveFromUndoNds( *pDoc, nMvNd, nMvCnt, *pPam->GetMark() );
@@ -322,9 +314,10 @@ void SwUndoInserts::Redo( SwUndoIter& rUndoIter )
             pTxtNd->ChgFmtColl( pLastNdColl );
     }
 
-    if( pFlyUndos )
-        for( USHORT n = pFlyUndos->Count(); n; )
-            (*pFlyUndos)[ --n ]->Redo( rUndoIter );
+    for (size_t n = m_FlyUndos.size(); 0 < n; --n)
+    {
+        m_FlyUndos[ n-1 ]->RedoImpl(rContext);
+    }
 
     pHistory->Rollback( pDoc, nSetPos );
 
@@ -340,21 +333,16 @@ void SwUndoInserts::Redo( SwUndoIter& rUndoIter )
         pDoc->SplitRedline( *pPam );
 }
 
-void SwUndoInserts::Repeat( SwUndoIter& rUndoIter )
+void SwUndoInserts::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    if( GetId() == rUndoIter.GetLastUndoId() )
-        return;
-
-    SwPaM aPam( *rUndoIter.pAktPam->GetPoint() );
+    SwPaM aPam( rContext.GetDoc().GetNodes().GetEndOfContent() );
     SetPaM( aPam );
-    aPam.GetDoc()->CopyRange( aPam, *rUndoIter.pAktPam->GetPoint(), false );
-
-    rUndoIter.pLastUndoObj = this;
+    SwPaM & rRepeatPaM( rContext.GetRepeatPaM() );
+    aPam.GetDoc()->CopyRange( aPam, *rRepeatPaM.GetPoint(), false );
 }
 
 
-/*  */
-
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoInsDoc::SwUndoInsDoc( const SwPaM& rPam )
     : SwUndoInserts( UNDO_INSDOKUMENT, rPam )