ColourListComponent Class Reference

Provide a component that is linked to a ColourList object. This allows us to save out colour lists using the serialisation facilities of the DocComponent base class. More...

#include <colcomp.h>

Inheritance diagram for ColourListComponent:

List of all members.

Public Member Functions
	ColourListComponent ()
	Construct a colour list component. DO NOT use this constructor. It gives and ERROR3 (and sets up this in a semi-safe default state).
	ColourListComponent (ColourList *)
	Construct a colour list component using the given colour list.
virtual	~ColourListComponent ()
	Clean up a colour list component's data structures - deletes the colour list.
ColourList *	GetColourList ()
virtual BOOL	EPSStartImport (EPSFilter *)
	Inform the colour list document component that an EPS import is about to start.
virtual void	EPSEndImport (EPSFilter *, BOOL)
	Inform the colour list document component that an EPS import has just finished.
virtual BOOL	WriteEPSComments (EPSFilter *)
	Writes out the colour table in the form of EPS comments in the 'header' comments of the EPS file.
virtual ProcessEPSResult	ProcessEPSComment (EPSFilter *, PCTSTR)
	Process an EPS comment - if this is a colour table comment, this component will claim it and try to decode it.
virtual void	EndOfEPSComment (EPSFilter *)
	Informs the document component that the comment it has been decoding has now finished, and it should take whatever action required to act on the comment.
virtual BOOL	StartImport (BaseCamelotFilter *pFilter)
	Inform the colour list document component that a Native or Web import is about to start.
virtual BOOL	EndImport (BaseCamelotFilter *pFilter, BOOL Success)
	Inform the colour list document component that a Native or Web import has just finished.
virtual BOOL	StartExport (BaseCamelotFilter *pFilter)
	Inform the colour list document component that a WEb or Native export is about to start.
virtual BOOL	EndExport (BaseCamelotFilter *pFilter, BOOL Success)
	Inform the colour list document component that a Web or Native export has just finished.
virtual void	CleanUpAfterExport (BOOL Success)
	Inform the document component that a Web or Native export has just finished.
IndexedColour *	FindNamedColour (PCTSTR, DocColour *ColDef=NULL, UINT32 Tint=100, BOOL Strict=FALSE)
	Given the name of an imported named colour, return the relevant indexed colour. This allows attributes to be added when importing that use named colours. If ColDef is not NULL, then the Indexed colour found is checked to see if it agrees with the definition in ColDef - if not, then a new indexed colour is made, and a pointer to that is returned instead. This means we can cope with brain-damaged formats that have two or more named colours with the same format. It also makes it easy to cope with formats that use unnamed colours, as we just keep making colours called "Unnamed colour" or similar, and this function works it all out for us.
BOOL	GetDocColour (INT32 ColourRef, DocColour *pDocColour)
	Try and convert a colour reference i.e. record number into a previously imported colour definition which should now be an indexed colour in the document.
BOOL	ImportSimpleColour (CXaraFileRecord *pCXFileRec)
	Try and import a simple RGB colour definition record into the document.
BOOL	ImportColourDefinition (CXaraFileRecord *pCXFileRec)
	Try and import a colour definition record into the document.
INT32	GetWriteColourReference (DocColour *pDocColour, BaseCamelotFilter *pFilter)
	Return the colour reference to the caller, who will then use it to write the colour in the record that they are preparing to save to a Web or Native file. In the process of getting the colour reference, the colour definition record for the colour reference will be generated and saved to the file. In Web format this will just be the simple colour record, in native files this will be the full colour definition, possibly preceeded by the parents for the colour, as these must be saved before the children as the children must have a valid colour reference. NOTE: As this does save information into the record stream, it *MUST* be called before the caller has called StartRecord() as otherwise the records will become intertwined!
virtual BOOL	StartComponentCopy ()
	This function gets called to prepare for a copy of indexed colours into the document. It sets up the various arrays and other thangs which the colour copy will need.
virtual BOOL	EndComponentCopy ()
	Will commit all changes made by doing the component copy, returning TRUE. Any new colours will be inserted as instructed by the InsertBefore parameter. If some colours will not be insterted because they were merged, then a report to this effect can be given if desired.
virtual BOOL	EndComponentCopy (IndexedColour *InsertBefore, BOOL Report)
	Will commit all changes made by doing the component copy, returning TRUE. Any new colours will be inserted as instructed by the InsertBefore parameter. If some colours will not be insterted because they were merged, then a report to this effect can be given if desired.
virtual void	AbortComponentCopy ()
	Will abort all changes made for component copies. This means that things such as the colours referenced by the nodes you have just copied do not exist, so you must clean up to the state the document was in before you strated copying.
ColCompCopyResult	CopyColourAcross (DocColour *pDocColour, BOOL SourceIsUnique=FALSE)
	If the DocColour references an IndexedColour then a copy of that IxColour is made and remembered. The DocColour is then changed to reference the new indexed colour. On calling EndComponentCopy, these new IndexedColours will be added to the document. If a failure occurs at any stage, you must immediately* undo the entire copy operation, deleting all the nodes referencing the new colours we've created, before calling AbortComponentCopy.
IndexedColour *	ExactMatchExists (IndexedColour *SourceColour)
	Determine if a colour is already available in the paste-destination document This allows us to merge IndexedColours on the clipboard with those in the target document when doing a paste operation.
Private Member Functions
void	AddNewColour (IndexedColour *pNewCol)
	Adds an indexed colour to the colour list (which in turn ensures that it has a unique colour name).
BOOL	FindIdenticalColour (IndexedColour *pColour, IndexedColour **pResult)
	Find out if there is already a colour exactly the same as the one passed in in the existing colour list. If so, return a pointer to it, otherwise return NULL. Also indicates whether or not a colour with this name already exists in the document, regardless of whether the colour data is the same.
INT32	ExtractString (PCTSTR Comment, INT32 Start, PTSTR String)
	Copy a PostScript string out of the given EPS comment. It handles nested parentheses - e.g. a string like (Hello (there)) will be correctly returned in String as "Hello (there)". The end of the comment is also taken as terminating the string.
void	ReadEPS_RGB (ColourRGBT *pCol, TCHAR *pComment, NewColourInfo *pColourInfo)
void	ReadEPS_CMYK (ColourCMYK *pCol, TCHAR *pComment, NewColourInfo *pColourInfo)
void	ReadEPS_HSV (ColourHSVT *pCol, TCHAR *pComment, NewColourInfo *pColourInfo)
void	ReadEPS_Grey (ColourGreyT *pCol, TCHAR *pComment, NewColourInfo *pColourInfo)
UINT32	ReadEPS_Tint (TCHAR *pComment)
void	ReadEPS_Shade (TCHAR *pComment, INT32 *ResultX, INT32 *ResultY)
BOOL	ColourOrChildIsShade (IndexedColour *pCol)
	To determine if a colour is a Shade or has descendants which are Shades.
BOOL	SaveColourAndChildren (IndexedColour *pCol, EPSExportDC *pDC, BOOL CamelotEPS, INT32 NestingLevel=0, BOOL SaveShades=FALSE)
	Save out an indexed colour to an EPS file, and all the colours that rely on it, i.e. any other indexed colours which are tints of, or links to, this colour.
void	AddComponentValue (PTSTR ColDef, PCTSTR Format, double ComponentValue, BOOL Inherited)
	Add a colour component value to a colour definition string. This is used to build up the entries in the EPS colour table. It also centralises the syntax of inherited components.
INT32	SaveColourAndParents (IndexedColour *pCol, BaseCamelotFilter *pFilter, INT32 NestingLevel=0)
	Save out an indexed colour to a Web or Native file. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. This is the Web file form of saving colours. Save out an indexed colour in its complex form usually to a Native file. If it has any parents then these must be saved out before it, as the colour reference for the parent *MUST* be a real record number which has been previously saved into the stream. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. This is the Native file form of saving colours.
INT32	SaveComplexColour (IndexedColour *pCol, BaseCamelotFilter *pFilter, BOOL AddColourToList=TRUE)
	Actually save out an indexed colour to a Web or Native file in a complex colour record. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. If it has any parents then these must be saved out before it, as the colour reference for the parent *MUST* be a real record number which has been previously saved into the stream. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. This is the Native file form of saving colours.
INT32	SaveSimpleColour (IndexedColour *pCol, BaseCamelotFilter *pFilter)
	Save out an indexed colour to a Web or Native file. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. This is the Web file form of saving colours.
INT32	SaveSimpleColour (DocColour *pDocCol, BaseCamelotFilter *pFilter, BOOL CheckSimpleColourList=FALSE)
	Save out a document colour to a Web or Native file. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. This is the Web file form of saving colours.
UINT32	AddComponentValue (FIXED24 ComponentValue, BOOL Inherited)
	Returns either the colour component value or if it is inherited, a known illegal value which we can intepret on import to be an overridden value. Doing it in a function centralises the syntax of inherited components.
INT32	GetIndexColourNumber (IndexedColour *pCol)
	Work out the index of this colour in the list of indexed colours so that we can try and load back the colours in the same order. Unfortunately, the only way it seems that we can work out this number is by counting back to the start of the indexed colour list. Doh!
BOOL	ReadRGB (ColourRGBT *pCol, NewColourInfo *pColourInfo, UINT32 Comp1, UINT32 Comp2, UINT32 Comp3, UINT32 Comp4)
	Read the RGB values from a Camelot RGB colour definition record.
BOOL	ReadCMYK (ColourCMYK *pCol, NewColourInfo *pColourInfo, UINT32 Comp1, UINT32 Comp2, UINT32 Comp3, UINT32 Comp4)
	Read the CMYK values from a Camelot CMYK colour definition record.
BOOL	ReadHSV (ColourHSVT *pCol, NewColourInfo *pColourInfo, UINT32 Comp1, UINT32 Comp2, UINT32 Comp3, UINT32 Comp4)
	Read the HSV values from a Camelot HSV colour definition record.
BOOL	ReadGrey (ColourGreyT *pCol, NewColourInfo *pColourInfo, UINT32 Comp1)
	Read the Grey values from a Camelot Grey colour definition record.
BOOL	ReadTint (NewColourInfo *pColourInfo, UINT32 Comp1)
	Read the tint values from a Camelot tint colour definition record.
BOOL	ReadShade (NewColourInfo *pColourInfo, UINT32 Comp1, UINT32 Comp2)
	Read the shade values from a Camelot shade colour definition record.
INT32	ExtendTables (void)
	Called by Component Copy routines to extend the size of the copy mapping tables (SourceColours[], DestColours[], and MergeColours[]). This returns the index of the first free entry in the new tables, or -1 if it fails.
IndexedColour *	MapColour (IndexedColour *SourceColour, BOOL *AlreadyThere=NULL, BOOL SourceIsUnique=FALSE)
	Used internally in ColourListComponent Component Copy routines. This method keeps track of mappings between source document and destination document colours. It determines the mapping from source to dest, and returns the appropriate destination-docuemnt IndexedColour. This may be a new colour which will later be added to the destination document or a colour already in the dest. doc (merged colour). Once an IndexedColour is mapped, future calls to this method will be very efficient (a simple table search and lookup of the previous mapping).
IndexedColour *	GetIndexedParentOfColour (DocColour Colour)
	It is possible for us to create doccolours from indexed colours and then convert them so that they are standalone. This method goes through all the indexed colours to try and find out which indexed colour (if any) originally created the input.
Private Attributes
ColourList *	pIndexedColours
ImportedColours *	pNewColours
ExportedColours *	pExportedColours
IndexedColour **	SourceColours
IndexedColour **	DestColours
BOOL *	MergeColours
INT32	ColourTableSize
INT32	LinkNesting
BaseCamelotFilter *	pCamFilter
BOOL	WarnedBefore
Friends
class	ImportedColours

---

Detailed Description

Provide a component that is linked to a ColourList object. This allows us to save out colour lists using the serialisation facilities of the DocComponent base class.

Author:

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

Date:

02/08/94

See also:

DocComponent

Definition at line 176 of file colcomp.h.

---

Constructor & Destructor Documentation

ColourListComponent::ColourListComponent (   )

