undoapi: #i115383#: derive sw::UndoManager from SfxUndoManager:

derive SwUndo from SfxUndoAction.
throw away most of docundo.cxx.
throw away SwUndoStart and SwUndoEnd.
replace SwUndoIter with sw::UndoRedoContext and sw::RepeatContext.
SwUndo::GetId() no longer public to prevent abuse.
add SwEditShell::HandleUndoRedoContext().

26 files changed, 1089 insertions, 1618 deletions

diff --git a/sw/source/core/undo/SwUndoField.cxx b/sw/source/core/undo/SwUndoField.cxx
index 578e6edf144e..3f714561b05b 100644
--- a/sw/source/core/undo/SwUndoField.cxx
+++ b/sw/source/core/undo/SwUndoField.cxx
@@ -86,7 +86,7 @@ SwUndoFieldFromDoc::~SwUndoFieldFromDoc()
     delete pNewField;
 }
 
-void SwUndoFieldFromDoc::Undo( SwUndoIter& )
+void SwUndoFieldFromDoc::UndoImpl(::sw::UndoRedoContext &)
 {
     SwTxtFld * pTxtFld = SwDoc::GetTxtFld(GetPosition());
     const SwField * pField = pTxtFld->GetFld().GetFld();
@@ -97,7 +97,7 @@ void SwUndoFieldFromDoc::Undo( SwUndoIter& )
     }
 }
 
-void SwUndoFieldFromDoc::Redo( SwUndoIter& )
+void SwUndoFieldFromDoc::DoImpl()
 {
     SwTxtFld * pTxtFld = SwDoc::GetTxtFld(GetPosition());
     const SwField * pField = pTxtFld->GetFld().GetFld();
@@ -112,10 +112,15 @@ void SwUndoFieldFromDoc::Redo( SwUndoIter& )
     }
 }
 
