ColourManager Class Reference

This class provides miscellaneous shared functions for use by various colour entities. The provided functions are currently:. More...

#include <colormgr.h>

Inheritance diagram for ColourManager:

List of all members.

Public Member Functions
	ColourManager ()
	Constructs a ColourManager object.
Static Public Member Functions
static BOOL	Init (void)
	Initialises the entire colour system. This includes the colour manager, colour contexts, and colour dialogues, etc. Notes: Should only be called once ever. Called by Application::Init().
static void	Deinit (void)
	De-Initlialises the entire colour system. This includes the colour manager, colour contexts, and colour dialogues, etc. Notes: Should only be called once ever. Called by Application::Deinit().
static ColourList *	GetColourList (BOOL InvalidateCache=FALSE)
	To obtain the ColourList of IndexedColours in the SelectedDocument (the colours which the user can use within the document; this is the set of colours displayed by the colour bar and edited by the ColourMgrDlg) Note that an ordered list is used so that multiple display orders can be used (e.g. for the ColourMgrDlg and ColourBar, etc).
static ColourList *	GetCurrentColourList (void)
	To obtain the ColourList of IndexedColours in the CurrentDocument.
static ColourContext *	GetColourContext (ColourModel Model, Document *ScopeDocument=NULL)
	To easily find an appropriate colour context to use when converting colours. There are global contexts, but in order to supply special document-specific colour corrections etc, each document actually has its own private set of contexts. Thus, you should call this function to determine the most appropriate context to use.
static ColourContext *	GetColourContext (ColourModel Model, View *ScopeView)
	To easily find an appropriate colour context to use when converting colours. There are global contexts, but in order to supply special view-specific colour corrections etc, each document view actually has its own private set of contexts. Thus, you should call this function to determine the most appropriate context to use.
static void	SelViewContextHasChanged (void)
	To redraw all windows which depend upon the Selected View's colour context. i.e. The selected view, and also the colour editor, gallery, & line. (and maybe other windows in the future, e.g. object properties, grad fill editors, etc).
static void	ColourHasChanged (Document *ScopeDoc, ColourList *ColList, IndexedColour *Col)
	Indicates to all interested parties that the given IndexedColour has been changed (sends a COLOURUPDATED message) e.g. Causes the ColourBar and document to redraw themselves.
static void	ColourHasChangedInvisible (Document *ScopeDoc, ColourList *ColList, IndexedColour *Col)
	Indicates to all interested parties that the given IndexedColour has been changed (sends a COLOURUPDATEDINVISIBLE message) e.g. Causes the ColourBar to redraw itself.
static void	ColourListHasChanged (ColourList *ColList)
	To inform all interested parties that the given list of IndexedColours has changed by item(s) being added, deleted, or moved to a new position. e.g This causes the ColourBar and ColourMgrDlg to update their displays to reflect the new state of the list, if the list is the one which they are currently displaying.
static BOOL	HideColours (ColourList *ColList, IndexedColour **ColourArray, BOOL ForceDelete)
	This 'deletes' colours by creating an undoable operation to hide them. It is assumed that the colours are not in use by the time you call this function - An ENSURE failure will occur if any are. After invoking the 'hide' operation, this function calls ColourListHasChanged.
static BOOL	UnHideColours (ColourList *ColList, IndexedColour **ColourArray)
	This un-'deletes' colours by creating an undoable operation to unhide them. This is used when creating a new colour to 'unhide' it (which has no immediate effect on the colour) - this creates an undo record that will hide the colour if the 'new' is undone.
static BOOL	ChangeColour (ColourList *ColList, IndexedColour *NewDefn, IndexedColour *Target, BOOL ChangeisInvisible=FALSE)
	This changes the colour 'Target' to be the same as 'NewDefn'. To achieve undo of this operation, the data members of the two colours are swapped (as the colour being changed must stay at the same memory location), and the NewDefn is used again as the undo record of this colour. Whenever the colour is changed, including during the execution of this funciton, and also by undo/redo, a ColourChangingMsg will be broadcast (either COLOURUPDATED or COLOURUPDATEDINVISIBLE, depending on the state of the ChangeIsInvisible flag).
static void	ForceRedrawOfChangedColours (Document *ScopeDoc, IndexedColour **Colours)
	Scans the document tree of the given scope document, and causes a redraw of all objects which are affected by any attributes which contain references to any of the colours in the given NULL-terminated list of colours. If none of the colours are in use in the document tree, nothing should result. (i.e. it force redraws any areas of the document containing any of the given colours).
static IndexedColour *	GenerateNewNamedColour (ColourList *ParentList, IndexedColour *SourceColour)
	Creates a new named IndexedColour. If possible, this colour is copied from the given SourceColour, but if this is not available, an attempt to find a useful colour to copy will be made - if this fails, a battleship grey will be created. i.e. apart from abject failure, this always creates a new colour.
static IndexedColour *	GenerateNewUnnamedColour (ColourList *ParentList, DocColour *SourceColour)
	Creates a new named IndexedColour. If possible, this colour is copied from the given SourceColour, but if this is not available, an attempt to find a useful colour to copy will be made - if this fails, a battleship grey will be created. i.e. apart from abject failure, this always creates a new colour.
static void	EnsureColourIsInDocument (Document *SourceDoc, Document *DestDoc, DocColour *SourceAndResultCol)
	Ensures that the given DocColour references a "safe" colour to use within the given document. This may mean doing nothing to the colour, or it may be necessary to copy the colour (and possibly linked parent colour(s) as well!) into the DestDoc. Whatever happens, ResultCol will be filled in with something that you can use with confidence.
static BOOL	GetCurrentLineAndFillAttrs (AttrStrokeColour **LineAttr, AttrFillGeometry **FillAttr)
	Determines the current line and fill colour attributes. These are the default ones, or if there is a selection, the attrs which are common to all selected objects. If there are many different attributes of the same type associated with the selection, NULL is returned. Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care This function ensures that Current == Selected during its operation.
static BOOL	GetCurrentLineAndFillColours (DocColour **LineCol, DocColour **FillCol, DocColour **EndGradFill=NULL)
	Finds the current line and fill attributes, and dereferences them to find the current line and fill DocColours. These may be returned NULL if there are no current attributes (no document/many colours selected).
static void	FindColourOfInterestToUser (IndexedColour **ResultCol, ColourList **ResultList=NULL)
	Several things (Colour editor whenever the selection changes, generation of a new colour) need to know a 'useful' colour to display/copy. Rather than just showing the current default colour or something, they need to interactively update to show an appropriate colour from the selection and suchlike.
static void	FindColourOfInterestToUser (DocColour *ResultCol, ColourList **ResultList=NULL, BOOL WantLineColour=FALSE)
	Several things (Colour editor whenever the selection changes, generation of a new colour) need to know a 'useful' colour to display/copy. Rather than just showing the current default colour or something, they need to interactively update to show an appropriate colour from the selection and suchlike.
Protected Member Functions
MsgResult	Message (Msg *Msg)
	Process messages sent to the ColourManager Some messages (DocChanging) will cause new broadcasts indicating that the colour system has changed (new colour list has been paged in, etc).
Static Protected Attributes
static ColourList *	CurrentColourList
static Document *	ScopeDocument

---

Detailed Description

This class provides miscellaneous shared functions for use by various colour entities. The provided functions are currently:.

Author:

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

Date:

11/5/94

Determine the current colour list

This is the Indexed Colour list for the SelectedDocument (if any). It is displayed by the colour bar, and/or edited by the Colour Manager Dialogue.

Find a suitable global or document-specific colour context to use

Handle colour system state changes

Messages are sent whenever the current list changes. This happens when:

1) A colour is inserted/deleted/edited in the SelectedDocument,

2) The SelectedDocument changes,

3) The Colour List is deselected (i.e. when there is no SelectedDocument, there is no available list)

These messages allow the colour manager dialogues and colour bar (and other clients) to update their contents (or hide, etc) when such changes occur.

Other processing (invalidating colour caches, etc) may also occur in some cases. This is all handled internally by the ColourManager.

Copy or create new colours

Find "Useful" colours for the editor to edit and the colour line/gallery to display.

