diff options
Diffstat (limited to 'sw/inc/undobj.hxx')
| -rw-r--r-- | sw/inc/undobj.hxx | 1754 |
1 files changed, 85 insertions, 1669 deletions
diff --git a/sw/inc/undobj.hxx b/sw/inc/undobj.hxx index 7f16e4e4d44c..9d447c18034f 100644 --- a/sw/inc/undobj.hxx +++ b/sw/inc/undobj.hxx @@ -28,118 +28,50 @@ #define SW_UNDOBJ_HXX #include <vector> -#include <memory> #include <boost/shared_ptr.hpp> -#include <com/sun/star/uno/Sequence.h> +#include <svl/undo.hxx> -#include <tools/mempool.hxx> -#ifndef _SVSTDARR_HXX -#define _SVSTDARR_USHORTS -#define _SVSTDARR_ULONGS -#define _SVSTDARR_BOOLS -#define _SVSTDARR_BYTES -#define _SVSTDARR_USHORTSSORT -#include <svl/svstdarr.hxx> -#endif -#include <svl/itemset.hxx> - -#include <svx/svdundo.hxx> // #111827# - -#include <numrule.hxx> -#include <itabenum.hxx> -#include <format.hxx> #include <SwRewriter.hxx> #include <swundo.hxx> -#include <IMark.hxx> -#include <IDocumentContentOperations.hxx> -class SwUndoIter; class SwHistory; class SwIndex; class SwPaM; struct SwPosition; class SwDoc; -class SwFmt; -class SwFmtColl; class SwTxtFmtColl; -class SwTxtNode; -class SwTableNode; -class SwTable; -class SwTableBox; -struct SwSortOptions; class SwFrmFmt; -class SwHistoryBookmark; -class SwSectionData; -class SwSectionFmt; -class SwTOXBase; -class SvxTabStopItem; -class SwDDEFieldType; -class Graphic; -class SwGrfNode; -class SwUndos; -class SwFtnInfo; -class SwEndNoteInfo; class SwNodeIndex; class SwNodeRange; -class SwFmtAnchor; -struct SwUndoGroupObjImpl; -class SdrMark; -class SdrMarkList; -class SdrObject; -class SdrObjGroup; -class SdrUndoAction; -class SwDrawFrmFmt; -class _SaveTable; -class SwTableAutoFmt; -class SwSelBoxes; -class SwTableSortBoxes; -class SwUndoSaveSections; -class SwUndoMoves; -class SwStartNode; -class _SaveFlyArr; -class SwTblToTxtSaves; class SwRedlineData; -class SwRedlineSaveData; -class SwRedline; -struct SwSaveRowSpan; - -namespace sfx2 { - class MetadatableUndo; -} +class SwRedlineSaveDatas; -namespace utl { - class TransliterationWrapper; +namespace sw { + class UndoRedoContext; + class RepeatContext; } -const String UNDO_ARG1("$1", RTL_TEXTENCODING_ASCII_US); -const String UNDO_ARG2("$2", RTL_TEXTENCODING_ASCII_US); -const String UNDO_ARG3("$3", RTL_TEXTENCODING_ASCII_US); - -typedef SwRedlineSaveData* SwRedlineSaveDataPtr; -SV_DECL_PTRARR_DEL( SwRedlineSaveDatas, SwRedlineSaveDataPtr, 8, 8 ) - class SwUndo + : public SfxUndoAction { - SwUndoId nId; - USHORT nOrigRedlineMode; + SwUndoId const m_nId; + sal_uInt16 nOrigRedlineMode; protected: bool bCacheComment; mutable String * pComment; - void RemoveIdxFromSection( SwDoc&, ULONG nSttIdx, ULONG* pEndIdx = 0 ); - void RemoveIdxFromRange( SwPaM& rPam, BOOL bMoveNext ); - void RemoveIdxRel( ULONG, const SwPosition& ); + void RemoveIdxFromSection( SwDoc&, sal_uLong nSttIdx, sal_uLong* pEndIdx = 0 ); + void RemoveIdxFromRange( SwPaM& rPam, sal_Bool bMoveNext ); + void RemoveIdxRel( sal_uLong, const SwPosition& ); - void SetId( SwUndoId nNew ) { nId = nNew; } - - static BOOL CanRedlineGroup( SwRedlineSaveDatas& rCurr, + static sal_Bool CanRedlineGroup( SwRedlineSaveDatas& rCurr, const SwRedlineSaveDatas& rCheck, - BOOL bCurrIsEnd ); + sal_Bool bCurrIsEnd ); // #111827# /** @@ -148,16 +80,31 @@ protected: @return the rewriter for this object */ virtual SwRewriter GetRewriter() const; + + // return type is sal_uInt16 because this overrides SfxUndoAction::GetId() + virtual sal_uInt16 GetId() const { return static_cast<sal_uInt16>(m_nId); } + + // the 4 methods that derived classes have to override + // base implementation does nothing + virtual void RepeatImpl( ::sw::RepeatContext & ); + virtual bool CanRepeatImpl( ::sw::RepeatContext & ) const; +public: // should not be public, but ran into trouble in untbl.cxx + virtual void UndoImpl( ::sw::UndoRedoContext & ) = 0; + virtual void RedoImpl( ::sw::UndoRedoContext & ) = 0; + +private: + // SfxUndoAction + virtual void Undo(); + virtual void Redo(); + virtual void UndoWithContext(SfxUndoContext &); + virtual void RedoWithContext(SfxUndoContext &); + virtual void Repeat(SfxRepeatTarget &); + virtual sal_Bool CanRepeat(SfxRepeatTarget &) const; + public: - SwUndo( SwUndoId nI ); + SwUndo(SwUndoId const nId); virtual ~SwUndo(); - SwUndoId GetId() const { return nId; } - virtual SwUndoId GetEffectiveId() const; - virtual void Undo( SwUndoIter& ) = 0; - virtual void Redo( SwUndoIter& ) = 0; - virtual void Repeat( SwUndoIter& ); - // #111827# /** Returns textual comment for this undo object. @@ -172,20 +119,20 @@ public: // das UndoObject merkt sich, welcher Mode eingeschaltet war. // In Undo/Redo/Repeat wird dann immer auf diesen zurueck geschaltet - USHORT GetRedlineMode() const { return nOrigRedlineMode; } - void SetRedlineMode( USHORT eMode ) { nOrigRedlineMode = eMode; } + sal_uInt16 GetRedlineMode() const { return nOrigRedlineMode; } + void SetRedlineMode( sal_uInt16 eMode ) { nOrigRedlineMode = eMode; } bool IsDelBox() const; // sicher und setze die RedlineDaten - static BOOL FillSaveData( const SwPaM& rRange, SwRedlineSaveDatas& rSData, - BOOL bDelRange = TRUE, BOOL bCopyNext = TRUE ); - static BOOL FillSaveDataForFmt( const SwPaM& , SwRedlineSaveDatas& ); + static sal_Bool FillSaveData( const SwPaM& rRange, SwRedlineSaveDatas& rSData, + sal_Bool bDelRange = sal_True, sal_Bool bCopyNext = sal_True ); + static sal_Bool FillSaveDataForFmt( const SwPaM& , SwRedlineSaveDatas& ); static void SetSaveData( SwDoc& rDoc, const SwRedlineSaveDatas& rSData ); - static BOOL HasHiddenRedlines( const SwRedlineSaveDatas& rSData ); + static sal_Bool HasHiddenRedlines( const SwRedlineSaveDatas& rSData ); }; -typedef USHORT DelCntntType; +typedef sal_uInt16 DelCntntType; namespace nsDelCntntType { const DelCntntType DELCNT_FTN = 0x01; @@ -217,17 +164,17 @@ protected: // MoveFrom.. verschiebt aus dem UndoNodesArray in das NodesArray void MoveToUndoNds( SwPaM& rPam, SwNodeIndex* pNodeIdx = 0, SwIndex* pCntIdx = 0, - ULONG* pEndNdIdx = 0, xub_StrLen * pEndCntIdx = 0 ); - void MoveFromUndoNds( SwDoc& rDoc, ULONG nNodeIdx, xub_StrLen nCntntIdx, + sal_uLong* pEndNdIdx = 0, xub_StrLen * pEndCntIdx = 0 ); + void MoveFromUndoNds( SwDoc& rDoc, sal_uLong nNodeIdx, xub_StrLen nCntntIdx, SwPosition& rInsPos, - ULONG* pEndNdIdx = 0, xub_StrLen * pEndCntIdx = 0 ); + sal_uLong* pEndNdIdx = 0, xub_StrLen * pEndCntIdx = 0 ); // diese beiden Methoden bewegen den SPoint vom Pam zurueck/vor. Damit // kann fuer ein Undo/Redo ein Bereich aufgespannt werden. (Der // SPoint liegt dann vor dem manipuliertem Bereich !!) // Das Flag gibt an, ob noch vorm SPoint Inhalt steht. - BOOL MovePtBackward( SwPaM& rPam ); - void MovePtForward( SwPaM& rPam, BOOL bMvBkwrd ); + sal_Bool MovePtBackward( SwPaM& rPam ); + void MovePtForward( SwPaM& rPam, sal_Bool bMvBkwrd ); // vor dem Move ins UndoNodes-Array muss dafuer gesorgt werden, das // die Inhaltstragenden Attribute aus dem Nodes-Array entfernt werden. @@ -245,12 +192,12 @@ class SwUndoSaveSection : private SwUndoSaveCntnt { SwNodeIndex *pMvStt; SwRedlineSaveDatas* pRedlSaveData; - ULONG nMvLen; // Index ins UndoNodes-Array - ULONG nStartPos; + sal_uLong nMvLen; // Index ins UndoNodes-Array + sal_uLong nStartPos; protected: SwNodeIndex* GetMvSttIdx() const { return pMvStt; } - ULONG GetMvNodeCnt() const { return nMvLen; } + sal_uLong GetMvNodeCnt() const { return nMvLen; } public: SwUndoSaveSection(); @@ -258,7 +205,7 @@ public: void SaveSection( SwDoc* pDoc, const SwNodeIndex& rSttIdx ); void SaveSection( SwDoc* pDoc, const SwNodeRange& rRange ); - void RestoreSection( SwDoc* pDoc, SwNodeIndex* pIdx, USHORT nSectType ); + void RestoreSection( SwDoc* pDoc, SwNodeIndex* pIdx, sal_uInt16 nSectType ); void RestoreSection( SwDoc* pDoc, const SwNodeIndex& rInsPos ); const SwHistory* GetHistory() const { return pHistory; } @@ -266,517 +213,51 @@ public: }; -// 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 class SwUndRng { public: - ULONG nSttNode, nEndNode; + sal_uLong nSttNode, nEndNode; xub_StrLen nSttCntnt, nEndCntnt; SwUndRng(); SwUndRng( const SwPaM& ); void SetValues( const SwPaM& rPam ); - void SetPaM( SwPaM&, BOOL bCorrToCntnt = FALSE ) const; - void SetPaM( SwUndoIter&, BOOL bCorrToCntnt = FALSE ) const; -}; - - -class SwUndoStart: public SwUndo -{ - // Um innerhalb von Undo zuerkennen, wann ein Start vorliegt, gibt - // GetId() immer die UNDO_START zurueck. Die UserId kann ueber - // GetUserId() erfragt werden. - SwUndoId nUserId; - // fuer die "Verpointerung" von Start- und End-Undos - USHORT nEndOffset; - - SwRewriter mRewriter; - -public: - SwUndoStart( SwUndoId nId ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - // -> #111827# - virtual String GetComment() const; - void SetRewriter(const SwRewriter & rRewriter); - virtual SwRewriter GetRewriter() const; - // <- #111827# - - virtual SwUndoId GetEffectiveId() const; - SwUndoId GetUserId() const { return nUserId; } - // Setzen vom End-Undo-Offset geschieht im Doc::EndUndo - USHORT GetEndOffset() const { return nEndOffset; } - void SetEndOffset( USHORT n ) { nEndOffset = n; } -}; - -class SwUndoEnd: public SwUndo -{ - // Um innerhalb von Undo zuerkennen, wann ein Ende vorliegt, gibt - // GetId() immer die UNDO_END zurueck. Die UserId kann ueber - // GetUserId() erfragt werden. - SwUndoId nUserId; - // fuer die "Verpointerung" von Start- und End-Undos - USHORT nSttOffset; - - SwRewriter mRewriter; - -public: - SwUndoEnd( SwUndoId nId ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - // -> #111827# - virtual String GetComment() const; - void SetRewriter(const SwRewriter & rRewriter); - virtual SwRewriter GetRewriter() const; - // <- #111827# - - virtual SwUndoId GetEffectiveId() const; - SwUndoId GetUserId() const { return nUserId; } - - // Setzen vom Start-Undo-Offset geschieht im Doc::EndUndo - void SetSttOffset(USHORT _nSttOffSet) { nSttOffset = _nSttOffSet; } - USHORT GetSttOffset() const { return nSttOffset; } -}; - -class SwUndoInsert: public SwUndo, private SwUndoSaveCntnt -{ - SwPosition *pPos; // Inhalt fuers Redo - String *pTxt, *pUndoTxt; - SwRedlineData* pRedlData; - ULONG nNode; - xub_StrLen nCntnt, nLen; - BOOL bIsWordDelim : 1; - BOOL bIsAppend : 1; - - const IDocumentContentOperations::InsertFlags m_nInsertFlags; - - friend class SwDoc; // eigentlich nur SwDoc::Insert( String ) - BOOL CanGrouping( sal_Unicode cIns ); - BOOL CanGrouping( const SwPosition& rPos ); - - SwDoc * pDoc; - - void Init(const SwNodeIndex & rNode); - String * GetTxtFromDoc() const; - -public: - SwUndoInsert( const SwNodeIndex& rNode, xub_StrLen nCntnt, xub_StrLen nLen, - const IDocumentContentOperations::InsertFlags nInsertFlags, - BOOL bWDelim = TRUE ); - SwUndoInsert( const SwNodeIndex& rNode ); - virtual ~SwUndoInsert(); - - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - // #111827# - /** - Returns rewriter for this undo object. - - The returned rewriter has the following rule: - - $1 -> '<inserted text>' - - <inserted text> is shortened to a length of nUndoStringLength. - - @return rewriter for this undo object - */ - virtual SwRewriter GetRewriter() const; - - - DECL_FIXEDMEMPOOL_NEWDEL(SwUndoInsert) -}; - - -class SwUndoDelete: public SwUndo, private SwUndRng, private SwUndoSaveCntnt -{ - SwNodeIndex* pMvStt; // Position der Nodes im UndoNodes-Array - String *pSttStr, *pEndStr; - SwRedlineData* pRedlData; - SwRedlineSaveDatas* pRedlSaveData; - ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoStart; - ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoEnd; - - String sTableName; - - ULONG nNode; - ULONG nNdDiff; // Differenz von Nodes vor-nach Delete - ULONG nSectDiff; // Diff. von Nodes vor/nach Move mit SectionNodes - ULONG nReplaceDummy; // Diff. to a temporary dummy object - USHORT nSetPos; - - BOOL bGroup : 1; // TRUE: ist schon eine Gruppe; wird in CanGrouping() ausgwertet !! - BOOL bBackSp : 1; // TRUE: wenn Gruppierung und der Inhalt davor geloescht wird - BOOL bJoinNext: 1; // TRUE: wenn der Bereich von Oben nach unten geht - BOOL bTblDelLastNd : 1; // TRUE: TextNode hinter der Tabelle einf./loeschen - BOOL bDelFullPara : 1; // TRUE: gesamte Nodes wurden geloescht - BOOL bResetPgDesc : 1; // TRUE: am nachfolgenden Node das PgDsc zuruecksetzen - BOOL bResetPgBrk : 1; // TRUE: am nachfolgenden Node das PgBreak zuruecksetzen - BOOL bFromTableCopy : 1; // TRUE: called by SwUndoTblCpyTbl - - BOOL SaveCntnt( const SwPosition* pStt, const SwPosition* pEnd, - SwTxtNode* pSttTxtNd, SwTxtNode* pEndTxtNd ); -public: - SwUndoDelete( SwPaM&, BOOL bFullPara = FALSE, BOOL bCalledByTblCpy = FALSE ); - virtual ~SwUndoDelete(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - // #111827# - /** - Returns rewriter for this undo object. - - The rewriter consists of the following rule: - - $1 -> '<deleted text>' - - <deleted text> is shortened to nUndoStringLength characters. - - @return rewriter for this undo object - */ - virtual SwRewriter GetRewriter() const; - - BOOL CanGrouping( SwDoc*, const SwPaM& ); - - void SetTblDelLastNd() { bTblDelLastNd = TRUE; } - - // fuer die PageDesc/PageBreak Attribute einer Tabelle - void SetPgBrkFlags( BOOL bPageBreak, BOOL bPageDesc ) - { bResetPgDesc = bPageDesc; bResetPgBrk = bPageBreak; } - - void SetTableName(const String & rName); - - // SwUndoTblCpyTbl needs this information: - long NodeDiff() const { return nSttNode - nEndNode; } - xub_StrLen ContentStart() const { return nSttCntnt; } - BOOL IsDelFullPara() const { return bDelFullPara; } - - DECL_FIXEDMEMPOOL_NEWDEL(SwUndoDelete) -}; - - -class SwUndoOverwrite: public SwUndo, private SwUndoSaveCntnt -{ - String aDelStr, aInsStr; - SwRedlineSaveDatas* pRedlSaveData; - ULONG nSttNode; - xub_StrLen nSttCntnt; - BOOL bInsChar : 1; // kein Overwrite mehr; sondern Insert - BOOL bGroup : 1; // TRUE: ist schon eine Gruppe; wird in - // CanGrouping() ausgwertet !! -public: - SwUndoOverwrite( SwDoc*, SwPosition&, sal_Unicode cIns ); - virtual ~SwUndoOverwrite(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - // #111827# - /** - Returns the rewriter of this undo object. - - The rewriter contains the following rule: - - $1 -> '<overwritten text>' - - <overwritten text> is shortened to nUndoStringLength characters. - - @return the rewriter of this undo object - */ - virtual SwRewriter GetRewriter() const; - - BOOL CanGrouping( SwDoc*, SwPosition&, sal_Unicode cIns ); -}; - - -class SwUndoSplitNode: public SwUndo -{ - SwHistory* pHistory; - SwRedlineData* pRedlData; - ULONG nNode; - xub_StrLen nCntnt; - BOOL bTblFlag : 1; - BOOL bChkTblStt : 1; -public: - SwUndoSplitNode( SwDoc* pDoc, const SwPosition& rPos, BOOL bChkTbl ); - virtual ~SwUndoSplitNode(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - void SetTblFlag() { bTblFlag = TRUE; } -}; - - -class SwUndoMove : public SwUndo, private SwUndRng, private SwUndoSaveCntnt -{ - // nDest.. - Bereich, in den verschoben wurde (nach dem Move!) - // nIns.. - Position, von der verschoben wurde und wieder die neue InsPos. ist - // nMv.. Position auf die verschoben wird (vor dem Move!) ; fuers REDO - ULONG nDestSttNode, nDestEndNode, nInsPosNode, nMvDestNode; - xub_StrLen nDestSttCntnt, nDestEndCntnt, nInsPosCntnt, nMvDestCntnt; - - USHORT nFtnStt; // StartPos der Fussnoten in der History - - BOOL bJoinNext : 1, - bJoinPrev : 1, - bMoveRange : 1; - - bool bMoveRedlines; // use DOC_MOVEREDLINES when calling SwDoc::Move - - void DelFtn( const SwPaM& ); -public: - SwUndoMove( const SwPaM&, const SwPosition& ); - SwUndoMove( SwDoc* pDoc, const SwNodeRange&, const SwNodeIndex& ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - // setze den Destination-Bereich nach dem Verschieben. - void SetDestRange( const SwPaM&, const SwPosition&, BOOL, BOOL ); - void SetDestRange( const SwNodeIndex& rStt, const SwNodeIndex& rEnd, - const SwNodeIndex& rInsPos ); - - BOOL IsMoveRange() const { return bMoveRange; } - ULONG GetEndNode() const { return nEndNode; } - ULONG GetDestSttNode() const { return nDestSttNode; } - xub_StrLen GetDestSttCntnt() const { return nDestSttCntnt; } - - void SetMoveRedlines( bool b ) { bMoveRedlines = b; } - -}; - - -class SwUndoAttr : public SwUndo, private SwUndRng -{ - SfxItemSet m_AttrSet; // attributes for Redo - const ::std::auto_ptr<SwHistory> m_pHistory; // History for Undo - ::std::auto_ptr<SwRedlineData> m_pRedlineData; // Redlining - ::std::auto_ptr<SwRedlineSaveDatas> m_pRedlineSaveData; - ULONG m_nNodeIndex; // Offset: for Redlining - const SetAttrMode m_nInsertFlags; // insert flags - - void RemoveIdx( SwDoc& rDoc ); - -public: - SwUndoAttr( const SwPaM&, const SfxItemSet &, const SetAttrMode nFlags ); - SwUndoAttr( const SwPaM&, const SfxPoolItem&, const SetAttrMode nFlags ); - virtual ~SwUndoAttr(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - void SaveRedlineData( const SwPaM& rPam, BOOL bInsCntnt ); - - SwHistory& GetHistory() { return *m_pHistory; } - -}; - -class SwUndoResetAttr : public SwUndo, private SwUndRng -{ - const ::std::auto_ptr<SwHistory> m_pHistory; - SvUShortsSort m_Ids; - const USHORT m_nFormatId; // Format-Id for Redo - -public: - SwUndoResetAttr( const SwPaM&, USHORT nFmtId ); - SwUndoResetAttr( const SwPosition&, USHORT nFmtId ); - virtual ~SwUndoResetAttr(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - void SetAttrs( const SvUShortsSort& rArr ); - - SwHistory& GetHistory() { return *m_pHistory; } - -}; - -class SwUndoFmtAttr : public SwUndo -{ - friend class SwUndoDefaultAttr; - SwFmt * m_pFmt; - ::std::auto_ptr<SfxItemSet> m_pOldSet; // old attributes - ULONG m_nNodeIndex; - const USHORT m_nFmtWhich; - const bool m_bSaveDrawPt; - - bool IsFmtInDoc( SwDoc* ); //is the attribute format still in the Doc? - void SaveFlyAnchor( bool bSaveDrawPt = false ); - // --> OD 2004-10-26 #i35443# - Add return value, type <bool>. - // Return value indicates, if anchor attribute is restored. - // Notes: - If anchor attribute is restored, all other existing attributes - // are also restored. - // - Anchor attribute isn't restored successfully, if it contains - // an invalid anchor position and all other existing attributes - // aren't restored. - // This situation occurs for undo of styles. - bool RestoreFlyAnchor( SwUndoIter& rIter ); - // <-- - // --> OD 2008-02-27 #refactorlists# - removed <rAffectedItemSet> - void Init(); - // <-- - -public: - // register at the Format and save old attributes - // --> OD 2008-02-27 #refactorlists# - removed <rNewSet> - SwUndoFmtAttr( const SfxItemSet& rOldSet, - SwFmt& rFmt, - bool bSaveDrawPt = true ); - // <-- - SwUndoFmtAttr( const SfxPoolItem& rItem, - SwFmt& rFmt, - bool bSaveDrawPt = true ); - virtual ~SwUndoFmtAttr(); - virtual void Undo( SwUndoIter& ); - // --> OD 2004-10-26 #i35443# - <Redo(..)> calls <Undo(..)> - nothing else - virtual void Redo( SwUndoIter& ); - // <-- - virtual void Repeat( SwUndoIter& ); - virtual SwRewriter GetRewriter() const; - - void PutAttr( const SfxPoolItem& rItem ); - SwFmt* GetFmt( SwDoc& rDoc ); // checks if it is still in the Doc! -}; - -// --> OD 2008-02-12 #newlistlevelattrs# -class SwUndoFmtResetAttr : public SwUndo -{ - public: - SwUndoFmtResetAttr( SwFmt& rChangedFormat, - const USHORT nWhichId ); - ~SwUndoFmtResetAttr(); - - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - private: - // format at which a certain attribute is reset. - SwFmt * const m_pChangedFormat; - // which ID of the reset attribute - const USHORT m_nWhichId; - // old attribute which has been reset - needed for undo. - ::std::auto_ptr<SfxPoolItem> m_pOldItem; -}; -// <-- - -class SwUndoDontExpandFmt : public SwUndo -{ - const ULONG m_nNodeIndex; - const xub_StrLen m_nContentIndex; - -public: - SwUndoDontExpandFmt( const SwPosition& rPos ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); -}; - -// helper class to receive changed attribute sets -class SwUndoFmtAttrHelper : public SwClient -{ - ::std::auto_ptr<SwUndoFmtAttr> m_pUndo; - const bool m_bSaveDrawPt; - -public: - SwUndoFmtAttrHelper( SwFmt& rFmt, bool bSaveDrawPt = true ); - - virtual void Modify( SfxPoolItem*, SfxPoolItem* ); - - SwUndoFmtAttr* GetUndo() const { return m_pUndo.get(); } - // release the undo object (so it is not deleted here), and return it - SwUndoFmtAttr* ReleaseUndo() { return m_pUndo.release(); } -}; - - -class SwUndoFmtColl : public SwUndo, private SwUndRng -{ - String aFmtName; - SwHistory* pHistory; - SwFmtColl* pFmtColl; - // --> OD 2008-04-15 #refactorlists# - for correct <ReDo(..)> and <Repeat(..)> - // boolean, which indicates that the attributes are reseted at the nodes - // before the format has been applied. - const bool mbReset; - // boolean, which indicates that the list attributes had been reseted at - // the nodes before the format has been applied. - const bool mbResetListAttrs; - // <-- -public: - // --> OD 2008-04-15 #refactorlists# -// SwUndoFmtColl( const SwPaM&, SwFmtColl* ); - SwUndoFmtColl( const SwPaM&, SwFmtColl*, - const bool bReset, - const bool bResetListAttrs ); - // <-- - virtual ~SwUndoFmtColl(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - // #111827# - /** - Returns the rewriter for this undo object. - - The rewriter contains one rule: - - $1 -> <name of format collection> - - <name of format collection> is the name of the format - collection that is applied by the action recorded by this undo - object. - - @return the rewriter for this undo object - */ - virtual SwRewriter GetRewriter() const; - - SwHistory* GetHistory() { return pHistory; } - + void SetPaM( SwPaM&, sal_Bool bCorrToCntnt = sal_False ) const; + SwPaM & AddUndoRedoPaM( + ::sw::UndoRedoContext &, bool const bCorrToCntnt = false) const; }; -class SwUndoMoveLeftMargin : public SwUndo, private SwUndRng -{ - const ::std::auto_ptr<SwHistory> m_pHistory; - const bool m_bModulus; - -public: - SwUndoMoveLeftMargin( const SwPaM&, BOOL bRight, BOOL bModulus ); - virtual ~SwUndoMoveLeftMargin(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - SwHistory& GetHistory() { return *m_pHistory; } -}; +class SwUndoInsLayFmt; -// Basis-Klasse fuer Insert von Dokument, Glossaries und Kopieren +// base class for insertion of Document, Glossaries and Copy class SwUndoInserts : public SwUndo, public SwUndRng, private SwUndoSaveCntnt { SwTxtFmtColl *pTxtFmtColl, *pLastNdColl; SvPtrarr* pFrmFmts; - SwUndos* pFlyUndos; + ::std::vector< ::boost::shared_ptr<SwUndoInsLayFmt> > m_FlyUndos; SwRedlineData* pRedlData; - BOOL bSttWasTxtNd; + sal_Bool bSttWasTxtNd; protected: - ULONG nNdDiff; + sal_uLong nNdDiff; SwPosition *pPos; // Inhalt fuers Redo - USHORT nSetPos; // Start in der History-Liste + sal_uInt16 nSetPos; // Start in der History-Liste SwUndoInserts( SwUndoId nUndoId, const SwPaM& ); public: virtual ~SwUndoInserts(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); + virtual void UndoImpl( ::sw::UndoRedoContext & ); + virtual void RedoImpl( ::sw::UndoRedoContext & ); + virtual void RepeatImpl( ::sw::RepeatContext & ); + // setze den Destination-Bereich nach dem Einlesen. - void SetInsertRange( const SwPaM&, BOOL bScanFlys = TRUE, - BOOL bSttWasTxtNd = TRUE ); + void SetInsertRange( const SwPaM&, sal_Bool bScanFlys = sal_True, + sal_Bool bSttWasTxtNd = sal_True ); }; class SwUndoInsDoc : public SwUndoInserts @@ -791,384 +272,6 @@ public: SwUndoCpyDoc( const SwPaM& ); }; -class SwUndoInsTbl : public SwUndo -{ - String sTblNm; - SwInsertTableOptions aInsTblOpts; - SwDDEFieldType* pDDEFldType; - SvUShorts* pColWidth; - SwRedlineData* pRedlData; - SwTableAutoFmt* pAutoFmt; - ULONG nSttNode; - USHORT nRows, nCols; - USHORT nAdjust; - -public: - SwUndoInsTbl( const SwPosition&, USHORT nCols, USHORT nRows, - USHORT eAdjust, const SwInsertTableOptions& rInsTblOpts, - const SwTableAutoFmt* pTAFmt, const SvUShorts* pColArr, - const String & rName); - virtual ~SwUndoInsTbl(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - virtual SwRewriter GetRewriter() const; - -}; - -class SwUndoTxtToTbl : public SwUndo, public SwUndRng -{ - String sTblNm; - SwInsertTableOptions aInsTblOpts; - SvULongs* pDelBoxes; - SwTableAutoFmt* pAutoFmt; - SwHistory* pHistory; - sal_Unicode cTrenner; - USHORT nAdjust; - BOOL bSplitEnd : 1; - -public: - SwUndoTxtToTbl( const SwPaM&, const SwInsertTableOptions&, sal_Unicode , USHORT, - const SwTableAutoFmt* pAFmt ); - virtual ~SwUndoTxtToTbl(); - - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - SwHistory& GetHistory(); // wird ggfs. angelegt - void AddFillBox( const SwTableBox& rBox ); -}; - -class SwUndoTblToTxt : public SwUndo -{ - String sTblNm; - SwDDEFieldType* pDDEFldType; - _SaveTable* pTblSave; - SwTblToTxtSaves* pBoxSaves; - SwHistory* pHistory; - ULONG nSttNd, nEndNd; - USHORT nAdjust; - sal_Unicode cTrenner; - USHORT nHdlnRpt; - BOOL bCheckNumFmt : 1; - -public: - SwUndoTblToTxt( const SwTable& rTbl, sal_Unicode cCh ); - virtual ~SwUndoTblToTxt(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - void SetRange( const SwNodeRange& ); - void AddBoxPos( SwDoc& rDoc, ULONG nNdIdx, ULONG nEndIdx, - xub_StrLen nCntntIdx = STRING_MAXLEN); -}; - -class SwUndoAttrTbl : public SwUndo -{ - ULONG nSttNode; - _SaveTable* pSaveTbl; - BOOL bClearTabCol : 1; -public: - SwUndoAttrTbl( const SwTableNode& rTblNd, BOOL bClearTabCols = FALSE ); - virtual ~SwUndoAttrTbl(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); -}; - -class SwUndoTblAutoFmt : public SwUndo -{ - ULONG nSttNode; - _SaveTable* pSaveTbl; - SwUndos* pUndos; - BOOL bSaveCntntAttr; - - void UndoRedo( BOOL bUndo, SwUndoIter& rUndoIter ); - -public: - SwUndoTblAutoFmt( const SwTableNode& rTblNd, const SwTableAutoFmt& ); - virtual ~SwUndoTblAutoFmt(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - void SaveBoxCntnt( const SwTableBox& rBox ); -}; - -class SwUndoTblNdsChg : public SwUndo -{ - _SaveTable* pSaveTbl; - SvULongs aBoxes; - - union { - SvULongs* pNewSttNds; - SwUndoSaveSections* pDelSects; - } Ptrs; - SvBools aMvBoxes; // fuers SplitRow (aufgeteilte Nodes einer Box) - long nMin, nMax; // for redo of delete column - ULONG nSttNode, nCurrBox; - USHORT nCount, nRelDiff, nAbsDiff, nSetColType; - BOOL bFlag; - BOOL bSameHeight; // only used for SplitRow -public: - SwUndoTblNdsChg( SwUndoId UndoId, - const SwSelBoxes& rBoxes, - const SwTableNode& rTblNd, - long nMn, long nMx, - USHORT nCnt, BOOL bFlg, BOOL bSameHeight ); - - // fuer SetColWidth - SwUndoTblNdsChg( SwUndoId UndoId, const SwSelBoxes& rBoxes, - const SwTableNode& rTblNd ); - - virtual ~SwUndoTblNdsChg(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - void SaveNewBoxes( const SwTableNode& rTblNd, const SwTableSortBoxes& rOld ); - void SaveNewBoxes( const SwTableNode& rTblNd, const SwTableSortBoxes& rOld, - const SwSelBoxes& rBoxes, const SvULongs& rNodeCnts ); - void SaveSection( SwStartNode* pSttNd ); - void ReNewBoxes( const SwSelBoxes& rBoxes ); - - - void SetColWidthParam( ULONG nBoxIdx, USHORT nMode, USHORT nType, - SwTwips nAbsDif, SwTwips nRelDif ) - { - nCurrBox = nBoxIdx; - nCount = nMode; - nSetColType = nType; - nAbsDiff = (USHORT)nAbsDif; - nRelDiff = (USHORT)nRelDif; - } - -}; - -class SwUndoTblMerge : public SwUndo, private SwUndRng -{ - ULONG nTblNode; - _SaveTable* pSaveTbl; - SvULongs aBoxes, aNewSttNds; - SwUndoMoves* pMoves; - SwHistory* pHistory; - -public: - SwUndoTblMerge( const SwPaM& rTblSel ); - virtual ~SwUndoTblMerge(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - void MoveBoxCntnt( SwDoc* pDoc, SwNodeRange& rRg, SwNodeIndex& rPos ); - - void SetSelBoxes( const SwSelBoxes& rBoxes ); - - void AddNewBox( ULONG nSttNdIdx ) - { aNewSttNds.Insert( nSttNdIdx, aNewSttNds.Count() ); } - - void SaveCollection( const SwTableBox& rBox ); - -}; - - -class SwUndoTblNumFmt : public SwUndo -{ - SfxItemSet *pBoxSet; - SwHistory* pHistory; - String aStr, aNewFml; - - ULONG nFmtIdx, nNewFmtIdx; - double fNum, fNewNum; - ULONG nNode; - ULONG nNdPos; - - BOOL bNewFmt : 1; - BOOL bNewFml : 1; - BOOL bNewValue : 1; - -public: - SwUndoTblNumFmt( const SwTableBox& rBox, const SfxItemSet* pNewSet = 0 ); - virtual ~SwUndoTblNumFmt(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - void SetNumFmt( ULONG nNewNumFmtIdx, const double& rNewNumber ) - { nFmtIdx = nNewNumFmtIdx; fNum = rNewNumber; } - void SetBox( const SwTableBox& rBox ); -}; - -class _UndoTblCpyTbl_Entries; - -class SwUndoTblCpyTbl : public SwUndo -{ - _UndoTblCpyTbl_Entries* pArr; - SwUndoTblNdsChg* pInsRowUndo; - - //b6341295: When redlining is active, PrepareRedline has to create the redlining attributes - //for the new and the old table cell content - SwUndo* PrepareRedline( SwDoc* pDoc, const SwTableBox& rBox, const SwPosition& rPos, - bool& rJoin, bool bRedo ); -public: - SwUndoTblCpyTbl(); - virtual ~SwUndoTblCpyTbl(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - void AddBoxBefore( const SwTableBox& rBox, BOOL bDelCntnt ); - void AddBoxAfter( const SwTableBox& rBox, const SwNodeIndex& rIdx, BOOL bDelCntnt ); - - BOOL IsEmpty() const; - BOOL InsertRow( SwTable& rTbl, const SwSelBoxes& rBoxes, USHORT nCnt ); -}; - -class SwUndoCpyTbl : public SwUndo -{ - SwUndoDelete* pDel; - ULONG nTblNode; -public: - SwUndoCpyTbl(); - virtual ~SwUndoCpyTbl(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - void SetTableSttIdx( ULONG nIdx ) { nTblNode = nIdx; } -}; - -class SwUndoSplitTbl : public SwUndo -{ - ULONG nTblNode, nOffset; - SwSaveRowSpan* mpSaveRowSpan; // stores the row span values at the splitting row - _SaveTable* pSavTbl; - SwHistory* pHistory; - USHORT nMode, nFmlEnd; - BOOL bCalcNewSize; -public: - SwUndoSplitTbl( const SwTableNode& rTblNd, SwSaveRowSpan* pRowSp, USHORT nMode, BOOL bCalcNewSize ); - virtual ~SwUndoSplitTbl(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - void SetTblNodeOffset( ULONG nIdx ) { nOffset = nIdx - nTblNode; } - SwHistory* GetHistory() { return pHistory; } - void SaveFormula( SwHistory& rHistory ); -}; - -class SwUndoMergeTbl : public SwUndo -{ - String aName; - ULONG nTblNode; - _SaveTable* pSavTbl, *pSavHdl; - SwHistory* pHistory; - USHORT nMode; - BOOL bWithPrev; -public: - SwUndoMergeTbl( const SwTableNode& rTblNd, const SwTableNode& rDelTblNd, - BOOL bWithPrev, USHORT nMode ); - virtual ~SwUndoMergeTbl(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - void SaveFormula( SwHistory& rHistory ); -}; - - -class SwUndoBookmark : public SwUndo -{ - const ::std::auto_ptr<SwHistoryBookmark> m_pHistoryBookmark; - -protected: - SwUndoBookmark( SwUndoId nUndoId, const ::sw::mark::IMark& ); - - void SetInDoc( SwDoc* ); - void ResetInDoc( SwDoc* ); - -public: - virtual ~SwUndoBookmark(); - - // #111827# - /** - Returns the rewriter for this undo object. - - The rewriter contains the following rule: - - $1 -> <name of bookmark> - - <name of bookmark> is the name of the bookmark whose - insertion/deletion is recorded by this undo object. - - @return the rewriter for this undo object - */ - virtual SwRewriter GetRewriter() const; -}; - - -class SwUndoInsBookmark : public SwUndoBookmark -{ -public: - SwUndoInsBookmark( const ::sw::mark::IMark& ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); -}; - - -/*-------------------------------------------------------------------- - Beschreibung: Undo auf Sorting - --------------------------------------------------------------------*/ - -struct SwSortUndoElement -{ - union { - struct { - ULONG nKenn; - ULONG nSource, nTarget; - } TXT; - struct { - String *pSource, *pTarget; - } TBL; - } SORT_TXT_TBL; - - SwSortUndoElement( const String& aS, const String& aT ) - { - SORT_TXT_TBL.TBL.pSource = new String( aS ); - SORT_TXT_TBL.TBL.pTarget = new String( aT ); - } - SwSortUndoElement( ULONG nS, ULONG nT ) - { - SORT_TXT_TBL.TXT.nSource = nS; - SORT_TXT_TBL.TXT.nTarget = nT; - SORT_TXT_TBL.TXT.nKenn = 0xffffffff; - } - ~SwSortUndoElement(); -}; - -SV_DECL_PTRARR_DEL(SwSortList, SwSortUndoElement*, 10,30) -SV_DECL_PTRARR(SwUndoSortList, SwNodeIndex*, 10,30) - -class SwUndoSort : public SwUndo, private SwUndRng -{ - SwSortOptions* pSortOpt; // die Optionen mit den Sortier-Kriterien - SwSortList aSortList; - SwUndoAttrTbl* pUndoTblAttr; - SwRedlineData* pRedlData; - ULONG nTblNd; - - void RemoveIdx( SwPaM& rPam ); -public: - SwUndoSort( const SwPaM&, const SwSortOptions& ); - SwUndoSort( ULONG nStt, ULONG nEnd, const SwTableNode&, - const SwSortOptions&, BOOL bSaveTable ); - virtual ~SwUndoSort(); - - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - void Insert( const String& rOrgPos, const String& rNewPos ); - void Insert( ULONG nOrgPos, ULONG nNewPos ); - -}; - //-------------------------------------------------------------------- @@ -1177,38 +280,36 @@ class SwUndoFlyBase : public SwUndo, private SwUndoSaveSection { protected: SwFrmFmt* pFrmFmt; // das gespeicherte FlyFormat - ULONG nNdPgPos; + sal_uLong nNdPgPos; xub_StrLen nCntPos; // Seite/am Absatz/im Absatz - USHORT nRndId; - BOOL bDelFmt; // loesche das gespeicherte Format + sal_uInt16 nRndId; + sal_Bool bDelFmt; // loesche das gespeicherte Format - void InsFly( SwUndoIter&, BOOL bShowSel = TRUE ); + void InsFly(::sw::UndoRedoContext & rContext, bool bShowSel = true); void DelFly( SwDoc* ); SwUndoFlyBase( SwFrmFmt* pFormat, SwUndoId nUndoId ); SwNodeIndex* GetMvSttIdx() const { return SwUndoSaveSection::GetMvSttIdx(); } - ULONG GetMvNodeCnt() const { return SwUndoSaveSection::GetMvNodeCnt(); } + sal_uLong GetMvNodeCnt() const { return SwUndoSaveSection::GetMvNodeCnt(); } public: virtual ~SwUndoFlyBase(); - virtual void Undo( SwUndoIter& ) = 0; - virtual void Redo( SwUndoIter& ) = 0; - }; class SwUndoInsLayFmt : public SwUndoFlyBase { - ULONG mnCrsrSaveIndexPara; // Cursor position + sal_uLong mnCrsrSaveIndexPara; // Cursor position xub_StrLen mnCrsrSaveIndexPos; // for undo public: - SwUndoInsLayFmt( SwFrmFmt* pFormat, ULONG nNodeIdx, xub_StrLen nCntIdx ); - ~SwUndoInsLayFmt(); + SwUndoInsLayFmt( SwFrmFmt* pFormat, sal_uLong nNodeIdx, xub_StrLen nCntIdx ); + + virtual ~SwUndoInsLayFmt(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); + virtual void UndoImpl( ::sw::UndoRedoContext & ); + virtual void RedoImpl( ::sw::UndoRedoContext & ); + virtual void RepeatImpl( ::sw::RepeatContext & ); String GetComment() const; @@ -1216,704 +317,19 @@ public: class SwUndoDelLayFmt : public SwUndoFlyBase { - BOOL bShowSelFrm; + sal_Bool bShowSelFrm; public: SwUndoDelLayFmt( SwFrmFmt* pFormat ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - void Redo(); // Schnittstelle fuers Rollback - - void ChgShowSel( BOOL bNew ) { bShowSelFrm = bNew; } - - virtual SwRewriter GetRewriter() const; - -}; - - -class SwUndoSetFlyFmt : public SwUndo, public SwClient -{ - SwFrmFmt* pFrmFmt; // das gespeicherte FlyFormat - SwFrmFmt* pOldFmt; // die alte Fly Vorlage - SwFrmFmt* pNewFmt; // die neue Fly Vorlage - SfxItemSet* pItemSet; // die zurueck-/ gesetzten Attribute - ULONG nOldNode, nNewNode; - xub_StrLen nOldCntnt, nNewCntnt; - USHORT nOldAnchorTyp, nNewAnchorTyp; - BOOL bAnchorChgd; - - void PutAttr( USHORT nWhich, const SfxPoolItem* pItem ); - void Modify( SfxPoolItem*, SfxPoolItem* ); - void GetAnchor( SwFmtAnchor& rAnhor, ULONG nNode, xub_StrLen nCntnt ); - -public: - SwUndoSetFlyFmt( SwFrmFmt& rFlyFmt, SwFrmFmt& rNewFrmFmt ); - virtual ~SwUndoSetFlyFmt(); - - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - virtual SwRewriter GetRewriter() const; -}; - -//-------------------------------------------------------------------- - -class _UnReplaceData; -SV_DECL_PTRARR_DEL( _UnReplaceDatas, _UnReplaceData*, 10, 25 ) - -class SwUndoReplace : public SwUndo -{ - friend class SwDoc; - - BOOL bOldIterFlag; // Status vom Undo-Iter vorm 1. Aufruf - USHORT nAktPos; // fuer GetUndoRange und Undo/Redo - _UnReplaceDatas aArr; - SwRedlineData* pRedlData; - -public: - SwUndoReplace(); - virtual ~SwUndoReplace(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - // #111827# - /** - Returns the rewriter of this undo object. - - If this undo object represents several replacements the - rewriter contains the following rules: - - $1 -> <number of replacements> - $2 -> occurrences of - $3 -> <replaced text> - - If this undo object represents one replacement the rewriter - contains these rules: - - $1 -> <replaced text> - $2 -> "->" (STR_YIELDS) - $3 -> <replacing text> - - @return the rewriter of this undo object - */ - virtual SwRewriter GetRewriter() const; - - void AddEntry( const SwPaM& rPam, const String& rInsert, BOOL bRegExp ); - void SetEntryEnd( const SwPaM& rPam ); - - BOOL IsFull() const - { return ((USHRT_MAX / sizeof( void* )) - 50 ) < aArr.Count(); } - -}; - - -//-------------------------------------------------------------------- - - -class SwUndoTblHeadline : public SwUndo -{ - ULONG nTblNd; - USHORT nOldHeadline; - USHORT nNewHeadline; -public: - SwUndoTblHeadline( const SwTable&, USHORT nOldHdl, USHORT nNewHdl ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); -}; - - -//------------ Undo von Insert-/Delete-Sections ---------------------- - -class SwUndoInsSection : public SwUndo, private SwUndRng -{ -private: - const ::std::auto_ptr<SwSectionData> m_pSectionData; - const ::std::auto_ptr<SwTOXBase> m_pTOXBase; /// set iff section is TOX - const ::std::auto_ptr<SfxItemSet> m_pAttrSet; - ::std::auto_ptr<SwHistory> m_pHistory; - ::std::auto_ptr<SwRedlineData> m_pRedlData; - ULONG m_nSectionNodePos; - bool m_bSplitAtStart : 1; - bool m_bSplitAtEnd : 1; - bool m_bUpdateFtn : 1; - - void Join( SwDoc& rDoc, ULONG nNode ); - -public: - SwUndoInsSection(SwPaM const&, SwSectionData const&, - SfxItemSet const*const pSet, SwTOXBase const*const pTOXBase); - virtual ~SwUndoInsSection(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - void SetSectNdPos(ULONG const nPos) { m_nSectionNodePos = nPos; } - void SaveSplitNode(SwTxtNode *const pTxtNd, bool const bAtStart); - void SetUpdtFtnFlag(bool const bFlag) { m_bUpdateFtn = bFlag; } -}; - -SW_DLLPRIVATE SwUndo * MakeUndoDelSection(SwSectionFmt const&); - -SW_DLLPRIVATE SwUndo * MakeUndoUpdateSection(SwSectionFmt const&, bool const); - - -//------------ Undo von verschieben/stufen von Gliederung ---------------- - -class SwUndoOutlineLeftRight : public SwUndo, private SwUndRng -{ - short nOffset; -public: - SwUndoOutlineLeftRight( const SwPaM& rPam, short nOffset ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); -}; - -//-------------------------------------------------------------------- - -class SwUndoDefaultAttr : public SwUndo -{ - ::std::auto_ptr<SfxItemSet> m_pOldSet; // the old attributes - ::std::auto_ptr<SvxTabStopItem> m_pTabStop; + virtual void UndoImpl( ::sw::UndoRedoContext & ); + virtual void RedoImpl( ::sw::UndoRedoContext & ); -public: - // registers at the format and saves old attributes - SwUndoDefaultAttr( const SfxItemSet& rOldSet ); - virtual ~SwUndoDefaultAttr(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); -}; + void RedoForRollback(); -//-------------------------------------------------------------------- -// ---------- Undo fuer Numerierung ---------------------------------- + void ChgShowSel( sal_Bool bNew ) { bShowSelFrm = bNew; } -class SwUndoInsNum : public SwUndo, private SwUndRng -{ - SwNumRule aNumRule; - SwHistory* pHistory; - ULONG nSttSet; - SwNumRule* pOldNumRule; - String sReplaceRule; - USHORT nLRSavePos; -public: - SwUndoInsNum( const SwPaM& rPam, const SwNumRule& rRule ); - SwUndoInsNum( const SwNumRule& rOldRule, const SwNumRule& rNewRule, - SwUndoId nUndoId = UNDO_INSFMTATTR ); - SwUndoInsNum( const SwPosition& rPos, const SwNumRule& rRule, - const String& rReplaceRule ); - virtual ~SwUndoInsNum(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); virtual SwRewriter GetRewriter() const; - SwHistory* GetHistory(); // wird ggfs. neu angelegt! - void SetSttNum( ULONG nNdIdx ) { nSttSet = nNdIdx; } - void SaveOldNumRule( const SwNumRule& rOld ); - - void SetLRSpaceEndPos(); - -}; - -class SwUndoDelNum : public SwUndo, private SwUndRng -{ - SvULongs aNodeIdx; - SvBytes aLevels; - SvBools aRstLRSpaces; - SwHistory* pHistory; -public: - SwUndoDelNum( const SwPaM& rPam ); - virtual ~SwUndoDelNum(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - void AddNode( const SwTxtNode& rNd, BOOL bResetLRSpace ); - SwHistory* GetHistory() { return pHistory; } - -}; - -class SwUndoMoveNum : public SwUndo, private SwUndRng -{ - ULONG nNewStt; - long nOffset; -public: - SwUndoMoveNum( const SwPaM& rPam, long nOffset, BOOL bIsOutlMv = FALSE ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - void SetStartNode( ULONG nValue ) { nNewStt = nValue; } -}; - -class SwUndoNumUpDown : public SwUndo, private SwUndRng -{ - short nOffset; -public: - SwUndoNumUpDown( const SwPaM& rPam, short nOffset ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); -}; - -class SwUndoNumOrNoNum : public SwUndo -{ - ULONG nIdx; - BOOL mbNewNum, mbOldNum; - -public: - SwUndoNumOrNoNum( const SwNodeIndex& rIdx, BOOL mbOldNum, - BOOL mbNewNum ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); -}; - -class SwUndoNumRuleStart : public SwUndo -{ - ULONG nIdx; - USHORT nOldStt, nNewStt; - BOOL bSetSttValue : 1; - BOOL bFlag : 1; -public: - SwUndoNumRuleStart( const SwPosition& rPos, BOOL bDelete ); - SwUndoNumRuleStart( const SwPosition& rPos, USHORT nStt ); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); -}; - -//-------------------------------------------------------------------- -// ---------- Undo fuer DrawObjecte ---------------------------------- - -class SwSdrUndo : public SwUndo -{ - SdrUndoAction* pSdrUndo; - SdrMarkList* pMarkList; // MarkList for all selected SdrObjects -public: - SwSdrUndo( SdrUndoAction* , const SdrMarkList* pMarkList ); - virtual ~SwSdrUndo(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - String GetComment() const; }; -class SwUndoDrawGroup : public SwUndo -{ - SwUndoGroupObjImpl* pObjArr; - USHORT nSize; - BOOL bDelFmt; - -public: - SwUndoDrawGroup( USHORT nCnt ); - virtual ~SwUndoDrawGroup(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - void AddObj( USHORT nPos, SwDrawFrmFmt*, SdrObject* ); - void SetGroupFmt( SwDrawFrmFmt* ); -}; - -// --> OD 2006-11-01 #130889# -// Action "ungroup drawing object" is now splitted into three parts - see -// method <SwDoc::UnGroupSelection(..)>: -// - creation for <SwDrawFrmFmt> instances for the group members of the -// selected group objects -// - intrinsic ungroup of the selected group objects -// - creation of <SwDrawContact> instances for the former group members and -// connection to the Writer layout. -// Thus, two undo actions (instances of <SwUndo>) are needed: -// - Existing class <SwUndoDrawUnGroup> takes over the part for the formats. -// - New class <SwUndoDrawUnGroupConnectToLayout> takes over the part for -// contact object. -class SwUndoDrawUnGroup : public SwUndo -{ - SwUndoGroupObjImpl* pObjArr; - USHORT nSize; - BOOL bDelFmt; - -public: - SwUndoDrawUnGroup( SdrObjGroup* ); - virtual ~SwUndoDrawUnGroup(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - void AddObj( USHORT nPos, SwDrawFrmFmt* ); -}; - -// --> OD 2006-11-01 #130889# -class SwUndoDrawUnGroupConnectToLayout : public SwUndo -{ - private: - std::vector< std::pair< SwDrawFrmFmt*, SdrObject* > > aDrawFmtsAndObjs; - - public: - SwUndoDrawUnGroupConnectToLayout(); - virtual ~SwUndoDrawUnGroupConnectToLayout(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - void AddFmtAndObj( SwDrawFrmFmt* pDrawFrmFmt, - SdrObject* pDrawObject ); -}; -// <-- - - -class SwUndoDrawDelete : public SwUndo -{ - SwUndoGroupObjImpl* pObjArr; - SdrMarkList* pMarkLst; // MarkList for all selected SdrObjects - USHORT nSize; - BOOL bDelFmt; - -public: - SwUndoDrawDelete( USHORT nCnt ); - virtual ~SwUndoDrawDelete(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - void AddObj( USHORT nPos, SwDrawFrmFmt*, const SdrMark& ); -}; - -//-------------------------------------------------------------------- - -class SwUndoReRead : public SwUndo -{ - Graphic *pGrf; - String *pNm, *pFltr; - ULONG nPos; - USHORT nMirr; - - void SaveGraphicData( const SwGrfNode& ); - void SetAndSave( SwUndoIter& ); - -public: - SwUndoReRead( const SwPaM& rPam, const SwGrfNode& pGrfNd ); - virtual ~SwUndoReRead(); - - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); -}; - -//-------------------------------------------------------------------- - -class SwUndoInsertLabel : public SwUndo -{ - union { - struct { - // fuer NoTxtFrms - SwUndoInsLayFmt* pUndoFly; - SwUndoFmtAttr* pUndoAttr; - } OBJECT; - struct { - // fuer Tabelle/TextRahmen - SwUndoDelete* pUndoInsNd; - ULONG nNode; - } NODE; - }; - - String sText; - // --> PB 2005-01-06 #i39983# - the separator will be drawed with a character style - String sSeparator; - // <-- - String sNumberSeparator; - String sCharacterStyle; - // OD 2004-04-15 #i26791# - re-store of drawing object position no longer needed - USHORT nFldId; - SwLabelType eType; - BYTE nLayerId; // fuer Zeichen-Objekte - BOOL bBefore :1; - BOOL bUndoKeep :1; - BOOL bCpyBrd :1; - -public: - SwUndoInsertLabel( const SwLabelType eTyp, const String &rText, - // --> PB 2005-01-06 #i39983# - the separator will be drawed with a character style - const String& rSeparator, - // <-- - const String& rNumberSeparator, //#i61007# order of captions - const BOOL bBefore, const USHORT nId, - const String& rCharacterStyle, - const BOOL bCpyBrd ); - virtual ~SwUndoInsertLabel(); - - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - // #111827# - /** - Returns the rewriter of this undo object. - - The rewriter contains this rule: - - $1 -> '<text of inserted label>' - - <text of inserted label> is shortened to nUndoStringLength - characters. - - @return the rewriter of this undo object - */ - virtual SwRewriter GetRewriter() const; - - void SetNodePos( ULONG nNd ) - { if( LTYPE_OBJECT != eType ) NODE.nNode = nNd; } - - void SetUndoKeep() { bUndoKeep = TRUE; } - void SetFlys( SwFrmFmt& rOldFly, SfxItemSet& rChgSet, SwFrmFmt& rNewFly ); - void SetDrawObj( BYTE nLayerId ); -}; - -//-------------------------------------------------------------------- - -class SwUndoChangeFootNote : public SwUndo, private SwUndRng -{ - const ::std::auto_ptr<SwHistory> m_pHistory; - const String m_Text; - const USHORT m_nNumber; - const bool m_bEndNote; - -public: - SwUndoChangeFootNote( const SwPaM& rRange, const String& rTxt, - USHORT nNum, bool bIsEndNote ); - virtual ~SwUndoChangeFootNote(); - - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - virtual void Repeat( SwUndoIter& ); - - SwHistory& GetHistory() { return *m_pHistory; } -}; - -class SwUndoFootNoteInfo : public SwUndo -{ - ::std::auto_ptr<SwFtnInfo> m_pFootNoteInfo; - -public: - SwUndoFootNoteInfo( const SwFtnInfo &rInfo ); - virtual ~SwUndoFootNoteInfo(); - - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); -}; - -class SwUndoEndNoteInfo : public SwUndo -{ - ::std::auto_ptr<SwEndNoteInfo> m_pEndNoteInfo; - -public: - SwUndoEndNoteInfo( const SwEndNoteInfo &rInfo ); - virtual ~SwUndoEndNoteInfo(); - - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); -}; - - -//-------------------------------------------------------------------- - -struct _UndoTransliterate_Data; -class SwUndoTransliterate : public SwUndo, public SwUndRng -{ - std::vector< _UndoTransliterate_Data * > aChanges; - sal_uInt32 nType; - -public: - SwUndoTransliterate( const SwPaM& rPam, - const utl::TransliterationWrapper& rTrans ); - virtual ~SwUndoTransliterate(); - - virtual void Undo( SwUndoIter& rUndoIter ); - virtual void Redo( SwUndoIter& rUndoIter ); - virtual void Repeat( SwUndoIter& rUndoIter ); - - void AddChanges( SwTxtNode& rTNd, xub_StrLen nStart, xub_StrLen nLen, - ::com::sun::star::uno::Sequence <sal_Int32>& rOffsets ); - BOOL HasData() const { return aChanges.size() > 0; } -}; - -//-------------------------------------------------------------------- - -class SwUndoRedline : public SwUndo, public SwUndRng -{ -protected: - SwRedlineData* pRedlData; - SwRedlineSaveDatas* pRedlSaveData; - SwUndoId nUserId; - BOOL bHiddenRedlines; - - virtual void _Undo( SwUndoIter& ); - virtual void _Redo( SwUndoIter& ); - -public: - SwUndoRedline( SwUndoId nUserId, const SwPaM& rRange ); - virtual ~SwUndoRedline(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); - - SwUndoId GetUserId() const { return nUserId; } - USHORT GetRedlSaveCount() const - { return pRedlSaveData ? pRedlSaveData->Count() : 0; } -}; - -class SwUndoRedlineDelete : public SwUndoRedline -{ - BOOL bCanGroup : 1; - BOOL bIsDelim : 1; - BOOL bIsBackspace : 1; - - virtual void _Undo( SwUndoIter& ); - virtual void _Redo( SwUndoIter& ); - -public: - SwUndoRedlineDelete( const SwPaM& rRange, SwUndoId nUserId = UNDO_EMPTY ); - - BOOL CanGrouping( const SwUndoRedlineDelete& rPrev ); -}; - -class SwUndoRedlineSort : public SwUndoRedline -{ - SwSortOptions* pOpt; - ULONG nSaveEndNode, nOffset; - xub_StrLen nSaveEndCntnt; - - virtual void _Undo( SwUndoIter& ); - virtual void _Redo( SwUndoIter& ); - -public: - SwUndoRedlineSort( const SwPaM& rRange, const SwSortOptions& rOpt ); - virtual ~SwUndoRedlineSort(); - virtual void Repeat( SwUndoIter& ); - - void SetSaveRange( const SwPaM& rRange ); - void SetOffset( const SwNodeIndex& rIdx ); -}; - -class SwUndoAcceptRedline : public SwUndoRedline -{ - virtual void _Redo( SwUndoIter& ); -public: - SwUndoAcceptRedline( const SwPaM& rRange ); - virtual void Repeat( SwUndoIter& ); -}; - -class SwUndoRejectRedline : public SwUndoRedline -{ - virtual void _Redo( SwUndoIter& ); -public: - SwUndoRejectRedline( const SwPaM& rRange ); - virtual void Repeat( SwUndoIter& ); -}; - -//-------------------------------------------------------------------- - -class SwUndoCompDoc : public SwUndo, public SwUndRng -{ - SwRedlineData* pRedlData; - SwUndoDelete* pUnDel, *pUnDel2; - SwRedlineSaveDatas* pRedlSaveData; - BOOL bInsert; -public: - SwUndoCompDoc( const SwPaM& rRg, BOOL bIns ); - SwUndoCompDoc( const SwRedline& rRedl ); - - virtual ~SwUndoCompDoc(); - virtual void Undo( SwUndoIter& ); - virtual void Redo( SwUndoIter& ); -}; - - -//-------------------------------------------------------------------- - -// Object der als Iterator durch die Undo-Liste laeuft, bis die -// letze oder die angegebene Klammerung/Id erreicht ist. - -class SwUndoIter -{ - friend class SwDoc; // um im SwDoc::Undo bWeiter zu stezen - friend void SwUndoEnd::Undo( SwUndoIter& ); - friend void SwUndoStart::Undo( SwUndoIter& ); - friend void SwUndoEnd::Redo( SwUndoIter& ); - friend void SwUndoStart::Redo( SwUndoIter& ); - friend void SwUndoEnd::Repeat( SwUndoIter& ); - friend void SwUndoStart::Repeat( SwUndoIter& ); - friend void SwUndoReplace::Undo( SwUndoIter& ); - friend void SwUndoReplace::Redo( SwUndoIter& ); - - SwUndoId nUndoId; - USHORT nEndCnt; - BOOL bWeiter : 1; - BOOL bUpdateAttr : 1; // Setze das GCAttr an der CursorShell - -public: - SwPaM * pAktPam; // Member fuer das Undo - SwUndo* pLastUndoObj; // fuers Redo, das vorherige UndoObj. - SwFrmFmt* pSelFmt; // ggfs. das Format Rahmen/Object-Selektionen - SdrMarkList* pMarkList; // MarkList for all selected SdrObjects - - SwUndoIter( SwPaM * pPam, SwUndoId nId = UNDO_EMPTY ); - - BOOL IsNextUndo() const { return bWeiter; } - BOOL IsUpdateAttr() const { return bUpdateAttr; } - void SetUpdateAttr( BOOL bNew ) { bUpdateAttr = bNew; } - - inline SwDoc& GetDoc() const; - SwUndoId GetId() const { return nUndoId; } - SwUndoId GetLastUndoId() const - { return pLastUndoObj ? pLastUndoObj->GetId() : UNDO_EMPTY ; } - void ClearSelections() { pSelFmt = 0; pMarkList = 0; } -}; - - -// -> #111827# -const int nUndoStringLength = 20; - -/** - Shortens a string to a maximum length. - - @param rStr the string to be shortened - @param nLength the maximum length for rStr - @param rFillStr string to replace cut out characters with - - If rStr has less than nLength characters it will be returned unaltered. - - If rStr has more than nLength characters the following algorithm - generates the shortened string: - - frontLength = (nLength - length(rFillStr)) / 2 - rearLength = nLength - length(rFillStr) - frontLength - shortenedString = concat(<first frontLength characters of rStr, - rFillStr, - <last rearLength characters of rStr>) - - Preconditions: - - nLength - length(rFillStr) >= 2 - - @return the shortened string - */ -String ShortenString(const String & rStr, xub_StrLen nLength, const String & rFillStr); -// <- #111827# - -// #16487# -/** - Denotes special characters in a string. - - The rStr is split into parts containing special characters and - parts not containing special characters. In a part containing - special characters all characters are equal. These parts are - maximal. - - @param rStr the string to denote in - - The resulting string is generated by concatenating the found - parts. The parts without special characters are surrounded by - "'". The parts containing special characters are denoted as "n x", - where n is the length of the part and x is the representation of - the special character (i. e. "tab(s)"). - - @return the denoted string -*/ -String DenoteSpecialCharacters(const String & rStr); - #endif |