-void SwUndoFieldFromDoc::Repeat(SwUndoIter & rIt)
+void SwUndoFieldFromDoc::RedoImpl(::sw::UndoRedoContext &)
+{
+    DoImpl();
+}
+
+void SwUndoFieldFromDoc::RepeatImpl(::sw::RepeatContext &)
 {
     ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
-    Redo(rIt);
+    DoImpl();
 }
 
 SwUndoFieldFromAPI::SwUndoFieldFromAPI(const SwPosition & rPos,
@@ -129,7 +134,7 @@ SwUndoFieldFromAPI::~SwUndoFieldFromAPI()
 {
 }
 
-void SwUndoFieldFromAPI::Undo( SwUndoIter& )
+void SwUndoFieldFromAPI::UndoImpl(::sw::UndoRedoContext &)
 {
     SwField * pField = SwDoc::GetField(GetPosition());
 
@@ -137,7 +142,7 @@ void SwUndoFieldFromAPI::Undo( SwUndoIter& )
         pField->PutValue(aOldVal, nWhich);
 }
 
-void SwUndoFieldFromAPI::Redo( SwUndoIter& )
+void SwUndoFieldFromAPI::DoImpl()
 {
     SwField * pField = SwDoc::GetField(GetPosition());
 
@@ -145,8 +150,13 @@ 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();
 }
+
diff --git a/sw/source/core/undo/SwUndoFmt.cxx b/sw/source/core/undo/SwUndoFmt.cxx
index 00518539a8ae..4c95a6f1049d 100644
--- a/sw/source/core/undo/SwUndoFmt.cxx
+++ b/sw/source/core/undo/SwUndoFmt.cxx
@@ -56,7 +56,7 @@ SwUndoFmtCreate::~SwUndoFmtCreate()
 {
 }
 
-void SwUndoFmtCreate::Undo(SwUndoIter &)
+void SwUndoFmtCreate::UndoImpl(::sw::UndoRedoContext &)
 {
     if (pNew)
     {
@@ -77,7 +77,7 @@ void SwUndoFmtCreate::Undo(SwUndoIter &)
     }
 }
 
-void SwUndoFmtCreate::Redo(SwUndoIter &)
+void SwUndoFmtCreate::RedoImpl(::sw::UndoRedoContext &)
 {
     SwFmt * pDerivedFrom = Find(sDerivedFrom);
     SwFmt * pFmt = Create(pDerivedFrom);
@@ -123,7 +123,7 @@ SwUndoFmtDelete::~SwUndoFmtDelete()
 {
 }
 
-void SwUndoFmtDelete::Undo(SwUndoIter &)
+void SwUndoFmtDelete::UndoImpl(::sw::UndoRedoContext &)
 {
     SwFmt * pDerivedFrom = Find(sDerivedFrom);
 
@@ -139,7 +139,7 @@ void SwUndoFmtDelete::Undo(SwUndoIter &)
     }
 }
 
-void SwUndoFmtDelete::Redo(SwUndoIter &)
+void SwUndoFmtDelete::RedoImpl(::sw::UndoRedoContext &)
 {
     SwFmt * pOld = Find(sOldName);
 
@@ -172,7 +172,7 @@ SwUndoRenameFmt::~SwUndoRenameFmt()
 {
 }
 
-void SwUndoRenameFmt::Undo(SwUndoIter &)
+void SwUndoRenameFmt::UndoImpl(::sw::UndoRedoContext &)
 {
     SwFmt * pFmt = Find(sNewName);
 
@@ -182,7 +182,7 @@ void SwUndoRenameFmt::Undo(SwUndoIter &)
     }
 }
 
-void SwUndoRenameFmt::Redo(SwUndoIter &)
+void SwUndoRenameFmt::RedoImpl(::sw::UndoRedoContext &)
 {
     SwFmt *  pFmt = Find(sOldName);
 
@@ -373,7 +373,7 @@ SwUndoNumruleCreate::SwUndoNumruleCreate(const SwNumRule * _pNew,
 {
 }
 
-void SwUndoNumruleCreate::Undo(SwUndoIter &)
+void SwUndoNumruleCreate::UndoImpl(::sw::UndoRedoContext &)
 {
     if (! bInitialized)
     {
@@ -384,7 +384,7 @@ void SwUndoNumruleCreate::Undo(SwUndoIter &)
     pDoc->DelNumRule(aNew.GetName(), TRUE);
 }
 
-void SwUndoNumruleCreate::Redo(SwUndoIter &)
+void SwUndoNumruleCreate::RedoImpl(::sw::UndoRedoContext &)
 {
     pDoc->MakeNumRule(aNew.GetName(), &aNew, TRUE);
 }
@@ -410,12 +410,12 @@ SwUndoNumruleDelete::SwUndoNumruleDelete(const SwNumRule & rRule,
 {
 }
 
-void SwUndoNumruleDelete::Undo(SwUndoIter &)
+void SwUndoNumruleDelete::UndoImpl(::sw::UndoRedoContext &)
 {
     pDoc->MakeNumRule(aOld.GetName(), &aOld, TRUE);
 }
 
-void SwUndoNumruleDelete::Redo(SwUndoIter &)
+void SwUndoNumruleDelete::RedoImpl(::sw::UndoRedoContext &)
 {
     pDoc->DelNumRule(aOld.GetName(), TRUE);
 }
@@ -437,12 +437,12 @@ SwUndoNumruleRename::SwUndoNumruleRename(const String & _aOldName,
 {
 }
 
-void SwUndoNumruleRename::Undo(SwUndoIter &)
+void SwUndoNumruleRename::UndoImpl(::sw::UndoRedoContext &)
 {
     pDoc->RenameNumRule(aNewName, aOldName, TRUE);
 }
 
-void SwUndoNumruleRename::Redo(SwUndoIter &)
+void SwUndoNumruleRename::RedoImpl(::sw::UndoRedoContext &)
 {
     pDoc->RenameNumRule(aOldName, aNewName, TRUE);
 }
diff --git a/sw/source/core/undo/SwUndoPageDesc.cxx b/sw/source/core/undo/SwUndoPageDesc.cxx
index adada319d516..c23811d08f4c 100644
--- a/sw/source/core/undo/SwUndoPageDesc.cxx
+++ b/sw/source/core/undo/SwUndoPageDesc.cxx
@@ -326,7 +326,7 @@ void SwUndoPageDesc::ExchangeContentNodes( SwPageDesc& rSource, SwPageDesc &rDes
     }
 }
 
-void SwUndoPageDesc::Undo(SwUndoIter &)
+void SwUndoPageDesc::UndoImpl(::sw::UndoRedoContext &)
 {
     // Move (header/footer)content node responsibility from new page descriptor to old one again.
     if( bExchange )
@@ -334,7 +334,7 @@ void SwUndoPageDesc::Undo(SwUndoIter &)
     pDoc->ChgPageDesc(aOld.GetName(), aOld);
 }
 
-void SwUndoPageDesc::Redo(SwUndoIter &)
+void SwUndoPageDesc::RedoImpl(::sw::UndoRedoContext &)
 {
     // Move (header/footer)content node responsibility from old page descriptor to new one again.
     if( bExchange )
@@ -342,10 +342,6 @@ void SwUndoPageDesc::Redo(SwUndoIter &)
     pDoc->ChgPageDesc(aNew.GetName(), aNew);
 }
 
-void SwUndoPageDesc::Repeat(SwUndoIter &)
-{
-}
-
 SwRewriter SwUndoPageDesc::GetRewriter() const
 {
     SwRewriter aResult;
@@ -370,7 +366,7 @@ SwUndoPageDescCreate::~SwUndoPageDescCreate()
 {
 }
 
-void SwUndoPageDescCreate::Undo(SwUndoIter &)
+void SwUndoPageDescCreate::UndoImpl(::sw::UndoRedoContext &)
 {
     // -> #116530#
     if (pDesc)
@@ -383,17 +379,21 @@ void SwUndoPageDescCreate::Undo(SwUndoIter &)
     pDoc->DelPageDesc(aNew.GetName(), TRUE);
 }
 
-
-void SwUndoPageDescCreate::Redo(SwUndoIter &)
+void SwUndoPageDescCreate::DoImpl()
 {
     SwPageDesc aPageDesc = aNew;
     pDoc->MakePageDesc(aNew.GetName(), &aPageDesc, FALSE, TRUE); // #116530#
 }
 
-void SwUndoPageDescCreate::Repeat(SwUndoIter & rIt)
+void SwUndoPageDescCreate::RedoImpl(::sw::UndoRedoContext &)
+{
+    DoImpl();
+}
+
+void SwUndoPageDescCreate::RepeatImpl(::sw::RepeatContext &)
 {
     ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
-    Redo(rIt);
+    DoImpl();
 }
 
 SwRewriter SwUndoPageDescCreate::GetRewriter() const
@@ -420,21 +420,26 @@ SwUndoPageDescDelete::~SwUndoPageDescDelete()
 {
 }
 
-void SwUndoPageDescDelete::Undo(SwUndoIter &)
+void SwUndoPageDescDelete::UndoImpl(::sw::UndoRedoContext &)
 {
     SwPageDesc aPageDesc = aOld;
     pDoc->MakePageDesc(aOld.GetName(), &aPageDesc, FALSE, TRUE); // #116530#
 }
 
-void SwUndoPageDescDelete::Redo(SwUndoIter &)
+void SwUndoPageDescDelete::DoImpl()
 {
     pDoc->DelPageDesc(aOld.GetName(), TRUE); // #116530#
 }
 
-void SwUndoPageDescDelete::Repeat(SwUndoIter & rIt)
+void SwUndoPageDescDelete::RedoImpl(::sw::UndoRedoContext &)
+{
+    DoImpl();
+}
+
+void SwUndoPageDescDelete::RepeatImpl(::sw::RepeatContext &)
 {
     ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
-    Redo(rIt);
+    DoImpl();
 }
 
 SwRewriter SwUndoPageDescDelete::GetRewriter() const
diff --git a/sw/source/core/undo/SwUndoTOXChange.cxx b/sw/source/core/undo/SwUndoTOXChange.cxx
index 8628ff70acc7..457ddc366e7c 100644
--- a/sw/source/core/undo/SwUndoTOXChange.cxx
+++ b/sw/source/core/undo/SwUndoTOXChange.cxx
@@ -27,6 +27,7 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
+
 #include <SwUndoTOXChange.hxx>
 #include <swundo.hxx>
 #include <doctxm.hxx>
@@ -45,27 +46,32 @@ 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();
 }
+
diff --git a/sw/source/core/undo/docundo.cxx b/sw/source/core/undo/docundo.cxx
index 4b42a2b9540e..18a37e02c307 100644
--- a/sw/source/core/undo/docundo.cxx
+++ b/sw/source/core/undo/docundo.cxx
@@ -41,11 +41,12 @@
 #include <ndarr.hxx>
 #include <pam.hxx>
 #include <ndtxt.hxx>
-#include <swundo.hxx>       // fuer die UndoIds
+#include <swundo.hxx>
 #include <undobj.hxx>
 #include <rolbck.hxx>
-#include <docary.hxx>
 #include <undo.hrc>
+#include <editsh.hxx>
+#include <unobaseclass.hxx>
 
 
 using namespace ::com::sun::star;
@@ -55,50 +56,6 @@ using namespace ::com::sun::star;
 #define UNDO_ACTION_LIMIT (USHRT_MAX - 1000)
 
 
-//#define _SHOW_UNDORANGE
-#ifdef _SHOW_UNDORANGE
-
-
-class UndoArrStatus : public WorkWindow
-{
-    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();
-}
-
-
-void UndoArrStatus::Set( USHORT n1, USHORT n2 )
-{
-    nUndo = n1; nUndoNds = n2;
-    Invalidate();
-}
-
-
-void UndoArrStatus::Paint( const Rectangle& )
-{
-    String s;
-    DrawRect( Rectangle( Point(0,0), GetOutputSize() ));
-    ( s = "Undos: " ) += nUndo;
-    DrawText( Point( 0, 0 ), s );
-    ( s = "UndoNodes: " ) += nUndoNds;
-    DrawText( Point( 0, 15 ), s );
-}
-
-#endif
-
-
 // UndoManager ///////////////////////////////////////////////////////////
 
 namespace sw {
@@ -111,17 +68,16 @@ UndoManager::UndoManager(::std::auto_ptr<SwNodes> pUndoNodes,
     ,   m_rRedlineAccess(rRedlineAccess)
     ,   m_rState(rState)
     ,   m_pUndoNodes(pUndoNodes)
-    ,   m_pUndos( new SwUndos( 0, 20 ) )
-    ,   m_nUndoPos(0)
-    ,   m_nUndoSavePos(0)
-    ,   m_nUndoActions(0)
-    ,   m_nNestingDepth(0)
-    ,   m_bUndo(false)
     ,   m_bGroupUndo(true)
     ,   m_bDrawUndo(true)
     ,   m_bLockUndoNoModifiedPosition(false)
+    ,   m_bClearOnLeave(false)
+    ,   m_UndoSaveMark(MARK_INVALID)
 {
     OSL_ASSERT(m_pUndoNodes.get());
+    // writer expects it to be disabled initially
+    // Undo is enabled by SwEditShell constructor
+    SfxUndoManager::EnableUndo(false);
 }
 
 SwNodes const& UndoManager::GetUndoNodes() const
@@ -141,7 +97,7 @@ bool UndoManager::IsUndoNodes(SwNodes const& rNodes) const
 
 void UndoManager::DoUndo(bool const bDoUndo)
 {
-    m_bUndo = bDoUndo;
+    EnableUndo(bDoUndo);
 
     SdrModel *const pSdrModel = m_rDrawModelAccess.GetDrawModel();
     if( pSdrModel )
@@ -152,7 +108,7 @@ void UndoManager::DoUndo(bool const bDoUndo)
 
 bool UndoManager::DoesUndo() const
 {
-    return m_bUndo;
+    return IsUndoEnabled();
 }
 
 void UndoManager::DoGroupUndo(bool const bDoUndo)
@@ -178,21 +134,23 @@ bool UndoManager::DoesDrawUndo() const
 
 bool UndoManager::IsUndoNoResetModified() const
 {
-    return USHRT_MAX == m_nUndoSavePos;
+    return MARK_INVALID == m_UndoSaveMark;
 }
 
 void UndoManager::SetUndoNoResetModified()
 {
-    m_nUndoSavePos = USHRT_MAX;
+    if (MARK_INVALID != m_UndoSaveMark)
+    {
+        RemoveMark(m_UndoSaveMark);
+        m_UndoSaveMark = MARK_INVALID;
+    }
 }
 
 void UndoManager::SetUndoNoModifiedPosition()
 {
     if (!m_bLockUndoNoModifiedPosition)
     {
-        m_nUndoSavePos = (m_pUndos->Count())
-            ?   m_nUndoPos
-            :   USHRT_MAX;
+        m_UndoSaveMark = MarkTopUndoAction();
     }
 }
 
@@ -209,334 +167,51 @@ void UndoManager::UnLockUndoNoModifiedPosition()
 
 SwUndo* UndoManager::GetLastUndo()
 {
-    return (0 == m_nUndoPos)
-        ?   0
-        :   (*m_pUndos)[m_nUndoPos-1];
-}
-
-void UndoManager::AppendUndo(SwUndo *const pUndo)
-{
-    OSL_ENSURE(DoesUndo(), "AppendUndo called with Undo disabled?");
-    if (!DoesUndo())
-    {
-        return;
-    }
-
-    if( nsRedlineMode_t::REDLINE_NONE == pUndo->GetRedlineMode() )
-    {
-        pUndo->SetRedlineMode( m_rRedlineAccess.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#
-    OSL_ENSURE( m_pUndos->Count() < USHRT_MAX - 16,
-                "Writer will crash soon. I apologize for the inconvenience." );
-
-    m_pUndos->Insert(pUndo, m_nUndoPos);
-    ++m_nUndoPos;
-    switch( pUndo->GetId() )
-    {
-        case UNDO_START:
-            ++m_nNestingDepth;
-        break;
-
-        case UNDO_END:
-            OSL_ENSURE(m_nNestingDepth, "AppendUndo(): Undo-End without Start");
-            --m_nNestingDepth;
-            // no break !
-
-        default:
-            if ((m_pUndos->Count() != m_nUndoPos) &&
-                (UNDO_END != pUndo->GetId()))
-            {
-                ClearRedo();
-            }
-            OSL_ENSURE( m_pUndos->Count() == m_nUndoPos
-                    ||  UNDO_END == pUndo->GetId(),
-                        "AppendUndo(): Redo history not deleted!" );
-            if (!m_nNestingDepth)
-            {
-                ++m_nUndoActions;
-            }
-        break;
-    }
-
-#ifdef _SHOW_UNDORANGE
-    // zur Anzeige der aktuellen Undo-Groessen
-    if( !pUndoMsgWin )
-            pUndoMsgWin = new UndoArrStatus;
-    pUndoMsgWin->Set( m_pUndos->Count(), GetUndoNodes()->Count() );
-#endif
-
-    // if the bracketing is still open, nothing more to do here
-    if (m_nNestingDepth)
-    {
-        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;
-
-#ifdef DBG_UTIL
-{
-    USHORT nUndosCnt = 0, nSttEndCnt = 0;
-    for (USHORT nCnt = 0; nCnt < m_nUndoPos; ++nCnt)
+    if (!SfxUndoManager::GetUndoActionCount(CurrentLevel))
     {
-        SwUndoId const nId = (*m_pUndos)[ nCnt ]->GetId();
-        if (UNDO_START == nId)
-        {
-            ++nSttEndCnt;
-        }
-        else if( UNDO_END == nId )
-            --nSttEndCnt;
-        if( !nSttEndCnt )
-            ++nUndosCnt;
+        return 0;
     }
-    OSL_ENSURE(nSttEndCnt == m_nNestingDepth,
-            "AppendUndo(): nesting depth is wrong");
-    OSL_ENSURE(nUndosCnt == m_nUndoActions,
-            "AppendUndo(): Undo action count is wrong");
+    SfxUndoAction *const pAction( SfxUndoManager::GetUndoAction(0) );
+    return dynamic_cast<SwUndo*>(pAction);
 }
-#endif
 
-    sal_Int32 const nActions(SW_MOD()->GetUndoOptions().GetUndoCount());
-    if (nActions < m_nUndoActions)
-    {
-        // 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( sal_uInt16( m_nUndoActions - nActions ) );
-    }
-    else
-    {
-        USHORT const nUndosCnt = m_nUndoActions;
-            // immer 1/10 loeschen bis der "Ausloeser" behoben ist
-        while (nEnde < GetUndoNodes().Count())
-        {
-            DelUndoObj( nUndosCnt / 10 );
-        }
-    }
+void UndoManager::AppendUndo(SwUndo *const pUndo)
+{
+    AddUndoAction(pUndo);
 }
 
-
 void UndoManager::ClearRedo()
 {
-    if (m_nUndoPos != m_pUndos->Count())
-    {
-        // update m_nUndoActions
-        for (USHORT nCnt = m_pUndos->Count(); m_nUndoPos < nCnt;
-                --m_nUndoActions)
-        {
-            // skip Start/End bracketing
-            SwUndo *const pUndo = (*m_pUndos)[ --nCnt ];
-            if (UNDO_END == pUndo->GetId())
-            {
-                nCnt = nCnt - static_cast<SwUndoEnd*>(pUndo)->GetSttOffset();
-            }
-        }
-
-        // delete Undo actions in reverse order!
-        m_pUndos->DeleteAndDestroy(m_nUndoPos, m_pUndos->Count() - m_nUndoPos);
-    }
+    return SfxUndoManager::ImplClearRedo_NoLock(TopLevel);
 }
 
-
 void UndoManager::DelAllUndoObj()
 {
     ::sw::UndoGuard const undoGuard(*this);
 
-    ClearRedo();
+    SfxUndoManager::Clear();
 
-    // retain open Start bracketing!
-    USHORT nSize = m_pUndos->Count();
-    while( nSize )
+    m_UndoSaveMark = MARK_INVALID;
+    if (SfxUndoManager::IsInListAction())
     {
-        SwUndo *const pUndo = (*m_pUndos)[ --nSize ];
-        if ((UNDO_START != pUndo->GetId()) ||
-            // bracketing closed with End?
-            static_cast<SwUndoStart*>(pUndo)->GetEndOffset())
-        {
-            m_pUndos->DeleteAndDestroy( nSize, 1 );
-        }
+        m_bClearOnLeave = true;
     }
-
-    m_nUndoActions = 0;
-    m_nUndoPos = m_pUndos->Count();
-
-    m_nUndoSavePos = USHRT_MAX;
 }
 
 
-bool UndoManager::DelUndoObj( sal_uInt16 nEnd )
-{
-    if (0 == nEnd)  // in case 0 is passed in
-    {
-        if (!m_pUndos->Count())
-        {
-            return false;
-        }
-        ++nEnd;     // correct it to 1 // FIXME  why ???
-    }
-
-    ::sw::UndoGuard const undoGuard(*this);
-
-    // check where the end is
-    USHORT nSttEndCnt = 0;
-    USHORT nCnt;
-
-    for (nCnt = 0; nEnd && nCnt < m_nUndoPos; ++nCnt)
-    {
-        SwUndoId const nId = (*m_pUndos)[ nCnt ]->GetId();
-        if (UNDO_START == nId)
-        {
-            ++nSttEndCnt;
-        }
-        else if( UNDO_END == nId )
-        {
-            --nSttEndCnt;
-        }
-        if( !nSttEndCnt )
-        {
-            --nEnd, --m_nUndoActions;
-        }
-    }
-
-    OSL_ENSURE( nCnt < m_nUndoPos || m_nUndoPos == m_pUndos->Count(),
-            "DelUndoObj(): end inside of Redo actions!" );
-
-    // update positions
-    nSttEndCnt = nCnt;
-    if (m_nUndoSavePos < nSttEndCnt) // abandon SavePos
-    {
-        m_nUndoSavePos = USHRT_MAX;
-    }
-    else if (m_nUndoSavePos != USHRT_MAX)
-    {
-        m_nUndoSavePos = m_nUndoSavePos - nSttEndCnt;
-    }
-
-    while( nSttEndCnt )
-    {
-        m_pUndos->DeleteAndDestroy( --nSttEndCnt, 1 );
-    }
-    m_nUndoPos = m_pUndos->Count();
-
-    return true;
-}
-
 /**************** UNDO ******************/
 
-bool UndoManager::HasUndoId(SwUndoId const eId) const
-{
-    USHORT nSize = m_nUndoPos;
-    while( nSize-- )
-    {
-        SwUndo *const pUndo = (*m_pUndos)[nSize];
-        if ((pUndo->GetId() == eId) ||
-            ( UNDO_START == pUndo->GetId() &&
-                (static_cast<SwUndoStart*>(pUndo)->GetUserId() == eId))
-            || ( UNDO_END == pUndo->GetId() &&
-                (static_cast<SwUndoEnd*>(pUndo)->GetUserId() == eId)))
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-
-bool UndoManager::Undo( SwUndoIter& rUndoIter )
-{
-    if ( (rUndoIter.GetId()!=0) && (!HasUndoId(rUndoIter.GetId())) )
-    {
-        rUndoIter.bWeiter = FALSE;
-        return false;
-    }
-    if (!m_nUndoPos)
-    {
-        rUndoIter.bWeiter = FALSE;
-        return false;
-    }
-
-    ::sw::UndoGuard const undoGuard(*this);
-
-    SwUndo * pUndo = (*m_pUndos)[ --m_nUndoPos ];
-
-    RedlineMode_t const eOld = m_rRedlineAccess.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() )
-    {
-        m_rRedlineAccess.SetRedlineMode( eTmpMode );
-    }
-    m_rRedlineAccess.SetRedlineMode_intern(
-        static_cast<RedlineMode_t>(eTmpMode | nsRedlineMode_t::REDLINE_IGNORE));
-
-    SwUndoId const 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 );
-
-    m_rRedlineAccess.SetRedlineMode( eOld );
-
-    if (m_nUndoPos && !rUndoIter.bWeiter)
-    {
-        pUndo = (*m_pUndos)[ m_nUndoPos-1 ];
-        if (UNDO_START == pUndo->GetId())
-        {
-            --m_nUndoPos;
-        }
-    }
-
-    // if we are at the "last save" position, the document is not modified
-    if (m_nUndoSavePos == m_nUndoPos)
-    {
-        m_rState.ResetModified();
-    }
-    // JP 29.10.96: Start und End setzen kein Modify-Flag.
-    //              Sonst gibt es Probleme mit der autom. Aufnahme von Ausnahmen
-    //              bei der Autokorrektur
-    else if ((UNDO_START != nAktId) && (UNDO_END != nAktId))
-    {
-        m_rState.SetModified();
-    }
-
-    return true;
-}
-
-
 SwUndoId
 UndoManager::StartUndo(SwUndoId const i_eUndoId,
         SwRewriter const*const pRewriter)
 {
-    if (!m_bUndo)
+    if (!IsUndoEnabled())
     {
         return UNDO_EMPTY;
     }
 
     SwUndoId const eUndoId( (0 == i_eUndoId) ? UNDO_START : i_eUndoId );
 
-    SwUndoStart * pUndo = new SwUndoStart( eUndoId );
-
     OSL_ASSERT(UNDO_END != eUndoId);
     String comment( (UNDO_START == eUndoId)
         ?   String("??", RTL_TEXTENCODING_ASCII_US)
@@ -546,9 +221,8 @@ UndoManager::StartUndo(SwUndoId const i_eUndoId,
         OSL_ASSERT(UNDO_START != eUndoId);
         comment = pRewriter->Apply(comment);
     }
-    pUndo->SetComment(comment);
 
-    AppendUndo(pUndo);
+    SfxUndoManager::EnterListAction(comment, comment, eUndoId);
 
     return eUndoId;
 }
@@ -557,8 +231,7 @@ UndoManager::StartUndo(SwUndoId const i_eUndoId,
 SwUndoId
 UndoManager::EndUndo(SwUndoId const i_eUndoId, SwRewriter const*const pRewriter)
 {
-    USHORT nSize = m_nUndoPos;
-    if (!m_bUndo || !nSize--)
+    if (!IsUndoEnabled())
     {
         return UNDO_EMPTY;
     }
@@ -566,334 +239,93 @@ UndoManager::EndUndo(SwUndoId const i_eUndoId, SwRewriter const*const pRewriter)
     SwUndoId const eUndoId( ((0 == i_eUndoId) || (UNDO_START == i_eUndoId))
             ? UNDO_END : i_eUndoId );
 
-    SwUndo * pUndo = (*m_pUndos)[ nSize ];
-    if( UNDO_START == pUndo->GetId() )
-    {
-        // empty Start/End bracketing?
-        m_pUndos->DeleteAndDestroy( nSize );
-        --m_nUndoPos;
-        --m_nNestingDepth;
-        return UNDO_EMPTY;
-    }
+    SfxUndoAction *const pLastUndo(
+        (0 == SfxUndoManager::GetUndoActionCount(CurrentLevel))
+            ? 0 : SfxUndoManager::GetUndoAction(0) );
 
-    // exist above any redo objects? If yes, delete them
-    if (m_nUndoPos != m_pUndos->Count())
-    {
-        // update UndoCnt
-        for (USHORT nCnt = m_pUndos->Count(); m_nUndoPos < nCnt;
-                --m_nUndoActions)
-        {
-            // skip bracketing
-            pUndo = (*m_pUndos)[ --nCnt ];
-            if (UNDO_END == pUndo->GetId())
-            {
-                nCnt -= static_cast<SwUndoEnd*>(pUndo)->GetSttOffset();
-            }
-        }
+    int const nCount = LeaveListAction();
 
-        m_pUndos->DeleteAndDestroy(m_nUndoPos, m_pUndos->Count() - m_nUndoPos);
-    }
-
-    // search for Start of this bracketing
-    SwUndoStart * pUndoStart(0);
-    while( nSize )
+    if (nCount) // otherwise: empty list action not inserted!
     {
-        SwUndo *const pTmpUndo = (*m_pUndos)[ --nSize ];
-        if ((UNDO_START == pTmpUndo->GetId()) &&
-            !static_cast<SwUndoStart*>(pTmpUndo)->GetEndOffset())
-        {
-            pUndoStart = static_cast<SwUndoStart *>(pTmpUndo);
-            break;      // found start
-        }
-    }
-
-    if (!pUndoStart)
-    {
-        // kann eigentlich nur beim Abspielen von Macros passieren, die
-        // Undo/Redo/Repeat benutzen und die eine exitierende Selection
-        // durch Einfuegen loeschen
-        OSL_ENSURE(false , "EndUndo(): corresponding UNDO_START not found");
-        // not found => do not insert end and reset members
-
-        m_nNestingDepth = 0;
-        m_nUndoActions = 0;
-        // update m_nUndoActions
-        for (USHORT nCnt = 0; nCnt < m_pUndos->Count();
-                ++nCnt, ++m_nUndoActions)
-        {
-            // skip bracketing
-            SwUndo *const pTmpUndo = (*m_pUndos)[ nCnt ];
-            if (UNDO_START == pTmpUndo->GetId())
-            {
-                nCnt += static_cast<SwUndoStart*>(pTmpUndo)->GetEndOffset();
-            }
-        }
-        return UNDO_EMPTY;
-    }
-
-    // bracketing around single Undo action is unnecessary!
-    // except if there is a custom user ID.
-    if ((2 == m_pUndos->Count() - nSize) &&
-        ((UNDO_END == eUndoId) || (eUndoId == (*m_pUndos)[ nSize+1 ]->GetId())))
-    {
-        m_pUndos->DeleteAndDestroy( nSize );
-        m_nUndoPos = m_pUndos->Count();
-        if (!--m_nNestingDepth)
+        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)
         {
-            ++m_nUndoActions;
-            sal_Int32 const nActions(SW_MOD()->GetUndoOptions().GetUndoCount());
-            if (nActions < m_nUndoActions)
+            if (UNDO_END != eUndoId)
             {
-                // 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( sal_uInt16( m_nUndoActions - nActions ) );
-            }
-            else
-            {
-                USHORT nEnde = USHRT_MAX - 1000;
-                USHORT const nUndosCnt = m_nUndoActions;
-                    // immer 1/10 loeschen bis der "Ausloeser" behoben ist
-                while (nEnde < GetUndoNodes().Count())
+                // comment set by caller of EndUndo
+                String comment = String(SW_RES(UNDO_BASE + eUndoId));
+                if (pRewriter)
                 {
-                    DelUndoObj( nUndosCnt / 10 );
+                    comment = pRewriter->Apply(comment);
                 }
+                pListAction->SetComment(comment);
             }
-        }
-        return eUndoId;
-    }
-
-    // set offset for Start/End bracketing
-    nSize = m_pUndos->Count() - nSize;
-    pUndoStart->SetEndOffset( nSize );
-
-    SwUndoEnd *const pUndoEnd = new SwUndoEnd( eUndoId );
-    pUndoEnd->SetSttOffset( nSize );
-
-// nur zum Testen der Start/End-Verpointerung vom Start/End Undo
-#ifdef DBG_UTIL
-    {
-        USHORT nEndCnt = 1;
-        USHORT nCnt = m_pUndos->Count();
-        SwUndoId nTmpId = UNDO_EMPTY;
-        while( nCnt )
-        {
-            nTmpId = (*m_pUndos)[ --nCnt ]->GetId();
-            if (UNDO_START == nTmpId)
+            else if ((UNDO_START != pListAction->GetId()))
             {
-                if( !nEndCnt ) // falls mal ein Start ohne Ende vorhanden ist
-                    continue;
-                --nEndCnt;
-                if( !nEndCnt )      // hier ist der Anfang
-                    break;
+                // comment set by caller of StartUndo: nothing to do here
             }
-            else if( UNDO_END == nTmpId )
-                ++nEndCnt;
-            else if( !nEndCnt )
-                break;
-        }
-        OSL_ENSURE( nCnt == m_pUndos->Count() - nSize,
-                "EndUndo(): Start-End bracketing wrong" );
-    }
-#endif
-
-    if (pRewriter)
-    {
-        OSL_ASSERT(UNDO_START != eUndoId);
-        String const comment( (UNDO_END == eUndoId)
-            ?   String("??", RTL_TEXTENCODING_ASCII_US)
-            :   pRewriter->Apply(String(SW_RES(UNDO_BASE + eUndoId))) );
-        pUndoStart->SetComment(comment);
-        pUndoEnd->SetComment(comment);
-    }
-    else
-    {
-        pUndoEnd->SetComment(pUndoStart->GetComment());
-    }
-
-    AppendUndo( pUndoEnd );
-    return eUndoId;
-}
-
-/*-- 24.11.2004 16:11:21---------------------------------------------------
-
-  -----------------------------------------------------------------------*/
-
-typedef ::std::pair<SwUndoId, ::rtl::OUString> IdAndName_t;
-
-/**
-   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 IdAndName_t object containing the query result
- */
-IdAndName_t 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())
-    {
-    case UNDO_START:
-        {
-            SwUndoStart * pUndoStart = (SwUndoStart *) pUndo;
-            nId = pUndoStart->GetUserId();
-
-            if (nId <= UNDO_END)
+            else if (pLastUndo)
             {
-                /**
-                   Start at the according UNDO_END.  Search backwards
-                   for first objects that is not a UNDO_END.
-                 */
-                int nTmpPos = nPos + pUndoStart->GetEndOffset();
-                int nSubstitute = -1;
-
-                // --> OD 2009-09-30 #i105457#
-                if ( nTmpPos > 0 )
-                // <--
-                {
-                    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();
-                    }
-                }
+                // 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
-                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;
-                int nUndoStart = nTmpPos - pUndoEnd->GetSttOffset();
-                int nSubstitute = -1;
-
-                if (nTmpPos > 0)
-                {
-                    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();
-                    }
-                }
+                OSL_ENSURE(false, "EndUndo(): no comment?");
             }
-            else
-                sStr = pUndo->GetComment();
         }
-
-        break;
-
-    default:
-        nId = pUndo->GetId();
-        sStr = pUndo->GetComment();
     }
 
-    return IdAndName_t(nId, sStr);
+    return eUndoId;
 }
 
-
 bool
 UndoManager::GetLastUndoInfo(
         ::rtl::OUString *const o_pStr, SwUndoId *const o_pId) const
 {
-    if (!m_nUndoPos)
+    // this is actually expected to work on the current level,
+    // but that was really not obvious from the previous implementation...
+    if (!SfxUndoManager::GetUndoActionCount(CurrentLevel))
     {
         return false;
     }
 
-    IdAndName_t const idAndName(lcl_GetUndoIdAndName(*m_pUndos, m_nUndoPos-1));
+    SfxUndoAction *const pAction( SfxUndoManager::GetUndoAction(0) );
 
     if (o_pStr)
     {
-        *o_pStr = idAndName.second;
+        *o_pStr = pAction->GetComment();
     }
     if (o_pId)
     {
-        *o_pId = idAndName.first;
+        USHORT const nId(pAction->GetId());
+        *o_pId = static_cast<SwUndoId>(nId);
     }
 
     return true;
 }
 
-
 SwUndoComments_t UndoManager::GetUndoComments() const
 {
-    SwUndoComments_t ret;
-    int nTmpPos = m_nUndoPos - 1;
+    OSL_ENSURE(!SfxUndoManager::IsInListAction(),
+            "GetUndoComments() called while in list action?");
 
-    while (nTmpPos >= 0)
+    SwUndoComments_t ret;
+    USHORT const nUndoCount(SfxUndoManager::GetUndoActionCount(TopLevel));
+    for (USHORT n = 0; n < nUndoCount; ++n)
     {
-        SwUndo *const pUndo = (*m_pUndos)[ static_cast<USHORT>(nTmpPos) ];
-
-        IdAndName_t const idAndName(
-            lcl_GetUndoIdAndName(*m_pUndos, static_cast<sal_uInt16>(nTmpPos)));
-
-        ret.push_back(idAndName.second);
-
-        if (pUndo->GetId() == UNDO_END)
-        {
-            nTmpPos -= static_cast<SwUndoEnd *>(pUndo)->GetSttOffset();
-        }
-
-        nTmpPos--;
+        ::rtl::OUString const comment(
+                SfxUndoManager::GetUndoActionComment(n, TopLevel));
+        ret.push_back(comment);
     }
 
     return ret;
@@ -902,197 +334,264 @@ SwUndoComments_t UndoManager::GetUndoComments() const
 
 /**************** REDO ******************/
 
-
-bool UndoManager::Redo(SwUndoIter & rUndoIter)
+bool UndoManager::GetFirstRedoInfo(::rtl::OUString *const o_pStr) const
 {
-    if( rUndoIter.GetId() && !HasUndoId( rUndoIter.GetId() ) )
+    if (!SfxUndoManager::GetRedoActionCount(CurrentLevel))
     {
-        rUndoIter.bWeiter = FALSE;
         return false;
     }
-    if (m_nUndoPos == m_pUndos->Count())
+
+    if (o_pStr)
     {
-        rUndoIter.bWeiter = FALSE;
-        return false;
+        *o_pStr = SfxUndoManager::GetRedoActionComment(0, CurrentLevel);
     }
 
-    ::sw::UndoGuard const undoGuard(*this);
+    return true;
+}
+
 
-    SwUndo *const pUndo = (*m_pUndos)[ m_nUndoPos++ ];
+SwUndoComments_t UndoManager::GetRedoComments() const
+{
+    OSL_ENSURE(!SfxUndoManager::IsInListAction(),
+            "GetRedoComments() called while in list action?");
 
-    RedlineMode_t const eOld = m_rRedlineAccess.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() )
+    SwUndoComments_t ret;
+    USHORT const nRedoCount(SfxUndoManager::GetRedoActionCount(TopLevel));
+    for (USHORT n = 0; n < nRedoCount; ++n)
     {
-        m_rRedlineAccess.SetRedlineMode(eTmpMode);
+        ::rtl::OUString const comment(
+                SfxUndoManager::GetRedoActionComment(n, TopLevel));
+        ret.push_back(comment);
     }
-    m_rRedlineAccess.SetRedlineMode_intern(
-        static_cast<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 );
+    return ret;
+}
 
-    m_rRedlineAccess.SetRedlineMode(eOld);
+/**************** REPEAT ******************/
 
-    if (rUndoIter.bWeiter && (m_nUndoPos >= m_pUndos->Count()))
+SwUndoId UndoManager::GetRepeatInfo(::rtl::OUString *const o_pStr) const
+{
+    SwUndoId nRepeatId(UNDO_EMPTY);
+    GetLastUndoInfo(o_pStr, & nRepeatId);
+    if( REPEAT_START <= nRepeatId && REPEAT_END > nRepeatId )
     {
-        rUndoIter.bWeiter = FALSE;
+        return nRepeatId;
     }
+    if (o_pStr) // not repeatable -> clear comment
+    {
+        *o_pStr = String();
+    }
+    return UNDO_EMPTY;
+}
 
-    // if we are at the "last save" position, the document is not modified
-    if (m_nUndoSavePos == m_nUndoPos)
+SwUndo * UndoManager::RemoveLastUndo()
+{
+    if (SfxUndoManager::GetRedoActionCount(CurrentLevel) ||
+        SfxUndoManager::GetRedoActionCount(TopLevel))
     {
-        m_rState.ResetModified();
+        OSL_ENSURE(false, "RemoveLastUndoAction(): there are Redo actions?");
+        return 0;
     }
-    else
+    if (!SfxUndoManager::GetUndoActionCount(CurrentLevel))
     {
-        m_rState.SetModified();
+        OSL_ENSURE(false, "RemoveLastUndoAction(): no Undo actions");
+        return 0;
     }
-    return true;
+    SfxUndoAction *const pLastUndo(GetUndoAction(0));
+    SfxUndoManager::RemoveLastUndoAction();
+    return dynamic_cast<SwUndo *>(pLastUndo);
 }
 
+// svl::IUndoManager /////////////////////////////////////////////////////
 
-bool UndoManager::GetFirstRedoInfo(::rtl::OUString *const o_pStr) const
+void UndoManager::EnableUndo(bool bEnable)
 {
-    if (m_pUndos->Count() == m_nUndoPos)
+    // UGLY: SfxUndoManager has a counter to match enable/disable calls
+    //       but the writer code expects that a single call switches
+    while (IsUndoEnabled() != bEnable)
     {
-        return false;
+        SfxUndoManager::EnableUndo(bEnable);
     }
+}
 
-    IdAndName_t const idAndName(lcl_GetUndoIdAndName(*m_pUndos, m_nUndoPos));
+USHORT UndoManager::LeaveListAction()
+{
+    USHORT const nCount = SfxUndoManager::LeaveListAction();
 
-    if (o_pStr)
+    if (m_bClearOnLeave)
     {
-        *o_pStr = idAndName.second;
+        SfxUndoManager::Clear();
+        if (!SfxUndoManager::IsInListAction())
+        {
+            m_bClearOnLeave = false;
+        }
+        return 0; // EndUndo() must not access deleted last undo action!
     }
 
-    return true;
+    return nCount;
 }
 
-
-SwUndoComments_t UndoManager::GetRedoComments() const
+void UndoManager::AddUndoAction(SfxUndoAction *pAction, sal_Bool bTryMerge)
 {
-    SwUndoComments_t ret;
-    sal_uInt16 nTmpPos = m_nUndoPos;
-
-    while (nTmpPos < m_pUndos->Count())
+    SwUndo *const pUndo( dynamic_cast<SwUndo *>(pAction) );
+    if (pUndo)
     {
-        SwUndo *const pUndo = (*m_pUndos)[nTmpPos];
-
-        IdAndName_t const idAndName(lcl_GetUndoIdAndName(*m_pUndos, nTmpPos));
-
-        ret.push_back(idAndName.second);
-
-        if (pUndo->GetId() == UNDO_START)
+        if (nsRedlineMode_t::REDLINE_NONE == pUndo->GetRedlineMode())
         {
-            nTmpPos =
-                nTmpPos + static_cast<SwUndoStart *>(pUndo)->GetEndOffset();
+            pUndo->SetRedlineMode( m_rRedlineAccess.GetRedlineMode() );
         }
-
-        nTmpPos++;
     }
-
-    return ret;
+    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 UndoManager::Repeat(SwUndoIter & rUndoIter, sal_uInt16 const 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 nCurrentRepeat = m_nUndoPos;
-    if( !nCurrentRepeat )
+    ~CursorGuard()
     {
-        rUndoIter.bWeiter = FALSE;
-        return false;
+        if (m_bSaveCursor)
+        {
+            m_rShell.Pop();
+        }
     }
+private:
+    SwEditShell & m_rShell;
+    bool const m_bSaveCursor;
+};
+
+bool UndoManager::impl_DoUndoRedo(UndoOrRedo_t const undoOrRedo)
+{
+    SwDoc & rDoc(*GetUndoNodes().GetDoc());
+
+    UnoActionContext c(& rDoc); // exception-safe StartAllAction/EndAllAction
 
-    // look for current Repeat action, considering Start/End bracketing
-    SwUndo *const pUndo = (*m_pUndos)[ --nCurrentRepeat ];
-    if( UNDO_END == pUndo->GetId() )
+    SwEditShell *const pEditShell( rDoc.GetEditShell() );
+
+    OSL_ENSURE(pEditShell, "sw::UndoManager needs a SwEditShell!");
+    if (!pEditShell)
     {
-        nCurrentRepeat -= static_cast<SwUndoEnd*>(pUndo)->GetSttOffset();
+        throw uno::RuntimeException();
     }
 
-    USHORT const nEndCnt = m_nUndoPos;
-    bool const bOneUndo = (nCurrentRepeat + 1 == m_nUndoPos);
+    // 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();
+    }
 
-    SwPaM* pTmpCrsr = rUndoIter.pAktPam;
-    SwUndoId nId = UNDO_EMPTY;
+    bool bRet(false);
 
-    // need Start/End bracketing?
-    if (pTmpCrsr != pTmpCrsr->GetNext() || !bOneUndo)
+    ::sw::UndoRedoContext context(rDoc, *pEditShell);
+
+    // N.B. these may throw!
+    if (UNDO == undoOrRedo)
     {
-        if (pUndo->GetId() == UNDO_END)
+        bRet = SfxUndoManager::UndoWithContext(context);
+    }
+    else
+    {
+        bRet = SfxUndoManager::RedoWithContext(context);
+    }
+
+    if (bRet)
+    {
+        // if we are at the "last save" position, the document is not modified
+        if (SfxUndoManager::HasTopUndoActionMark(m_UndoSaveMark))
         {
-            SwUndoStart *const pStartUndo =
-                static_cast<SwUndoStart *>((*m_pUndos)[nCurrentRepeat]);
-            nId = pStartUndo->GetUserId();
+            m_rState.ResetModified();
         }
-
-        StartUndo( nId, NULL );
-    }
-    do {    // iterate over ring
-        for( USHORT nRptCnt = nRepeatCnt; nRptCnt > 0; --nRptCnt )
+        else
         {
-            for (USHORT nCnt = nCurrentRepeat; nCnt < nEndCnt; ++nCnt)
-            {
-                (*m_pUndos)[ nCnt ]->Repeat( rUndoIter );
-            }
+            m_rState.SetModified();
         }
-        rUndoIter.m_bDeleteRepeated = false; // reset for next PaM
-        rUndoIter.pAktPam = static_cast<SwPaM*>(rUndoIter.pAktPam->GetNext());
-    } while (pTmpCrsr != rUndoIter.pAktPam);
-    if( pTmpCrsr != pTmpCrsr->GetNext() || !bOneUndo )
-    {
-        EndUndo( nId, NULL );
     }
 
-    return true;
+    pEditShell->HandleUndoRedoContext(context);
+
+    return bRet;
 }
 
+sal_Bool UndoManager::Undo()
+{
+    bool const bRet = impl_DoUndoRedo(UNDO);
+    return bRet;
+}
 
-SwUndoId UndoManager::GetRepeatInfo(::rtl::OUString *const o_pStr) const
+sal_Bool UndoManager::Redo()
 {
-    SwUndoId nRepeatId(UNDO_EMPTY);
-    GetLastUndoInfo(o_pStr, & nRepeatId);
-    if( REPEAT_START <= nRepeatId && REPEAT_END > nRepeatId )
+    bool const bRet = impl_DoUndoRedo(REDO);
+    return bRet;
+}
+
+/** 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)
+{
+    if (SfxUndoManager::IsInListAction())
     {
-        return nRepeatId;
+        OSL_ENSURE(false, "repeat in open list action???");
+        return false;
     }
-    if (o_pStr) // not repeatable -> clear comment
+    if (!SfxUndoManager::GetUndoActionCount(TopLevel))
     {
-        *o_pStr = String();
+        return false;
+    }
+    SfxUndoAction *const pRepeatAction(GetUndoAction(0));
+    OSL_ASSERT(pRepeatAction);
+    if (!pRepeatAction || !pRepeatAction->CanRepeat(rContext))
+    {
+        return false;
     }
-    return UNDO_EMPTY;
-}
-
 
-SwUndo* UndoManager::RemoveLastUndo()
-{
-    SwUndo *const pUndo = (*m_pUndos)[ m_nUndoPos - 1 ];
-    if (m_nUndoPos != m_pUndos->Count())
+    ::rtl::OUString const comment(pRepeatAction->GetComment());
+    ::rtl::OUString const rcomment(pRepeatAction->GetRepeatComment(rContext));
+    USHORT const nId(pRepeatAction->GetId());
+    if (DoesUndo())
     {
-        OSL_ENSURE(false, "RemoveLastUndo(): there are Redo actions?");
-        return 0;
+        EnterListAction(comment, rcomment, nId);
     }
-    if (!m_nNestingDepth)
+
+    SwPaM *const pFirstCursor(& rContext.GetRepeatPaM());
+    do {    // iterate over ring
+        for (USHORT 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())
     {
-        --m_nUndoActions;
+        LeaveListAction();
     }
-    --m_nUndoPos;
-    m_pUndos->Remove( m_nUndoPos, 1 );
-    return pUndo;
+    return true;
 }
 
 } // namespace sw
diff --git a/sw/source/core/undo/makefile.mk b/sw/source/core/undo/makefile.mk
index 35771fa444bf..38285c909187 100644
--- a/sw/source/core/undo/makefile.mk
+++ b/sw/source/core/undo/makefile.mk
@@ -46,6 +46,7 @@ SRC1FILES =  \
 
 EXCEPTIONSFILES = \
         $(SLO)$/SwRewriter.obj \
+        $(SLO)$/docundo.obj \
         $(SLO)$/unattr.obj \
         $(SLO)$/undobj.obj \
         $(SLO)$/undraw.obj \
diff --git a/sw/source/core/undo/rolbck.cxx b/sw/source/core/undo/rolbck.cxx
index e2a8ffa8f67c..7ee75378ff5a 100644
--- a/sw/source/core/undo/rolbck.cxx
+++ b/sw/source/core/undo/rolbck.cxx
@@ -579,9 +579,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);
 }
 
 
@@ -1265,7 +1266,7 @@ USHORT SwHistory::SetTmpEnd( USHORT nNewTmpEnd )
         if ( HSTRY_FLYCNT == (*this)[ n ]->Which() )
         {
             static_cast<SwHistoryTxtFlyCnt*>((*this)[ n ])
-                ->GetUDelLFmt()->Redo();
+                ->GetUDelLFmt()->RedoForRollback();
         }
     }
 
diff --git a/sw/source/core/undo/unattr.cxx b/sw/source/core/undo/unattr.cxx
index 1886e40ec4b9..5e0cdda4e5bd 100644
--- a/sw/source/core/undo/unattr.cxx
+++ b/sw/source/core/undo/unattr.cxx
@@ -48,6 +48,7 @@
 #include <ftnidx.hxx>
 #include <doc.hxx>
 #include <IDocumentUndoRedo.hxx>
+#include <IShellCursorSupplier.hxx>
 #include <docary.hxx>
 #include <swundo.hxx>           // fuer die UndoIds
 #include <pam.hxx>
@@ -65,9 +66,6 @@
 
 
 
-inline SwDoc& SwUndoIter::GetDoc() const
-{ return *pAktPam->GetDoc(); }
-
 // -----------------------------------------------------
 
 SwUndoFmtAttrHelper::SwUndoFmtAttrHelper( SwFmt& rFmt, bool bSvDrwPt )
@@ -195,12 +193,12 @@ 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
@@ -209,7 +207,7 @@ void SwUndoFmtAttr::Undo( SwUndoIter& rUndoIter)
     bool bAnchorAttrRestored( false );
     if ( SFX_ITEM_SET == m_pOldSet->GetItemState( RES_ANCHOR, FALSE ))
     {
-        bAnchorAttrRestored = RestoreFlyAnchor( rUndoIter );
+        bAnchorAttrRestored = RestoreFlyAnchor(rContext);
         if ( bAnchorAttrRestored )
         {
             // Anchor attribute successfull restored.
@@ -241,7 +239,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);
         }
     }
 }
@@ -331,39 +329,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;
 
+    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;
@@ -377,7 +377,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!
@@ -387,11 +388,13 @@ 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;
@@ -466,9 +469,9 @@ 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 ) );
@@ -611,7 +614,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;
@@ -639,7 +642,7 @@ SwUndoFmtResetAttr::~SwUndoFmtResetAttr()
 {
 }
 
-void SwUndoFmtResetAttr::Undo( SwUndoIter& )
+void SwUndoFmtResetAttr::UndoImpl(::sw::UndoRedoContext &)
 {
     if ( m_pOldItem.get() )
     {
@@ -647,7 +650,7 @@ void SwUndoFmtResetAttr::Undo( SwUndoIter& )
     }
 }
 
-void SwUndoFmtResetAttr::Redo( SwUndoIter& )
+void SwUndoFmtResetAttr::RedoImpl(::sw::UndoRedoContext &)
 {
     if ( m_pOldItem.get() )
     {
@@ -678,10 +681,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() );
 
@@ -696,27 +699,25 @@ void SwUndoResetAttr::Undo( SwUndoIter& rUndoIter )
         }
     }
 
-    // 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();
+    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, FALSE, pIdArr );
         break;
     case RES_CONDTXTFMTCOLL:
-        rUndoIter.GetDoc().ResetAttrs( *rUndoIter.pAktPam, TRUE, pIdArr );
+        rDoc.ResetAttrs(rPam, TRUE, pIdArr );
 
         break;
     case RES_TXTATR_TOXMARK:
@@ -760,7 +761,7 @@ void SwUndoResetAttr::Redo( SwUndoIter& rUndoIter )
     }
 }
 
-void SwUndoResetAttr::Repeat( SwUndoIter& rUndoIter )
+void SwUndoResetAttr::RepeatImpl(::sw::RepeatContext & rContext)
 {
     if (m_nFormatId < RES_FMT_BEGIN)
     {
@@ -771,13 +772,13 @@ 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;
     }
 }
@@ -848,29 +849,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 );
@@ -887,32 +888,30 @@ void SwUndoAttr::Undo( SwUndoIter& rUndoIter )
     m_pHistory->SetTmpEnd( m_pHistory->Count() );
 
     // set cursor onto Undo area
-    SetPaM( rUndoIter );
+    AddUndoRedoPaM(rContext);
 }
 
-void SwUndoAttr::Repeat( SwUndoIter& rUndoIter )
+void SwUndoAttr::RepeatImpl(::sw::RepeatContext & rContext)
 {
     // RefMarks are not repeat capable
     if ( SFX_ITEM_SET != m_AttrSet.GetItemState( RES_TXTATR_REFMARK, 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 );
     }
 }
 
-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() ) )
@@ -1042,9 +1041,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(
@@ -1066,9 +1065,9 @@ void SwUndoDefaultAttr::Undo( SwUndoIter& rUndoIter)
     }
 }
 
-void SwUndoDefaultAttr::Redo( SwUndoIter& rUndoIter)
+void SwUndoDefaultAttr::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    Undo( rUndoIter );
+    UndoImpl(rContext);
 }
 
 // -----------------------------------------------------
@@ -1086,29 +1085,30 @@ SwUndoMoveLeftMargin::~SwUndoMoveLeftMargin()
 {
 }
 
-void SwUndoMoveLeftMargin::Undo( SwUndoIter& rIter )
+void SwUndoMoveLeftMargin::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     // restore old values
-    m_pHistory->TmpRollback( pDoc, 0 );
+    m_pHistory->TmpRollback( & rDoc, 0 );
     m_pHistory->SetTmpEnd( m_pHistory->Count() );
 
-    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 );
 }
 
@@ -1129,30 +1129,30 @@ SwUndoChangeFootNote::~SwUndoChangeFootNote()
 {
 }
 
-void SwUndoChangeFootNote::Undo( SwUndoIter& rIter )
+void SwUndoChangeFootNote::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
-    SetPaM( rIter );
+    SwDoc & rDoc = rContext.GetDoc();
 
     m_pHistory->TmpRollback( &rDoc, 0 );
     m_pHistory->SetTmpEnd( m_pHistory->Count() );
 
     rDoc.GetFtnIdxs().UpdateAllFtn();
 
-    SetPaM( rIter );
+    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 );
+    SwDoc & rDoc = rContext.GetDoc();
+    rDoc.SetCurFtn( rContext.GetRepeatPaM(), m_Text, m_nNumber, m_bEndNote );
 }
 
 
@@ -1169,17 +1169,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 );
@@ -1198,17 +1198,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 );
@@ -1223,10 +1223,10 @@ 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;
@@ -1235,10 +1235,10 @@ void SwUndoDontExpandFmt::Undo( SwUndoIter& rIter )
 }
 
 
-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;
@@ -1246,10 +1246,10 @@ 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() );
 }
 
diff --git a/sw/source/core/undo/unbkmk.cxx b/sw/source/core/undo/unbkmk.cxx
index b86bdad692ac..e433ed72a315 100644
--- a/sw/source/core/undo/unbkmk.cxx
+++ b/sw/source/core/undo/unbkmk.cxx
@@ -41,9 +41,6 @@
 #include "SwRewriter.hxx"
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
-
 SwUndoBookmark::SwUndoBookmark( SwUndoId nUndoId,
             const ::sw::mark::IMark& rBkmk )
     : SwUndo( nUndoId )
@@ -60,7 +57,6 @@ void SwUndoBookmark::SetInDoc( SwDoc* pDoc )
     m_pHistoryBookmark->SetInDoc( pDoc, false );
 }
 
-
 void SwUndoBookmark::ResetInDoc( SwDoc* pDoc )
 {
     IDocumentMarkAccess* const pMarkAccess = pDoc->getIDocumentMarkAccess();
@@ -95,15 +91,13 @@ 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() );
 }
 
-
diff --git a/sw/source/core/undo/undel.cxx b/sw/source/core/undo/undel.cxx
index db51feb5d138..680660de4353 100644
--- a/sw/source/core/undo/undel.cxx
+++ b/sw/source/core/undo/undel.cxx
@@ -61,8 +61,6 @@
 
 // using namespace comphelper;
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 
 // DELETE
 /*  lcl_MakeAutoFrms has to call MakeFrms for objects bounded "AtChar" ( == AUTO ),
@@ -643,9 +641,9 @@ void lcl_ReAnchorAtCntntFlyFrames( const SwSpzFrmFmts& rSpzArr, SwPosition &rPos
     }
 }
 
-void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
+void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rUndoIter.GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
 
     ULONG nCalcStt = nSttNode - nNdDiff;
 
@@ -846,16 +844,14 @@ void SwUndoDelete::Undo( SwUndoIter& rUndoIter )
     if( pRedlSaveData )
         SetSaveData( *pDoc, *pRedlSaveData );
 
-    SetPaM( rUndoIter, TRUE );
+    AddUndoRedoPaM(rContext, true);
 }
 
-void SwUndoDelete::Redo( SwUndoIter& rUndoIter )
+void SwUndoDelete::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM& rPam = *rUndoIter.pAktPam;
+    SwPaM & rPam = AddUndoRedoPaM(rContext);
     SwDoc& rDoc = *rPam.GetDoc();
 
-    SetPaM( rPam );
-
     if( pRedlSaveData )
     {
         bool bSuccess = FillSaveData(rPam, *pRedlSaveData, TRUE);
@@ -970,14 +966,14 @@ void SwUndoDelete::Redo( SwUndoIter& rUndoIter )
         rDoc.DeleteAndJoin( rPam );
 }
 
-void SwUndoDelete::Repeat( SwUndoIter& rUndoIter )
+void SwUndoDelete::RepeatImpl(::sw::RepeatContext & rContext)
 {
     // this action does not seem idempotent,
     // so make sure it is only executed once on repeat
-    if (rUndoIter.m_bDeleteRepeated)
+    if (rContext.m_bDeleteRepeated)
         return;
 
-    SwPaM& rPam = *rUndoIter.pAktPam;
+    SwPaM & rPam = rContext.GetRepeatPaM();
     SwDoc& rDoc = *rPam.GetDoc();
     ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
     if( !rPam.HasMark() )
@@ -989,7 +985,7 @@ void SwUndoDelete::Repeat( SwUndoIter& rUndoIter )
         rDoc.DelFullPara( rPam );
     else
         rDoc.DeleteAndJoin( rPam );
-    rUndoIter.m_bDeleteRepeated = true;
+    rContext.m_bDeleteRepeated = true;
 }
 
 
diff --git a/sw/source/core/undo/undobj.cxx b/sw/source/core/undo/undobj.cxx
index dfb2fe8b7be6..144b15c6b725 100644
--- a/sw/source/core/undo/undobj.cxx
+++ b/sw/source/core/undo/undobj.cxx
@@ -29,6 +29,7 @@
 #include "precompiled_sw.hxx"
 
 
+#include <IShellCursorSupplier.hxx>
 #include <txtftn.hxx>
 #include <fmtanchr.hxx>
 #include <ftnidx.hxx>
@@ -70,17 +71,6 @@ public:
 SV_IMPL_PTRARR( SwUndos, SwUndo*)
 SV_IMPL_PTRARR( SwRedlineSaveDatas, SwRedlineSaveDataPtr )
 
-SwUndoIter::SwUndoIter( SwPaM* pPam, SwUndoId nId )
-    : m_bDeleteRepeated(false)
-{
-    nUndoId = nId;
-    bWeiter = nId ? TRUE : FALSE;
-    pAktPam = pPam;
-    nEndCnt = 0;
-    pSelFmt = 0;
-    pMarkList = 0;
-}
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
 
 //------------------------------------------------------------
 
@@ -144,12 +134,15 @@ 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;
 }
 
+
 //------------------------------------------------------------
 
 
@@ -215,8 +208,89 @@ SwUndo::~SwUndo()
     delete pComment;
 }
 
-void SwUndo::Repeat( SwUndoIter & )
+
+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()
+{
+    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);
+}
+
+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
@@ -248,11 +322,6 @@ String SwUndo::GetComment() const
     return aResult;
 }
 
-SwUndoId SwUndo::GetEffectiveId() const
-{
-    return GetId();
-}
-
 SwRewriter SwUndo::GetRewriter() const
 {
     SwRewriter aResult;
@@ -260,6 +329,7 @@ SwRewriter SwUndo::GetRewriter() const
     return aResult;
 }
 
+
 //------------------------------------------------------------
 
 SwUndoSaveCntnt::SwUndoSaveCntnt()
@@ -905,92 +975,6 @@ 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
-{
-    OSL_ASSERT(pComment);
-    return (pComment) ? *pComment : String("??", RTL_TEXTENCODING_ASCII_US);
-}
-
-void SwUndoStart::SetComment(String const& rComment)
-{
-    pComment = new String(rComment);
-}
-
-SwUndoId SwUndoStart::GetEffectiveId() const
-{
-    return GetUserId();
-}
-
-
-// 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
-{
-    OSL_ASSERT(pComment);
-    return (pComment) ? *pComment : String("??", RTL_TEXTENCODING_ASCII_US);
-}
-
-void SwUndoEnd::SetComment(String const& rComment)
-{
-    pComment = new String(rComment);
-}
-
-SwUndoId SwUndoEnd::GetEffectiveId() const
-{
-    return GetUserId();
-}
-
-/*  */
         // sicher und setze die RedlineDaten
 
 SwRedlineSaveData::SwRedlineSaveData( SwComparePosition eCmpPos,
diff --git a/sw/source/core/undo/undobj1.cxx b/sw/source/core/undo/undobj1.cxx
index 42b1944d1139..a6050354545e 100644
--- a/sw/source/core/undo/undobj1.cxx
+++ b/sw/source/core/undo/undobj1.cxx
@@ -49,10 +49,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 )
@@ -65,9 +64,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();
@@ -96,7 +95,7 @@ void SwUndoFlyBase::InsFly( SwUndoIter& rUndoIter, BOOL bShowSelFrm )
     }
     else
     {
-        SwPosition aNewPos( *rUndoIter.pAktPam->GetPoint() );
+        SwPosition aNewPos(pDoc->GetNodes().GetEndOfContent());
         aNewPos.nNode = nNdPgPos;
         if ((FLY_AS_CHAR == nRndId) || (FLY_AT_CHAR == nRndId))
         {
@@ -132,7 +131,9 @@ void SwUndoFlyBase::InsFly( SwUndoIter& rUndoIter, BOOL bShowSelFrm )
     pFrmFmt->MakeFrms();
 
     if( bShowSelFrm )
-        rUndoIter.pSelFmt = pFrmFmt;
+    {
+        rContext.SetSelections(pFrmFmt, 0);
+    }
 
     if( GetHistory() )
         GetHistory()->Rollback( pDoc );
@@ -234,7 +235,7 @@ void SwUndoFlyBase::DelFly( SwDoc* pDoc )
     rFlyFmts.Remove( rFlyFmts.GetPos( pFrmFmt ));
 }
 
-// ----- Undo-InsertFly ------
+// SwUndoInsLayFmt ///////////////////////////////////////////////////////
 
 SwUndoInsLayFmt::SwUndoInsLayFmt( SwFrmFmt* pFormat, ULONG nNodeIdx, xub_StrLen nCntIdx )
     : SwUndoFlyBase( pFormat, RES_DRAWFRMFMT == pFormat->Which() ?
@@ -270,47 +271,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, 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)
 {
-    InsFly( rUndoIter );
+    InsFly(rContext);
 }
 
-void SwUndoInsLayFmt::Repeat( SwUndoIter& rUndoIter )
+void SwUndoInsLayFmt::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    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 );
@@ -319,7 +325,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 );
@@ -332,15 +339,17 @@ void SwUndoInsLayFmt::Repeat( SwUndoIter& rUndoIter )
     }
     else if (FLY_AT_PAGE == aAnchor.GetAnchorId())
     {
-        aAnchor.SetPageNum( pDoc->GetRootFrm()->GetCurrPage(
-                                        rUndoIter.pAktPam ));
+        aAnchor.SetPageNum(
+                pDoc->GetRootFrm()->GetCurrPage(& rContext.GetRepeatPaM()) );
     }
     else {
         ASSERT( FALSE, "was fuer ein Anker ist es denn nun?" );
     }
 
     SwFrmFmt* pFlyFmt = pDoc->CopyLayoutFmt( *pFrmFmt, aAnchor, true, true );
-    rUndoIter.pSelFmt = pFlyFmt;
+    (void) pFlyFmt;
+//FIXME nobody ever did anything with this selection:
+//    rContext.SetSelections(pFlyFmt, 0);
 }
 
 // #111827#
@@ -375,7 +384,7 @@ String SwUndoInsLayFmt::GetComment() const
     return aResult;
 }
 
-// ----- Undo-DeleteFly ------
+// SwUndoDelLayFmt ///////////////////////////////////////////////////////
 
 static SwUndoId
 lcl_GetSwUndoId(SwFrmFmt *const pFrmFmt)
@@ -433,22 +442,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 +469,7 @@ void SwUndoDelLayFmt::Redo()
     DelFly( pFrmFmt->GetDoc() );
 }
 
-/*  */
+// SwUndoSetFlyFmt ///////////////////////////////////////////////////////
 
 SwUndoSetFlyFmt::SwUndoSetFlyFmt( SwFrmFmt& rFlyFmt, SwFrmFmt& rNewFrmFmt )
     : SwUndo( UNDO_SETFLYFRMFMT ), SwClient( &rFlyFmt ), pFrmFmt( &rFlyFmt ),
@@ -534,9 +545,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 +615,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,7 +638,7 @@ void SwUndoSetFlyFmt::Redo( SwUndoIter& rIter )
         else
             rDoc.SetFrmFmtToFly( *pFrmFmt, *pNewFmt, 0 );
 
-        rIter.pSelFmt = pFrmFmt;
+        rContext.SetSelections(pFrmFmt, 0);
     }
 }
 
diff --git a/sw/source/core/undo/undoflystrattr.cxx b/sw/source/core/undo/undoflystrattr.cxx
index 23113d6b0d1b..fad07654f6f8 100644
--- a/sw/source/core/undo/undoflystrattr.cxx
+++ b/sw/source/core/undo/undoflystrattr.cxx
@@ -49,7 +49,7 @@ SwUndoFlyStrAttr::~SwUndoFlyStrAttr()
 {
 }
 
-void SwUndoFlyStrAttr::Undo( SwUndoIter& )
+void SwUndoFlyStrAttr::UndoImpl(::sw::UndoRedoContext &)
 {
     switch ( GetId() )
     {
@@ -69,7 +69,7 @@ void SwUndoFlyStrAttr::Undo( SwUndoIter& )
     }
 }
 
-void SwUndoFlyStrAttr::Redo( SwUndoIter& )
+void SwUndoFlyStrAttr::RedoImpl(::sw::UndoRedoContext &)
 {
     switch ( GetId() )
     {
@@ -89,11 +89,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 e4e9e9055c91..7e736b59dd50 100644
--- a/sw/source/core/undo/undraw.cxx
+++ b/sw/source/core/undo/undraw.cxx
@@ -65,8 +65,6 @@ struct SwUndoGroupObjImpl
 };
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 // Draw-Objecte
 
 IMPL_LINK( SwDoc, AddDrawUndo, SdrUndoAction *, pUndo )
@@ -107,16 +105,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
@@ -223,7 +221,7 @@ SwUndoDrawGroup::~SwUndoDrawGroup()
     delete [] pObjArr;
 }
 
-void SwUndoDrawGroup::Undo( SwUndoIter& )
+void SwUndoDrawGroup::UndoImpl(::sw::UndoRedoContext &)
 {
     bDelFmt = FALSE;
 
@@ -274,7 +272,7 @@ void SwUndoDrawGroup::Undo( SwUndoIter& )
     }
 }
 
