UndoableOperation Class Reference

All Undoable operations should be derived from this class. More...

#include <undoop.h>

Inheritance diagram for UndoableOperation:

List of all members.

Public Member Functions
BOOL	DoInvalidateNodesRegions (Range NodeRange, BOOL IncludeBlobs, BOOL UndoBlobs=FALSE, BOOL IfBgRedraw=FALSE, BOOL bForceRecache=TRUE)
	This low level Do function invalidates a region which is the union of the bounding rectangles of each node in the range. When the includeBlobs flag is TRUE the region which gets invalidated includes the objects blobs.
BOOL	DoInvalidateNodeRegion (NodeRenderableBounded *Node, BOOL IncludeBlobs, BOOL UndoBlobs=FALSE, BOOL IfBgRedraw=FALSE, BOOL bForceRecache=TRUE)
	Invalidates the nodes bounding rectangle, or blob bounding rectangle.
BOOL	DoInvalidateRegion (Spread *pSpread, const DocRect &InvalidRegion)
	Invalidates the region specified and adds the appropriate action to the action list for the current operation. If you are invalidating a region associated with a node in the tree then you should be using DoInvalidateNodeRegion() or DoInvalidateNodesRegion().
BOOL	DoSaveCopyOfNode (NodeRenderable *Node)
	This fn saves a copy of the node in the operation history. When the operation is undone the copy is restored.
BOOL	DoSaveCopyOfNodes (Range NodeRange)
	This fn takes a copy of the nodes in the range. The copies are restored when the operation is undone.
BOOL	DoHideNode (Node *NodeToHide, BOOL IncludeSubtreeSize, NodeHidden **nodeHidden=NULL, BOOL TellSubtree=TRUE)
	This low level Do function hides the subtree with root NodeToHide.
BOOL	DoHideNodes (Range NodeRange, BOOL IncludeSubtreeSize, BOOL TellSubtree=TRUE)
	This low level Do function hides a range of the subtrees.
BOOL	DoHideComplexRange (Range &RangeToHide)
	This function is a pre process to DoHideNodes(). It calls each object in the range to hide themselves in a complex way. It may be that no objects in the selection require this facility, which means the RangeToHide object will be returned from this function unaffected. DoHideNodes() will then go through hidding all nodes in the range itself. If however a node responds to ComplexHide() and hides itself, the node will be removed from the range. This allows complex group nodes to control how they are hidden. Note, it is expected that ComplexHide() responders will hide nodes themselves This will have the automatic effect of removing them from the range. Hidden nodes do not appear in ranges.
BOOL	DoInsertNewNode (NodeRenderableBounded *NewNode, Spread *pSpread, BOOL InvalidateRgn, BOOL ClearSelection=TRUE, BOOL SelectNewObject=TRUE, BOOL NormaliseAttributes=TRUE)
	Inserts the node as a last child of the active layer of the pSpread. If the NewNode is a NodeRenderableInk then the node becomes selected and all other nodes are deselected. If pSpread is NULL then the object is inserted on the selected spread.
BOOL	DoInsertNewNode (NodeRenderableBounded *NewNode, Node *ContextNode, AttachNodeDirection Direction, BOOL InvalidateRegion, BOOL ClearSelection=TRUE, BOOL SelectNewObject=TRUE, BOOL NormaliseAttributes=TRUE)
	This high level do function attaches the node to ContextNode in the direction specified. If the NewNode is a NodeRenderableInk then the node becomes selected and all other nodes are deselected.
BOOL	DoMoveNode (Node *MoveNode, Node *Destination, AttachNodeDirection Direction)
	This high level function moves NodeToMove from its current position in the tree, and attaches it to Destination in the direction specified by Direction.
BOOL	DoMoveNodes (Range NodeRange, Node *Destination, AttachNodeDirection Direction)
	This high level function moves the range of nodes from their current position in the tree, and attaches them to the Destination node in the direction specified by Direction.
BOOL	DoTransformNode (NodeRenderableInk *NodeToTransform, TransformBase *T)
	This high level Do function applies the transform Trans to the NodeToTransform.
BOOL	DoTransformNodes (Range NodeRange, TransformBase *T)
	This high level Do function applies the transform Trans to each object in the range.
BOOL	DoMakeShapes (Range NodeRange)
	This low level Do function calls the DoBecomeA virtual function on all SelectedNodes. It is the node's DoBecomeA function which is responsible for generating actions.
BOOL	DoFlattenRange (Range NodeRange)
	Not implemented yet.
BOOL	DoCopyNodesToClipboard (Range NodeRange)
	This Do function copies all nodes in the range to the internal clipboard. The objects are made attribute complete prior to being moved.
BOOL	DoRemoveAttrTypeFromSubtree (Node *Subtree, CCRuntimeClass *NodeClass, Node *pExceptThis=NULL)
	Searches the subtree and every attribute which has type AttrType is hidden.
