windows-xp/Source/XPSP1/NT/windows/richedit/re41/_m_undo.h

/*
 *	_M_UNDO.H
 *
 *	Purpose:
 *		Declares multilevel undo interfaces and classes
 *
 *	Author:
 *		alexgo  3/25/95
 *
 *	Copyright (c) 1995-2000, Microsoft Corporation. All rights reserved.
 */

#ifndef __M_UNDO_H__
#define __M_UNDO_H__

#include "_callmgr.h"

// Forward declaration to get around dependency cycle
class CTxtEdit;
class IUndoBuilder;

/*
 *	MergeDataTypes
 *
 *	@enum	Tags indicating the different data types that can be
 *			sent in IAntiEvent::MergeData
 */
enum MergeDataTypes
{
	MD_SIMPLE_REPLACERANGE	= 1,	//@emem a simple replace range; 
									//usually just typing or backspace
	MD_SELECTIONRANGE		= 2		//@emem the selection location
};

/*
 *	SimpleReplaceRange
 *
 *	@stuct	SimpleReplaceRange | has the data from a replace range operation
 *			*except* for any deleted characters.  If we don't have to save
 *			the deleted characters, we don't.
 */
struct SimpleReplaceRange
{
	LONG	cpMin;		//@field	cpMin of new text
	LONG	cpMax;		//@field	cpMax of new text
	LONG	cchDel;		//@field 	number of characters deleted
};

/*
 *	SELAEFLAGS
 *
 *	@enum	Flags to control how the selection range info should be treated
 */
enum SELAE
{
	SELAE_MERGE = 1,
	SELAE_FORCEREPLACE	= 2
};

/*
 *	SelRange
 *
 *	@struct SelRange | has the data for a selection's location _and_ the 
 *			information needed to generate an undo action for the selection
 *			placement
 *	
 *	@comm	-1 may be used to NO-OP any field
 */
struct SelRange
{
	LONG	cp;			//@field	Active end
	LONG	cch;		//@field	Signed extension
	LONG	cpNext;		//@field	cp for the inverse of this action
	LONG	cchNext;	//@field	Extension for the inverse of this action
	SELAE	flags;		//@field	Controls how this info is interpreted
};

/*
 *	IAntiEvent
 *
 *	Purpose:
 *		Antievents undo 'normal' events, like typing a character
 */
class IAntiEvent 
{
public:
	virtual void Destroy( void ) = 0;

	// It should be noted that CTxtEdit * here is really just a general
	// closure, i.e. it could be expressed by void *.  However, since
	// this interface is currently just used internally, I've opted
	// to use the extra type-checking.  alexgo
	virtual HRESULT Undo( CTxtEdit *ped, IUndoBuilder *publdr ) = 0;

	// This method will let us merge in arbitrary data for things like
	// group typing
	virtual HRESULT MergeData( DWORD dwDataType, void *pdata) = 0;

	// This method is called when antievent is committed to undo stack.
	// Allows us to handle re-entrancy better for OLE objects.
	virtual void OnCommit(CTxtEdit *ped) = 0;

	// These two methods allow antievents to be chained together in
	// a linked list
	virtual	void SetNext(IAntiEvent *pNext) = 0;
	virtual IAntiEvent *GetNext() = 0;
protected:
	~IAntiEvent() {;}
};

/*
 *	IUndoMgr
 *
 *	Purpose:
 *		Interface for managing "stacks" of antievents
 */
class IUndoMgr
{
public:
	virtual void		Destroy () = 0;
	virtual LONG		SetUndoLimit (LONG cUndoLim) = 0;
	virtual LONG		GetUndoLimit () = 0;
	virtual HRESULT		PushAntiEvent (UNDONAMEID idName, IAntiEvent *pae) = 0;
	virtual HRESULT		PopAndExecuteAntiEvent (void* pAE) = 0;
	virtual UNDONAMEID	GetNameIDFromAE (void *pAE) = 0;
	virtual IAntiEvent *GetMergeAntiEvent () = 0;
	virtual void *		GetTopAECookie () = 0;
	virtual	void		ClearAll () = 0;
	virtual BOOL		CanUndo () = 0;
	virtual void		StartGroupTyping () = 0;
	virtual void		StopGroupTyping () = 0;

protected:
	~IUndoMgr() {;}
};