-void SwUndoDrawGroup::Redo( SwUndoIter& )
+void SwUndoDrawGroup::RedoImpl(::sw::UndoRedoContext &)
 {
     bDelFmt = TRUE;
 
@@ -388,14 +386,14 @@ SwUndoDrawUnGroup::~SwUndoDrawUnGroup()
     delete [] pObjArr;
 }
 
-void SwUndoDrawUnGroup::Undo( SwUndoIter& rIter )
+void SwUndoDrawUnGroup::UndoImpl(::sw::UndoRedoContext & rContext)
 {
     bDelFmt = TRUE;
 
-    // aus dem Array austragen
-    SwDoc* pDoc = &rIter.GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
     SwSpzFrmFmts& rFlyFmts = *(SwSpzFrmFmts*)pDoc->GetSpzFrmFmts();
 
+    // remove from array
     for( USHORT n = 1; n < nSize; ++n )
     {
         SwUndoGroupObjImpl& rSave = *( pObjArr + n );
@@ -440,7 +438,7 @@ void SwUndoDrawUnGroup::Undo( SwUndoIter& rIter )
     // <--
 }
 
-void SwUndoDrawUnGroup::Redo( SwUndoIter& )
+void SwUndoDrawUnGroup::RedoImpl(::sw::UndoRedoContext &)
 {
     bDelFmt = FALSE;
 
@@ -510,7 +508,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 +528,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 )
@@ -571,10 +571,10 @@ SwUndoDrawDelete::~SwUndoDrawDelete()
     delete pMarkLst;
 }
 
