// $Id: ops.h 877 2006-04-24 17:15:07Z alex $ /* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE ================================XARAHEADERSTART=========================== Xara LX, a vector drawing and manipulation program. Copyright (C) 1993-2006 Xara Group Ltd. Copyright on certain contributions may be held in joint with their respective authors. See AUTHORS file for details. LICENSE TO USE AND MODIFY SOFTWARE ---------------------------------- This file is part of Xara LX. Xara LX is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. Xara LX and its component source files are 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 General Public License for more details. You should have received a copy of the GNU General Public License along with Xara LX (see the file GPL in the root directory of the distribution); if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ADDITIONAL RIGHTS ----------------- Conditional upon your continuing compliance with the GNU General Public License described above, Xara Group Ltd grants to you certain additional rights. The additional rights are to use, modify, and distribute the software together with the wxWidgets library, the wxXtra library, and the "CDraw" library and any other such library that any version of Xara LX relased by Xara Group Ltd requires in order to compile and execute, including the static linking of that library to XaraLX. In the case of the "CDraw" library, you may satisfy obligation under the GNU General Public License to provide source code by providing a binary copy of the library concerned and a copy of the license accompanying it. Nothing in this section restricts any of the rights you have under the GNU General Public License. SCOPE OF LICENSE ---------------- This license applies to this program (XaraLX) and its constituent source files only, and does not necessarily apply to other Xara products which may in part share the same code base, and are subject to their own licensing terms. This license does not apply to files in the wxXtra directory, which are built into a separate library, and are subject to the wxWindows license contained within that directory in the file "WXXTRA-LICENSE". This license does not apply to the binary libraries (if any) within the "libs" directory, which are subject to a separate license contained within that directory in the file "LIBS-LICENSE". ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS ---------------------------------------------- Subject to the terms of the GNU Public License (see above), you are free to do whatever you like with your modifications. However, you may (at your option) wish contribute them to Xara's source tree. You can find details of how to do this at: http://www.xaraxtreme.org/developers/ Prior to contributing your modifications, you will need to complete our contributor agreement. This can be found at: http://www.xaraxtreme.org/developers/contribute/ Please note that Xara will not accept modifications which modify any of the text between the start and end of this header (marked XARAHEADERSTART and XARAHEADEREND). MARKS ----- Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara designs are registered or unregistered trademarks, design-marks, and/or service marks of Xara Group Ltd. All rights in these marks are reserved. Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK. http://www.xara.com/ =================================XARAHEADEREND============================ */ /* Declaration of the following classes: ActionList: Class used by an Operation to store UNDO, REDO, and Smart Duplicate actions Operation: Class from which all Camelot operations are derived Action: Class from which all operations actions are derived */ /* * */ #ifndef INC_OPS #define INC_OPS #include "listitem.h" #include "list.h" #include "binds.h" #include "clikmods.h" #include "doccoord.h" #include "docrect.h" #include "opdesc.h" #include "range.h" //#include "basedoc.h" #include "selstate.h" //#include "bars.h" class Document; class DocView; class View; class OperationHistory; class Spread; class Node; class NodeHidden; class TransformBase; class KeyPress; class Action; class BaseDocument; /******************************************************************************************* < SystemBarType Comment: A number of hidden bars are created by the kernel during startup to group together OpDescriptors in sensible groups for the user. This enum allows each of those hidden bars to be uniquely identified. enum SystemBarType { SYSTEMBAR_ILLEGAL = 0, SYSTEMBAR_FILE, SYSTEMBAR_EDIT, SYSTEMBAR_ATTRIBUTE, SYSTEMBAR_ARRANGE, SYSTEMBAR_UTILITIES, SYSTEMBAR_WINDOW, SYSTEMBAR_VIEW = SYSTEMBAR_WINDOW, SYSTEMBAR_HELP, SYSTEMBAR_DEBUG SYSTEMBAR_FEATHER }; SeeAlso: SystemBarOp::FindType ********************************************************************************************/ enum SystemBarType { SYSTEMBAR_ILLEGAL = 0, SYSTEMBAR_FILE, SYSTEMBAR_EDIT, SYSTEMBAR_ATTRIBUTE, SYSTEMBAR_ARRANGE, SYSTEMBAR_UTILITIES, SYSTEMBAR_WINDOW, SYSTEMBAR_VIEW = SYSTEMBAR_WINDOW, // Alias VIEW to WINDOW for now... SYSTEMBAR_HELP, SYSTEMBAR_ANIMATION, SYSTEMBAR_TYPESETTING, SYSTEMBAR_DEBUG, SYSTEMBAR_FEATHER }; /******************************************************************************************** > class ActionList: public List Author: Simon_Maneggio (Xara Group Ltd) Created: 6/7/93 Purpose: An ActionList is a list object which holds actions which can be executed. It is used by Operation objects to hold UNDO, REDO and Smart duplicate actions. SeeAlso: Operation SeeAlso: Action ********************************************************************************************/ class CCAPI ActionList: public List { CC_DECLARE_MEMDUMP( ActionList ) public: ActionList(); ~ActionList(); BOOL ExecuteForwards(BOOL AllButLast); BOOL ExecuteBackwards(BOOL AllButLast, BOOL bIgnoreSelectActions = FALSE); // This function can be used to search the action list to see if it contains an action // with a specific runtime class. Action* FindActionOfClass(CCRuntimeClass* ClassOfActionToFind, Action* LastAction = NULL); }; // The Opflags structure is used by the operation class to hold information about // how an operation should behave when it ends. struct CCAPI OpFlgsStr { // TRUE when: BOOL Failed : 1; // Action could not be created BOOL ExecuteOnEnd : 1; // Execute all actions in End BOOL AllButLast : 1; // Execute all acts but last one in End BOOL KeepOnEnd : 1; // Not deleted in End BOOL UnwindingActions:1; // Op is being unwound BOOL HasOwnTimeIndicator:1; // Usually FALSE by default, however when TRUE indicates that // the operation should not use the default hourglass BOOL SucceedAndDiscard:1; // After the operation has finished all undo actions will be discarded BOOL DeleteOnEnd : 1; // After the operation has ended it will be deleted BOOL IgnoreSelectActions : 1; // Ignore selections when executing (for use when executing undo due to selection changes) }; // Current status of operation:- enum OperationStatus { UNDO, REDO, DO }; /******************************************************************************************** > class CUniversalParam Author: Luke_Hart (Xara Group Ltd) Created: 14/10/05 Purpose: Simple class that makes it possible to have parameters that can either be a pointer or an INT32 in a 64bit safe manner. ********************************************************************************************/ class CUniversalParam { private: union { void *m_pVal; INT32 m_lVal; }; public: CUniversalParam() : m_pVal( NULL ) {} CUniversalParam( void *p ) : m_pVal( p ) {} CUniversalParam( INT32 l ) : m_lVal( l ) {} void *operator =( void *p ) { return m_pVal = p; } INT32 operator =( INT32 l ) { return m_lVal = l; } operator void *() { return m_pVal; } operator INT32() { return m_lVal; } }; /******************************************************************************************** > class OpParam Author: Simon_Maneggio (Xara Group Ltd) Created: 9/6/94 Purpose: Operation parameter structure. The meaning of the structure's fields are defined by each operation. Note that sensible Operations will derive a special OpParam for their own specific needs, so you should use the derived class where it is available. SeeAlso: Operation::DoWithParam ********************************************************************************************/ class OpParam : public CCObject { CC_DECLARE_DYNAMIC(OpParam) public: OpParam() { Param1 = Param2 = INT32(0); Output = NULL; } OpParam(CUniversalParam P1, CUniversalParam P2) { Param1 = P1; Param2 = P2; Output = 0; } OpParam(CUniversalParam P1, CUniversalParam P2, BOOL* Out) { Param1 = P1; Param2 = P2; Output = Out; } CUniversalParam Param1; CUniversalParam Param2; BOOL *Output; }; /******************************************************************************************** > class Operation : public MessageHandler Author: Simon_Maneggio (Xara Group Ltd) Created: 6/7/93 Purpose: This abstract class represents an operation which is a single job initiated by the user. You should derive all non undoable operations directly from this base class. SeeAlso: OperationHistory SeeAlso: UndoableOperation ********************************************************************************************/ class CCAPI Operation : public MessageHandler { CC_DECLARE_DYNCREATE( Operation ) public: virtual void OnClickWhileDragging(OilCoord PointerPos, ClickType Click, ClickModifiers Mods, BOOL bSolidDrag); Operation(CCRuntimeClass* MsgHandlerClass = CC_RUNTIME_CLASS(Operation)); virtual ~Operation(); static BOOL Initialise(); virtual void End(); // Mark H virtual Matrix GetCurrentMatrix() { return Matrix(); }; UINT32 GetSize(); static Operation* GetCurrentDragOp(); virtual BOOL SnappingDrag() { return TRUE; } // Event handler functions called by DocView/CCamView... virtual void DragPointerMove( DocCoord PointerPos, ClickModifiers ClickMods, Spread *pSpread, BOOL bSolidDrag); virtual void DragPointerIdle( DocCoord PointerPos, ClickModifiers ClickMods, Spread *pSpread, BOOL bSolidDrag); virtual void DragFinished( DocCoord PointerPos, ClickModifiers ClickMods, Spread *pSpread, BOOL Success, BOOL bSolidDrag); virtual BOOL DragKeyPress(KeyPress* pKeyPress, BOOL bSolidDrag); virtual void DragModeChanged(BOOL bSolidDrag); // Function to translate coord from one spread to another. DocCoord MakeRelativeToSpread(Spread *Dest, Spread *Src, DocCoord); // Function to allow operations to render something during a drag virtual void RenderDragBlobs(DocRect, Spread*, BOOL bSolidDrag); // Function called on idle events if required virtual BOOL OnIdleEvent(); // These Fail functions tell the Op what to do when it ends. void FailAndExecute(); void FailAndExecuteAllButLast(); void FailAndDiscard(); void FailAndExecuteIgnoreSelActions(); // When called operation will not be undoable void SucceedAndDiscard(); // These two functions execute the appropriate action list. virtual BOOL Undo(); virtual BOOL Redo(); // This function asks the operation to Do itself again. Notice that DoSmart // can be polymorphic because no smart functions can take params - they // all work on the selection. virtual void DoSmart(); // This function is the polymorphic one to be used to Do all simple Operations. All subclasses // of Operation will implement there own DO function maintaining the same interface as // below in order for the Do function to work with all simple Operations. (This will be // particularly useful for implementing Menu Operations!) virtual void Do(OpDescriptor*); // Same as Do except it allows a parameter to be passed - Yes I know this is a bit yuk // but at least is saves me changing every Do function in Camelot. virtual void DoWithParam(OpDescriptor*, OpParam* pOpParam); OpFlgsStr GetOpFlgs(); BOOL OpHasFailed() const {return OpFlags.Failed;} void DeleteOnEnd(); void KeepOnEnd() {OpFlags.KeepOnEnd = TRUE;} ActionList* GetUndoActionList(); ActionList* GetRedoActionList(); OperationStatus OpStatus; // When doing the operation for the first time equals DO // When UNDOING the operation equals UNDO // when REDOING the operation equals REDO // Utility methods required by the ALLOC_WITH_FAIL macro BOOL UserWantsToDeleteUndoOps(); void OperationMemoryFailure(); // Find out which document/(doc)view this operation is working on. Document *GetWorkingDoc() { return pOurDoc; } View *GetWorkingView() { return pOurView; } DocView *GetWorkingDocView(); // Retrieve The Operations Name virtual void GetOpName(String_256*); // interogates the current (drag) Operation for statusLine text virtual BOOL GetStatusLineText(String_256* pText, Spread* pSpread, DocCoord DocPos, ClickModifiers ClickMods); // Call this function from the Operation's Init method to register the operations OpDescriptor static BOOL RegisterOpDescriptor( UINT32 toolID, // Module (Tool) Identifier UINT32 txID, // String Resource ID CCRuntimeClass* RuntimeClass, // The operations runtime class TCHAR* tok, // pointer to the token string pfnGetState gs, // pointer to the GetState function UINT32 helpId = 0, // help identifier UINT32 bubbleID = 0, // string resource for bubble help UINT32 resourceID = 0, // resource ID UINT32 controlID = 0, // control ID SystemBarType GroupBarID = SYSTEMBAR_ILLEGAL, // group bar ID BOOL ReceiveMessages = TRUE, // BODGE BOOL Smart = FALSE, BOOL Clean = TRUE, OpDescriptor *pVertOpDesc = NULL, UINT32 OneOpenInstID = 0, UINT32 AutoStateFlags = 0, BOOL fCheckable = FALSE ); // These functions should be used in conjuction with Node::AllowOp() or Range::AllowOp() to allow // the op to work when select-inside is present. // Calling these functions should ensure that parent nodes update themselves when an op is applied to // their children virtual BOOL UpdateChangedNodes(ObjChangeParam* pParam,Spread* pSpread = NULL); virtual BOOL UpdateChangedNode(ObjChangeParam* pParam,Node* pNode); // This varient will update all nodes in all the docs in the application virtual BOOL UpdateAllChangedNodes(ObjChangeParam* pParam); // This will update all nodes in the given document virtual BOOL UpdateChangedNodes(ObjChangeParam* pParam,Document* pDoc); // Dumps the undo/redo action lists to the debugger virtual void Dump(); static BOOL GetQuickRender(Node* pNode); static void SetQuickRender(BOOL bNewState, Operation* pQROp = NULL); protected: // Functions called by subclasses of Operation... BOOL StartDrag( DragType type, DocRect* MoveBBox = NULL, DocCoord* StartPos = NULL, BOOL KeepAccuracy = TRUE, BOOL bSolidDragSupported = FALSE); BOOL EndDrag(void); void EndOp(); // The old End() function // Operation flags structure OpFlgsStr OpFlags; // Points to the document/view this Operation is associated with when "live". // // NB. pOurView is usually NULL as many operations don't care which or many views are // associated with the document, but some do - e.g. changing rendering quality, // zooming in and out, etc. Document* pOurDoc; View* pOurView; // UNDO/REDO lists. // Note: At any given time ONE of these lists MUST be empty. This means that there is no // need to store flags to indicate if the operation is for UNDO or REDO. If UndoActions // contains any actions then the operation can be undone, else the operation can be // redone. ActionList UndoActions; ActionList RedoActions; // Actions for smart duplicate ActionList SmartActions; public: // Somebody might want to invoke an action given an undoable op pointer. At this point, they // will need access to the action lists. So give them a public access function. // Only use these if you know what you are doing! // Should be const but of course then nothing would work! ActionList * GetUndoActions() { return &UndoActions; } ActionList * GetRedoActions() { return &RedoActions; } ActionList * GetSmartActions() { return &SmartActions; } private: // The string OpName should be defined in a subclass of operation and be returned // by the GetName() function. It is not defined for the operation class. // static String OpName; // The name of the operation object // For drag operations CurrentDragOp will be a pointer to the Operation which should // receive mouse movement events during the drag. It will ensure that only one // operation can perform a drag at a time and that keypress events cannot change the // state of the document while a drag is taking place. static Operation* CurrentDragOp; // The DeleteUndoOpsToMake space flag is set to TRUE after the user responds YES to the // question "do you want to delete undo operations to make space for the current operation ?". // It is required so that the user is not asked the same question more than once in performing // the operation (The next time YES will be taken as the default). It will be reset to FALSE // when the operation ends. BOOL DeleteUndoOpsToMakeSpace; // In the operations End method if pDocToInformOfOpStatus is not NULL then // If the operation has failed AbortComponent copy is called on the document // else EndComponentCopy is called. BaseDocument* pDocToInformOfOpStatus; // Vars to do with stopping auto-repeat keys during drags static INT32 CurKeyboardSpeed; static BOOL ResetKeyboardSpeed; static BOOL KeyboardRepeatOffDuringDrags; static BOOL s_bQuickRender; public: void InformDocComponentsOfOperationsOutcome(BaseDocument* pDoc) { pDocToInformOfOpStatus = pDoc; }; }; enum ActionCode { AC_FAIL, AC_OK, AC_NORECORD }; /******************************************************************************************** > class Action: public ListItem Author: Simon_Maneggio (Xara Group Ltd) Created: 6/7/93 Purpose: This class represents an Action which is an individual job which is executed to accomplish an operation. An operation contains lists of actions to perform Undo, Redo and Smart Duplication. SeeAlso: Operation ********************************************************************************************/ class CCAPI Action: public ListItem { CC_DECLARE_DYNCREATE( Action ) friend class OperationHistory; public: Action(); virtual ~Action(); virtual void Slaughter(); // A more extreme form of destruction virtual ActionCode Execute(); static ActionCode Init(Operation* pOp, ActionList* pActionList, UINT32 Size, CCRuntimeClass* ActionClass, Action** NewAction); // If IsDiscardableAction returns TRUE then it indicates that it can be deleted after the // operation ends. It indicates that the action never does anything and so is dead-wood. virtual BOOL IsADiscardableAction() { return FALSE; } // Find out which document/(doc)view this action is working on. Document *GetWorkingDoc() { return pOperation->GetWorkingDoc(); } View *GetWorkingView() { return pOperation->GetWorkingView(); } DocView *GetWorkingDocView() { return pOperation->GetWorkingDocView(); } UINT32 GetSize(); // Dumps the action list to the dubugger virtual void Dump(); BOOL TransferToOtherOp(Operation* pOtherOp, ActionList* pAddActions, ActionList* pOtherActions); protected: Operation* pOperation; // Pointer to the operation to which the action is attached. It // is neccessary to store this because executing an action will // usually cause a new action to be created, and Operation is // required as an argument to the new action's Init method. ActionList* pOppositeActLst; // A pointer to the opposite action list. This is really useful // to know, especially when an Action is used both to Undo and Redo. // If the action is on the UndoActionList then pOppositeActLst // will point to the RedoActionList, and visa versa. UINT32 Size; // The total size of the action in bytes. It is neccessary to // store this because before the action is deleted the size of the // operation history needs to be reduced by the size of the action. // *** This is what LastDiscardableAction USED to be - see below for it's new friendly // purpose. // When an Action fails in the Init function this can be due to either there not being // enough system memory, or because there is not enough space in the Operation History for // the Action. In the later case an instance of the action will exist and // LastDiscardable action will be set to point at the action. When Init is called the next // time it will be deleted. //static Action* LastDiscardableAction; }; /******************************************************************************************** > ALLOC_WITH_FAIL(Ptr, AllocExpr, pOp) \ Author: Simon_Maneggio (Xara Group Ltd) Created: 4/8/93 Inputs: Ptr: The pointer or handle to the object being allocated AllocExpr: The expression to allocate memory (e.g. new Blobby(x,y,z) ) pOp: A pointer to the operation for which memory is being allocated. Outputs: - Returns: - Purpose: This macro should be used whenever you want to allocate any memory in an operation.It initially tries to allocate system memory, if it fails then it prompts the user to see if they want to delete undo operations to try and make room. If after deleting undo operations memory still cannot be allocated then FailAndExecute() is called and a NULL Ptr is returned. The macro is fairly long and may be replaced by a series of functions one for each type of memmory allocation. Errors: - SeeAlso: CALL_WITH_FAIL ********************************************************************************************/ #define ALLOC_WITH_FAIL(Ptr, AllocExpr, pOp) \ { \ (Ptr) = (AllocExpr); \ if ( (Ptr) == NULL && (pOp) != NULL ) \ { \ OperationHistory& OpHist = pOp->GetWorkingDoc()->GetOpHistory(); \ /* If the operation is unwinding then we can't afford the luxury of asking the */ \ /* user */ \ if (((pOp)->GetOpFlgs().UnwindingActions) || ((pOp)->UserWantsToDeleteUndoOps())) \ { \ /* The user wants to try deleting undo records to make space for the action*/ \ BOOL NoMoreUndoOpsToDelete = FALSE; \ /* Repeatedly delete undo operations to try and create enough room for the \ allocation. */ \ do \ { \ /* Reduce the size of the operation history by deleting a single undo */ \ /* operation */ \ if ((OpHist.ReduceSize((OpHist.GetSize()-1), TRUE)) == FALSE) \ NoMoreUndoOpsToDelete = TRUE; \ \ } while ( (((Ptr) = (AllocExpr)) == NULL) \ && (!NoMoreUndoOpsToDelete) ); \ \ if (NoMoreUndoOpsToDelete) \ (pOp)->OperationMemoryFailure(); \ } \ else \ { \ pOp->FailAndExecute(); \ } \ } \ } /******************************************************************************************** > CALL_WITH_FAIL(fn, pOp, Success) Author: Simon_Maneggio (Xara Group Ltd) Created: 4/8/93 Inputs: fn: the function to call pOp: A pointer to the operation for which memory is being allocated. Outputs: Success: A BOOL variable which is TRUE if the function could be executed with a TRUE return value. Returns: - Purpose: This MACRO is the same as the ALLOC_WITH_FAIL except that it repeatedly calls a function which tries to allocate memory. The function must return a TRUE/FALSE success status. Errors: - SeeAlso: ALLOC_WITH_FAIL ********************************************************************************************/ #define CALL_WITH_FAIL(fn,pOp,Success) \ { \ Success = FALSE; \ if ( !(fn) ) \ { \ if ( (pOp) != NULL ) \ { \ OperationHistory& OpHist = (pOp)->GetWorkingDoc()->GetOpHistory(); \ if ( ((pOp)->GetOpFlgs().UnwindingActions) || (pOp)->UserWantsToDeleteUndoOps()) \ { \ /* The user wants to try deleting undo records to make space for the action*/ \ BOOL NoMoreUndoOpsToDelete = FALSE; \ /* Repeatedly delete undo operations to try and create enough room for the \ allocation. */ \ do \ { \ /* Reduce the size of the operation history by deleting a single undo */ \ /* operation */ \ if ((OpHist.ReduceSize((OpHist.GetSize()-1), TRUE)) == FALSE) \ NoMoreUndoOpsToDelete = TRUE; \ \ } while ( (!(fn)) \ && (!NoMoreUndoOpsToDelete) ); \ \ if (NoMoreUndoOpsToDelete) \ { \ (pOp)->OperationMemoryFailure(); \ } \ else \ { \ Success = TRUE; \ } \ } \ else \ { \ (pOp)->FailAndExecute(); \ } \ } \ } \ else \ { \ Success = TRUE; \ } \ } \ /******************************************************************************************** > class InvalidateRegionAction: public Action Author: Simon_Maneggio (Xara Group Ltd) Created: 13/9/93 Purpose: When executed this action will Force a redraw of the bounding rectangles of each node in a range. SeeAlso: - ********************************************************************************************/ class CCAPI InvalidateRegionAction: public Action { CC_DECLARE_DYNCREATE( InvalidateRegionAction ) public: InvalidateRegionAction(); virtual ActionCode Execute(); static ActionCode Init(Operation* const pOp, ActionList* pActionList, Range nodeRange, // The range on nodes we want to invalidate Spread* pSpread, BOOL includeBlobs, Action** NewAction); protected: Range NodeRange; BOOL IncludeBlobs:1; Spread* pSpread; // We need to be able to invalidate the region of a hidden node, // so we must store a copy of the spread. }; /******************************************************************************************** > class InvalidateRegionIfBgRedrawAction: public InvalidateRegionAction Author: Will_Cowling (Xara Group Ltd) Created: 10/5/95 Purpose: When executed this action will Force a redraw of the bounding rectangles of each node in a range. This version will only invalidate the region if Background Redraw is in progress. SeeAlso: - ********************************************************************************************/ class InvalidateRegionIfBgRedrawAction: public InvalidateRegionAction { CC_DECLARE_DYNCREATE( InvalidateRegionIfBgRedrawAction ) public: InvalidateRegionIfBgRedrawAction(); virtual ActionCode Execute(); static ActionCode Init(Operation* const pOp, ActionList* pActionList, Range nodeRange, // The range on nodes we want to invalidate Spread* pSpread, BOOL includeBlobs, Action** NewAction); }; /******************************************************************************************** > class HideNodeAction: public Action Author: Simon_Maneggio (Xara Group Ltd) Created: 13/9/93 Purpose: When executed this action will hide a node. It will also generate a ShowNodeAction action adding it to the opposite Action list. SeeAlso: ShowNodeAction ********************************************************************************************/ class CCAPI HideNodeAction: public Action { CC_DECLARE_DYNCREATE( HideNodeAction ) public: HideNodeAction(); virtual ActionCode Execute(); static ActionCode Init(Operation* const pOp, ActionList* pActionList, Node* NodeToHide, BOOL IncludeSubtreeSize, Action** NewAction, BOOL TellSubtree = TRUE); CCRuntimeClass* GetClassOfAttrNodeToHide() const { return ClassOfAttributeToHide; } void RecordTag(Node* NodeToHide); private: // When we generate a HideNodeAction for a non attribute node, we need to simply store // a pointer to the node, as we can be sure that this node will be around when we come to // execute this action. // However if we are generating a HideNodeAction for an attribute then things are different. // During attribute optimisation attribute nodes can get deleted, so storing a pointer to // the attribute node is a bad idea. Instead we store a pointer to the attribute's parent (which can't // be an attribute, so can't get deleted), and the RuntimeClass of the attribute. We can then // find the attribute by searching for it. Node* node; // node which should be hidden when HideNodeAction is executed. If the node // to be hidden is an attribute however then this node will be the attribute's // parent (see the notes below). CCRuntimeClass* ClassOfAttributeToHide; // If the node being hidden is a NodeAttribute then // node will point to the attribute's parent (see above) // and ClassOfAttributeToHide will be the runtime class // of the attribute which should be hidden. When this // action is executed if ClassOfAttributeToHide is // non NULL then we know that it is an attribute that we // must hide, so we search for it. TAG m_nHiddenWixAttrTag; // If the node being hidden is a Wix attribute then this // holds its tag so it can be properly identified by the // Execute() function. Wix attributes are not optimised // and also unlike other attributes, more than one of the // same kind can apply to an object. // The size of a HideNodeAction is always sizeof(HideNodeAction), however the // IncludeSubtreeSize flag is required to pass to the twin ShowNodeAction. BOOL IncludeSubtreeSize:1; BOOL TellSubtree:1; BOOL m_bEffect:1; }; /******************************************************************************************** > class ShowNodeAction: public Action Author: Simon_Maneggio (Xara Group Ltd) Created: 13/9/93 Purpose: When executed this action will show a node. It will also generate a HideNodeAction action adding it to the opposite Action list. SeeAlso: HideNodeAction ********************************************************************************************/ class CCAPI ShowNodeAction: public Action { CC_DECLARE_DYNCREATE( ShowNodeAction ) public: ShowNodeAction(); virtual ~ShowNodeAction(); virtual void Slaughter(); virtual ActionCode Execute(); static ActionCode Init(Operation* const pOp, ActionList* pActionList, NodeHidden* HiddenToShow, BOOL IncludeSubtreeSize, Action** NewAction, BOOL TellSubtree = TRUE); private: NodeHidden* node; // We need to store an IncludeSubtreeSize flag because when we create the twin // HideNodeAction it is required as a parameter. BOOL IncludeSubtreeSize:1; BOOL TellSubtree:1; }; /******************************************************************************************** > class UnApplyAction: public Action Author: Phil_Martin (Xara Group Ltd) Created: 26/07/2005 Purpose: When executed this action will hide a node. It will also generate a ShowNodeAction action adding it to the opposite Action list. SeeAlso: ShowNodeAction ********************************************************************************************/ class CCAPI UnApplyAction: public Action { CC_DECLARE_DYNCREATE( UnApplyAction ) friend class OpApplyAttrInteractive; public: UnApplyAction(); ~UnApplyAction(); virtual ActionCode Execute(); static ActionCode Init(Operation* const pOp, ActionList* pActionList, Node* pActionNode, NodeAttribute* pActionAttribute, BOOL IncludeSubtreeSize, Action** NewAction, BOOL TellSubtree = TRUE); // CCRuntimeClass* GetClassOfAttrNodeToHide() const // { return ClassOfAttributeToHide; } void RecordTag(NodeAttribute* pAttr); private: Node* m_pApplyNode; NodeAttribute* m_pAttribute; TAG m_nAttrTag; // If the node being hidden is a Wix attribute then this // holds its tag so it can be properly identified by the // Execute() function. Wix attributes are not optimised // and also unlike other attributes, more than one of the // same kind can apply to an object. // The size of a HideNodeAction is always sizeof(HideNodeAction), however the // IncludeSubtreeSize flag is required to pass to the twin ShowNodeAction. BOOL IncludeSubtreeSize:1; BOOL TellSubtree:1; }; /******************************************************************************************** > class ApplyAction: public Action Author: Phil_Martin (Xara Group Ltd) Created: 26/07/2005 Purpose: When executed this action will show a node. It will also generate a HideNodeAction action adding it to the opposite Action list. SeeAlso: HideNodeAction ********************************************************************************************/ class CCAPI ApplyAction: public Action { CC_DECLARE_DYNCREATE( ApplyAction ) friend class OpApplyAttrInteractive; public: ApplyAction(); virtual ~ApplyAction(); virtual ActionCode Execute(); static ActionCode Init(Operation* const pOp, ActionList* pActionList, Node* pActionApplyNode, NodeAttribute* pActionAttribute, BOOL IncludeSubtreeSize, Action** NewAction, BOOL TellSubtree = TRUE); private: Node* m_pApplyNode; NodeAttribute* m_pAttribute; // We need to store an IncludeSubtreeSize flag because when we create the twin // HideNodeAction it is required as a parameter. BOOL IncludeSubtreeSize:1; BOOL TellSubtree:1; }; /******************************************************************************************** > class RestoreSelectionsAction: public Action Author: Simon_Maneggio (Xara Group Ltd) Created: 13/9/93 Purpose: When executed this action will restore the selection state of the document. It will also spawn another identical RestoreSelectionsAction adding and add it to the opposite action list. SeeAlso: - ********************************************************************************************/ class CCAPI RestoreSelectionsAction: public Action { CC_DECLARE_DYNCREATE( RestoreSelectionsAction ) public: RestoreSelectionsAction(); ~RestoreSelectionsAction(); void Slaughter(); virtual ActionCode Execute(); static ActionCode Init(Operation* const pOp, ActionList* pActionList, SelectionState* SelState, BOOL Toggle, BOOL ToggleStatus, BOOL SelStateShared, BOOL RenderStartBlobs, BOOL RenderEndBlobs, BOOL StartRestore, Action** NewAction); SelectionState* GetSelState() { return SelState; }; private: SelectionState* SelState; // Selection state which will be restored when the action is // executed. // If toggle is true then the ToggleStatus determines if the selections are restored // or not. See Init method if you are confused. BOOL toggle:1; BOOL toggleStatus:1; BOOL SelStateShared:1; // If the SelState is shared by a pair of RestoreSelActions // then the SelState will only be deleted when ToggleStatus = TRUE BOOL RenderStartBlobs:1; BOOL RenderEndBlobs:1; BOOL StartRestore:1; // Is this the first restore executed when the operation is undone/redone }; /******************************************************************************************** > class SelectDeselectAction: public Action Author: Simon_Maneggio (Xara Group Ltd) Created: 13/9/93 Purpose: When executed this action will render node's selection blobs (which could remove them) and set it's selection state. If the node is currently selected then the node is deselected. If the node is currently deselected it is selected. It creates a second SelectDeselectAction for the node and adds it to the opposite action list. SeeAlso: - ********************************************************************************************/ class CCAPI SelectDeselectAction: public Action { CC_DECLARE_DYNCREATE( SelectDeselectAction ) public: SelectDeselectAction(); ~SelectDeselectAction(); virtual ActionCode Execute(); static ActionCode Init(Operation* const pOp, ActionList* pActionList, Node* SelDeNode, Spread* pSpread, Action** NewAction); Node* node; // The node which will be selected/deselected Spread *Parent; }; /******************************************************************************************** > class TransformNodeAction: public Action Author: Simon_Maneggio (Xara Group Ltd) Created: 13/9/93 Purpose: When executed this action will transform a range of NodeRenderableInk nodes. It also creates another TransformNodeAction to 'undo' the transformation just performed. It adds this action to the opposite action list. SeeAlso: - ********************************************************************************************/ class CCAPI TransformNodeAction: public Action { CC_DECLARE_DYNCREATE( TransformNodeAction ) public: TransformNodeAction(); ~TransformNodeAction(); void Slaughter(); virtual ActionCode Execute(); static ActionCode Init(Operation* const pOp, ActionList* pActionList, Range NodeRangeIn, TransformBase* Trans, List * pNodeList, Action** NewAction); // For op merging void CombineWith(TransformNodeAction* pMatrixTransformAction); TransformBase* GetTransform(); const Range* GetActionRange() const {return &NodeRange;} private: Range NodeRange; // the list of parent-promoted nodes in the first range List * m_pNodeList; TransformBase* pTrans; // The transform to apply to every node in the range }; #endif