1 files changed, 133 insertions, 109 deletions

diff --git a/sw/source/core/doc/docedt.cxx b/sw/source/core/doc/docedt.cxx
index d966cb78ba8c..ba43772dcaa0 100644
--- a/sw/source/core/doc/docedt.cxx
+++ b/sw/source/core/doc/docedt.cxx
@@ -49,6 +49,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
@@ -64,7 +65,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 <vcl/msgbox.hxx>
@@ -453,8 +459,8 @@ bool lcl_SaveFtn( const SwNodeIndex& rSttNd, const SwNodeIndex& rEndNd,
                 if( pHints && pHints->HasFtn() ) //...with footnotes
                 {
                     bUpdateFtn = sal_True; // Heureka
-                    USHORT nCount = pHints->Count();
-                    for( USHORT i = 0; i < nCount; ++i )
+                    sal_uInt16 nCount = pHints->Count();
+                    for( sal_uInt16 i = 0; i < nCount; ++i )
                     {
                         SwTxtAttr *pAttr = pHints->GetTextHint( i );
                         if ( pAttr->Which() == RES_TXTATR_FTN )
@@ -752,8 +758,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;
@@ -761,13 +769,11 @@ 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;
 
-    BOOL bOldExpFlg = pNode->IsIgnoreDontExpand();
-    pNode->SetIgnoreDontExpand( TRUE );
+    sal_Bool bOldExpFlg = pNode->IsIgnoreDontExpand();
+    pNode->SetIgnoreDontExpand( sal_True );
 
     for( xub_StrLen nCnt = 0; nCnt < rStr.Len(); ++nCnt )
     {
@@ -778,16 +784,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
@@ -820,7 +834,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 );
@@ -887,15 +902,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.
-        BOOL bDoesUndo = DoesUndo();
-        DoUndo( FALSE );
+        ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
         _DelBookmarks(
             pStt->nNode,
             pEnd->nNode,
             NULL,
             &pStt->nContent,
             &pEnd->nContent);
-        DoUndo( bDoesUndo );
     }
 
 
@@ -904,9 +917,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 );
     }