-void SwUndoDrawDelete::Undo( SwUndoIter &rIter )
+void SwUndoDrawDelete::UndoImpl(::sw::UndoRedoContext & rContext)
 {
     bDelFmt = FALSE;
-    SwSpzFrmFmts& rFlyFmts = *rIter.GetDoc().GetSpzFrmFmts();
+    SwSpzFrmFmts & rFlyFmts = *rContext.GetDoc().GetSpzFrmFmts();
     for( USHORT n = 0; n < pMarkLst->GetMarkCount(); ++n )
     {
         SwUndoGroupObjImpl& rSave = *( pObjArr + n );
@@ -597,13 +597,13 @@ 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();
+    SwSpzFrmFmts & rFlyFmts = *rContext.GetDoc().GetSpzFrmFmts();
     for( USHORT n = 0; n < pMarkLst->GetMarkCount(); ++n )
     {
         SwUndoGroupObjImpl& rSave = *( pObjArr + n );
diff --git a/sw/source/core/undo/unfmco.cxx b/sw/source/core/undo/unfmco.cxx
index 6c51b8556ee2..29b694a095db 100644
--- a/sw/source/core/undo/unfmco.cxx
+++ b/sw/source/core/undo/unfmco.cxx
@@ -39,8 +39,6 @@
 #include "rolbck.hxx"
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 //--------------------------------------------------
 
 
@@ -70,37 +68,40 @@ 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 );
+    SwPaM & rPam = AddUndoRedoPaM(rContext);
 
-    Repeat( rUndoIter );    // Collection setzen
+    DoSetFmtColl(rContext.GetDoc(), rPam);
 }
 
+void SwUndoFmtColl::RepeatImpl(::sw::RepeatContext & rContext)
+{
+    DoSetFmtColl(rContext.GetDoc(), rContext.GetRepeatPaM());
+}
 
-void SwUndoFmtColl::Repeat( SwUndoIter& rUndoIter )
+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(
+    USHORT const nPos = rDoc.GetTxtFmtColls()->GetPos(
                                                      (SwTxtFmtColl*)pFmtColl );
-    // ist das Format ueberhaupt noch vorhanden?
+    // does the format still exist?
     if( USHRT_MAX != nPos )
     {
         // --> OD 2008-04-15 #refactorlists#
-        rUndoIter.GetDoc().SetTxtFmtColl( *rUndoIter.pAktPam,
+        rDoc.SetTxtFmtColl(rPaM,
                                           (SwTxtFmtColl*)pFmtColl,
                                           mbReset,
                                           mbResetListAttrs );
diff --git a/sw/source/core/undo/unins.cxx b/sw/source/core/undo/unins.cxx
index 215cc8693f7e..d9f39925045f 100644
--- a/sw/source/core/undo/unins.cxx
+++ b/sw/source/core/undo/unins.cxx
@@ -63,16 +63,6 @@
 using namespace ::com::sun::star;
 
 
-//------------------------------------------------------------------
-
-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
@@ -224,13 +214,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() ))
@@ -287,24 +277,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(
-                IterPt(rUndoIter)->nNode.GetNode().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 )
@@ -360,18 +348,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);
         }
     }
 
