ImportedColours Class Reference

Encapsulate the process of importing a number of colours into a document. This object maintains a list of colours to be imported, and implicitly handles all the merging/duplication problems that may occur. More...

#include <impcol.h>

Inheritance diagram for ImportedColours:

List of all members.

Public Member Functions
	ImportedColours (ColourListComponent *, BOOL)
	Create a table of imported colours (initially empty).
	~ImportedColours ()
	Destroy a table of imported colours. This should only be done after calling AddColoursToDocument() or DestroyColours() - an ERROR3 will occur if this is not done.
BOOL	Init ()
	Initialise the table of imported colours.
BOOL	AddColour (const String_64 *pColName, ColourCMYK *pCMYK, NewColourInfo *pLinkInfo=NULL)
	Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. If pColourInfo specifies a linked or tinted colour, then this colour is also linked to the colour currently specified by the colour link context (see SaveContext and RestoreContextTo).
BOOL	AddColour (const String_64 *pColName, ColourRGBT *pRGB, NewColourInfo *pLinkInfo=NULL)
	Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. If pColourInfo specifies a linked or tinted colour, then this colour is also linked to the colour currently specified by the colour link context (see SaveContext and RestoreContextTo).
BOOL	AddColour (const String_64 *pColName, ColourHSVT *pHSV, NewColourInfo *pLinkInfo=NULL)
	Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. If pColourInfo specifies a linked or tinted colour, then this colour is also linked to the colour currently specified by the colour link context (see SaveContext and RestoreContextTo).
BOOL	AddColour (const String_64 *pColName, ColourGreyT *pGrey, NewColourInfo *pLinkInfo=NULL)
	Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. If pColourInfo specifies a linked or tinted colour, then this colour is also linked to the colour currently specified by the colour link context (see SaveContext and RestoreContextTo).
BOOL	AddColour (const String_64 *pColName, ImportedNewColour *pCol, NewColourInfo *pLinkInfo=NULL)
	Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. If pColourInfo specifies a linked or tinted colour, then this colour is also linked to the colour currently specified by the colour link context (see SaveContext and RestoreContextTo). This version adds a colour of from any colour model (supported by other AddColour functions).
BOOL	AddTintOrShade (const String_64 *pColName, NewColourInfo *pColourInfo)
	Add the specified tint or shade to the colour table. Assumes the vital tint information has already been filled in.
BOOL	AddTint (const String_64 *pColName, UINT32 Tint)
	Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. This colour is a tint of the colour currently specified by the colour link context (see SaveContext and RestoreContextTo).
BOOL	AddShade (const String_64 *pColName, INT32 ShadeX, INT32 ShadeY)
	Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. This colour is a shade of the colour currently specified by the colour link context (see SaveContext and RestoreContextTo).
void	SetLinkedColourInherits (UINT32 ComponentID)
void	SaveContext ()
	None.
void	RestoreContextTo (UINT32 Level)
	None.
IndexedColour *	GetColour (PCTSTR ColName)
	Find a named colour in the import list. This look up is obviously done purely on the colour name, and as such is a slightly risky thing to do, especially when importing such flaky file formats as EPS - use the version of GetColour that takes a PColourCMYK value to provide more reliable colour lookup.
IndexedColour *	GetColour (PCTSTR ColName, const PColourCMYK *Defn)
	Searches for a named colour. If the colour name has had duplicate definitions during this import, then the colour definition is compared against the values pointed to by Defn (converting to CMYK first if needed).
BOOL	AddColoursToDocument ()
	None.
BOOL	SortColoursByEntryNumber ()
	Sorts the list of imported colours by the EntryNumber that is saved in the colour definition in the native file format so that we load the list back in the same order that it was in when the document was saved. This because when we save the colours we cannot save the list in the order they are defined in the colour list as we must save parent colours before children so that the children can reference the parent. Borrowed code from SuperGallery::ApplySortNow as we need a much simpler version.
BOOL	DestroyColours ()
	None.
IndexedColour *	GetColour (INT32 ReqRecordNumber)
	Searches for a previously imported colour definition. Used by the native/web filter to convert a colour reference in a record to an IndexedColour. This must have already been imported in the file as the rule is that reference to colours can only be made if the colour definition has already been output.
