office-gobmx/sw/inc/rolbck.hxx
Jens-Heiner Rechtien 7b0b5cdfee initial import
2000-09-18 16:15:01 +00:00

433 lines
12 KiB
C++

/*************************************************************************
*
* $RCSfile: rolbck.hxx,v $
*
* $Revision: 1.1.1.1 $
*
* last change: $Author: hr $ $Date: 2000-09-18 17:14:27 $
*
* 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 _ROLBCK_HXX
#define _ROLBCK_HXX
#ifndef _SOLAR_H
#include <tools/solar.h>
#endif
#ifndef _SVSTDARR_HXX
#define _SVSTDARR_USHORTS
#define _SVSTDARR_USHORTSSORT
#include <svtools/svstdarr.hxx>
#endif
#ifndef _SFXITEMSET_HXX
#include <svtools/itemset.hxx>
#endif
//Nur die History anziehen, um das docnew.cxx gegen die CLOOK's zu behaupten.
class SwDoc;
class SwFmt;
class SwFmtColl;
class SwHstryHint;
class SwBookmark;
class SwTxtAttr;
class SfxPoolItem;
class SwTxtNode;
class SwCntntNode;
class SwUndoSaveSection;
class SwTxtFtn;
class SwTxtFlyCnt;
class SwUndoDelLayFmt;
class SwFlyFrmFmt;
class SwFmtFld;
class SwTxtFld;
class SwFieldType;
class SwTxtTOXMark;
class SwTxtRefMark;
class SwFrmFmt;
class SwNodeIndex;
class SwpHints;
class SwFmtChain;
class SwNode;
#ifndef ROLBCK_HISTORY_ONLY
#ifndef _TOX_HXX
#include <tox.hxx>
#endif
#ifndef PRODUCT
class Writer;
#define OUT_HSTR_HINT( name ) \
friend Writer& OutUndo_Hstr_ ## name( Writer&, const SwHstryHint& );
#else
#define OUT_HSTR_HINT( name )
#endif
enum HISTORY_HINT {
HSTRY_SETFMTHNT,
HSTRY_RESETFMTHNT,
HSTRY_SETTXTHNT,
HSTRY_SETTXTFLDHNT,
HSTRY_SETREFMARKHNT,
HSTRY_SETTOXMARKHNT,
HSTRY_RESETTXTHNT,
HSTRY_SETFTNHNT,
HSTRY_CHGFMTCOLL,
HSTRY_FLYCNT,
HSTRY_BOOKMARK,
HSTRY_SETATTRSET,
HSTRY_RESETATTRSET,
HSTRY_CHGFLYANCHOR,
HSTRY_CHGFLYCHAIN,
HSTRY_END
};
class SwHstryHint
{
HISTORY_HINT eWhichId;
public:
SwHstryHint( HISTORY_HINT eWh ) : eWhichId( eWh ) {}
virtual ~SwHstryHint() {} // jetzt inline
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet ) = 0;
HISTORY_HINT Which() const { return eWhichId; }
};
class SwSetFmtHint : public SwHstryHint
{
SfxPoolItem* pAttr;
ULONG nNode;
USHORT nSetStt;
BYTE nNumLvl;
BOOL bNumStt;
public:
SwSetFmtHint( const SfxPoolItem* pFmtHt, ULONG nNode );
virtual ~SwSetFmtHint();
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
OUT_HSTR_HINT(SetFmtHnt)
};
class SwResetFmtHint : public SwHstryHint
{
ULONG nNode;
USHORT nWhich;
public:
SwResetFmtHint( const SfxPoolItem* pFmtHt, ULONG nNode );
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
OUT_HSTR_HINT(ResetFmtHnt)
};
class SwSetTxtHint : public SwHstryHint
{
SfxPoolItem *pAttr;
ULONG nNode;
xub_StrLen nStart, nEnd;
public:
SwSetTxtHint( /*const*/ SwTxtAttr* pTxtHt, ULONG nNode );
virtual ~SwSetTxtHint();
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
OUT_HSTR_HINT(SetTxtHnt)
};
class SwSetTxtFldHint : public SwHstryHint
{
SwFmtFld* pFld;
SwFieldType* pFldType;
ULONG nNode;
xub_StrLen nPos;
USHORT nFldWhich;
public:
SwSetTxtFldHint( SwTxtFld* pTxtFld, ULONG nNode );
virtual ~SwSetTxtFldHint();
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
OUT_HSTR_HINT(SetTxtFldHnt)
};
class SwSetRefMarkHint : public SwHstryHint
{
String aRefName;
ULONG nNode;
xub_StrLen nStart, nEnd;
public:
SwSetRefMarkHint( SwTxtRefMark* pTxtHt, ULONG nNode );
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
OUT_HSTR_HINT(SetRefMarkHnt)
};
class SwSetTOXMarkHint : public SwHstryHint
{
String aTOXName;
TOXTypes eTOXTypes;
SwTOXMark aTOXMark;
ULONG nNode;
xub_StrLen nStart, nEnd;
public:
SwSetTOXMarkHint( SwTxtTOXMark* pTxtHt, ULONG nNode );
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
int IsEqual( const SwTOXMark& rCmp ) const;
OUT_HSTR_HINT(SetToxMarkHnt)
};
class SwResetTxtHint : public SwHstryHint
{
ULONG nNode;
xub_StrLen nStart, nEnd;
USHORT nAttr;
public:
SwResetTxtHint( USHORT nWhich, xub_StrLen nStt, xub_StrLen nEnd, ULONG nNode );
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
USHORT GetWhich() const { return nAttr; }
ULONG GetNode() const { return nNode; }
xub_StrLen GetCntnt() const { return nStart; }
OUT_HSTR_HINT(ResetTxtHnt)
};
class SwSetFtnHint : public SwHstryHint
{
String aFtnStr;
SwUndoSaveSection* pUndo;
ULONG nNode;
xub_StrLen nStart;
BOOL bEndNote;
public:
SwSetFtnHint( SwTxtFtn* pTxtFtn, ULONG nNode );
SwSetFtnHint( const SwTxtFtn& );
~SwSetFtnHint();
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
const SwUndoSaveSection* GetUndoObj() const { return pUndo; }
SwUndoSaveSection* GetUndoObj() { return pUndo; }
OUT_HSTR_HINT(SetFtnHnt)
};
class SwChgFmtColl : public SwHstryHint
{
const SwFmtColl* pColl;
ULONG nNode;
USHORT nSetStt;
BYTE nNdWhich, nNumLvl;
BOOL bNumStt;
public:
SwChgFmtColl( const SwFmtColl* pColl, ULONG nNode, BYTE nNodeWhich );
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
OUT_HSTR_HINT(ChgFmtColl)
};
class SwHstryTxtFlyCnt : public SwHstryHint
{
SwUndoDelLayFmt* pUndo;
public:
SwHstryTxtFlyCnt( SwTxtFlyCnt* pTxtFly ); // fuer Zeichengebundene
SwHstryTxtFlyCnt( SwFlyFrmFmt* pFlyFmt ); // fuer Absatzgebundene
~SwHstryTxtFlyCnt();
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
SwUndoDelLayFmt* GetUDelLFmt() { return pUndo; }
OUT_HSTR_HINT(FlyCnt)
};
class SwHstryBookmark : public SwHstryHint
{
String aName, aShortName;
ULONG nNode1, nNode2;
xub_StrLen nCntnt1, nCntnt2;
USHORT nKeyCode;
BYTE nTyp;
public:
enum { BKMK_POS = 1, BKMK_OTHERPOS = 2 };
SwHstryBookmark( const SwBookmark&, BYTE nTyp );
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
OUT_HSTR_HINT(Bookmark)
BOOL IsEqualBookmark( const SwBookmark& );
};
class SwHstrySetAttrSet : public SwHstryHint
{
SfxItemSet aOldSet;
SvUShorts aResetArr;
ULONG nNode;
USHORT nSetStt;
BYTE nNumLvl;
BOOL bNumStt;
public:
SwHstrySetAttrSet( const SfxItemSet& rSet, ULONG nNode,
const SvUShortsSort& rSetArr );
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
OUT_HSTR_HINT(SetAttrSet)
};
class SwHstryResetAttrSet : public SwHstryHint
{
ULONG nNode;
xub_StrLen nStart, nEnd;
SvUShorts aArr;
public:
SwHstryResetAttrSet( const SfxItemSet& rSet, ULONG nNode,
xub_StrLen nStt = STRING_MAXLEN,
xub_StrLen nEnd = STRING_MAXLEN );
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
const SvUShorts& GetArr() const { return aArr; }
ULONG GetNode() const { return nNode; }
xub_StrLen GetCntnt() const { return nStart; }
OUT_HSTR_HINT(ResetAttrSet)
};
class SwHstryChgFlyAnchor : public SwHstryHint
{
SwFrmFmt* pFmt;
ULONG nOldPos;
xub_StrLen nOldCnt;
public:
SwHstryChgFlyAnchor( const SwFrmFmt& rFmt );
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
};
class SwHstryChgFlyChain : public SwHstryHint
{
SwFlyFrmFmt *pPrevFmt, *pNextFmt, *pFlyFmt;
public:
SwHstryChgFlyChain( const SwFlyFrmFmt& rFmt, const SwFmtChain& rAttr );
virtual void SetInDoc( SwDoc* pDoc, BOOL bTmpSet );
};
#endif
typedef SwHstryHint* SwHstryHintPtr;
SV_DECL_PTRARR_DEL( SwpHstry, SwHstryHintPtr, 0, 2 )
class SwHistory : private SwpHstry
{
friend class SwDoc; // eig. darf nur SwDoc::DelUndoObj zugreifen
friend class SwUndoWriter; // fuer den Undo/Redo-Writer
friend class SwRegHistory; // fuer Insert, von Histoy-Attributen
USHORT nEndDiff;
public:
SwHistory( USHORT nInitSz = 0, USHORT nGrowSz = 2 );
~SwHistory();
// loesche die History ab Start bis zum Ende
void Delete( USHORT nStart = 0 );
// alle Objecte zwischen nStart und Array-Ende aufrufen und loeschen
BOOL Rollback( SwDoc* pDoc, USHORT nStart = 0 );
// alle Objecte zwischen nStart und temporaeren Ende aufrufen und
// den Start als temporaeres Ende speichern
BOOL TmpRollback( SwDoc* pDoc, USHORT nStart, BOOL ToFirst = TRUE );
void Add( const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue,
ULONG nNodeIdx );
void Add( const SwTxtAttr* pTxtHt, ULONG nNodeIdx,
BOOL bNewAttr = TRUE );
void Add( const SwFmtColl*, ULONG nNodeIdx, BYTE nWhichNd );
void Add( const SwFmt*, ULONG nNodeIdx, BYTE nWhichNd );
void Add( const SwBookmark&, BYTE );
void Add( const SwFrmFmt& rFmt );
void Add( const SwFlyFrmFmt&, USHORT& rSetPos );
void Add( const SwTxtFtn& );
USHORT Count() const { return SwpHstry::Count(); }
USHORT GetTmpEnd() const { return SwpHstry::Count() - nEndDiff; }
USHORT SetTmpEnd( USHORT nTmpEnd ); // returne alten Wert
SwHstryHint* operator[]( USHORT nPos ) const { return SwpHstry::operator[](nPos); }
// fuer SwUndoDelete::Undo/Redo
void Move( USHORT nPos, SwHistory *pIns,
USHORT nStart = 0, USHORT nEnd = USHRT_MAX )
{
SwpHstry::Insert( pIns, nPos, nStart, nEnd );
SwpHstry* pDel = pIns;
pDel->Remove( nStart, nEnd == USHRT_MAX
? pDel->Count() - nStart
: nEnd );
}
// Hilfs-Methoden zum Sichern von Attributen in der History.
// Wird von UndoKlasse benutzt (Delete/Overwrite/Inserts)
void CopyAttr( const SwpHints* pHts, ULONG nNodeIdx, xub_StrLen nStt,
xub_StrLen nEnd, BOOL bFields );
void CopyFmtAttr( const SfxItemSet& rSet, ULONG nNodeIdx );
};
#ifndef ROLBCK_HISTORY_ONLY
class SwRegHistory : public SwClient
{
SvUShortsSort aSetWhichIds;
SwHistory* pHstry;
const SwCntntNode * pNode;
ULONG nNodeIdx;
void _MakeSetWhichIds();
public:
SwRegHistory( SwHistory* pHst );
SwRegHistory( SwTxtNode* pTxtNd, SwTxtAttr* pTxtHt,
USHORT nFlags, SwHistory* pHst );
SwRegHistory( SwTxtNode* pTxtNode, const SfxItemSet& rSet,
xub_StrLen nStart, xub_StrLen nEnd, USHORT nFlags,
SwHistory* pHst );
SwRegHistory( const SwNode& rNd, SwHistory* pHst );
SwRegHistory( SwModify* pRegIn, const SwNode& rNd, SwHistory* pHst );
virtual void Modify( SfxPoolItem* pOld, SfxPoolItem* pNew );
void Add( SwTxtAttr* pHt, const BOOL bNew = FALSE );
void RegisterInModify( SwModify* pRegIn, const SwNode& rNd );
};
#endif
#endif // _ROLBCK_HXX