1 files changed, 112 insertions, 88 deletions

diff --git a/sw/source/core/doc/docedt.cxx b/sw/source/core/doc/docedt.cxx
index 61098176ce52..6e5c259a9d04 100644
--- a/sw/source/core/doc/docedt.cxx
+++ b/sw/source/core/doc/docedt.cxx
@@ -48,6 +48,7 @@
 #include <cntfrm.hxx>           // fuers Spell
 #include <crsrsh.hxx>
 #include <doc.hxx>
+#include <UndoManager.hxx>
 #include <docsh.hxx>
 #include <docary.hxx>
 #include <doctxm.hxx>       // beim Move: Verzeichnisse korrigieren
@@ -63,7 +64,12 @@
 #include <swtable.hxx>
 #include <swundo.hxx>       // fuer die UndoIds
 #include <txtfrm.hxx>
-#include <undobj.hxx>
+#include <hints.hxx>
+#include <UndoSplitMove.hxx>
+#include <UndoRedline.hxx>
+#include <UndoOverwrite.hxx>
+#include <UndoInsert.hxx>
+#include <UndoDelete.hxx>
 #include <breakit.hxx>
 #include <hhcwrp.hxx>
 #include <breakit.hxx>
@@ -773,8 +779,10 @@ bool SwDoc::Overwrite( const SwPaM &rRg, const String &rStr )
     if(!pNode)
         return sal_False;
 
-    if( DoesUndo() )
-        ClearRedo();
+    if (GetIDocumentUndoRedo().DoesUndo())
+    {
+        GetIDocumentUndoRedo().ClearRedo(); // AppendUndo not always called
+    }
 
     sal_uInt16 nOldAttrCnt = pNode->GetpSwpHints()
                                 ? pNode->GetpSwpHints()->Count() : 0;
@@ -782,8 +790,6 @@ bool SwDoc::Overwrite( const SwPaM &rRg, const String &rStr )
     SwIndex& rIdx = rPt.nContent;
     xub_StrLen nStart = 0;
 
-    sal_uInt16 nUndoSize = pUndos->Count();
-    SwUndo * pUndo;
     sal_Unicode c;
     String aStr;
 
@@ -799,16 +805,24 @@ bool SwDoc::Overwrite( const SwPaM &rRg, const String &rStr )
             lcl_SkipAttr( pNode, rIdx, nStart );
         }
         c = rStr.GetChar( nCnt );
-        if( DoesUndo() )
+        if (GetIDocumentUndoRedo().DoesUndo())
         {
-            if( DoesGroupUndo() && nUndoSize &&
-                UNDO_OVERWRITE == ( pUndo = (*pUndos)[ nUndoSize-1 ])->GetId() &&
-                ((SwUndoOverwrite*)pUndo)->CanGrouping( this, rPt, c ))
-                ;// wenn CanGrouping() sal_True returnt, ist schon alles erledigt
-            else
+            bool bMerged(false);
+            if (GetIDocumentUndoRedo().DoesGroupUndo())
+            {
+                SwUndo *const pUndo = GetUndoManager().GetLastUndo();
+                SwUndoOverwrite *const pUndoOW(
+                    dynamic_cast<SwUndoOverwrite *>(pUndo) );
+                if (pUndoOW)
+                {
+                    // if CanGrouping() returns true it's already merged
+                    bMerged = pUndoOW->CanGrouping( this, rPt, c );
+                }
+            }
+            if (!bMerged)
             {
-                AppendUndo( new SwUndoOverwrite( this, rPt, c ));
-                nUndoSize = pUndos->Count();
+                SwUndo *const pUndoOW( new SwUndoOverwrite(this, rPt, c) );
+                GetIDocumentUndoRedo().AppendUndo(pUndoOW);
             }
         }
         else
@@ -841,7 +855,8 @@ bool SwDoc::Overwrite( const SwPaM &rRg, const String &rStr )
         }
     }
 