BOOL	DoChangeSelection (NodePath *ThisNode, INT32 Index, BOOL NewState)
	This 'Do' function changes the selected state of a particular element in a path it creates all the necessary undo information so that the selection can be undone.
BOOL	DoDeletePathSection (NodePath *ThisNode, INT32 Index, INT32 NumElements, BOOL RedrawPath=TRUE)
	This 'Do' function changes the selected state of a particular element in a path it creates all the necessary undo information so that the selection can be undone.
BOOL	DoAlterPathElement (NodePath *ThisNode, INT32 Index, DocCoord NewCoord, PathFlags NewFlags, PathVerb NewVerb, BOOL RedrawPath=TRUE)
	This 'Do' function changes the selected element, recording undo information.
BOOL	DoInsertPathElement (NodePath *ThisPath, INT32 Index, DocCoord NewCoord, PathFlags NewFlags, PathVerb NewVerb, BOOL RedrawPath=TRUE)
	This 'Do' function adds an element into a path, recording undo information.
BOOL	DoReversePath (NodePath *ThisPath, BOOL RedrawPath=TRUE)
	This 'Do' function reverse a path, recording undo information.
BOOL	DoSmoothNodePath (NodePath *pThisNode, double smoothacc)
	This function will smooth a node path given an accuracy. It will create a new node in the tree after the node specified and hide node passed if all is succesfull.
BOOL	DoMakeNodeFromPath (NodePath *pParentNode, Path *pParentPath, AttachNodeDirection Direction, BOOL CopyAttributes)
	This functio will create a new nodepath and attach it in the specified direction to the context node specified. It will also copy attributes applied as children of the ConextNode to the new node if required.
BOOL	DoLocaliseForAttrChange (NodeRenderableInk *Object, AttrTypeSet *pAffectedAttrTypes, ObjectSet *pLocalisedCompounds)
	This Do function must be called on an object prior to a set of attributes being applied to it. It globally localises those attributes which have a type in the pAffectedAttrTypes set.
BOOL	DoLocaliseForAttrChange (NodeRenderableInk *Object, CCRuntimeClass *pAffectedAttrType, ObjectSet *pLocalisedCompounds)
	This Do function must be called on an object prior to an attribute being applied to it. If you are going to apply multiple attributes to the Object then it is more efficient to call the other version of this function which takes a set of attribute types.
BOOL	DoLocaliseForAttrChange (Range *pRange, AttrTypeSet *pAffectedAttrTypes, BOOL ExcludeTextObjects=FALSE)
	This Do function must be called on a range prior to a set of attributes being applied to it. It globally localises those attributes which have a type in the pAffectedAttrTypes set.
BOOL	DoLocaliseForAttrChange (Range *pRange, CCRuntimeClass *pAffectedAttrType)
	This Do function must be called on a range prior to an attribute being applied to it. If you are going to apply multiple attributes to the range then it is more efficient to call the other version of this function which takes a set of attribute types.
BOOL	DoFactorOutAfterAttrChange (NodeRenderableInk *Object, AttrTypeSet *pAffectedAttrTypes)
	This Do function must be called on an object after attributes have being applied to it.
BOOL	DoFactorOutAfterAttrChange (NodeRenderableInk *Object, CCRuntimeClass *pAffectedAttrType)
	This Do function must be called on an object after an attribute being applied to it. If you have applied multiple attributes to the Object then it is more efficient to call the other version of this function which takes a set of attribute types.
BOOL	DoFactorOutAfterAttrChange (Range *pRange, AttrTypeSet *pAffectedAttrTypes)
	This Do function must be called on the range after attributes have being applied to it.
BOOL	DoFactorOutAfterAttrChange (Range *pRange, CCRuntimeClass *pAffectedAttrType)
	This Do function must be called on the range after an attribute being applied to it. If you have applied multiple attributes to the range then it is more efficient to call the other version of this function which takes a set of attribute types.
BOOL	DoFactorOutAfterAttrChange (ObjectSet *pLocalisedCompounds, AttrTypeSet *pAffectedAttrTypes)
	This Do function is designed to be called after all attributes in the pAffectedAttrTypes set have been localised on all compound nodes in the pLocalisedCompounds set.
BOOL	DoFactorOutAfterAttrChange (ObjectSet *pLocalisedCompounds, CCRuntimeClass *pAffectedAttrType)
	This Do function is designed to be called after pAffectedAttrType has been localised on all compound nodes in the pLocalisedCompounds set.
BOOL	DoFactorOutCommonChildAttributes (NodeRenderableInk *CompoundObject, BOOL Global=FALSE, AttrTypeSet *pAffectedAttrTypes=NULL)
	This function is an information gatherer for the DoFactorOutAfterDeletion function. See this function for a full description of its purpose. Whenever we delete a range of objects, if any objects in the range have compound parents then we must adjust the common attributes on these compounds. This function factors out all attributes which are common to all children of the compound object. All common attributes become first children of the compound object.