Miscellaneous other useful functions. See colormgr.h for details of currently available functions

See also:

ColourBar; ColourMgrDlg; ColourChangingMsg; ColourList Documentation: HowToUse.doc

Definition at line 168 of file colormgr.h.

---

Constructor & Destructor Documentation

ColourManager::ColourManager (   )

Constructs a ColourManager object. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/94 See also: ColourManager; MessageHandler Definition at line 168 of file colormgr.cpp. : MessageHandler(CC_RUNTIME_CLASS(MessageHandler), TRUE) { }

---

Member Function Documentation

BOOL ColourManager::ChangeColour (  ColourList *  ColList, IndexedColour *  NewDefn, IndexedColour *  Target, BOOL  ChangeIsInvisible = FALSE )  [static]

This changes the colour 'Target' to be the same as 'NewDefn'. To achieve undo of this operation, the data members of the two colours are swapped (as the colour being changed must stay at the same memory location), and the NewDefn is used again as the undo record of this colour. Whenever the colour is changed, including during the execution of this funciton, and also by undo/redo, a ColourChangingMsg will be broadcast (either COLOURUPDATED or COLOURUPDATEDINVISIBLE, depending on the state of the ChangeIsInvisible flag). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/94 Parameters: ColList  - The colour list in which the colours reside [INPUTS] NewDefn - The new IndexedColour definition to be applied Target - The colour to which the definition is to be applied ChangeIsInvisible - TRUE if the change does not affect 'visible' parts of the colour definition (i.e. if objects drawn using this colour need not be redrawn). FALSE if the chnage does affect such objects. -  [OUTPUTS] Returns: TRUE if it thinks it succeeded Notes: As the memory occupied by 'NewDefn' is used in the undo record, it is essential that you do NOT DELETE it after invoking this function. You must also make absolutely sure that you do not pass the same pointer in NewDefn more than once, or a crash will occur when Camelot throws away the undo records. See also: OpColourChange; ColourChangingMsg Definition at line 2124 of file colormgr.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR3IF(ColList == NULL || NewDefn == NULL || Target == NULL, "ColourManager::ChangeColour - illegal NULL param(s)"); OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpColourChange)); if (OpDesc != NULL) { ColourChangeInfo Param; Param.ParentList = ColList; Param.Target = Target; Param.NewDefn = NewDefn; Param.InvisibleChange = ChangeIsInvisible; OpDesc->Invoke((OpParam *) &Param); } #endif return(TRUE); }

void ColourManager::ColourHasChanged (  Document *  ScopeDoc, ColourList *  ColList, IndexedColour *  Col )  [static]

Indicates to all interested parties that the given IndexedColour has been changed (sends a COLOURUPDATED message) e.g. Causes the ColourBar and document to redraw themselves. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/94 Parameters: ScopeDoc  - the document in which this change is occurring [INPUTS] ColList - the list of IndexedColours in which 'Col' resides Col - A pointer to the IndexedColour which has been changed -  [OUTPUTS] Returns: - This variant indicates that the actual visible-colour definition has changed (i.e. the appearance of something filled with this colour will chnage, and thus must be redrawn). If 'non-visible' information only has changed, use ColourHasChangedInvisible instead. Notes: If you are recieving messages, and wish to act on COLOURUPDATEDINVISIBLE, you should sit on BOTH COLOURUPDATED messages. Otherwise, you should only sit on COLOURUPDATED messages. The ColourManager will force-redraw the parst of the ScopeDoc which rely on the changed colour, or any colour liked to the changed colour. If ColList == the current colour list then entities such as the colour bar will redraw themselves to show the new state of this colour. See also: ColourManager::ColourHasChangedInvisible Definition at line 1867 of file colormgr.cpp. { ERROR3IF(ScopeDoc == NULL || ColList == NULL || Col == NULL, "ColourManager::ColourHasChanged - NULL parameters are illegal!\n"); ColList->InvalidateInheritanceCache(); BROADCAST_TO_ALL(ColourChangingMsg(ScopeDoc, ColList, Col, ColourChangingMsg::COLOURUPDATED)); }

void ColourManager::ColourHasChangedInvisible (  Document *  ScopeDoc, ColourList *  ColList, IndexedColour *  Col )  [static]

Indicates to all interested parties that the given IndexedColour has been changed (sends a COLOURUPDATEDINVISIBLE message) e.g. Causes the ColourBar to redraw itself. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/94 Parameters: ScopeDoc  - NULL, or the document in which this change is occurring [INPUTS] (if non-NULL, the ColourManager will force a redraw of this document) ColList - NULL, or a list of IndexedColours in which 'Col' can be found. Col - A pointer to the IndexedColour which has been changed -  [OUTPUTS] Returns: - This variant indicates that the actual visible-colour definition has NOT changed (i.e. the appearance of something filled with this colour will NOT change, and thus redraw is unnecessary). e.g. the If 'visible' information has changed, use ColourHasChanged instead. Notes: If you are recieving messages, and wish to act on COLOURUPDATEDINVISIBLE, you should sit on BOTH COLOURUPDATED messages. ColList really should point to the list in which the colour resides. If ColList == NULL or ColList == the current colour list, then entities such as the colour bar will redraw themselves to show the new state of this colour. If ColList is not NULL, then all its sort orders will be marked invalid so that they are re-sorted the next time they are used. (If an incorrect pointer (or NULL) is passed in, unnecessary redraws of colour bars etc may take place, so it is most preferable that you pass in the correct list pointer if you know it) See also: ColourManager::ColourHasChanged Definition at line 1924 of file colormgr.cpp. { ColList->InvalidateInheritanceCache(); BROADCAST_TO_ALL(ColourChangingMsg(ScopeDoc, ColList, Col, ColourChangingMsg::COLOURUPDATEDINVISIBLE)); }

void ColourManager::ColourListHasChanged (  ColourList *  ColList  )  [static]