@@ -379,12 +367,12 @@ void SwUndoInsert::Redo( SwUndoIter& rUndoIter )
 }
 
 
-void SwUndoInsert::Repeat( SwUndoIter& rUndoIter )
+void SwUndoInsert::RepeatImpl(::sw::RepeatContext & rContext)
 {
     if( !nLen )
         return;
 
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwNodeIndex aNd( rDoc.GetNodes(), nNode );
     SwCntntNode* pCNd = aNd.GetNode().GetCntntNode();;
 
@@ -402,12 +390,14 @@ 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() );
             ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
-            rDoc.InsertString( *rUndoIter.pAktPam,
+            rDoc.InsertString( rContext.GetRepeatPaM(),
                 aTxt.Copy( nCntnt - nLen, nLen ) );
         }
         break;
@@ -418,7 +408,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 );
         }
@@ -438,7 +428,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;
@@ -497,8 +490,9 @@ class SwUndoReplace::Impl
 public:
     Impl(SwPaM const& rPam, ::rtl::OUString const& rIns, bool const bRegExp);
 
-    void Undo( SwUndoIter& );
-    void Redo( SwUndoIter& );
+    virtual void UndoImpl( ::sw::UndoRedoContext & );
+    virtual void RedoImpl( ::sw::UndoRedoContext & );
+
     void SetEnd(SwPaM const& rPam);
 
     ::rtl::OUString const& GetOld() const { return m_sOld; }
