/*************************************************************************
 *
 *  $RCSfile: svdundo.hxx,v $
 *
 *  $Revision: 1.5 $
 *
 *  last change: $Author: rt $ $Date: 2003/04/24 13:25:58 $
 *
 *  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 _SVDUNDO_HXX
#define _SVDUNDO_HXX

#ifndef _SOLAR_HRC
#include <svtools/solar.hrc>
#endif

#ifndef _UNDO_HXX //autogen
#include <svtools/undo.hxx>
#endif

#ifndef _CONTNR_HXX //autogen
#include <tools/contnr.hxx>
#endif

#ifndef _GEN_HXX //autogen
#include <tools/gen.hxx>
#endif

#ifndef _SVDTYPES_HXX
#include <svx/svdtypes.hxx> // fuer enum RepeatFuncts
#endif

//************************************************************
//   Vorausdeklarationen
//************************************************************

class SfxItemSet;
class SfxStyleSheet;
class SdrView;
class SdrPageView;
class SdrModel;
class SdrObject;
class SdrPage;
class SdrObjList;
class SdrLayer;
class SdrLayerAdmin;
class SdrObjGeoData;
class OutlinerParaObject;
class SdrMasterPageDescriptor;

//************************************************************
//   SdrUndoAction
//
// Abstrakte Basisklasse fuer alle UndoActions der DrawingEngine
//
//************************************************************

class SdrUndoAction : public SfxUndoAction
{
protected:
	SdrModel&					rMod;

protected:
	SdrUndoAction(SdrModel& rNewMod)
	:	rMod(rNewMod)
	{}

public:
	TYPEINFO();
	virtual BOOL CanRepeat(SfxRepeatTarget& rView) const;
	virtual void Repeat(SfxRepeatTarget& rView);

	virtual String GetRepeatComment(SfxRepeatTarget& rView) const;
	virtual String GetSdrRepeatComment(SdrView& rView) const;

	virtual FASTBOOL CanSdrRepeat(SdrView& rView) const;
	virtual void SdrRepeat(SdrView& rView);
};

//************************************************************
//   SdrUndoGroup
//
// Zusammenfassung beliebig vieler einzelner UndoActions zu einer einzigen
// UndoAction. Beim Undo() werden die Einzelactions rueckwaets aufgerufen
// (die zuletzt angehaengte zuerst...), beim Redo() dagegen entspricht die
// Aufrufreihenfolge der Einfuegereihenfolge.
//
//************************************************************

class SdrUndoGroup : public SdrUndoAction
{
protected:
	Container					aBuf;

	// Beschreibung der Action, nicht expandiert (beinhaltet %O)
	String						aComment;
	String						aObjDescription;

	SdrRepeatFunc				eFunction;

public:
	SdrUndoGroup(SdrModel& rNewMod);
	SdrUndoGroup(SdrModel& rNewMod,const String& rStr);
	virtual ~SdrUndoGroup();

	void Clear();
	ULONG GetActionCount() const { return aBuf.Count(); }
	SdrUndoAction* GetAction(ULONG nNum) const { return (SdrUndoAction*)(aBuf.GetObject(nNum)); }
	void AddAction(SdrUndoAction* pAct);

	void SetComment(const String& rStr) { aComment=rStr; }
	void SetObjDescription(const String& rStr) { aObjDescription=rStr; }
	virtual String GetComment() const;
	virtual String GetSdrRepeatComment(SdrView& rView) const;

	virtual void Undo();
	virtual void Redo();

	virtual FASTBOOL CanSdrRepeat(SdrView& rView) const;
	virtual void SdrRepeat(SdrView& rView);
	void SetRepeatFunction(SdrRepeatFunc eFunc) { eFunction=eFunc; }
	SdrRepeatFunc GetRepeatFunction() const { return eFunction; }
};

//************************************************************
//   SdrUndoObj
//
// Abstrakte Basisklasse fuer alle UndoActions die mit Objekten zu tun haben.
//
//************************************************************

class SdrUndoObj : public SdrUndoAction
{
protected:
	SdrObject*					pObj;

protected:
	SdrUndoObj(SdrObject& rNewObj);

	void ImpTakeDescriptionStr(USHORT nStrCacheID, String& rStr, FASTBOOL bRepeat=FALSE) const;

	// #94278# new method for evtl. PageChange at UNDO/REDO
	void ImpShowPageOfThisObject();
};

//************************************************************
//   SdrUndoAttrObj
//
// Aenderung der Objektattribute.
// Action direkt vor dem Setzen der neuen Attribute konstruieren.
// Auch fuer StyleSheets
//
//************************************************************

class SdrUndoAttrObj : public SdrUndoObj
{
protected:
	SfxItemSet*					pUndoSet;
	SfxItemSet*					pRedoSet;
	SfxItemSet*					pRepeatSet;

	// oder besser den StyleSheetNamen merken?
	SfxStyleSheet*				pUndoStyleSheet;
	SfxStyleSheet*				pRedoStyleSheet;
	SfxStyleSheet*				pRepeatStyleSheet;
	FASTBOOL					bStyleSheet;
	FASTBOOL					bHaveToTakeRedoSet;

	// Bei Zuweisung von TextItems auf ein Zeichenobjekt mit Text:
	OutlinerParaObject*			pTextUndo;
	// #i8508#
	// The text rescue mechanism needs also to be implemented for redo actions.
	OutlinerParaObject*			pTextRedo;

	// Wenn sich um ein Gruppenobjekt handelt:
	SdrUndoGroup*				pUndoGroup;

public:
	SdrUndoAttrObj(SdrObject& rNewObj, FASTBOOL bStyleSheet1=FALSE, FASTBOOL bSaveText=FALSE);
	virtual ~SdrUndoAttrObj();
	void SetRepeatAttr(const SfxItemSet& rSet);
	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
	virtual String GetSdrRepeatComment(SdrView& rView) const;

	virtual void SdrRepeat(SdrView& rView);
	virtual FASTBOOL CanSdrRepeat(SdrView& rView) const;
};

//************************************************************
//   SdrUndoMoveObj
//
// Blosses verschieben eines Objektes.
// Action direkt vor dem Verschieben konstruieren.
//
//************************************************************

class SdrUndoMoveObj : public SdrUndoObj
{
protected:
	Size						aDistance;     // Entfernung, um die verschoben wird

public:
	SdrUndoMoveObj(SdrObject& rNewObj): SdrUndoObj(rNewObj) {}
	SdrUndoMoveObj(SdrObject& rNewObj, const Size& rDist): SdrUndoObj(rNewObj),aDistance(rDist) {}

	void SetDistance(const Size& rDist) { aDistance=rDist; }
	const Size& GetDistance() const { return aDistance; }

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
	virtual String GetSdrRepeatComment(SdrView& rView) const;

	virtual void SdrRepeat(SdrView& rView);
	virtual FASTBOOL CanSdrRepeat(SdrView& rView) const;
};

//************************************************************
//   SdrUndoGeoObj
//
// Aenderung der Geometrie eines Objektes.
// Action direkt vor der geometrischen Transformation konstruieren.
//
//************************************************************

class SdrUndoGeoObj : public SdrUndoObj
{
protected:
	SdrObjGeoData*				pUndoGeo;
	SdrObjGeoData*				pRedoGeo;
	// Wenn sich um ein Gruppenobjekt handelt:
	SdrUndoGroup*				pUndoGroup;

public:
	SdrUndoGeoObj(SdrObject& rNewObj);
	virtual ~SdrUndoGeoObj();

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

//************************************************************
//   SdrUndoObjList
//
// Manipulationen an einer ObjList: Neues Obj, DeleteObj, SetObjZLevel, Grouping, ...
// Abstrakte Basisklasse.
//
//************************************************************

class SdrUndoObjList : public SdrUndoObj {
	FASTBOOL					bOwner;

protected:
	SdrObjList*					pObjList;
	SdrView*					pView;      // um bei ObjDel, Undo die
	SdrPageView*				pPageView;  // Selektion widerherstellen zu koennen
	UINT32						nOrdNum;
	// Bei einem Undo/Redo findet moeglicherweise Uebereignung des Objektes
	// statt. Im Dtor wird das Obj deleted, wenn bOwner==TRUE

protected:
	SdrUndoObjList(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=FALSE);
	virtual ~SdrUndoObjList();

	void SetView(SdrView* pView1, SdrPageView* pPageView1) { pView=pView1; pPageView=pPageView1; }
	BOOL IsOwner() { return bOwner; }
	void SetOwner(BOOL bNew);
};

//************************************************************
//   SdrUndoRemoveObj
//
// Entfernen Objekts aus einer Objektliste. Innerhalb einer UndoGroup
// mit korrospondierenden Inserts zu verwenden.
// Action vor dem entfernen aus der ObjList konstruieren.
//
//************************************************************

class SdrUndoRemoveObj : public SdrUndoObjList
{
public:
	SdrUndoRemoveObj(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=FALSE)
	: SdrUndoObjList(rNewObj,bOrdNumDirect) {}

	virtual void Undo();
	virtual void Redo();
};

//************************************************************
//   SdrUndoInsertObj
//
// Einfuegen Objekts in eine Objektliste. Innerhalb einer UndoGroup
// mit korrospondierenden Removes zu verwenden.
// Action vor dem entfernen aus der ObjList konstruieren.
//
//************************************************************

class SdrUndoInsertObj : public SdrUndoObjList
{
public:
	SdrUndoInsertObj(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=FALSE)
	:	SdrUndoObjList(rNewObj,bOrdNumDirect) {}

	virtual void Undo();
	virtual void Redo();
};

//************************************************************
//   SdrUndoDelObj
//
// Loeschen eines Objekts.
// Action vor dem entfernen aus der ObjList konstruieren.
//
//************************************************************

class SdrUndoDelObj : public SdrUndoRemoveObj
{
public:
	SdrUndoDelObj(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=FALSE)
	:	SdrUndoRemoveObj(rNewObj,bOrdNumDirect) { SetOwner(TRUE); }

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
	virtual String GetSdrRepeatComment(SdrView& rView) const;

	virtual void SdrRepeat(SdrView& rView);
	virtual FASTBOOL CanSdrRepeat(SdrView& rView) const;
};

//************************************************************
//   SdrUndoNewObj
//
// Einfuegen eines neuen Objektes.
// Action nach dem einfuegen in die ObjList konstruieren.
//
//************************************************************

class SdrUndoNewObj : public SdrUndoInsertObj
{
public:
	SdrUndoNewObj(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=FALSE)
	:	SdrUndoInsertObj(rNewObj,bOrdNumDirect) {}

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

//************************************************************
//   SdrUndoReplaceObj
//
// Austausch eines Objektes.
// Action vor dem Replace an der ObjList konstruieren.
//
//************************************************************

class SdrUndoReplaceObj : public SdrUndoObj
{
	FASTBOOL					bOldOwner;
	FASTBOOL					bNewOwner;

protected:
	SdrObjList*					pObjList;
	UINT32						nOrdNum;
	SdrObject*					pNewObj;

public:
	SdrUndoReplaceObj(SdrObject& rOldObj1, SdrObject& rNewObj1, FASTBOOL bOrdNumDirect=FALSE);
	virtual ~SdrUndoReplaceObj();

	virtual void Undo();
	virtual void Redo();

	BOOL IsNewOwner() { return bNewOwner; }
	void SetNewOwner(BOOL bNew);

	BOOL IsOldOwner() { return bOldOwner; }
	void SetOldOwner(BOOL bNew);
};

//************************************************************
//   SdrUndoCopyObj
//
// Kopieren eines Objekts
// Action nach dem einfuegen in die ObjList konstruieren.
//
//************************************************************

class SdrUndoCopyObj : public SdrUndoNewObj
{
public:
	SdrUndoCopyObj(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=FALSE)
	:	SdrUndoNewObj(rNewObj,bOrdNumDirect) {}

	virtual String GetComment() const;
};

//************************************************************
//   SdrUndoObjOrdNum
//************************************************************

class SdrUndoObjOrdNum : public SdrUndoObj
{
protected:
	UINT32						nOldOrdNum;
	UINT32						nNewOrdNum;

public:
	SdrUndoObjOrdNum(SdrObject& rNewObj, UINT32 nOldOrdNum1, UINT32 nNewOrdNum1);

	virtual void Undo();
	virtual void Redo();

	virtual String   GetComment() const;
};

//////////////////////////////////////////////////////////////////////////////
// #i11702#

class SdrUndoObjectLayerChange : public SdrUndoObj
{
protected:
	SdrLayerID					maOldLayer;
	SdrLayerID					maNewLayer;

public:
	SdrUndoObjectLayerChange(SdrObject& rObj, SdrLayerID aOldLayer, SdrLayerID aNewLayer);

	virtual void Undo();
	virtual void Redo();
};

//************************************************************
//   SdrUndoObjSetText
//************************************************************

class SdrUndoObjSetText : public SdrUndoObj
{
protected:
	OutlinerParaObject*			pOldText;
	OutlinerParaObject*			pNewText;
	FASTBOOL					bNewTextAvailable;
	BOOL						bEmptyPresObj;

public:
	SdrUndoObjSetText(SdrObject& rNewObj);
	virtual ~SdrUndoObjSetText();

	FASTBOOL IsDifferent() const { return pOldText!=pNewText; }
	void AfterSetText();

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
	virtual String GetSdrRepeatComment(SdrView& rView) const;

	virtual void SdrRepeat(SdrView& rView);
	virtual FASTBOOL CanSdrRepeat(SdrView& rView) const;
};

////////////////////////////////////////////////////////////////////////////////////////////////////
//
//  @@     @@@@  @@  @@ @@@@@ @@@@@
//  @@    @@  @@ @@  @@ @@    @@  @@
//  @@    @@  @@ @@  @@ @@    @@  @@
//  @@    @@@@@@  @@@@  @@@@  @@@@@
//  @@    @@  @@   @@   @@    @@  @@
//  @@    @@  @@   @@   @@    @@  @@
//  @@@@@ @@  @@   @@   @@@@@ @@  @@
//
////////////////////////////////////////////////////////////////////////////////////////////////////

//************************************************************
//   SdrUndoLayer
//
// Abstrakte Basisklasse fuer alle UndoActions die mit SdrLayer zu tun haben.
//
//************************************************************

class SdrUndoLayer : public SdrUndoAction
{
protected:
	SdrLayer*					pLayer;
	SdrLayerAdmin*				pLayerAdmin;
	USHORT						nNum;
	FASTBOOL					bItsMine;

protected:
	SdrUndoLayer(USHORT nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel);
	virtual ~SdrUndoLayer();
};

//************************************************************
//   SdrUndoNewLayer
//
// Einfuegen eines neuen Layer. Action nach dem Einfuegen konstruieren.
//
//************************************************************

class SdrUndoNewLayer : public SdrUndoLayer
{
public:
	SdrUndoNewLayer(USHORT nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
	: SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel) {}

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

//************************************************************
//   SdrUndoDelLayer
//
// Loeschen eines Layer. Action vor dem Remove konstruieren
//
//************************************************************

class SdrUndoDelLayer : public SdrUndoLayer
{
public:
	SdrUndoDelLayer(USHORT nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
	: SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel) { bItsMine=TRUE; }

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

//************************************************************
//   SdrUndoMoveLayer
//
// Verschieben eines Layer. Action vor dem Verschieben konstruieren.
//
//************************************************************

class SdrUndoMoveLayer : public SdrUndoLayer
{
	USHORT						nNeuPos;

public:
	SdrUndoMoveLayer(USHORT nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel, USHORT nNeuPos1)
	:	SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel), nNeuPos(nNeuPos1) {}

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

////////////////////////////////////////////////////////////////////////////////////////////////////
//
//  @@@@@   @@@@   @@@@  @@@@@  @@@@
//  @@  @@ @@  @@ @@  @@ @@    @@  @@
//  @@  @@ @@  @@ @@     @@    @@
//  @@@@@  @@@@@@ @@ @@@ @@@@   @@@@
//  @@     @@  @@ @@  @@ @@        @@
//  @@     @@  @@ @@  @@ @@    @@  @@
//  @@     @@  @@  @@@@@ @@@@@  @@@@
//
////////////////////////////////////////////////////////////////////////////////////////////////////

//************************************************************
//   SdrUndoPage
//
// Abstrakte Basisklasse fuer alle UndoActions die mit SdrPages zu tun haben.
//
//************************************************************

class SdrUndoPage : public SdrUndoAction
{
protected:
	SdrPage*					pPage;

protected:
	void ImpInsertPage(USHORT nNum);
	void ImpRemovePage(USHORT nNum);
	void ImpMovePage(USHORT nOldNum, USHORT nNewNum);

protected:
	SdrUndoPage(SdrPage& rNewPg);

	void ImpTakeDescriptionStr(USHORT nStrCacheID, String& rStr, USHORT n=0, FASTBOOL bRepeat=FALSE) const;
};

//************************************************************
//   SdrUndoPageList
//
// Manipulationen an einer PageList: Neue Page, DeletePage, MovePage(ChangePageNum)
// Abstrakte Basisklasse.
//
//************************************************************

class SdrUndoPageList : public SdrUndoPage
{
protected:
	USHORT						nPageNum;

	// Bei einem Undo/Redo findet moeglicherweise Uebereignung der Page
	// statt. Im Dtor wird die Page deleted, wenn bItsMine==TRUE
	FASTBOOL					bItsMine;

protected:
	SdrUndoPageList(SdrPage& rNewPg);
	virtual ~SdrUndoPageList();
};

//************************************************************
//   SdrUndoDelPage
//
// Loeschen einer Page.
// Action vor dem entfernen aus der List konstruieren.
//
//************************************************************

class SdrUndoDelPage : public SdrUndoPageList
{
	// Beim loeschen einer MasterPage merke ich mir in dieser UndoGroup
	// alle Beziehungen der Zeichenseiten zu der geloeschten MasterPage
	SdrUndoGroup*				pUndoGroup;

public:
	SdrUndoDelPage(SdrPage& rNewPg);
	virtual ~SdrUndoDelPage();

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
	virtual String GetSdrRepeatComment(SdrView& rView) const;

	virtual void SdrRepeat(SdrView& rView);
	virtual FASTBOOL CanSdrRepeat(SdrView& rView) const;
};

//************************************************************
//   SdrUndoNewPage
//
// Einfuegen einer neuen Page.
// Action nach dem einfuegen in die Liste konstruieren.
//
//************************************************************

class SdrUndoNewPage : public SdrUndoPageList
{
public:
	SdrUndoNewPage(SdrPage& rNewPg): SdrUndoPageList(rNewPg) {}

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

//************************************************************
//   SdrUndoCopyPage
//
// Kopieren einer Page
// Action nach dem einfuegen in die Liste konstruieren.
//
//************************************************************

class SdrUndoCopyPage : public SdrUndoNewPage
{
public:
	SdrUndoCopyPage(SdrPage& rNewPg): SdrUndoNewPage(rNewPg) {}

	virtual String GetComment() const;
	virtual String GetSdrRepeatComment(SdrView& rView) const;

	virtual void SdrRepeat(SdrView& rView);
	virtual FASTBOOL CanSdrRepeat(SdrView& rView) const;
};

//************************************************************
//   SdrUndoSetPageNum
//
// Verschieben der Page innerhalb der Liste
// Action vor dem Verschieben der Page konstruieren.
//
//************************************************************

class SdrUndoSetPageNum : public SdrUndoPage
{
protected:
	USHORT						nOldPageNum;
	USHORT						nNewPageNum;

public:
	SdrUndoSetPageNum(SdrPage& rNewPg, USHORT nOldPageNum1, USHORT nNewPageNum1)
	:	SdrUndoPage(rNewPg),nOldPageNum(nOldPageNum1),nNewPageNum(nNewPageNum1) {}

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

////////////////////////////////////////////////////////////////////////////////////////////////////
//
//  @@   @@  @@@@   @@@@  @@@@@@ @@@@@ @@@@@   @@@@@   @@@@   @@@@  @@@@@  @@@@
//  @@@ @@@ @@  @@ @@  @@   @@   @@    @@  @@  @@  @@ @@  @@ @@  @@ @@    @@  @@
//  @@@@@@@ @@  @@ @@       @@   @@    @@  @@  @@  @@ @@  @@ @@     @@    @@
//  @@@@@@@ @@@@@@  @@@@    @@   @@@@  @@@@@   @@@@@  @@@@@@ @@ @@@ @@@@   @@@@
//  @@ @ @@ @@  @@     @@   @@   @@    @@  @@  @@     @@  @@ @@  @@ @@        @@
//  @@   @@ @@  @@ @@  @@   @@   @@    @@  @@  @@     @@  @@ @@  @@ @@    @@  @@
//  @@   @@ @@  @@  @@@@    @@   @@@@@ @@  @@  @@     @@  @@  @@@@@ @@@@@  @@@@
//
////////////////////////////////////////////////////////////////////////////////////////////////////

//************************************************************
//   SdrUndoPageMasterPage
//
// Abstrakte Basisklasse fuer alle UndoActions die mit
// MasterPage-Beziehungen zu tun haben.
//
//************************************************************

class SdrUndoPageMasterPage : public SdrUndoPage
{
protected:
	SdrMasterPageDescriptor*	pMasterDescriptor;
	SdrMasterPageDescriptor*	pNewMasterDescriptor;
	USHORT						nMasterNum;
	USHORT						nNewMasterNum;

protected:
	// Achtung! nMasterDescriptorNum ist nicht die Seitennummer
	// der MasterPage sondern die Position des MasterPage-Verweises
	// an der Page // (eine Page kann auf beliebig viele MasterPages
	// verweisen)
	SdrUndoPageMasterPage(SdrPage& rNewPg, USHORT nMasterDescriptorNum);

public:
	virtual ~SdrUndoPageMasterPage();
};

//************************************************************
//   SdrUndoPageInsertMasterPage
//
// Setzen einer MasterPage an einer Zeichenseite.
// Action nach dem Einfuegen des MasterPageDescriptors erzeugen.
//
//************************************************************

class SdrUndoPageInsertMasterPage : public SdrUndoPageMasterPage
{
public:
	SdrUndoPageInsertMasterPage(SdrPage& rNewPg, USHORT nMasterDescriptorNum)
	:	SdrUndoPageMasterPage(rNewPg,nMasterDescriptorNum) {}

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

//************************************************************
//   SdrUndoPageRemoveMasterPage
//
// Entfernen einer MasterPage von einer Zeichenseite.
// Action vor dem Entfernen des MasterPageDescriptors erzeugen.
//
//************************************************************

class SdrUndoPageRemoveMasterPage : public SdrUndoPageMasterPage
{
public:
	SdrUndoPageRemoveMasterPage(SdrPage& rNewPg, USHORT nMasterDescriptorNum)
	:	SdrUndoPageMasterPage(rNewPg,nMasterDescriptorNum) {}

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

//************************************************************
//   SdrUndoPageMoveMasterPage
//
// Verschieben einer MasterPage an einer Zeichenseite (Aendern
// der Reihenfolge der MasterPageDescriptorList).
// Action vor dem Umsortieren des MasterPageDescriptors erzeugen.
//
//************************************************************

class SdrUndoPageMoveMasterPage : public SdrUndoPageMasterPage
{
public:
	SdrUndoPageMoveMasterPage(SdrPage& rNewPg, USHORT nMasterDescriptorNum, USHORT nNewPos)
	:	SdrUndoPageMasterPage(rNewPg,nMasterDescriptorNum) { nNewMasterNum=nNewPos; }

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

//************************************************************
//   SdrUndoPageChangeMasterPage
//
// Aenderung des MasterPageDescriptors (z.B. Aendern der VisibleLayer).
// Action vor der Aenderung am MasterPageDescriptor erzeugen.
//
//************************************************************

class SdrUndoPageChangeMasterPage : public SdrUndoPageMasterPage
{
public:
	SdrUndoPageChangeMasterPage(SdrPage& rNewPg, USHORT nMasterDescriptorNum)
	:	SdrUndoPageMasterPage(rNewPg,nMasterDescriptorNum) {}

	virtual void Undo();
	virtual void Redo();

	virtual String GetComment() const;
};

////////////////////////////////////////////////////////////////////////////////////////////////////

#endif //_SVDUNDO_HXX