BOOL	DoFactorOutCommonAttributes (NodeRenderableInk *pRootNode, BOOL bGlobal=FALSE, AttrTypeSet *pAffectedAttrTypes=NULL)
	Just a wrapper to get function name consistency and do the common IsCompound test to prevent DFOCCA from barfing...
BOOL	DoLocaliseCommonAttributes (NodeRenderableInk *CompoundObject, BOOL CheckForDuplicates=FALSE, BOOL Global=FALSE, AttrTypeSet *pAffectedAttrTypes=NULL)
	This function is the opposite of DoFactorOutCommonChildAttributes it copies all attributes common to the compound object to each child object within the group which requires each attribute. The groups common attributes are deleted.
BOOL	DoSelectNode (NodeRenderableInk *NodeToSelect, Spread *Parent=NULL)
	The function selects NodeToSelect. It also generates an action which will deselect the node when executed.
BOOL	DoDeselectNode (NodeRenderableInk *NodeToDeselect, Spread *Parent=NULL)
	The function de-selects NodeToDeselect. It also generates an action which will select the node when executed.
	UndoableOperation ()
	Constructs a new undoable operation object:.
virtual	~UndoableOperation ()
	UndoableOperation destructor.
virtual void	PerformMergeProcessing ()
	This function gets called from the Operation::EndOp method after the operation has ended successfuly and been added to the operation history. If the operation could potentially merge itself with the previous operation then perform this merging here.
void	MergeWithPrevious ()
	Moves all the actions in this operation to the end of the previous action, then deletes this action.
virtual BOOL	UpdateChangedNodes (ObjChangeParam *pParam, Spread *pSpread=NULL)
	This function overrides its namesake in Operation, calling the base function first and then adding a call to NameGallery::PostTriggerEdit if this Op admits it may change the bounds of nodes within the tree.
virtual BOOL	NoStretchUpdateChangedNodes (ObjChangeParam *pParam, Document *pDoc)
	This is *not* an override of Operation::UpdateChangedNodes(..., Document*), although it performs *almost* exactly the same job. It is provided solely for NameGallery::PostTriggerEdit to call in order to get all affected nodes to update themselves correctly after a stretch. PostTriggerEdit is itself called in response to normal UpdateChangedNodes calls, so this avoids recursion problems.
virtual BOOL	MayChangeNodeBounds () const
virtual BOOL	GetStarted () const
Static Public Member Functions
static BOOL	RegisterOpDescriptor (UINT32 toolID, UINT32 txID, CCRuntimeClass *RuntimeClass, TCHAR *tok, pfnGetState gs, UINT32 helpId=0, UINT32 bubbleID=0, UINT32 resourceID=0, UINT32 controlID=0, SystemBarType GroupBarID=SYSTEMBAR_ILLEGAL, BOOL ReceiveMessages=TRUE, BOOL Smart=FALSE, BOOL Clean=FALSE, UINT32 OneOpenInstID=0, UINT32 AutoStateFlags=0)
	This function should be called from the operations Init method. It creates an OpDescriptor for the operation.
Static Public Attributes
static BOOL	MovingNode = FALSE
Private Member Functions
Range *	IncludeParentTransformNodesInRange (Range *Rng)
	Transforms the node, checking if any parents need to transform too.
Private Attributes
BOOL	WarnInsertObjsOntoLockedLayers

---

Detailed Description

All Undoable operations should be derived from this class.

Author:

Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>

Date:

9/3/94

See also:

Operation

Definition at line 195 of file undoop.h.

---

Constructor & Destructor Documentation

UndoableOperation::UndoableOperation (   )

