EPSStack Class Reference

Provides a heterogeneous stack for use when reading PostScript (EPS) files. Graeme (30/5/00) - I've replaced the array implementation that Tim originally used with a linked list. The array was originally there as a performance tweak, but increased CPU power has made this a less perceiveable gain. By using a linked list, I've made the implementation a little more error tolerant, which means that files containing stranglely placed bitmaps are now loaded. More...

#include <epsstack.h>

Inheritance diagram for EPSStack:

List of all members.

Public Member Functions
	EPSStack ()
	Constructor. Initialises scaling factor to be 1.
	~EPSStack ()
	Destructor - deallocates all storage associated with the stack.
BOOL	Push (const INT32)
	Push a INT32 value onto the stack.
BOOL	Push (const FIXEDPOINT)
	Push a fixed point value onto the stack.
BOOL	Push (const double)
	Push a double value onto the stack.
BOOL	Push (const TCHAR *, BOOL IsName=FALSE)
	Push a TCHAR* string item onto the stack.
BOOL	Push (const EPSCommand Cmd)
	Push an EPS command onto the stack.
BOOL	Pop (INT32 *)
	Pop a INT32 value from the top of the stack. If there is a floating point value on the stack, it is converted before being returned to the caller.
BOOL	Pop (UINT32 *)
	Pop a UINT32 value from the top of the stack. If there is a floating point value on the stack, it is converted before being returned to the caller.
BOOL	Pop (FIXEDPOINT *)
	Pop a double value from the top of the stack. If there is an integer value on top of the stack, it is converted to a floating point value before being returned to the caller.
BOOL	Pop (double *)
	Pop a double value from the top of the stack. If there is an integer value on top of the stack, it is converted to a floating point value before being returned to the caller.
BOOL	Pop (TCHAR *)
	Pop a TCHAR* string value from the top of the stack.
BOOL	Pop (StringBase *)
	Pop a string value from the top of the stack.
BOOL	PopCmd (EPSCommand *)
	Pop an EPS command from the top of the stack.
BOOL	PopCoord (INT32 *)
	Pop a INT32 value from the top of the stack. If there is a fixed point value on the stack, it is converted before being returned to the caller. The value is scaled before being returned, so that it is easy to cope with EPS files that use brainless coordinate schemes (i.e. all of them). Scaling factor is initially 1, but can be changed via SetCoordScaleFactor().
BOOL	PopCoordPair (DocCoord *)
	Pop two INT32 values from the top of the stack. If they are in floating point format, they are converted before being returned to the caller. The coords are scaled and translated before being returned, so that it is easy to cope with EPS files that use brainless coordinate schemes (ArtWorks EPS are you listening?). Scaling factor is initially 1, but can be changed via SetCoordScaleFactor(). Origin is initially (0,0), but can be changed via SetCoordOrigin().
BOOL	PopColour (PColourCMYK *, TintType Tint=TINT_NONE, FIXEDPOINT *TintVal=NULL, String_64 *pName=NULL)
	Extract CYMK values from an ArtWorks EPS format and convert to Camelot range. AWEPS colour values are in the range 0 to 1; this function converts them to the 0 to 255 range. See Also: EPSStack::PopColourRGB.
BOOL	PopColourRGB (INT32 *red, INT32 *green, INT32 *blue, TintType Tint=TINT_NONE, FIXEDPOINT *TintVal=NULL, String_64 *pName=NULL)
	Extract RGB values from a generic EPS format and convert to Camelot range. EPS colour values are in the range 0 to 1; this function converts them to the 0 to 255 range. See Also: EPSStack::PopColour.
BOOL	PopGrayScale (PColourCMYK *)
	Extract grayscale value from an EPS format file and convert to Camelot range.
BOOL	Pop (Matrix *, BOOL)
	Pop a matrix object from the EPS stack.
BOOL	PopArray (INT32 *, INT32 *)
	Pop a PostScript array object from the stack.
BOOL	Discard (UINT32 NumToDiscard=1, BOOL EvenCommands=FALSE)
	Discard a number of items from the stack, irrespective of their type. NB. The exception is that you cannot discard a command, only operands (e.g. strings, numbers or names) unless EvenCommands == TRUE.
BOOL	DiscardArray ()
	Discard a PostScript array object from the stack. This is normally used when an EPS filter is not complete, but the file is still parsed correctly by discarding information that is npt yet needed/processed.
void	SetCoordScaleFactor (INT32 NewScaleFactor)
	Set the scale factor used by PopCoord(). Scaling factor is initially 1.
void	SetCoordOrigin (DocCoord NewOrigin)
	Set the translation values used by PopCoord(). Initially (0,0).
void	TranslateCoordOrigin (MILLIPOINT dx, MILLIPOINT dy)
	Translate the current origin for the EPS file by the given amounts. This is used when the %BoundingBox comment is encountered, so that the image appears in a sensible place.
void	SetXformMatrix (Matrix &)
	Sets up an additional transformation matrix to be used when decoding document coordinates (via EPSStack::PopCoordPair). When a transform matrix is active, all coords returned from PopCoordPair will have been transformed by the matrix after first having had the usual origin translation performed. The transformation matrix can be disabled by called SetNoXFormMatrix().
