diff -r 000000000000 -r 1fb32624e06b textrendering/textformatting/undo/UndoSystemImpl.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/textrendering/textformatting/undo/UndoSystemImpl.h Tue Feb 02 02:02:46 2010 +0200 @@ -0,0 +1,286 @@ +/* +* Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + +#ifndef UNDOSYSTEMIMPL_H_ +#define UNDOSYSTEMIMPL_H_ + +#include +#include "UndoSystem.h" + +namespace UndoSystem +{ +class CCommand; +class CSingleCommand; +class CBatchCommand; + +/** + * Undo panic codes + * + * @internalComponent + */ +enum TPanicCode + { + /** + * CSingleCommand::PrepareToAddInverseToLast() overridden to return ETrue, but + * CSingleCommand::AddInverseToLast() not overridden. + */ + KAddToLastOnlyHalfImplemented = 1, + /** + * CCommandStack or CSingleCommandStack::Pop() called on an empty stack + */ + KCommandStackUnderflow, + /** + * CCommandStack or CSingleCommandStack::Push() called without adequate + * space being reserved via PrepareToPushL() + */ + KCommandStackPushNotPrepared, + /** + * No shared undo system passed when expected + */ + KEditorUndoNoCommandManager + }; + +/** + * Panic from Undo DLL + * + * @internalComponent + */ +void Panic(TPanicCode aCode); + +/** + * Stack of commands. A bookmark is maintianed so that we can tell if the stack + * is in the same state it was at a previous time. + * + * @internalComponent + * @since App-frameworks6.1 + */ +NONSHARABLE_CLASS(CCommandStack) : public CBase + { +public: + static CCommandStack* NewL(); + ~CCommandStack(); + CCommandStack(); + void ConstructL(); + + CCommand* Top() const; + CCommand* Pop(); + /** + * Allows aNumberOfItems Push()s to be done before the next + * call to another non-const member function apart from Push(). + * aNumberOfItems must be non-negative. + */ + void PrepareToPushL(TInt aNumberOfItems); + void Push(CCommand* aCommand); + void PruneTo(TInt aNumberOfItems); + TInt Count() const; + /** + * Removes all elements from the stack and deletes the bookmark. + */ + void Reset(); + /** + * Adds aStack to the top of this CCommandStack, emptying it completely. + * Enough items must have been reserved with PrepareToPushL(TInt). + */ + void Concatenate(CCommandStack& aStack); + /** + * Sets the current position in the stack as the location of the bookmark. + * The bookmark will be lost if the bookmarked object is removed from the + * stack. Bookmark begins set at the zero position. + */ + void SetBookmark(); + /** + * Returns true iff we are at the current bookmark position. + */ + TBool IsAtBookmark() const; + +private: + CArrayFix* iStack; + /** + * One-past-top element in the array. Less than Count() after a call + * to PrepareToPushL() with non-zero argument. + */ + TInt iEnd; + /** + * The bookmark into the stack. We are at the bookmark when iEnd == + * iBookmark. No bookmark is represented by iBookmark < 0. + */ + TInt iBookmark; + }; + +/** + * Stack of single commands + * + * @internalComponent + * @since App-frameworks6.1 + */ +class CSingleCommandStack : public CBase + { +public: + static CSingleCommandStack* NewL(); + + inline CSingleCommand* Top() const; + inline CSingleCommand* Pop(); + inline void PrepareToPushL(TInt aNumberOfItems); + inline void Push(CSingleCommand* aCommand); + inline void PruneTo(TInt aNumberOfItems); + inline TInt Count() const; + inline void Reset(); + inline void Concatenate(CSingleCommandStack& aStack); + +private: + CSingleCommandStack() {} + + CCommandStack iStack; + }; + +/** + * A stack of commands supporting batching and a flag for whether a batch + * has had its undo option waived. A bookmark is also supported, so that we can + * tell whether the history is in the same state as it was at a previous time. + * + * @internalComponent + * @since App-frameworks6.1 + */ +NONSHARABLE_CLASS(CCommandHistory) : public CBase + { +public: + ~CCommandHistory(); + static CCommandHistory* NewL(); + + /** + * Returns the command at the top of the stack. + */ + CCommand* Top() const; + /** + * Returns the single command at the top of the stack. + */ + CSingleCommand* TopSingleCommand() const; + /** + * Allocates enough resources for one call to AddCommand(CCommand* aCommand). + */ + void PrepareToAddCommandL(CCommand* aCommand); + /** + * Adds the command to the top of the stack. PrepareToAddCommandL() must + * have been called successfully since the last call to AddCommand or NewL. + */ + void AddCommand(CCommand*); + /** + * Returns ETrue iff SetUndoWaived() has been called during this batch. If + * there is no batch currently open, this function will always return + * EFalse. + */ + TBool UndoHasBeenWaived() const; + /** + * Sets a flag to indicated that undo is not required for this current + * batch. This function has no effect if there is no batch currently open. + * + * @see UndoHasBeenWaived + */ + void SetUndoWaived(); + /** + * Sets the maximum height of the stack to aMaxItems. If it is exceeded, + * the stack is truncated to aPrunedItems. + */ + void SetMaxItems(TInt aMaxItems); + /** + * Returns ETrue iff the stack has no elements. + */ + TBool IsEmpty() const { return Top()? EFalse : ETrue; } + /** + * Begins a new batch. All commands added subsequently will be exeuted all + * at once. Close the batch with CleanupStack::PopAndDestroy(); + */ + void BeginBatchLC(); + /** + * Returns ETrue iff there is a batch currently open. + */ + TBool IsWithinBatch() const; + /** + * Removes and returns the top element. There must be no batch currently + * open before a call to Pop(). + */ + CCommand* Pop(); + /** + * Removes all elements from the stack. If a batch is currently open, any + * commands added subsequently will not be added to it. Deletes the + * bookmark. + */ + void Reset(); + /** + * Removes and destroys the top element iff it is an empty batch. Must not + * be called if a batch is currently open. + */ + void Clean(); + /** + * Sets the bookmark to the current position. + */ + void SetBookmark(); + /** + * Returns true iff the bookmark is at the current position. + */ + TBool IsAtBookmark(); + +private: + + CCommandHistory(); + void ConstructL(); + void Prune(); + + static void CloseBatch(void* aCCommandHistory); + static void DownBatchLevel(void* aCCommandHistory); + + CCommandStack* iStack; + CBatchCommand* iCurrent; // either == 0 or points to the most + // recent CBatchCommand within iStack + + TInt iMaxItems; + + TBool iBatchUndoHasBeenWaived; + }; + +// +// CSingleCommandStack inlines +// +CSingleCommand* CSingleCommandStack::Top() const + { return static_cast(iStack.Top()); } + +CSingleCommand* CSingleCommandStack::Pop() + { return static_cast(iStack.Pop()); } + +void CSingleCommandStack::PrepareToPushL(TInt aNumberOfItems) + { iStack.PrepareToPushL(aNumberOfItems); } + +void CSingleCommandStack::Push(CSingleCommand* aCommand) + { iStack.Push(aCommand); } + +void CSingleCommandStack::PruneTo(TInt aNumberOfItems) + { iStack.PruneTo(aNumberOfItems); } + +TInt CSingleCommandStack::Count() const + { return iStack.Count(); } + +void CSingleCommandStack::Reset() + { iStack.Reset(); } + +void CSingleCommandStack::Concatenate(CSingleCommandStack& aStack) + { iStack.Concatenate(aStack.iStack); } + +} + +#endif +