@@ -517,15 +511,14 @@ SwUndoReplace::~SwUndoReplace()
 {
 }
 
-void SwUndoReplace::Undo( SwUndoIter& rUndoIter )
+void SwUndoReplace::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    m_pImpl->Undo( rUndoIter );
+    m_pImpl->UndoImpl(rContext);
 }
 
-
-void SwUndoReplace::Redo( SwUndoIter& rUndoIter )
+void SwUndoReplace::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    m_pImpl->Redo( rUndoIter );
+    m_pImpl->RedoImpl(rContext);
 }
 
 SwRewriter
@@ -646,10 +639,10 @@ SwUndoReplace::Impl::Impl(
     m_sOld = pNd->GetTxt().Copy( m_nSttCnt, nECnt - m_nSttCnt );
 }
 
-void SwUndoReplace::Impl::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();
@@ -731,11 +724,10 @@ void SwUndoReplace::Impl::Undo( SwUndoIter& rIter )
     rPam.GetPoint()->nContent = aIdx;
 }
 
-void SwUndoReplace::Impl::Redo( SwUndoIter& rIter )
+void SwUndoReplace::Impl::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rIter.GetDoc();
-
-    SwPaM& rPam = *rIter.pAktPam;
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPaM & rPam(rContext.GetCursorSupplier().CreateNewShellCursor());
     rPam.DeleteMark();
     rPam.GetPoint()->nNode = m_nSttNd;
 
@@ -804,9 +796,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 )
@@ -834,19 +826,19 @@ void SwUndoReRead::SetAndSave( SwUndoIter& rIter )
     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);
 }
 
 
@@ -905,9 +897,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 )
     {
@@ -919,8 +911,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 );
@@ -936,7 +928,7 @@ 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;
@@ -945,9 +937,9 @@ void SwUndoInsertLabel::Undo( SwUndoIter& rIter )
 }
 
 
-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 )
     {
@@ -959,8 +951,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 );
@@ -981,15 +973,15 @@ void SwUndoInsertLabel::Redo( SwUndoIter& rIter )
             if ( pNd )
                 pNd->GetTable().GetFrmFmt()->SetFmtAttr( SvxFmtKeepItem(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;
 
diff --git a/sw/source/core/undo/unmove.cxx b/sw/source/core/undo/unmove.cxx
index 1b155a8e3c7d..b93d33f6c972 100644
--- a/sw/source/core/undo/unmove.cxx
+++ b/sw/source/core/undo/unmove.cxx
@@ -37,8 +37,6 @@
 #include <rolbck.hxx>
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 // MOVE
 
 SwUndoMove::SwUndoMove( const SwPaM& rRange, const SwPosition& rMvPos )
@@ -188,9 +186,9 @@ void SwUndoMove::SetDestRange( const SwNodeIndex& rStt,
 }
 
 
-void SwUndoMove::Undo( SwUndoIter& rUndoIter )
+void SwUndoMove::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rUndoIter.GetDoc();
+    SwDoc *const pDoc = & rContext.GetDoc();
 
     // Block, damit aus diesem gesprungen werden kann
     do {
@@ -277,14 +275,16 @@ void SwUndoMove::Undo( SwUndoIter& rUndoIter )
 
     // 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 );
diff --git a/sw/source/core/undo/unnum.cxx b/sw/source/core/undo/unnum.cxx
index f5947bc702b4..da7d5b8d1c0a 100644
--- a/sw/source/core/undo/unnum.cxx
+++ b/sw/source/core/undo/unnum.cxx
@@ -43,7 +43,6 @@
 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,11 +87,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 );
+    SwDoc & rDoc = rContext.GetDoc();
 
     if( pOldNumRule )
         rDoc.ChgNumRuleFmts( *pOldNumRule );
@@ -132,28 +129,31 @@ void SwUndoInsNum::Undo( SwUndoIter& rUndoIter )
         pHistory->SetTmpEnd( pHistory->Count() );
     }
 
-    if( nSttNode )
-        SetPaM( rUndoIter );
+    if (nSttNode)
+    {
+        AddUndoRedoPaM(rContext);
+    }
 }
 