void	SetNoXformMatrix ()
	Disable the transformation matrix used by EPSStack::PopCoordPair(). See SetXFormMatrix() for details.
EPSType	GetType ()
	Find out what type of object is on the top of the stack. The item is not removed from the stack by this operation.
EPSCommand	ReadCmd ()
	Find out what command is on top of the stack. The command is not removed from the stack. Numbers, strings, names, etc. do not count as being commands.
void	Dump (EPSFilter *)
	Dump out the contents of the stack to the debug window. The stack is unchanged.
BOOL	IsEmpty ()
	Test to see if the stack is empty.
Private Attributes
INT32	ScaleFactor
DocCoord	Origin
Matrix	XformMatrix
BOOL	UseXformMatrix

---

Detailed Description

Provides a heterogeneous stack for use when reading PostScript (EPS) files. Graeme (30/5/00) - I've replaced the array implementation that Tim originally used with a linked list. The array was originally there as a performance tweak, but increased CPU power has made this a less perceiveable gain. By using a linked list, I've made the implementation a little more error tolerant, which means that files containing stranglely placed bitmaps are now loaded.

Author:

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

Date:

13/10/93

See also:

EPSInputFilter; EPSStackItem

Definition at line 166 of file epsstack.h.

---

Constructor & Destructor Documentation

EPSStack::EPSStack (   )