Constructs a new undoable operation object:. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 9/3/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: Operation::Operation Definition at line 294 of file undoop.cpp. : Operation() { // This var is a flag that ensures that this warning will only appear once for the lifetime of this op WarnInsertObjsOntoLockedLayers = TRUE; }

UndoableOperation::~UndoableOperation (   )  [virtual]

UndoableOperation destructor. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 9/3/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 317 of file undoop.cpp. { }

---

Member Function Documentation

BOOL UndoableOperation::DoAlterPathElement (  NodePath *  ThisPath, INT32  Index, DocCoord  NewCoord, PathFlags  NewFlags, PathVerb  NewVerb, BOOL  RedrawPath = TRUE )

This 'Do' function changes the selected element, recording undo information. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 27/7/94 Parameters: ThisPath  points at the NodePath whose state we want to change [INPUTS] Index is the element we want to change NewCoord is the new coordinate value NewFlags is the new flags value NewVerb is the new verb value RedrawPath - TRUE if the screen area of the path should be invalidated, FALSE if not -  [OUTPUTS] Returns: TRUE if succeeded, FALSE otherwise Errors: - See also: - Definition at line 2126 of file undoop.cpp. { #ifndef STANDALONE // Here we're changing an element, so we have to change the element in the path, // recording undo information at the same time. ModifyElementAction* ModAction = NULL; // Get pointers to all the arrays of the path PathVerb* Verbs = NULL; DocCoord* Coords = NULL; PathFlags* Flags = NULL; ThisPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); // Create an undo action for this action, which is a ModifyElementAction ActionCode Act; Act = ModifyElementAction::Init(this, &UndoActions, Verbs[Index], Flags[Index], Coords[Index], Index, ThisPath, (Action**)(&ModAction)); if (Act == AC_FAIL) return FALSE; Document* pDocument = GetWorkingDoc(); ERROR2IF(pDocument == NULL, FALSE, "There was no Document when deleteing path elements"); Spread* pSpread = ThisPath->FindParentSpread(); ERROR2IF(pSpread == NULL, FALSE, "Path had no parent spread"); // Force a re-draw of the place where the path used to be if (RedrawPath) { DocRect Invalid = ThisPath->GetUnionBlobBoundingRect(); // Mark the region as requiring object to recache any cached // data they may be holding because the Op may have changed it pDocument->ForceRedraw( pSpread, Invalid, FALSE, ThisPath ); } // Update the coords Verbs[Index] = NewVerb; Flags[Index] = NewFlags; Coords[Index] = NewCoord; // The bounding rect may have changed ThisPath->InvalidateBoundingRect(); // redraw the new area if (RedrawPath) { // redraw the new area DocRect Invalid = ThisPath->GetUnionBlobBoundingRect(); // Mark the region as requiring object to recache any cached // data they may be holding because the Op may have changed it pDocument->ForceRedraw( pSpread, Invalid, FALSE, ThisPath ); } #endif return TRUE; }

BOOL UndoableOperation::DoChangeSelection (  NodePath *  ThisNode, INT32  Index, BOOL  NewState )

This 'Do' function changes the selected state of a particular element in a path it creates all the necessary undo information so that the selection can be undone. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: ThisNode  points at the NodePath whose state we want to change [INPUTS] Index is the element we want to change NewState is the new state of selection we want to set -  [OUTPUTS] Returns: TRUE if succeeded, FALSE otherwise Errors: - See also: - Definition at line 1978 of file undoop.cpp. { #ifndef STANDALONE ModifyFlagsAction* UnAction; PathFlags* Flags = ThisNode->InkPath.GetFlagArray(); if (Flags[Index].IsSelected != NewState) { ActionCode Act = ModifyFlagsAction::Init(this, &UndoActions, Flags[Index], Index, ThisNode, (Action**)&UnAction); if (Act == AC_FAIL) return FALSE; Flags[Index].IsSelected = NewState; return TRUE; } #endif return TRUE; }

BOOL UndoableOperation::DoCopyNodesToClipboard (  Range  NodeRange  )

This Do function copies all nodes in the range to the internal clipboard. The objects are made attribute complete prior to being moved. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 03/05/94 Parameters: NodeRange,:  The Range of nodes to copy [INPUTS] Returns: TRUE if successful FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) Before the copy begins StartComponentCopy is called on each DocComponent in the clipboard. The nodes are then copied to the clipboard CopyComponentData is then called on each node which has been copied to allow component data to be copied to the clipboard. In the operations End method: If the operation has not failed then EndComponentCopy is called on each doc component do give them a chance to commit changes. If the operation has failed then AbortComponentCopy is called instead. Returns: Errors: - See also: NodeRenderableInk::MakeAttributeComplete Definition at line 1830 of file undoop.cpp. { BOOL CopiedOK; BOOL ok; InternalClipboard* pInternalClip = InternalClipboard::Instance(); // After the operation ends we will need to inform all DocComponents in the clipboard // of the outcome. InformDocComponentsOfOperationsOutcome(pInternalClip); // Inform all DocComponents in the clipboard that a copy is about to take place CALL_WITH_FAIL(pInternalClip->StartComponentCopy(), this, ok) if (!ok) { // Start Component copy has failed so abort operation // Note that AbortComponentCopy will get called in the ops end method return FALSE; } // Try to copy the selection to the clipboard CALL_WITH_FAIL(InternalClipboard::CopyObjects(NodeRange, this), this, CopiedOK) if (!CopiedOK) { return FALSE; } // Now try and copy accross the component data CALL_WITH_FAIL(InternalClipboard::CopyComponentData(pOurDoc), this, CopiedOK) if (!CopiedOK) { return FALSE; } // Create action, this action will do nothing for undo but it's twin redo action will // copy the selection to the clipboard. CopyObjectsToClipboardAction* UndoCopyObjectsToClipboardAction; if ( CopyObjectsToClipboardAction::Init(this, &UndoActions, NodeRange, ( Action**)(&UndoCopyObjectsToClipboardAction)) == AC_FAIL) { return FALSE; // Failed to create action } return TRUE; // Success }

BOOL UndoableOperation::DoDeletePathSection (  NodePath *  ThisPath, INT32  Index, INT32  NumElements, BOOL  RedrawPath = TRUE )

This 'Do' function changes the selected state of a particular element in a path it creates all the necessary undo information so that the selection can be undone. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: ThisPath  points at the NodePath whose state we want to change [INPUTS] Index is the element we want to change NumElements is the number of elements to be deleted RedrawPath - TRUE if the path ares should be redrawn, FALSE if the caller will do it -  [OUTPUTS] Returns: TRUE if succeeded, FALSE otherwise Errors: - See also: - Definition at line 2023 of file undoop.cpp. { #ifndef STANDALONE InsertPathElementAction* UnAction = NULL; ActionCode Act; Act = InsertPathElementAction::Init(this, &UndoActions, NumElements, Index, (Action**)(&UnAction)); if (Act == AC_FAIL) return FALSE; Document* pDocument = GetWorkingDoc(); ERROR2IF(pDocument == NULL, FALSE, "There was no Document when deleteing path elements"); Spread* pSpread = ThisPath->FindParentSpread(); ERROR2IF(pSpread == NULL, FALSE, "Path had no parent spread"); // Force a re-draw of the place where the path used to be if (RedrawPath) { DocRect Invalid = ThisPath->GetUnionBlobBoundingRect(); // Mark the region as requiring object to recache any cached // data they may be holding because the Op may have changed it pDocument->ForceRedraw(pSpread, Invalid, FALSE, ThisPath); } if ((Act != AC_NORECORD) && (UnAction != NULL)) { // I have to claim some memory to store the elements I'm deleting... PathVerb* ChangedVerbs = NULL; DocCoord* ChangedCoords = NULL; PathFlags* ChangedFlags = NULL; ALLOC_WITH_FAIL(ChangedVerbs,(PathVerb*) CCMalloc(NumElements * sizeof(PathVerb)),this); ALLOC_WITH_FAIL(ChangedCoords,(DocCoord*) CCMalloc(NumElements * sizeof(DocCoord)),this); ALLOC_WITH_FAIL(ChangedFlags,(PathFlags*) CCMalloc(NumElements * sizeof(PathFlags)),this); if (!ChangedVerbs || !ChangedCoords || !ChangedFlags) { if (ChangedVerbs) CCFree(ChangedVerbs); if (ChangedCoords) CCFree(ChangedCoords); if (ChangedFlags) CCFree(ChangedFlags); return FALSE; } // Get pointers to all the arrays of the path PathVerb* Verbs = NULL; DocCoord* Coords = NULL; PathFlags* Flags = NULL; ThisPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); // Now copy the data from the path into the arrays for (INT32 i=0;i<NumElements;i++) { ChangedVerbs[i] = Verbs[Index+i]; ChangedCoords[i] = Coords[Index+i]; ChangedFlags[i] = Flags[Index+i]; } // Now pass these arrays to the Insert action UnAction->RecordPath(ChangedVerbs, ChangedFlags, ChangedCoords, ThisPath); } // Now we've recorded the data we're about to delete, let's delete it ThisPath->InkPath.DeleteSection(Index, NumElements); if (RedrawPath) { DocRect Invalid = ThisPath->GetUnionBlobBoundingRect(); // Accumulate this invalid region in a pending list until the Op // finishes // Mark the region as requiring object to recache any cached // data they may be holding because the Op may have changed it pDocument->ForceRedraw(pSpread, Invalid, FALSE, ThisPath); } #endif return TRUE; }

BOOL UndoableOperation::DoDeselectNode (  NodeRenderableInk *  NodeToDeselect, Spread *  Parent = NULL )

The function de-selects NodeToDeselect. It also generates an action which will select the node when executed. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/93 Parameters: NodeToDeselect,:  The node that is to be de-selected [INPUTS] -  [OUTPUTS] Returns: TRUE if successful FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) Errors: - See also: UndoableOperation::DoDeselectNode Definition at line 1733 of file undoop.cpp. { SelectDeselectAction* UndoSelectDeselectAction; // Create an action to deselect the NodeToSelect when we undo. if ( SelectDeselectAction::Init(this, &UndoActions, NodeToDeselect, Parent, (Action**)(&UndoSelectDeselectAction)) != AC_FAIL) { // We shall be able to select the object if we fail so deselect it. NodeToDeselect->DeSelect(FALSE); return (TRUE); } else return (FALSE); }

BOOL UndoableOperation::DoFactorOutAfterAttrChange (  ObjectSet *  pLocalisedCompounds, CCRuntimeClass *  pAffectedAttrType )

This Do function is designed to be called after pAffectedAttrType has been localised on all compound nodes in the pLocalisedCompounds set. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/95 Parameters: pLocalisedCompounds,:  A set of compound nodes which have localised their [INPUTS] pAffectedAttrType attributes. pAffectedAttrType: The type of the attribute that have just been applied to the range. Parameters: -  [OUTPUTS] Returns: TRUE if successful, FALSE if we run out of memory. Tidyup then call End() The function globally factors out the attribute which has type pAffectedAttrType Before calling the function you should have localised the attribute by calling DoLocaliseForAttrChange. See also: AttrTypeSet NodeAttribute::GetAttributeType UndoableOperation::DoLocaliseForAttrChange Definition at line 3316 of file undoop.cpp. { ERROR3IF(!pLocalisedCompounds, "DoFactorOutAfterAttrChange called with a NULL compound set"); ERROR3IF(!pAffectedAttrType, "DoFactorOutAfterAttrChange called with a NULL attr type"); // Scan the range ObjectItem* pObjItem = (ObjectItem*)(pLocalisedCompounds->GetHead()); NodeRenderableInk* pCurrent; // We need an attribute type set AttrTypeSet Set; // Add the attributes type to the set if (!(Set.AddToSet(pAffectedAttrType))) { return FALSE; } while (pObjItem) { pCurrent = pObjItem->pObject; ERROR3IF(!(pCurrent->IsCompound()), "Set should only contain compound objects"); if (pCurrent->IsCompound()) { if (!DoFactorOutCommonChildAttributes((NodeRenderableInk*)pCurrent, TRUE, // Global &Set)) { Set.DeleteAll(); return FALSE; } } pObjItem = (ObjectItem*)pLocalisedCompounds->GetNext(pObjItem); } Set.DeleteAll(); return TRUE; }

BOOL UndoableOperation::DoFactorOutAfterAttrChange (  ObjectSet *  pLocalisedCompounds, AttrTypeSet *  pAffectedAttrTypes )

This Do function is designed to be called after all attributes in the pAffectedAttrTypes set have been localised on all compound nodes in the pLocalisedCompounds set. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/95 Parameters: pLocalisedCompounds,:  A set of compound nodes which have localised their [INPUTS] pAffectedAttrTypes attributes pAffectedAttrTypes: The types of the attributes that have been applied to the range. Parameters: -  [OUTPUTS] Returns: TRUE if successful, FALSE if we run out of memory. Tidyup then call End() The function globally factors out the attributes which have a type which is in the pAffectedAttrTypes set. Before calling the function you should have localised the attribute by calling DoLocaliseForAttrChange. See also: AttrTypeSet NodeAttribute::GetAttributeType UndoableOperation::DoLocaliseForAttrChange Definition at line 3248 of file undoop.cpp. { ERROR3IF(!pLocalisedCompounds, "DoFactorOutAfterAttrChange called with a NULL compound set"); //ERROR3IF(!pAffectedAttrTypes, "DoFactorOutAfterAttrChange called with a NULL attr type set"); // Scan the range ObjectItem* pObjItem = (ObjectItem*)(pLocalisedCompounds->GetHead()); NodeRenderableInk* pCurrent; while (pObjItem) { pCurrent = pObjItem->pObject; ERROR3IF(!(pCurrent->IsCompound()), "Set should only contain compound objects"); if (pCurrent->IsCompound()) { if (!DoFactorOutCommonChildAttributes((NodeRenderableInk*)pCurrent, TRUE, // Global pAffectedAttrTypes)) { return FALSE; } } pObjItem = (ObjectItem*)pLocalisedCompounds->GetNext(pObjItem); } return TRUE; }

BOOL UndoableOperation::DoFactorOutAfterAttrChange (  Range *  pRange, CCRuntimeClass *  pAffectedAttrType )

This Do function must be called on the range after an attribute being applied to it. If you have applied multiple attributes to the range then it is more efficient to call the other version of this function which takes a set of attribute types. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/95 Parameters: pRange,:  The objects that need their attributes factoring out [INPUTS] pAffectedAttrType: The type of the attribute that have just been applied to the range. Parameters: -  [OUTPUTS] Returns: TRUE if successful, FALSE if we run out of memory. Tidyup then call End() The function globally factors out the attribute which has type pAffectedAttrType Before calling the function you should have localised the attribute by calling DoLocaliseForAttrChange. If an object in the range Discards its attribute children then its attributes are ignored when factoring (eg. the caret) Note: When applying an attribute, we are not always going to apply it to the object itself, sometimes we need to apply it to the object's parent. Eg. when we apply a line based attribute to a text character the attributes will get applied to the parent TextLine. In this situation we do not factor out the objects attributes, but its parents attributes instead. Note: When applying attributes, we are not always going to apply the attributes to the object itself, sometimes we need to apply them to the object's parent. Eg. when we apply a line based attribute to a text character the attributes will get applied to the parent TextLine. In this situation we do not factor out the object's attributes, but its parents attributes instead. See also: AttrTypeSet NodeAttribute::GetAttributeType UndoableOperation::DoLocaliseForAttrChange Range::DoLocaliseForAttrChange Range::DoFactorOutAfterAttrChange Definition at line 2740 of file undoop.cpp. { ERROR3IF(pRange->Count() == 0, "Range::DoFactorOutAfterAttrChange called on an empty range"); // Scan the range // Iterate over the top of any liveeffects applied to the selection // Its important that this iteration matches those used in DoApplyAttribute functions // so that attributes are put in the places where mutation will find them ListRange* pLevel = EffectsStack::GetNewLevelRange(pRange, FALSE); // We DO own this range Node* pCurrent = pLevel->FindFirst(); // There is no need to factor out the attributes on a compound more than once, so we // remember the last compound node which has had its attributes factored out NodeRenderableInk* pFactoredOutCompound = NULL; Node* pParent; Node* pObject; while (pCurrent) { pObject = pCurrent; // Get the object that the attribute has been applied to ERROR3IF(!pAffectedAttrType, "AttrType is NULL"); pObject = ((NodeRenderableInk*)pObject)->GetObjectToApplyTo(pAffectedAttrType); // If the object can discard its attribute children then we should not try to factor // out its attributes { // We only need to factor out attributes on nodes which have a compound parent pParent = pObject->FindParent(); ERROR3IF(pParent == NULL, "Range::DoFactorOutAfterAttrChange, node found without a parent"); // Only factor out attribs if the parent has not already had its attribs factored out if ((pParent->IsCompound()) && (pParent != pFactoredOutCompound)) { // Attempt to localise the compound if (!DoFactorOutAfterAttrChange((NodeRenderableInk*)pObject, pAffectedAttrType)) { delete pLevel; return FALSE; } pFactoredOutCompound = (NodeRenderableInk*)pParent; // Remember that it's been localised } } pCurrent = pLevel->FindNext(pCurrent); } delete pLevel; return TRUE; }

BOOL UndoableOperation::DoFactorOutAfterAttrChange (  Range *  pRange, AttrTypeSet *  pAffectedAttrTypes )

This Do function must be called on the range after attributes have being applied to it. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/95 Parameters: pRange,:  The objects that need their attributes factoring out [INPUTS] pAffectedAttrTypes: The types of the attributes that have just been applied to the range. Parameters: -  [OUTPUTS] Returns: TRUE if successful, FALSE if we run out of memory. Tidyup then call End() The function globally factors out those attributes which have a type in the pAffectedAttrTypes set. Before calling the function you should have localised attributes by calling DoLocaliseForAttrChange. If an object in the range Discards its attribute children then its attributes are ignored when factoring (eg. the caret) Note: When applying attributes, we are not always going to apply the attributes to the object itself, sometimes we need to apply them to the object's parent. Eg. when we apply a line based attribute to a text character the attributes will get applied to the parent TextLine. In this situation we do not factor out the objects attributes, but its parents attributes instead. Warning ~~~~~~~ All attribute types in the AttrTypeSet must have been localised (and so need factoring out) on the same compound node. This means for example that the AttrType set cannot contain a Bold and a Line space attribute. If we need to do this in future then the routine will need to be changed. See also: AttrTypeSet NodeAttribute::GetAttributeType UndoableOperation::DoFactorOutAfterAttrChange Range::DoLocaliseForAttrChange Definition at line 2625 of file undoop.cpp. { ERROR3IF(pRange->Count() == 0, "Range::DoFactorOutAfterAttrChange called on an empty range"); // Iterate over the top of any liveeffects applied to the selection // Its important that this iteration matches those used in DoApplyAttribute functions // so that attributes are put in the places where mutation will find them ListRange* pLevel = EffectsStack::GetNewLevelRange(pRange, FALSE); // We DO own this range Node* pCurrent = pLevel->FindFirst(); // There is no need to factor out the attributes on a compound more than once, so we // remember the last compound node which has had its attributes factored out NodeRenderableInk* pFactoredOutCompound = NULL; Node* pParent; Node* pObject; while (pCurrent) { // If the object can discard its attribute children then we should not try to factor // out its attributes CCRuntimeClass* AttrType; pObject = pCurrent; if (pAffectedAttrTypes && (!pAffectedAttrTypes->IsEmpty())) { AttrType = ((AttrTypeItem*)pAffectedAttrTypes->GetHead())->AttributeType; ERROR3IF(!AttrType, "AttrType set contains NULL attribute type"); pObject = ((NodeRenderableInk*)pObject)->GetObjectToApplyTo(AttrType); } // DY added test for NULL, which can occur with bevels if ((pObject != NULL)) { // We only need to factor out attributes on nodes which have a compound parent pParent = pObject->FindParent(); ERROR3IF(pParent == NULL, "Range::DoFactorOutAfterAttrChange, node found without a parent"); // Only factor out attribs if the parent has not already had its attribs factored out if ((pParent->IsCompound()) && (pParent != pFactoredOutCompound)) { // Attempt to localise the compound if (!DoFactorOutAfterAttrChange((NodeRenderableInk*)pObject, pAffectedAttrTypes)) { delete pLevel; return FALSE; } pFactoredOutCompound = (NodeRenderableInk*)pParent; // Remember that it's been localised } } pCurrent = pLevel->FindNext(pCurrent); } delete pLevel; return TRUE; }

