mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4bf521529edb9ded3fdfbdfbec9d047bbd39d57f
libreoffice/sw/inc/undobj.hxx

1660 lines
48 KiB
C++
Raw Normal View History

initial import
2000-09-18 16:15:01 +00:00
/*************************************************************************
*
* $RCSfile: undobj.hxx,v $
*
#103485# SplitRows with equal height
2002-11-15 08:24:03 +00:00
* $Revision: 1.6 $
initial import
2000-09-18 16:15:01 +00:00
*
#103485# SplitRows with equal height
2002-11-15 08:24:03 +00:00
* last change: $Author: fme $ $Date: 2002-11-15 09:24:03 $
initial import
2000-09-18 16:15:01 +00:00
*
* 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
password change: use sequence instead of string
2001-03-02 13:39:49 +00:00
#ifndef _COM_SUN_STAR_UNO_SEQUENCE_H_
#include <com/sun/star/uno/Sequence.h>
#endif
initial import
2000-09-18 16:15:01 +00:00
#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;
new: transliteration
2000-12-21 08:32:45 +00:00
class SwFmtAnchor;
initial import
2000-09-18 16:15:01 +00:00
struct SwUndoGroupObjImpl;
Bug #94630#: SwUndoDrawDelete - store marklist for undo
2001-11-13 12:52:46 +00:00
class SdrMark;
initial import
2000-09-18 16:15:01 +00:00
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;
password change: use sequence instead of string
2001-03-02 13:39:49 +00:00
class SwSectionNode;
initial import
2000-09-18 16:15:01 +00:00
new: transliteration
2000-12-21 08:32:45 +00:00
namespace utl {
class TransliterationWrapper;
};
initial import
2000-09-18 16:15:01 +00:00
#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;
#103485# SplitRows with equal height
2002-11-15 08:24:03 +00:00
BOOL bSameHeight; // only used for SplitRow
initial import
2000-09-18 16:15:01 +00:00
public:
SwUndoTblNdsChg( USHORT UndoId,
const SwSelBoxes& rBoxes,
const SwTableNode& rTblNd,
#103485# SplitRows with equal height
2002-11-15 08:24:03 +00:00
USHORT nCnt, BOOL bFlg, BOOL bSameHeight = FALSE );
initial import
2000-09-18 16:15:01 +00:00
// 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
{
password change: use sequence instead of string
2001-03-02 13:39:49 +00:00
::com::sun::star::uno::Sequence <sal_Int8> aPasswd;
ULONG nSectNd;
initial import
2000-09-18 16:15:01 +00:00
public:
password change: use sequence instead of string
2001-03-02 13:39:49 +00:00
SwUndoChgSectPsswd(
const ::com::sun::star::uno::Sequence <sal_Int8> & rOld,
const SwSectionNode* pSectNd = 0 );
initial import
2000-09-18 16:15:01 +00:00
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;
Bug #94630#: SwUndoDrawDelete - store marklist for undo
2001-11-13 12:52:46 +00:00
SdrMarkList* pMarkLst; // MarkList for all selected SdrObjects
initial import
2000-09-18 16:15:01 +00:00
USHORT nSize;
BOOL bDelFmt;
public:
SwUndoDrawDelete( USHORT nCnt );
virtual ~SwUndoDrawDelete();
virtual void Undo( SwUndoIter& );
virtual void Redo( SwUndoIter& );
Bug #94630#: SwUndoDrawDelete - store marklist for undo
2001-11-13 12:52:46 +00:00
void AddObj( USHORT nPos, SwDrawFrmFmt*, const SdrMark& );
initial import
2000-09-18 16:15:01 +00:00
};
//--------------------------------------------------------------------
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& );
};
new: transliteration
2000-12-21 08:32:45 +00:00
//--------------------------------------------------------------------
struct _UndoTransliterate_Data;
class SwUndoTransliterate : public SwUndo, public SwUndRng
{
_UndoTransliterate_Data *pData, *pLastData;
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( const SwTxtNode& rTNd, xub_StrLen nStart, xub_StrLen nLen,
::com::sun::star::uno::Sequence <long>& rOffsets );
BOOL HasData() const {return 0 != pData; }
};
initial import
2000-09-18 16:15:01 +00:00
//--------------------------------------------------------------------
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;
Task #87374#: SwUndoCompDoc - need an additionl member
2001-09-27 12:27:58 +00:00
SwUndoDelete* pUnDel, *pUnDel2;
initial import
2000-09-18 16:15:01 +00:00
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
Reference in New Issue Copy Permalink