ColourList Class Reference

A colour list is held by each document to store the list of available IndexedColours for use by that document. (This colour list is displayed in the ColourBar/ColourGallery via the ColGalDisplayList which references colours held in the ColourList). More...

#include <collist.h>

Inheritance diagram for ColourList:

List of all members.

Public Member Functions
	ColourList ()
	ColourList constructor.
	~ColourList ()
	ColourList destructor.
void	Init (BaseDocument *ParentDocument)
	ColourList initialiser. MUST be called after constructing a ColourList in order to correctly initialise it. Note that if ParentDocument is not set to a useful value, some operations on colour lists (eg. the colour editor) will fail.
void	AddHead (ListItem *)
	Overrides the List::AddHead method to ensure that any added item has a name which is unique within this colour list.
void	AddTail (ListItem *)
	Overrides the List::AddTail method to ensure that any added item has a name which is unique within this colour list.
BOOL	AddItem (IndexedColour *NewColour)
	Adds an IndexedColour item to the tail of the ColourList The name of the colour is checked, and may be changed to ensure that it is a unique identifier within the scope of this colour list.
LISTPOS	InsertBefore (LISTPOS here, ListItem *item)
	Inserts a NAMED IndexedColour at a particular list position (See List base class for a further description of the actual insertion process).
ListItem *	InsertBefore (ListItem *here, ListItem *item)
	Inserts the 'newItem' ListItem before 'here' ListItem in the list.
LISTPOS	InsertAfter (LISTPOS here, ListItem *item)
	Inserts a ListItem in the list position after the one that is passed in. Notes: To find 'here', the list must be scanned, so this is much slower on average than the other flavour of InsertAfter.
ListItem *	InsertAfter (ListItem *here, ListItem *item)
	Inserts the 'newItem' ListItem after 'here' ListItem in the list.
virtual void	DeleteAll ()
	Deletes the list, calling the destructors of all ListItems.
UINT32	GetUndeletedCount (void)
	Count the number of non-'deleted' items in a ColourList.
IndexedColour *	FindUndeletedItem (INT32 Index)
	The same as the conventional List FindItem() function, except that it treats 'deleted' colours as if they are not in the list.
IndexedColour *	GetUndeletedHead (void)
	The same as the conventional List GetHead() function, except that it treats 'deleted' colours as if they are not in the list.
IndexedColour *	GetUndeletedNext (IndexedColour *ThisItem)
	The same as the conventional List GetNext() function, except that it treats 'deleted' colours as if they are not in the list.
BaseDocument *	GetParentDocument (void)
	To find the parent document of this colour list.
IndexedColour **	CompileInheritanceArray (IndexedColour *Parent)
	Compiles a NULL-terminated array of pointers to ALL colours which are linked to this, both directly and indirectly (i.e. an array listing the entire inheritance 'subtree' from 'Parent', *including* 'Parent', and including named, unnamed, and 'deleted' colours).
void	RemoveLinksToColour (IndexedColour *DeadColour)
	Scans the entire ColourList for any colours which reference the given IndexedColour. All these colours are converted into standalone representation of their former definition, so that all child-links of this colour are removed. It is then safe to delete the colour.