To inform all interested parties that the given list of IndexedColours has changed by item(s) being added, deleted, or moved to a new position. e.g This causes the ColourBar and ColourMgrDlg to update their displays to reflect the new state of the list, if the list is the one which they are currently displaying. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/94 Parameters: ColList  - A ColourList of IndexedColours which has changed [INPUTS] May NOT be NULL -  [OUTPUTS] Returns: - Notes: Remember to invalidate the sort orders in this sorted list if you have done anything that could affect sorting (Adding items will do this automatically, but you must do it if you've changed a colour) This is not done by this function, as actions such as deleting items never affect the sort order, but do need to cause a re-display Definition at line 1959 of file colormgr.cpp. { ERROR3IF(ColList == NULL, "ColourManager::ColourListHasChanged: NULL parameter is illegal"); // Inform the colour gallery ahead of everyone else // ColourGallery::ColourListHasChanged(ColList); // And inform the plebs ColList->InvalidateInheritanceCache(); Document *ParentDoc = (Document *) ColList->GetParentDocument(); BROADCAST_TO_ALL(ColourChangingMsg(ParentDoc, ColList, NULL, ColourChangingMsg::LISTUPDATED)); }

void ColourManager::Deinit (  void   )  [static]

De-Initlialises the entire colour system. This includes the colour manager, colour contexts, and colour dialogues, etc. Notes: Should only be called once ever. Called by Application::Deinit(). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 1/6/94 See also: ColourManager; MessageHandler Definition at line 233 of file colormgr.cpp. { // shut down the colour contexts ColourContextList::DeinitColourContexts(); }

void ColourManager::EnsureColourIsInDocument (  Document *  SourceDoc, Document *  DestDoc, DocColour *  ResultCol )  [static]

Ensures that the given DocColour references a "safe" colour to use within the given document. This may mean doing nothing to the colour, or it may be necessary to copy the colour (and possibly linked parent colour(s) as well!) into the DestDoc. Whatever happens, ResultCol will be filled in with something that you can use with confidence. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/4/95 (Moved to ColourManager, 20/11/95) Parameters: SourceDoc  - NULL, or the document which contains the source colour [INPUTS] DestDoc - The document in which you want to use the colour (NOT NULL) ResultCol - should point at a DocColour defining the colour you want to put in this document. It may be an immediate DocColour, or a reference to an IndexedColour. (this param may NOT be NULL) Parameters: ResultCol  (which may not be NULL) will be returned with a colour to [OUTPUTS] use. This will either be COLOUR_TRANS, or will point at an IndexedColour in the SELECTED document which you may apply in that document. Notes: Uses the component copy system to copy colours across with merging. What do you mean this should be in the colour manager? Have you seen how many files it rebuilds?! Eeek! (OK, so I've moved it now) See also: ColourListComponent::StartComponentCopy Definition at line 1784 of file colormgr.cpp. { ERROR3IF(ResultCol == NULL || DestDoc == NULL, "Illegal NULL param"); if (SourceDoc == DestDoc) // Completely safe - into the same doc return; // Find the indexed colour (if any) that the given colour references IndexedColour *ColourToApply = ResultCol->FindParentIndexedColour(); if (ColourToApply == NULL) // It's a simple DocColour, so safe return; // It's an IndexedColour. We must copy it to the dest doc, and use the copy. if (DestDoc != NULL) { // We're applying the colour into a different document! // We must duplicate (with merging) this colour into the dest doc before applying ColourListComponent *ColComp = (ColourListComponent *) DestDoc->GetDocComponent(CC_RUNTIME_CLASS(ColourListComponent)); // Start the copy if (ColComp != NULL && ColComp->StartComponentCopy()) { DocColour RefCol; RefCol.MakeRefToIndexedColour(ColourToApply); // Copy this colour (and any linked parents if necessary). RefCol now // references the destination colour, so we point ColourToApply at it ColComp->CopyColourAcross(&RefCol); ColourToApply = RefCol.FindParentIndexedColour(); // And clean up, merging the colour into the other document's colour list ColComp->EndComponentCopy(NULL, FALSE); // We've got an IndexedColour, so set ResultCol on it, and return ResultCol->MakeRefToIndexedColour(ColourToApply); return; } } // We've failed to copy the colour across, so set it to simple 'no colour' *ResultCol = DocColour(COLOUR_BLACK); }

void ColourManager::FindColourOfInterestToUser (  DocColour *  ResultCol, ColourList **  ResultList = NULL, BOOL  WantLineColour = FALSE )  [static]

Several things (Colour editor whenever the selection changes, generation of a new colour) need to know a 'useful' colour to display/copy. Rather than just showing the current default colour or something, they need to interactively update to show an appropriate colour from the selection and suchlike. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/95 Parameters: -  [INPUTS] ResultCol  - will be returned filled in with details of the colour to use [OUTPUTS] ResultList - NULL, or a pointer to the ColourList of the relevant document WantLinecolour - TRUE if you'd rather get a line colour, FALSE if you want a fill colour. Returns: - This is very similar to the other overloaded method, but returns a DocColour. NOTE however, that the returned colour may not match the IndexedColour returned by the other method - a DocColour (which does not reference a NAMED IndexedColour) may be returned before a suitable IndexedColour would have been found. This is used to determine the colour definition for a colour to use when editing "local colours" in the colour editor. The exact colour returned will be NULL (in dire emergency, usually only occurs if there are no documents open), or will be chosen from this priority list of possible contenders: MonoOn (1) Colour of first selected fill-blob found (if !WantLineColour), (2) Fill-Colour of selection (if !WantLineColour), (3) current/default fill colour (if !WantLineColour), (4) line-Colour of selection (If WantLineColour), (5) current/default line colour (if WantLineColour), (6) COLOUR_BLACK MonoOff Notes: 'Colour of selection' is determined by using (if possible) the last object selected, or the frontmost selected object if this fails. If you are not interested in the ResultList return value, pass in NULL (use the default) for this parameter. Camelot will not return a 'no fill' default colour (conditions 3 and 6) but Webster does because the Webster colour editor wants to handle this situation. Definition at line 1202 of file colormgr.cpp. { ERROR3IF(ResultCol == NULL, "ColourManager::FindColourOfInterestToUser - ResultCol is NULL!"); // Ensure safe return values *ResultCol = DocColour(COLOUR_BLACK); if (ResultList != NULL) *ResultList = NULL; // If there are no documents available, then we can't find a colour - Return NULLs if (Document::GetSelected() == NULL) return; // Ensure CurrentDoc == SelectedDoc Document *OldCurrentDoc = SetCurrentDoc(); // Get the colour list. Just in case, we invalidate the cache (as this method is // called on document chnages and suchlike, so it is best to make sure we don't use // cached values for a no-longer-present document!) ColourList *ColList = ColourManager::GetColourList(TRUE); BOOL FoundUsefulColour = FALSE; // First, check if there is a VISIBLE selected fill blob, and use the colour of // the first one that we find, if we are lucky enough to find one. if (!WantLineColour && AttrFillGeometry::CountSelectionControlPoints() > 0) { // Yep. There is at least 1 visible selected fill blob... AttrFillGeometry* Fill = AttrFillGeometry::FindFirstSelectedAttr(); while (Fill != NULL && !FoundUsefulColour) { if (Fill->GetSelectionCount() > 0) { // CGS .... // DMc's multi stage fills (blobs) do not dynamically update the colour edit // dialog when they are clicked on. This has now been // fixed (by me!). Problem was to do with the fact that this function never // even considered them .... FillRamp* pFillRamp = Fill->GetFillRamp (); if (pFillRamp != NULL) { UINT32 NumberSelected = pFillRamp->CountSelBlobs (); if (NumberSelected > 0) { INT32 SelectedIndex = pFillRamp->GetSelectedIndex (); ColRampItem* TheItem = (ColRampItem*) pFillRamp->GetValidIndexedItem (SelectedIndex); if (TheItem != NULL) { FoundUsefulColour = TRUE; *ResultCol = TheItem->GetColour (); } } } if (Fill->IsSelected(FILLCONTROL_STARTPOINT) && Fill->GetStartColour() != NULL) { // Use Fill Start Colour FoundUsefulColour = TRUE; *ResultCol = *(Fill->GetStartColour()); break; } if (Fill->IsSelected(FILLCONTROL_ENDPOINT) && Fill->GetEndColour() != NULL) { // Use Fill End Colour FoundUsefulColour = TRUE; *ResultCol = *(Fill->GetEndColour()); break; } if (Fill->IsSelected(FILLCONTROL_ENDPOINT2) && Fill->GetEndColour2() != NULL) { // Use Fill End Colour FoundUsefulColour = TRUE; *ResultCol = *(Fill->GetEndColour2()); break; } if (Fill->IsSelected(FILLCONTROL_ENDPOINT3) && Fill->GetEndColour3() != NULL) { // Use Fill End Colour FoundUsefulColour = TRUE; *ResultCol = *(Fill->GetEndColour3()); break; } } Fill = AttrFillGeometry::FindNextSelectedAttr(); } } if (!FoundUsefulColour) { // Find the last node which was made selected (if any) // Scan back from this to find the nearest previous NodeAttribute which contains // colour(s), and make ResultColour ref the first IndexedColour which we find in this search. SelRange *Selection = GetApplication()->FindSelection(); // If there are any selected nodes, then... if (Selection != NULL && Selection->Count() > 0) { Node *pNode = Selection->GetLastSelectedNode(); // If the SelRange doesn't know what was last made selected, then see if anything // is selected, and if so, grab the last (topmost) selected object instead if (pNode == NULL) pNode = Selection->FindLast(); // Now search through the attributes applied to this node, to see if we can // find an IndexedColour FILL (i.e. we ignore stroke colours for now) - we // will use the first one that we find NodeAttribute *pAttr = NULL; if (!WantLineColour) { if (pNode != NULL) pAttr = NodeAttribute::FindFirstAppliedAttr(pNode); while (pAttr != NULL && !FoundUsefulColour) { // Scan each NodeAttribute in turn to see if any of them contain any colours DocColour *pColour; UINT32 Context = 0; // Only check non-line-colour attributes if (!(IS_A(pAttr, AttrStrokeColour))) { do { // Get the next colour field (if any) from the attribute, and find the // IndexedColour (if any) to which it refers pColour = pAttr->EnumerateColourFields(Context++); if (pColour != NULL) { FoundUsefulColour = TRUE; *ResultCol = *pColour; } } while (pColour != NULL && !FoundUsefulColour); } pAttr = NodeAttribute::FindPrevAppliedAttr(pAttr); } } else { // If we still haven't found a colour, try for a line/stroke colour instead if (pNode != NULL && !FoundUsefulColour) pAttr = NodeAttribute::FindFirstAppliedAttr(pNode); while (pAttr != NULL && !FoundUsefulColour) { // Scan each NodeAttribute in turn to see if any of them contain any colours DocColour *pColour; UINT32 Context = 0; // Only check line-colour attributes if (IS_A(pAttr, AttrStrokeColour)) { do { // Get the next colour field (if any) from the attribute, and find the // IndexedColour (if any) to which it refers pColour = pAttr->EnumerateColourFields(Context++); if (pColour != NULL) { FoundUsefulColour = TRUE; *ResultCol = *pColour; } } while (pColour != NULL && !FoundUsefulColour); } pAttr = NodeAttribute::FindPrevAppliedAttr(pAttr); } } } } if (!FoundUsefulColour) { // OK, then. let's see if there is a default fill colour, or failing that // (eg it could be 'no colour') a default line colour, which we can edit. AttributeManager &AttrMgr = Document::GetSelected()->GetAttributeMgr(); DocColour LineCol; DocColour FillCol; AttrMgr.GetCurrentLineAndFillColour(CC_RUNTIME_CLASS(NodeRenderableInk), &LineCol, &FillCol); if (!WantLineColour) { // Webster wants the colour even if it is 'no fill' #ifndef WEBSTER if (!FillCol.IsTransparent()) #endif //WEBSTER { *ResultCol = FillCol; FoundUsefulColour = TRUE; } } else { #ifndef WEBSTER if (!LineCol.IsTransparent()) #endif //WEBSTER { *ResultCol = LineCol; FoundUsefulColour = TRUE; } } } if (!FoundUsefulColour) { // Ok, we're rapidly approaching a moment of panic. Try the first non-deleted named // colour in the selected document's colour list. If nothing else, there should // always be a default Black that we can use if (ColList != NULL) { IndexedColour *Ptr = (IndexedColour *) ColList->GetHead(); while (Ptr != NULL && !FoundUsefulColour) { if (Ptr->IsNamed() && !Ptr->IsDeleted()) { FoundUsefulColour = TRUE; ResultCol->MakeRefToIndexedColour(Ptr); } Ptr = (IndexedColour *) ColList->GetNext(Ptr); } } } // Fill in the return results if (ResultList != NULL) *ResultList = ColList; // And restore the previous CurrentDocument state RestoreCurrentDoc(OldCurrentDoc); }

void ColourManager::FindColourOfInterestToUser (  IndexedColour **  ResultCol, ColourList **  ResultList = NULL )  [static]

Several things (Colour editor whenever the selection changes, generation of a new colour) need to know a 'useful' colour to display/copy. Rather than just showing the current default colour or something, they need to interactively update to show an appropriate colour from the selection and suchlike. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/95 Parameters: -  [INPUTS] ResultCol  - NULL, or a pointer to the colour to use [OUTPUTS] ResultList - NULL, or a pointer to the ColourList that colour resides in Returns: - NOTE that there is another overloaded form of this method, which returns a DocColour istead. This method returns a pointer to a NAMED IndexedColour, so may return an entirely different colour to the other function. The exact colour returned will be NULL (in dire emergency, usually only occurs if there are no documents open), or will be chosen from this priority list of possible contenders: MonoOn (1) Colour of first selected fill-blob found, (2) Fill-Colour of selection, (3) current/default fill colour, (4) line-Colour of selection, (5) current/default line colour, (6) the first active named colour in the document's colour list, (7) NULL MonoOff Notes: 'Colour of selection' is determined by using (if possible) the last object selected, or the frontmost selected object if this fails. If you are not interested in the ResultList return value, pass in NULL (use the default) for this parameter. In debug builds only, extra checks are made which can cause an ERROR3 if the colour found was not in the selected document's ColourList. Definition at line 932 of file colormgr.cpp. { ERROR3IF(ResultCol == NULL, "ColourManager::FindColourOfInterestToUser - ResultCol is NULL!"); // Ensure safe return values *ResultCol = NULL; if (ResultList != NULL) *ResultList = NULL; // If there are no documents available, then we can't find a colour - Return NULLs if (Document::GetSelected() == NULL) return; // Ensure CurrentDoc == SelectedDoc Document *OldCurrentDoc = SetCurrentDoc(); // Get the colour list. Just in case, we invalidate the cache (as this method is // called on document chnages and suchlike, so it is best to make sure we don't use // cached values for a no-longer-present document!) ColourList *ColList = ColourManager::GetColourList(TRUE); IndexedColour *UsefulColour = NULL; // First, check if there is a VISIBLE selected fill blob, and use the colour of // the first one that we find, if we are lucky enough to find one. if (AttrFillGeometry::CountSelectionControlPoints() > 0) { // Yep. There is at least 1 visible selected fill blob... AttrFillGeometry* Fill = AttrFillGeometry::FindFirstSelectedAttr(); while (Fill != NULL && UsefulColour == NULL) { if (Fill->GetSelectionCount() > 0) { if (Fill->IsSelected(FILLCONTROL_STARTPOINT) && Fill->GetStartColour() != NULL) { // Use Fill Start Colour UsefulColour = Fill->GetStartColour()->FindParentIndexedColour(); break; } if (Fill->IsSelected(FILLCONTROL_ENDPOINT) && Fill->GetEndColour() != NULL) { // Use Fill End Colour UsefulColour = Fill->GetEndColour()->FindParentIndexedColour(); break; } if (Fill->IsSelected(FILLCONTROL_ENDPOINT2) && Fill->GetEndColour2() != NULL) { // Use Fill End Colour UsefulColour = Fill->GetEndColour2()->FindParentIndexedColour(); break; } if (Fill->IsSelected(FILLCONTROL_ENDPOINT3) && Fill->GetEndColour3() != NULL) { // Use Fill End Colour UsefulColour = Fill->GetEndColour3()->FindParentIndexedColour(); break; } } Fill = AttrFillGeometry::FindNextSelectedAttr(); } } if (UsefulColour == NULL) { // Find the last node which was made selected (if any) // Scan back from this to find the nearest previous NodeAttribute which contains // colour(s), and make UsefulColour the first IndexedColour which we find in this search. SelRange *Selection = GetApplication()->FindSelection(); if (Selection != NULL) { Node *pNode = Selection->GetLastSelectedNode(); // If the SelRange doesn't know what was last made selected, then see if anything // is selected, and if so, grab the last (topmost) selected object instead if (pNode == NULL) pNode = Selection->FindLast(); // Now search through the attributes applied to this node, to see if we can // find an IndexedColour FILL (i.e. we ignore stroke colours for now) - we // will use the first one that we find NodeAttribute *pAttr = NULL; if (pNode != NULL) pAttr = NodeAttribute::FindFirstAppliedAttr(pNode); while (pAttr != NULL && UsefulColour == NULL) { // Scan each NodeAttribute in turn to see if any of them contain any colours DocColour *pColour; UINT32 Context = 0; // Only check non-line-colour attributes if (!(IS_A(pAttr, AttrStrokeColour))) { do { // Get the next colour field (if any) from the attribute, and find the // IndexedColour (if any) to which it refers pColour = pAttr->EnumerateColourFields(Context++); if (pColour != NULL) UsefulColour = pColour->FindParentIndexedColour(); } while (pColour != NULL && UsefulColour == NULL); } pAttr = NodeAttribute::FindPrevAppliedAttr(pAttr); } // If we still haven't found a colour, try for a line/stroke colour instead if (pNode != NULL && UsefulColour == NULL) pAttr = NodeAttribute::FindFirstAppliedAttr(pNode); while (pAttr != NULL && UsefulColour == NULL) { // Scan each NodeAttribute in turn to see if any of them contain any colours DocColour *pColour; UINT32 Context = 0; // Only check line-colour attributes if (IS_A(pAttr, AttrStrokeColour)) { do { // Get the next colour field (if any) from the attribute, and find the // IndexedColour (if any) to which it refers pColour = pAttr->EnumerateColourFields(Context++); if (pColour != NULL) UsefulColour = pColour->FindParentIndexedColour(); } while (pColour != NULL && UsefulColour == NULL); } pAttr = NodeAttribute::FindPrevAppliedAttr(pAttr); } } } if (UsefulColour == NULL) { // OK, then. let's see if there is a default fill colour, or failing that // (eg it could be 'no colour') a default line colour, which we can edit. AttributeManager &AttrMgr = Document::GetSelected()->GetAttributeMgr(); DocColour LineCol; DocColour FillCol; AttrMgr.GetCurrentLineAndFillColour(CC_RUNTIME_CLASS(NodeRenderableInk), &LineCol, &FillCol); UsefulColour = FillCol.FindParentIndexedColour(); if (UsefulColour == NULL) UsefulColour = LineCol.FindParentIndexedColour(); } if (UsefulColour == NULL) { // Ok, we're rapidly approaching a moment of panic. Try the first non-deleted named // colour in the selected document's colour list. If nothing else, there should // always be a default Black that we can use if (ColList != NULL) { IndexedColour *Ptr = (IndexedColour *) ColList->GetHead(); while (Ptr != NULL && UsefulColour == NULL) { if (Ptr->IsNamed() && !Ptr->IsDeleted()) UsefulColour = Ptr; Ptr = (IndexedColour *) ColList->GetNext(Ptr); } } } // Sanity check. Should never ever ever be the case, ever. if (UsefulColour != NULL) ERROR3IF(UsefulColour->IsDeleted(), "ColourManager::FindColourOfInterestToUser - Colour found is DELETED!"); // Fill in the return results *ResultCol = UsefulColour; if (UsefulColour != NULL && ResultList != NULL) *ResultList = ColList; #ifdef _DEBUG // In debug builds, verify that the returned colour is in the list we // expect it to be in! if (ColList != NULL && UsefulColour != NULL) { IndexedColour *Ptr = (IndexedColour *) ColList->GetHead(); while (Ptr != NULL && Ptr != UsefulColour) Ptr = (IndexedColour *) ColList->GetNext(Ptr); if (Ptr == NULL) { Ptr = (IndexedColour *) ColList->GetUnnamedColours()->GetHead(); while (Ptr != NULL && Ptr != UsefulColour) Ptr = (IndexedColour *) ColList->GetUnnamedColours()->GetNext(Ptr); } ERROR3IF(Ptr != UsefulColour, "ColourManager::FindColourOfInterestToUser" " - Colour found is not in the current colour list!"); } #endif // And restore the previous CurrentDocument state RestoreCurrentDoc(OldCurrentDoc); }

void ColourManager::ForceRedrawOfChangedColours (  Document *  ScopeDoc, IndexedColour **  Colours )  [static]

Scans the document tree of the given scope document, and causes a redraw of all objects which are affected by any attributes which contain references to any of the colours in the given NULL-terminated list of colours. If none of the colours are in use in the document tree, nothing should result. (i.e. it force redraws any areas of the document containing any of the given colours). See also: RecursivelyForceRedraw Definition at line 261 of file colormgr.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Sanity check if (ScopeDoc == NULL) { ERROR3("Illegal NULL param"); return; } OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_REDRAWCOLOURS); if (OpDesc != NULL) { OpRedrawColoursInfo Info; Info.ScopeDoc = ScopeDoc; Info.Colours = Colours; OpDesc->Invoke((OpParam *) &Info); } #endif }

IndexedColour * ColourManager::GenerateNewNamedColour (  ColourList *  ParentList, IndexedColour *  SourceColour )  [static]

Creates a new named IndexedColour. If possible, this colour is copied from the given SourceColour, but if this is not available, an attempt to find a useful colour to copy will be made - if this fails, a battleship grey will be created. i.e. apart from abject failure, this always creates a new colour. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 25/11/94 Parameters: ParentList  - The list in which the SourceColour resides - The resulting [INPUTS] colour will also be placed into this list. May NOT be NULL. SourceColour - NULL (to copy the current attribute FillColour), or a pointer to the colour you wish to duplicate. (ParentList  - will contain the new colour if all went well) [OUTPUTS] Returns: NULL if it failed, else A clone of SourceColour. This will be pretty much identical to SourceColour, except that it will always be a NAMED colour. It generates a new colour, adds it to the ParentList, and generates an UNDO record for the action; this includes a ColourListChanged msg broadcast. NOTE that the user is prompted for a new name, and has the opportunity to cancel creation of the colour, in which case, NULL will be returned. You must therefore handle a NULL return *quietly*. Notes: This code is used by the ColourBar and ColourGallery "new colour" code to generate a new named colour. Returns: Errors: If the return value is NULL, an unreported memory allocation failure has occurred. If the ParentList is not the ColourList for the Selected document, and no source colour is given, chances are FindColourOfInterestToUser will get upset and ERROR3. See also: IndexedColour::IndexedColour; ColourManager::UnHideColours; ColourManager::FindColourOfInterestToUser Definition at line 1499 of file colormgr.cpp. { ERROR3IF(ParentList == NULL, "ColourManager::GenerateNamedColour - NULL ParentList!"); IndexedColour *NewCol = NULL; if (SourceColour != NULL) { // Copy the source colour NewCol = new IndexedColour(*SourceColour); // If parent is named and not tint/linked colour, remember where we copied // it from so that we can give a useful default parent in the colour editor // if the user decides to make it a tint/linked colour later on. if (NewCol->IsNamed() && NewCol->FindLinkedParent() == NULL) NewCol->SetLinkedParent(SourceColour, NewCol->GetType()); } else { IndexedColour *UsefulColour; FindColourOfInterestToUser(&UsefulColour); if (UsefulColour != NULL) { NewCol = new IndexedColour(*UsefulColour); // If parent is named and not tint/linked colour, remember where we copied // it from so that we can give a useful default parent in the colour editor // if the user decides to make it a tint/linked colour later on. if (NewCol->IsNamed() && NewCol->FindLinkedParent() == NULL) NewCol->SetLinkedParent(UsefulColour, NewCol->GetType()); } else { // Create a mid-grey HSV colour for them to edit ColourHSVT Bob; Bob.Hue = Bob.Saturation = Bob.Transparent = 0; Bob.Value = FIXED24(0.5); NewCol = new INDEXEDCOLOUR_HSVT(&Bob); } } if (NewCol == NULL) // Serious memory failure! return(NULL); // Set the colour's name (1 to make it named, and 2 so it is not // the same as the colour it was copied from) /* String_64 NewName; if (NewCol->IsNamed()) { // Is named, so is a copy: Name it "New Colour (Copy of WXYZ)" String_64 OldName = *NewCol->GetName(); String_64 TruncOldName; // Truncate old name to 32 chars OldName.Left(&TruncOldName, 32); // and add it into the new name NewName.MakeMsg(_R(IDS_NEWCOLOUR_COPY), (TCHAR *)TruncOldName); } else NewName.MakeMsg(_R(IDS_NEWCOLOUR)); // No name, so make it named: "New colour" */ #if !defined(EXCLUDE_FROM_RALPH) #ifndef STANDALONE // Ask for a new name for the colour. This also gives the user a chance // to back out of the deal without losing their deposit (though if they didn't // tick the small box in the small print, we'll continue sending them junk mail ;-) if (!NewColourDlg::InvokeDialog(ParentList, NewCol, NEWCOLOUR_MUSTBENAMED)) { delete NewCol; // Bummer. They cancelled their subscription return(NULL); } #endif #endif // NewCol->SetName(NewName); // Add the new colour (also ensuring that the colour has a unique name) ParentList->AddItem(NewCol); // Create an undo record, but only if it is a colour style (named) IndexedColour *UnHideList[2]; UnHideList[0] = NewCol; UnHideList[1] = NULL; ColourManager::UnHideColours(ParentList, UnHideList); return(NewCol); }

IndexedColour * ColourManager::GenerateNewUnnamedColour (  ColourList *  ParentList, DocColour *  BaseSourceColour )  [static]

Creates a new named IndexedColour. If possible, this colour is copied from the given SourceColour, but if this is not available, an attempt to find a useful colour to copy will be made - if this fails, a battleship grey will be created. i.e. apart from abject failure, this always creates a new colour. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 29/3/95 Parameters: ParentList  - The list in which the resulting colour will be placed. [INPUTS] In debug builds an ENSURE will be triggered if the new colour would be created with a parent-colour in a different colour list. May NOT be NULL. SourceColour - A pointer to the colour you wish to duplicate. If NULL, some random "useful" colour will be substituted. Parameters: (ParentList  - will contain the new colour if all went well) [OUTPUTS] Returns: NULL if it failed, else A copy of SourceColour. This will be pretty much identical to SourceColour, except that it will always be an UNNAMED IndexedColour. It generates a new colour & adds it to the ParentList unnamed-colours-list Notes: This code is used by the Colour Editor to generate a new unnamed colour when editing "local colours". Unnamed colours are auto-destructed when their usagecount is decremented to zero, so you don't generally need to clean up these colours. When copying a colour style as an unnamed colour, we force it to be 'normal' This is so that initial attempts to edit the colour of an object delink it from its parent, and allow the colour to be freely edited. When editing the local colour, this force won't occur, which allows the user to specifically make locals which are links/tints. Returns: Errors: If the return value is NULL, an unreported memory allocation failure has occurred. See also: IndexedColour::IndexedColour; ColourManager::UnHideColours; ColourManager::FindColourOfInterestToUser Definition at line 1641 of file colormgr.cpp. { if (ParentList == NULL) { ERROR3("ColourManager::GenerateNewUnnamedColour - NULL ParentList!"); return(NULL); } IndexedColour *NewCol = NULL; DocColour SourceColour(COLOUR_BLACK); if (BaseSourceColour == NULL) FindColourOfInterestToUser(&SourceColour); // No supplied colour, so find one else SourceColour = *BaseSourceColour; // Use the supplied colour IndexedColour *SourceIxCol = SourceColour.FindParentIndexedColour(); if (SourceIxCol == NULL) { // Copy the definition of a DocColour ColourGeneric ColDef; SourceColour.GetSourceColour(&ColDef); NewCol = new IndexedColour(SourceColour.GetColourModel(), &ColDef); } else { // Copy an IndexedColour NewCol = new IndexedColour(*SourceIxCol); if (NewCol != NULL) { NewCol->SetUnnamed(); // Ensure the colour is unnamed // When copying a colour style as an unnamed colour, we force it to be 'normal' // This is so that initial attempts to edit the colour of an object delink // it from its parent, and allow the colour to be freely edited. When editing // the local colour, this force won't occur, which allows the user to specifically // make locals which are links/tints. // NOTE that we make the source colour our parent, so that subsequent attempts // to edit this colour will choose a sensible parent. // if (SourceIxCol->IsNamed()) // { // We no longer do this (Jason - 18/10/95) // This was a fix to the fact that the user could not edit tints/linked colours in the "simple" // colour editor, and thus could get trapped in a very confusing uneditable state. // These days they have both the ability to edit all colour types in the simple mode, // and the extra status line and constraint-display stuff to make it more obvious why they // can't change stuff when they can't. // NewCol->SetLinkedParent(SourceIxCol, COLOURTYPE_NORMAL); // // } // We have copied the Parent colour (hint) from the copied colour. // However, if this is a "normal" (unlinked) colour, we really want to set // the parent hint to be the colour we were copied from. // (But we can only use the source colour if it's named and "alive") if (NewCol->FindLinkedParent() == NULL && SourceIxCol->IsNamed() && !SourceIxCol->IsDeleted()) NewCol->SetLinkedParent(SourceIxCol, NewCol->GetType()); } } // Check that the parent colour of our new one is a legal parent (named, not deleted, and exists // in the target document) if (NewCol != NULL) { IndexedColour *Parent = NewCol->FindLastLinkedParent(); if (Parent != NULL) { if (Parent->IsDeleted() || !Parent->IsNamed()) Parent = NULL; // Deleted or unnamed - forget it if (Parent != NULL) { // Check that the parent colour is in the same colour list as the NewCol will be going IndexedColour *Ptr = ParentList->GetUndeletedHead(); while (Ptr != NULL) { if (Ptr == Parent) break; Ptr = ParentList->GetUndeletedNext(Ptr); } if (Ptr != Parent) Parent = NULL; } // Nope - we haven't got a safe parent, so vape the parent field altogether if (Parent == NULL) { ERROR3("Warning: Had to correct colour with illegal parent pointer"); NewCol->SetLinkedParent(NULL, COLOURTYPE_NORMAL); } } // Add the new colour (also ensuring that the colour has a unique name) ParentList->GetUnnamedColours()->AddTail(NewCol); } return(NewCol); }

ColourContext * ColourManager::GetColourContext (  ColourModel  Model, View *  ScopeView )  [static]

To easily find an appropriate colour context to use when converting colours. There are global contexts, but in order to supply special view-specific colour corrections etc, each document view actually has its own private set of contexts. Thus, you should call this function to determine the most appropriate context to use. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/96 Parameters: Model  - The colour model of the desired ColourContext [INPUTS] ScopeView - A pointer to the view for which you want the colour context. This should not be NULL, but if it is, a global default context will be returned Returns: NULL if it failed to find an appropriate colour context, else a pointer to the context Definition at line 586 of file colormgr.cpp. { if (ScopeView != NULL) return(ScopeView->GetColourContext(Model)); return(ColourContext::GetGlobalDefault(Model)); }

ColourContext * ColourManager::GetColourContext (  ColourModel  Model, Document *  ScopeDocument = NULL )  [static]

To easily find an appropriate colour context to use when converting colours. There are global contexts, but in order to supply special document-specific colour corrections etc, each document actually has its own private set of contexts. Thus, you should call this function to determine the most appropriate context to use. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/11/95 Parameters: Model  - The colour model of the desired ColourContext [INPUTS] ScopeDocument - NULL (to retrieve a global context) or a pointer to the document for which you want the colour context. Returns: NULL if it failed to find an appropriate colour context, else a pointer to the context Definition at line 552 of file colormgr.cpp. { if (ScopeDocument == NULL) return(ColourContext::GetGlobalDefault(Model)); return(ScopeDocument->GetDefaultColourContexts()->Context[Model]); }

ColourList * ColourManager::GetColourList (  BOOL  InvalidateCache = FALSE  )  [static]

To obtain the ColourList of IndexedColours in the SelectedDocument (the colours which the user can use within the document; this is the set of colours displayed by the colour bar and edited by the ColourMgrDlg) Note that an ordered list is used so that multiple display orders can be used (e.g. for the ColourMgrDlg and ColourBar, etc). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/94 Parameters: InvalidateCache  - TRUE if you want to force it to re-cache the [INPUTS] list pointer (generally only used internally; the default setting of FALSE is all external clients should ever need to use) -  [OUTPUTS] Returns: NULL, or a pointer to the current colour list Notes: This returns the list of colours from the SELECTED document, i.e. the colours displayed in the colour bar etc. Use GetCurrentColourList if you wish to get the colours for the CURRENT doc. The list is cached so this call is generally pretty efficient Definition at line 471 of file colormgr.cpp. { Document *ParentDoc = Document::GetSelected(); if (ParentDoc != NULL) { if (InvalidateCache || ParentDoc != ScopeDocument) { CurrentColourList = ParentDoc->GetIndexedColours(); ScopeDocument = ParentDoc; } // else // Cache is up to date, so quit messing about } else { ScopeDocument = NULL; // ParentDocument is NULL - no colour list CurrentColourList = NULL; } return(CurrentColourList); }

ColourList * ColourManager::GetCurrentColourList (  void   )  [static]

To obtain the ColourList of IndexedColours in the CurrentDocument. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: NULL, or a pointer to the current colour list Notes: This returns the colours for the CURRENT document, NOT the Selected one - that is, these may not be the colours displayed in the colour bar/input-focus document. See also: ColourManager::GetColourList Definition at line 517 of file colormgr.cpp. { Document *ParentDoc = Document::GetCurrent(); if (ParentDoc != NULL) return(ParentDoc->GetIndexedColours()); return(NULL); }

BOOL ColourManager::GetCurrentLineAndFillAttrs (  AttrStrokeColour **  LineAttr, AttrFillGeometry **  FillAttr )  [static]

Determines the current line and fill colour attributes. These are the default ones, or if there is a selection, the attrs which are common to all selected objects. If there are many different attributes of the same type associated with the selection, NULL is returned. Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care This function ensures that Current == Selected during its operation. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/7/94 (Moved from ccolbar.cpp, 25/11/94) Parameters: -  [INPUTS] LineAttr  - will be filled in with NULL, or pointer to the attribute [OUTPUTS] FillAttr - will be filled in with NULL, or pointer to the attribute Returns: TRUE if these are default attributes; FALSE if the attributes are those common to the current selection. Definition at line 721 of file colormgr.cpp. { ENSURE(LineAttr != NULL && FillAttr != NULL, "ColourManager::GetCurrentLineAndFillAttrs - NULL pointers passed in!"); *LineAttr = NULL; // Ensure safe exit if we fail *FillAttr = NULL; // I don't think it is the colour bar's responsibility to check this, but // this is the only way that *I* can fix the problem of an ENSURE failure // on exit (we ask for info when no tools are current... I believe this is // because some slurphead has thrown away the tools BEFORE the document, // because the Document::GetSelected still does not return NULL in this case!) if (Tool::GetCurrent() == NULL) return(TRUE); Document *SelectedDoc = Document::GetSelected(); if (SelectedDoc == NULL) return(TRUE); // Save the current CurrentDoc, and set (CurrentDoc = SelectedDoc) Document *OldCurrentDoc = SetCurrentDoc(); SelRange *Selection = Camelot.FindSelection(); ENSURE(Selection != NULL, "No Selection SelRange!?!"); SelRange::CommonAttribResult result = Selection->FindCommonAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), (NodeAttribute **)LineAttr); if (result == SelRange::ATTR_MANY) *LineAttr = NULL; result = Selection->FindCommonAttribute(CC_RUNTIME_CLASS(AttrFillGeometry), (NodeAttribute **)FillAttr); if (result == SelRange::ATTR_MANY) *FillAttr = NULL; RestoreCurrentDoc(OldCurrentDoc); return(result == SelRange::ATTR_NONE); }

BOOL ColourManager::GetCurrentLineAndFillColours (  DocColour **  LineCol, DocColour **  FillCol, DocColour **  EndGradFill = NULL )  [static]

Finds the current line and fill attributes, and dereferences them to find the current line and fill DocColours. These may be returned NULL if there are no current attributes (no document/many colours selected). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (changed by Gerry 21/8/96) Date: 9/9/94 (Moved from ccolbar.cpp, 25/11/94) Parameters: -  [INPUTS] LineCol  - NULL, or will be filled in with a pointer to the current line colour [OUTPUTS] FillCol - NULL, or will be filled in with a pointer to the current fill colour EndGradFill - NULL, or will be filled in with NULL or the grad-fill end colour (see below) EndGradFill2 - NULL, or will be filled in with NULL or the second end colour EndGradFill3 - NULL, or will be filled in with NULL or the third end colour Returns: TRUE if these are default attributes; FALSE if the attributes are those common to the current selection. Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care LineCol and/or FillCol may be passed in NULL if you are not interested in having these results returned to you. If EndGradFill is NULL and a grad fill is selected then FillColour will be filled in with the selected fill blob's colour (or NULL if there are zero or more than one selected blob). EndGradFill2 and EndGradFill3 will be filled in with NULL (if they are non NULL) If EndGradFill is non-NULL and a grad-fill is selected, instead of returning only the selected endpoint colour, it returns the start and end colours in FillCol (start) and EndGradFill (end). If the fill has more than two colours (ie GetEndColour2() != NULL) then both FillCol and EndGradFill will bet filled in with NULL (to indicate many). MULTIFILL: This system needs to be changed to support multistage fills. See also: CColourBar::GetCurrentLineAndFillAttrs Definition at line 814 of file colormgr.cpp. { if (LineCol != NULL) // Ensure return NULL if we fail *LineCol = NULL; if (FillCol != NULL) *FillCol = NULL; if (EndGradFill != NULL) *EndGradFill = NULL; AttrStrokeColour *LineAttr = NULL; AttrFillGeometry *FillAttr = NULL; BOOL result = GetCurrentLineAndFillAttrs(&LineAttr, &FillAttr); if (LineAttr != NULL && LineCol != NULL) *LineCol = LineAttr->GetStartColour(); if (FillAttr != NULL && FillCol != NULL) { // New bit added by will (3/11/94) to make colour bar show // the selected fill control point's colour. // Note this assumes there are only start and end colours, // and so will NOT work with multi-stage fills. if (FillAttr->GetRuntimeClass() == CC_RUNTIME_CLASS(AttrFlatColourFill)) { *FillCol = FillAttr->GetStartColour(); } else { if (EndGradFill == NULL) { // The caller wants the selected point's colour or NULL (already set) if (FillAttr->GetSelectionCount() == 1) // If there is only 1 selected blob { // Get the colour of the selected blob if (FillAttr->IsSelected(FILLCONTROL_STARTPOINT)) // Show Start Colour *FillCol = FillAttr->GetStartColour(); else if (FillAttr->IsSelected(FILLCONTROL_ENDPOINT)) // Show End Colour *FillCol = FillAttr->GetEndColour(); else if (FillAttr->IsSelected(FILLCONTROL_ENDPOINT2)) // Show End2 Colour *FillCol = FillAttr->GetEndColour2(); else if (FillAttr->IsSelected(FILLCONTROL_ENDPOINT3)) // Show End3 Colour *FillCol = FillAttr->GetEndColour3(); } } else { // User wants two colours if (FillAttr->GetEndColour2() == NULL) // If the fill doesn't have a third colour { // We know FillCol is non-NULL *FillCol = FillAttr->GetStartColour(); // We know EndGradFill is non-NULL *EndGradFill = FillAttr->GetEndColour(); } } } } return(result); }

BOOL ColourManager::HideColours (  ColourList *  ColList, IndexedColour **  ColourArray, BOOL  ForceDelete )  [static]

This 'deletes' colours by creating an undoable operation to hide them. It is assumed that the colours are not in use by the time you call this function - An ENSURE failure will occur if any are. After invoking the 'hide' operation, this function calls ColourListHasChanged. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/6/94 Parameters: ColList  - The colour list in which the colours reside. Must be non-NULL. [INPUTS] ColourArray - A NULL-terminated list of pointers to colours to be hidden. NOTE that this array is changed in the process! ForceDelete - TRUE if you want to forcibly hide ('delete') all the colours, even if they are in use in the document (in this case, all references in the document will be coerced to immediate DocColours (undoable, of course) and then the colour will be hidden as usual) FALSE if you only want truly unused colours to be hidden ColourArray  may be changed (see Notes) [OUTPUTS] Returns: TRUE if it thinks it succeeded Notes: The passed ColourArray parameter is used as temporary workspace, and will be returned containing a list of the colours which were succesfully deleted. This modified list is copied for the undo system, so you need not keep it around after the call to this fn - i.e. it is your responsibility to delete the array after calling this method. The modified list is also guaranteed to be no larger than the original array, so you don't need to allocate extra space for it. See also: ColourManager::UnHideColours; ColourManager::ColourListHasChanged Definition at line 2014 of file colormgr.cpp. { ERROR3IF(ColList == NULL || ColourArray == NULL, "ColourManager::HideColours cannot accept NULL parameters\n"); HideColoursInfo HCInfo; HCInfo.ParentList = ColList; HCInfo.Colours = ColourArray; HCInfo.ForceDelete = ForceDelete; HCInfo.HideThem = TRUE; OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor( OPTOKEN_HIDECOLOURS ); if (OpDesc != NULL) OpDesc->Invoke((OpParam *) &HCInfo); return(TRUE); }

BOOL ColourManager::Init (  void   )  [static]

Initialises the entire colour system. This includes the colour manager, colour contexts, and colour dialogues, etc. Notes: Should only be called once ever. Called by Application::Init(). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/94 Returns: FALSE if initialisation failed See also: ColourManager; MessageHandler Reimplemented from SimpleCCObject. Definition at line 189 of file colormgr.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Init (register) all our operations #if !defined(EXCLUDE_FROM_XARALX) if (!::InitImagesettingOps()) return(FALSE); #endif if (!OpHideColours::Init()) return(FALSE); if (!OpColourChange::Init()) return(FALSE); if (!OpRedrawColours::Init()) return(FALSE); if (!OpMakeColourLocalToFrame::Init()) return(FALSE); #endif // Init the global list of active colour contexts if (!ColourContextList::InitColourContexts()) return(FALSE); return(TRUE); }

MsgResult ColourManager::Message (  Msg *  Message  )  [protected, virtual]

Process messages sent to the ColourManager Some messages (DocChanging) will cause new broadcasts indicating that the colour system has changed (new colour list has been paged in, etc). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/94 Parameters: Message,:  The message [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: ColourManager; MessageHandler; ColourChangingMsg Reimplemented from MessageHandler. Definition at line 303 of file colormgr.cpp. { if (MESSAGE_IS_A(Message, DocChangingMsg)) { DocChangingMsg *TheMsg = (DocChangingMsg *) Message; switch ( TheMsg->State ) { case DocChangingMsg::SELCHANGED: if (TheMsg->pNewDoc == NULL) // No document selected any more { // Send PaletteChangingMsg - DESELECTED CurrentColourList = NULL; // No document present ScopeDocument = NULL; BROADCAST_TO_ALL(ColourChangingMsg(ScopeDocument, CurrentColourList, NULL, ColourChangingMsg::LISTDESELECTED)); } else if (TheMsg->pOldDoc != TheMsg->pNewDoc) { // Send PaletteChangingMsg - PAGED CurrentColourList = NULL; // Cause re-caching of this info ScopeDocument = NULL; GetColourList(TRUE); // Find the new colour list BROADCAST_TO_ALL(ColourChangingMsg(ScopeDocument, CurrentColourList, NULL, ColourChangingMsg::LISTPAGED)); } break; case DocChangingMsg::ABOUTTODIE: // Pass this around as a ColourList killed message if (TheMsg->pChangingDoc != NULL) BROADCAST_TO_ALL(ColourChangingMsg(TheMsg->pChangingDoc, TheMsg->pChangingDoc->GetIndexedColours(), NULL, ColourChangingMsg::LISTDELETED)); if (TheMsg->pChangingDoc == ScopeDocument) { // We can't keep a cached value around, as soon after this point the // colour list will cease to exist CurrentColourList = NULL; ScopeDocument = NULL; } break; default: break; } } else if (MESSAGE_IS_A(Message, ColourChangingMsg)) { ColourChangingMsg *TheMsg = (ColourChangingMsg *) Message; switch ( TheMsg->State ) { case ColourChangingMsg::LISTUPDATED: // The list has changed- may involve a colour having been deleted. // We check if the attribute manager is using any colours which are // now deleted, and if so, set it to use safer ones! if (TheMsg->ScopeDoc == NULL || TheMsg->NewColourList == NULL) { ERROR3("ColChangingMsg::LISTUPDATED broadcast with NULL colour list"); } else TheMsg->ScopeDoc->GetAttributeMgr().UpdateForDeletedColours( TheMsg->NewColourList); break; case ColourChangingMsg::COLOURUPDATED: { // An IndexedColour has been edited. // We need to force an update on all colours Linked to this one, and // then redraw all DocViews on this document. if (TheMsg->ScopeDoc != NULL && TheMsg->NewColourList != NULL && TheMsg->ChangedColour != NULL) { IndexedColour **AffectedColours = TheMsg->NewColourList-> CompileInheritanceArray(TheMsg->ChangedColour); if (AffectedColours == NULL) { // Memory error means we can't get the array // Tell *all* linked colours in the list they may have changed List *TheList = TheMsg->NewColourList; IndexedColour *Ptr = (IndexedColour *) (TheList->GetHead()); while (Ptr != NULL) { if (Ptr->FindLinkedParent() != NULL) // If is linked Ptr->LinkedAncestorHasChanged(); // Warn it of the change Ptr = (IndexedColour *) TheList->GetNext(Ptr); } // And all unnamed colours too TheList = TheMsg->NewColourList->GetUnnamedColours(); Ptr = (IndexedColour *) (TheList->GetHead()); while (Ptr != NULL) { if (Ptr->FindLinkedParent() != NULL) // If is linked Ptr->LinkedAncestorHasChanged(); // Warn it of the change Ptr = (IndexedColour *) TheList->GetNext(Ptr); } // And force-redraw the entire document - all views CBitmapCache *pBC = Camelot.GetBitmapCache(); if( NULL != pBC ) pBC->DeInitialise(); // Brute force cache management! TheMsg->ScopeDoc->ForceRedraw(); } else { // Inform all the linked colours (except the first, which is the // actual colour which has changed) that they may have changed INT32 Index = 1; while (AffectedColours[Index] != NULL) { AffectedColours[Index]->LinkedAncestorHasChanged(); Index++; } // And redraw all affected areas of the document ForceRedrawOfChangedColours(TheMsg->ScopeDoc, AffectedColours); } } } break; default: break; } } return OK; }

void ColourManager::SelViewContextHasChanged (  void   )  [static]

To redraw all windows which depend upon the Selected View's colour context. i.e. The selected view, and also the colour editor, gallery, & line. (and maybe other windows in the future, e.g. object properties, grad fill editors, etc). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/96 This redraws the selected view, then broadcasts a ColourChangingMsg message with a state of SELVIEWCONTEXTCHANGE to inform other interested parties. Notes: This should only be called when the selected view's RGB (screen) colour context is changed, which really shouldn't happen terribly often. Definition at line 616 of file colormgr.cpp. { View *SelView = DocView::GetSelected(); if (SelView != NULL && SelView->IsKindOf(CC_RUNTIME_CLASS(DocView))) { CBitmapCache* pBC = Camelot.GetBitmapCache(); if( NULL != pBC ) pBC->DeInitialise(); // Brute force cache management ((DocView *)SelView)->ForceRedraw(); } BROADCAST_TO_ALL(ColourChangingMsg(NULL, NULL, NULL, ColourChangingMsg::SELVIEWCONTEXTCHANGE)); }

BOOL ColourManager::UnHideColours (  ColourList *  ColList, IndexedColour **  ColourArray )  [static]

This un-'deletes' colours by creating an undoable operation to unhide them. This is used when creating a new colour to 'unhide' it (which has no immediate effect on the colour) - this creates an undo record that will hide the colour if the 'new' is undone. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/94 Parameters: ColList  - The colour list in which the colours reside. Must be non-NULL. [INPUTS] ColourArray - A NULL-terminated list of pointers to colours to be unhidden -  [OUTPUTS] Returns: TRUE if it thinks it succeeded Notes: The undo record generated uses a COPY of the array you passed in. It is your responsibility to delete the original array after calling this method. See also: ColourManager::HideColours; ColourManager::ColourListHasChanged Definition at line 2063 of file colormgr.cpp. { ERROR3IF(ColList == NULL || ColourArray == NULL, "ColourManager::UnHideColours cannot accept NULL parameters\n"); HideColoursInfo HCInfo; HCInfo.ParentList = ColList; HCInfo.Colours = ColourArray; HCInfo.ForceDelete = FALSE; HCInfo.HideThem = FALSE; OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor( OPTOKEN_SHOWCOLOURS ); if (OpDesc != NULL) OpDesc->Invoke((OpParam *) &HCInfo); return(TRUE); }

---

Member Data Documentation

ColourList* ColourManager::CurrentColourList [static, protected]

Definition at line 264 of file colormgr.h.

Document* ColourManager::ScopeDocument [static, protected]

Definition at line 265 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)

---