OpHideColours Class Reference

#include <colormgr.h>

Inheritance diagram for OpHideColours:

List of all members.

Public Member Functions
	OpHideColours ()
	OpHideColours constructor (Creates an undoable operation).
void	Do (OpDescriptor *)
	(Performs the colour change operation) OpHideColours has a special overloaded Do operator which takes parameters describing what is to be done - that version of Do must be used
void	DoWithParam (OpDescriptor *, OpParam *Param)
	Performs the colour change operation, as described by 'Param'.
virtual BOOL	Undo ()
	Undoes whatever Do() or Redo() did.
virtual BOOL	Redo ()
	Redoes whatever Undo() undid.
virtual void	GetOpName (String_256 *)
	Redoes whatever Undo() undid.
Static Public Member Functions
static BOOL	Init ()
	OpHideColours initialiser method.
static OpState	GetState (String_256 *, OpDescriptor *)
	For finding the OpHideColours' state.
Private Member Functions
NodeAttribute *	HideAttrNode (Node *CurNode, DocColour *TheColour)
	Checks if the given colour references an IndexedColour in the given NULL terminated list of colours. If this is the case, then the node containing the colour attribute is hidden and replaced with a clone of itself. This clone is returned, so that the caller can then change the contained DocColour(s) appropriately.
void	KillColourRef (DocColour *Perpetrator, IndexedColourPtr *ColourMap)
	If the given DocColour refers to an IndexedColour, it is redefined as a Local colour based on the IndexedColour's definition.
void	HideColourRefs (void)
	Traverses the entire Camelot tree and replaces all references to indexed colours with immediate DocColour equivalents. The original attributes are hidden to allow undo.
void	RemoveColour (DocColour *Ref, INT32 *LastColour)
	Removes the indexedcolour (if any) referenced by the given DocColour from the 'Colours' list of colours-to-delete.
void	RemoveReferencedColours (void)
	Traverses the entire Camelot tree and removes all IndexedColours that are referenced therein from our list of colours-to-delete.
Private Attributes
IndexedColour **	Colours
ColourList *	ParentColList
BOOL	HideThem

---

Detailed Description

Definition at line 308 of file colormgr.h.

---

Constructor & Destructor Documentation

OpHideColours::OpHideColours (   )