-    if( !DoesUndo() && !IsIgnoreRedline() && GetRedlineTbl().Count() )
+    if (!GetIDocumentUndoRedo().DoesUndo() &&
+        !IsIgnoreRedline() && GetRedlineTbl().Count())
     {
         SwPaM aPam( rPt.nNode, nStart, rPt.nNode, rPt.nContent.GetIndex() );
         DeleteRedline( aPam, true, USHRT_MAX );
@@ -909,15 +924,13 @@ bool SwDoc::MoveRange( SwPaM& rPaM, SwPosition& rPos, SwMoveFlags eMvFlags )
         //          in a particular order, and presence of bookmarks
         //          will change this order. Hence, we delete bookmarks
         //          here without undo.
-        sal_Bool bDoesUndo = DoesUndo();
-        DoUndo( sal_False );
+        ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
         _DelBookmarks(
             pStt->nNode,
             pEnd->nNode,
             NULL,
             &pStt->nContent,
             &pEnd->nContent);
-        DoUndo( bDoesUndo );
     }
 
 
@@ -926,9 +939,9 @@ bool SwDoc::MoveRange( SwPaM& rPaM, SwPosition& rPos, SwMoveFlags eMvFlags )
 
     // falls Undo eingeschaltet, erzeuge das UndoMove-Objekt
     SwUndoMove * pUndoMove = 0;
-    if( DoesUndo() )
+    if (GetIDocumentUndoRedo().DoesUndo())
     {
-        ClearRedo();
+        GetIDocumentUndoRedo().ClearRedo();
         pUndoMove = new SwUndoMove( rPaM, rPos );
         pUndoMove->SetMoveRedlines( eMvFlags == DOC_MOVEREDLINES );
     }
@@ -1025,7 +1038,7 @@ bool SwDoc::MoveRange( SwPaM& rPaM, SwPosition& rPos, SwMoveFlags eMvFlags )
 
     rPaM.SetMark();         // um den neuen Bereich eine Sel. aufspannen
     pTNd = aSavePam.GetNode()->GetTxtNode();