@@ -1003,7 +1016,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 )
@@ -1046,7 +1059,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
     {
@@ -1127,11 +1140,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 );
@@ -1177,7 +1194,7 @@ bool SwDoc::MoveNodeRange( SwNodeRange& rRange, SwNodeIndex& rPos,
         pSaveInsPos = new SwNodeIndex( rRange.aStart, -1 );
 
     // verschiebe die Nodes
-    BOOL bNoDelFrms = 0 != (DOC_NO_DELFRMS & eMvFlags);
+    sal_Bool bNoDelFrms = 0 != (DOC_NO_DELFRMS & eMvFlags);
     if( GetNodes()._MoveNodes( rRange, GetNodes(), rPos, !bNoDelFrms ) )
     {
         aIdx++;     // wieder auf alte Position
@@ -1221,9 +1238,8 @@ bool SwDoc::MoveNodeRange( SwNodeRange& rRange, SwNodeIndex& rPos,
 
     if( pUndo )
     {
-        ClearRedo();
         pUndo->SetDestRange( aIdx, rPos, *pSaveInsPos );
-        AppendUndo( pUndo );
+        GetIDocumentUndoRedo().AppendUndo(pUndo);
     }
 
     if( pSaveInsPos )
@@ -1245,7 +1261,7 @@ bool SwDoc::MoveNodeRange( SwNodeRange& rRange, SwNodeIndex& rPos,
 }
 
 // Convert list of ranges of whichIds to a corresponding list of whichIds
-SvUShorts * lcl_RangesToUShorts(USHORT * pRanges)
+SvUShorts * lcl_RangesToUShorts(sal_uInt16 * pRanges)
 {
     SvUShorts * pResult = new SvUShorts();
 
@@ -1254,7 +1270,7 @@ SvUShorts * lcl_RangesToUShorts(USHORT * pRanges)
     {
         OSL_ENSURE(pRanges[i+1] != 0, "malformed ranges");
 
-        for (USHORT j = pRanges[i]; j < pRanges[i+1]; j++)
+        for (sal_uInt16 j = pRanges[i]; j < pRanges[i+1]; j++)
             pResult->Insert(j, pResult->Count());
 
         i += 2;
@@ -1333,8 +1349,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 ...
@@ -1386,8 +1401,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() )
@@ -1524,21 +1537,19 @@ bool SwDoc::DeleteAndJoinWithRedlineImpl( SwPaM & rPam, const bool )
     OSL_ENSURE( 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);
@@ -1546,18 +1557,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 );
@@ -1654,17 +1676,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();
 
@@ -1808,7 +1838,7 @@ void lcl_syncGrammarError( SwTxtNode &rTxtNode, linguistic2::ProofreadingResult&
         return;
     SwGrammarMarkUp* pWrong = rTxtNode.GetGrammarCheck();
     linguistic2::SingleProofreadingError* pArray = rResult.aErrors.getArray();
-    USHORT i, j = 0;
+    sal_uInt16 i, j = 0;
     if( pWrong )
     {
         for( i = 0; i < rResult.aErrors.getLength(); ++i )
@@ -1848,8 +1878,8 @@ uno::Any SwDoc::Spell( SwPaM& rPaM,
                             pEndPos->nNode.GetNode().GetTxtNode(), pEndPos->nContent,
                             bGrammarCheck );
 
-    ULONG nCurrNd = pSttPos->nNode.GetIndex();
-    ULONG nEndNd = pEndPos->nNode.GetIndex();
+    sal_uLong nCurrNd = pSttPos->nNode.GetIndex();
+    sal_uLong nEndNd = pEndPos->nNode.GetIndex();
 
     uno::Any aRet;
     if( nCurrNd <= nEndNd )
@@ -2180,7 +2210,7 @@ bool SwDoc::ReplaceRange( SwPaM& rPam, const String& rStr,
     ::std::vector<xub_StrLen> Breaks;
 
     SwPaM aPam( *rPam.GetMark(), *rPam.GetPoint() );
-    aPam.Normalize(FALSE);
+    aPam.Normalize(sal_False);
     if (aPam.GetPoint()->nNode != aPam.GetMark()->nNode)
     {
         aPam.Move(fnMoveBackward);
@@ -2283,9 +2313,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 );
@@ -2365,15 +2395,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 );
@@ -2400,21 +2434,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();
@@ -2467,8 +2493,7 @@ SetRedlineMode( eOld );
 
             if( pUndoRpl )
             {
-                pUndoRpl->SetEntryEnd( rPam );
-                DoUndo( sal_True );
+                pUndoRpl->SetEnd(rPam);
             }
         }
     }
@@ -2499,16 +2524,18 @@ 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;
 
     /* #i9185# This whould lead to a segmentation fault if not catched
        above. */
-    ULONG nNextNd = rEnd.nNode.GetIndex() + 1;
-    SwTableNode* pTblNd = aNodes[ nNextNd ]->GetTableNode();
+    sal_uLong nNextNd = rEnd.nNode.GetIndex() + 1;
+    SwTableNode *const pTblNd = GetNodes()[ nNextNd ]->GetTableNode();
 
     if( pTblNd && pNd->IsCntntNode() )
     {
@@ -2533,7 +2560,7 @@ bool SwDoc::DelFullPara( SwPaM& rPam )
         }
     }
 
-    sal_Bool bDoesUndo = DoesUndo();
+    bool const bDoesUndo = GetIDocumentUndoRedo().DoesUndo();
     if( bDoesUndo )
     {
         if( !rPam.HasMark() )
@@ -2548,7 +2575,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() );
         {
@@ -2565,7 +2592,7 @@ bool SwDoc::DelFullPara( SwPaM& rPam )
 
         *rPam.GetPoint() = *aDelPam.GetPoint();
         pUndo->SetPgBrkFlags( bSavePageBreak, bSavePageDesc );
-        AppendUndo( pUndo );
+        GetIDocumentUndoRedo().AppendUndo(pUndo);
     }
     else
     {
@@ -2606,10 +2633,10 @@ bool SwDoc::DelFullPara( SwPaM& rPam )
             }
         }
 
-        SwCntntNode *pTmpNode = rPam.GetBound( TRUE ).nNode.GetNode().GetCntntNode();
-        rPam.GetBound( TRUE ).nContent.Assign( pTmpNode, 0 );
-        pTmpNode = rPam.GetBound( FALSE ).nNode.GetNode().GetCntntNode();
-        rPam.GetBound( FALSE ).nContent.Assign( pTmpNode, 0 );
+        SwCntntNode *pTmpNode = rPam.GetBound( sal_True ).nNode.GetNode().GetCntntNode();
+        rPam.GetBound( sal_True ).nContent.Assign( pTmpNode, 0 );
+        pTmpNode = rPam.GetBound( sal_False ).nNode.GetNode().GetCntntNode();
+        rPam.GetBound( sal_False ).nContent.Assign( pTmpNode, 0 );
         GetNodes().Delete( aRg.aStart, nNodeDiff+1 );
     }
     rPam.DeleteMark();