/*
 *	USFlags
 *
 *	@enum
 *		Flags affecting the behaviour of Undo stacks
 */
enum USFlags
{
	US_UNDO			= 1,	//@emem Regular undo stack
	US_REDO			= 2		//@emem	Undo stack is for REDO functionality
};
	
/*
 *	CUndoStack
 *	
 *	@class
 *		Manages a stack of antievents.  These antievents are kept in
 *		a resizable ring buffer.  Exports the IUndoMgr interface
 */
class CUndoStack : public IUndoMgr
{
//@access	Public Methods
public:
	virtual void	Destroy();					//@cmember Destroy
	virtual LONG	SetUndoLimit(LONG cUndoLim);//@cmember Set item limit
	virtual LONG	GetUndoLimit();
												//@cmember	Add an AE to stack
	virtual HRESULT PushAntiEvent(UNDONAMEID idName, IAntiEvent *pae);
												//@cmember Execute most recent
	virtual HRESULT PopAndExecuteAntiEvent(void *pAE);//   antievent or upto pAE  
	virtual UNDONAMEID GetNameIDFromAE(void *pAE);//@cmember Get name of given AE 
	virtual IAntiEvent *GetMergeAntiEvent();	//@cmember Get most recent AE
												//			of merge state
	virtual void *	GetTopAECookie();			//@cmember Get cookie for top AE
	virtual	void	ClearAll();					//@cmember Delete all AEs
	virtual BOOL	CanUndo();					//@cmember Something to undo?
	virtual void	StartGroupTyping();			//@cmember Starts group typing
	virtual void	StopGroupTyping();			//@cmember Stops group typing

	// Public methods; not part of IUndoMgr
	HRESULT	EnableSingleLevelMode();			//@cmember RE1.0 undo mode
	void	DisableSingleLevelMode();			//@cmember Back to RE2.0 mode
												//@cmember Are we in 1.0 mode?
	BOOL	GetSingleLevelMode() {return _fSingleLevelMode;}

	CUndoStack(CTxtEdit *ped, LONG &cUndoLim, USFlags flags);

private:
	~CUndoStack();

	struct UndoAction
	{
		IAntiEvent * pae;
		UNDONAMEID	 id;
	};

	void Next();						//@cmember Moves by 1
	void Prev();						//@cmember Moves by -1
	LONG GetPrev();						//@cmember Get previous index
										//@cmember TRUE iff cookie ae is in ae list
	BOOL IsCookieInList(IAntiEvent *pae, IAntiEvent *paeCookie);
										//@cmember Transfer this object to new stack
	void TransferToNewBuffer(UndoAction *prgnew, LONG dwLimNew);

	UndoAction *_prgActions;			//@cmember List of AEs
	LONG 		_cUndoLim;				//@cmember Undo limit
	LONG		_index;					//@cmember Current index
	CTxtEdit *	_ped;					//@cmember Big Papa

	DWORD		_fGroupTyping	  :1;	//@cmember Group Typing flag
	DWORD		_fMerge			  :1;	//@cmember Merge flag
	DWORD		_fRedo			  :1;	//@cmember Stack is the redo stack
	DWORD		_fSingleLevelMode :1;	//@cmember TRUE if single level undo
										// mode is on. Valid only for undo,
};										// i.e., not for redo stack

/*
 *	IUndoBuilder
 *
 *	Purpose:
 *		Provides a closure for collecting a sequence of antievents (such
 *		as all of the antievents involved in doing an intraedit drag-move
 *		operation.
 */
class IUndoBuilder
{
public:
	// Names antievent collection
	virtual void SetNameID( UNDONAMEID idName ) = 0;

	// Adds new antievent to collection
	virtual HRESULT AddAntiEvent( IAntiEvent *pae ) = 0;

	// Gets topmost antievent in this undo context.  This method
	// is useful for grouped typing (merging antievents)
	virtual IAntiEvent *GetTopAntiEvent() = 0;

	// Commits antievent collection
	virtual HRESULT Done() = 0;

	// Get rid of any antievents that have been collected
	virtual void Discard() = 0;

	// Notify that a group-typing session should start (forwarded
	// to the undo manager)
	virtual void StartGroupTyping() = 0;

	// Notify that a group-typing session should stop (forwarded
	// to the undo manager)
	virtual void StopGroupTyping() = 0;
};  