-    if( DoesUndo() )
+    if (GetIDocumentUndoRedo().DoesUndo())
     {
         // korrigiere erstmal den Content vom SavePam
         if( bNullCntnt )
@@ -1069,7 +1082,7 @@ bool SwDoc::MoveRange( SwPaM& rPaM, SwPosition& rPos, SwMoveFlags eMvFlags )
         // zwischen SPoint und GetMark steht jetzt der neu eingefuegte Bereich
         pUndoMove->SetDestRange( aSavePam, *rPaM.GetPoint(),
                                     bJoin, bCorrSavePam );
-        AppendUndo( pUndoMove );
+        GetIDocumentUndoRedo().AppendUndo( pUndoMove );
     }
     else
     {
@@ -1152,11 +1165,15 @@ bool SwDoc::MoveNodeRange( SwNodeRange& rRange, SwNodeIndex& rPos,
     SwFtnIdxs aTmpFntIdx;
 
     SwUndoMove* pUndo = 0;
-    if( (DOC_CREATEUNDOOBJ & eMvFlags ) && DoesUndo() )
+    if ((DOC_CREATEUNDOOBJ & eMvFlags ) && GetIDocumentUndoRedo().DoesUndo())
+    {
         pUndo = new SwUndoMove( this, rRange, rPos );
+    }
     else
+    {
         bUpdateFtn = lcl_SaveFtn( rRange.aStart, rRange.aEnd, rPos,
                                     GetFtnIdxs(), aTmpFntIdx );
+    }
 
     _SaveRedlines aSaveRedl( 0, 4 );
     SvPtrarr aSavRedlInsPosArr( 0, 4 );
@@ -1246,9 +1263,8 @@ bool SwDoc::MoveNodeRange( SwNodeRange& rRange, SwNodeIndex& rPos,
 
     if( pUndo )
     {
-        ClearRedo();
         pUndo->SetDestRange( aIdx, rPos, *pSaveInsPos );
-        AppendUndo( pUndo );
+        GetIDocumentUndoRedo().AppendUndo(pUndo);
     }
 
     if( pSaveInsPos )
@@ -1359,8 +1375,7 @@ void lcl_JoinText( SwPaM& rPam, sal_Bool bJoinPrev )
                 // falls PageBreaks geloescht / gesetzt werden, darf das
                 // nicht in die Undo-History aufgenommen werden !!
                 // (das loeschen vom Node geht auch am Undo vorbei !!!)
-                sal_Bool bDoUndo = pDoc->DoesUndo();
-                pDoc->DoUndo( sal_False );
+                ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
 
                 /* PageBreaks, PageDesc, ColumnBreaks */
                 // Sollte an der Logik zum Kopieren der PageBreak's ...
@@ -1412,8 +1427,6 @@ void lcl_JoinText( SwPaM& rPam, sal_Bool bJoinPrev )
                 if( aBkmkArr.Count() )
                     ::_RestoreCntntIdx( pDoc, aBkmkArr, aIdx.GetIndex() );
 
-                pDoc->DoUndo( bDoUndo );
-
                 // falls der uebergebene PaM nicht im Crsr-Ring steht,
                 // gesondert behandeln (z.B. Aufruf aus dem Auto-Format)
                 if( pOldTxtNd == rPam.GetBound( sal_True ).nContent.GetIdxReg() )
@@ -1553,21 +1566,19 @@ bool SwDoc::DeleteAndJoinWithRedlineImpl( SwPaM & rPam, const bool )
     ASSERT( IsRedlineOn(), "DeleteAndJoinWithRedline: redline off" );
 
     {
-        sal_uInt16 nUndoSize = 0;
         SwUndoRedlineDelete* pUndo = 0;
         RedlineMode_t eOld = GetRedlineMode();
         checkRedlining(eOld);
-        if( DoesUndo() )
+        if (GetIDocumentUndoRedo().DoesUndo())
         {
-            ClearRedo();
 
     //JP 06.01.98: MUSS noch optimiert werden!!!
     SetRedlineMode(
            (RedlineMode_t)(nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE ));
 
-            nUndoSize = pUndos->Count();
-            StartUndo(UNDO_EMPTY, NULL);
-            AppendUndo( pUndo = new SwUndoRedlineDelete( rPam, UNDO_DELETE ));
+            GetIDocumentUndoRedo().StartUndo(UNDO_EMPTY, NULL);
+            pUndo = new SwUndoRedlineDelete( rPam, UNDO_DELETE );
+            GetIDocumentUndoRedo().AppendUndo(pUndo);
         }
         if( *rPam.GetPoint() != *rPam.GetMark() )
             AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_DELETE, rPam ), true);
@@ -1575,18 +1586,29 @@ bool SwDoc::DeleteAndJoinWithRedlineImpl( SwPaM & rPam, const bool )
 
         if( pUndo )
         {
-            EndUndo(UNDO_EMPTY, NULL);
-            SwUndo* pPrevUndo;
-            if( nUndoSize && DoesGroupUndo() &&
-                nUndoSize + 1 == pUndos->Count() &&
-                UNDO_REDLINE == ( pPrevUndo = (*pUndos)[ nUndoSize-1 ])->GetId() &&
-                UNDO_DELETE == ((SwUndoRedline*)pPrevUndo)->GetUserId() &&
-                ((SwUndoRedlineDelete*)pPrevUndo)->CanGrouping( *pUndo ))
+            GetIDocumentUndoRedo().EndUndo(UNDO_EMPTY, NULL);
+            // ??? why the hell is the AppendUndo not below the
+            // CanGrouping, so this hideous cleanup wouldn't be necessary?
+            // bah, this is redlining, probably changing this would break it...
+            if (GetIDocumentUndoRedo().DoesGroupUndo())
             {
-                DoUndo( sal_False );
-                pUndos->DeleteAndDestroy( nUndoSize, 1 );
-                --nUndoPos, --nUndoCnt;
-                DoUndo( sal_True );
+                SwUndo *const pLastUndo( GetUndoManager().GetLastUndo() );
+                SwUndoRedlineDelete *const pUndoRedlineDel(
+                        dynamic_cast<SwUndoRedlineDelete*>(pLastUndo) );
+                if (pUndoRedlineDel)
+                {
+                    bool const bMerged = pUndoRedlineDel->CanGrouping(*pUndo);
+                    if (bMerged)
+                    {
+                        ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
+                        SwUndo const*const pDeleted =
+                            GetUndoManager().RemoveLastUndo();
+                        OSL_ENSURE(pDeleted == pUndo,
+                            "DeleteAndJoinWithRedlineImpl: "
+                            "undo removed is not undo inserted?");
+                        delete pDeleted;
+                    }
+                }
             }
 //JP 06.01.98: MUSS noch optimiert werden!!!
 SetRedlineMode( eOld );
@@ -1683,17 +1705,25 @@ bool SwDoc::DeleteRangeImplImpl(SwPaM & rPam)
     }
 
 
-    if( DoesUndo() )
+    if (GetIDocumentUndoRedo().DoesUndo())
     {
-        ClearRedo();
-        sal_uInt16 nUndoSize = pUndos->Count();
-        SwUndo * pUndo;
-        if( DoesGroupUndo() && nUndoSize-- &&
-            UNDO_DELETE == ( pUndo = (*pUndos)[ nUndoSize ])->GetId() &&
-            ((SwUndoDelete*)pUndo)->CanGrouping( this, rPam ))
-            ;// wenn CanGrouping() sal_True returnt, ist schon alles erledigt
-        else
-            AppendUndo( new SwUndoDelete( rPam ) );
+        GetIDocumentUndoRedo().ClearRedo();
+        bool bMerged(false);
+        if (GetIDocumentUndoRedo().DoesGroupUndo())
+        {
+            SwUndo *const pLastUndo( GetUndoManager().GetLastUndo() );
+            SwUndoDelete *const pUndoDelete(
+                    dynamic_cast<SwUndoDelete *>(pLastUndo) );
+            if (pUndoDelete)
+            {
+                bMerged = pUndoDelete->CanGrouping( this, rPam );
+                // if CanGrouping() returns true it's already merged
+            }
+        }
+        if (!bMerged)
+        {
+            GetIDocumentUndoRedo().AppendUndo( new SwUndoDelete( rPam ) );
+        }
 
         SetModified();
 
@@ -2316,9 +2346,9 @@ bool SwDoc::ReplaceRangeImpl( SwPaM& rPam, const String& rStr,
         {
             RedlineMode_t eOld = GetRedlineMode();
             checkRedlining(eOld);
-            if( DoesUndo() )
+            if (GetIDocumentUndoRedo().DoesUndo())
             {
-                StartUndo(UNDO_EMPTY, NULL);
+                GetIDocumentUndoRedo().StartUndo(UNDO_EMPTY, NULL);
 
                 // Bug 68584 - if any Redline will change (split!) the node
                 const ::sw::mark::IMark* pBkmk = getIDocumentMarkAccess()->makeMark( aDelPam, ::rtl::OUString(), IDocumentMarkAccess::UNO_BOOKMARK );
@@ -2398,15 +2428,19 @@ bool SwDoc::ReplaceRangeImpl( SwPaM& rPam, const String& rStr,
                 InsertItemSet( aTmpRange, aSet, 0 );
             }
 
-            if( DoesUndo() )
-                AppendUndo( new SwUndoRedlineDelete( aDelPam, UNDO_REPLACE ));
+            if (GetIDocumentUndoRedo().DoesUndo())
+            {
+                SwUndo *const pUndoRD =
+                    new SwUndoRedlineDelete( aDelPam, UNDO_REPLACE );
+                GetIDocumentUndoRedo().AppendUndo(pUndoRD);
+            }
             AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_DELETE, aDelPam ), true);
 
             *rPam.GetMark() = *aDelPam.GetMark();
-            if( DoesUndo() )
+            if (GetIDocumentUndoRedo().DoesUndo())
             {
                 *aDelPam.GetPoint() = *rPam.GetPoint();
-                EndUndo(UNDO_EMPTY, NULL);
+                GetIDocumentUndoRedo().EndUndo(UNDO_EMPTY, NULL);
 
                 // Bug 68584 - if any Redline will change (split!) the node
                 const ::sw::mark::IMark* pBkmk = getIDocumentMarkAccess()->makeMark( aDelPam, ::rtl::OUString(), IDocumentMarkAccess::UNO_BOOKMARK );
@@ -2433,21 +2467,13 @@ SetRedlineMode( eOld );
                 DeleteRedline( aDelPam, true, USHRT_MAX );
 
             SwUndoReplace* pUndoRpl = 0;
-            if( DoesUndo() )
+            bool const bDoesUndo = GetIDocumentUndoRedo().DoesUndo();
+            if (bDoesUndo)
             {
-                ClearRedo();
-                SwUndo* pU;
-
-                if( !pUndos->Count() ||
-                    UNDO_REPLACE != ( pU = (*pUndos)[ pUndos->Count()-1 ])->GetId() ||
-                    ( pUndoRpl = (SwUndoReplace*)pU )->IsFull() )
-                {
-                    pUndoRpl = new SwUndoReplace();
-                    AppendUndo( pUndoRpl );
-                }
-                pUndoRpl->AddEntry( aDelPam, sRepl, bRegExReplace );
-                DoUndo( sal_False );
+                pUndoRpl = new SwUndoReplace(aDelPam, sRepl, bRegExReplace);
+                GetIDocumentUndoRedo().AppendUndo(pUndoRpl);
             }
+            ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
 
             if( aDelPam.GetPoint() != pStt )
                 aDelPam.Exchange();
@@ -2500,8 +2526,7 @@ SetRedlineMode( eOld );
 
             if( pUndoRpl )
             {
-                pUndoRpl->SetEntryEnd( rPam );
-                DoUndo( sal_True );
+                pUndoRpl->SetEnd(rPam);
             }
         }
     }
@@ -2532,8 +2557,10 @@ bool SwDoc::DelFullPara( SwPaM& rPam )
 
     if ( nSectDiff-2 <= nNodeDiff || IsRedlineOn() ||
          /* #i9185# Prevent getting the node after the end node (see below) */
-        rEnd.nNode.GetIndex() + 1 == aNodes.Count() )
+        rEnd.nNode.GetIndex() + 1 == GetNodes().Count() )
+    {
         return sal_False;
+    }
 
     // harte SeitenUmbrueche am nachfolgenden Node verschieben
     sal_Bool bSavePageBreak = sal_False, bSavePageDesc = sal_False;
@@ -2541,7 +2568,7 @@ bool SwDoc::DelFullPara( SwPaM& rPam )
     /* #i9185# This whould lead to a segmentation fault if not catched
        above. */
     sal_uLong nNextNd = rEnd.nNode.GetIndex() + 1;
-    SwTableNode* pTblNd = aNodes[ nNextNd ]->GetTableNode();
+    SwTableNode *const pTblNd = GetNodes()[ nNextNd ]->GetTableNode();
 
     if( pTblNd && pNd->IsCntntNode() )
     {
@@ -2570,7 +2597,7 @@ bool SwDoc::DelFullPara( SwPaM& rPam )
         }
     }
 
-    sal_Bool bDoesUndo = DoesUndo();
+    bool const bDoesUndo = GetIDocumentUndoRedo().DoesUndo();
     if( bDoesUndo )
     {
         if( !rPam.HasMark() )
@@ -2585,7 +2612,7 @@ bool SwDoc::DelFullPara( SwPaM& rPam )
         pTmpNode = rPam.GetMark()->nNode.GetNode().GetCntntNode();
         rPam.GetMark()->nContent.Assign( pTmpNode, 0 );
 
-        ClearRedo();
+        GetIDocumentUndoRedo().ClearRedo();
 
         SwPaM aDelPam( *rPam.GetMark(), *rPam.GetPoint() );
         {
@@ -2602,7 +2629,7 @@ bool SwDoc::DelFullPara( SwPaM& rPam )
 
         *rPam.GetPoint() = *aDelPam.GetPoint();
         pUndo->SetPgBrkFlags( bSavePageBreak, bSavePageDesc );
-        AppendUndo( pUndo );
+        GetIDocumentUndoRedo().AppendUndo(pUndo);
     }
     else
     {
@@ -2660,11 +2687,9 @@ void SwDoc::TransliterateText(
     const SwPaM& rPaM,
     utl::TransliterationWrapper& rTrans )
 {
-    SwUndoTransliterate* pUndo;
-    if( DoesUndo() )
-        pUndo = new SwUndoTransliterate( rPaM, rTrans );
-    else
-        pUndo = 0;
+    SwUndoTransliterate *const pUndo = (GetIDocumentUndoRedo().DoesUndo())
+        ?   new SwUndoTransliterate( rPaM, rTrans )
+        :   0;
 
     const SwPosition* pStt = rPaM.Start(),
                        * pEnd = rPaM.End();
@@ -2722,8 +2747,7 @@ void SwDoc::TransliterateText(
     {
         if( pUndo->HasData() )
         {
-            ClearRedo();
-            AppendUndo( pUndo );
+            GetIDocumentUndoRedo().AppendUndo(pUndo);
         }
         else
             delete pUndo;