@@ -2622,15 +2649,13 @@ 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();
-    ULONG nSttNd = pStt->nNode.GetIndex(),
+    sal_uLong nSttNd = pStt->nNode.GetIndex(),
           nEndNd = pEnd->nNode.GetIndex();
     xub_StrLen nSttCnt = pStt->nContent.GetIndex(),
                nEndCnt = pEnd->nContent.GetIndex();
@@ -2646,7 +2671,7 @@ void SwDoc::TransliterateText(
                         pTNd->GetTxt(), nSttCnt,
                         pBreakIt->GetLocale( pTNd->GetLang( nSttCnt ) ),
                         WordType::ANY_WORD /*ANYWORD_IGNOREWHITESPACES*/,
-                        TRUE );
+                        sal_True );
 
         if( aBndry.startPos < nSttCnt && nSttCnt < aBndry.endPos )
         {
@@ -2684,8 +2709,7 @@ void SwDoc::TransliterateText(
     {
         if( pUndo->HasData() )
         {
-            ClearRedo();
-            AppendUndo( pUndo );
+            GetIDocumentUndoRedo().AppendUndo(pUndo);
         }
         else
             delete pUndo;
@@ -2704,7 +2728,7 @@ void SwDoc::checkRedlining(RedlineMode_t& _rReadlineMode)
         && !((_rReadlineMode & nsRedlineMode_t::REDLINE_SHOW_DELETE) == nsRedlineMode_t::REDLINE_SHOW_DELETE) )
     {
         WarningBox aWarning( pParent,SW_RES(MSG_DISABLE_READLINE_QUESTION));
-        USHORT nResult = aWarning.Execute();
+        sal_uInt16 nResult = aWarning.Execute();
         mbReadlineChecked = sal_True;
         if ( nResult == RET_YES )
         {
@@ -2722,8 +2746,8 @@ void SwDoc::CountWords( const SwPaM& rPaM, SwDocStat& rStat ) const
     const SwPosition* pEnd = pStt == rPaM.GetPoint() ? rPaM.GetMark()
                                                      : rPaM.GetPoint();
 
-    const ULONG nSttNd = pStt->nNode.GetIndex();
-    const ULONG nEndNd = pEnd->nNode.GetIndex();
+    const sal_uLong nSttNd = pStt->nNode.GetIndex();
+    const sal_uLong nEndNd = pEnd->nNode.GetIndex();
 
     const xub_StrLen nSttCnt = pStt->nContent.GetIndex();
     const xub_StrLen nEndCnt = pEnd->nContent.GetIndex();