/*
 *	UBFlags
 *
 *	@enum
 *		Flags affecting the behaviour of Undo builders
 */
enum UBFlags
{
	UB_AUTOCOMMIT		= 1,	//@emem Call IUndoBuilder::Done before delete
	UB_REDO				= 2,	//@emem	Undo builder is for REDO functionality
	UB_DONTFLUSHREDO	= 4		//@emem Don't flush redo stack when adding
								//		antievents to undo stack
};

/*
 *	CGenUndoBuilder
 *
 *	@class
 *		A general purpose undo builder.  It can be easily allocated and freed
 *		on the stack and simply puts new antievents at the beginning of an
 *		antievent linked list.  NO attempt is made to optimize or reorder
 *		antievents.
 */
class CGenUndoBuilder : public IUndoBuilder, public IReEntrantComponent
{
//@access	Public methods
public:
	virtual void SetNameID( UNDONAMEID idName );	//@cmember Set the name
	virtual HRESULT AddAntiEvent(IAntiEvent *pae);	//@cmember Add an AE
	virtual IAntiEvent *GetTopAntiEvent( );			//@cmember Get top AE
	virtual HRESULT Done();							//@cmember Commit AEs
	virtual void Discard();							//@cmember Discard AEs
	virtual void StartGroupTyping();				//@cmember Start GT
	virtual void StopGroupTyping();					//@cmember Stop GT

	CGenUndoBuilder(CTxtEdit *ped, DWORD flags,		//@cmember Constructor
					IUndoBuilder **ppubldr = NULL);
	~CGenUndoBuilder( );							//@cmember Destructor

	// IReEntrantComponent methods
	virtual void OnEnterContext() {;}				//@cmember Reentered notify

//@access	Private methods
private:
	IUndoBuilder *	_publdrPrev;					//@cmember Ptr to undobldr
													//		   higher in stack
	IUndoMgr *		_pundo;							//@cmember Ptr to undo mgr
	CTxtEdit *		_ped;							//@cmember Ptr to edit contxt
	UNDONAMEID		_idName;						//@cmember Current name
	IAntiEvent *	_pfirstae;						//@cmember AE list
	UINT			_fAutoCommit:1;					//@cmember AutoCommit on?
	UINT			_fStartGroupTyping:1;			//@cmember GroupTyping on?
	UINT			_fRedo:1;						//@cmember UB destination is
													//		   the redo stack
	UINT			_fDontFlushRedo:1;				//@cmember Don't flush redo
													//	stack; i.e. we are
													//	invoking a redo action
	UINT			_fInactive:1;					//@cmember TRUE if undo enabled
};

/*
 *	CUndoStackGuard
 *
 *	@class
 *		A stack based class which helps manage reentrancy for the undo stack
 */
class CUndoStackGuard : public IReEntrantComponent
{
//@access	Public Methods
public:
	virtual void OnEnterContext();					//@cmember reentered notify

	CUndoStackGuard(CTxtEdit *ped);					//@cmember Constructor
	~CUndoStackGuard();								//@cmember Destructor
													//@cmember Execute the undo
	HRESULT SafeUndo(IAntiEvent *pae, IUndoBuilder *publdr);// actions in <p pae>
	BOOL	WasReEntered()  {return _fReEntered;}	//@cmember Return reentered flag 

//@access	Private Data
private:
	CTxtEdit *				_ped;					//@cmember Edit context
	volatile IAntiEvent *	_paeNext;				//@cmember Antievent loop ptr
	volatile HRESULT		_hr;					//@cmember Cached hr
	IUndoBuilder *			_publdr;				//@cmember Undo/redo context
	BOOL					_fReEntered;			//@cmember Have we been
};													//		   been reentered?

// Helper Functions. 

// Loop through a chain of antievents and destroy them
void DestroyAEList(IAntiEvent *pae);

// Loop through a chain of antievents and call OnCommit
void CommitAEList(CTxtEdit *ped, IAntiEvent *pae);

// Handles merging and/or creation of selection antievent info
HRESULT HandleSelectionAEInfo(CTxtEdit *ped, IUndoBuilder *publdr, 
			LONG cp, LONG cch, LONG cpNext, LONG cchNext, SELAE flags);

#endif // !__M_UNDO_H__