OpHideColours constructor (Creates an undoable operation). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 2186 of file colormgr.cpp. : UndoableOperation() { Colours = NULL; // For safety, ensure initialised ParentColList = NULL; HideThem = TRUE; }

---

Member Function Documentation

void OpHideColours::Do (  OpDescriptor *  NotUsed  )  [virtual]

(Performs the colour change operation) OpHideColours has a special overloaded Do operator which takes parameters describing what is to be done - that version of Do must be used Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: OpDescriptor  (unused) [INPUTS] -  [OUTPUTS] Returns: - Errors: Always generates an ENSURE failure because this Do doesn't. See also: - Reimplemented from Operation. Definition at line 2281 of file colormgr.cpp. { ERROR3("OpHideColours does not provide a Do() function - use DoWithParam"); End(); }

void OpHideColours::DoWithParam (  OpDescriptor *  pOp, OpParam *  Param )  [virtual]

Performs the colour change operation, as described by 'Param'. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: pOp  - OpDescriptor as for all Do() functions [INPUTS] Param - Actually points to a HideColoursInfo structure, detailing what to hide/unhide, and how to do it. -  [OUTPUTS] Returns: - Reimplemented from Operation. Definition at line 2304 of file colormgr.cpp. { HideColoursInfo *WhatToDo = (HideColoursInfo *) Param; // If Forced-delete is desired, then ensure that all DocColours referencing // any of our list of IndexedColours are forced to 'immediate' definitions // Make sure that this operation is applied within the document which owns the colour list! pOurDoc = (Document *) WhatToDo->ParentList->GetParentDocument(); pOurView = NULL; if (!pOurDoc->IsKindOf(CC_RUNTIME_CLASS(Document))) { pOurDoc = NULL; // Arrrgh! It must be a basedoc or something! End(); return; } ParentColList = WhatToDo->ParentList; Colours = WhatToDo->Colours; HideThem = WhatToDo->HideThem; if (HideThem) { if (WhatToDo->ForceDelete) HideColourRefs(); else RemoveReferencedColours(); } if (Colours[0] == NULL) { End(); return; } // Create an action to undo the IndexedColour hide operation, and if we // succeed, then {un}hide the colours (Do) and inform the world of the change ActionHideColours *AHC; if (ActionHideColours::Init(this, &UndoActions, sizeof(ActionHideColours), WhatToDo->ParentList, WhatToDo->Colours, ((WhatToDo->HideThem) ? FALSE : TRUE), (Action**)(&AHC)) == AC_OK) { // Now, hide/unhide all the colours remaining in the list INT32 Index = 0; while (WhatToDo->Colours[Index] != NULL) { WhatToDo->Colours[Index]->SetDeleted(WhatToDo->HideThem); Index++; } // We have made the change, so broadcast that the list for this doc has changed ColourManager::ColourListHasChanged(ParentColList); } End(); }

void OpHideColours::GetOpName (  String_256 *  Result  )  [virtual]

Redoes whatever Undo() undid. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: Result  - returned filled-in with the name [OUTPUTS] Returns: - Reimplemented from Operation. Definition at line 2430 of file colormgr.cpp. { ERROR3IF(Result == NULL, "Illegal null param"); if (HideThem) Result->MakeMsg(_R(IDS_DELETECOLOURS)); else Result->MakeMsg(_R(IDS_CREATECOLOURS)); }

OpState OpHideColours::GetState (  String_256 *  UIDescription, OpDescriptor *  )  [static]

For finding the OpHideColours' state. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The state of the OpHideColours operation Definition at line 2255 of file colormgr.cpp. { OpState OpSt; return(OpSt); }

NodeAttribute * OpHideColours::HideAttrNode (  Node *  CurNode, DocColour *  TheColour )  [private]

Checks if the given colour references an IndexedColour in the given NULL terminated list of colours. If this is the case, then the node containing the colour attribute is hidden and replaced with a clone of itself. This clone is returned, so that the caller can then change the contained DocColour(s) appropriately. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: CurNode  - The Attribute node containing the colour [INPUTS] TheColour - the colour in the node which we may want to hide -  [OUTPUTS] Returns: NULL, or the cloned node. Definition at line 2460 of file colormgr.cpp. { IndexedColour *ParentCol = TheColour->FindParentIndexedColour(); if (ParentCol != NULL) { INT32 i = 0; while (Colours[i] != NULL && Colours[i] != ParentCol) i++; if (Colours[i] != ParentCol) return(NULL); Node *ParentNode = CurNode->FindParent(); NodeAttribute *NodeToClone = (NodeAttribute *) CurNode; NodeAttribute *Clone; ALLOC_WITH_FAIL(Clone, ((NodeAttribute *)NodeToClone->SimpleCopy()), this); if (Clone != NULL) { // Hide the original Attribute DoHideNode(CurNode, TRUE); // Add the clone into the tree Clone->AttachNode(ParentNode, FIRSTCHILD); HideNodeAction* TheUndoAction; // Create an action to hide the attribute when we undo if (HideNodeAction::Init(this, &UndoActions, Clone, TRUE, (Action**)(&TheUndoAction)) == AC_FAIL) { Clone->CascadeDelete(); // Delink the node/subtree from the delete Clone; // document tree and delete it } else return(Clone); } } return(NULL); }

void OpHideColours::HideColourRefs (  void   )  [private]

Traverses the entire Camelot tree and replaces all references to indexed colours with immediate DocColour equivalents. The original attributes are hidden to allow undo. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/6/94 Definition at line 2623 of file colormgr.cpp. { INT32 NumCols = 0; while (Colours[NumCols] != NULL) // Find the last colour in the list NumCols++; IndexedColourPtr *ColourMap; ALLOC_WITH_FAIL(ColourMap, new IndexedColourPtr[NumCols+1], this); // If ALLOC_WITH_FAIL fails, we back down to making the colours immediate DocColours // rather than failing completely. // Clear the array to all NULL pointers if (ColourMap != NULL) { for (INT32 i = 0; i <= NumCols; i++) ColourMap[i] = NULL; } Node *CurNode = Node::DocFindFirstDepthFirst(GetWorkingDoc()); Node *NextNode; Node *NewNode; while (CurNode != NULL) { // We may be about to chop this node out of the tree, so get the next node now NextNode = CurNode->DocFindNextDepthFirst(); NewNode = NULL; // Use to scan the colour fields of the attribute. UINT32 Context = 0; DocColour *pColour; if (CurNode->IsAnAttribute()) { NodeAttribute *pNodeAttr = (NodeAttribute *) CurNode; do { // Get the next colour field from the attribute pColour = pNodeAttr->EnumerateColourFields(Context++); // If there is another colour field, see if we need to hide it if (pColour != NULL && pColour->FindParentIndexedColour() != NULL) NewNode = HideAttrNode(CurNode, pColour); } while ((NewNode == NULL) && (pColour != NULL)); // Keep going until we run out of colour fields, or we find one // that requires the node to be hidden if (NewNode != NULL) { // Forcibly change the NewNode DocColours to be local pNodeAttr = (NodeAttribute *) NewNode; Context = 0; // Start at the first colour field again do { // Get the next colour field from the attribute pColour = pNodeAttr->EnumerateColourFields(Context++); // If there is another colour, kill its reference, if any if (pColour != NULL) KillColourRef(pColour, ColourMap); } while (pColour != NULL); } } // end if CurNode = NextNode; } // end while // And get rid of our working array delete [] ColourMap; }

BOOL OpHideColours::Init (  void   )  [static]

OpHideColours initialiser method. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the operation could be successfully initialised FALSE if no more memory could be allocated Notes: This provides TWO OpDescriptors (Hide colours and Show colours). The same actual Op is invoked for both hiding and showing colours, but it is invoked via different op descriptors, to provide different names for the undo ("undo delete colours" or "undo create colours") Reimplemented from SimpleCCObject. Definition at line 2216 of file colormgr.cpp. { BOOL Result = RegisterOpDescriptor(0, _R(IDS_OPHIDECOLOURS), CC_RUNTIME_CLASS(OpHideColours), OPTOKEN_HIDECOLOURS, OpHideColours::GetState, 0, /* help ID */ 0, /* Bubble help ID */ 0 /* bitmap ID */ ); if (Result) Result = RegisterOpDescriptor(0, _R(IDS_OPSHOWCOLOURS), CC_RUNTIME_CLASS(OpHideColours), OPTOKEN_SHOWCOLOURS, OpHideColours::GetState, 0, /* help ID */ 0, /* Bubble help ID */ 0 /* bitmap ID */ ); return(Result); }

void OpHideColours::KillColourRef (  DocColour *  Perpetrator, IndexedColourPtr *  ColourMap )  [private]

If the given DocColour refers to an IndexedColour, it is redefined as a Local colour based on the IndexedColour's definition. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: Perpetrator  - The DocColour to be neutered [INPUTS] ColourMap - NULL, or an array of IndexedColour pointers which map Colours[] into new local colour pointers. If the mapping entry is NULL, a mapping is set up, else the existing mapping is used. If ColourMap is NULL or memory cannot be allocated for the new mapping, this method will revert to making the colours immediate DocColours (which means it'll work in a falback mode) This releases the DocColour's claim on the IxCol, thus allowing the latter to be deleted. Used for forced-delete A new local colour is created (if necessary) and placed in the colour map entry corresponding to the index of the source colour in Colours[]. This is used for look-up, so that many colours using the same colour style can share the same resulting local colour definition, saving gobs of memory. Scope: private Definition at line 2535 of file colormgr.cpp. { IndexedColour *Parent = Perpetrator->FindParentIndexedColour(); if (Parent == NULL) return; INT32 i = 0; if (ColourMap != NULL) { // Find the colour map entry index while (Colours[i] != NULL && Colours[i] != Parent) i++; // If there is no mapping yet, create a new local colour to map to this Parent colour if (Colours[i] != NULL && ColourMap != NULL && ColourMap[i] == NULL) { ColourMap[i] = new IndexedColour(*(Colours[i])); if (ColourMap[i] != NULL) { ColourMap[i]->SetUnnamed(); // Ensure it's unnamed ERROR3IF(GetWorkingDoc() == NULL, "NULL working doc in OpHideColours"); // Add the local colour to the unnamed colour list // (A nasty sequence of derefs, but these are all guaranteed to work) GetWorkingDoc()->GetIndexedColours()->GetUnnamedColours()->AddTail(ColourMap[i]); // Make sure the new local colour is legal (if its parent is deleted or is // just about to become deleted, then we must make the new colour stand-alone. // (In the case of undo, we needen't worry about being able to restore the // parent link, because the undo will also hide this attribute and return to // the original one which references the old parent-colour chain) IndexedColour *LinkedParent = ColourMap[i]->FindLinkedParent(); if (LinkedParent != NULL) { // Is the parent already deleted? BOOL MustMakeStandalone = LinkedParent->IsDeleted(); // If not, is it one of the colours we are currently deleting? if (!MustMakeStandalone) { INT32 j = 0; while (Colours[j] != NULL && Colours[j] != LinkedParent) j++; if (Colours[j] != NULL) // LinkedParent is in our list to be deleted! MustMakeStandalone = TRUE; } // It's parent is dodgy, so make it stand-alone if (MustMakeStandalone) ColourMap[i]->SetLinkedParent(NULL, COLOURTYPE_NORMAL); } } } } if (ColourMap != NULL && Colours[i] != NULL && ColourMap[i] != NULL) { // We have a mapping - change the colour to reference the relevant local colour Perpetrator->MakeRefToIndexedColour(ColourMap[i]); } else { // Serious failure - make the DocColour immediate ColourGeneric Bob; Parent->GetSourceColour(&Bob); *Perpetrator = DocColour(Parent->GetColourModel(), &Bob); } }

BOOL OpHideColours::Redo (   )  [virtual]

Redoes whatever Undo() undid. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Reimplemented from Operation. Definition at line 2403 of file colormgr.cpp. { BOOL Result = Operation::Redo(); if (Result) { // We have made the change, so broadcast that the list for this doc has changed ColourManager::ColourListHasChanged(ParentColList); } return (Result); }

void OpHideColours::RemoveColour (  DocColour *  Ref, INT32 *  LastColour )  [private]

Removes the indexedcolour (if any) referenced by the given DocColour from the 'Colours' list of colours-to-delete. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Notes: This assumes that any given colour will only appear in the list once It shifts all colours down by one place, as it is essential that the list ordering is retained. Returns: Errors: - See also: - Definition at line 2726 of file colormgr.cpp. { IndexedColour *Col = Ref->FindParentIndexedColour(); if (Col == NULL) // No colour referenced return; INT32 i; for (i = 0; i <= *LastColour; i++) // Search for colour to delete { if (Col == Colours[i]) break; } if (Col == Colours[i]) // We found something to delete { while (i < *LastColour) // Shift remaining list down one place { Colours[i] = Colours[i+1]; i++; } Colours[*LastColour] = NULL; // Add new NULL terminator (*LastColour)--; // Decrement LastColour index } }

void OpHideColours::RemoveReferencedColours (  void   )  [private]

Traverses the entire Camelot tree and removes all IndexedColours that are referenced therein from our list of colours-to-delete. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 2771 of file colormgr.cpp. { INT32 LastColour = 0; while (Colours[LastColour] != NULL) // Find the last colour in the list LastColour++; if ((--LastColour) < 0) return; // Search the entire tree, removing all IndexedColours (from the WhatToDo // list) which are still in use in live parts of the tree. These cannot // be deleted, and so should be removed from further consideration ERROR3IF(GetWorkingDoc() == NULL, "OpHideColours called with NULL Document"); Node *CurNode = GetWorkingDoc()->GetFirstNode(); Node *NextNode; while (CurNode != NULL) { // Have to remember this now, as we may be about to chop this node out of the tree! NextNode = CurNode->DocFindNextDepthFirst(); if (CurNode->IsAnAttribute()) { // These variables are used to scan the colour fields in the attribute. NodeAttribute *pNodeAttr = (NodeAttribute *) CurNode; DocColour *pColour; UINT32 Context = 0; do { // Get the next colour field from the attribute pColour = pNodeAttr->EnumerateColourFields(Context++); // If there is another colour field, see if we need to hide it. if (pColour != NULL) RemoveColour(pColour, &LastColour); } // Keep going until we run out of colour fields while (pColour != NULL); } CurNode = NextNode; } }

BOOL OpHideColours::Undo (   )  [virtual]

Undoes whatever Do() or Redo() did. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Reimplemented from Operation. Definition at line 2376 of file colormgr.cpp. { BOOL Result = Operation::Undo(); if (Result) { // We have made the change, so broadcast that the list for this doc has changed ColourManager::ColourListHasChanged(ParentColList); } return (Result); }

---

Member Data Documentation

IndexedColour** OpHideColours::Colours [private]

Definition at line 325 of file colormgr.h.

BOOL OpHideColours::HideThem [private]

Definition at line 327 of file colormgr.h.

ColourList* OpHideColours::ParentColList [private]

Definition at line 326 of file colormgr.h.

---

The documentation for this class was generated from the following files:

• Kernel/colormgr.h (r1785/r1282)
• Kernel/colormgr.cpp (r1785/r1777)

---