BOOL UndoableOperation::DoFactorOutAfterAttrChange (  NodeRenderableInk *  Object, CCRuntimeClass *  pAffectedAttrType )

This Do function must be called on an object after an attribute being applied to it. If you have applied multiple attributes to the Object then it is more efficient to call the other version of this function which takes a set of attribute types. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/95 Parameters: Object,:  The object that you have just applied attributes to [INPUTS] pAffectedAttrType: The types of the attribute that have just been applied to the object. Parameters: -  [OUTPUTS] Returns: TRUE if successful, FALSE if we run out of memory. Tidyup then call End() The function globally factors out the attribute with type pAffectedAttrType If the function is called on a object which does not have a compound parent then there will be no attributes to factor out so the function will simply return TRUE without having done anything. Before calling the function you should have localised attributes by calling DoLocaliseForAttrChange. If the object discards its attribute children then the routine does nothing (eg. the caret) Note: When applying attributes, we are not always going to apply the attributes to the object itself, sometimes we need to apply them to the object's parent. Eg. when we apply a line based attribute to a text character the attributes will get applied to the parent TextLine. In this situation we do not factor out the objects attributes, but its parents attributes instead. See also: AttrTypeSet NodeAttribute::GetAttributeType UndoableOperation::DoLocaliseForAttrChange Range::DoLocaliseForAttrChange Range::DoFactorOutAfterAttrChange Definition at line 3170 of file undoop.cpp. { BOOL ok = TRUE; // Get object attr was applied to ERROR3IF(!pAffectedAttrType, "AttrType is NULL"); Object = Object->GetObjectToApplyTo(pAffectedAttrType); { Node* pParent; pParent = Object->FindParent(); ERROR3IF(!pParent, "UndoableOperation::DoFactorOutAfterAttrChange called on an object which has no parent"); if (pParent->IsCompound()) { // We need an attribute type set AttrTypeSet Set; // Add the attributes type to the set if (!(Set.AddToSet(pAffectedAttrType))) { ok = FALSE; } if (ok) { return (DoFactorOutCommonChildAttributes((NodeRenderableInk*)pParent, TRUE, // Global &Set)); } Set.DeleteAll(); } } return ok; }