Construct a colour list component. DO NOT use this constructor. It gives and ERROR3 (and sets up this in a semi-safe default state). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 8/11/94 See also: ColourListComponent Definition at line 251 of file colcomp.cpp. { ERROR3("ColourListComponent constructed with default constructor!?\n"); // We don't have a colour list! Eek! pIndexedColours = NULL; // Initialise importer colour maps etc pNewColours = NULL; // Initialise Exporter colour list pExportedColours = NULL; // Initialise IndexedColour ComponentCopy array pointers SourceColours = NULL; DestColours = NULL; ColourTableSize = 32; // Our link to the BaseCamelotFilter pCamFilter = NULL; // Set our variable so that we warn about a possible replacement only once WarnedBefore = FALSE; }

ColourListComponent::ColourListComponent (  ColourList *  pColList  )

Construct a colour list component using the given colour list. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/94 Parameters: pColList  - the colour list to use for this colour list componet. [INPUTS] Notes: NOTE that the list you pass in now "belongs" to this CLC, and it will be automatically deleted when you delete this CLC object. Returns: Errors: ENSURE if pColList is NULL. See also: ColourListComponent Definition at line 294 of file colcomp.cpp. { ENSURE(pColList != NULL, "NULL colour list in colour list component constructor!"); // Install this colour list. pIndexedColours = pColList; // Initialise importer colour tables etc pNewColours = NULL; // Initialise Exporter colour list pExportedColours = NULL; // Initialise IndexedColour ComponentCopy array pointers SourceColours = NULL; DestColours = NULL; ColourTableSize = 32; // Our link to the BaseCamelotFilter pCamFilter = NULL; // Set our variable so that we warn about a possible replacement only once WarnedBefore = FALSE; }

ColourListComponent::~ColourListComponent (   )  [virtual]

Clean up a colour list component's data structures - deletes the colour list. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 08/09/94 Returns: Errors: ENSURE if IndexedColour copying stuff has not been cleaned up (this will occur if End/AbortComponentCopy is not called after a component copy) See also: ColourListComponent Definition at line 332 of file colcomp.cpp. { // Delete our colour list. if (pIndexedColours != NULL) { pIndexedColours->DeleteAll(); delete pIndexedColours; pIndexedColours = NULL; } // Sanity check to see if we've done something terrible... ENSURE(SourceColours == NULL && DestColours == NULL, "Someone failed to EndComponentCopy before destructing a ColourListComponent"); // As we have finished with it now, destroy the list of exported colours if (pExportedColours) { delete pExportedColours; pExportedColours = NULL; } }

---

Member Function Documentation

void ColourListComponent::AbortComponentCopy (   )  [virtual]

Will abort all changes made for component copies. This means that things such as the colours referenced by the nodes you have just copied do not exist, so you must clean up to the state the document was in before you strated copying. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Notes: May be called even if StartComponentCopy has not been called. May be called multiple times See also: ColourListComponent::EndComponentCopy; ColourListComponent::AbortComponentCopy; ColourListComponent::CopyColourAcross Reimplemented from DocComponent. Definition at line 3989 of file colcomp.cpp. { // Clean up by deleting all the new indexedColours we created. We hope that by the // time we do this, all DocColours referencing these colours will have been vaped. if (DestColours != NULL) { for (INT32 i = 0; i < ColourTableSize; i++) { if (DestColours[i] != NULL && !MergeColours[i]) { delete DestColours[i]; DestColours[i] = NULL; } } } // And release our working arrays if (SourceColours != NULL) { CCFree(SourceColours); SourceColours = NULL; } if (DestColours != NULL) { CCFree(DestColours); DestColours = NULL; } if (MergeColours != NULL) { CCFree(MergeColours); MergeColours = NULL; } }

UINT32 ColourListComponent::AddComponentValue (  FIXED24  ComponentValue, BOOL  Inherited )  [private]

Returns either the colour component value or if it is inherited, a known illegal value which we can intepret on import to be an overridden value. Doing it in a function centralises the syntax of inherited components. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 28/5/96 Parameters: ComponentValue  - the value to be returned. [INPUTS] Inherited - TRUE => This component is inherited, so just output a known illegal value FALSE => This component is not inherited, so output the actual value to the string -  [OUTPUTS] Returns: The colour component as a UINT32 ready to write out to file. Errors: - See also: ColourListComponent::SaveColourAndParents Definition at line 2044 of file colcomp.cpp. { // Construct the colour component value UINT32 ColourValue = 0L; // If this is a linked colour, and this component is inherited, then just add a '-'. if (Inherited) { ColourValue = FIXED24(-8.0).GetAsFixed24(); } else { // We have to output the component.... ColourValue = ComponentValue.GetAsFixed24(); } return ColourValue; }

void ColourListComponent::AddComponentValue (  PTSTR  ColDef, PCTSTR  Format, double  ComponentValue, BOOL  Inherited )  [private]

Add a colour component value to a colour definition string. This is used to build up the entries in the EPS colour table. It also centralises the syntax of inherited components. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/12/94 Parameters: ColDef  - the current colour definition string, which this routine should [INPUTS] append the component value to. Format - the printf format to use when converting the value to ASCII. ComponentValue - the value to add to the string. Inherited - TRUE => This component is inherited, so just output a '-' FALSE => This component is not inherited, so output the actual value to the string ColDef  - the updated colour definition string, with the value converted to [OUTPUTS] ASCII (taking into account the Inherited flag), and appended (with a leading space so the values don't join together). Returns: Errors: - See also: ColourListComponent::SaveColourAndChildren Definition at line 2401 of file colcomp.cpp. { // Construct the colour component value TCHAR CompVal[20]; // If this is a linked colour, and this component is inherited, then just add a '-'. if (Inherited) { camStrcpy( CompVal, _T("-") ); } else { // We have to output the component.... camSnprintf( CompVal, 20, const_cast<TCHAR *>(Format), ComponentValue ); } // Add the value onto the end of the string camStrcat( ColDef, _T(" ") ); camStrcat( ColDef, CompVal ); }

void ColourListComponent::AddNewColour (  IndexedColour *  pNewCol  )  [private]

Adds an indexed colour to the colour list (which in turn ensures that it has a unique colour name). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 08/08/94 Parameters: pNewCol  - the colour to add. [INPUTS] See also: ColourList::AddItem Definition at line 2199 of file colcomp.cpp. { ERROR3IF(pNewCol == NULL, "ColourListComponent::AddNewColour: The colour to add is NULL!"); ERROR3IF(pIndexedColours == NULL, "ColourListComponent::AddNewColour: I have no IndexedColour list!"); // Add the colour, ensuring that it has a unique name pIndexedColours->AddItem(pNewCol); }

void ColourListComponent::CleanUpAfterExport (  BOOL  Success  )  [virtual]

Inform the document component that a Web or Native export has just finished. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/8/96 Parameters: Success  - True if everything went swimmingly, False if the export failed [INPUTS] Notes: This is called after EndExport, so that the component can clean up any during-export data structures. This allows situations like: PrintComponent wants to save a colour reference in it's EndExport call, but is called after the ColourComponent EndExport. The ColourComponent EndExport does not delete its data structures, so is still able to supply colour references to other components' EndExport functions. See also: ColourListComponent::EndExport; DocComponent::CleanUpAfterExport Reimplemented from DocComponent. Definition at line 1255 of file colcomp.cpp. { #ifdef DO_EXPORT // As we have finished with it now, destroy the list of exported colours if (pExportedColours) { delete pExportedColours; pExportedColours = NULL; } // Null our link to the BaseCamelotFilter pCamFilter = NULL; #endif return; }

BOOL ColourListComponent::ColourOrChildIsShade (  IndexedColour *  pCol  )  [private]

To determine if a colour is a Shade or has descendants which are Shades. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: pCol  - The (root) colour to check [INPUTS] Returns: TRUE if this colour or a descendant is a Shade colour Definition at line 2439 of file colcomp.cpp. { // Check if this colour exists if (pCol->IsDeleted()) return(FALSE); // Check if this colour is a shade if (pCol->GetType() == COLOURTYPE_TINT && pCol->TintIsShade()) return(TRUE); // If this has no children, then no point in scanning further if (!pCol->HasLinkedChildren()) return(FALSE); // Ask all the named colours that are immediate children of this colour IndexedColour *pChild = (IndexedColour *) pIndexedColours->GetHead(); while (pChild != NULL) { if (!pChild->IsDeleted() && pChild->FindLinkedParent() == pCol) { // Found a child - recurse on it if (ColourOrChildIsShade(pChild)) return(TRUE); } // Try the next colour pChild = (IndexedColour *) pIndexedColours->GetNext(pChild); } // Get all the unnamed colours that are immediate children of this colour List *pUnnamedList = pIndexedColours->GetUnnamedColours(); pChild = (IndexedColour *) pUnnamedList->GetHead(); while (pChild != NULL) { if (!pChild->IsDeleted() && pChild->FindLinkedParent() == pCol) { // Found a child - recurse on it if (ColourOrChildIsShade(pChild)) return(TRUE); } // Try the next colour pChild = (IndexedColour *) pUnnamedList->GetNext(pChild); } return(FALSE); }

ColCompCopyResult ColourListComponent::CopyColourAcross (  DocColour *  pDocColour, BOOL  SourceIsUnique = FALSE )

If the DocColour references an IndexedColour then a copy of that IxColour is made and remembered. The DocColour is then changed to reference the new indexed colour. On calling EndComponentCopy, these new IndexedColours will be added to the document. If a failure occurs at any stage, you must immediately* undo the entire copy operation, deleting all the nodes referencing the new colours we've created, before calling AbortComponentCopy. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/94 Parameters: pDocColour  - The colour which resulted from copying across from one document [INPUTS] to our document. SourceIsUnique - FALSE (the default) if you're copying existing document colours around, and therefore could attempt to copy the same colour multiple times. TRUE if you can guarantee that this colour will only be copied once. This is used only for copying library colours into a document in the colour gallery (where it uses a temporary IndexedColour, which causes problems when several different colours accidentally map to the same temporary memory allocation, thus causing rampant incorrect colour merging to occur). ONLY USE THIS IF YOU REALLY REALLY BELIEVE YOU MUST - ** IT SHOULD NOT BE NECESSARY UNDER NORMAL CIRCUMSTANCES ** Returns: CCCOPY_FAILED = 0/FALSE - if it failed, in which case the error has been reported CCCOPY_NEWCOLOUR - if it succeeded by creating a new colour CCCOPY_MERGEDCOLOUR - if it succeeded by merging (using an existing colour) Chains of linked/tint IndexedColours are also handled properly. Notes: If this function returns FALSE, you MUST clean up and then call AbortComponentCopy to clean up. Returns: Errors: Memory errors are reported immediately If StartComponentCopy has not been called, or an internal consistency failure occurs (our working array pointer(s) are NULL), an ERROR2 will be reported. See also: ColourListComponent::StartComponentCopy; ColourListComponent::AbortComponentCopy; ColourListComponent::EndComponentCopy Definition at line 4307 of file colcomp.cpp. { IndexedColour *SourceColour = pDocColour->FindParentIndexedColour(); if (SourceColour == NULL) // Doesn't reference an IndexedColour, so return success return(CCCOPY_MERGEDCOLOUR); if (SourceColours == NULL || DestColours == NULL || MergeColours == NULL) { ERROR2RAW("ColourListComponent::CopyColourAcross called without a prior StartComponentCopy"); InformError(); return(CCCOPY_FAILED); } BOOL WasMerged = FALSE; IndexedColour *NewColour = MapColour(SourceColour, &WasMerged, SourceIsUnique); if (NewColour == NULL) // An error (no memory) occurred - abort component copy return(CCCOPY_FAILED); // Fix the colour to reference the destination copy of the indexed colour pDocColour->MakeRefToIndexedColour(NewColour); return((WasMerged) ? CCCOPY_MERGEDCOLOUR : CCCOPY_NEWCOLOUR); return CCCOPY_FAILED; }

BOOL ColourListComponent::EndComponentCopy (  IndexedColour *  InsertBefore, BOOL  Report )  [virtual]

Will commit all changes made by doing the component copy, returning TRUE. Any new colours will be inserted as instructed by the InsertBefore parameter. If some colours will not be insterted because they were merged, then a report to this effect can be given if desired. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/94 Parameters: InsertBefore  - NULL to insert at the end of the colour list, else a pointer [INPUTS] the the IndexedColour before which you wish to insert the colours. Report - FALSE to do it quietly, TRUE if you'd like a report given if any colours were merged (used by the colour gallery when copying colours, as merged colours will fail to appear in the chunk of copied colours, which can confuse the user) Returns: TRUE if it succeeded Notes: May be called multiple times - subsequent calls will be ignored WARNING: This is NOT an override of the base class method. Be careful See also: ColourListComponent::StartComponentCopy; ColourListComponent::AbortComponentCopy; ColourListComponent::CopyColourAcross Definition at line 3891 of file colcomp.cpp. { BOOL NeedToReport = FALSE; if (SourceColours != NULL) // Free the source mapping array { CCFree(SourceColours); SourceColours = NULL; } if (DestColours != NULL) { // Add the colours in the 'Destination' array to the ColourList for the dest. doc. // We only add those colours which have not been merged with existing colours in the // destination list. The AddItem() call ensures their names are unique in this doc. INT32 i; for ( i = 0; i < ColourTableSize; i++) { if (DestColours[i] != NULL && !MergeColours[i]) { if (InsertBefore == NULL || !DestColours[i]->IsNamed()) pIndexedColours->AddItem(DestColours[i]); else pIndexedColours->InsertBefore(InsertBefore, DestColours[i]); } } // Now, remove all merged colours from the list of colours to be 'unhidden' for undo // NOTE that DestColours is guaranteed to be NULL terminated // We delete each merged colour from the list by copying the first valid list item // over the top of the merged item; we keep track of the valid list start with // 'ListStart'. Once finished, we pass any remainder of the array to UnHideColours INT32 ListStart = 0; for (i = 0; i < ColourTableSize; i++) { if (DestColours[i] == NULL) // Stop at NULL terminator break; if (MergeColours[i] || !DestColours[i]->IsNamed()) { // A merged or unnamed colour - copy list item '0' over it, so that we do not // try to do any undo record for it. DestColours[i] = DestColours[ListStart]; DestColours[ListStart] = NULL; ListStart++; NeedToReport = TRUE; } } if (DestColours[ListStart] != NULL) // If there are non-merged named colours, create undo ColourManager::UnHideColours(pIndexedColours, &DestColours[ListStart]); // Lose our workspace array of pointers to these colours CCFree(DestColours); DestColours = NULL; } if (MergeColours != NULL) // Free the 'merged'-flag array { CCFree(MergeColours); MergeColours = NULL; } // If the caller wants us to, report (if necessary) that some of the colours // were not copied, as they were already present in the dest. doc if (Report && NeedToReport) InformMessage(_R(IDS_COLOURSMERGED), _R(IDS_OK)); return(TRUE); }

BOOL ColourListComponent::EndComponentCopy (   )  [virtual]

Will commit all changes made by doing the component copy, returning TRUE. Any new colours will be inserted as instructed by the InsertBefore parameter. If some colours will not be insterted because they were merged, then a report to this effect can be given if desired. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/94 Returns: TRUE if it succeeded Notes: May be called multiple times - subsequent calls will be ignored Overrides the base class method. Calls an internal variant on this method. See also: ColourListComponent::StartComponentCopy; ColourListComponent::AbortComponentCopy; ColourListComponent::CopyColourAcross Reimplemented from DocComponent. Definition at line 3854 of file colcomp.cpp. { return(ColourListComponent::EndComponentCopy(NULL, FALSE)); }

BOOL ColourListComponent::EndExport (  BaseCamelotFilter *  pFilter, BOOL  Success )  [virtual]

Inform the colour list document component that a Web or Native export has just finished. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/96 Parameters: pFilter  - the BaseCamelotFilter filter that is being used to import a file. [INPUTS] Success - True if everything went swimmingly, False if just a clean up is required. Returns: TRUE if the component was able to end the importing; FALSE if not (e.g. out of memory) See also: DocComponent Reimplemented from DocComponent. Definition at line 1173 of file colcomp.cpp. { #ifdef DO_EXPORT // ERROR2IF(pExportedColours == NULL, FALSE, "ColourListComponent::EndExport no pExportedColours!"); // If we error about the pExportedColours then we assume that the EndImport has been called. // This may not be the case if we are in clean up mode. So just handle it! TRACEUSER( "Neville", _T("ColourListComponent::EndExport\n")); if (pFilter == NULL) { ERROR3("ColourListComponent::EndExport filter is null!"); return TRUE; } // Check if we should be saving unused colours or not. Usually this is controlled by the // user in Web files and always done in Native files. // Do not do if we are just in clean up mode or have no pExportedColours (indicating in clean up mode) if (!pFilter->IsWebFilter() && !pFilter->GetRemoveUnusedColours() && Success && pExportedColours) { TRACEUSER( "Neville", _T("ColourListComponent::EndExport exporting unsaved colours\n")); // Iterate over the document's list of named IndexedColours... IndexedColour *pCol = (IndexedColour *) pIndexedColours->GetHead(); BOOL ok = TRUE; while (ok && pCol != NULL) { if (!pCol->IsDeleted()) { // The colour is in use - save it to the file. ok = SaveColourAndParents(pCol, pFilter, 0); } // Try the next colour pCol = (IndexedColour *) pIndexedColours->GetNext(pCol); } // Iterate over the document's list of unnamed IndexedColours... List *pUnnamedColours = pIndexedColours->GetUnnamedColours(); pCol = (IndexedColour *) pUnnamedColours->GetHead(); ok = TRUE; while (ok && pCol != NULL) { if (!pCol->IsDeleted() && pCol->IsInUse()) { // The colour is in use and is not deleted // - save it to the file. ok = SaveColourAndParents(pCol, pFilter, 0); } // Try the next colour pCol = (IndexedColour *) pUnnamedColours->GetNext(pCol); } } #endif return TRUE; }

BOOL ColourListComponent::EndImport (  BaseCamelotFilter *  pFilter, BOOL  Success )  [virtual]

Inform the colour list document component that a Native or Web import has just finished. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/96 Parameters: pFilter  - the BaseCamelotFilter filter that is being used to import a file. [INPUTS] Success - TRUE => The import was successful; FALSE => The import failed - abandon any changes. Returns: TRUE if the component was able to end the importing; FALSE if not (e.g. out of memory) See also: DocComponent Reimplemented from DocComponent. Definition at line 423 of file colcomp.cpp. { TRACEUSER( "Neville", _T("ColourListComponent::EndImport\n") ); if (pFilter == NULL) { ERROR3("ColourListComponent::EndImport filter is null!"); return TRUE; } // If we didn't even get to initialise, then return quietly. if (pNewColours == NULL) { ERROR3("ColourListComponent::EndImport pNewColours is null!"); return TRUE; } // Import is finished, so add any outstanding colours to the document (if the // import was successful), and delete the colour table if (Success) { // Try and sort the imported colour list by the entry number that was saved // in the colour definition on export. This was the colour's position in // the indexed colour list. pNewColours->SortColoursByEntryNumber(); // Adds the colours to the system, with undo pNewColours->AddColoursToDocument(); } else { // Import failed - destroy all the colours. pNewColours->DestroyColours(); } // Finally, delete the IndexedColour table. delete pNewColours; pNewColours = NULL; // Null our link to the BaseCamelotFilter pCamFilter = NULL; // Set our variable so that we warn about a possible replacement only once WarnedBefore = FALSE; return TRUE; }

void ColourListComponent::EndOfEPSComment (  EPSFilter *  pFilter  )  [virtual]

Informs the document component that the comment it has been decoding has now finished, and it should take whatever action required to act on the comment. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/94 Parameters: pFilter  - the EPS filter that is being used to import a file. [INPUTS] See also: DocComponent::EndOfPESComment Reimplemented from DocComponent. Definition at line 3428 of file colcomp.cpp. { // Do any cleanup we need to here after loading in a colour table... }

void ColourListComponent::EPSEndImport (  EPSFilter *  pFilter, BOOL  Success )  [virtual]

Inform the colour list document component that an EPS import has just finished. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 03/08/94 Parameters: pFilter  - the EPS filter that is being used to import a file. [INPUTS] Success - TRUE => The import was successful; FALSE => The import failed - abandon any changes. See also: DocComponent Reimplemented from DocComponent. Definition at line 2159 of file colcomp.cpp. { ERROR3IF(pNewColours == NULL, "No colour table in EndEPSImport"); // If we didn't even get to initialise, then return quietly. if (pNewColours == NULL) return; // Import is finished, so add any outstanding colours to the document (if the // import was successful), and delete the colour table if (Success) { pNewColours->AddColoursToDocument(); } else { // Import failed - destroy all the colours. pNewColours->DestroyColours(); } // Finally, delete the IndexedColour table. delete pNewColours; pNewColours = NULL; }

BOOL ColourListComponent::EPSStartImport (  EPSFilter *  pFilter  )  [virtual]

Inform the colour list document component that an EPS import is about to start. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 03/08/94 Parameters: pFilter  - the EPS filter that is being used to import a file. [INPUTS] See also: DocComponent Reimplemented from DocComponent. Definition at line 2125 of file colcomp.cpp. { // Is this a Camelot EPS filter? BOOL CamelotEPS = pFilter->IS_KIND_OF(CamelotEPSFilter); // Get a colour table (and don't do strict checking if we are loading Camelot EPS). pNewColours = new ImportedColours(this, !CamelotEPS); if ((pNewColours == NULL) || !pNewColours->Init()) return FALSE; // We keep a record of how nested we are with respect to linking colours, e.g. // links of links of links. // A nesting of 0 is no nesting. LinkNesting = 0; // Must have worked return TRUE; }

IndexedColour * ColourListComponent::ExactMatchExists (  IndexedColour *  SourceColour  )

Determine if a colour is already available in the paste-destination document This allows us to merge IndexedColours on the clipboard with those in the target document when doing a paste operation. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 18/10/94 Parameters: SourceColour  - The colour to match [INPUTS] Returns: A pointer to the IndexedColour in this document which exactly matches the given SourceColour, or NULL if no matching colour exists. Notes: Exact match means: Another non-deleted colour which is not IsDifferent and which has an identical (sortof - see below) name string. SPECIAL behaviour: The name string match now ignores digits on the end of the string. This is so that if you copy and paste "Red" such that the pasted colour is "Red 2", a subsequent paste will match the source "Red" and the destination "Red 2", rather than adding an identical "Red 3"! Unnamed colours will never match. See also: ColourListComponent::CopyColourAcross Definition at line 3665 of file colcomp.cpp. { // If it's an unnamed (local) colour, then we don't bother looking for a match if (!SourceColour->IsNamed()) return(NULL); IndexedColour *pItem = (IndexedColour *) pIndexedColours->GetHead(); // --- First check for any *exact* matches // Get the name/ID for this colour. TRUE is passed in so that unnamed colours return // their unique id string rather than "Local colour" (hmmm... we aren't checking // unnamed colours, so this is a bit of a moot point! ;-) String_64 SourceName = *(SourceColour->GetName(TRUE)); while (pItem != NULL) { if (!pItem->IsDeleted() && !pItem->IsDifferent(*SourceColour)) // not different, so check name { if (SourceName.CompareTo(*pItem->GetName(TRUE)) == 0) // If has same name then... return(pItem); // Return it as match } // Try the next colour pItem = (IndexedColour *) pIndexedColours->GetNext(pItem); } // --- Second, check for near-matches. // This is an exact match except it ignores the space and digits appended to a name // in the quest for a unique name. This means if the name "Red" is in use, and we paste // a different colour called "Red" it will add "Red 2" the first paste, but subsequent // pastes will match "Red 2" and simply merge with that colour (rather than adding Red 2 // Red 3, Red 4, ect ad infinitum!) pItem = (IndexedColour *) pIndexedColours->GetHead(); while (pItem != NULL) { if (!pItem->IsDeleted() && !pItem->IsDifferent(*SourceColour)) // not different, so check name { // Get the string as a TCHAR array so we can actually do something with it (grr) TCHAR *StrPtr = (TCHAR *) (*pItem->GetName(TRUE)); // Find the zero terminator INT32 Index = 0; while (StrPtr[Index] != (TCHAR)'\0') Index++; // Now make index point at the last character Index -= 1; if (Index > 0) { if (UnicodeManager::IsDBCSLeadByte(StrPtr[Index-1])) Index -= 1; } // Scan backwards, skipping all digits that we find INT32 EndIndex = Index; while (Index > 0) { if (!StringBase::IsNumeric(StrPtr[Index])) break; Index -= 1; if (Index > 0) { if (UnicodeManager::IsDBCSLeadByte(StrPtr[Index-1])) Index -= 1; } } // Now, if we found digits, scan back over this char if it is a space if (Index > 0 && Index < EndIndex && StrPtr[Index] == (TCHAR)' ') { // Rightoh. This looks like an auto-generated unique-name, so does the text // without the unique-ness number match our name? String_64 ToCheck; pItem->GetName(TRUE)->Left(&ToCheck, Index); if (SourceName.CompareTo(ToCheck) == 0) return(pItem); // Yep - the names match } } // Try the next colour pItem = (IndexedColour *) pIndexedColours->GetNext(pItem); } // No match was found for this colour return(NULL); }

INT32 ColourListComponent::ExtendTables (  void   )  [private]

Called by Component Copy routines to extend the size of the copy mapping tables (SourceColours[], DestColours[], and MergeColours[]). This returns the index of the first free entry in the new tables, or -1 if it fails. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 (Separated from CopyColourAcross) Parameters: -  [INPUTS] (The  mapping arrays may have been moved by realloc) [OUTPUTS] Returns: -1 if it fails (it will have already reported the error else the index of the first free entry in the mapping tables Errors: Memory errors are reported immediately See also: ColourListComponent::StartComponentCopy; ColourListComponent::AbortComponentCopy; ColourListComponent::EndComponentCopy Definition at line 4050 of file colcomp.cpp. { INT32 i = ColourTableSize; // Set the index to the first new array entry ColourTableSize += 64; // Increase the size of our mapping arrays IndexedColour **TempArray; // Realloc the Source array, with error handling TempArray = (IndexedColour **) CCRealloc(SourceColours, ColourTableSize * sizeof(IndexedColour *)); if (TempArray == NULL) { InformError(); return(-1); } SourceColours = TempArray; // Realloc succeeded - set the new SourceColour ptr // Realloc the Dest array, with error handling TempArray = (IndexedColour **) CCRealloc(DestColours, (ColourTableSize+1) * sizeof(IndexedColour *)); if (TempArray == NULL) { InformError(); return(-1); } DestColours = TempArray; // Realloc succeeded - set the new DestColour ptr // Realloc the 'Merged'-flag array, with error handling BOOL *TempBoolArray = (BOOL *) CCRealloc(MergeColours, ColourTableSize * sizeof(BOOL)); if (TempBoolArray == NULL) { InformError(); return(-1); } MergeColours = TempBoolArray; // Realloc succeeded - set the new MergeColour ptr // Initialise the new portions of the arrays for (INT32 j = i; j < ColourTableSize; j++) { SourceColours[j] = DestColours[j] = NULL; MergeColours[j] = FALSE; } DestColours[ColourTableSize] = NULL; // And add a NULL terminator to dest. list return(i); }

INT32 ColourListComponent::ExtractString (  PCTSTR  Comment, INT32  Start, PTSTR  String )  [private]

Copy a PostScript string out of the given EPS comment. It handles nested parentheses - e.g. a string like (Hello (there)) will be correctly returned in String as "Hello (there)". The end of the comment is also taken as terminating the string. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 07/08/94 Parameters: Comment  - pointer to the comment. [INPUTS] Start - offset into Comment of the first character of the string (not including the first opening parenthesis). String  - the PostScript string. [OUTPUTS] Returns: The offset to the first character after the closing parenthesis of the string. Definition at line 3070 of file colcomp.cpp. { // INT32 i = Start; // INT32 j = 0; // INT32 StringNesting = 1; // Look for the last closing Parenthesis in this string... const TCHAR *End = camStrrchr(Comment, ')'); if ((End == NULL) || (End < (Comment + Start))) { // Something's gone wrong - don't extract string and put a warning where the colour name // should be. camStrcpy( String, _T("Colour Import Error") ); return Start; } // Copy the colour name from the comment into the string provided, and NULL // terminate it. INT32 NameLength = End - Comment; NameLength -= Start; camStrncpy( String, Comment + Start, NameLength ); String[NameLength] = 0; // Return the next character position after the string's closing parenthesis. return Start + NameLength + 1; }

BOOL ColourListComponent::FindIdenticalColour (  IndexedColour *  pColour, IndexedColour **  pResult )  [private]

Find out if there is already a colour exactly the same as the one passed in in the existing colour list. If so, return a pointer to it, otherwise return NULL. Also indicates whether or not a colour with this name already exists in the document, regardless of whether the colour data is the same. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 07/08/94 Parameters: pColour  - the colour to match with. [INPUTS] pResult  - pointer to the matching colour, if found; [OUTPUTS] NULL otherwise. Returns: TRUE if a colour with this *name* was found in the document; FALSE if not. Definition at line 3570 of file colcomp.cpp. { IndexedColour *pItem = (IndexedColour *) pIndexedColours->GetHead(); BOOL FoundSameName = FALSE; // Get the name/ID for this colour. TRUE is passed in so that unnamed colours return // their unique id string rather than "Local colour" String_64 *Name1 = pColour->GetName(TRUE); while (pItem != NULL) { // Don't bother with deleted colours if (!pItem->IsDeleted()) { // WEBSTER - markn 14/2/97 // Introduced WEBSTER_IGNORE_NAME_MATCHING so that Webster can ignore the name when // trying to find an identical colour #if WEBSTER_IGNORE_NAME_MATCHING if (pIndexedColours != NULL) { if (!pItem->IsDifferent(*pColour, COL_ACCURACY)) { if (ColourSGallery::CanAddColourToGallery(pItem,pIndexedColours)) { *pResult = pItem; return TRUE; } } } #else // Compare names String_64 *Name2 = pItem->GetName(TRUE); if ((*Name1) == (*Name2)) { FoundSameName = TRUE; // Name is the same - what about colour model + definition? if (!pItem->IsDifferent(*pColour, COL_ACCURACY)) { // The colour defn the same too - it's a match *pResult = pItem; return TRUE; } } #endif // WEBSTER_IGNORE_NAME_MATCHING } // Try the next colour pItem = (IndexedColour *) pIndexedColours->GetNext(pItem); } // No match - tell caller whether we found one with the same name. *pResult = NULL; return FoundSameName; }

IndexedColour * ColourListComponent::FindNamedColour (  PCTSTR  pName, DocColour *  ColDef = NULL, UINT32  Tint = 100, BOOL  Strict = FALSE )

Given the name of an imported named colour, return the relevant indexed colour. This allows attributes to be added when importing that use named colours. If ColDef is not NULL, then the Indexed colour found is checked to see if it agrees with the definition in ColDef - if not, then a new indexed colour is made, and a pointer to that is returned instead. This means we can cope with brain-damaged formats that have two or more named colours with the same format. It also makes it easy to cope with formats that use unnamed colours, as we just keep making colours called "Unnamed colour" or similar, and this function works it all out for us. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 04/08/94 Parameters: pName  - the name of the colour to find. [INPUTS] ColDef - the colour definition that it should match. Tint - the tint value applied to ColDef (NB it should already have been applied); 100 = same colour, 0 = white. Strict - not used (obsolete) Returns: Pointer to the indexed colour that corresponds to the file's named colour; or NULL if the colour could not be found (the caller should fall back to an immediate colour in this case). If the named colour is not found, and ColDef is not NULL, then again a new Indexed colour is created, and a pointer to it is returned. NB. The name of the indexed colour returned MAY NOT have the same name as specified in pName, because it may clash with colours already in the document, and hence may have been mangled to make it unambiguous. Definition at line 3474 of file colcomp.cpp. { // Sanity check ENSURE(pNewColours != NULL, "Someone asked for an imported colour when there is no import going on!"); if (pNewColours == NULL) return NULL; // Special case for tinted colours - if the Tint is not 100%, then we must look for // or create a tinted version of the colour. if (Tint != 100) { // Create a new name to indicate this is tinted String_64 NewName(pName); // Work out where to add the tint comment to the colour name. // Comment is of the form: " (xx% tint)", which is 11 characters long. INT32 Len = NewName.Length(); if (Len > 50) { // This should give us enough room for our tint comment Len = 50; } TCHAR *pNewName = (TCHAR *)NewName; camSnprintf( pNewName + Len, 64 - Len, _T(" (%d%% tint)"), Tint ); // Ok - we have a name - recurse so we can get a new colour (or use an existing // one created by this bit of code). return FindNamedColour(NewName, ColDef); } // Find the colour in the imported colour table. IndexedColour *pColour; PColourCMYK CMYK; ColDef->GetCMYKValue(&CMYK); pColour = pNewColours->GetColour( pName, &CMYK ); // Is there one that fits the bill? if (pColour != NULL) return pColour; // Colour not found - can we make a new one? if (ColDef != NULL) { // Yes - add a new colour... // Make a proper definition: ColourCMYK FullCMYK; FullCMYK.Cyan = FIXED24( ((double) CMYK.Cyan) / 255.0 ); FullCMYK.Magenta = FIXED24( ((double) CMYK.Magenta) / 255.0 ); FullCMYK.Yellow = FIXED24( ((double) CMYK.Yellow) / 255.0 ); FullCMYK.Key = FIXED24( ((double) CMYK.Key) / 255.0 ); // And use it to add the colour String_64 NewName(pName); if (pNewColours->AddColour(&NewName, &FullCMYK)) { // It worked - return the colour created return pNewColours->GetColour( pName, &CMYK ); } else { // Failed to add a new colour return NULL; } } // Can't make a new one without a colour definition - give up. return NULL; }

ColourList* ColourListComponent::GetColourList (   )  [inline]

Definition at line 186 of file colcomp.h. { return pIndexedColours; }

BOOL ColourListComponent::GetDocColour (  INT32  ColourRef, DocColour *  pDocColour )

Try and convert a colour reference i.e. record number into a previously imported colour definition which should now be an indexed colour in the document. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 30/5/96 Parameters: ColourRef  - The colour reference or record number that the record handler has loaded [INPUTS] from the record. pDocColour  - A pointer to return the required doc colour in [OUTPUTS] Returns: TRUE if the colour reference was succesfully converted into a DocColour; FALSE if not (e.g. out of memory) See also: ColourRecordHandler; Definition at line 486 of file colcomp.cpp. { ERROR2IF(pDocColour == NULL,FALSE,"ColourListComponent::GetDocColour NULL pCXFileRec"); ERROR2IF(pNewColours == NULL,FALSE,"ColourListComponent::ImportSimpleColour NULL pNewColours"); //TRACEUSER( "Neville", _T("GetDocColour for ref %d\n"), ColourRef); // First check to see if the colour refers to any of the built in colours. // These will have negative record numbers if (ColourRef < 0) { // At present, we only use the one colour reference StockColour defaultcolour = COLOUR_NONE; switch (ColourRef) { case REF_DEFAULTCOLOUR_TRANSPARENT: defaultcolour = COLOUR_TRANS; break; case REF_DEFAULTCOLOUR_BLACK: defaultcolour = COLOUR_BLACK; break; case REF_DEFAULTCOLOUR_WHITE: defaultcolour = COLOUR_WHITE; break; case REF_DEFAULTCOLOUR_RED: defaultcolour = COLOUR_RED; break; case REF_DEFAULTCOLOUR_GREEN: defaultcolour = COLOUR_GREEN; break; case REF_DEFAULTCOLOUR_BLUE: defaultcolour = COLOUR_BLUE; break; case REF_DEFAULTCOLOUR_CYAN: defaultcolour = COLOUR_CYAN; break; case REF_DEFAULTCOLOUR_MAGENTA: defaultcolour = COLOUR_MAGENTA; break; case REF_DEFAULTCOLOUR_YELLOW: defaultcolour = COLOUR_YELLOW; break; default: { defaultcolour = REPLACEMENTCOLOUR; // It is an unknown default colour reference // We will warn the user and use a replacement colour instead // If we have a pFilter then ask the default warning handle to append our message if (pCamFilter) { if (!WarnedBefore) { pCamFilter->AppendWarning(_R(IDS_NATIVE_COLOURWARNING)); WarnedBefore = TRUE; } } else ERROR2(FALSE,"ColourListComponent::GetDocColour negative ColourRef is unknown"); break; } } // Make ourselves the required colour DocColour * pReplacementCol = new DocColour(defaultcolour); // Make the return colour this *pDocColour = *pReplacementCol; // And now delete that temp replacement colour delete pReplacementCol; } else { // In case of early exit set the return DocColour pointer to NULL, i.e. nothing found //*pDocColour = NULL; // Try and find the specified record number in our colour list IndexedColour *pCol = pNewColours->GetColour(ColourRef); // If not found then this is a problem as a colour must have been defined before its being // referenced // We will warn the user and use a replacement colour instead if (pCol == NULL) { // If we have a pFilter then ask the default warning handle to append our message if (pCamFilter) { if (!WarnedBefore) { pCamFilter->AppendWarning(_R(IDS_NATIVE_COLOURWARNING)); WarnedBefore = TRUE; } // Make ourselves a colour to use instead DocColour * pReplacementCol = new DocColour(REPLACEMENTCOLOUR); // Make the return colour this *pDocColour = *pReplacementCol; // And now delete that temp replacement colour delete pReplacementCol; } else ERROR2(FALSE,"ColourListComponent::GetDocColour ColourRef cannot be found"); } else { // Make the specified DocColour referencing this IndexedColour. pDocColour->MakeRefToIndexedColour(pCol); } } return TRUE; }

INT32 ColourListComponent::GetIndexColourNumber (  IndexedColour *  pCol  )  [private]

Work out the index of this colour in the list of indexed colours so that we can try and load back the colours in the same order. Unfortunately, the only way it seems that we can work out this number is by counting back to the start of the indexed colour list. Doh! Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/96 Parameters: pCol  - the indexed colour to search out the number for. [INPUTS] Returns: The number of this indexed colour in the list of colours (i.e.position) See also: IndexedColour Definition at line 2079 of file colcomp.cpp. { ERROR2IF(pCol==NULL,0,"ColourListComponent::GetIndexColourNumber no Colour pointer"); ERROR2IF(pIndexedColours==NULL,0,"ColourListComponent::GetIndexColourNumber no pIndexedColours"); INT32 number = 0; // Due to pants list class, we need to check that there is a previous memember before we // call GetPrev, otherwise it ensures all over the place. Why it can't just return NULL! if (pIndexedColours->IsEmpty()) return number; // Go from this item to the start of the inddexed colour list, counting items as we go while (pCol) { pCol = (IndexedColour *) pIndexedColours->GetPrev(pCol); // If the colour is not deleted then count it if (pCol && !pCol->IsDeleted()) number ++; } return number; }

IndexedColour * ColourListComponent::GetIndexedParentOfColour (  DocColour  Colour  )  [private]

It is possible for us to create doccolours from indexed colours and then convert them so that they are standalone. This method goes through all the indexed colours to try and find out which indexed colour (if any) originally created the input. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/2000 Parameters: Colour  - the doccolour that was originally created from an indexed colour [INPUTS] -  [OUTPUTS] Returns: the indexed colour that originally created Colour, if there is one, else NULL Definition at line 4349 of file colcomp.cpp. { ColourList* pList = GetColourList(); if (pList == NULL) return NULL; ColourGeneric ColDef; ColourContext *cc = ColourManager::GetColourContext(Colour.GetColourModel()); ERROR2IF(cc == NULL, NULL, "Can't find colour context?!"); DocColour ConvertedDocCol; IndexedColour* pItem = (IndexedColour*)pList->GetHead(); // what we have to do is get each indexed colour as a standalone definition then // ask it to make a doccolour. If this is the same as our input then we have our match while (pItem != NULL) { // Get the IndexedColour definition as a standalone colour definition cc->ConvertColour(pItem, &ColDef); // Make the DocColour into a simple standalone "lookalike" of the parent colour ConvertedDocCol = DocColour(Colour.GetColourModel(), &ColDef); // now test to see if its the same, if so we've got what we want if (ConvertedDocCol == Colour) break; pItem = (IndexedColour*)pList->GetNext(pItem); } return pItem; }

INT32 ColourListComponent::GetWriteColourReference (  DocColour *  pDocColour, BaseCamelotFilter *  pFilter )

Return the colour reference to the caller, who will then use it to write the colour in the record that they are preparing to save to a Web or Native file. In the process of getting the colour reference, the colour definition record for the colour reference will be generated and saved to the file. In Web format this will just be the simple colour record, in native files this will be the full colour definition, possibly preceeded by the parents for the colour, as these must be saved before the children as the children must have a valid colour reference. NOTE: As this does save information into the record stream, it *MUST* be called before the caller has called StartRecord() as otherwise the records will become intertwined! Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/5/96 Parameters: pDocCololour  - The document colour to save [INPUTS] pFilter - The filter to use for saving -  [OUTPUTS] Returns: The colour reference for the doccolour ready for writing in a record. This will be zero if a problem has occurred. May return -1 if it does not need to save anything i.e if the colour is not in use and not named. Errors: - See also: IndexedColour; SaveComplexColour; SaveSimpleColour; SaveColourAndParents; Definition at line 1303 of file colcomp.cpp. { #ifdef DO_EXPORT ERROR2IF(pDocColour == NULL,0L,"ColourListComponent::GetWriteColourReference null pDocColour"); ERROR2IF(pFilter == NULL,0L,"ColourListComponent::GetWriteColourReference null pFilter"); INT32 RecordNumber = 0L; // First, check to see if the doc colour is transparent. If so then just return the default // default reference for this if (pDocColour->IsTransparent()) return REF_DEFAULTCOLOUR_TRANSPARENT; // Get the indexed colour which this DocColour refers to, if any. IndexedColour * pCol = pDocColour->FindParentIndexedColour(); if (pCol) { // Its an indexed colour so either save it as a simple colour or a complex colour // depending on whether we are in Web or Native mode. if (pFilter->IsWebFilter()) { // We are in Web mode so save the simple colour RecordNumber = SaveSimpleColour(pCol, pFilter); } else { // We are in Web mode so save the simple colour RecordNumber = SaveColourAndParents(pCol, pFilter); } } else { // its a simple colour, so save this out as a simple colour. if (pFilter->IsWebFilter()) { // its a simple colour, so just save this as a simple colour. // We must add the RGB colours to our exported list, so that we only save the // definition out once. RecordNumber = SaveSimpleColour(pDocColour, pFilter, TRUE); } else { // TODO: // Could change this later to save out a complex colour in native files so that // these are converted to indexed colours on loading. Jason reckons this is favourable. // If we save it as a simple colour then there are bound to be conversion errors as // we are going from 24 bit components down to 8 bits and then back. // Find a global colour context to convert this colour into RGB for us. ColourContextRGBT *cc = (ColourContextRGBT *)ColourManager::GetColourContext(COLOURMODEL_RGBT); ERROR3IF(cc == NULL, "ColourListComponent::GetWriteColourReference No global RGB colour context!? Something is very broken"); if (cc == NULL) return 0L; // And convert the colour into a *packed* (8-bit components) colour structure PColourRGBT Result; cc->ConvertColour(pDocColour, (ColourPacked *)&Result); // Only write this record out if we have not done so already // Check by seeing if the colour is already in our exported colour list ExportColour* pExportCol = NULL; pExportCol = pExportedColours->GetColour(&Result); // If it is then do not save this colour if (pExportCol) { // Just return the record number as the colour reference to the caller RecordNumber = pExportCol->RecordNumber; } else { // Create ourselves a new indexed colour to put our data in // Use the DocColour we have been supplied with, this should create an unnamed colour by default IndexedColour *pNewCol = new IndexedColour(*pDocColour); if (pNewCol) { // DY 3/5/2000 Now that I am now using the Reserved flag to indicate whether or not a doccolour // was created from a named colour and then de-indexed. For details see LineDefinition::ConvertIndexedColours // This means that if we get a doccolour with that flag set it was originally created by an indexed colour, so // we can call our function to find the parent IndexedColour* pIndexedCol = NULL; if (pDocColour->IsNamed()) { // Diccon, this is a named colour that was originally generated from an indexed colour but // subsequently de-indexed for various reasons. Its original parent should be in the list // somewhere pIndexedCol = GetIndexedParentOfColour(*pDocColour); } else pNewCol->SetUnnamed(); // Now save out the colour data in a complex colour record out to file // We cannot ask the routine to add this colour to the exported list as it is // not a REAL indexed colour in the indexed colour list, so say False. if (pIndexedCol == NULL) RecordNumber = SaveComplexColour(pNewCol, pFilter, FALSE); else // if we found an indexed colour then save out normally - DY RecordNumber = SaveColourAndParents(pIndexedCol, pFilter); if (RecordNumber > 0) { // Add this colour to our list of exported items /*BOOL ok =*/ pExportedColours->AddColour(&Result, RecordNumber); // Should return this error to the caller but not fatal so just continue } // We have finished with our indexed colour and so remove it delete pNewCol; } else { // We failed to create the complex colour so we have no choice but to save // it as a simple colour. // We must add the RGB colours to our exported list, so that we only save the // definition out once. RecordNumber = SaveSimpleColour(pDocColour, pFilter, TRUE); } } } } return RecordNumber; #endif return 0L; }

BOOL ColourListComponent::ImportColourDefinition (  CXaraFileRecord *  pCXFileRec  )

Try and import a colour definition record into the document. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 28/5/96 Parameters: pCXFileRec  - The CXaraFileRecord that is being used to provide read functions etc. [INPUTS] Returns: TRUE if the record was succesfully imported; FALSE if not (e.g. out of memory) See also: ColourRecordHandler; Definition at line 657 of file colcomp.cpp. { ERROR2IF(pCXFileRec == NULL,FALSE,"ColourListComponent::ImportColourDefinition NULL pCXFileRec"); ERROR2IF(pNewColours == NULL,FALSE,"ColourListComponent::ImportColourDefinition NULL pNewColours"); // Check for special types (NB a colour cannot be both a spot colour and a linked colour). NewColourInfo ColourInfo; // BOOL Linked = FALSE; // Flag we are importing a web/native style colour and so use the specified parent and not // the context form. ColourInfo.RecordNumber = pCXFileRec->GetRecordNumber(); ColourInfo.WebNativeColour = TRUE; //IndexedColour *pParent = NULL; // Read in the simple RGB colour, which we won't need BYTE Red; BYTE Green; BYTE Blue; BOOL ok = pCXFileRec->ReadBYTE(&Red); if (ok) ok = pCXFileRec->ReadBYTE(&Green); if (ok) ok = pCXFileRec->ReadBYTE(&Blue); // read in the colour model ColourModel ColModel = COLOURMODEL_RGBT; BYTE temp; if (ok) ok = pCXFileRec->ReadBYTE(&temp); ColModel = (ColourModel)temp; // read in the colour type ExportColourType ColType = EXPORT_COLOURTYPE_NORMAL; if (ok) ok = pCXFileRec->ReadBYTE(&temp); ColType = (ExportColourType)temp; // read in the entry number that this colour should be in the list of colours UINT32 EntryNumber = 0; if (ok) ok = pCXFileRec->ReadUINT32(&EntryNumber); ColourInfo.EntryNumber = EntryNumber; // read in the record number of the parent colour UINT32 ParentColour = 0; if (ok) ok = pCXFileRec->ReadUINT32(&ParentColour); // Now convert this into a indexed colour pointer, if required if (ok && (ColType == EXPORT_COLOURTYPE_LINKED || ColType == EXPORT_COLOURTYPE_TINT || ColType == EXPORT_COLOURTYPE_SHADE)) { TRACEUSER( "Neville", _T("Trying to find parent reference %d\n"),ParentColour); ColourInfo.pParentCol = pNewColours->GetColour(ParentColour); if (ColourInfo.pParentCol == NULL) { TRACEUSER( "Neville", _T("Cannot convert parent colour reference %d into an IndexedColour\n"),ParentColour); ERROR2(FALSE,"Cannot find parent IndexedColour"); } } // Read in the four colour components UINT32 Comp1 = 0; if (ok) ok = pCXFileRec->ReadUINT32(&Comp1); UINT32 Comp2 = 0; if (ok) ok = pCXFileRec->ReadUINT32(&Comp2); UINT32 Comp3 = 0; if (ok) ok = pCXFileRec->ReadUINT32(&Comp3); UINT32 Comp4 = 0; if (ok) ok = pCXFileRec->ReadUINT32(&Comp4); String_64 ColName; if (ok) ok = pCXFileRec->ReadUnicode(&ColName);//, ColName.MaxLength()); if (ColName.Length() == 0 ) { // We are an unnamed colour and so make up a name based on the record number // This is so that all the existing import code can be reused. // Make the name unique by adding a text form of the record number TCHAR *pNewName = (TCHAR *)ColName; camSnprintf( pNewName, 64, _T("_%d"), ColourInfo.RecordNumber ); } TRACEUSER( "Neville", _T("ImportColourDefinition Name %s RecordNumber %d, EntryNumber %d\n"),(TCHAR*)ColName,ColourInfo.RecordNumber,EntryNumber); // We had a problem reading the colour definition so stop now if (!ok) return FALSE; // Read the colour components according to the colour model. switch (ColType) { case EXPORT_COLOURTYPE_NORMAL: // Set the correct colour type ColourInfo.Type = COLOURTYPE_NORMAL; // Fall through below case EXPORT_COLOURTYPE_SPOT: case EXPORT_COLOURTYPE_LINKED: // Set the correct colour type if (ColType == EXPORT_COLOURTYPE_SPOT) ColourInfo.Type = COLOURTYPE_SPOT; else if (ColType == EXPORT_COLOURTYPE_LINKED) ColourInfo.Type = COLOURTYPE_LINKED; // These all require the same handling // Linked colours save out the components in the normal fashion switch (ColModel) { case COLOURMODEL_RGBT: { ColourRGBT NewRGBT; ReadRGB(&NewRGBT, &ColourInfo, Comp1, Comp2, Comp3, Comp4); if (!pNewColours->AddColour(&ColName, &NewRGBT, &ColourInfo)) return FALSE; } break; case COLOURMODEL_CMYK: { ColourCMYK NewCMYK; ReadCMYK(&NewCMYK, &ColourInfo, Comp1, Comp2, Comp3, Comp4); if (!pNewColours->AddColour(&ColName, &NewCMYK, &ColourInfo)) return FALSE; } break; case COLOURMODEL_HSVT: { ColourHSVT NewHSVT; ReadHSV(&NewHSVT, &ColourInfo, Comp1, Comp2, Comp3, Comp4); if (!pNewColours->AddColour(&ColName, &NewHSVT, &ColourInfo)) return FALSE; } break; case COLOURMODEL_GREYT: { ColourGreyT NewGreyT; ReadGrey(&NewGreyT, &ColourInfo, Comp1); if (!pNewColours->AddColour(&ColName, &NewGreyT, &ColourInfo)) return FALSE; } break; default: ERROR3("ColourListComponent::ImportColourDefinition unknown colour model!"); break; } break; case EXPORT_COLOURTYPE_TINT: { // Set the correct colour type ColourInfo.Type = COLOURTYPE_TINT; // Read in the tint value from the colour definition record ReadTint(&ColourInfo, Comp1); // Now, try and add that to the system if (!pNewColours->AddTintOrShade(&ColName, &ColourInfo)) return FALSE; } break; case EXPORT_COLOURTYPE_SHADE: { // Set the correct colour type ColourInfo.Type = COLOURTYPE_TINT; // Read in the shade value from the colour definition record ReadShade(&ColourInfo, Comp1, Comp2); // Now, try and add that to the system if (!pNewColours->AddTintOrShade(&ColName, &ColourInfo)) return FALSE; } break; default: ERROR3("ColourListComponent::ImportColourDefinition unknown colourtype!"); break; } return ok; }

BOOL ColourListComponent::ImportSimpleColour (  CXaraFileRecord *  pCXFileRec  )

Try and import a simple RGB colour definition record into the document. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 30/5/96 Parameters: pCXFileRec  - The CXaraFileRecord that is being used to provide read functions etc. [INPUTS] Returns: TRUE if the record was succesfully imported; FALSE if not (e.g. out of memory) See also: ColourRecordHandler; Definition at line 610 of file colcomp.cpp. { ERROR2IF(pCXFileRec == NULL,FALSE,"ColourListComponent::ImportSimpleColour NULL pCXFileRec"); ERROR2IF(pNewColours == NULL,FALSE,"ColourListComponent::ImportSimpleColour NULL pNewColours"); //TRACEUSER( "Neville", _T("ImportSimpleColour\n")); // Read in the simple RGB colour BYTE Red; BYTE Green; BYTE Blue; BOOL ok = pCXFileRec->ReadBYTE(&Red); if (ok) ok = pCXFileRec->ReadBYTE(&Green); if (ok) ok = pCXFileRec->ReadBYTE(&Blue); NewColourInfo ColourInfo; // Flag we are importing a web/native style colour and so use the specified parent and not // the context form. ColourInfo.RecordNumber = pCXFileRec->GetRecordNumber(); ColourInfo.WebNativeColour = TRUE; ColourRGBT NewRGBT; String_64 ColName; //(TEXT("_")); // Make the name unique by adding a text form of the record number TCHAR *pNewName = (TCHAR *)ColName; camSnprintf( pNewName, 64, _T("_%d"), ColourInfo.RecordNumber ); NewRGBT.Red = (double)((double)Red/256.0); NewRGBT.Green = (double)((double)Green/256.0); NewRGBT.Blue = (double)((double)Blue/256.0); if (ok) ok = pNewColours->AddColour(&ColName, &NewRGBT, &ColourInfo); return ok; }

IndexedColour * ColourListComponent::MapColour (  IndexedColour *  SourceColour, BOOL *  AlreadyThere = NULL, BOOL  SourceIsUnique = FALSE )  [private]

Used internally in ColourListComponent Component Copy routines. This method keeps track of mappings between source document and destination document colours. It determines the mapping from source to dest, and returns the appropriate destination-docuemnt IndexedColour. This may be a new colour which will later be added to the destination document or a colour already in the dest. doc (merged colour). Once an IndexedColour is mapped, future calls to this method will be very efficient (a simple table search and lookup of the previous mapping). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 29/10/94 Parameters: SourceColour  - pointer to an IndexedColour to map [INPUTS] (AlreadyThere is an output only) SourceIsUnique - FALSE (the default) if you're copying existing document colours around, and therefore could attempt to copy the same colour multiple times. TRUE if you can guarantee that this colour will only be copied once. This is used only for copying library colours into a document in the colour gallery (where it uses a temporary IndexedColour, which causes problems when several different colours accidentally map to the same temporary memory allocation, thus causing rampant incorrect colour merging to occur). Parameters: AlreadyThere  - (if non-NULL) is filled in with TRUE if the colour was merged [OUTPUTS] or FALSE if a new colour had to be created. Returns: NULL if it fails (the error will have been reported) Otherwise, a pointer to the IndexedColour resulting from the mapping Notes: This method is recursive. This allows it to cope with a chain of parent tint/link colours which may or may not be mapped already. Special care is taken to ensure that only destination-document references are left at the end of the copy operation (as obviously, references to the source doc are highly dangerous, and usually fatal) See also: ColourListComponent::StartComponentCopy; ColourListComponent::AbortComponentCopy; ColourListComponent::EndComponentCopy Definition at line 4155 of file colcomp.cpp. { if (AlreadyThere != NULL) // Set a safe return value *AlreadyThere = FALSE; // First, check if the colour is already mapped; if so, just return its mapping // If SourceIsUnique, then we know no two source colours will never be the same, // and to fix a temporary-colour-reuse (2 colours in the same memory location) // problem in colour gallery library colour copies, we don't cache the mappings. // This is fine, because those copies only copy each colour once, so there is // no need to cache mappings for them anyway. if (!SourceIsUnique) { INT32 i = 0; while (i < ColourTableSize && SourceColours[i] != NULL && SourceColours[i] != SourceColour) i++; if (i < ColourTableSize && SourceColours[i] == SourceColour) { // If it was merged, return a value indicating that case if (AlreadyThere != NULL && MergeColours[i]) *AlreadyThere = TRUE; return(DestColours[i]); } } // Next, copy the colour being mapped IndexedColour *DestColour = new IndexedColour(*SourceColour); if (DestColour == NULL) return(NULL); // Now ensure our parent/ancestors are mapped, ... IndexedColour *SourceParent = SourceColour->FindLinkedParent(); IndexedColour *DestParent = NULL; if (SourceParent != NULL) { DestParent = MapColour(SourceParent); if (DestParent == NULL) { delete DestColour; return(NULL); } } // ... and set the copied colour's parent to the mapped (dest doc) parent, rather than // the source doc version of the parent. // Note that if this is not a tint/linked colour, this has the side effect of ensuring // that Parent is NULL, rather than referencing a parent in a different document DestColour->SetLinkedParent(DestParent, DestColour->GetType()); // Finally, map ourselves... // Find a blank entry in the mapping tables INT32 i = 0; while (i < ColourTableSize && SourceColours[i] != NULL) i++; if (i >= ColourTableSize) // If no free entries, extend them and get first free entry i = ExtendTables(); if (i < 0) // We failed - no memory for tables { delete DestColour; return(NULL); } // Check if there is already a matching colour in the dest. document. // If there is one, then chuck away DestColour, and use the matching colour instead IndexedColour *MatchColour = ExactMatchExists(DestColour); if (MatchColour != NULL) { delete DestColour; DestColour = MatchColour; if (AlreadyThere != NULL) // And return info to indicate that the colour is merged *AlreadyThere = TRUE; } // And finally, write the new entry into the mapping tables // (but only if we need to cache the mappings - NOTE that we need to store a // mapping (at least to the extent of having a destination part of the mapping) // or the new colours won't be added in EndComponentCopy. Unfortunately this // means we need a source mapping that isn't NULL or it all falls apart. if (SourceIsUnique) SourceColours[i] = (IndexedColour *) 1; // Yeek! Have to stop this being null else SourceColours[i] = SourceColour; DestColours[i] = DestColour; MergeColours[i] = (MatchColour != NULL); return(DestColour); // And return the result of the mapping operation return NULL; }

ProcessEPSResult ColourListComponent::ProcessEPSComment (  EPSFilter *  pFilter, PCTSTR  pComment )  [virtual]

Process an EPS comment - if this is a colour table comment, this component will claim it and try to decode it. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/94 Parameters: pFilter  - the EPS filter that is being used to import a file. [INPUTS] pComment - pointer to the comment to process. Returns: EPSCommentUnknown - This EPS comment is not recognised by the document component. EPSCommentError - This EPS comment was recognised by this document component, but it contained an error. EPSCommentOK - This EPS comment was recognised as a legal comment by this document component, and was processed successfully. Notes: IMPORTANT There is a new colour field (which should only be put in a JWColourTable in CamelotEPS) which starts a comment line with "%%+x". The remainder of the line is undefined, but is treated as a valid line. This will make it possible to add data to the colour list in future without losing backward compatability or having to add yet another colour table type! If you use this, make sure your code happily *ignores* unknown x extensions. Returns: Errors: Badly formed EPS comment. See also: DocComponent::ProcessEPSComment Definition at line 2823 of file colcomp.cpp. { if (pFilter->IsKindOf(CC_RUNTIME_CLASS(ArtWorksEPSFilter))) { // Is it a Camelot specific filter? BOOL CamelotEPS = pFilter->IsKindOf(CC_RUNTIME_CLASS(CamelotEPSFilter)); // ArtWorks EPS (or derivative) if (camStrncmp(pComment, _T("%%AWColourTable"), 15) == 0) { // Found a colour table return EPSCommentOK; } else if (camStrncmp(pComment, _T("%%JWColourTable"), 15) == 0) { // Found a version 1.1 extended colour table return EPSCommentOK; } else if (camStrncmp(pComment, _T("%%+"), 3) == 0) { // Found a colour - add it to the colour list for the document. // Take a copy of this comment TCHAR Comment[256]; camStrcpy(Comment, pComment); // Find out the colour model (c, h, r, or t) INT32 i = 3; TCHAR ColModel = Comment[i++]; // Check for special types (NB a colour cannot be both a spot colour and // a linked colour). NewColourInfo ColourInfo; BOOL Linked = FALSE; // Is it a spot colour? if (ColModel == 's') { ColourInfo.Type = COLOURTYPE_SPOT; ColModel = Comment[i++]; } else if (ColModel == 'l') { // It's a link, then find out the colour model of the linked colour. Linked = TRUE; ColourInfo.Type = COLOURTYPE_LINKED; ColModel = Comment[i++]; } // If a tint/shade or link, find the nesting level, if any INT32 ColourNesting = 0; if ((ColModel == 't') || (ColModel == 'd') || Linked) { // Skip until we find a digit, a '(' or a terminator while (!isdigit(Comment[i]) && (Comment[i] != '(') && (Comment[i] != 0)) i++; // Is there a nesting level? if (isdigit(Comment[i])) { // Yes - extract it and skip past it. ColourNesting = camAtol(Comment+i); while (isdigit(Comment[i])) i++; } else { // Must be level 1 ColourNesting = 1; } } // Do we need to alter the link context? if (ColourNesting == 0) { // Normal colour pNewColours->RestoreContextTo(0); } else if (ColourNesting <= LinkNesting) { // Falling back to a previous nesting level - restore context to one // less than the nesting of this link/tint // (because we want to link/tint the colour one level below this one // in the nesting). LinkNesting = ColourNesting - 1; pNewColours->RestoreContextTo(LinkNesting); } // Find the colour name while ((Comment[i] != '(') && (Comment[i] != 0)) i++; // Got it - copy it out of the string (skip the opening parenthesis) TCHAR ColName[128]; i = ExtractString(Comment, i+1, ColName); String_64 ColNameS = ColName; // Copied the name - skip any whitespace while (((Comment[i] == ' ') || (Comment[i] == '\t')) && (Comment[i] != 0)) { i++; } // Check for the overprint flag if (Comment[i] == 'o') { // Ignore it for now... i++; while (((Comment[i] == ' ') || (Comment[i] == '\t')) && (Comment[i] != 0)) { i++; } } // Validate the colour model for this filter. if ((ColModel != 'r') && (ColModel != 'c') && // Rgb, Cmyk (ColModel != 'h') && (ColModel != 't')) // Hsv, Tint { // Reject outright if this is an ArtWorks file if (!CamelotEPS) { pFilter->HandleEPSError(); return EPSCommentSyntaxError; } } // Do we need to save the context before adding this colour? if (Linked || (ColModel == 't') || (ColModel == 'd')) { pNewColours->SaveContext(); LinkNesting++; } // Read the colour components according to the colour model. switch (ColModel) { case 'r': case 'R': { ColourRGBT NewRGBT; ReadEPS_RGB(&NewRGBT, Comment + i, &ColourInfo); if (!pNewColours->AddColour(&ColNameS, &NewRGBT, &ColourInfo)) return EPSCommentSystemError; } break; case 'c': { ColourCMYK NewCMYK; ReadEPS_CMYK(&NewCMYK, Comment + i, &ColourInfo); if (!pNewColours->AddColour(&ColNameS, &NewCMYK, &ColourInfo)) return EPSCommentSystemError; } break; case 'h': case 'H': { ColourHSVT NewHSVT; ReadEPS_HSV(&NewHSVT, Comment + i, &ColourInfo); if (!pNewColours->AddColour(&ColNameS, &NewHSVT, &ColourInfo)) return EPSCommentSystemError; } break; case 't': // Tint { UINT32 Tint = ReadEPS_Tint(Comment + i); if (!pNewColours->AddTint(&ColNameS, Tint)) return EPSCommentSystemError; } break; case 'd': // Shade - saved in same format as tint, so re-use ReadEPS_Tint method { INT32 ShadeX; INT32 ShadeY; ReadEPS_Shade(Comment + i, &ShadeX, &ShadeY); if (!pNewColours->AddShade(&ColNameS, ShadeX, ShadeY)) return EPSCommentSystemError; } break; case 'G': case 'g': { ColourGreyT NewGreyT; ReadEPS_Grey(&NewGreyT, Comment + i, &ColourInfo); // Bodge for version 2 // We really want black to be defined as CMYK so that it colour separates // more cleanly (and also merges on import better with new docs). Prior to v2, // the default black was defined as a greyscale so we sit on it during import // and turn it into a CMYK colour. if (NewGreyT.Intensity == 0 && ColNameS == String_64(TEXT("Black"))) { ColourCMYK Bodge; Bodge.Cyan = Bodge.Magenta = Bodge.Yellow = 0; Bodge.Key = 1.0; if (!pNewColours->AddColour(&ColNameS, &Bodge, &ColourInfo)) return EPSCommentSystemError; } else { if (!pNewColours->AddColour(&ColNameS, &NewGreyT, &ColourInfo)) return EPSCommentSystemError; } } break; } // Parsed this colour ok. return EPSCommentOK; } } // Ignore all other comments return EPSCommentUnknown; }

BOOL ColourListComponent::ReadCMYK (  ColourCMYK *  pCol, NewColourInfo *  pColourInfo, UINT32  Comp1, UINT32  Comp2, UINT32  Comp3, UINT32  Comp4 )  [private]

Read the CMYK values from a Camelot CMYK colour definition record. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/96 Parameters: pCol  - RGB colour data to fill in [INPUTS] pColourInfo - pointer to the colour info to fill in Comp1 .. 4 - colour components read in from the record The  data in the pCol and pColourInfo will have been filled in [OUTPUTS] Returns: True if value read ok, False otherwise. See also: ColourListComponent::ImportColourDefinition; Definition at line 906 of file colcomp.cpp. { ERROR2IF(pCol == NULL,FALSE,"ColourListComponent::ReadCMYK NULL pCol"); ERROR2IF(pColourInfo == NULL,FALSE,"ColourListComponent::ReadCMYK NULL pColourInfo"); BOOL Linked = (pColourInfo != NULL) && (pColourInfo->Type == COLOURTYPE_LINKED); // read the Cyan colour component in FIXED24 Value24 = 0.0; Value24.SetAsFixed24(Comp1); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[0] = TRUE; else pCol->Cyan = Value24; // read the Magenta colour component in Value24.SetAsFixed24(Comp2); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[1] = TRUE; else pCol->Magenta = Value24; // read the Yellow colour component in Value24.SetAsFixed24(Comp3); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[2] = TRUE; else pCol->Yellow = Value24; // read the Key colour component in Value24.SetAsFixed24(Comp4); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[3] = TRUE; else pCol->Key = Value24; return TRUE; }

void ColourListComponent::ReadEPS_CMYK (  ColourCMYK *  pCol, TCHAR *  pComment, NewColourInfo *  pColourInfo )  [private]

void ColourListComponent::ReadEPS_Grey (  ColourGreyT *  pCol, TCHAR *  pComment, NewColourInfo *  pColourInfo )  [private]

void ColourListComponent::ReadEPS_HSV (  ColourHSVT *  pCol, TCHAR *  pComment, NewColourInfo *  pColourInfo )  [private]

void ColourListComponent::ReadEPS_RGB (  ColourRGBT *  pCol, TCHAR *  pComment, NewColourInfo *  pColourInfo )  [private]

void ColourListComponent::ReadEPS_Shade (  TCHAR *  pComment, INT32 *  ResultX, INT32 *  ResultY )  [private]

UINT32 ColourListComponent::ReadEPS_Tint (  TCHAR *  pComment  )  [private]

BOOL ColourListComponent::ReadGrey (  ColourGreyT *  pCol, NewColourInfo *  pColourInfo, UINT32  Comp1 )  [private]

Read the Grey values from a Camelot Grey colour definition record. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/96 Parameters: pCol  - Grey colour data to fill in [INPUTS] pColourInfo - pointer to the colour info to fill in Comp1 - the first of the colour components read in from the record The  data in the pCol and pColourInfo will have been filled in [OUTPUTS] Returns: True if value read ok, False otherwise. See also: ColourListComponent::ImportColourDefinition; Definition at line 1015 of file colcomp.cpp. { ERROR2IF(pCol == NULL,FALSE,"ColourListComponent::ReadGrey NULL pCol"); ERROR2IF(pColourInfo == NULL,FALSE,"ColourListComponent::ReadGrey NULL pColourInfo"); BOOL Linked = (pColourInfo != NULL) && (pColourInfo->Type == COLOURTYPE_LINKED); // read the grey Intensity colour component in FIXED24 Value24 = 0.0; Value24.SetAsFixed24(Comp1); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[0] = TRUE; else pCol->Intensity = Value24; // Clear the reserved words to 0. pCol->Reserved1 = 0.0; pCol->Reserved2 = 0.0; // No transparency pCol->Transparent = 0.0; return TRUE; }

BOOL ColourListComponent::ReadHSV (  ColourHSVT *  pCol, NewColourInfo *  pColourInfo, UINT32  Comp1, UINT32  Comp2, UINT32  Comp3, UINT32  Comp4 )  [private]

Read the HSV values from a Camelot HSV colour definition record. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/96 Parameters: pCol  - HSVT colour data to fill in [INPUTS] pColourInfo - pointer to the colour info to fill in Comp1 .. 4 - colour components read in from the record The  data in the pCol and pColourInfo will have been filled in [OUTPUTS] Returns: True if value read ok, False otherwise. See also: ColourListComponent::ImportColourDefinition; Definition at line 963 of file colcomp.cpp. { ERROR2IF(pCol == NULL,FALSE,"ColourListComponent::ReadHSV NULL pCol"); ERROR2IF(pColourInfo == NULL,FALSE,"ColourListComponent::ReadHSV NULL pColourInfo"); BOOL Linked = (pColourInfo != NULL) && (pColourInfo->Type == COLOURTYPE_LINKED); // read the Hue colour component in FIXED24 Value24 = 0.0; Value24.SetAsFixed24(Comp1); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[0] = TRUE; else pCol->Hue = Value24; // read the Saturation colour component in Value24.SetAsFixed24(Comp2); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[1] = TRUE; else pCol->Saturation = Value24; // read the Value colour component in Value24.SetAsFixed24(Comp3); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[2] = TRUE; else pCol->Value = Value24; // No transparency pCol->Transparent = 0.0; return TRUE; }

BOOL ColourListComponent::ReadRGB (  ColourRGBT *  pCol, NewColourInfo *  pColourInfo, UINT32  Comp1, UINT32  Comp2, UINT32  Comp3, UINT32  Comp4 )  [private]

Read the RGB values from a Camelot RGB colour definition record. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/96 Parameters: pCol  - RGB colour data to fill in [INPUTS] pColourInfo - pointer to the colour info to fill in Comp1 .. 4 - colour components read in from the record The  data in the pCol and pColourInfo will have been filled in [OUTPUTS] Returns: True if value read ok, False otherwise. See also: ColourListComponent::ImportColourDefinition; Definition at line 853 of file colcomp.cpp. { ERROR2IF(pCol == NULL,FALSE,"ColourListComponent::ReadRGB NULL pCol"); ERROR2IF(pColourInfo == NULL,FALSE,"ColourListComponent::ReadRGB NULL pColourInfo"); BOOL Linked = (pColourInfo != NULL) && (pColourInfo->Type == COLOURTYPE_LINKED); // read the Red colour component in FIXED24 Value24 = 0.0; Value24.SetAsFixed24(Comp1); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[0] = TRUE; else pCol->Red = Value24; // read the Green colour component in Value24.SetAsFixed24(Comp2); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[1] = TRUE; else pCol->Green = Value24; // read the Blue colour component in Value24.SetAsFixed24(Comp3); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[2] = TRUE; else pCol->Blue = Value24; // No transparency pCol->Transparent = 0.0; return TRUE; }

BOOL ColourListComponent::ReadShade (  NewColourInfo *  pColourInfo, UINT32  Comp1, UINT32  Comp2 )  [private]

Read the shade values from a Camelot shade colour definition record. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/96 Parameters: pColourInfo  - pointer to the colour info to fill in [INPUTS] Comp1 .. 2 - the first two colour components read in from the record The  data in the pCol and pColourInfo will have been filled in [OUTPUTS] Returns: True if value read ok, False otherwise. See also: ColourListComponent::ImportColourDefinition; Definition at line 1091 of file colcomp.cpp. { ERROR2IF(pColourInfo == NULL,FALSE,"ColourListComponent::ReadShade NULL pColourInfo"); BOOL Linked = (pColourInfo != NULL) && (pColourInfo->Type == COLOURTYPE_LINKED); FIXED24 Value24 = 0.0; Value24.SetAsFixed24(Comp1); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[0] = TRUE; pColourInfo->TintValue = Value24; Value24.SetAsFixed24(Comp2); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[1] = TRUE; pColourInfo->ShadeValue = Value24; pColourInfo->Type = COLOURTYPE_TINT; // And flag the fact that this "tint" is a really a shade! pColourInfo->TintIsShade = TRUE; return TRUE; }

BOOL ColourListComponent::ReadTint (  NewColourInfo *  pColourInfo, UINT32  Comp1 )  [private]

Read the tint values from a Camelot tint colour definition record. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/96 Parameters: pColourInfo  - pointer to the colour info to fill in [INPUTS] Comp1 - the first of the colour components read in from the record The  data in the pCol and pColourInfo will have been filled in [OUTPUTS] Returns: True if value read ok, False otherwise. See also: ColourListComponent::ImportColourDefinition; Definition at line 1055 of file colcomp.cpp. { ERROR2IF(pColourInfo == NULL,FALSE,"ColourListComponent::ReadTint NULL pColourInfo"); BOOL Linked = (pColourInfo != NULL) && (pColourInfo->Type == COLOURTYPE_LINKED); // read the grey Intensity colour component in FIXED24 Value24 = 0.0; Value24.SetAsFixed24(Comp1); if (Linked && (Value24 == LinkValue)) pColourInfo->Inherits[0] = TRUE; pColourInfo->TintValue = Value24; pColourInfo->Type = COLOURTYPE_TINT; // And flag the fact that this "tint" is a tint rather than a shade! pColourInfo->TintIsShade = FALSE; return TRUE; }

BOOL ColourListComponent::SaveColourAndChildren (  IndexedColour *  pCol, EPSExportDC *  pDC, BOOL  CamelotEPS, INT32  NestingLevel = 0, BOOL  SaveShades = FALSE )  [private]

Save out an indexed colour to an EPS file, and all the colours that rely on it, i.e. any other indexed colours which are tints of, or links to, this colour. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/12/94 Parameters: pCol  - The (root) colour to save [INPUTS] pDC - The EPS export DC to save to CamelotEPS - TRUE if exporting Camelot EPS NestingLevel- The nesting level of tint/shade/link colours. Used in recursion - external callers should pass in 0 SaveShades - Indicates if Shades and their children should be saved. Used in version 1.1 CamelotEPS to save out 2 colour tables, the second of which includes the shades. (In this way, we could retain load-compatability with older versions) -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 2522 of file colcomp.cpp. { #ifdef DO_EXPORT // (Jason 27/10/95) If the colour is unnamed and it's not actually used anywhere, // don't bother saving it. This optimises out temporary locals that are no longer // needed. At the worst, if something goes horribly wrong, this just means that // some locals might turn up as CMYK definitions on reloading, but this shouldn't // cause any problems unless something deeply scary has happened to the colour system. if (!pCol->IsNamed() && !pCol->IsInUse()) return(TRUE); // Check for silly recursion errors [not that you can get circular references with // the amazingly strict and careful checking done by the IndexedColour class - JW ;-] ERROR2IF(NestingLevel > 200, FALSE, "Rampant linked colour nesting detected!"); // First, save out this indexed colour. ColourModel Model = pCol->GetColourModel(); // Buffer to build up colour defs in. TCHAR ColDef[256]; camStrcpy(ColDef, _T("%%+")); // Buffer for temporary strings TCHAR TmpBuf[256]; // Get information on the colour - ask for its full identifier rather than just the name, // so we get a unique id for unnamed colours rather than just "Local colour" ColourGeneric GenCol; IndexedColourType ColType = pCol->GetType(); pCol->GetSourceColour(&GenCol); TCHAR *ColName = (TCHAR *) (*(pCol->GetName(TRUE))); // Special check - Shades are only properly preserved in CamelotEPS. In all others, they // are treated as unlinked, normal colours, so that they will be read happily. if (!CamelotEPS && ColType == COLOURTYPE_TINT && pCol->TintIsShade()) { ColType = COLOURTYPE_NORMAL; } // If we shouldn't be saving shade colours or their children on this pass, then don't // do anything for them this time. if (!SaveShades && ColType == COLOURTYPE_TINT && pCol->TintIsShade()) return(TRUE); // If saving shades, then don't bother with non-shade colours which have no children, as // they do not need to be output. if (SaveShades && (ColType != COLOURTYPE_TINT || !pCol->TintIsShade()) && !pCol->HasLinkedChildren()) return(TRUE); // Check for tints if (ColType == COLOURTYPE_TINT) { FIXED24 TintVal(0.0); FIXED24 ShadeVal(0.0); // Add tint identifier to colour definition if (pCol->TintIsShade()) { camStrcat(ColDef, _T("d")); // Is a shaDe TintVal = pCol->GetShadeValueY(); // Note that it is written out as "Y X" ShadeVal = pCol->GetShadeValueX(); // to make backward compatability easier } else { camStrcat(ColDef, _T("t")); // Is a Tint TintVal = pCol->GetTintValue(); } ERROR3IF(NestingLevel < 1, "Bad nesting when saving a tint/shade colour"); // Get tint/shade value as an integer in range 0 - 100. INT32 Tint = (INT32) ((TintVal.MakeDouble() * 100.0) + ((TintVal < 0) ? -0.5 : 0.5)); INT32 Shade = (INT32) ((ShadeVal.MakeDouble() * 100.0) + ((ShadeVal < 0) ? -0.5 : 0.5)); if (NestingLevel > 1) { // Write out the nesting level camSnprintf(TmpBuf, 256, _T(" %d"), NestingLevel); camStrcat(ColDef, TmpBuf); } // Add the colour name and tint value if (pCol->TintIsShade()) camSnprintf(TmpBuf, 256, _T(" (%s) %d %d"), ColName, Tint, Shade); else camSnprintf(TmpBuf, 256, _T(" (%s) %d"), ColName, Tint); camStrcat(ColDef, TmpBuf); } else { // Is this a linked colour? BOOL Linked = (ColType == COLOURTYPE_LINKED); // We only do linked colours in CamelotEPS Linked = Linked && CamelotEPS; if (Linked) { // Mark this as a linked colour camStrcat(ColDef, _T("l")); } else if (CamelotEPS && (ColType == COLOURTYPE_SPOT)) { // Mark this as a spot colour camStrcat(ColDef, _T("s")); } // Save out colour model, nesting level and colour name switch (Model) { case COLOURMODEL_RGBT: camStrcat(ColDef, _T("r")); break; case COLOURMODEL_HSVT: camStrcat(ColDef, _T("h")); break; case COLOURMODEL_CMYK: camStrcat(ColDef, _T("c")); break; case COLOURMODEL_GREYT: // Special case - only Camelot can handle greyscales - ArtWorks can't. if (CamelotEPS) camStrcat(ColDef, _T("g")); else camStrcat(ColDef, _T("r")); break; default: break; } // Add nesting level, if needed if (NestingLevel > 1) { // Write out the nesting level camSnprintf(TmpBuf, 256, _T(" %d"), NestingLevel); camStrcat(ColDef, TmpBuf); } // Add colour name camStrcat(ColDef , _T(" (")); camStrcat(ColDef, ColName); camStrcat(ColDef, _T(")")); // Now write out the colour component values... switch (Model) { case COLOURMODEL_RGBT: // Now add the RGB components. ColourRGBT *pRGBT; pRGBT = (ColourRGBT *) &GenCol; AddComponentValue(ColDef, _T("%.3f"), pRGBT->Red.MakeDouble(), LINKED(1)); AddComponentValue(ColDef, _T("%.3f"), pRGBT->Green.MakeDouble(), LINKED(2)); AddComponentValue(ColDef, _T("%.3f"), pRGBT->Blue.MakeDouble(), LINKED(3)); break; case COLOURMODEL_HSVT: // Now add the HSV components. ColourHSVT *pHSVT; pHSVT = (ColourHSVT *) &GenCol; AddComponentValue(ColDef, _T("%.1f"), pHSVT->Hue.MakeDouble() * 360.0, LINKED(1)); AddComponentValue(ColDef, _T("%.1f"), pHSVT->Saturation.MakeDouble() * 100.0, LINKED(2)); AddComponentValue(ColDef, _T("%.1f"), pHSVT->Value.MakeDouble() * 100.0, LINKED(3)); break; case COLOURMODEL_CMYK: // Now add the CMYK components. ColourCMYK *pCMYK; pCMYK = (ColourCMYK *) &GenCol; AddComponentValue(ColDef, _T("%.3f"), pCMYK->Cyan.MakeDouble(), LINKED(1)); AddComponentValue(ColDef, _T("%.3f"), pCMYK->Magenta.MakeDouble(), LINKED(2)); AddComponentValue(ColDef, _T("%.3f"), pCMYK->Yellow.MakeDouble(), LINKED(3)); AddComponentValue(ColDef, _T("%.3f"), pCMYK->Key.MakeDouble(), LINKED(4)); break; case COLOURMODEL_GREYT: // ArtWorks doesn't have explicit greyscale colours - use RGB model. ColourGreyT *pGreyT; pGreyT = (ColourGreyT *) &GenCol; double Intensity; Intensity = pGreyT->Intensity.MakeDouble(); if (CamelotEPS) { // General greyscale format...just add the intensity component AddComponentValue(ColDef, _T("%.3f"), Intensity, LINKED(1)); } else { // Fake a greyscale for ArtWorks with an RGB colour // where R = G = B. for (INT32 i = 1; i <= 3; i++) { AddComponentValue(ColDef, _T("%.3f"), Intensity, FALSE); } } break; default: ERROR3("Unknown colour type found in EPS export!"); break; } } // Output colour definition to the EPS file pDC->OutputToken(ColDef); pDC->OutputNewLine(); // (Jason 27/10/95) If it doesn't have linked children, don't recurse. // On large files, this saves a *lot* of time (O(n*n) becomes O(n)), because // (a) linked colours are only usually used sporadically, and (b) local colours, // which make up the bulk of saved colours, cannot have any children. if (!pCol->HasLinkedChildren()) return(TRUE); // ---------- recurse ---------- // Now recurse to save out any children of this colour (links or tints)... // Get all the named colours that are immediate children of this colour IndexedColour *pChild = (IndexedColour *) pIndexedColours->GetHead(); while (pChild != NULL) { if (!pChild->IsDeleted() && pChild->FindLinkedParent() == pCol) { // Found a child - save out via recursion so we save all its descendants in the // right order... SaveColourAndChildren(pChild, pDC, CamelotEPS, NestingLevel + 1, SaveShades); } // Try the next colour pChild = (IndexedColour *) pIndexedColours->GetNext(pChild); } // Get all the unnamed colours that are immediate children of this colour List *pUnnamedList = pIndexedColours->GetUnnamedColours(); pChild = (IndexedColour *) pUnnamedList->GetHead(); while (pChild != NULL) { if (!pChild->IsDeleted() && pChild->FindLinkedParent() == pCol) { // Found a child - save out via recursion so we save all its descendants in the // right order... SaveColourAndChildren(pChild, pDC, CamelotEPS, NestingLevel + 1, SaveShades); } // Try the next colour pChild = (IndexedColour *) pUnnamedList->GetNext(pChild); } #endif return TRUE; }

INT32 ColourListComponent::SaveColourAndParents (  IndexedColour *  pCol, BaseCamelotFilter *  pFilter, INT32  NestingLevel = 0 )  [private]

Save out an indexed colour to a Web or Native file. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. This is the Web file form of saving colours. Save out an indexed colour in its complex form usually to a Native file. If it has any parents then these must be saved out before it, as the colour reference for the parent *MUST* be a real record number which has been previously saved into the stream. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. This is the Native file form of saving colours. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/96 Parameters: pCol  - The (root) colour to save [INPUTS] pFilter - The filter to use for saving NestingLevel - How many parental levels up we have gone so far -  [OUTPUTS] Returns: The record number for this colour, if it has been saved correctly or zero if a problem has occurred. May return -1 if it does not need to save anything i.e if the colour is not in use and not named. Errors: - See also: - Definition at line 1671 of file colcomp.cpp. { #ifdef DO_EXPORT ERROR2IF(pCol == NULL || pFilter == NULL, 0L, "ColourListComponent::SaveColourAndParents no pCol or pFilter!"); ERROR2IF(pExportedColours == NULL, 0L, "ColourListComponent::SaveColourAndParents no pExportedColours!"); // Use same condition as SaveColourAndChildren so that if the colour is unnamed // and it's not actually used anywhere, don't bother saving it. // This optimises out temporary locals that are no longer needed. At the worst, // if something goes horribly wrong, this just means that some locals might turn up // as CMYK definitions on reloading, but this shouldn't cause any problems unless // something deeply scary has happened to the colour system. if (!pCol->IsNamed() && !pCol->IsInUse()) return -1L; // Check for silly recursion errors [not that you can get circular references with // the amazingly strict and careful checking done by the IndexedColour class. // Same test as SaveColourAndChildren. ERROR2IF(NestingLevel > 200, 0L, "ColourListComponent::SaveColourAndParents - Rampant linked colour nesting detected!"); // **** // **** First, save parents of this colour, if any and if not saved previously // **** // Before we save out this colour, we must check if it has a parent, if so then // we must save out the parents first as we must reference parents by a record // number and hence it must have already been saved! // So, recurse and save out any parents of this colour (links or tints)... // Get all the named colours that are immediate children of this colour // This only returns a parent if this is a colour with a valid parent e.g. tint IndexedColour *pParent = pCol->FindLinkedParent(); //IndexedColour *pParentCol = pParent; ExportColour* pExportCol = NULL; while (pParent != NULL) { if (!pParent->IsDeleted()) { // Found a parent - save out via recursion so we save all its ascendants in the // right order... // To save time, check here if this parent is already in our list, if it this // then no point in recursing through the chain of parents as they all have already // been saved. pExportCol = pExportedColours->GetColour(pParent); // If it is NULL then we have not already saved this colour, so do so. if (pExportCol == NULL) SaveColourAndParents(pParent, pFilter, NestingLevel + 1); } // Try the next colour pParent = pParent->FindLinkedParent(); } // **** // **** Saved this colour before? // **** // Only write this record out if we have not done so already // Check by seeing if the colour is already in our exported colour list pExportCol = pExportedColours->GetColour(pCol); // If it is then do not save this colour if (pExportCol) { // Just return the record number as the colour reference to the caller return pExportCol->RecordNumber; } // Now save out the colour data in a complex colour record out to file // We want this indexed colour adding to the exported list and so say TRUE INT32 RecordNumber = SaveComplexColour(pCol, pFilter, TRUE); // Everything went tickety boo, so return the record number to the caller. return RecordNumber; #else return 0L; #endif }

INT32 ColourListComponent::SaveComplexColour (  IndexedColour *  pCol, BaseCamelotFilter *  pFilter, BOOL  AddColourToList = TRUE )  [private]

Actually save out an indexed colour to a Web or Native file in a complex colour record. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. If it has any parents then these must be saved out before it, as the colour reference for the parent *MUST* be a real record number which has been previously saved into the stream. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. This is the Native file form of saving colours. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/6/96 Parameters: pCol  - The (root) colour to save [INPUTS] pFilter - The filter to use for saving AddColourToList - True if we are to add this colour to the exported colour list False if the caller has already done this -  [OUTPUTS] Returns: The record number for this colour, if it has been saved correctly or zero if a problem has occurred. May return -1 if it does not need to save anything i.e if the colour is not in use and not named. Errors: - See also: SaveColourAndParents; GetWriteColourReference; Definition at line 1779 of file colcomp.cpp. { #ifdef DO_EXPORT ERROR2IF(pCol == NULL || pFilter == NULL, 0L, "ColourListComponent::SaveComplexColour no pCol or pFilter!"); ERROR2IF(pExportedColours == NULL, 0L, "ColourListComponent::SaveComplexColour no pExportedColours!"); // When GetColourLinePosition is TRUE, it means that we want to save the colour's pos on the colour // line, so that it can be imported in the correct order. // // This is set to AddColourToList by default - i.e. assume that if it's being added to the list of exported // colours, then we probably want to preserve the colour' pos BOOL GetColourLinePosition = AddColourToList; // **** // **** Get the information on the colour // **** // Get information on the colour - ask for its full identifier rather than just the name, // so we get a unique id for unnamed colours rather than just "Local colour" ColourModel Model = pCol->GetColourModel(); ColourGeneric GenCol; IndexedColourType ColType = pCol->GetType(); pCol->GetSourceColour(&GenCol); String_64 ColName = *(pCol->GetName(TRUE)); if (ColName[0] == '_') { // We have an unnamed colour and so the name should be blank ColName.Empty(); // If it's an unnamed colour, then it's assumed it's not on the colour line, so we // won't need to find it's pos on the colour line GetColourLinePosition = FALSE; } //TCHAR *ColName = (TCHAR *) (*(pCol->GetName(TRUE))); // Find a global colour context to convert this colour into RGB for us. ColourContextRGBT *cc = (ColourContextRGBT *)ColourManager::GetColourContext(COLOURMODEL_RGBT); ERROR3IF(cc == NULL, "ColourListComponent::SaveComplexColour No global RGB colour context!? Something is very broken"); if (cc == NULL) return 0L; BOOL ok = FALSE; // Create a DocColour referencing this IndexedColour. DocColour SimpleColour; SimpleColour.MakeRefToIndexedColour(pCol); // And convert the colour into a *packed* (8-bit components) colour structure PColourRGBT Result; cc->ConvertColour(&SimpleColour, (ColourPacked *)&Result); // And finally, read the bytes out of the packed colour struct. BYTE RedByteValue = Result.Red; BYTE GreenByteValue = Result.Green; BYTE BlueByteValue = Result.Blue; // **** // **** Save the record // **** // Write the data out to the file UINT32 Size = TAG_DEFINECOMPLEXCOLOUR_SIZE; // If there is a string name, then add it to this size // REMEMBER: We save out unicode strings and so we need to double the length of the returned string length Size += (ColName.Length() + 1) * SIZEOF_XAR_UTF16; // INT32 RecordNumber = pFilter->StartRecord(TAG_DEFINECOMPLEXCOLOUR, Size); CXaraFileRecord Rec(TAG_DEFINECOMPLEXCOLOUR, Size); ok = Rec.Init(); // Start with the simple RGB colour if (ok) ok = Rec.WriteBYTE(RedByteValue); if (ok) ok = Rec.WriteBYTE(GreenByteValue); if (ok) ok = Rec.WriteBYTE(BlueByteValue); // Now write out the colour model... if (ok) ok = Rec.WriteBYTE((BYTE)Model); // Now write out the colour type... // Include flags about linking in colour type? // If the colour is linked, we save out the component as an illegal known value // Convert the colour types into export colour types // Should be a straight conversion but just in case... ExportColourType ExpColType=EXPORT_COLOURTYPE_NORMAL; switch (ColType) { case COLOURTYPE_NORMAL: ExpColType = EXPORT_COLOURTYPE_NORMAL; break; case COLOURTYPE_SPOT: ExpColType = EXPORT_COLOURTYPE_SPOT; break; case COLOURTYPE_LINKED: ExpColType = EXPORT_COLOURTYPE_LINKED; break; case COLOURTYPE_TINT: if (pCol->TintIsShade()) ExpColType = EXPORT_COLOURTYPE_SHADE; else ExpColType = EXPORT_COLOURTYPE_TINT; break; default: ERROR3("ColourListComponent::SaveColour - Unknown colour model!"); break; } if (ok) ok = Rec.WriteBYTE((BYTE)ExpColType); // Write out the entry number this colour is in the indexed colour list UINT32 ColourListNumber = 0L; // If GetColourLinePosition is False then the indexed colour is not on the colour line. // so do NOT try and go through the list of colours to find its pos number, just use zero. if (GetColourLinePosition) ColourListNumber = GetIndexColourNumber(pCol); if (ok) ok = Rec.WriteUINT32(ColourListNumber); // Write out the reference number of the parent colour UINT32 ParentColourRef = 0L; IndexedColour *pParentCol = pCol->FindLinkedParent(); ExportColour* pExportCol = NULL; if (pParentCol) { // If there is a parent then recover the record number from the exported colours list pExportCol = pExportedColours->GetColour(pParentCol); ERROR2IF(pExportCol == NULL,FALSE,"ColourListComponent::SaveComplexColour Not exported parent before child!"); ParentColourRef = pExportCol->RecordNumber; TRACEUSER( "Neville", _T("Saving parent reference %d\n"),ParentColourRef); } if (ok) ok = Rec.WriteReference(ParentColourRef); BOOL Linked = (ColType == COLOURTYPE_LINKED); switch (ColType) { case COLOURTYPE_NORMAL: case COLOURTYPE_SPOT: case COLOURTYPE_LINKED: { // These all require the same handling // Linked colours save out the components in the normal fashion // Now write out the colour component values depending on the model in use... switch (Model) { case COLOURMODEL_RGBT: // Now add the RGB components. // Stored as FIXED24s. ColourRGBT *pRGBT; pRGBT = (ColourRGBT *) &GenCol; if (ok) ok = Rec.WriteUINT32(AddComponentValue(pRGBT->Red, LINKED_COLOUR(1))); if (ok) ok = Rec.WriteUINT32(AddComponentValue(pRGBT->Green, LINKED_COLOUR(2))); if (ok) ok = Rec.WriteUINT32(AddComponentValue(pRGBT->Blue, LINKED_COLOUR(3))); if (ok) ok = Rec.WriteUINT32(AddComponentValue(pRGBT->Transparent, LINKED_COLOUR(4))); break; case COLOURMODEL_HSVT: // Now add the HSV components. ColourHSVT *pHSVT; pHSVT = (ColourHSVT *) &GenCol; if (ok) ok = Rec.WriteUINT32(AddComponentValue(pHSVT->Hue, LINKED_COLOUR(1))); if (ok) ok = Rec.WriteUINT32(AddComponentValue(pHSVT->Saturation, LINKED_COLOUR(2))); if (ok) ok = Rec.WriteUINT32(AddComponentValue(pHSVT->Value, LINKED_COLOUR(3))); if (ok) ok = Rec.WriteUINT32(0); // pad to 4 colour components break; case COLOURMODEL_CMYK: // Now add the CMYK components. ColourCMYK *pCMYK; pCMYK = (ColourCMYK *) &GenCol; if (ok) ok = Rec.WriteUINT32(AddComponentValue(pCMYK->Cyan, LINKED_COLOUR(1))); if (ok) ok = Rec.WriteUINT32(AddComponentValue(pCMYK->Magenta, LINKED_COLOUR(2))); if (ok) ok = Rec.WriteUINT32(AddComponentValue(pCMYK->Yellow, LINKED_COLOUR(3))); if (ok) ok = Rec.WriteUINT32(AddComponentValue(pCMYK->Key, LINKED_COLOUR(4))); break; case COLOURMODEL_GREYT: // greyscale colour. ColourGreyT *pGreyT; pGreyT = (ColourGreyT *) &GenCol; if (ok) ok = Rec.WriteUINT32(AddComponentValue(pGreyT->Intensity, LINKED_COLOUR(1))); if (ok) ok = Rec.WriteUINT32(0); // pad to 4 colour components if (ok) ok = Rec.WriteUINT32(0); // pad to 4 colour components if (ok) ok = Rec.WriteUINT32(0); // pad to 4 colour components break; default: ERROR3("ColourListComponent::SaveColour - Unknown colour model!"); break; } break; } case COLOURTYPE_TINT: { // If we have a tint colour then this needs special handling FIXED24 TintVal(0.0); FIXED24 ShadeVal(0.0); // Is the tint a tint or is it really a shade // Add tint identifier to colour definition if (pCol->TintIsShade()) { ShadeVal = pCol->GetShadeValueX(); TintVal = pCol->GetShadeValueY(); if (ok) ok = Rec.WriteUINT32(AddComponentValue(ShadeVal, LINKED_COLOUR(1))); if (ok) ok = Rec.WriteUINT32(AddComponentValue(TintVal, LINKED_COLOUR(1))); if (ok) ok = Rec.WriteUINT32(0); // pad to 4 colour components if (ok) ok = Rec.WriteUINT32(0); // pad to 4 colour components } else { TintVal = pCol->GetTintValue(); if (ok) ok = Rec.WriteUINT32(AddComponentValue(TintVal, LINKED_COLOUR(1))); if (ok) ok = Rec.WriteUINT32(0); // pad to 4 colour components if (ok) ok = Rec.WriteUINT32(0); // pad to 4 colour components if (ok) ok = Rec.WriteUINT32(0); // pad to 4 colour components } break; } default: ERROR3("ColourListComponent::SaveColour - Unknown colour type!"); break; } // Write out the name of the colour if (ok) ok = Rec.WriteUnicode(ColName); // Finally, write the record out to file INT32 RecordNumber = 0L; if (ok) RecordNumber = pFilter->WriteDefinitionRecord(&Rec); // Has the caller handled adding this to the colour list already? No, so do it oursleves. if (AddColourToList && RecordNumber > 0) { // Add this colour to our list of exported items ok = pExportedColours->AddColour(pCol, RecordNumber); } //TRACEUSER( "Neville", _T("Saving colour %s, number %d, entry number %d\n"),(TCHAR*)ColName, RecordNumber, ColourListNumber); // If we have had a problem at any of the stages then return that to the caller if (!ok) return 0L; // Everything went tickety boo, so return the record number to the caller. return RecordNumber; #else return 0L; #endif }

INT32 ColourListComponent::SaveSimpleColour (  DocColour *  pDocCol, BaseCamelotFilter *  pFilter, BOOL  CheckSimpleColourList = FALSE )  [private]

Save out a document colour to a Web or Native file. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. This is the Web file form of saving colours. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/96 Parameters: pDocCol  - The document colour to save [INPUTS] pFilter - The filter to use for saving CheckSimpleColourList - If TRUE then check the export colour list to see if we have saved this simple colour before If FALSE then this is an indexed colour so don't search the export colour list -  [OUTPUTS] Returns: The record number for this colour, if it has been saved correctly or zero if a problem has occurred. May return -1 if it does not need to save anything i.e if the colour is not in use and not named. Errors: - See also: - Definition at line 1529 of file colcomp.cpp. { #ifdef DO_EXPORT ERROR2IF(pDocCol == NULL || pFilter == NULL, 0L, "ColourListComponent::SaveSimpleColour no pCol or pFilter supplied!"); // Find a global colour context to convert this colour into RGB for us. ColourContextRGBT *cc = (ColourContextRGBT *)ColourManager::GetColourContext(COLOURMODEL_RGBT); ERROR3IF(cc == NULL, "ColourListComponent::SaveSimpleColour No global RGB colour context!? Something is very broken"); if (cc == NULL) return 0L; // And convert the colour into a *packed* (8-bit components) colour structure PColourRGBT Result; cc->ConvertColour(pDocCol, (ColourPacked *)&Result); // If this is a simple colour rather than a simple colour of an indexed colour then // check to see if we have saved it already. If so then just return the record number if (CheckSimpleColourList) { // Only write this record out if we have not done so already // Check by seeing if the colour is already in our exported colour list ExportColour* pExportCol = NULL; pExportCol = pExportedColours->GetColour(&Result); // If it is then do not save this colour if (pExportCol) { // Just return the record number as the colour reference to the caller return pExportCol->RecordNumber; } } // And finally, read the bytes out of the packed colour struct. BYTE RedByteValue = Result.Red; BYTE GreenByteValue = Result.Green; BYTE BlueByteValue = Result.Blue; INT32 RecordNumber = 0L; if (RedByteValue == 0xFF && GreenByteValue == 0xFF && BlueByteValue == 0xFF) { RecordNumber = REF_DEFAULTCOLOUR_WHITE; } else if (RedByteValue == 0x00 && GreenByteValue == 0x00 && BlueByteValue == 0x00) { RecordNumber = REF_DEFAULTCOLOUR_BLACK; } else if (RedByteValue == 0xFF && GreenByteValue == 0x00 && BlueByteValue == 0x00) { RecordNumber = REF_DEFAULTCOLOUR_RED; } else if (RedByteValue == 0x00 && GreenByteValue == 0xFF && BlueByteValue == 0x00) { RecordNumber = REF_DEFAULTCOLOUR_GREEN; } else if (RedByteValue == 0x00 && GreenByteValue == 0x00 && BlueByteValue == 0xFF) { RecordNumber = REF_DEFAULTCOLOUR_BLUE; } else if (RedByteValue == 0x00 && GreenByteValue == 0xFF && BlueByteValue == 0xFF) { RecordNumber = REF_DEFAULTCOLOUR_CYAN; } else if (RedByteValue == 0xFF && GreenByteValue == 0x00 && BlueByteValue == 0xFF) { RecordNumber = REF_DEFAULTCOLOUR_MAGENTA; } else if (RedByteValue == 0xFF && GreenByteValue == 0xFF && BlueByteValue == 0x00) { RecordNumber = REF_DEFAULTCOLOUR_YELLOW; } else { BOOL ok = TRUE; // Write the data out to the file //INT32 RecordNumber = pFilter->StartRecord(TAG_DEFINERGBCOLOUR, TAG_DEFINERGBCOLOUR_SIZE); CXaraFileRecord Rec(TAG_DEFINERGBCOLOUR,TAG_DEFINERGBCOLOUR_SIZE); ok = Rec.Init(); if (ok) ok = Rec.WriteBYTE(RedByteValue); if (ok) ok = Rec.WriteBYTE(GreenByteValue); if (ok) ok = Rec.WriteBYTE(BlueByteValue); // Finally, write the record out to file // In the process get the record number that this was written out as if (ok) RecordNumber = pFilter->WriteDefinitionRecord(&Rec); // If we have had a problem at any of the stages then return that to the caller if (!ok || RecordNumber <= 0) return 0L; } // If this is a simple colour rather than a simple colour of an indexed colour then // add it to the list so that we do not save out the definition twice! if (CheckSimpleColourList) { // Add this colour to our list of exported items BOOL ok = pExportedColours->AddColour(&Result, RecordNumber); // If we have had a problem at any of the stages then return that to the caller if (!ok) return 0L; } // Everything went tickety boo, so return the record number to the caller. return RecordNumber; #else return 0L; #endif }

INT32 ColourListComponent::SaveSimpleColour (  IndexedColour *  pCol, BaseCamelotFilter *  pFilter )  [private]

Save out an indexed colour to a Web or Native file. Returns a record number or colour reference to the caller ready for use by somebody else to save in their record. This is the Web file form of saving colours. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/96 Parameters: pCol  - The (root) colour to save [INPUTS] pFilter - The filter to use for saving -  [OUTPUTS] Returns: The record number for this colour, if it has been saved correctly or zero if a problem has occurred. May return -1 if it does not need to save anything i.e if the colour is not in use and not named. Errors: - See also: - Definition at line 1453 of file colcomp.cpp. { #ifdef DO_EXPORT ERROR2IF(pCol == NULL || pFilter == NULL, 0L, "ColourListComponent::SaveSimpleColour no pCol or pFilter supplied!"); ERROR2IF(pExportedColours == NULL, 0L, "ColourListComponent::SaveSimpleColour no pExportedColours!"); // Use same condition as SaveColourAndChildren so that if the colour is unnamed // and it's not actually used anywhere, don't bother saving it. // This optimises out temporary locals that are no longer needed. At the worst, // if something goes horribly wrong, this just means that some locals might turn up // as CMYK definitions on reloading, but this shouldn't cause any problems unless // something deeply scary has happened to the colour system. if (!pCol->IsNamed() && !pCol->IsInUse()) return -1L; // Only write this record out if we have not done so already // Check by seeing if the colour is already in our exported colour list ExportColour* pExportCol = NULL; pExportCol = pExportedColours->GetColour(pCol); // If it is then do not save this colour if (pExportCol) { // Just return the record number as the colour reference to the caller return pExportCol->RecordNumber; } // Create a DocColour referencing this IndexedColour. DocColour SimpleColour; SimpleColour.MakeRefToIndexedColour(pCol); // Save this as a document colour, don't check the export colour list as we are an indexed colour // really and so have cope with the list ourselves. INT32 RecordNumber = SaveSimpleColour(&SimpleColour, pFilter, FALSE); // returns 0 if there was a problem, exit now if (RecordNumber == 0) return RecordNumber; // Add this colour to our list of exported items BOOL ok = pExportedColours->AddColour(pCol, RecordNumber); // If we have had a problem at any of the stages then return that to the caller if (!ok) return 0L; // Everything went tickety boo, so return the record number to the caller. return RecordNumber; #else return 0L; #endif }

BOOL ColourListComponent::StartComponentCopy (   )  [virtual]

This function gets called to prepare for a copy of indexed colours into the document. It sets up the various arrays and other thangs which the colour copy will need. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if it succeeded. FALSE if the copy must be aborted Errors: ENSURE failure if called when a component copy is already under way. Errors will be reported if memory is unavailable See also: ColourListComponent::EndComponentCopy; ColourListComponent::AbortComponentCopy; ColourListComponent::CopyColourAcross Reimplemented from DocComponent. Definition at line 3777 of file colcomp.cpp. { // Make sure the fn has not been called before if (SourceColours != NULL || DestColours != NULL) { ERROR3("StartComponentCopy already called"); return(TRUE); } ColourTableSize = 64; // Start off with 64-entry table. This may grow if // we find we have a lot of colours to copy over SourceColours = (IndexedColour **) CCMalloc(ColourTableSize * sizeof(IndexedColour *)); if (SourceColours == NULL) { InformError(); // Out of memory - inform the user return(FALSE); } DestColours = (IndexedColour **) CCMalloc((ColourTableSize+1) * sizeof(IndexedColour *)); if (DestColours == NULL) { InformError(); // Out of memory - inform the user CCFree(SourceColours); // And release our other memory - we can't use it now SourceColours = NULL; return(FALSE); } MergeColours = (BOOL *) CCMalloc(ColourTableSize * sizeof(BOOL)); if (MergeColours == NULL) { InformError(); // Out of memory - inform the user CCFree(SourceColours); // And release our other memory - we can't use it now CCFree(DestColours); SourceColours = DestColours = NULL; return(FALSE); } // Initialise the arrays for (INT32 i = 0; i < ColourTableSize; i++) { SourceColours[i] = DestColours[i] = NULL; MergeColours[i] = FALSE; } DestColours[ColourTableSize] = NULL; // And add a NULL terminator to dest. list return(TRUE); }

BOOL ColourListComponent::StartExport (  BaseCamelotFilter *  pFilter  )  [virtual]

Inform the colour list document component that a WEb or Native export is about to start. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/96 Returns: TRUE if the component was able to prepare for exporting; FALSE if not (e.g. out of memory) Parameters: pFilter  - the BaseCamelotFilter filter that is being used to export a file. [INPUTS] See also: DocComponent Reimplemented from DocComponent. Definition at line 1135 of file colcomp.cpp. { #ifdef DO_EXPORT TRACEUSER( "Neville", _T("ColourListComponent::StartExport\n")); // Mark all colours as unsaved if (pFilter == NULL) { ERROR3("ColourListComponent::StartExport filter is null!"); return TRUE; } // Save this in our link to the BaseCamelotFilter pCamFilter = pFilter; // Set up and start the exported colour list pExportedColours = new ExportedColours(); if (pExportedColours == NULL) return FALSE; #endif return TRUE; }

BOOL ColourListComponent::StartImport (  BaseCamelotFilter *  pFilter  )  [virtual]

Inform the colour list document component that a Native or Web import is about to start. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/96 Parameters: pFilter  - the BaseCamelotFilter filter that is being used to import a file. [INPUTS] Returns: TRUE if the component was able to prepare for importing; FALSE if not (e.g. out of memory) See also: DocComponent Reimplemented from DocComponent. Definition at line 378 of file colcomp.cpp. { TRACEUSER( "Neville",_T("ColourListComponent::StartImport\n") ); if (pFilter == NULL) { ERROR3("ColourListComponent::StartImport filter is null!"); return TRUE; } // Save this in our link to the BaseCamelotFilter pCamFilter = pFilter; // Set our variable so that we warn about a possible replacement only once WarnedBefore = FALSE; // Get a colour table and don't do strict checking (as per Camelot EPS and Native EPS). pNewColours = new ImportedColours(this, FALSE); if ((pNewColours == NULL) || !pNewColours->Init()) return FALSE; // We keep a record of how nested we are with respect to linking colours, e.g. // links of links of links. // A nesting of 0 is no nesting. // Do this so that we are consistent with the EPS form LinkNesting = 0; return TRUE; }

BOOL ColourListComponent::WriteEPSComments (  EPSFilter *  pFilter  )  [virtual]

Writes out the colour table in the form of EPS comments in the 'header' comments of the EPS file. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/94 Parameters: pFilter  - the filter being used to import the EPS file. [INPUTS] Returns: TRUE if the colour table was written successfully; FALSE if not. Notes: IMPORTANT: Version 1.1 file extensions (Jason, 7/9/95 & 14/10/95) For this version, Shade colours have been added. To retain backward compatability, all shades and their children are written into a second colour table (a %JWColourTable). This means old loader code will skip them and use the inlined CMYK definitions, thus retaining the appearance of the document while only losing unsupported colour linking info. Thus, we do a 2-pass scheme. The first pass will (by use of default params in SaveColourAndChildren) fail to save out any shades and children. The second pass then saves all shades and their parents and children. Note this means parent colours can be saved twice, but these will be happily merged on loading, so no bad effects occur. Shades are only saved out in CamelotEPS. In Artworks EPS mode, they become standalone named colours. Returns: Errors: Out of disk space, and similar disk errors. See also: DocComponent::WriteEPSComments; DocComponent Reimplemented from DocComponent. Definition at line 2246 of file colcomp.cpp. { #ifdef DO_EXPORT if (pFilter->IsKindOf(CC_RUNTIME_CLASS(ArtWorksEPSFilter))) { // Is it a Camelot specific filter? BOOL CamelotEPS = pFilter->IsKindOf(CC_RUNTIME_CLASS(CamelotEPSFilter)); // Output the colour table in ArtWorks format. EPSExportDC *pDC = pFilter->GetExportDC(); // The ArtWorks EPS comment: pDC->OutputToken(_T("%%AWColourTable")); pDC->OutputNewLine(); // Iterate over the document's list of named IndexedColours... IndexedColour *pCol = (IndexedColour *) pIndexedColours->GetHead(); while (pCol != NULL) { if (!pCol->IsDeleted() && ((pCol->GetType() == COLOURTYPE_NORMAL) || (pCol->GetType() == COLOURTYPE_SPOT))) { // The colour is in use and is not a linked colour or tint - save it to // the EPS file. SaveColourAndChildren(pCol, pDC, CamelotEPS); } // Try the next colour pCol = (IndexedColour *) pIndexedColours->GetNext(pCol); } // Iterate over the document's list of unnamed IndexedColours... List *pUnnamedColours = pIndexedColours->GetUnnamedColours(); pCol = (IndexedColour *) pUnnamedColours->GetHead(); while (pCol != NULL) { if (!pCol->IsDeleted() && pCol->IsInUse() && ((pCol->GetType() == COLOURTYPE_NORMAL) || (pCol->GetType() == COLOURTYPE_SPOT))) { // The colour is in use and is not a linked colour or tint - save it to // the EPS file. SaveColourAndChildren(pCol, pDC, CamelotEPS); } // Try the next colour pCol = (IndexedColour *) pUnnamedColours->GetNext(pCol); } // --- PASS 2 - version 1.1 second colour table for shades and other extensions if (CamelotEPS) { // This variable is used to stop us outputting the colour table section // if it is not needed - we only output the header line when we write the // first colour out to this table. BOOL HaveOutputHeader = FALSE; // Iterate over the document's list of named IndexedColours... IndexedColour *pCol = (IndexedColour *) pIndexedColours->GetHead(); while (pCol != NULL) { if (!pCol->IsDeleted() && ((pCol->GetType() == COLOURTYPE_NORMAL) || (pCol->GetType() == COLOURTYPE_SPOT))) { // The colour is in use and is not a linked colour or tint - save it to // the EPS file. if (ColourOrChildIsShade(pCol)) { if (!HaveOutputHeader) { // Output the header comment if we haven't already done so pDC->OutputToken(_T("%%JWColourTable")); pDC->OutputNewLine(); HaveOutputHeader = TRUE; } SaveColourAndChildren(pCol, pDC, CamelotEPS, 0, TRUE); } } // Try the next colour pCol = (IndexedColour *) pIndexedColours->GetNext(pCol); } // Iterate over the document's list of unnamed IndexedColours... List *pUnnamedColours = pIndexedColours->GetUnnamedColours(); pCol = (IndexedColour *) pUnnamedColours->GetHead(); while (pCol != NULL) { if (!pCol->IsDeleted() && pCol->IsInUse() && ((pCol->GetType() == COLOURTYPE_NORMAL) || (pCol->GetType() == COLOURTYPE_SPOT))) { // The colour is in use and is not a linked colour or tint - save it to // the EPS file. if (ColourOrChildIsShade(pCol)) { if (!HaveOutputHeader) { // Output the header comment if we haven't already done so pDC->OutputToken(_T("%%JWColourTable")); pDC->OutputNewLine(); HaveOutputHeader = TRUE; } SaveColourAndChildren(pCol, pDC, CamelotEPS, 0, TRUE); } } // Try the next colour pCol = (IndexedColour *) pUnnamedColours->GetNext(pCol); } } } #endif // All ok. return TRUE; }

---

Friends And Related Function Documentation

friend class ImportedColours [friend]

Definition at line 180 of file colcomp.h.

---

Member Data Documentation

INT32 ColourListComponent::ColourTableSize [private]

Definition at line 295 of file colcomp.h.

IndexedColour** ColourListComponent::DestColours [private]

Definition at line 293 of file colcomp.h.

INT32 ColourListComponent::LinkNesting [private]

Definition at line 300 of file colcomp.h.

BOOL* ColourListComponent::MergeColours [private]

Definition at line 294 of file colcomp.h.

BaseCamelotFilter* ColourListComponent::pCamFilter [private]

Definition at line 303 of file colcomp.h.

ExportedColours* ColourListComponent::pExportedColours [private]

Definition at line 221 of file colcomp.h.

ColourList* ColourListComponent::pIndexedColours [private]

Definition at line 216 of file colcomp.h.

ImportedColours* ColourListComponent::pNewColours [private]

Definition at line 218 of file colcomp.h.

IndexedColour** ColourListComponent::SourceColours [private]

Definition at line 292 of file colcomp.h.

BOOL ColourListComponent::WarnedBefore [private]

Definition at line 304 of file colcomp.h.

---

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

• Kernel/colcomp.h (r1785/r1282)
• Kernel/colcomp.cpp (r1785/r1315)

---