Protected Types
typedef CMap< String_64, const String_64 &, NewColour *, NewColour * >	CMapStringToNewColour
Protected Member Functions
BOOL	AddColour (const String_64 *pColName, IndexedColour **pCol, NewColourInfo *pLinkInfo=NULL)
	Generic routine for adding a colour to the table of imported colours. All the other AddColour() routines map onto this.
Static Protected Member Functions
static INT32 __cdecl	SortComparator (const void *Item1, const void *Item2)
	'qsort' comparator function, used when quicksorting the loaded colour list
Protected Attributes
NewColourList	Colours
CMapStringToNewColour *	pColourMap
ColourListComponent *	pColourComponent
ColourImportContext	Context
BOOL	StrictColourMatching

---

Detailed Description

Encapsulate the process of importing a number of colours into a document. This object maintains a list of colours to be imported, and implicitly handles all the merging/duplication problems that may occur.

Author:

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

Date:

30/11/94

See also:

NewColour; NewColourList

Definition at line 291 of file impcol.h.

---

Member Typedef Documentation

typedef CMap< String_64, const String_64 &, NewColour *, NewColour * > ImportedColours::CMapStringToNewColour [protected]

Definition at line 353 of file impcol.h.

---

Constructor & Destructor Documentation

ImportedColours::ImportedColours (  ColourListComponent *  TheColourComponent, BOOL  Strict )

Create a table of imported colours (initially empty). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: TheColourComponent  - the relevant colour component for this import. [INPUTS] Strict - TRUE => when servicing calls to GetColour(), check the CMYK colour definition for a match in case a colour is being used which wasn't declared in the colour table (this is what we do for ArtWorks EPS). FALSE => don't bother checking CMYK - just use the name to look up the colour - we use this for Camelot EPS because we know we don't save out brain damaged EPS like ArtWorks does. See also: ImportedColours::Init Definition at line 517 of file impcol.cpp. { // Remember this document component pColourComponent = TheColourComponent; // Do we check CMYK values when matching colours? StrictColourMatching = Strict; // No hash table yet pColourMap = NULL; }

ImportedColours::~ImportedColours (   )