BOOL	IsColourInUseInDoc (IndexedColour *TheColour, BOOL IgnoreColourGallery=FALSE)
	Determine if a colour is used in the parent document. This is similar to IndexedColour::IsInUse(), but it also traverses the linking hierarchy to see if a colour is in use indirectly (e.g. A parent of a colour that is in use is needed for the document even if it is not used directly in document.
void	InvalidateInheritanceCache (void)
	Deallocates any memory used for the array of IndexedColours compiled by ColourList::CompileInheritanceArray. The next request for such an array will be regenerated from the ColourList, rather than from cache.
BOOL	NamedColourExists (PCTSTR pName)
	Determine if a colour name is already in use by any colours stored in this colour list.
BOOL	NamedColourExists (const StringBase *pName)
	Determine if a colour name is already in use by any colours stored in this colour list.
BOOL	GenerateUniqueColourName (const StringBase *pPrefix, String_64 *pResult)
	Scans the entire ColourList to determine if the suggested name is unique within this document. If it is not, the name is altered (currently by truncating to 50 characters and appending a decimal number) to provide a unique name, which is returned in the supplied string.
List *	GetUnnamedColours (void)
	To find the unnamed colours for this document.
Private Attributes
BaseDocument *	ParentDoc
IndexedColour *	ArrayParent
IndexedColour **	InheritanceArray
INT32	LastUnnamedColour
List	UnnamedColours

---

Detailed Description

A colour list is held by each document to store the list of available IndexedColours for use by that document. (This colour list is displayed in the ColourBar/ColourGallery via the ColGalDisplayList which references colours held in the ColourList).

Author:

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

The ColourList also provides a couple of special access methods for determining the number of visible/undeleted colours in the document (deleted colours are still held in this list, but are marked deleted for undo purposes - if scanning the ColourList, remember to check IndexedColours IsDeleted() flag) -- See the Undeleted list operators provided by this class to save you loads of effort.

The Colour list also includes another simple List of unnamed colours which are used for local colour attributes in a document. Unnamed colours are simply stored in this list, and are simpler than named colours...

See also:

IndexedColour; ColGalDisplayList; BaseDocument; List

Definition at line 141 of file collist.h.

---

Constructor & Destructor Documentation

ColourList::ColourList (   )

ColourList constructor. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 25/5/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 138 of file collist.cpp. { ParentDoc = NULL; // Document containing this list ArrayParent = NULL; // Current parent of the cached array InheritanceArray = NULL; // Cached array of all offspring of ArrayParent LastUnnamedColour = 2; // Memory to optimise unnamed-colour name generation }

ColourList::~ColourList (   )

ColourList destructor. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 17/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 162 of file collist.cpp. { InvalidateInheritanceCache(); // Release our memory claims UnnamedColours.DeleteAll(); // Delete any remaining unnamed colours // This will probably cause IxCol in use errors // as by now all colours should have been deleted // automatically when their usage reached zero. }

---

Member Function Documentation

void ColourList::AddHead (  ListItem *  ItemToAdd  )  [virtual]

Overrides the List::AddHead method to ensure that any added item has a name which is unique within this colour list. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/94 ERROR3's if the item is not a NAMED IndexedColour See also: ColourList::AddItem Reimplemented from List. Definition at line 236 of file collist.cpp. { ERROR3IF(!IS_A(ItemToAdd, IndexedColour), "You can only insert IndexedColours into ColourLists!"); IndexedColour *NewColour = (IndexedColour *) ItemToAdd; // Ensure the colour has a name which is unique within this colour list ERROR3IF(!NewColour->IsNamed(), "You can't Insert an unnamed colour before a named one!"); // It's a named colour, so make sure its name is unique String_64 NewName; if (GenerateUniqueColourName(NewColour->GetName(), &NewName)) NewColour->SetName(NewName); // And call the base class to add the item List::AddHead(ItemToAdd); }

BOOL ColourList::AddItem (  IndexedColour *  NewColour  )

Adds an IndexedColour item to the tail of the ColourList The name of the colour is checked, and may be changed to ensure that it is a unique identifier within the scope of this colour list. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 25/5/94 Returns: TRUE This can also be used to add unnamed colours - in this case, they are just added to the list of unnamed colours held by this object. See also: ColourList::GenerateUniqueColourName Definition at line 311 of file collist.cpp. { // Ensure the colour has a name which is unique within this colour list if (!NewColour->IsNamed()) { UnnamedColours.AddTail(NewColour); return(TRUE); } // It's a named colour, then... String_64 NewName; if (GenerateUniqueColourName(NewColour->GetName(), &NewName)) NewColour->SetName(NewName); // And add it to the tail of the list - using the base class function, not our overrides! List::AddTail(NewColour); return(TRUE); }

void ColourList::AddTail (  ListItem *  ItemToAdd  )  [virtual]

Overrides the List::AddTail method to ensure that any added item has a name which is unique within this colour list. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/94 ERROR3's if the item is not a NAMED IndexedColour See also: ColourList::AddItem Reimplemented from List. Definition at line 272 of file collist.cpp. { ERROR3IF(!IS_A(ItemToAdd, IndexedColour), "You can only insert IndexedColours into ColourLists!"); IndexedColour *NewColour = (IndexedColour *) ItemToAdd; // Ensure the colour has a name which is unique within this colour list ERROR3IF(!NewColour->IsNamed(), "You can't Insert an unnamed colour before a named one!"); // It's a named colour, so make sure its name is unique String_64 NewName; if (GenerateUniqueColourName(NewColour->GetName(), &NewName)) NewColour->SetName(NewName); // And call the base class to add the item List::AddTail(ItemToAdd); }

IndexedColour ** ColourList::CompileInheritanceArray (  IndexedColour *  Parent  )

Compiles a NULL-terminated array of pointers to ALL colours which are linked to this, both directly and indirectly (i.e. an array listing the entire inheritance 'subtree' from 'Parent', *including* 'Parent', and including named, unnamed, and 'deleted' colours). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 17/11/94 Parameters: Parent  - The colour for which you want an inheritance array [INPUTS] Returns: If NO error occurred, this returns a pointer to a NULL terminated array of IndexedColours, with Array[0] == Parent. If an error did occur, the error is reported, and NULL is returned This array is cached so that the cost of generating it several times in a row (as may be necessary for different clients of the ColourChangingMsg) is minimised. Notes: The array is NULL terminated The array INCLUDES Parent as its first member (Array[0]) The array is owned (allocated and deallocated) by the ColourList. It MUST be treated as a read-only shared array. The array includes ALL affected indexed colours. Use IsDeleted() and IsNamed() to sort out named/unnamed colours, and deleted (hidden for undo) colours. This is expected to be called mainly as a result of COLOURUPDATED ColourChangingMsg broadcasts. The cache is flushed automatically by the colour manager just prior to these broadcasts. If you want to use this function outside these message broadcasts, then you must invalidate the cache at an appropriate time. See also: ColourList::InvalidateInheritanceCache; IndexedColour::IsADescendantOf; ColourManager::ColourHasChanged Definition at line 652 of file collist.cpp. { if (Parent != ArrayParent) { InvalidateInheritanceCache(); // Throw away any existing array // Generate the array INT32 ColourArraySize = 32; InheritanceArray = (IndexedColour**) CCMalloc(ColourArraySize * sizeof(IndexedColour *)); if (InheritanceArray == NULL) { InformError(); // Out of memory - inform the user return(NULL); } INT32 ListEnd = 1; // Initialise array to just the Parent InheritanceArray[0] = Parent; InheritanceArray[1] = NULL; // Do all the Named colours IndexedColour *Ptr = (IndexedColour *) GetHead(); while (Ptr != NULL) { if (Ptr != Parent && Ptr->IsADescendantOf(Parent)) { // Is a descendant: add this item to the end of the list if (ListEnd >= ColourArraySize - 1) { // We've filled the array - must increase the size ColourArraySize += 32; IndexedColour **TempArray = (IndexedColour **) CCRealloc(InheritanceArray, ColourArraySize * sizeof(IndexedColour *)); if (TempArray == NULL) { InvalidateInheritanceCache(); // Free our existing memory claim InformError(); return(NULL); } InheritanceArray = TempArray; // It worked- set our ptr to the new block } InheritanceArray[ListEnd++] = Ptr; // Add the item and a new NULL terminator InheritanceArray[ListEnd] = 0; // to the end of the list } Ptr = (IndexedColour *) GetNext(Ptr); } // And likewise with all unnamed colours IndexedColour *Next; Ptr = (IndexedColour *) UnnamedColours.GetHead(); while (Ptr != NULL) { // Allow for deleting this colour from underneath ourselves Next = (IndexedColour *) UnnamedColours.GetNext(Ptr); if (Ptr->IsInUse()) { if (Ptr->IsADescendantOf(Parent)) { // Is a descendant: add this item to the end of the list if (ListEnd >= ColourArraySize - 1) { // We've filled the array - must increase the size ColourArraySize += 32; IndexedColour **TempArray = (IndexedColour **) CCRealloc(InheritanceArray, ColourArraySize * sizeof(IndexedColour *)); if (TempArray == NULL) { InvalidateInheritanceCache(); // Free our existing memory claim InformError(); return(NULL); } InheritanceArray = TempArray; // It worked- set our ptr to the new block } InheritanceArray[ListEnd++] = Ptr; // Add the item and a new NULL terminator InheritanceArray[ListEnd] = 0; // to the end of the list } } else { // We've found an unnamed IndexedColour which is not in use, so we can vape it TRACEUSER( "Jason", _T("CIA: Deleting unnamed colour which is not in use [%p]\n"), Ptr ); // UnnamedColours.RemoveItem(Ptr); // delete Ptr; } Ptr = Next; } ArrayParent = Parent; } TRACEUSER( "Jason", _T("\n")); return(InheritanceArray); }

void ColourList::DeleteAll (   )  [virtual]

Deletes the list, calling the destructors of all ListItems. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 1/6/96 Notes: Colours are deleted carefully to be tidy with child links (As we're deleting them all this shouldn't matter, but when children of a deleted colour are deleted, they poke its ChildUsage, and Smart Heap chokes itself in dismay. The old smartheap didn't care) We thus vape all colour linking before deleting the colours. We don't need to be particularly gentle about this because we are deleting them all anyway. See also: List::DeleteAll Reimplemented from List. Definition at line 458 of file collist.cpp. { // Vape all colour linkages in the named colour list IndexedColour *Ptr = (IndexedColour *) GetHead(); while (Ptr != NULL) { Ptr->SetLinkedParent(NULL, COLOURTYPE_NORMAL); Ptr = (IndexedColour *) GetNext(Ptr); } // And vape all colour linkages in the UNnamed colour list Ptr = (IndexedColour *) UnnamedColours.GetHead(); while (Ptr != NULL) { Ptr->SetLinkedParent(NULL, COLOURTYPE_NORMAL); Ptr = (IndexedColour *) UnnamedColours.GetNext(Ptr); } // Delete all the unnamed colours now too, just to be tidy UnnamedColours.DeleteAll(); // Finally, call the base class to do the actual deletions List::DeleteAll(); }

IndexedColour * ColourList::FindUndeletedItem (  INT32  Index  )

The same as the conventional List FindItem() function, except that it treats 'deleted' colours as if they are not in the list. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/6/94 Parameters: ColourIndex  - essentially a LISTPOS of the item in the Palette list [INPUTS] Returns: NULL if the index is past the end of the list else a pointer to the referenced IndexedColour ListItem Definition at line 534 of file collist.cpp. { IndexedColour *Ptr = (IndexedColour *) GetHead(); while (Ptr != NULL) { if (!Ptr->IsDeleted() && --Index < 0) return(Ptr); Ptr = (IndexedColour *) GetNext(Ptr); } return(NULL); }

BOOL ColourList::GenerateUniqueColourName (  const StringBase *  pPrefix, String_64 *  pResult )

Scans the entire ColourList to determine if the suggested name is unique within this document. If it is not, the name is altered (currently by truncating to 50 characters and appending a decimal number) to provide a unique name, which is returned in the supplied string. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (From code by Tim) Date: 16/12/94 (8/8/94) Parameters: pPrefix  - Points to the suggested name for this colour. This may be NULL, [INPUTS] in which case a name based on the string "Unnamed" will be generated pResult  - is filled in with a unique name [OUTPUTS] NOTE that this is a String_64, the maximum length for a colour name. If the input pPrefix string is longer than will fit, it will be truncated. If truncation was necessary, this will have no effect on the return value. (IndexedColour::SetName will truncate strings longer than 64 chars as well) Returns: TRUE if the pResult contains a different string from that supplied in pPrefix. (pResult will always contain a valid result, but checking this flag may save you the bother of copying the string over) This method can be called whenever you wish to generate a unique name for a colour. However, note that it is called automatically for every colour which is added to the colour list with the AddItem() method Notes: Name matching is done using StringBase::IsIdentical, so see that method to determine the rules by which strings are matched If the colour is unnamed (pPrefix == NULL, *pPrefix is a NULL string, or the name is "Unnamed" (_R(IDS_UNNAMEDCOLOUR)), then the code is optimised to provide a new name for it extra fast. See also: ColourList::AddItem; IndexedColour::SetName; StringBase::IsIdentical Definition at line 1005 of file collist.cpp. { if (pResult == NULL) { ERROR3("ColourList::GenerateUniqueColourName: pResult is NULL!"); return(FALSE); } if (pPrefix != NULL && !NamedColourExists(pPrefix)) { // Either the List is empty, or this name is unique, so return it (ensuring < 64 chars) pPrefix->Left(pResult, 63); return(FALSE); } // Copy the prefix into this string. String_64 NewName; BOOL Unnamed = FALSE; // Remember if it is 'unnamed' if (pPrefix != NULL) pPrefix->Left(&NewName, 50); // Copy into NewName, truncating String_64 NoName(_R(IDS_UNNAMEDCOLOUR)); if ((pPrefix == NULL) || (NewName.Length() == 0)) // Has no name, so call it "Unnamed" { Unnamed = TRUE; NewName = NoName; } else if (NewName.IsIdentical(NoName)) // Is called 'Unnamed', so remember that { Unnamed = TRUE; } INT32 PrefixLen = NewName.Length(); if (PrefixLen > 50) { // Limit prefix length to 50 chars - this means we can add numbers up to // 10-odd digits long in order to make it unique - should be enough! PrefixLen = 50; } TCHAR *pPrefixEnd = (TCHAR *) NewName; pPrefixEnd += PrefixLen; // Is this name ok? if (!NamedColourExists(NewName)) { (*pResult) = NewName; // Yes - return it. return(TRUE); } // Start adding numbers to make it unique INT32 i = (Unnamed) ? LastUnnamedColour : 2; while (TRUE) { // If this doesn't terminate [Tim] will eat [his] Archimedes! camSnprintf( pPrefixEnd, 64, _T(" %ld"), i++ ); // Is this name ok? if (!NamedColourExists(NewName)) { (*pResult) = NewName; // Yes - return it if (Unnamed) // Update unnamed colour generation number LastUnnamedColour = i; return(TRUE); } } *pResult = NewName; // Ensure stable return, though this should never happen return(TRUE); }

BaseDocument * ColourList::GetParentDocument (  void   )  [inline]

To find the parent document of this colour list. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/94 Returns: The document in which this colour list resides Definition at line 235 of file collist.h. { ERROR3IF(ParentDoc == NULL, "Uninitialised ColourList detected!"); return(ParentDoc); }

UINT32 ColourList::GetUndeletedCount (  void   )

Count the number of non-'deleted' items in a ColourList. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The number of IndexedColours in this ColourList which are not 'deleted' so as to be hidden from view by the undo system. Definition at line 500 of file collist.cpp. { ListItem *Ptr = GetHead(); UINT32 Count = 0; while (Ptr != NULL) { if ( !((IndexedColour *)Ptr)->IsDeleted() ) Count++; Ptr = GetNext(Ptr); } return(Count); }

IndexedColour * ColourList::GetUndeletedHead (  void   )

The same as the conventional List GetHead() function, except that it treats 'deleted' colours as if they are not in the list. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/3/95 Returns: NULL if the list contains no 'live' (non-deleted) colours else a pointer to the first IndexedColour ListItem in the list Definition at line 566 of file collist.cpp. { IndexedColour *Ptr = (IndexedColour *) GetHead(); while (Ptr != NULL && Ptr->IsDeleted()) Ptr = (IndexedColour *) GetNext(Ptr); return(Ptr); }

IndexedColour * ColourList::GetUndeletedNext (  IndexedColour *  ThisItem  )

The same as the conventional List GetNext() function, except that it treats 'deleted' colours as if they are not in the list. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/3/95 Returns: NULL if the list contains no more 'live' (non-deleted) colours else a pointer to the next 'live' IndexedColour in the list Definition at line 593 of file collist.cpp. { ERROR2IF(ThisItem == NULL, NULL, "ColourList::GetUndeletedNext - NULL parameter is illegal"); IndexedColour *Ptr = (IndexedColour *) GetNext(ThisItem); while (Ptr != NULL && Ptr->IsDeleted()) Ptr = (IndexedColour *) GetNext(Ptr); return(Ptr); }

List * ColourList::GetUnnamedColours (  void   )  [inline]

To find the unnamed colours for this document. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/95 Returns: The storage-list containing this document's unnamed colours Definition at line 254 of file collist.h. { return(&UnnamedColours); }

void ColourList::Init (  BaseDocument *  ParentDocument  )

ColourList initialiser. MUST be called after constructing a ColourList in order to correctly initialise it. Note that if ParentDocument is not set to a useful value, some operations on colour lists (eg. the colour editor) will fail. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/94 Parameters: ParentDocument  - the parent document of this colour list [INPUTS] Definition at line 187 of file collist.cpp. { ERROR3IF(ParentDocument == NULL, "NULL ParentDoc in ColourList::Init()"); ParentDoc = ParentDocument; }

ListItem * ColourList::InsertAfter (  ListItem *  here, ListItem *  item )  [virtual]

Inserts the 'newItem' ListItem after 'here' ListItem in the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 15/4/93 Parameters: ListItem  to be inserted [INPUTS] ListItem after insertion None  [OUTPUTS] Returns: ListItem inserted NULL if list empty or ListItem not found or parameters are NULL Errors: In the debug build, this checks that the item you wish to insert after is actually in the list, and that the item you are inserting is not already in the list - an ENSURE failure results if not. Reimplemented from List. Definition at line 416 of file collist.cpp. { ERROR3IF(!IS_A(item, IndexedColour), "You can only insert IndexedColours into ColourLists!"); IndexedColour *NewColour = (IndexedColour *) item; // Ensure the colour has a name which is unique within this colour list ERROR3IF(!NewColour->IsNamed(), "You can't Insert an unnamed colour before a named one!"); // It's a named colour, so make sure its name is unique String_64 NewName; if (GenerateUniqueColourName(NewColour->GetName(), &NewName)) NewColour->SetName(NewName); // And add it to the tail of the list - using the base class function, not our overrides! return(List::InsertAfter(here, item)); }

LISTPOS ColourList::InsertAfter (  LISTPOS  here, ListItem *  item )  [virtual]

Inserts a ListItem in the list position after the one that is passed in. Notes: To find 'here', the list must be scanned, so this is much slower on average than the other flavour of InsertAfter. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: ListItem  to be inserted [INPUTS] List position None  [OUTPUTS] Returns: List position new item is inserted at. INVALID_LISTPOS when the list position goes beyond the list size INVALID_NEWITEM when new list item is NULL Errors: This ALWAYS checks that the item you wish to insert after is actually in the list, and that the item you are inserting is not already in the list - an ENSURE failure results if not. Reimplemented from List. Definition at line 398 of file collist.cpp. { ERROR3IF(!IS_A(item, IndexedColour), "You can only insert IndexedColours into ColourLists!"); IndexedColour *NewColour = (IndexedColour *) item; // Ensure the colour has a name which is unique within this colour list ERROR3IF(!NewColour->IsNamed(), "You can't Insert an unnamed colour before a named one!"); // It's a named colour, so make sure its name is unique String_64 NewName; if (GenerateUniqueColourName(NewColour->GetName(), &NewName)) NewColour->SetName(NewName); // And add it to the tail of the list - using the base class function, not our overrides! return(List::InsertAfter(here, item)); }

ListItem * ColourList::InsertBefore (  ListItem *  here, ListItem *  item )  [virtual]

Inserts the 'newItem' ListItem before 'here' ListItem in the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 15/4/93 Parameters: ListItem  to be inserted [INPUTS] ListItem before insertion None  [OUTPUTS] Returns: ListItem inserted INVALID_NEWITEM when the new item is NULL NULL if list empty or ListItem not found or parameters are NULL Errors: In the debug build, this checks that the item you wish to insert before is actually in the list, and that the item you are inserting is not already in the list - an ENSURE failure results if not. Reimplemented from List. Definition at line 380 of file collist.cpp. { ERROR3IF(!IS_A(item, IndexedColour), "You can only insert IndexedColours into ColourLists!"); IndexedColour *NewColour = (IndexedColour *) item; // Ensure the colour has a name which is unique within this colour list ERROR3IF(!NewColour->IsNamed(), "You can't Insert an unnamed colour before a named one!"); // It's a named colour, so make sure its name is unique String_64 NewName; if (GenerateUniqueColourName(NewColour->GetName(), &NewName)) NewColour->SetName(NewName); // And add it to the tail of the list - using the base class function, not our overrides! return(List::InsertBefore(here, item)); }

LISTPOS ColourList::InsertBefore (  LISTPOS  here, ListItem *  item )  [virtual]

Inserts a NAMED IndexedColour at a particular list position (See List base class for a further description of the actual insertion process). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 2/8/95 Parameters: here  - the list item to insert before. NULL is not allowed (List is unhelpful) [INPUTS] item - the item to insert before/after the 'here' item Returns: The position/item which was inserted These methods are a veneer onto the normal list calls, which ensure that all inserted colours are given unique names within this list. Note: IMPORTANT: NOTE that at present, these are NOT VIRTUAL, so you MUST call them using a ColourList pointer rather than a generic List pointer! See also: List; List::InsertBefore; ColourList::GenerateUniqueColourName Reimplemented from List. Definition at line 362 of file collist.cpp. { ERROR3IF(!IS_A(item, IndexedColour), "You can only insert IndexedColours into ColourLists!"); IndexedColour *NewColour = (IndexedColour *) item; // Ensure the colour has a name which is unique within this colour list ERROR3IF(!NewColour->IsNamed(), "You can't Insert an unnamed colour before a named one!"); // It's a named colour, so make sure its name is unique String_64 NewName; if (GenerateUniqueColourName(NewColour->GetName(), &NewName)) NewColour->SetName(NewName); // And add it to the tail of the list - using the base class function, not our overrides! return(List::InsertBefore(here, item)); }

void ColourList::InvalidateInheritanceCache (  void   )

Deallocates any memory used for the array of IndexedColours compiled by ColourList::CompileInheritanceArray. The next request for such an array will be regenerated from the ColourList, rather than from cache. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 17/11/94 This is automatically called by the ColourManager immediately prior to a ColourChangingMsg COLOURUPDATED message broadcast. See also: ColourList::CompileInheritanceArray Definition at line 211 of file collist.cpp. { if (InheritanceArray != NULL) CCFree(InheritanceArray); InheritanceArray = NULL; ArrayParent = NULL; }

BOOL ColourList::IsColourInUseInDoc (  IndexedColour *  TheColour, BOOL  IgnoreColourGallery = FALSE )

Determine if a colour is used in the parent document. This is similar to IndexedColour::IsInUse(), but it also traverses the linking hierarchy to see if a colour is in use indirectly (e.g. A parent of a colour that is in use is needed for the document even if it is not used directly in document. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/95 Parameters: TheColour  - Points to the colour to check [INPUTS] IgnoreColourGallery - TRUE to ignore usage in the colour gallery. DO NOT USE this parameter. It is a special-case for the colour gallery to use to ignore the usage that that gallery has of the colour. Returns: TRUE if the colour is in use in the document See also: IndexedColour::IsInUse Definition at line 859 of file collist.cpp. { ERROR3IF(TheColour == NULL, "Illegal NULL param"); // First, is it directly in-use? if (TheColour->IsInUse(IgnoreColourGallery)) return(TRUE); // Is it a parent of other colours? If not, then it is not in use if (!TheColour->IsNamed() || !TheColour->HasLinkedChildren()) return(FALSE); // It has descendants, so scan the inheritance tree to determine if any of them are in use // Scan through the named colours (NOTE: We also scan 'deleted' colours, as a parent colour // may be indirectly in use in the undo record) IndexedColour *Ptr = (IndexedColour *) GetHead(); while (Ptr != NULL) // For all colours in the list... { if (Ptr != TheColour && Ptr->IsADescendantOf(TheColour)) // If this one is a descendant... { if (Ptr->IsInUse(IgnoreColourGallery)) // and it's in use, then we are return(TRUE); // in use, and can return now. } Ptr = (IndexedColour *) GetNext(Ptr); } // And scan through the unnamed colours as well Ptr = (IndexedColour *) UnnamedColours.GetHead(); while (Ptr != NULL) // For all colours in the list... { if (Ptr != TheColour && Ptr->IsADescendantOf(TheColour)) // If this one is a descendant... { if (Ptr->IsInUse()) // and it's in use, then we are return(TRUE); // in use, and can return now. } Ptr = (IndexedColour *) UnnamedColours.GetNext(Ptr); } // OK, we're obviously not in use then return(FALSE); }

BOOL ColourList::NamedColourExists (  const StringBase *  pName  )

Determine if a colour name is already in use by any colours stored in this colour list. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pName  - the name to look for. [INPUTS] Returns: TRUE if the name is already in use; FALSE otherwise. See also: ColourList::GenerateUniqueColourName Definition at line 958 of file collist.cpp. { return(NamedColourExists((const TCHAR *)(*pName))); }

BOOL ColourList::NamedColourExists (  PCTSTR  pName  )

Determine if a colour name is already in use by any colours stored in this colour list. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> (Jason copied this code here from colcomp.cpp) Date: 08/08/94 (19/12/94) Parameters: pName  - the name to look for. [INPUTS] Returns: TRUE if the name is already in use; FALSE otherwise. See also: ColourList::GenerateUniqueColourName Definition at line 920 of file collist.cpp. { IndexedColour *pItem = (IndexedColour *) GetHead(); while (pItem != NULL) { if (!pItem->IsDeleted() && pItem->IsNamed() && (pItem->GetName()->IsIdentical(pName)) ) { // The name is the same - it's a match return(TRUE); } // Try the next colour pItem = (IndexedColour *) GetNext(pItem); } // No match for this name return(FALSE); }

void ColourList::RemoveLinksToColour (  IndexedColour *  DeadColour  )

Scans the entire ColourList for any colours which reference the given IndexedColour. All these colours are converted into standalone representation of their former definition, so that all child-links of this colour are removed. It is then safe to delete the colour. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/94 Parameters: DeadColour  - The colour for which all ParentColour references are to be [INPUTS] removed. This is done automatically for colours deleted by the HideColours method of the colour manager; however, deletion only occurs for real when the undo record containing the deleted colours is deleted. NOTE that this does NOT remove the colour from the ColourList It also does NOT delete the colour. See also: ColourManager::HideColours Definition at line 784 of file collist.cpp. { // Search through the named colours IndexedColour *Ptr = (IndexedColour *) GetHead(); while (Ptr != NULL) // For all colours in the list... { if (Ptr->FindLastLinkedParent() == DeadColour) // If they reference DeadColour... { IndexedColourType TheType = COLOURTYPE_NORMAL; if (Ptr->GetType() == COLOURTYPE_SPOT) TheType = COLOURTYPE_SPOT; Ptr->SetLinkedParent(NULL, TheType); // Convert to unlinked (normal/spot) colour } Ptr = (IndexedColour *) GetNext(Ptr); } // And drag through the unnamed colours as well Ptr = (IndexedColour *) UnnamedColours.GetHead(); IndexedColour *Next; while (Ptr != NULL) // For all colours in the list... { Next = (IndexedColour *) UnnamedColours.GetNext(Ptr); if (Ptr->FindLastLinkedParent() == DeadColour) // If they reference DeadColour... { IndexedColourType TheType = COLOURTYPE_NORMAL; if (Ptr->GetType() == COLOURTYPE_SPOT) TheType = COLOURTYPE_SPOT; Ptr->SetLinkedParent(NULL, TheType); // Convert to unlinked (normal/spot) colour } // This could be dangerous - what if the deleted colour is in the inheritance array? // if (!Ptr->IsInUse()) // { // // We've found an unnamed colour which is not in use - we can vape it //TRACEUSER( "Jason", _T("RLTC: Deleting unnamed colour which is not in use [%x]\n"), (INT32)Ptr); // UnnamedColours.RemoveItem(Ptr); // delete Ptr; // } Ptr = Next; } }

---

Member Data Documentation

IndexedColour* ColourList::ArrayParent [private]

Definition at line 200 of file collist.h.

IndexedColour** ColourList::InheritanceArray [private]

Definition at line 201 of file collist.h.

INT32 ColourList::LastUnnamedColour [private]

Definition at line 213 of file collist.h.

BaseDocument* ColourList::ParentDoc [private]

Definition at line 181 of file collist.h.

List ColourList::UnnamedColours [private]

Definition at line 219 of file collist.h.

---

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

• Kernel/collist.h (r1785/r1282)
• Kernel/collist.cpp (r1785/r1282)

---