-
-void SwUndoInsNum::Redo( SwUndoIter& rUndoIter )
+void SwUndoInsNum::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     if( pOldNumRule )
         rDoc.ChgNumRuleFmts( aNumRule );
     else if( pHistory )
     {
-        SetPaM( rUndoIter );
+        SwPaM & rPam( AddUndoRedoPaM(rContext) );
         if( sReplaceRule.Len() )
-            rDoc.ReplaceNumRule( *rUndoIter.pAktPam->GetPoint(),
+        {
+            rDoc.ReplaceNumRule(*rPam.GetPoint(),
                                 sReplaceRule, aNumRule.GetName() );
+        }
         else
         {
             // --> OD 2005-02-25 #i42921# - adapt to changed signature
             // --> OD 2008-03-18 #refactorlists#
-            rDoc.SetNumRule( *rUndoIter.pAktPam, aNumRule, false );
+            rDoc.SetNumRule(rPam, aNumRule, false);
             // <--
         }
     }
@@ -165,20 +165,23 @@ void SwUndoInsNum::SetLRSpaceEndPos()
         nLRSavePos = pHistory->Count();
 }
 
-void SwUndoInsNum::Repeat( SwUndoIter& rUndoIter )
+void SwUndoInsNum::RepeatImpl(::sw::RepeatContext & rContext)
 {
+    SwDoc & rDoc(rContext.GetDoc());
     if( nSttNode )
     {
         if( !sReplaceRule.Len() )
         {
             // --> OD 2005-02-25 #i42921# - adapt to changed signature
             // --> OD 2008-03-18 #refactorlists#
-            rUndoIter.GetDoc().SetNumRule( *rUndoIter.pAktPam, aNumRule, false );
+            rDoc.SetNumRule(rContext.GetRepeatPaM(), aNumRule, false);
             // <--
         }
     }
     else
-        rUndoIter.GetDoc().ChgNumRuleFmts( aNumRule );
+    {
+        rDoc.ChgNumRuleFmts( aNumRule );
+    }
 }
 
 SwHistory* SwUndoInsNum::GetHistory()
@@ -204,17 +207,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 );
+    SwDoc & rDoc = rContext.GetDoc();
 
     pHistory->TmpRollback( &rDoc, 0 );
     pHistory->SetTmpEnd( pHistory->Count() );
@@ -229,21 +229,18 @@ void SwUndoDelNum::Undo( SwUndoIter& rUndoIter )
             pNd->ChkCondColl();
     }
 
-    SetPaM( rUndoIter );
+    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 )
@@ -270,8 +267,7 @@ 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;
 
@@ -288,33 +284,35 @@ void SwUndoMoveNum::Undo( SwUndoIter& rUndoIter )
 //  SetPaM( rUndoIter );
 //  RemoveIdxFromRange( *rUndoIter.pAktPam, 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 );
 
-    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, FALSE);
+    }
 }
 
 /*  */
@@ -328,24 +326,21 @@ SwUndoNumUpDown::SwUndoNumUpDown( const SwPaM& rPam, short nOff )
     //          Up      => -1
 }
 
-
-void SwUndoNumUpDown::Undo( SwUndoIter& rUndoIter )
+void SwUndoNumUpDown::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetPaM( rUndoIter );
-    rUndoIter.GetDoc().NumUpDown( *rUndoIter.pAktPam, 1 != nOffset );
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().NumUpDown(rPam, 1 != nOffset );
 }
 
-
-void SwUndoNumUpDown::Redo( SwUndoIter& rUndoIter )
+void SwUndoNumUpDown::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    SetPaM( rUndoIter );
-    rUndoIter.GetDoc().NumUpDown( *rUndoIter.pAktPam, 1 == nOffset );
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().NumUpDown(rPam, 1 == nOffset);
 }
 
-
-void SwUndoNumUpDown::Repeat( SwUndoIter& rUndoIter )
+void SwUndoNumUpDown::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    rUndoIter.GetDoc().NumUpDown( *rUndoIter.pAktPam, 1 == nOffset );
+    rContext.GetDoc().NumUpDown(rContext.GetRepeatPaM(), 1 == nOffset);
 }
 
 /*  */
@@ -359,9 +354,9 @@ SwUndoNumOrNoNum::SwUndoNumOrNoNum( const SwNodeIndex& rIdx, BOOL bOldNum,
 }
 
 // #115901#, #i40034#
-void SwUndoNumOrNoNum::Undo( SwUndoIter& rUndoIter )
+void SwUndoNumOrNoNum::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwNodeIndex aIdx( rUndoIter.GetDoc().GetNodes(), nIdx );
+    SwNodeIndex aIdx( rContext.GetDoc().GetNodes(), nIdx );
     SwTxtNode * pTxtNd = aIdx.GetNode().GetTxtNode();
 
     if (NULL != pTxtNd)
@@ -371,9 +366,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)
@@ -383,15 +378,17 @@ void SwUndoNumOrNoNum::Redo( SwUndoIter& rUndoIter )
 }
 
 // #115901#
-void SwUndoNumOrNoNum::Repeat( SwUndoIter& rUndoIter )
+void SwUndoNumOrNoNum::RepeatImpl(::sw::RepeatContext & rContext)
 {
-
+    SwDoc & rDoc = rContext.GetDoc();
     if (mbOldNum && ! mbNewNum)
-        rUndoIter.GetDoc().NumOrNoNum( rUndoIter.pAktPam->GetPoint()->nNode,
-                                       FALSE);
+    {
+        rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, FALSE);
+    }
     else if ( ! mbOldNum && mbNewNum )
-        rUndoIter.GetDoc().NumOrNoNum( rUndoIter.pAktPam->GetPoint()->nNode,
-                                       TRUE);
+    {
+        rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, TRUE);
+    }
 }
 
 /*  */
@@ -425,34 +422,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 2a92097221b6..1e8474d79f8e 100644
--- a/sw/source/core/undo/unoutl.cxx
+++ b/sw/source/core/undo/unoutl.cxx
@@ -28,8 +28,6 @@
 // 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"
@@ -38,33 +36,26 @@
 #include "undobj.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);
 }
 
-
-
diff --git a/sw/source/core/undo/unovwr.cxx b/sw/source/core/undo/unovwr.cxx
index b9a3d8a709b6..0c83b2aeba48 100644
--- a/sw/source/core/undo/unovwr.cxx
+++ b/sw/source/core/undo/unovwr.cxx
@@ -37,6 +37,7 @@
 
 #include <doc.hxx>
 #include <IDocumentUndoRedo.hxx>
+#include <IShellCursorSupplier.hxx>
 #include <swundo.hxx>           // fuer die UndoIds
 #include <pam.hxx>
 #include <ndtxt.hxx>
@@ -52,19 +53,9 @@ 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
 
 
@@ -203,10 +194,11 @@ BOOL SwUndoOverwrite::CanGrouping( SwDoc* pDoc, SwPosition& rPos,
 
 
 
-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();
@@ -269,13 +261,13 @@ void SwUndoOverwrite::Undo( SwUndoIter& rUndoIter )
         SetSaveData( *pDoc, *pRedlSaveData );
 }
 
-void SwUndoOverwrite::Repeat( SwUndoIter& rUndoIter )
+void SwUndoOverwrite::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwPaM* pAktPam = rUndoIter.pAktPam;
+    SwPaM *const pAktPam = & rContext.GetRepeatPaM();
     if( !aInsStr.Len() || pAktPam->HasMark() )
         return;
 
-    SwDoc& rDoc = *pAktPam->GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
 
     {
         ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
@@ -285,12 +277,11 @@ void SwUndoOverwrite::Repeat( SwUndoIter& rUndoIter )
         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();
@@ -382,9 +373,9 @@ SwUndoTransliterate::~SwUndoTransliterate()
         delete aChanges[i];
 }
 
-void SwUndoTransliterate::Undo( SwUndoIter& rUndoIter )
+void SwUndoTransliterate::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc& rDoc = rUndoIter.GetDoc();
+    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
@@ -393,20 +384,22 @@ void SwUndoTransliterate::Undo( SwUndoIter& rUndoIter )
     for (sal_Int32 i = aChanges.size() - 1; i >= 0;  --i)
         aChanges[i]->SetChangeAtNode( rDoc );
 
-    SetPaM( rUndoIter, TRUE );
+    AddUndoRedoPaM(rContext, true);
 }
 
-void SwUndoTransliterate::Redo( SwUndoIter& rUndoIter )
+void SwUndoTransliterate::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    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 );
 }
diff --git a/sw/source/core/undo/unredln.cxx b/sw/source/core/undo/unredln.cxx
index 392ffbd854b8..ee51af629163 100644
--- a/sw/source/core/undo/unredln.cxx
+++ b/sw/source/core/undo/unredln.cxx
@@ -46,9 +46,6 @@ extern void lcl_GetJoinFlags( SwPaM& rPam, BOOL& rJoinTxt, 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 ),
@@ -94,13 +91,12 @@ SwUndoRedline::~SwUndoRedline()
     delete pRedlSaveData;
 }
 
-void SwUndoRedline::Undo( SwUndoIter& rIter )
+void SwUndoRedline::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwDoc* pDoc = &rIter.GetDoc();
-    SetPaM( *rIter.pAktPam );
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
 
-// RedlineMode setzen?
-    _Undo( rIter );
+    UndoRedlineImpl(*pDoc, rPam);
 
     if( pRedlSaveData )
     {
@@ -114,47 +110,47 @@ 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,
+        FillSaveData(rPam, *pRedlSaveData, 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 ),
@@ -178,15 +174,17 @@ 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), FALSE );
+    }
 }
 
 BOOL SwUndoRedlineDelete::CanGrouping( const SwUndoRedlineDelete& rNext )
@@ -238,14 +236,13 @@ 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();
@@ -266,7 +263,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;
@@ -274,9 +271,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();
@@ -289,13 +286,11 @@ 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();
@@ -304,7 +299,7 @@ void SwUndoRedlineSort::_Redo( SwUndoIter& rIter )
     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 );
@@ -326,9 +321,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 )
@@ -343,21 +338,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 )
@@ -365,17 +360,17 @@ 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 )
     : SwUndo( UNDO_COMPAREDOC ), SwUndRng( rRg ), pRedlData( 0 ),
@@ -416,12 +411,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 )
     {
@@ -481,20 +474,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();
+    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 );
@@ -519,10 +509,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 );
@@ -535,7 +525,6 @@ void SwUndoCompDoc::Redo( SwUndoIter& rIter )
 //      pDoc->SetRedlineMode_intern( eOld );
     }
 
-    SetPaM( rIter, TRUE );
+    SetPaM(*pPam, true);
 }
 
-
diff --git a/sw/source/core/undo/unsect.cxx b/sw/source/core/undo/unsect.cxx
index 98d0e41d4616..bcda05a60344 100644
--- a/sw/source/core/undo/unsect.cxx
+++ b/sw/source/core/undo/unsect.cxx
@@ -48,8 +48,6 @@
 #include <calc.hxx>
 
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
-
 SfxItemSet* lcl_GetAttrSet( const SwSection& rSect )
 {
     // Attribute des Formate sichern (Spalten, Farbe, ... )
@@ -122,9 +120,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 );
 
@@ -167,25 +165,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())
@@ -224,22 +220,21 @@ 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 )
 {
     SwNodeIndex aIdx( rDoc.GetNodes(), nNode );
@@ -300,9 +295,11 @@ private:
 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)
@@ -330,9 +327,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())
     {
@@ -383,13 +380,13 @@ 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();
-    ASSERT( pNd, "wo ist mein SectionNode?" );
+    OSL_ENSURE(pNd, "SwUndoDelSection::RedoImpl(): no SectionNode?");
     // einfach das Format loeschen, der Rest erfolgt automatisch
     rDoc.DelSectionFmt( pNd->GetSection().GetFmt() );
 }
@@ -409,9 +406,11 @@ private:
 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 *
@@ -436,9 +435,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();
     ASSERT( pSectNd, "wo ist mein SectionNode?" );
@@ -492,8 +491,8 @@ void SwUndoUpdateSection::Undo( SwUndoIter& rUndoIter )
     }
 }
 
-void SwUndoUpdateSection::Redo( SwUndoIter& rUndoIter )
+void SwUndoUpdateSection::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    Undo( rUndoIter );
+    UndoImpl(rContext);
 }
 
