diff options
Diffstat (limited to 'sw/inc/undobj.hxx')
| -rw-r--r-- | sw/inc/undobj.hxx | 1624 |
1 files changed, 1624 insertions, 0 deletions
diff --git a/sw/inc/undobj.hxx b/sw/inc/undobj.hxx new file mode 100644 index 000000000000..6064c6377af2 --- /dev/null +++ b/sw/inc/undobj.hxx @@ -0,0 +1,1624 @@ +/************************************************************************* + * + * $RCSfile: undobj.hxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:14:29 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ +#ifndef _UNDOBJ_HXX +#define _UNDOBJ_HXX + +#ifndef _SVMEMPOOL_HXX //autogen +#include <tools/mempool.hxx> +#endif +#ifndef _SVSTDARR_HXX +#define _SVSTDARR_USHORTS +#define _SVSTDARR_ULONGS +#define _SVSTDARR_BOOLS +#define _SVSTDARR_BYTES +#define _SVSTDARR_USHORTSSORT +#include <svtools/svstdarr.hxx> +#endif +#ifndef _SFXITEMSET_HXX //autogen +#include <svtools/itemset.hxx> +#endif +#ifndef _NUMRULE_HXX +#include <numrule.hxx> +#endif +#ifndef _REDLENUM_HXX +#include <redlenum.hxx> +#endif + +class SwUndoIter; +class SwHistory; + +class SwIndex; +class SwPaM; +struct SwPosition; +class SwDoc; +class SwNodes; +class SwFmt; +class SwFmtColl; +class SwTxtFmtColl; +class SwTxtNode; +class SwpHints; +class SwBookmark; +class SwTableNode; +class SwTable; +class SwTableBox; +struct SwSortOptions; +class SwFrmFmt; +class SwHstryBookmark; +class SwSection; +class SwSectionFmt; +class SvxTabStopItem; +class SwNumSection; +class SwDDEFieldType; +class Graphic; +class SwGrfNode; +class SwUndos; +class SwUndoRange; +class SwFtnInfo; +class SwEndNoteInfo; +class SwNodeIndex; +class SwNodeRange; + +struct SwUndoGroupObjImpl; +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; + +#ifndef PRODUCT +class Writer; +class SwUndo; +#define OUT_UNDOBJ( name ) \ + friend Writer& OutUndo_ ## name( Writer&, const SwUndo& ); +#else +#define OUT_UNDOBJ( name ) +#endif + + +typedef SwRedlineSaveData* SwRedlineSaveDataPtr; +SV_DECL_PTRARR_DEL( SwRedlineSaveDatas, SwRedlineSaveDataPtr, 8, 8 ) + +class SwUndo +{ + USHORT nId; + USHORT nOrigRedlineMode; +protected: + void RemoveIdxFromSection( SwDoc&, ULONG nSttIdx, ULONG* pEndIdx = 0 ); + void RemoveIdxFromRange( SwPaM& rPam, BOOL bMoveNext ); + void RemoveIdxRel( ULONG, const SwPosition& ); + + void SetId( USHORT nNew ) { nId = nNew; } + + static BOOL CanRedlineGroup( SwRedlineSaveDatas& rCurr, + const SwRedlineSaveDatas& rCheck, + BOOL bCurrIsEnd ); +public: + SwUndo( USHORT nI ) { nId = nI; nOrigRedlineMode = REDLINE_NONE; } + virtual ~SwUndo(); + + USHORT GetId() const { return nId; } + virtual void Undo( SwUndoIter& ) = 0; + virtual void Redo( SwUndoIter& ) = 0; + virtual void Repeat( SwUndoIter& ); + + // 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; } + + // 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 void SetSaveData( SwDoc& rDoc, const SwRedlineSaveDatas& rSData ); + static BOOL HasHiddenRedlines( const SwRedlineSaveDatas& rSData ); +}; + + +// diese Klasse muss in ein Undo-Object vererbt werden, wenn dieses Inhalt +// fuers Redo/Undo ... speichert +class SwUndoSaveCntnt +{ +protected: + + SwHistory* pHistory; + + // wird fuer das loeschen von Inhalt benoetigt. Fuer das ReDo werden + // Inhalte in das UndoNodesArray verschoben. Diese Methoden fuegen + // am Ende eines TextNodes ein Trenner fuer die Attribute. Damit werden + // Attribute nicht expandiert. + // MoveTo.. verschiebt aus dem NodesArray in das UndoNodesArray + // 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, + SwPosition& rInsPos, + 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 ); + + // vor dem Move ins UndoNodes-Array muss dafuer gesorgt werden, das + // die Inhaltstragenden Attribute aus dem Nodes-Array entfernt werden. + enum DelCntntType{ DELCNT_FTN = 0x01, + DELCNT_FLY = 0x02, + DELCNT_TOC = 0x04, + DELCNT_BKM = 0x08, + DELCNT_ALL = 0x0F, + DELCNT_CHKNOCNTNT = 0x80 // nur den NodeIndex beachten + }; + void DelCntntIndex( const SwPosition& pMark, const SwPosition& pPoint, + DelCntntType nDelCntntType = DELCNT_ALL ); + +public: + SwUndoSaveCntnt(); + ~SwUndoSaveCntnt(); + OUT_UNDOBJ( SaveCntnt ) +}; + + +// sicher eine vollstaendige Section im Nodes-Array +class SwUndoSaveSection : private SwUndoSaveCntnt +{ + SwNodeIndex *pMvStt; + SwRedlineSaveDatas* pRedlSaveData; + ULONG nMvLen; // Index ins UndoNodes-Array + ULONG nStartPos; + +protected: + SwNodeIndex* GetMvSttIdx() const { return pMvStt; } + ULONG GetMvNodeCnt() const { return nMvLen; } + +public: + SwUndoSaveSection(); + ~SwUndoSaveSection(); + + 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, const SwNodeIndex& rInsPos ); + + const SwHistory* GetHistory() const { return pHistory; } + SwHistory* GetHistory() { return pHistory; } + OUT_UNDOBJ( SaveSection ) +}; + + +// Diese Klasse speichert den Pam als USHORT's und kann diese wieder zu +// einem PaM zusammensetzen +class SwUndRng +{ +public: + 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. + USHORT nUserId; + // fuer die "Verpointerung" von Start- und End-Undos + USHORT nEndOffset; +public: + SwUndoStart( USHORT nId ); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + USHORT GetUserId() const { return nUserId; } + // Setzen vom End-Undo-Offset geschieht im Doc::EndUndo + USHORT GetEndOffset() const { return nEndOffset; } + void SetEndOffset( USHORT n ) { nEndOffset = n; } + OUT_UNDOBJ( Start ) +}; + +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. + USHORT nUserId; + // fuer die "Verpointerung" von Start- und End-Undos + USHORT nSttOffset; +public: + SwUndoEnd( USHORT nId ); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + USHORT GetUserId() const { return nUserId; } + // Setzen vom Start-Undo-Offset geschieht im Doc::EndUndo + USHORT GetSttOffset() const { return nSttOffset; } + void SetSttOffset( USHORT n ) { nSttOffset = n; } + OUT_UNDOBJ( End ) +}; + +class SwUndoInsert: public SwUndo, private SwUndoSaveCntnt +{ + SwPosition *pPos; // Inhalt fuers Redo + String* pTxt; + SwRedlineData* pRedlData; + ULONG nNode; + xub_StrLen nCntnt, nLen; + BOOL bIsWordDelim : 1; + BOOL bIsAppend : 1; + + friend class SwDoc; // eigentlich nur SwDoc::Insert( String ) + BOOL CanGrouping( sal_Unicode cIns ); + BOOL CanGrouping( const SwPosition& rPos ); + +public: + SwUndoInsert( const SwNodeIndex& rNode, xub_StrLen nCntnt, xub_StrLen nLen, + BOOL bWDelim = TRUE ); + SwUndoInsert( const SwNodeIndex& rNode ); + virtual ~SwUndoInsert(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + + BOOL CanGrouping( const SwPosition&, sal_Unicode cIns ); + OUT_UNDOBJ( Insert ) + + 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; + + ULONG nNode; + ULONG nNdDiff; // Differenz von Nodes vor-nach Delete + ULONG nSectDiff; // Diff. von Nodes vor/nach Move mit SectionNodes + 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 bSectNdFnd : 1; // TRUE: Sonderbehandlung fuer SectionNodes + BOOL bMvAroundSectNd :1;// TRUE: Sonderbehandlung fuer SectionNodes + 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 SaveCntnt( const SwPosition* pStt, const SwPosition* pEnd, + SwTxtNode* pSttTxtNd, SwTxtNode* pEndTxtNd ); +public: + SwUndoDelete( SwPaM&, BOOL bFullPara = FALSE ); + virtual ~SwUndoDelete(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + 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; } + + OUT_UNDOBJ( Delete ) + + 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& ); + BOOL CanGrouping( SwDoc*, SwPosition&, sal_Unicode cIns ); + OUT_UNDOBJ( Overwrite ) +}; + + +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; } + OUT_UNDOBJ( SplitNode ) +}; + + +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; + + 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 AddTblMrgFlyHstry( SwHistory& rHstr ); + + OUT_UNDOBJ( Move ) +}; + + +class SwUndoAttr : public SwUndo, private SwUndRng +{ + SfxItemSet aSet; // Attribute fuers Redo + SwHistory* pHistory; // History fuers Undo + SwRedlineData* pRedlData; // Redlining + SwRedlineSaveDatas* pRedlSaveData; + ULONG nNdIdx; // fuers Redlining - Offset + USHORT nInsFlags; // Einfuege Flags + + void RemoveIdx( SwDoc& rDoc ); +public: + SwUndoAttr( const SwPaM&, const SfxItemSet&, USHORT nFlags = 0 ); + SwUndoAttr( const SwPaM&, const SfxPoolItem&, USHORT nFlags = 0 ); + virtual ~SwUndoAttr(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + SwHistory* GetHistory() { return pHistory; } + void SaveRedlineData( const SwPaM& rPam, BOOL bInsCntnt ); + + OUT_UNDOBJ( InsAttr ) +}; + +class SwUndoRstAttr : public SwUndo, private SwUndRng +{ + SwHistory* pHistory; + SvUShortsSort aIds; + USHORT nFmtId; // Format-Id fuer das Redo +public: + SwUndoRstAttr( const SwPaM&, USHORT nFmtId ); + SwUndoRstAttr( const SwDoc&, const SwPosition&, USHORT nWhichId ); + virtual ~SwUndoRstAttr(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + void SetAttrs( const SvUShortsSort& rArr ); + SwHistory* GetHistory() { return pHistory; } + OUT_UNDOBJ( ResetAttr ) +}; + + +class SwUndoFmtAttr : public SwUndo +{ + friend class SwUndoDefaultAttr; + SwFmt* pFmt; + SfxItemSet* pOldSet; // die alten Attribute + ULONG nNode; + USHORT nFmtWhich; + BOOL bSaveDrawPt; + + int IsFmtInDoc( SwDoc* ); // ist das Attribut-Format noch im Doc ? + void SaveFlyAnchor( BOOL bSaveDrawPt = FALSE ); + void RestoreFlyAnchor( SwUndoIter& rIter ); + void Init(); + +public: + // meldet sich im Format an und sichert sich die alten Attribute + SwUndoFmtAttr( const SfxItemSet& rOldSet, SwFmt& rFmt, + BOOL bSaveDrawPt = TRUE ); + SwUndoFmtAttr( const SfxPoolItem& rItem, SwFmt& rFmt, + BOOL bSaveDrawPt = TRUE ); + virtual ~SwUndoFmtAttr(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + OUT_UNDOBJ( InsFmtAttr ) + + void PutAttr( const SfxPoolItem& rItem ); + SwFmt* GetFmt( SwDoc& rDoc ); // prueft, ob es noch im Doc ist! +}; + +class SwUndoDontExpandFmt : public SwUndo +{ + ULONG nNode; + xub_StrLen nCntnt; +public: + SwUndoDontExpandFmt( const SwPosition& rPos ); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); +}; + +// Hilfs-Klasse, um die geaenderten Sets zu "empfangen" +struct _UndoFmtAttr : public SwClient +{ + SwUndoFmtAttr* pUndo; + BOOL bSaveDrawPt; + + _UndoFmtAttr( SwFmt& rFmt, BOOL bSaveDrawPt = TRUE ); + virtual void Modify( SfxPoolItem*, SfxPoolItem* ); +}; + + +class SwUndoFmtColl : public SwUndo, private SwUndRng +{ + SwHistory* pHistory; + SwFmtColl* pFmtColl; +public: + SwUndoFmtColl( const SwPaM&, SwFmtColl* ); + virtual ~SwUndoFmtColl(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + SwHistory* GetHistory() { return pHistory; } + OUT_UNDOBJ( SetFmtColl ) +}; + + +class SwUndoMoveLeftMargin : public SwUndo, private SwUndRng +{ + SwHistory* pHistory; + BOOL 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 pHistory; } + OUT_UNDOBJ( MoveLeftMargin ) +}; + +// Basis-Klasse fuer Insert von Dokument, Glossaries und Kopieren +class SwUndoInserts : public SwUndo, public SwUndRng, private SwUndoSaveCntnt +{ + SwTxtFmtColl *pTxtFmtColl, *pLastNdColl; + SvPtrarr* pFrmFmts; + SwUndos* pFlyUndos; + SwRedlineData* pRedlData; + BOOL bSttWasTxtNd; +protected: + ULONG nNdDiff; + SwPosition *pPos; // Inhalt fuers Redo + USHORT nSetPos; // Start in der History-Liste + + SwUndoInserts( USHORT nUndoId, const SwPaM& ); +public: + virtual ~SwUndoInserts(); + + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + // setze den Destination-Bereich nach dem Einlesen. + void SetInsertRange( const SwPaM&, BOOL bScanFlys = TRUE, + BOOL bSttWasTxtNd = TRUE ); + OUT_UNDOBJ( Inserts ) +}; + +class SwUndoInsDoc : public SwUndoInserts +{ +public: + SwUndoInsDoc( const SwPaM& ); + OUT_UNDOBJ( InsDoc ) +}; + +class SwUndoCpyDoc : public SwUndoInserts +{ +public: + SwUndoCpyDoc( const SwPaM& ); + OUT_UNDOBJ( Copy ) +}; + +class SwUndoInsTbl : public SwUndo +{ + String sTblNm; + SwDDEFieldType* pDDEFldType; + SvUShorts* pColWidth; + SwRedlineData* pRedlData; + SwTableAutoFmt* pAutoFmt; + ULONG nSttNode; + USHORT nRows, nCols; + USHORT nAdjust; + USHORT nInsTblFlags; + +public: + SwUndoInsTbl( const SwPosition&, USHORT nCols, USHORT nRows, + USHORT eAdjust, USHORT nInsert, + const SwTableAutoFmt* pTAFmt, const SvUShorts* pColArr ); + virtual ~SwUndoInsTbl(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + OUT_UNDOBJ( InsTable ) +}; + +class SwUndoTxtToTbl : public SwUndo, public SwUndRng +{ + String sTblNm; + SvULongs* pDelBoxes; + SwTableAutoFmt* pAutoFmt; + SwHistory* pHistory; + sal_Unicode cTrenner; + USHORT nAdjust; + USHORT nInsTblFlags; + BOOL bSplitEnd : 1; + +public: + SwUndoTxtToTbl( const SwPaM&, sal_Unicode , USHORT, USHORT nInsert, + 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 ); + OUT_UNDOBJ( TextToTable ) +}; + +class SwUndoTblToTxt : public SwUndo +{ + String sTblNm; + SwDDEFieldType* pDDEFldType; + _SaveTable* pTblSave; + SwTblToTxtSaves* pBoxSaves; + SwHistory* pHistory; + ULONG nSttNd, nEndNd; + USHORT nAdjust; + sal_Unicode cTrenner; + BOOL bCheckNumFmt : 1; + BOOL bHdlnRpt : 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, + xub_StrLen nCntntIdx = STRING_MAXLEN); + OUT_UNDOBJ( TableToText ) +}; + +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& ); + OUT_UNDOBJ( SetTableAttr ) +}; + +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 ); + OUT_UNDOBJ( TableAutoFmt ) +}; + +class SwUndoTblNdsChg : public SwUndo +{ + _SaveTable* pSaveTbl; + SvULongs aBoxes; + + union { + SvULongs* pNewSttNds; + SwUndoSaveSections* pDelSects; + } Ptrs; + SvBools aMvBoxes; // fuers SplitRow (aufgeteilte Nodes einer Box) + + ULONG nSttNode, nCurrBox; + USHORT nCount, nRelDiff, nAbsDiff, nSetColType; + BOOL bFlag; +public: + SwUndoTblNdsChg( USHORT UndoId, + const SwSelBoxes& rBoxes, + const SwTableNode& rTblNd, + USHORT nCnt, BOOL bFlg ); + + // fuer SetColWidth + SwUndoTblNdsChg( USHORT 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 SetColWidthParam( ULONG nBoxIdx, USHORT nMode, USHORT nType, + SwTwips nAbsDif, SwTwips nRelDif ) + { + nCurrBox = nBoxIdx; + nCount = nMode; + nSetColType = nType; + nAbsDiff = (USHORT)nAbsDif; + nRelDiff = (USHORT)nRelDif; + } + OUT_UNDOBJ( TblNodesChg ) +}; + +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( SwPaM& rPam, SwPosition& rPos, const _SaveFlyArr& ); + 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 ); + + OUT_UNDOBJ( TblMerge ) +}; + + +class SwUndoTblNumFmt : public SwUndo +{ + SfxItemSet *pBoxSet; + SwHistory* pHistory; + String aStr, aNewFml; + + ULONG nFmtIdx, nNewFmtIdx; + double fNum, fNewNum; + ULONG nNode; + + 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 nNewFmtIdx, const double& rNewNumber ) + { nFmtIdx = nNewFmtIdx; fNum = rNewNumber; } + void SetBox( const SwTableBox& rBox ); + OUT_UNDOBJ( TblNumFmt ) +}; + +class _UndoTblCpyTbl_Entries; + +class SwUndoTblCpyTbl : public SwUndo +{ + _UndoTblCpyTbl_Entries* pArr; + SwUndoTblNdsChg* pInsRowUndo; +public: + SwUndoTblCpyTbl(); + virtual ~SwUndoTblCpyTbl(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + + void AddBoxBefore( const SwTableBox& rBox, BOOL bDelCntnt ); + void AddBoxAfter( const SwTableBox& rBox, BOOL bDelCntnt ); + + BOOL IsEmpty() const; + BOOL InsertRow( SwTable& rTbl, const SwSelBoxes& rBoxes, USHORT nCnt ); + OUT_UNDOBJ( TblCpyTbl ) +}; + +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; } + OUT_UNDOBJ( CpyTbl ) +}; + +class SwUndoSplitTbl : public SwUndo +{ + ULONG nTblNode, nOffset; + _SaveTable* pSavTbl; + SwHistory* pHistory; + USHORT nMode, nFmlEnd; + BOOL bCalcNewSize; +public: + SwUndoSplitTbl( const SwTableNode& rTblNd, 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& ); + + SwHistory* GetHistory() { return pHistory; } + void SaveFormula( SwHistory& rHistory ); +}; + + +class SwUndoBookmark : public SwUndo +{ + SwHstryBookmark* pHBookmark; +protected: + SwUndoBookmark( USHORT nUndoId, const SwBookmark& ); + + void SetInDoc( SwDoc* ); + void ResetInDoc( SwDoc* ); + +public: + virtual ~SwUndoBookmark(); +}; + + +class SwUndoDelBookmark : public SwUndoBookmark +{ +public: + SwUndoDelBookmark( const SwBookmark& ); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + OUT_UNDOBJ( DelBookmark ) +}; + +class SwUndoInsBookmark : public SwUndoBookmark +{ +public: + SwUndoInsBookmark( const SwBookmark& ); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + OUT_UNDOBJ( InsBookmark ) +}; + + +/*-------------------------------------------------------------------- + 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 ); + + OUT_UNDOBJ( Sort ) +}; + + + +//-------------------------------------------------------------------- + +class SwUndoFlyBase : public SwUndo, private SwUndoSaveSection +{ +protected: + SwFrmFmt* pFrmFmt; // das gespeicherte FlyFormat + ULONG nNdPgPos; + xub_StrLen nCntPos; // Seite/am Absatz/im Absatz + USHORT nRndId; + BOOL bDelFmt; // loesche das gespeicherte Format + + void InsFly( SwUndoIter&, BOOL bShowSel = TRUE ); + void DelFly( SwDoc* ); + + SwUndoFlyBase( SwFrmFmt* pFormat, USHORT nUndoId ); + + SwNodeIndex* GetMvSttIdx() const { return SwUndoSaveSection::GetMvSttIdx(); } + ULONG GetMvNodeCnt() const { return SwUndoSaveSection::GetMvNodeCnt(); } + +public: + virtual ~SwUndoFlyBase(); + + virtual void Undo( SwUndoIter& ) = 0; + virtual void Redo( SwUndoIter& ) = 0; + OUT_UNDOBJ( FlyBase ) +}; + +class SwUndoInsLayFmt : public SwUndoFlyBase +{ +public: + SwUndoInsLayFmt( SwFrmFmt* pFormat ); + + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + OUT_UNDOBJ( InsLayFmt ) +}; + +class SwUndoDelLayFmt : public SwUndoFlyBase +{ + 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; } + BOOL GetShowSel() const { return bShowSelFrm; } + OUT_UNDOBJ( DelLayFmt ) +}; + + +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& ); +}; + +//-------------------------------------------------------------------- + +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& ); + + 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(); } + + OUT_UNDOBJ( Replace ) +}; + + +//-------------------------------------------------------------------- + + +class SwUndoTblHeadline : public SwUndo +{ + ULONG nTblNd; + BOOL bOldHeadline; +public: + SwUndoTblHeadline( const SwTable&, BOOL bOldHdl ); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + OUT_UNDOBJ( SwUndoTblHeadline ) +}; + + +//------------ Undo von Insert-/Delete-Sections ---------------------- + +class SwUndoInsSection : public SwUndo, private SwUndRng +{ + SwHistory* pHistory; + SwSection* pSection; + SwRedlineData* pRedlData; + SfxItemSet* pAttr; + ULONG nSectNodePos; + BOOL bSplitAtStt : 1; + BOOL bSplitAtEnd : 1; + BOOL bUpdateFtn : 1; + + void Join( SwDoc& rDoc, ULONG nNode ); + +public: + SwUndoInsSection( const SwPaM&, const SwSection&, + const SfxItemSet* pSet ); + virtual ~SwUndoInsSection(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + OUT_UNDOBJ( SwUndoInsSection ) + + void SetSectNdPos( ULONG nPos ) { nSectNodePos = nPos; } + void SaveSplitNode( SwTxtNode* pTxtNd, BOOL bAtStt ); + void SetUpdtFtnFlag( BOOL bFlag ) { bUpdateFtn = bFlag; } +}; + +class SwUndoDelSection : public SwUndo +{ + ULONG nSttNd, nEndNd; + SwSection* pSection; + SfxItemSet* pAttr; +public: + SwUndoDelSection( const SwSectionFmt& ); + virtual ~SwUndoDelSection(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + OUT_UNDOBJ( SwUndoDelSection ) +}; + +class SwUndoChgSection : public SwUndo +{ + ULONG nSttNd; + SwSection* pSection; + SfxItemSet* pAttr; + BOOL bOnlyAttrChgd; +public: + SwUndoChgSection( const SwSectionFmt&, BOOL bOnlyAttrChgd ); + virtual ~SwUndoChgSection(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + OUT_UNDOBJ( SwUndoChgSection ) +}; + +class SwUndoChgSectPsswd : public SwUndo +{ + String sPasswd; +public: + SwUndoChgSectPsswd( const String& rOld ); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + OUT_UNDOBJ( SwUndoChgSectPsswd ) +}; + +//------------ 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& ); + OUT_UNDOBJ( SwUndoOutlineLeftRight ) +}; + +//-------------------------------------------------------------------- + +class SwUndoDefaultAttr : public SwUndo +{ + SfxItemSet* pOldSet; // die alten Attribute + SvxTabStopItem* pTabStop; +public: + // meldet sich im Format an und sichert sich die alten Attribute + SwUndoDefaultAttr( const SfxItemSet& rOldSet ); + virtual ~SwUndoDefaultAttr(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + OUT_UNDOBJ( DefaultAttr ) +}; + +//-------------------------------------------------------------------- +// ---------- Undo fuer Numerierung ---------------------------------- + +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 ); + SwUndoInsNum( const SwPosition& rPos, const SwNumRule& rRule, + const String& rReplaceRule ); + virtual ~SwUndoInsNum(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + + SwHistory* GetHistory(); // wird ggfs. neu angelegt! + void SetSttNum( ULONG nNdIdx ) { nSttSet = nNdIdx; } + void SaveOldNumRule( const SwNumRule& rOld ); + + void SetLRSpaceEndPos(); + + OUT_UNDOBJ( InsNum ) +}; + +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; } + + OUT_UNDOBJ( DelNum ) +}; + +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; } + OUT_UNDOBJ( MoveNum ) +}; + +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& ); + OUT_UNDOBJ( NumUpDown ) +}; + +class SwUndoNumOrNoNum : public SwUndo +{ + ULONG nIdx; + BOOL bDel : 1; + BOOL bOutline : 1; +public: + SwUndoNumOrNoNum( const SwNodeIndex& rIdx, BOOL bDelete, BOOL bOutline ); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + OUT_UNDOBJ( NumOrNoNum ) +}; + +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& ); + OUT_UNDOBJ( NumRuleStart ) +}; + +//-------------------------------------------------------------------- +// ---------- 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* ); +}; + +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* ); +}; + +class SwUndoDrawDelete : public SwUndo +{ + SwUndoGroupObjImpl* pObjArr; + USHORT nSize; + BOOL bDelFmt; + +public: + SwUndoDrawDelete( USHORT nCnt ); + virtual ~SwUndoDrawDelete(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + + void AddObj( USHORT nPos, SwDrawFrmFmt*, SdrObject* ); +}; + +//-------------------------------------------------------------------- + +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; + Point aPos; // fuer Zeichen-Objekte + 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, + const BOOL bBefore, const USHORT nId, + const BOOL bCpyBrd ); + virtual ~SwUndoInsertLabel(); + + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + + 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( const Point& rPos, BYTE nLayerId ); +}; + +//-------------------------------------------------------------------- + +class SwUndoChgFtn : public SwUndo, private SwUndRng +{ + SwHistory* pHistory; + String sTxt; + USHORT nNo; + BOOL bEndNote; +public: + SwUndoChgFtn( const SwPaM& rRange, const String& rTxt, + USHORT nNum, BOOL bIsEndNote ); + virtual ~SwUndoChgFtn(); + + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + virtual void Repeat( SwUndoIter& ); + + SwHistory* GetHistory() { return pHistory; } +}; + +class SwUndoFtnInfo : public SwUndo +{ + SwFtnInfo *pFtnInfo; + +public: + SwUndoFtnInfo( const SwFtnInfo &rInfo ); + virtual ~SwUndoFtnInfo(); + + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); +}; + +class SwUndoEndNoteInfo : public SwUndo +{ + SwEndNoteInfo *pEndNoteInfo; + +public: + SwUndoEndNoteInfo( const SwEndNoteInfo &rInfo ); + virtual ~SwUndoEndNoteInfo(); + + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); +}; + + +//-------------------------------------------------------------------- + +class SwUndoRedline : public SwUndo, public SwUndRng +{ +protected: + SwRedlineData* pRedlData; + SwRedlineSaveDatas* pRedlSaveData; + USHORT nUserId; + BOOL bHiddenRedlines; + + virtual void _Undo( SwUndoIter& ); + virtual void _Redo( SwUndoIter& ); + +public: + SwUndoRedline( USHORT nUserId, const SwPaM& rRange ); + virtual ~SwUndoRedline(); + virtual void Undo( SwUndoIter& ); + virtual void Redo( SwUndoIter& ); + + USHORT 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, USHORT nUserId = 0 ); + + 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; + 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& ); + + USHORT 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, USHORT nId = 0 ); + + BOOL IsNextUndo() const { return bWeiter; } + BOOL IsUpdateAttr() const { return bUpdateAttr; } + void SetUpdateAttr( BOOL bNew ) { bUpdateAttr = bNew; } + + inline SwDoc& GetDoc() const; + USHORT GetId() const { return nUndoId; } + USHORT GetLastUndoId() const + { return pLastUndoObj ? pLastUndoObj->GetId() : 0 ; } + void ClearSelections() { pSelFmt = 0; pMarkList = 0; } +}; + + + + +#endif |