BOOL UndoableOperation::DoFactorOutAfterAttrChange (  NodeRenderableInk *  Object, AttrTypeSet *  pAffectedAttrTypes )

This Do function must be called on an object after attributes have being applied to it. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/95 Parameters: Object,:  The object that you have just applied attributes to [INPUTS] pAffectedAttrTypes: The types of the attributes that have just been applied to the object. Parameters: -  [OUTPUTS] Returns: TRUE if successful, FALSE if we run out of memory. Tidyup then call End() The function globally factors out those attributes which have a type in the pAffectedAttrTypes set. If the function is called on a object which does not have a compound parent then there will be no attributes to factor out so the function will simply return TRUE without having done anything. Before calling the function you should have localised attributes by calling DoLocaliseForAttrChange. If the object discards its attribute children then the routine does nothing (eg. the caret) Note: When applying attributes, we are not always going to apply the attributes to the object itself, sometimes we need to apply them to the object's parent. Eg. when we apply a line based attribute to a text character the attributes will get applied to the parent TextLine. In this situation we do not factor out the objects attributes, but its parents attributes instead. Warning ~~~~~~~ All attribute types in the AttrTypeSet must have been localised (and so need factoring out) on the same compound node. This means for example that the AttrType set cannot contain a Bold and a Line space attribute. If we need to do this in future then the routine will need to be changed. See also: AttrTypeSet NodeAttribute::GetAttributeType UndoableOperation::DoLocaliseForAttrChange Range::DoLocaliseForAttrChange Range::DoFactorOutAfterAttrChange Definition at line 3091 of file undoop.cpp. { CCRuntimeClass* AttrType; // Get object which attrib was applied to if (pAffectedAttrTypes && (!pAffectedAttrTypes->IsEmpty())) { AttrType = ((AttrTypeItem*)pAffectedAttrTypes->GetHead())->AttributeType; ERROR3IF(!AttrType, "AttrType set contains NULL attribute type"); Object = Object->GetObjectToApplyTo(AttrType); } { Node* pParent; pParent = Object->FindParent(); ERROR3IF(!pParent, "UndoableOperation::DoFactorOutAfterAttrChange called on an object which has no parent"); if (pParent->IsCompound()) { return (DoFactorOutCommonChildAttributes((NodeRenderableInk*)pParent, TRUE, // Global pAffectedAttrTypes)); } } return TRUE; }

BOOL UndoableOperation::DoFactorOutCommonAttributes (  NodeRenderableInk *  pRootNode, BOOL