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