Constructor. Initialises scaling factor to be 1. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Definition at line 195 of file epsstack.cpp. : List () { // Set scaling to unity. ScaleFactor = 1; // Set origin to default Origin.x = 0; Origin.y = 0; // By default, no additional transformation matrix is used. UseXformMatrix = FALSE; }

EPSStack::~EPSStack (   )

Destructor - deallocates all storage associated with the stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Definition at line 218 of file epsstack.cpp. { // Delete the contents of the list. DeleteAll (); }

---

Member Function Documentation

BOOL EPSStack::Discard (  UINT32  NumToDiscard = 1, BOOL  EvenCommands = FALSE )

Discard a number of items from the stack, irrespective of their type. NB. The exception is that you cannot discard a command, only operands (e.g. strings, numbers or names) unless EvenCommands == TRUE. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 14/10/93 Parameters: NumToDiscard  - the number of items to remove from the top of the stack. [INPUTS] Returns: TRUE if there were sufficient items on the stack to satisfy request, FALSE if not. See also: EPSStack::Pop Definition at line 1244 of file epsstack.cpp. { // Check we can discard this many items if ( GetCount () < NumToDiscard ) return FALSE; while (NumToDiscard > 0) { EPSStackItem *pItem = static_cast<EPSStackItem*> ( GetHead () ); // Catch NULL pointers. if ( pItem == NULL ) { // Cannot discard any more list items. break; } if((pItem->Type == EPSTYPE_COMMAND) && (EvenCommands == FALSE)) { // Cannot discard a command return FALSE; } // Clean up any storage for this item RemoveHead (); delete pItem; // Move to next item NumToDiscard--; } return TRUE; }

BOOL EPSStack::DiscardArray (   )

Discard a PostScript array object from the stack. This is normally used when an EPS filter is not complete, but the file is still parsed correctly by discarding information that is npt yet needed/processed. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 07/03/94 Returns: TRUE if the array was discarded ok, FALSE if an error occured. Errors: No syntactically correct array on the stack. See also: EPSStack::Discard Definition at line 1394 of file epsstack.cpp. { if (GetType() != EPSTYPE_COMMAND) { TRACEUSER( "Tim", _T("EPSStack::DiscardArray: Expected ArrayEnd\n")); return FALSE; } EPSCommand Cmd=EPSC_Invalid; PopCmd(&Cmd); if (Cmd != EPSC_ArrayEnd) { TRACEUSER( "Tim", _T("EPSStack::DiscardArray: Expected ArrayEnd\n")); return FALSE; } // Discard the rest of the array for(;;) { if (IsEmpty()) { // Run out of operands! TRACEUSER( "Tim", _T("EPSStack::DiscardArray: Run out of operands\n")); return FALSE; } if (GetType() != EPSTYPE_COMMAND) // Discard array member Discard(); else { EPSCommand Cmd = ReadCmd(); if (!PopCmd(&Cmd) || Cmd != EPSC_ArrayStart) { TRACEUSER( "Tim", _T("EPSStack::DiscardArray: Expected ArrayStart\n")); return FALSE; } else break; // exit loop - end of array found } } // Array discarded ok return TRUE; }

void EPSStack::Dump (  EPSFilter *  pFilter  )

Dump out the contents of the stack to the debug window. The stack is unchanged. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 15/10/93 Parameters: Pointer  to the filter that this stack is owned by. [INPUTS] Definition at line 1517 of file epsstack.cpp. { #if defined(_DEBUG) if (!Error::IsUserName("Tim") && !Error::IsUserName("Ben")) return; TRACE( _T("EPS STACK DUMP START\n\n")); for ( DWORD i = 0; i < GetCount (); i++ ) { EPSStackItem *pItem = static_cast<EPSStackItem*> ( FindItem ( i ) ); switch (pItem->Type) { case EPSTYPE_COMMAND: TRACE( _T("Command: %s\n"), pFilter->GetEPSCommand(pItem->Data.Cmd)); break; case EPSTYPE_FIXEDPOINT: TRACE( _T("Fixed point: %f\n"), ((double) pItem->Data.FixedPoint.Long) / FixedPointScale); break; case EPSTYPE_INT32: TRACE( _T("Long: %ld\n"), pItem->Data.Long); break; case EPSTYPE_STRING: TRACE( _T("String: '%s'\n"), pItem->Data.pString); break; case EPSTYPE_NAME: TRACE( _T("Name: '%s'\n"), pItem->Data.pString); break; case EPSTYPE_DOUBLE: TRACE( _T("Double: %f\n"), pItem->Data.Double); break; case EPSTYPE_EMPTY: case EPSTYPE_NONE: TRACE( _T("Empty/None\n")); break; default: TRACE( _T("Unknown type\n")); break; } } TRACE( _T("\nEPS STACK DUMP END\n")); #endif }

EPSType EPSStack::GetType (  void   )

Find out what type of object is on the top of the stack. The item is not removed from the stack by this operation. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 14/10/93 Returns: The type of the object on the top of the stack (if the stack is empty, the value EPSTYPE_NONE is returned). Definition at line 1453 of file epsstack.cpp. { EPSStackItem *pItem = static_cast<EPSStackItem*> ( GetHead () ); if ( pItem == NULL ) return EPSTYPE_NONE; else return pItem->Type; }

BOOL EPSStack::IsEmpty (   )

Test to see if the stack is empty. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Returns: Returns TRUE if the stack is empty, FALSE if it is not. See also: EPSStack::GetCount(); Definition at line 1500 of file epsstack.cpp. { return ( GetCount () == 0 ); }

BOOL EPSStack::Pop (  Matrix *  pMatrix, BOOL  UseBrackets )

Pop a matrix object from the EPS stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 2/2/95 Parameters: pMatrix  - the matrix to hold the popped values. [INPUTS] UseBrackets - TRUE if the matrix is bracketed by []; FALSE if just the numbers are in the file. Returns: TRUE if the matrix was decode ok; FALSE otherwise Errors: Not enough parameters/incorrect parameters. Definition at line 1087 of file epsstack.cpp. { if (UseBrackets) { EPSCommand Cmd=EPSC_Invalid; PopCmd(&Cmd); if (Cmd != EPSC_ArrayEnd) return FALSE; } // Extract the six array values from the stack. double M[6]; INT32 i = 5; for (i = 5; i >= 0; i--) { if (!Pop(&M[i])) return FALSE; } if (UseBrackets) { EPSCommand Cmd=EPSC_Invalid; PopCmd(&Cmd); if (Cmd != EPSC_ArrayStart) return FALSE; } // Convert the abcd values into FIXED16s, cos that's what we use. FIXED16 F16[4]; for (i = 0; i < 4; i++) { F16[i] = FIXED16(M[i]); } // Convert the Tx and Ty to MILLIPOINTS, cos that's what we use. INT32 L1 = (INT32) (M[4] * 1000.0); INT32 L2 = (INT32) (M[5] * 1000.0); // Construct the matrix in the variable supplied by the caller. *pMatrix = Matrix(F16[0], F16[1], F16[2], F16[3], L1, L2); // Success return TRUE; }

BOOL EPSStack::Pop (  StringBase *  pString  )

Pop a string value from the top of the stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: pString  - the String object to put the string value into. [OUTPUTS] Returns: TRUE if there is a string value on the top of the stack; FALSE if not. Definition at line 666 of file epsstack.cpp. { // Get pointer to the stack item. EPSStackItem *pItem = static_cast<EPSStackItem*> ( RemoveHead () ); // Return error if no items on stack. if ( pItem == NULL ) return FALSE; // Check that the item is of the correct type if ( pItem->Type == EPSTYPE_STRING ) { // Correct type - remove item from stack and return to caller. *pString = String_256(pItem->Data.pString); delete pItem; return TRUE; } else { // Tidy up the memory. delete pItem; // Type mismatch - return error condition return FALSE; } }

BOOL EPSStack::Pop (  TCHAR *  pString  )

Pop a TCHAR* string value from the top of the stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: pString  - the buffer to put the string value into. [OUTPUTS] Returns: TRUE if there is a string value on the top of the stack; FALSE if not. Definition at line 627 of file epsstack.cpp. { // Get pointer to the stack item. EPSStackItem *pItem = static_cast<EPSStackItem*> ( RemoveHead () ); // Return error if no items on stack. if ( pItem == NULL ) return FALSE; // Check that the item is of the correct type if ( pItem->Type == EPSTYPE_STRING ) { // Correct type - remove item from stack and return to caller. camStrcpy ( pString, pItem->Data.pString ); delete pItem; return TRUE; } else { // Tidy up the memory. delete pItem; // Type mismatch - return error condition return FALSE; } }

BOOL EPSStack::Pop (  double *  pDouble  )

Pop a double value from the top of the stack. If there is an integer value on top of the stack, it is converted to a floating point value before being returned to the caller. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: pDouble  - the value popped from the stack. [OUTPUTS] Returns: TRUE if there is a numeric value on the top of the stack; FALSE if not. Definition at line 577 of file epsstack.cpp. { // Get pointer to the stack item. EPSStackItem *pItem = static_cast<EPSStackItem*> ( RemoveHead () ); // Return error if no items on stack. if ( pItem == NULL ) return FALSE; // Check that the item is of the correct type switch ( pItem->Type ) { case EPSTYPE_INT32: // Correct type - remove item from stack and return to caller. *pDouble = static_cast<double> ( pItem->Data.Long ); break; case EPSTYPE_FIXEDPOINT: // Perform implicit type conversion a la PostScript *pDouble = static_cast<double> ( pItem->Data.FixedPoint.Long ) / FixedPointScale; break; case EPSTYPE_DOUBLE: // Perform implicit type conversion a la PostScript *pDouble = pItem->Data.Double; break; default: // Type mismatch - return error condition return FALSE; } // Delete item fron stack and return delete pItem; return TRUE; }

BOOL EPSStack::Pop (  FIXEDPOINT *  pFixedPoint  )

Pop a double value from the top of the stack. If there is an integer value on top of the stack, it is converted to a floating point value before being returned to the caller. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: pFixedPoint  - the value popped from the stack. [OUTPUTS] Returns: TRUE if there is a numeric value on the top of the stack; FALSE if not. Definition at line 525 of file epsstack.cpp. { // Get pointer to the stack item. EPSStackItem *pItem = static_cast<EPSStackItem*> ( RemoveHead () ); // Return error if no items on stack. if ( pItem == NULL ) return FALSE; // Check that the item is of the correct type switch (pItem->Type) { case EPSTYPE_INT32: // Correct type - remove item from stack and return to caller. pFixedPoint->Long = ( pItem->Data.Long * FixedPointScale ); break; case EPSTYPE_FIXEDPOINT: // Perform implicit type conversion a la PostScript *pFixedPoint = pItem->Data.FixedPoint; break; case EPSTYPE_DOUBLE: // Perform implicit type conversion a la PostScript pFixedPoint->Long = static_cast <INT32> ( pItem->Data.Double ); break; default: // Type mismatch - return error condition return FALSE; } // Delete item fron stack and return delete pItem; return TRUE; }

BOOL EPSStack::Pop (  UINT32 *  pUint  )

Pop a UINT32 value from the top of the stack. If there is a floating point value on the stack, it is converted before being returned to the caller. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: pUint  - the value popped from the stack. [OUTPUTS] Returns: TRUE if there is a numeric value on the top of the stack; FALSE if not. Definition at line 473 of file epsstack.cpp. { // Get pointer to the stack item. EPSStackItem *pItem = static_cast<EPSStackItem*> ( RemoveHead () ); // Return error if no items on stack. if ( pItem == NULL ) return FALSE; // Check that the item is of the correct type switch ( pItem->Type ) { case EPSTYPE_INT32: // Correct type - remove item from stack and return to caller. *pUint = static_cast<UINT32> ( pItem->Data.Long ); break; case EPSTYPE_FIXEDPOINT: // Perform implicit type conversion a la PostScript *pUint = static_cast<UINT32> ( pItem->Data.FixedPoint.Long / FixedPointScale ); break; case EPSTYPE_DOUBLE: // Perform implicit type conversion a la PostScript *pUint = static_cast<UINT32> ( pItem->Data.Double ); break; default: // Type mismatch - return error condition return FALSE; } // Delete item fron stack and return delete pItem; return TRUE; }

BOOL EPSStack::Pop (  INT32 *  pLong  )

Pop a INT32 value from the top of the stack. If there is a floating point value on the stack, it is converted before being returned to the caller. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: pLong  - the value popped from the stack. [OUTPUTS] Returns: TRUE if there is a numeric value on the top of the stack; FALSE if not. Definition at line 422 of file epsstack.cpp. { // Get pointer to the stack item. EPSStackItem *pItem = static_cast<EPSStackItem*> ( RemoveHead () ); // Return error if no items on stack. if ( pItem == NULL ) return FALSE; // Check that the item is of the correct type switch ( pItem->Type ) { case EPSTYPE_INT32: // Correct type - remove item from stack and return to caller. *pLong = static_cast<INT32> ( pItem->Data.Long ); break; case EPSTYPE_FIXEDPOINT: // Perform implicit type conversion a la PostScript *pLong = static_cast<INT32> ( pItem->Data.FixedPoint.Long / FixedPointScale ); break; case EPSTYPE_DOUBLE: // Perform implicit type conversion a la PostScript *pLong = static_cast<INT32> ( pItem->Data.Double ); break; default: // Type mismatch - return error condition return FALSE; } // Delete item fron stack and return delete pItem; return TRUE; }

BOOL EPSStack::PopArray (  INT32 *  Array, INT32 *  Elements )

Pop a PostScript array object from the stack. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 15/4/95 Returns: TRUE if the array was popped ok, FALSE if an error occured. Errors: No syntactically correct array on the stack. See also: EPSStack::Discard Definition at line 1290 of file epsstack.cpp. { if (Array == NULL || Elements == NULL) return FALSE; if (GetType() != EPSTYPE_COMMAND) { TRACEUSER( "Will", _T("EPSStack::PopArray: Expected ArrayEnd\n")); return FALSE; } // First this we find should be the 'Array End' command (']') EPSCommand Cmd=EPSC_Invalid; PopCmd(&Cmd); if (Cmd != EPSC_ArrayEnd) { TRACEUSER( "Will", _T("EPSStack::PopArray: Expected ArrayEnd\n")); return FALSE; } INT32 NumElements = 0; // The array element will be popped off the stack backwards, // so we need to make a tempory array, so we can swap them, // around at the end. INT32* TempArray = new INT32[*Elements]; if (TempArray == NULL) return FALSE; // Read the rest of the array for(;;) { if (IsEmpty()) { // Run out of operands! TRACEUSER( "Will", _T("EPSStack::PopArray: Run out of operands\n")); delete TempArray; return FALSE; } if (GetType() != EPSTYPE_COMMAND) { // Pop the array member double Double=0.0; if (!Pop(&Double)) { delete TempArray; return FALSE; } if (NumElements < *Elements) { TempArray[NumElements] = (INT32) (Double * EPSScaleFactor); NumElements++; } } else { EPSCommand Cmd = ReadCmd(); if (!PopCmd(&Cmd) || Cmd != EPSC_ArrayStart) { TRACEUSER( "Will", _T("EPSStack::PopArray: Expected ArrayStart\n")); delete TempArray; return FALSE; } else break; // exit loop - end of array found } } *Elements = NumElements; // Actual number of elements read // Now swap the elements so they are the correct way around. if (NumElements > 0) { INT32 LastEl = NumElements - 1; for (INT32 el = 0; el < NumElements; el++) { Array[el] = TempArray[LastEl - el]; } } delete TempArray; // Array popped ok return TRUE; }

BOOL EPSStack::PopCmd (  EPSCommand *  pCmd  )

Pop an EPS command from the top of the stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: pCmd  - the command on top of the stack. [OUTPUTS] Returns: TRUE if there is an EPS command on the top of the stack; FALSE if not. Definition at line 706 of file epsstack.cpp. { // Get pointer to the stack item. EPSStackItem *pItem = static_cast<EPSStackItem*> ( RemoveHead () ); // Return error if no items on stack. if ( pItem == NULL ) return FALSE; // Check that the item is of the correct type if (pItem->Type == EPSTYPE_COMMAND) { // Correct type - remove item from stack and return to caller. *pCmd = pItem->Data.Cmd; delete pItem; return TRUE; } else { // Type mismatch - return error condition delete pItem; return FALSE; } }

BOOL EPSStack::PopColour (  PColourCMYK *  Col, TintType  Tint = TINT_NONE, FIXEDPOINT *  pTintVal = NULL, String_64 *  pName = NULL )

Extract CYMK values from an ArtWorks EPS format and convert to Camelot range. AWEPS colour values are in the range 0 to 1; this function converts them to the 0 to 255 range. See Also: EPSStack::PopColourRGB. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 18/10/93 Parameters: Col  - the CMYK values popped from the stack and converted to 0-255 range. [OUTPUTS] TintType - indicates what kind of tint is on the stack: TINT_NONE - no tint is on the stack TINT_ILLUSTRATOR - An Illustrator type tint is on the stack, i.e. a value between 0 and 1, with 0 being 100% and 1 being 0%. TINT_COREL - An Corel Draw type tint is on the stack, i.e. a value between 0 and 1, with 1 being 100% and 0 being 0%. TintVal - the value of the tint operand. pName - the textual name of this colour. If there is a tint, then the CMYK values are followed by a colour name and a tint value (0.0 to 1.0). The colour name is discarded, and the colour is adjusted according to the tint value found. Returns: TRUE if valid colour parameters were found on the stack; FALSE if not enough parameters, or if there are not enough, or if they are outside the 0-1 range. Definition at line 867 of file epsstack.cpp. { double Cyan, Magenta, Yellow, Key; FIXEDPOINT TintValue; TintValue=0; // Warning suppression if (Tint != TINT_NONE) { // Get the tint. if (!Pop(&TintValue)) return FALSE; // Does the caller want the name of the colour? if (pName == NULL) { // Name is not wanted - discard it if (!Discard()) return FALSE; } else { // Name is wanted - get it from the stack if (!Pop(pName)) return FALSE; } ENSURE((TintValue >= 0) && (TintValue <= 1000), "Bad tint"); // Convert Tint to sensible value, if required if (Tint == TINT_ILLUSTRATOR) TintValue = (1 * FixedPointScale) - (INT32) TintValue; if (pTintVal != NULL) *pTintVal = TintValue; } if (Pop(&Key) && Pop(&Yellow) && Pop(&Magenta) && Pop(&Cyan)) { if ((Cyan < 0.0) || (Cyan > 1.0) || (Magenta < 0.0) || (Magenta > 1.0) || (Yellow < 0.0) || (Yellow > 1.0) || (Key < 0.0) || (Key > 1.0)) // Invalid colour value return FALSE; // Got the values ok - translate from 0->1 range to sensible range. // NB. Important that we round up here, because otherwise 8 bit values will // sometimes fail to match on boundary conditions. Col->Cyan = (INT32) ((Cyan * 255.0) + 0.5); Col->Magenta = (INT32) ((Magenta * 255.0) + 0.5); Col->Yellow = (INT32) ((Yellow * 255.0) + 0.5); Col->Key = (INT32) ((Key * 255.0) + 0.5); if (Tint != TINT_NONE) { // Tint the colour Col->Cyan = (Col->Cyan * TintValue) / FixedPointScale; Col->Magenta = (Col->Magenta * TintValue) / FixedPointScale; Col->Yellow = (Col->Yellow * TintValue) / FixedPointScale; Col->Key = (Col->Key * TintValue) / FixedPointScale; } return TRUE; } else return FALSE; }

BOOL EPSStack::PopColourRGB (  INT32 *  red, INT32 *  green, INT32 *  blue, TintType  Tint = TINT_NONE, FIXEDPOINT *  pTintVal = NULL, String_64 *  pName = NULL )

Extract RGB values from a generic EPS format and convert to Camelot range. EPS colour values are in the range 0 to 1; this function converts them to the 0 to 255 range. See Also: EPSStack::PopColour. Author: Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/00 Parameters: red,green,blue  - the RGB values popped from the stack and converted to [OUTPUTS] 0-255 range. TintType - indicates what kind of tint is on the stack: TINT_NONE - no tint is on the stack TINT_ILLUSTRATOR - An Illustrator type tint is on the stack, i.e. a value between 0 and 1, with 0 being 100% and 1 being 0%. TINT_COREL - An Corel Draw type tint is on the stack, i.e. a value between 0 and 1, with 1 being 100% and 0 being 0%. TintVal - the value of the tint operand. pName - the textual name of this colour. NOTE: The tint is currently not supported for RGB colours, although the syntax has been kept to keep it consistent with the CMYK/Greyscale versions, as well to enable expansion of this function. Returns: TRUE if valid colour parameters were found on the stack; FALSE if not enough parameters, or if there are not enough, or if they are outside the 0-1 range. Definition at line 969 of file epsstack.cpp. { double tempRed, tempGreen, tempBlue; FIXEDPOINT TintValue; if (Tint != TINT_NONE) { // Get the tint. if (!Pop(&TintValue)) return FALSE; // Does the caller want the name of the colour? if (pName == NULL) { // Name is not wanted - discard it if (!Discard()) return FALSE; } else { // Name is wanted - get it from the stack if (!Pop(pName)) return FALSE; } ENSURE((TintValue >= 0) && (TintValue <= 1000), "Bad tint"); // Convert Tint to sensible value, if required if (Tint == TINT_ILLUSTRATOR) TintValue = (1 * FixedPointScale) - (INT32) TintValue; if (pTintVal != NULL) *pTintVal = TintValue; } if (Pop(&tempBlue) && Pop(&tempGreen) && Pop(&tempRed)) { if ((tempRed < 0.0) || (tempRed > 1.0) || (tempBlue < 0.0) || (tempBlue > 1.0) || (tempGreen < 0.0) || (tempGreen > 1.0)) // Invalid colour value return FALSE; // Got the values ok - translate from 0->1 range to sensible range. // NB. Important that we round up here, because otherwise 8 bit values will // sometimes fail to match on boundary conditions. *red = (INT32) ((tempRed * 255.0) + 0.5); *green = (INT32) ((tempGreen * 255.0) + 0.5); *blue = (INT32) ((tempBlue * 255.0) + 0.5); if (Tint != TINT_NONE) { // Tint the colour - Not currently done for RGB colours } return TRUE; } else return FALSE; }

BOOL EPSStack::PopCoord (  INT32 *  pLong  )

Pop a INT32 value from the top of the stack. If there is a fixed point value on the stack, it is converted before being returned to the caller. The value is scaled before being returned, so that it is easy to cope with EPS files that use brainless coordinate schemes (i.e. all of them). Scaling factor is initially 1, but can be changed via SetCoordScaleFactor(). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: pLong  - the (scaled) value popped from the stack. [OUTPUTS] Returns: TRUE if there is a numeric value on the top of the stack; FALSE if not. See also: EPSStack::SetCoordScaleFactor Definition at line 748 of file epsstack.cpp. { // Get pointer to the stack item. EPSStackItem *pItem = static_cast<EPSStackItem*> ( RemoveHead () ); // Return error if no items on stack. if ( pItem == NULL ) return FALSE; // Check that the item is of the correct type switch ( pItem->Type ) { case EPSTYPE_INT32: // Correct type - remove item from stack and return to caller. *pLong = ScaleFactor * (pItem->Data.Long); break; case EPSTYPE_FIXEDPOINT: // Perform implicit type conversion a la PostScript // Fixed point values are stored as value * 1000, so if the ScaleFactor is // actually 1000, don't bother to scale - just return the value. if (ScaleFactor == FixedPointScale) *pLong = static_cast<INT32> ( pItem->Data.FixedPoint.Long ); else { // Perform the necessary scaling *pLong = static_cast<INT32> ( pItem->Data.FixedPoint.Long * ( static_cast<double> ( ScaleFactor ) ) ); *pLong /= FixedPointScale; } break; case EPSTYPE_DOUBLE: // Perform implicit type conversion a la PostScript *pLong = static_cast<INT32> ( static_cast<double> ( ScaleFactor ) * pItem->Data.Double ); break; default: // Type mismatch - return error condition return FALSE; } // Delete item fron stack and return delete pItem; return TRUE; }

BOOL EPSStack::PopCoordPair (  DocCoord *  pCoord  )

Pop two INT32 values from the top of the stack. If they are in floating point format, they are converted before being returned to the caller. The coords are scaled and translated before being returned, so that it is easy to cope with EPS files that use brainless coordinate schemes (ArtWorks EPS are you listening?). Scaling factor is initially 1, but can be changed via SetCoordScaleFactor(). Origin is initially (0,0), but can be changed via SetCoordOrigin(). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: pCoord  - the (scaled and translated) coordinate pair popped from the stack. [OUTPUTS] Returns: TRUE if there is a coord pair on the top of the stack; FALSE if not. See also: EPSStack::SetCoordScaleFactor; EPSStack::SetCoordOrigin Definition at line 817 of file epsstack.cpp. { if (PopCoord(&(pCoord->y)) && PopCoord(&(pCoord->x))) { // Use the transform matrix if necessary. if (UseXformMatrix) XformMatrix.transform((Coord *) pCoord, 1); // Translate coord using given origin and return success. pCoord->x += Origin.x; pCoord->y += Origin.y; return TRUE; } else return FALSE; }

BOOL EPSStack::PopGrayScale (  PColourCMYK *  Col  )

Extract grayscale value from an EPS format file and convert to Camelot range. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/02/94 Parameters: Col  - the CMYK version of the grayscale popped from the stack and converted [OUTPUTS] to 0-255 range. Returns: TRUE if a valid grayscale parameter was found on the stack; FALSE if not. See also: PopColour Definition at line 1045 of file epsstack.cpp. { double Gray=0.0; if (Pop(&Gray)) { if ((Gray < 0.0) || (Gray > 1.0)) // invalid gray scale value return FALSE; // Got the grayscale ok - translate from 0->1 range to sensible range. PColourValue GrayVal = 255 - (static_cast<INT32> (Gray * 255)); Col->Cyan = 0; Col->Magenta = 0; Col->Yellow = 0; Col->Key = static_cast<BYTE> ( GrayVal ); return TRUE; } else return FALSE; }

BOOL EPSStack::Push (  const EPSCommand  Cmd  )

Push an EPS command onto the stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: Cmd  - the EPS command to push onto the stack. [INPUTS] Returns: TRUE if successful, FALSE if out of stack space. Definition at line 385 of file epsstack.cpp. { EPSStackItem *pItem = new EPSStackItem; // Ensure that the item has been created. if ( pItem == NULL) { // Clear the stack as the caller will now abort. DeleteAll (); // Tell caller about the error ERROR ( _R(IDT_EPS_STACKLIMIT), FALSE ); } // Initialise stack item. pItem->Init ( Cmd ); // Add it to the list. AddHead ( pItem ); return TRUE; }

BOOL EPSStack::Push (  const TCHAR *  pString, BOOL  IsName = FALSE )

Push a TCHAR* string item onto the stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: pString  - pointer to the string data to push onto the stack. [INPUTS] Returns: TRUE if successful, FALSE if out of memory or stack space. Definition at line 344 of file epsstack.cpp. { EPSStackItem *pItem = new EPSStackItem; // Ensure that the item has been created. if ( pItem == NULL) { // Clear the stack as the caller will now abort. DeleteAll (); // Tell caller about the error ERROR ( _R(IDT_EPS_STACKLIMIT), FALSE ); } // Try to copy string TCHAR *NewStr = new TCHAR[camStrlen(pString) + 1]; ERRORIF(NewStr == NULL, _R(IDT_EPS_NOMEMORY), FALSE); camStrcpy(NewStr, pString); // Initialise stack item. pItem->Init ( NewStr ); // Add it to the list. AddHead ( pItem ); return TRUE; }

BOOL EPSStack::Push (  const double  Double  )

Push a double value onto the stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: Double  - the data to push onto the stack. [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE if out of stack space. Definition at line 308 of file epsstack.cpp. { EPSStackItem *pItem = new EPSStackItem; // Ensure that the item has been created. if ( pItem == NULL) { // Clear the stack as the caller will now abort. DeleteAll (); // Tell caller about the error ERROR ( _R(IDT_EPS_STACKLIMIT), FALSE ); } // Initialise stack item. pItem->Init ( Double ); // Add it to the list. AddHead ( pItem ); return TRUE; }

BOOL EPSStack::Push (  const FIXEDPOINT  FixedPoint  )

Push a fixed point value onto the stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: FixedPoint  - the data to push onto the stack. [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE if out of stack space. Definition at line 272 of file epsstack.cpp. { EPSStackItem *pItem = new EPSStackItem; // Ensure that the item has been created. if ( pItem == NULL) { // Clear the stack as the caller will now abort. DeleteAll (); // Tell caller about the error ERROR ( _R(IDT_EPS_STACKLIMIT), FALSE ); } // Initialise stack item. pItem->Init ( FixedPoint ); // Add it to the list. AddHead ( pItem ); return TRUE; }

BOOL EPSStack::Push (  const INT32  Long  )

Push a INT32 value onto the stack. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: Long  - the data to push onto the stack. [INPUTS] Returns: TRUE if successful, FALSE if out of stack space. Definition at line 236 of file epsstack.cpp. { EPSStackItem *pItem = new EPSStackItem; // Ensure that the item has been created. if ( pItem == NULL) { // Clear the stack as the caller will now abort. DeleteAll (); // Tell caller about the error ERROR ( _R(IDT_EPS_STACKLIMIT), FALSE ); } // Initialise stack item. pItem->Init ( Long ); // Add it to the list. AddHead ( pItem ); return TRUE; }

EPSCommand EPSStack::ReadCmd (   )

Find out what command is on top of the stack. The command is not removed from the stack. Numbers, strings, names, etc. do not count as being commands. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 14/10/93 Returns: The EPS command on the top of the stack, or EPSC_Invalid if there is no EPS command at the top of the stack. See also: EPSStack::GetType Definition at line 1478 of file epsstack.cpp. { EPSStackItem *pItem = static_cast<EPSStackItem*> ( GetHead () ); if ( ( pItem == NULL ) || ( pItem->Type != EPSTYPE_COMMAND ) ) return EPSC_Invalid; else return pItem->Data.Cmd; }

void EPSStack::SetCoordOrigin (  DocCoord  NewOrigin  )

Set the translation values used by PopCoord(). Initially (0,0). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 15/10/93 Parameters: NewOrigin  - the new origin to use when translating coordinates. [INPUTS] See also: EPSStack::PopCoord() Definition at line 1161 of file epsstack.cpp. { Origin = NewOrigin; }

void EPSStack::SetCoordScaleFactor (  INT32  NewScaleFactor  )

Set the scale factor used by PopCoord(). Scaling factor is initially 1. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 15/10/93 Parameters: NewScaleFactor  - the new factor to use when scaling coordinates. [INPUTS] See also: EPSStack::PopCoord() Definition at line 1144 of file epsstack.cpp. { ScaleFactor = NewScaleFactor; }

void EPSStack::SetNoXformMatrix (   )

Disable the transformation matrix used by EPSStack::PopCoordPair(). See SetXFormMatrix() for details. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/94 See also: EPSStack::PopCoordPair; EPSStack::SetXFormMatrix Definition at line 1223 of file epsstack.cpp. { UseXformMatrix = FALSE; }

void EPSStack::SetXformMatrix (  Matrix &  NewMatrix  )

Sets up an additional transformation matrix to be used when decoding document coordinates (via EPSStack::PopCoordPair). When a transform matrix is active, all coords returned from PopCoordPair will have been transformed by the matrix after first having had the usual origin translation performed. The transformation matrix can be disabled by called SetNoXFormMatrix(). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/94 Parameters: NewMatrix  - the matrix to use from now on. [INPUTS] Returns: Errors: - See also: EPSStack::PopCoordPair; EPSStack::SetNoXFormMatrix Definition at line 1204 of file epsstack.cpp. { // Install the new matrix XformMatrix = NewMatrix; UseXformMatrix = TRUE; }

void EPSStack::TranslateCoordOrigin (  MILLIPOINT  dx, MILLIPOINT  dy )

Translate the current origin for the EPS file by the given amounts. This is used when the %BoundingBox comment is encountered, so that the image appears in a sensible place. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 08/04/94 Parameters: dx,dy  - the translation values. [INPUTS] See also: EPSStack::SetCoordOrigin Definition at line 1180 of file epsstack.cpp. { Origin.x += dx; Origin.y += dy; }

---

Member Data Documentation

DocCoord EPSStack::Origin [private]

Definition at line 225 of file epsstack.h.

INT32 EPSStack::ScaleFactor [private]

Definition at line 224 of file epsstack.h.

BOOL EPSStack::UseXformMatrix [private]

Definition at line 228 of file epsstack.h.

Matrix EPSStack::XformMatrix [private]

Definition at line 227 of file epsstack.h.

---

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

• Kernel/epsstack.h (r1785/r1302)
• Kernel/epsstack.cpp (r1785/r1660)

---