diff --git a/sw/source/core/undo/unsort.cxx b/sw/source/core/undo/unsort.cxx
index 0a32f8e3e084..4175476877f4 100644
--- a/sw/source/core/undo/unsort.cxx
+++ b/sw/source/core/undo/unsort.cxx
@@ -39,7 +39,6 @@
 #include <redline.hxx>
 #include <node2lay.hxx>
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
 
 /*--------------------------------------------------------------------
     Beschreibung:  Undo fuers Sorting
@@ -88,16 +87,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();
 
@@ -135,8 +136,7 @@ void SwUndoSort::Undo( SwUndoIter& rIter)
     else
     {
         // Undo Text
-        SwPaM & rPam( *rIter.pAktPam );
-        SetPaM(rPam);
+        SwPaM & rPam( AddUndoRedoPaM(rContext) );
         RemoveIdxFromRange(rPam, true);
 
         // fuer die sorted Positions einen Index anlegen.
@@ -164,13 +164,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)
     {
@@ -203,7 +203,9 @@ 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
@@ -215,7 +217,7 @@ void SwUndoSort::Redo( SwUndoIter& rIter)
     else
     {
         // Redo for Text
-        SwPaM & rPam( *rIter.pAktPam );
+        SwPaM & rPam( AddUndoRedoPaM(rContext) );
         SetPaM(rPam);
         RemoveIdxFromRange(rPam, true);
 
@@ -238,19 +240,21 @@ 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 ) )
diff --git a/sw/source/core/undo/unspnd.cxx b/sw/source/core/undo/unspnd.cxx
index dd76f81bc219..0409575d0f3d 100644
--- a/sw/source/core/undo/unspnd.cxx
+++ b/sw/source/core/undo/unspnd.cxx
@@ -28,7 +28,6 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sw.hxx"
 
-
 #include "doc.hxx"
 #include "pam.hxx"
 #include "swtable.hxx"
@@ -41,9 +40,7 @@
 #include "rolbck.hxx"
 #include "redline.hxx"
 #include "docary.hxx"
-
-
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
+#include <IShellCursorSupplier.hxx>
 
 
 //------------------------------------------------------------------
@@ -75,21 +72,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 )
     {
@@ -163,20 +155,13 @@ void SwUndoSplitNode::Undo( SwUndoIter& rUndoIter )
     rPam.GetPoint()->nContent.Assign( rPam.GetCntntNode(), nCntnt );
 }
 
-
-void SwUndoSplitNode::Repeat( SwUndoIter& rUndoIter )
+void SwUndoSplitNode::RedoImpl(::sw::UndoRedoContext & rContext)
 {
-    rUndoIter.GetDoc().SplitNode( *rUndoIter.pAktPam->GetPoint(), bChkTblStt );
-}
-
-
-void SwUndoSplitNode::Redo( SwUndoIter& rUndoIter )
-{
-    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 );
 
@@ -207,7 +192,11 @@ 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 );
 }
 
diff --git a/sw/source/core/undo/untbl.cxx b/sw/source/core/undo/untbl.cxx
index b96fe8d05440..1f274a7e6c9e 100644
--- a/sw/source/core/undo/untbl.cxx
+++ b/sw/source/core/undo/untbl.cxx
@@ -81,7 +81,6 @@
     #define _DEBUG_REDLINE( pDoc ) lcl_DebugRedline( pDoc );
 #endif
 
-inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
 extern void ClearFEShellTabCols();
 
 typedef SfxItemSet* SfxItemSetPtr;
@@ -276,9 +275,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();
@@ -314,19 +313,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 );
@@ -365,11 +363,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
@@ -474,10 +472,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 );
@@ -654,11 +652,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 );
@@ -692,19 +689,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 );
     }
 }
 
@@ -746,9 +743,9 @@ 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;
     if( nSttCntnt )
@@ -784,15 +781,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(pPos->nNode.GetNode().GetCntntNode(), 0);
-        if( rUndoIter.pAktPam->Move( fnMoveBackward, fnGoCntnt))
+        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 );
@@ -801,7 +799,7 @@ void SwUndoTxtToTbl::Undo( SwUndoIter& rUndoIter )
         }
     }
 
-    // am Ende wieder zusammenfuegen ?
+    // join again at end?
     if( bSplitEnd )
     {
         SwNodeIndex& rIdx = pPos->nNode;
@@ -809,8 +807,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() );
@@ -820,30 +818,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 )
@@ -875,20 +874,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();
     ASSERT( 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();
     ASSERT( pTNd, "keinen Tabellen-Node gefunden" );
@@ -896,17 +893,18 @@ 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 )
@@ -1425,7 +1423,7 @@ void _SaveBox::CreateNew( SwTable& rTbl, SwTableLine& rParent, _SaveTable& rSTbl
 }
 
 
-/*  */
+//////////////////////////////////////////////////////////////////////////
 
 // UndoObject fuer Attribut Aenderung an der Tabelle
 
@@ -1438,17 +1436,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();
     ASSERT( pTblNd, "kein TabellenNode" );
 
@@ -1464,14 +1459,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
 
@@ -1493,7 +1487,6 @@ SwUndoTblAutoFmt::SwUndoTblAutoFmt( const SwTableNode& rTblNd,
     }
 }
 
-
 SwUndoTblAutoFmt::~SwUndoTblAutoFmt()
 {
     delete pUndos;
@@ -1509,9 +1502,10 @@ void SwUndoTblAutoFmt::SaveBoxCntnt( const SwTableBox& rBox )
 }
 
 
-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();
     ASSERT( pTblNd, "kein TabellenNode" );
 
@@ -1523,27 +1517,28 @@ void SwUndoTblAutoFmt::UndoRedo( BOOL bUndo, SwUndoIter& rUndoIter )
 
     if( pUndos && bUndo )
         for( USHORT n = pUndos->Count(); n; )
-            pUndos->GetObject( --n )->Undo( rUndoIter );
+        {
+            static_cast<SwUndoTblNumFmt*>(pUndos->GetObject( --n ))
+                ->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,
@@ -1767,9 +1762,9 @@ 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 *const pTblNd = aIdx.GetNode().GetTableNode();
@@ -1886,9 +1881,9 @@ 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();
     ASSERT( pTblNd, "kein TabellenNode" );
@@ -2000,8 +1995,7 @@ void SwUndoTblNdsChg::Redo( SwUndoIter& rUndoIter )
 }
 
 
-/*  */
-
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoTblMerge::SwUndoTblMerge( const SwPaM& rTblSel )
     : SwUndo( UNDO_TABLE_MERGE ), SwUndRng( rTblSel ), pHistory( 0 )
@@ -2013,7 +2007,6 @@ SwUndoTblMerge::SwUndoTblMerge( const SwPaM& rTblSel )
     nTblNode = pTblNd->GetIndex();
 }
 
-
 SwUndoTblMerge::~SwUndoTblMerge()
 {
     delete pSaveTbl;
@@ -2021,10 +2014,9 @@ 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 *const pTblNd = aIdx.GetNode().GetTableNode();
@@ -2096,7 +2088,7 @@ CHECKTABLE(pTblNd->GetTable())
                     pTxtNd = rDoc.GetNodes()[ pUndo->GetDestSttNode() ]->GetTxtNode();
                     nDelPos = pUndo->GetDestSttCntnt() - 1;
                 }
-                pUndo->Undo( rUndoIter );
+                pUndo->UndoImpl(rContext);
                 if( pUndo->IsMoveRange() )
                 {
                     // den ueberfluessigen Node loeschen
@@ -2169,7 +2161,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 );
@@ -2180,14 +2172,11 @@ 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 )
@@ -2205,7 +2194,6 @@ void SwUndoTblMerge::MoveBoxCntnt( SwDoc* pDoc, SwNodeRange& rRg, SwNodeIndex& r
     pMoves->Insert( pUndo, pMoves->Count() );
 }
 
-
 void SwUndoTblMerge::SetSelBoxes( const SwSelBoxes& rBoxes )
 {
     // die Selektion merken
@@ -2236,8 +2224,8 @@ void SwUndoTblMerge::SaveCollection( const SwTableBox& rBox )
         pHistory->CopyFmtAttr( *pCNd->GetpSwAttrSet(), aIdx.GetIndex() );
 }
 
-/*  */
 
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoTblNumFmt::SwUndoTblNumFmt( const SwTableBox& rBox,
                                     const SfxItemSet* pNewSet )
@@ -2300,18 +2288,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)
 {
     ASSERT( pBoxSet, "Where's the stored item set?" )
 
-    SwDoc& rDoc = rIter.GetDoc();
+    SwDoc & rDoc = rContext.GetDoc();
     SwStartNode* pSttNd = rDoc.GetNodes()[ nNode ]->
                             FindSttNodeByType( SwTableBoxStartNode );
     ASSERT( pSttNd, "ohne StartNode kein TabellenBox" );
@@ -2357,7 +2344,7 @@ void SwUndoTblNumFmt::Undo( SwUndoIter& rIter )
         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 );
@@ -2400,15 +2387,15 @@ 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;
 
@@ -2500,7 +2487,8 @@ void SwUndoTblNumFmt::SetBox( const SwTableBox& rBox )
     nNode = rBox.GetSttIdx();
 }
 
-/*  */
+
+//////////////////////////////////////////////////////////////////////////
 
 _UndoTblCpyTbl_Entry::_UndoTblCpyTbl_Entry( const SwTableBox& rBox )
     : nBoxIdx( rBox.GetSttIdx() ), nOffset( 0 ),
@@ -2527,9 +2515,9 @@ 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;
@@ -2604,8 +2592,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 )
             {
@@ -2628,8 +2617,9 @@ void SwUndoTblCpyTbl::Undo( SwUndoIter& rIter )
             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;
@@ -2665,17 +2655,21 @@ 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 )
@@ -2696,7 +2690,7 @@ void SwUndoTblCpyTbl::Redo( SwUndoIter& rIter )
         SwUndo* pUndo = IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) ? 0 : new SwUndoDelete( aPam, 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
@@ -2704,8 +2698,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 );
@@ -2713,6 +2711,7 @@ void SwUndoTblCpyTbl::Redo( SwUndoIter& rIter )
                 }
             }
             delete pEntry->pUndo;
+            pEntry->pUndo = 0;
         }
         pEntry->pUndo = pUndo;
         // b62341295: Redline for copying tables - End.
@@ -2904,7 +2903,8 @@ BOOL SwUndoTblCpyTbl::IsEmpty() const
     return !pInsRowUndo && !pArr->Count();
 }
 
-/*  */
+
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoCpyTbl::SwUndoCpyTbl()
     : SwUndo( UNDO_CPYTBL ), pDel( 0 ), nTblNode( 0 )
@@ -2916,9 +2916,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
@@ -2941,14 +2941,14 @@ void SwUndoCpyTbl::Undo( SwUndoIter& rIter )
     pDel = new SwUndoDelete( aPam, 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 )
@@ -2975,10 +2975,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;
@@ -3040,10 +3040,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;
@@ -3052,10 +3052,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();
@@ -3070,7 +3070,8 @@ void SwUndoSplitTbl::SaveFormula( SwHistory& rHistory )
     pHistory->Move( 0, &rHistory );
 }
 
-/*  */
+
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoMergeTbl::SwUndoMergeTbl( const SwTableNode& rTblNd,
                                 const SwTableNode& rDelTblNd,
@@ -3097,10 +3098,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;
@@ -3164,10 +3165,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;
@@ -3181,10 +3182,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();
@@ -3197,8 +3198,8 @@ void SwUndoMergeTbl::SaveFormula( SwHistory& rHistory )
     pHistory->Move( 0, &rHistory );
 }
 
-/*  */
 
+//////////////////////////////////////////////////////////////////////////
 
 void InsertSort( SvUShorts& rArr, USHORT nIdx, USHORT* pInsPos )
 {
diff --git a/sw/source/core/undo/untblk.cxx b/sw/source/core/undo/untblk.cxx
index b984d645dbf7..a32ef2c8b443 100644
--- a/sw/source/core/undo/untblk.cxx
+++ b/sw/source/core/undo/untblk.cxx
@@ -171,11 +171,10 @@ SwUndoInserts::~SwUndoInserts()
 }
 
 
-void SwUndoInserts::Undo( SwUndoIter& rUndoIter )
+void SwUndoInserts::UndoImpl(::sw::UndoRedoContext & rContext)
 {
-    SwPaM * pPam = rUndoIter.pAktPam;
-    SwDoc* pDoc = pPam->GetDoc();
-    SetPaM( rUndoIter );
+    SwDoc *const pDoc = & rContext.GetDoc();
+    SwPaM *const pPam = & AddUndoRedoPaM(rContext);
 
     if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
         pDoc->DeleteRedline( *pPam, true, USHRT_MAX );
@@ -198,7 +197,7 @@ void SwUndoInserts::Undo( SwUndoIter& rUndoIter )
         }
 
         RemoveIdxFromRange( *pPam, FALSE );
-        SetPaM( rUndoIter );
+        SetPaM(*pPam);
 
         // sind Fussnoten oder CntntFlyFrames im Text ??
         nSetPos = pHistory->Count();
@@ -220,7 +219,9 @@ void SwUndoInserts::Undo( SwUndoIter& rUndoIter )
     {
         ULONG nTmp = pPam->GetPoint()->nNode.GetIndex();
         for( USHORT n = pFlyUndos->Count(); n; )
-            (*pFlyUndos)[ --n ]->Undo( rUndoIter );
+        {
+            (*pFlyUndos)[ --n ]->UndoImpl(rContext);
+        }
         nNdDiff += nTmp - pPam->GetPoint()->nNode.GetIndex();
     }
 
@@ -266,15 +267,12 @@ void SwUndoInserts::Undo( SwUndoIter& rUndoIter )
             pHistory->TmpRollback( pDoc, 0, false );
         }
     }
-
-    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;
@@ -320,7 +318,9 @@ void SwUndoInserts::Redo( SwUndoIter& rUndoIter )
 
     if( pFlyUndos )
         for( USHORT n = pFlyUndos->Count(); n; )
-            (*pFlyUndos)[ --n ]->Redo( rUndoIter );
+        {
+            (*pFlyUndos)[ --n ]->RedoImpl(rContext);
+        }
 
     pHistory->Rollback( pDoc, nSetPos );
 
@@ -336,16 +336,16 @@ void SwUndoInserts::Redo( SwUndoIter& rUndoIter )
         pDoc->SplitRedline( *pPam );
 }
 
-void SwUndoInserts::Repeat( SwUndoIter& rUndoIter )
+void SwUndoInserts::RepeatImpl(::sw::RepeatContext & rContext)
 {
-    SwPaM aPam( *rUndoIter.pAktPam->GetPoint() );
+    SwPaM aPam( rContext.GetDoc().GetNodes().GetEndOfContent() );
     SetPaM( aPam );
-    aPam.GetDoc()->CopyRange( aPam, *rUndoIter.pAktPam->GetPoint(), false );
+    SwPaM & rRepeatPaM( rContext.GetRepeatPaM() );
+    aPam.GetDoc()->CopyRange( aPam, *rRepeatPaM.GetPoint(), false );
 }
 
 
-/*  */
-
+//////////////////////////////////////////////////////////////////////////
 
 SwUndoInsDoc::SwUndoInsDoc( const SwPaM& rPam )
     : SwUndoInserts( UNDO_INSDOKUMENT, rPam )