Destroy a table of imported colours. This should only be done after calling AddColoursToDocument() or DestroyColours() - an ERROR3 will occur if this is not done. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: Colours should be explicitly added to the document or deleted from this table before this function is called => ERROR3 See also: ImportedColours::AddColoursToDocument; ImportedColours::DestroyColours Definition at line 547 of file impcol.cpp. { // MORE STUFF HERE... // Trash the hash table delete pColourMap; pColourMap = NULL; }

---

Member Function Documentation

BOOL ImportedColours::AddColour (  const String_64 *  pColName, IndexedColour **  pNewIndexedCol, NewColourInfo *  pColourInfo = NULL )  [protected]

Generic routine for adding a colour to the table of imported colours. All the other AddColour() routines map onto this. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Modified: Jason (8/9/95) - Now handles exact duplicates as well as duplicate names (This is needed for new shade-colour saving system which does nasty things in order to retain backward compatability with old loaders) Parameters: pColName  - the name of the colour [INPUTS] pNewCol - ptr to ptr to the new indexed colour to use (if NULL then just returns FALSE immediately) (see also Outputs) pColourInfo - if NULL, then it is a normal colour; if non-NULL then colour is special in some way, i.e. a tint or a linked colour or a spot colour. If  *pNewCol points to an IndexedColour which already has an *identical* [OUTPUTS] twin colour (i.e. exactly the same colour appears twice in the doc) then pNewCol will be modified to point at the first incarnation of the colour, and the IndexedColour you passed in will be deleted. DO NOT use the previous IndexedColour pointer - only use the pointer as passed back from this method. Returns: TRUE if the colour was added ok; FALSE otherwise Errors: Out of memory => ERROR1 pNewCol is NULL => returns FALSE (no error set) See also: ImportedColours Scope: Protected Definition at line 954 of file impcol.cpp. { // Do we have a valid colour? if (pNewIndexedCol == NULL || *pNewIndexedCol == NULL) // No! return FALSE; // First, set the colour name to the one supplied. If it is unnamed, then we want // to set its unique-ID string to the value from the file. At the end of the import, // we will use SetUnnamed to force it to re-generate a unique name so that it is // (a) merged properly during import, and (b) doesn't clash with another colour // already in the same document once it is added. //String_64 Name = *pColName; //(*pNewIndexedCol)->SetName(*pColName, (ColName[0] != '_')); TCHAR ch = (*pColName)[0]; (*pNewIndexedCol)->SetName(*pColName, (ch != '_')); if (pColourInfo != NULL) { // Link the colour if required if ((pColourInfo->Type == COLOURTYPE_LINKED) || (pColourInfo->Type == COLOURTYPE_TINT)) { IndexedColour *pParent = NULL; if (pColourInfo->WebNativeColour) { pParent = pColourInfo->pParentCol; } else { // Importing a non-native or web file colour and so use the context of the colour // to define its parent. // Get the current colour context pParent = Context.GetContext(); ERROR2IF(pParent == NULL, FALSE, "NULL parent when creating linked colour!"); } // Link to it - either as a linked colour or a tint if (pColourInfo->Type == COLOURTYPE_LINKED) { // Linked colour (*pNewIndexedCol)->SetLinkedParent(pParent, COLOURTYPE_LINKED); // Set inheritance flags... for (INT32 i = 0; i < 4; i++) (*pNewIndexedCol)->SetInheritsComponent(i + 1, pColourInfo->Inherits[i]); } else { // Tinted colour (*pNewIndexedCol)->SetLinkedParent(pParent, COLOURTYPE_TINT); // Set tint/shade value as appropriate. This makes the 'tint' colour a // tint or shade. (Shades are special cases of tints for historical reasons) if (pColourInfo->TintIsShade) (*pNewIndexedCol)->SetShadeValues(pColourInfo->TintValue, pColourInfo->ShadeValue); else (*pNewIndexedCol)->SetTintValue(pColourInfo->TintValue); } } else if (pColourInfo->Type == COLOURTYPE_SPOT) { // Mark this as a spot colour (in case the caller hasn't already) (*pNewIndexedCol)->SetLinkedParent(NULL, COLOURTYPE_SPOT); } } // Is there a colour the same as this in the destination document already? IndexedColour *pIdenticalCol; pColourComponent->FindIdenticalColour(*pNewIndexedCol, &pIdenticalCol); BOOL AlreadyExists = (pIdenticalCol != NULL); /* Phil, 01/03/2004 If we remove colours from the document before we have added our list of imported colours anything could come along and add colours back in the meantime. (e.g. GradFillAttribute::GradFillAttribute) So leave colours in the list and only move them later on... */ if (AlreadyExists) { // Graeme (5/4/00) - This code now changes the colour list so that an // existing colour is repositioned where the original definition was. // Delete the new one because it duplicates one already in the document. delete *pNewIndexedCol; // Make pNewIndexedCol point to the existing colour *pNewIndexedCol = pIdenticalCol; // Set AlreadyExists to be FALSE so that the colour is included. AlreadyExists = FALSE; } NewColour *pNewColour = NULL; // If we are in web/native filter mode then we MUST always add a new colour item as this // is where we save the record number which will be reused later. So we must stop the // name look up and adding duplicates as this adds the new colour to the a list inside // the duplicated name that is in the ColourMap. BOOL WebNative = (pColourInfo && pColourInfo->WebNativeColour); // First, check to see if we already have a definition of this colour *NAME* if( !WebNative && pColourMap->Lookup( *pColName, pNewColour ) ) { // Yes - mark the current definition as a duplicate and add this new one to it. if (!pNewColour->AddDuplicateColour(pNewIndexedCol, AlreadyExists)) // Error encountered. return FALSE; } else { // No - but is it already in the destination document? // // (i.e. is there a colour in the document with the same // name, colour model and definition?) // // If yes - add a new colour that references the already existing colour, and // mark it as being such; // // If no - it's a new colour, so add it to the list. pNewColour = Colours.AddColour(*pNewIndexedCol, AlreadyExists); if (pNewColour == NULL) // out of memory return FALSE; // Either way, add it to the colour name map try { (*pColourMap)[ *pColName ] = pNewColour; } catch( CMemoryException ) { // Could not do it - report error to caller. ERROR(_R(IDS_OUT_OF_MEMORY), FALSE); } // If we are in web/native filter mode then save the record number that we // have been passed in in the NewColourInfo // At the same time save out the entry number for where we want this colour in the list // of colours if (pColourInfo && pColourInfo->WebNativeColour) { pNewColour->RecordNumber = pColourInfo->RecordNumber; pNewColour->EntryNumber = pColourInfo->EntryNumber; } } // We added the colour ok so set it as the current context colour // Note that AddDuplicateColour may have changed our pointer to point at a different // (identical) colour, but it will always point at the correct colour for us to use here. Context.SetContext(*pNewIndexedCol); // All ok return TRUE; }

BOOL ImportedColours::AddColour (  const String_64 *  pColName, ImportedNewColour *  pCol, NewColourInfo *  pColourInfo = NULL )

Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. If pColourInfo specifies a linked or tinted colour, then this colour is also linked to the colour currently specified by the colour link context (see SaveContext and RestoreContextTo). This version adds a colour of from any colour model (supported by other AddColour functions). Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 18 03 95 Parameters: pColName  - the name of the colour to add [INPUTS] pGrey - the definition of the colour to add pColourInfo - if NULL, then it is a normal colour; if non-NULL then colour is special in some way, i.e. a tint or a linked colour or a spot colour. Returns: TRUE if the colour could be added; FALSE if not Errors: - See also: ImportedColours; ImportedColours::GetColour; ImportedColours::SaveContext; ImportedColours::RestoreContextTo Definition at line 770 of file impcol.cpp. { switch(pCol->Model) { case COLOURMODEL_RGBT: return AddColour(pColName, (ColourRGBT *)&pCol->Colour, pColourInfo); break; case COLOURMODEL_CMYK: return AddColour(pColName, (ColourCMYK *)&pCol->Colour, pColourInfo); break; case COLOURMODEL_HSVT: return AddColour(pColName, (ColourHSVT *)&pCol->Colour, pColourInfo); break; case COLOURMODEL_GREYT: return AddColour(pColName, (ColourGreyT *)&pCol->Colour, pColourInfo); break; default: break; } ERROR3("Colour model presented to ImportedColours::AddColour is not a recognised model"); return FALSE; }

BOOL ImportedColours::AddColour (  const String_64 *  pColName, ColourGreyT *  pGrey, NewColourInfo *  pColourInfo = NULL )

Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. If pColourInfo specifies a linked or tinted colour, then this colour is also linked to the colour currently specified by the colour link context (see SaveContext and RestoreContextTo). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: pColName  - the name of the colour to add [INPUTS] pGrey - the definition of the colour to add pColourInfo - if NULL, then it is a normal colour; if non-NULL then colour is special in some way, i.e. a tint or a linked colour or a spot colour. Returns: TRUE if the colour could be added; FALSE if not Errors: - See also: ImportedColours; ImportedColours::GetColour; ImportedColours::SaveContext; ImportedColours::RestoreContextTo Definition at line 733 of file impcol.cpp. { IndexedColour *pNewCol = new INDEXEDCOLOUR_GREYT(pGrey); return AddColour(pColName, &pNewCol, pColourInfo); }

BOOL ImportedColours::AddColour (  const String_64 *  pColName, ColourHSVT *  pHSV, NewColourInfo *  pColourInfo = NULL )

Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. If pColourInfo specifies a linked or tinted colour, then this colour is also linked to the colour currently specified by the colour link context (see SaveContext and RestoreContextTo). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: pColName  - the name of the colour to add [INPUTS] pHSV - the definition of the colour to add pColourInfo - if NULL, then it is a normal colour; if non-NULL then colour is special in some way, i.e. a tint or a linked colour or a spot colour. Returns: TRUE if the colour could be added; FALSE if not Errors: - See also: ImportedColours; ImportedColours::GetColour; ImportedColours::SaveContext; ImportedColours::RestoreContextTo Definition at line 698 of file impcol.cpp. { IndexedColour *pNewCol = new INDEXEDCOLOUR_HSVT(pHSV); return AddColour(pColName, &pNewCol, pColourInfo); }

BOOL ImportedColours::AddColour (  const String_64 *  pColName, ColourRGBT *  pRGB, NewColourInfo *  pColourInfo = NULL )

Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. If pColourInfo specifies a linked or tinted colour, then this colour is also linked to the colour currently specified by the colour link context (see SaveContext and RestoreContextTo). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: pColName  - the name of the colour to add [INPUTS] pRGB - the definition of the colour to add pColourInfo - if NULL, then it is a normal colour; if non-NULL then colour is special in some way, i.e. a tint or a linked colour or a spot colour. Returns: TRUE if the colour could be added; FALSE if not Errors: - See also: ImportedColours; ImportedColours::GetColour; ImportedColours::SaveContext; ImportedColours::RestoreContextTo Definition at line 663 of file impcol.cpp. { IndexedColour *pNewCol = new INDEXEDCOLOUR_RGBT(pRGB); return AddColour(pColName, &pNewCol, pColourInfo); }

BOOL ImportedColours::AddColour (  const String_64 *  pColName, ColourCMYK *  pCMYK, NewColourInfo *  pColourInfo = NULL )

Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. If pColourInfo specifies a linked or tinted colour, then this colour is also linked to the colour currently specified by the colour link context (see SaveContext and RestoreContextTo). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: pColName  - the name of the colour to add [INPUTS] pCMYK - the definition of the colour to add pColourInfo - if NULL, then it is a normal colour; if non-NULL then colour is special in some way, i.e. a tint or a linked colour or a spot colour. Returns: TRUE if the colour could be added; FALSE if not Errors: - See also: ImportedColours; ImportedColours::GetColour; ImportedColours::SaveContext; ImportedColours::RestoreContextTo Definition at line 628 of file impcol.cpp. { IndexedColour *pNewCol = new INDEXEDCOLOUR_CMYK(pCMYK); return AddColour(pColName, &pNewCol, pColourInfo); }

BOOL ImportedColours::AddColoursToDocument (  void   )

None. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1290 of file impcol.cpp. { // Make an array for the new colours INT32 NumNewColours = Colours.GetCount(); INT32 TableSize = sizeof(IndexedColour *) * (NumNewColours + 1); IndexedColour **pNewArray = (IndexedColour **) CCMalloc(TableSize); if (pNewArray == NULL) { // Out of memory. return FALSE; } // set up a slow job String_64 ImportMessage(_R(IDT_ADDCOLOURSTODOC)); BeginSlowJob( NumNewColours, TRUE, &ImportMessage ); INT32 Done = 0; // Copy the colour pointers into this array INT32 i = 0; NewColour *pColour = (NewColour *) Colours.GetHead(); List *pUnnamedColours = pColourComponent->GetColourList()->GetUnnamedColours(); while (pColour != NULL) { // Remove this colour from the list, and add it (and all duplicates of it) to the // palette and the array, but only if it is not already in the document,and it // is not an unnamed colour (i.e. its name starts with an underscore). Colours.RemoveItem(pColour); while (pColour != NULL) { // Is it an unnamed colour? if (!pColour->pCol->IsNamed()) // Is it an unnamed colour? { // Yes - add to the unnamed colour list (no need for undo) // We force it unnamed again now to ensure it generates a new unique // ID for its destination document, rather than using the // unique-within-file id used during import. pColour->pCol->SetUnnamed(); pUnnamedColours->AddTail(pColour->pCol); } else { // It's a named colour - may be already in the doc, may be not IndexedColour* pIdenticalColour; pColourComponent->FindIdenticalColour(pColour->pCol, &pIdenticalColour); if (pIdenticalColour) { // Already in the doc so just move the existing colour // into the required position in the list by unlinking and relinking... ColourList *pColourList = pColourComponent->GetColourList (); if ( pColourList->RemoveItem ( pIdenticalColour ) != NULL ) { pColourComponent->AddNewColour(pIdenticalColour); pNewArray[i++] = pIdenticalColour; } } else { pColourComponent->AddNewColour(pColour->pCol); pNewArray[i++] = pColour->pCol; } } // Try next duplicate and delete this item. NewColour *pTmp = pColour; pColour = pColour->pNextDuplicate; delete pTmp; } // Try the next colour pColour = (NewColour *) Colours.GetHead(); // do progess bar stuff Done++; if(Done % 0xf == 0) ContinueSlowJob(Done); } // Terminate the list of pointers pNewArray[i] = NULL; // Add these colours|. ColourManager::UnHideColours(pColourComponent->GetColourList(), pNewArray); // Destroy the list of added colours (UnHideColours copied it, so our copy is useless now) CCFree(pNewArray); pNewArray = NULL; // Destroy the colour map delete pColourMap; pColourMap = NULL; // finish the slow job ContinueSlowJob(NumNewColours); EndSlowJob(); // All ok return TRUE; }

BOOL ImportedColours::AddShade (  const String_64 *  pColName, INT32  ShadeX, INT32  ShadeY )

Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. This colour is a shade of the colour currently specified by the colour link context (see SaveContext and RestoreContextTo). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (copied from code by Tim) Date: 7/9/95 (30/11/94) Parameters: pColName  - the name of the colour to add [INPUTS] ShadeX - the shade X value (between -100 and 100) ShadeY - the shade Y value (between -100 and 100) Returns: TRUE if the colour could be added; FALSE if not Errors: - See also: ImportedColours; ImportedColours::GetColour; ImportedColours::SaveContext; ImportedColours::RestoreContextTo Definition at line 895 of file impcol.cpp. { // Get a new colour to add IndexedColour *pNewCol = new IndexedColour; // Set up the tint information NewColourInfo ColourInfo; ColourInfo.Type = COLOURTYPE_TINT; // And flag the fact that this "tint" is really a shade! ColourInfo.TintIsShade = TRUE; // Convert -100 <-> 100 to -1.0 <-> 1.0 and pass in as FIXED24. ColourInfo.TintValue = FIXED24(((double) ShadeX) / 100.0); ColourInfo.ShadeValue = FIXED24(((double) ShadeY) / 100.0); return AddColour(pColName, &pNewCol, &ColourInfo); }

BOOL ImportedColours::AddTint (  const String_64 *  pColName, UINT32  Tint )

Add the specified colour to the colour table. If the colour name clashes with any already added or already in the destination document, this does not matter as the name specified in pColName is what should be used to access this colour again. This colour is a tint of the colour currently specified by the colour link context (see SaveContext and RestoreContextTo). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: pColName  - the name of the colour to add [INPUTS] Tint - the tint value (between 0 and 100) Returns: TRUE if the colour could be added; FALSE if not Errors: - See also: ImportedColours; ImportedColours::GetColour; ImportedColours::SaveContext; ImportedColours::RestoreContextTo Definition at line 854 of file impcol.cpp. { // Get a new colour to add IndexedColour *pNewCol = new IndexedColour; // Set up the tint information NewColourInfo ColourInfo; ColourInfo.Type = COLOURTYPE_TINT; // Convert 0 <-> 100 to 0.0 <-> 1.0 and pass in as FIXED24. ColourInfo.TintValue = FIXED24(((double) Tint) / 100.0); return AddColour(pColName, &pNewCol, &ColourInfo); }

BOOL ImportedColours::AddTintOrShade (  const String_64 *  pColName, NewColourInfo *  pColourInfo )

Add the specified tint or shade to the colour table. Assumes the vital tint information has already been filled in. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/96 Parameters: pColName  - the name of the colour to add [INPUTS] pLinkInfo - the colour information data Returns: TRUE if the colour could be added; FALSE if not Errors: - See also: ColourListComponent::ReadTint; ColourListComponent::ReadShade; ColourListComponent::ImportColourDefinition; Definition at line 818 of file impcol.cpp. { // Get a new colour to add IndexedColour *pNewCol = new IndexedColour; // Assumes tint and shade information already set up, this includes:- // pColourInfo->Type = COLOURTYPE_TINT; // pColourInfo->TintValue = 0.0; (FIXED24); // If shade then // pColourInfo->ShadeValue = 0.0; (FIXED24); return AddColour(pColName, &pNewCol, pColourInfo); }

BOOL ImportedColours::DestroyColours (   )

None. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1407 of file impcol.cpp. { NewColour *pColour = (NewColour *) Colours.GetHead(); while (pColour != NULL) { // Remove this colour from the list, and delete the indexed colour it points to // (if it is not already in the document). Colours.RemoveItem(pColour); while (pColour != NULL) { if (!pColour->AlreadyExistsInDoc) { // It's a brand new colour - delete it. // Except we don't because it causes an error. // NB. This is a temporary bodge to stop us from getting Indexed colour // deleted while in use errors - they happen because the undo // system does not delete the nodes added by InsertNode() yet. // When it does, then we can uncomment this line. As it stands we // we get a memory leak of new colours when an import fails, but // what the hell - it's only a bodge. //delete pColour->pCol; } // Try next duplicate and delete this item. NewColour *pTmp = pColour; pColour = pColour->pNextDuplicate; delete pTmp; } // Try the next colour pColour = (NewColour *) Colours.GetHead(); } // All done return TRUE; }

IndexedColour * ImportedColours::GetColour (  INT32  ReqRecordNumber  )

Searches for a previously imported colour definition. Used by the native/web filter to convert a colour reference in a record to an IndexedColour. This must have already been imported in the file as the rule is that reference to colours can only be made if the colour definition has already been output. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 30/5/96 Parameters: ReqRecordNumber  - the record number to search the list for [INPUTS] Returns: Pointer to the indexed colour if successful; NULL if not found. Errors: - See also: ImportedColours; ColourListComponent::ImportColourDefinition; Definition at line 1466 of file impcol.cpp. { // Work our way through the list of imported colours until we find the required record number NewColour *pColour = (NewColour *) Colours.GetHead(); while (pColour != NULL) { if (pColour->RecordNumber == ReqRecordNumber) return pColour->pCol; // Try the next colour pColour = (NewColour *) Colours.GetNext(pColour); } // Something went a bit wrong and we didn't find the requested record number // return NULL to the caller return NULL; }

IndexedColour * ImportedColours::GetColour (  PCTSTR  ColName, const PColourCMYK *  Defn )

Searches for a named colour. If the colour name has had duplicate definitions during this import, then the colour definition is compared against the values pointed to by Defn (converting to CMYK first if needed). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: ColName  - the colour name to look for. [INPUTS] Defn - pointer to the CMYK values specified in the imported file. Returns: Pointer to the indexed colour if successful; NULL if not found. Errors: - See also: ImportedColours Definition at line 1216 of file impcol.cpp. { // Do we have a definition of this colour name? NewColour *pNewColour=NULL; if( pColourMap->Lookup( ColName, pNewColour ) ) { // Should we check colour values before returning this colour? if (StrictColourMatching || (pNewColour->pNextDuplicate != NULL)) { // Yes - find a colour from this entry that matches the colour definition too... while (pNewColour != NULL) { // Is this a match? // NB. We allow them to be out by one to cope with rounding problems. // This is ok, because it will only happen in ArtWorks EPS files, // and then only on colours that are 1 out in the colour definition, // so I don't think anyone's going to notice! -- Tim if (WITHIN_ONE(pNewColour->ColDefn.Cyan, Defn->Cyan) && WITHIN_ONE(pNewColour->ColDefn.Magenta, Defn->Magenta) && WITHIN_ONE(pNewColour->ColDefn.Yellow, Defn->Yellow) && WITHIN_ONE(pNewColour->ColDefn.Key, Defn->Key)) { // Yes - quit loop break; } // Otherwise try next colour pNewColour = pNewColour->pNextDuplicate; } // Did we find one? if (pNewColour != NULL) { // Yes - return it to the caller. return pNewColour->pCol; } else { // No - return failure return NULL; } } else { // No checking needed -just return this colour return pNewColour->pCol; } } else { // No - return failure. return NULL; } }

IndexedColour * ImportedColours::GetColour (  PCTSTR  ColName  )

Find a named colour in the import list. This look up is obviously done purely on the colour name, and as such is a slightly risky thing to do, especially when importing such flaky file formats as EPS - use the version of GetColour that takes a PColourCMYK value to provide more reliable colour lookup. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: ColName  - the colour name to look for. [INPUTS] Returns: Pointer to the indexed colour if successful; NULL if not found. See also: ImportedColours Definition at line 1178 of file impcol.cpp. { // Do we have a definition of this colour name? NewColour *pNewColour=NULL; if( pColourMap->Lookup( ColName, pNewColour ) ) { // Yes - return the first entry return pNewColour->pCol; } else { // No - return failure. return NULL; } }

BOOL ImportedColours::Init (  void   )

Initialise the table of imported colours. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from SimpleCCObject. Definition at line 571 of file impcol.cpp. { // Get a hash table for the colour names... try { pColourMap = new CMapStringToNewColour; } catch( CMemoryException ) { ERROR(_R(IDS_OUT_OF_MEMORY), FALSE); } // Check our document's colour list component... if (pColourComponent == NULL) { // Whoops - something's up delete pColourMap; pColourMap = NULL; ERROR2(FALSE, "NULL colour list component!"); } // Ininitalise the colour linking context. if (!Context.Init()) return FALSE; // All ok return TRUE; }

void ImportedColours::RestoreContextTo (  UINT32  Level  )

None. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1152 of file impcol.cpp. { if (Context.RestoreContextTo(Level) == FALSE) { ERROR3("Unbalanced colour import context"); } }

void ImportedColours::SaveContext (   )

None. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1132 of file impcol.cpp. { Context.SaveContext(); }

void ImportedColours::SetLinkedColourInherits (  UINT32  ComponentID  )

BOOL ImportedColours::SortColoursByEntryNumber (   )

Sorts the list of imported colours by the EntryNumber that is saved in the colour definition in the native file format so that we load the list back in the same order that it was in when the document was saved. This because when we save the colours we cannot save the list in the order they are defined in the colour list as we must save parent colours before children so that the children can reference the parent. Borrowed code from SuperGallery::ApplySortNow as we need a much simpler version. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: True if the operation completed successfully False if it failed in some way. Errors: - See also: ImportedColours; ColourListComponent::ImportColourDefinition; ColourListComponent::EndImport; SuperGallery::ApplySortNow Definition at line 1507 of file impcol.cpp. { INT32 NumItems = 0; // Count the number of items we have to sort NewColour *pColour = (NewColour *) Colours.GetHead(); while (pColour != NULL) { if (pColour->pCol->IsNamed()) // Is it an named colour? NumItems++; pColour = (NewColour *) Colours.GetNext(pColour); } // Start progress indicators, with a percentage based upon the number of items. // We will update twice for each group (after qsort and shuffle-items stages) String_64 Description(_R(IDS_NATIVE_SORTCOLOURS)); BeginSlowJob(NumItems * 2, FALSE, &Description); INT32 NumItemsToSort = 0; if (NumItems > 1) { // Get memory for an array of pointers to these items NewColour **SortArray = (NewColour **)CCMalloc(NumItems * sizeof(NewColour *)); if (SortArray == NULL) return FALSE; // Fill in the array with pointers to display items to sort INT32 i = 0; NewColour *pColour = (NewColour *) Colours.GetHead(); while (pColour != NULL) { if (pColour->pCol->IsNamed()) // Is it an named colour? SortArray[i++] = pColour; pColour = (NewColour *) Colours.GetNext(pColour); } // Sort the array of pointers qsort(SortArray, NumItems, sizeof(NewColour *), ImportedColours::SortComparator); NumItemsToSort += NumItems; // Update percentage complete for the number of items processed ContinueSlowJob(NumItemsToSort); // Now, take the sorted array, and rearrange the items to be in that order // Special case the first item NewColour *pPrevColour = (NewColour *) Colours.GetPrev(SortArray[0]); if (pPrevColour != NULL) { Colours.RemoveItem(SortArray[0]); Colours.InsertBefore(SortArray[1], SortArray[0]); } // Then whip through the rest of the items for (i = 1; i < NumItems; i++) { pPrevColour = (NewColour *) Colours.GetPrev(SortArray[i]); if (pPrevColour != SortArray[i-1]) { Colours.RemoveItem(SortArray[i]); Colours.InsertAfter(SortArray[i-1], SortArray[i]); } } // Free our temporary workspace CCFree(SortArray); } // End the progress bar that we started EndSlowJob(); // We seem to have sorted the items ok return TRUE; }

INT32 __cdecl ImportedColours::SortComparator (  const void *  Item1, const void *  Item2 )  [static, protected]

'qsort' comparator function, used when quicksorting the loaded colour list Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/96 Parameters: Item1,Item2  - the display nodes to be compared [INPUTS] Returns: negative (I am lesser), 0 (we are equal), or positive (I am greater) result of comparing the items with the EntryNumber stored in each item in the loaded colour list. See also: ImportedColours::SortColoursByEntryNumber() SuperGallery::SortComparator; SuperGallery::ApplySortNow Definition at line 1597 of file impcol.cpp. { NewColour *pColourItem1 = *((NewColour **)Item1); NewColour *pColourItem2 = *((NewColour **)Item2); if (pColourItem1 == NULL || pColourItem2 == NULL) { ERROR3("ImportedColours::SortComparator bad pointers!"); return 0; } if (pColourItem1->EntryNumber < pColourItem2->EntryNumber) return(-1); return((pColourItem1->EntryNumber == pColourItem2->EntryNumber) ? 0 : 1); }

---

Member Data Documentation

NewColourList ImportedColours::Colours [protected]

Definition at line 350 of file impcol.h.

ColourImportContext ImportedColours::Context [protected]

Definition at line 360 of file impcol.h.

ColourListComponent* ImportedColours::pColourComponent [protected]

Definition at line 357 of file impcol.h.

CMapStringToNewColour* ImportedColours::pColourMap [protected]

Definition at line 354 of file impcol.h.

BOOL ImportedColours::StrictColourMatching [protected]

Definition at line 363 of file impcol.h.

---

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

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

---