CorelEPSFilter Class Reference

A base class filter that implements the core functionality required for a Corel EPS import filter. Other filters are derived from this - this class is never instantiated as it is incomplete. More...

#include <coreleps.h>

Inheritance diagram for CorelEPSFilter:

List of all members.

Public Member Functions
	CorelEPSFilter ()
	Constructor for an CorelEPSFilter object. The object should be initialised before use.
BOOL	Init ()
	Initialise an CorelEPSFilter object.
char *	GetEPSCommand (EPSCommand Cmd)
	Given an EPS token, return the string representation of it; mainly for debugging purposes.
Protected Member Functions
virtual void	LookUpToken ()
	Compare the current token against the Corel keywords to see if it is one of them.
virtual BOOL	ProcessToken ()
	Processes EPS tokens that are not part of the standard Illustrator set. i.e. this is the function that handles all the Corel EPS operators.
BOOL	DecodeCorelGradFill ()
	Convert the preposterous Corel format of graduated fill information into something that resembles sanity, and install it as the current fill. The graduated fill information is assumed to be in the CorelEPSFilter::GradFillInfo structure.
BOOL	DecodeLinearGradFill ()
	Convert the Corel grad values (padding, angle of fill etc) into a Camelot style grad fill - i.e. start and end points, like Camelot. This function copes with all styles of Corel linear graduated fills.
BOOL	DecodeRadialGradFill ()
	Convert the Corel grad values (padding, centre of fill etc) into a Camelot style radial fill - i.e. start and end points, like ArtWorks. The calculations may seem strange. They are - but that's how Corel define their grad fills.
BOOL	DecodeConicalGradFill ()
	Convert the Corel grad values (padding, centre of fill etc) into a Camelot style radial fill - i.e. start and end points, like ArtWorks.
BOOL	AddAttributes (NodeRenderableBounded *pNode, BOOL Stroked, BOOL Filled)
	Used as a veneer to EPSFilter::AddAttributes. It checks to see if the current fill style is a graduated fill - if it is, then it calls CorelEPSFilter::DecodeCorelGradFill, which converts the Corel form of the grad fill to the Camelot form. This must be done for each object, as the grad fill is stored relative to the object's bounding box in Corel EPS files.
Protected Attributes
CorelEPSFilter::CCAPI	GradFillInfo
BOOL	GradFill
DocColour	StartColour
DocColour	EndColour
Static Protected Attributes
static CommandMap	CorelCommands []
Private Member Functions
	CC_DECLARE_DYNAMIC (CorelEPSFilter)
Classes
struct	CCAPI

---

Detailed Description

A base class filter that implements the core functionality required for a Corel EPS import filter. Other filters are derived from this - this class is never instantiated as it is incomplete.

Author:

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

Date:

08/03/94

See also:

Corel3EPSFilter; Corel4EPSFilter; EPSFilter

Definition at line 119 of file coreleps.h.

---

Constructor & Destructor Documentation

CorelEPSFilter::CorelEPSFilter (   )

Constructor for an CorelEPSFilter object. The object should be initialised before use. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/10/93 See also: EPSFilter::Init Definition at line 208 of file coreleps.cpp. { // Set up filter description. FilterID = FILTERID_NONE; #ifndef STANDALONE Flags.CanImport = TRUE; Flags.CanExport = FALSE; #else Flags.CanImport = FALSE; Flags.CanExport = FALSE; #endif // Corel EPS does not store layer information SupportsLayers = FALSE; }

---

Member Function Documentation

BOOL CorelEPSFilter::AddAttributes (  NodeRenderableBounded *  pNode, BOOL  Stroked, BOOL  Filled )  [protected, virtual]

Used as a veneer to EPSFilter::AddAttributes. It checks to see if the current fill style is a graduated fill - if it is, then it calls CorelEPSFilter::DecodeCorelGradFill, which converts the Corel form of the grad fill to the Camelot form. This must be done for each object, as the grad fill is stored relative to the object's bounding box in Corel EPS files. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 18/04/94 Parameters: pNode  - the bounded renderable node to add atributes to. [INPUTS] Stroked - TRUE if the object to add attributes to should be stroked, FALSE if not. Stroked - TRUE if the object to add attributes to should be filled, FALSE if not. Returns: TRUE if the attributes were added ok; FALSE if not. Errors: Out of memory. See also: EPSFilter::AddAttributes; CorelEPSFilter::DeocdeCorelGradFill Reimplemented from EPSFilter. Definition at line 1093 of file coreleps.cpp. { // Check to see if we need to set up a Corel graduated fill attribute if (GradFill) { GradFill = FALSE; // Try to set up the grad fill for this object. if (!DecodeCorelGradFill()) return FALSE; } // Call the base class version return EPSFilter::AddAttributes(pNode, Stroked, Filled); }

CorelEPSFilter::CC_DECLARE_DYNAMIC (  CorelEPSFilter   )  [private]

BOOL CorelEPSFilter::DecodeConicalGradFill (   )  [protected]

Convert the Corel grad values (padding, centre of fill etc) into a Camelot style radial fill - i.e. start and end points, like ArtWorks. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 19/04/94 Returns: TRUE if grad fill converted without problems; FALSE if not. Errors: Out of memory. See also: CorelEPSFilter::DecodeCorelGradFill; CorelEPSFilter::DecodeLinearGradFill Definition at line 1016 of file coreleps.cpp. { // modified by Ben to get the start and end points right // The desired start and end points of the grad fill 'arrow'. DocCoord Start, End; // First, get the bounding box. DocRect BBox; CDRFilter::GetCorelBBox(pPath, &BBox); // Calculate width and height MILLIPOINT Width = BBox.Width(); MILLIPOINT Height = BBox.Height(); // Start point is the centre given by Corel. // This centre is percentage offsets from the centre of the object, i.e. (0,0) is // the centre of the bounding box. Start.x = BBox.lo.x + (Width / 2); Start.y = BBox.lo.y + (Height / 2); Start.x += ((GradFillInfo.RotateX * Width) / 100); Start.y += ((GradFillInfo.RotateY * Height) / 100); // End point is start point + radius but takes into account the angle double Radius = Width / 2; // angle is * 10, and needs to be in radians double Theta = (((double)(GradFillInfo.Angle)) / 360.0) * (2 * PI); // make the angle go anti-clockwise Theta = 0 - Theta; // rotate by PI / 2 Theta -= PI / 2; // angle can be negative, ensure it's positive while(Theta < 0) Theta += (2 * PI); // calculate the triangle double dx, dy; dx = Radius * sin(Theta); dy = Radius * cos(Theta); End.x = Start.x + (INT32)dx; End.y = Start.y + (INT32)dy; // Seems that we need to swap start and end colours... // Set the fill type according to these calculations. return SetConicalFill(EndColour, StartColour, Start, End); }

BOOL CorelEPSFilter::DecodeCorelGradFill (   )  [protected]

Convert the preposterous Corel format of graduated fill information into something that resembles sanity, and install it as the current fill. The graduated fill information is assumed to be in the CorelEPSFilter::GradFillInfo structure. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 18/04/94 Returns: TRUE if grad fill converted without problems; FALSE if not. Definition at line 702 of file coreleps.cpp. { switch (GradFillInfo.FillType) { case 0: return DecodeLinearGradFill(); case 1: case 3: // square - radial is closest approximation return DecodeRadialGradFill(); case 2: return DecodeConicalGradFill(); } // Can't handle any other kinds of fills - ignore them. return TRUE; }

BOOL CorelEPSFilter::DecodeLinearGradFill (   )  [protected]

Convert the Corel grad values (padding, angle of fill etc) into a Camelot style grad fill - i.e. start and end points, like Camelot. This function copes with all styles of Corel linear graduated fills. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 19/04/94 Returns: TRUE if grad fill converted without problems; FALSE if not. Errors: Out of memory. See also: CorelEPSFilter::DecodeCorelGradFill; CorelEPSFilter::DecodeRadialGradFill Definition at line 737 of file coreleps.cpp. { // NB. this function is (hopefully!) over-complex and will be simplified. // However, it's like this atm so I can get my head around the weird maths // The desired start and end points of the grad fill 'arrow'. DocCoord Start, End; // First, get the bounding box. DocRect BBox; CDRFilter::GetCorelBBox(pPath, &BBox); // Calculate width and height MILLIPOINT Width = BBox.Width(); MILLIPOINT Height = BBox.Height(); // Find centre of box DocCoord Centre; Centre.x = BBox.lo.x + (Width / 2); Centre.y = BBox.lo.y + (Height / 2); // Find total area of BBox double TotalArea = (double) Width * (double) Height; // Cope with angles > 180 BOOL Mirror = FALSE; INT32 Angle = GradFillInfo.Angle; if (Angle >= 180) { Angle -= 180; Mirror = TRUE; } else if (Angle < 0) { Angle += 180; Mirror = TRUE; } Angle += 90; if (Angle >= 180) { Angle -= 180; } // Calculate tan of the angle - convert angle to radians first. double Radians = (((double) Angle) / 180.0) * PI; double TanTheta; if (Angle == 90) { // Special case for horizontal grad fill arrow. // Make 0% padding first Start.x = BBox.lo.x; Start.y = Centre.y; End.x = BBox.hi.x; End.y = Centre.y; // Find out width of padding INT32 Padding = (Width * GradFillInfo.EdgePad) / 100; Start.x += Padding; End.x -= Padding; } else if (Angle == 0) { // Special case for vertical grad fill arrow. // Make 0% padding first Start.x = Centre.x; Start.y = BBox.lo.y; End.x = Centre.x; End.y = BBox.hi.y; // Find out width of padding INT32 Padding = (Height * GradFillInfo.EdgePad) / 100; Start.y += Padding; End.y -= Padding; } else { TanTheta = tan(Radians); // Find out what the maximum padding is that we can achieve using just triangles: // Find the maximum triangle width MILLIPOINT TriWidth = (MILLIPOINT) ((double) Height / TanTheta); // Limit it to sensible value if (TriWidth < 0) TriWidth = -TriWidth; if (TriWidth > Width) TriWidth = Width; // Find the maximum triangle width MILLIPOINT TriHeight = (MILLIPOINT) ((double) Width * TanTheta); // Limit it to sensible value if (TriHeight < 0) TriHeight = -TriHeight; if (TriHeight > Height) TriHeight = Height; // The 'c' values of the y = mx+c equation. MILLIPOINT StartC, EndC; // Work out the maximum percentage/edge padding this gives us // (50 because it's 100 / 2 because we want area of triangle, not rectangle). double Percentage = (50.0 * (double) TriWidth * (double) TriHeight) / TotalArea; INT32 Diff = 0; // Is this enough? if (((INT32) Percentage) >= GradFillInfo.EdgePad) { // Yes - calculate exactly how big the triangle needs to be. TriHeight = (MILLIPOINT) sqrt(ABS(((double) GradFillInfo.EdgePad * TotalArea * TanTheta) / 100.0)); TriWidth = (MILLIPOINT) ((double) TriHeight / TanTheta); if (TriWidth < 0) TriWidth = -TriWidth; ENSURE(TriWidth < Width, "Error in Corel Grad fill decoding logic"); } else { // How much percentage do we need to add with each rectangle? Percentage = (GradFillInfo.EdgePad - Percentage) / 2; // Handle the rectangle stuff. if (TriWidth == Width) { // Need to add rectangles to the top and bottom. Diff = (MILLIPOINT) ((Percentage * Height) / 100.0); } else { // Need to add rectangles to left and right Diff = (MILLIPOINT) ((Percentage * Width) / 100.0); Diff = (MILLIPOINT) (Diff / tan(PI - Radians)); Diff = ABS(Diff); } } // Work out the C value for the start line (c = y - mx) // (m = tan(angle) ) if (Angle == 90) { //ENSURE(FALSE, "90 degree angle found!"); } else if (Angle < 90) { StartC = (MILLIPOINT) (BBox.lo.y - ((BBox.hi.x - TriWidth) * TanTheta)); EndC = (MILLIPOINT) (BBox.hi.y - ((BBox.lo.x + TriWidth) * TanTheta)); } else { StartC = (MILLIPOINT) (BBox.lo.y - ((BBox.lo.x + TriWidth) * TanTheta)); EndC = (MILLIPOINT) (BBox.hi.y - ((BBox.hi.x - TriWidth) * TanTheta)); } // Add on difference for rectangles, if any. StartC += Diff; EndC -= Diff; // Work out m and c for the grad fill line. // We know m is -1/m of the triangle's hypotenuse. // c = roy - (rox/m) double FillM = -1.00 / TanTheta; MILLIPOINT FillC = (MILLIPOINT) (Centre.y - (Centre.x * FillM)); // Work out intersections: x = (c2 - c1) / (2m) Start.x = (MILLIPOINT) ( (FillC - StartC) / (TanTheta + (1.00 / TanTheta)) ); Start.y = (MILLIPOINT) ((FillM * Start.x) + FillC); End.x = (MILLIPOINT) ( (FillC - EndC) / (TanTheta + (1.00 / TanTheta)) ); End.y = (MILLIPOINT) ((FillM * End.x) + FillC); } if (Mirror) { // Swap the grid fill end-points over. DocCoord Tmp = Start; Start = End; End = Tmp; } // Set the fill type according to these calculations. return SetLinearFill(StartColour, EndColour, Start, End); }

BOOL CorelEPSFilter::DecodeRadialGradFill (   )  [protected]

Convert the Corel grad values (padding, centre of fill etc) into a Camelot style radial fill - i.e. start and end points, like ArtWorks. The calculations may seem strange. They are - but that's how Corel define their grad fills. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24/04/95 Returns: TRUE if grad fill converted without problems; FALSE if not. Errors: Out of memory. See also: CorelEPSFilter::DecodeCorelGradFill; CorelEPSFilter::DecodeLinearGradFill Definition at line 947 of file coreleps.cpp. { // The desired start and end points of the grad fill 'arrow'. DocCoord Start, End; // First, get the bounding box. DocRect BBox; CDRFilter::GetCorelBBox(pPath, &BBox); // Calculate width and height MILLIPOINT Width = BBox.Width(); MILLIPOINT Height = BBox.Height(); // caluculate the source area // first, what's the diagonal length double dWidth = Width; double dHeight = Height; INT32 Diagonal = (INT32)sqrt(dWidth*dWidth + dHeight*dHeight); // and from that calculate area of the box containing the bit of the // bit of the circle in the bbox INT32 Edge = (Diagonal * (100 - (GradFillInfo.EdgePad * 2))) / 100; // Start point is the centre given by Corel. // This centre is percentage offsets from the centre of the object, i.e. (0,0) is // the centre of the bounding box. DocCoord Centre = DocCoord(BBox.lo.x + (Width / 2), BBox.lo.y + (Height / 2)); INT32 OffX = (GradFillInfo.RotateX * Width) / 100; INT32 OffY = (GradFillInfo.RotateY * Height) / 100; Start.x = Centre.x + OffX; Start.y = Centre.y + OffY; // Find required radius of circle. double Radius = Edge / 2; // how far away is the centre of the fill from the centre of the bbox? double dOffX = OffX; double dOffY = OffY; double Dist = (INT32)sqrt(dOffX*dOffX + dOffY*dOffY); // and increase the radius by a bodge factor double BodgeFactor = 1 + (Dist / (double)(Diagonal / 2)); Radius *= BodgeFactor; // End point is start point + radius End.x = Start.x + ((MILLIPOINT) Radius); End.y = Start.y; // Seems that we need to swap start and end colours... // Set the fill type according to these calculations. return SetRadialFill(EndColour, StartColour, Start, End); }

char * CorelEPSFilter::GetEPSCommand (  EPSCommand  Cmd  )

Given an EPS token, return the string representation of it; mainly for debugging purposes. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/02/94 Parameters: Cmd  - the EPS token, e.g. EPSC_cd_c [INPUTS] Returns: Pointer to the string representation of the token, e.g. "@c" Reimplemented from EPSFilter. Reimplemented in Corel3EPSFilter, and Corel4EPSFilter. Definition at line 671 of file coreleps.cpp. { INT32 i = 0; while (CorelCommands[i].Cmd != EPSC_Invalid) { if (CorelCommands[i].Cmd == Cmd) return CorelCommands[i].CmdStr; // Try next command i++; } // Couldn't find it - default to base class method return EPSFilter::GetEPSCommand(Cmd); }

BOOL CorelEPSFilter::Init (  void   )  [virtual]

Initialise an CorelEPSFilter object. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/02/94 Returns: TRUE if the filter was initialised ok, FALSE otherwise. Errors: Will fail if not enough memory to initialise the EPS stack. See also: EPSStack Reimplemented from EPSFilter. Reimplemented in Corel3EPSFilter, and Corel4EPSFilter. Definition at line 238 of file coreleps.cpp. { // All ok return TRUE; }

void CorelEPSFilter::LookUpToken (   )  [protected, virtual]

Compare the current token against the Corel keywords to see if it is one of them. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 25/02/94 See also: EPSFilter::LookUpToken Reimplemented from EPSFilter. Reimplemented in Corel3EPSFilter, and Corel4EPSFilter. Definition at line 256 of file coreleps.cpp. { // Not interested in comments if (Token == EPSC_Comment) return; // Check to see if it is a keyword - cycle through the array of keyword names and // compare against our token (could use a hash table?) INT32 i = 0; while (CorelCommands[i].Cmd != EPSC_Invalid) { if (camStrcmp(TokenBuf, CorelCommands[i].CmdStr) == 0) { // Found the token - set the token variable and return success Token = CorelCommands[i].Cmd; return; } // Try next command i++; } // Did not find this token - pass on to base class. EPSFilter::LookUpToken(); }

BOOL CorelEPSFilter::ProcessToken (   )  [protected, virtual]

Processes EPS tokens that are not part of the standard Illustrator set. i.e. this is the function that handles all the Corel EPS operators. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 25/02/94 Returns: TRUE if token understood and processed ok, FALSE if not. Errors: Syntax error in EPS, Out of memory. See also: EPSFilter::ProcessToken Reimplemented from EPSFilter. Reimplemented in Corel3EPSFilter, and Corel4EPSFilter. Definition at line 295 of file coreleps.cpp. { // Variables used to extract operands from the stack DocCoord Coords[3]; INT32 Long; FIXEDPOINT FixedPoint; PColourCMYK Col; DocColour DocCol; String_64 ColName; FIXEDPOINT TintVal; // Decode the command, and execute it... switch (Token) { case EPSC_S: case EPSC_b: case EPSC_B: case EPSC_f: case EPSC_F: case EPSC_s: if (ThePathType == PATH_DISCARD) { // Discard this path, but try to use the next one. ThePathType = PATH_NORMAL; break; } if (ThePathType == PATH_DISCARD_STICKY) // Keep discarding paths until explicitly told not to. break; ENSURE((ThePathType == PATH_NORMAL) || (ThePathType == PATH_RECT) || (ThePathType == PATH_ELLIPSE), "No path in stroke!"); // If no path being constructed, probably just some strange masking going on // that we can't cope with yet, so ignore it. if (pPath == NULL) break; // Terminate path - always have to do this with Corel EPS, as it doesn't // do it itself. if ((Token == EPSC_s) || (Token == EPSC_b) || (Token == EPSC_f)) { if (!pPath->InkPath.CloseSubPath()) // Not enough dynamic heap to insert the final element of the path goto NoMemory; } // Make the path filled or not, depending on the EPS token. // NB. The IsFilled flag is set here too - this is an area in which // Corel EPS is different to AI/AW/Camelot EPS. if ((Token == EPSC_b) || (Token == EPSC_B) || (Token == EPSC_F) || (Token == EPSC_f)) { pPath->InkPath.IsFilled = TRUE; SetPathFilled(TRUE); } else { pPath->InkPath.IsFilled = FALSE; SetPathFilled(FALSE); } if (!EPSFlags.ComplexPath) { // Not a complex path, so we terminate properly. pPath->InvalidateBoundingRect(); // Add the attributes, if we haven't done so for this path if (EPSFlags.NoAttributes) { if (!AddAttributes(pPath, (Token != EPSC_f) && (Token != EPSC_F), pPath->InkPath.IsFilled)) goto NoMemory; EPSFlags.NoAttributes = FALSE; } // Add this path into the tree if (!AddNewNode(pPath)) goto NoMemory; // We've finished building this path - set to NULL so the other routines // know that we're not building a path any more. pPath = NULL; pInkPath = NULL; } else EPSFlags.StrokeComplexPath = (Token != EPSC_f) && (Token != EPSC_F); // Handle the next path normally ThePathType = PATH_NORMAL; break; case EPSC_cd_0sv: case EPSC_cd_0sm: case EPSC_cd_0rs: case EPSC_cd_0rax: // Ignore these commands - not needed break; case EPSC_cd_0E: // Bounding box of object - ignore it; we do it ourselves if (!Stack.Discard(4)) goto EPSError; break; case EPSC_cd_0B: case EPSC_cd_a: case EPSC_cd_r: // We don't need these commands - it seems safe to ignore them. // I think they're something to do with text handling, so when we do text // imoport, we'll need to process them properly. break; case EPSC_cd_0G: case EPSC_cd_0g: // Check the flag on the stack if (!Stack.Pop(&Long)) goto EPSError; if (Long == 1) { // Discard the 3 top values from the stack if (!Stack.Discard(3)) goto EPSError; } break; case EPSC_cd_0J: case EPSC_cd_0j: // Save/restore not needed - ignore break; case EPSC_cd_0w: // NOT IMPLEMENTED IN FULL // Set current line width to 1 (defined in points) if (!Stack.Discard(2)) goto EPSError; if (Stack.Pop(&FixedPoint)) { // Scale line width from points to millipoints, and remember for future // objects. if (!SetLineWidth((MILLIPOINT) (FixedPoint * EPSScaleFactor) / FixedPointScale)) goto NoMemory; // Check the flag if (Stack.Pop(&Long)) { if (Long == 1) { if (!Stack.DiscardArray()) goto EPSError; } } else goto EPSError; } else goto EPSError; break; case EPSC_cd_0c: // Close the current path if (pPath == NULL) // No path to close! goto EPSError; if (!pPath->InkPath.CloseSubPath()) // Not enough dynamic heap to insert the final element of the path goto NoMemory; break; case EPSC_cd_0t: // Display text - ignore for now; discard (x, y, string) if (!Stack.Discard(3)) goto EPSError; break; case EPSC_cd_0tm: { // Set text matrix - use this to update the stack's transform matrix, as // otherwise pathified text will not be imported correctly. EPSCommand Cmd; Stack.PopCmd(&Cmd); if (Cmd != EPSC_ArrayEnd) { if (IsUserName("Tim")) TRACE( _T("@tm: Expected ArrayEnd, found '%s'\n"), GetEPSCommand(Cmd)); goto EPSError; } // Extract the six array values from the stack. double M[6]; INT32 i = 5; for (i = 5; i >= 0; i--) { if (!Stack.Pop(&M[i])) goto EPSError; } Stack.PopCmd(&Cmd); if (Cmd != EPSC_ArrayStart) { if (IsUserName("Tim")) TRACE( _T("@tm: Expected ArrayStart, found '%s'\n"), GetEPSCommand(Cmd)); goto EPSError; } // 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 and tell the EPS stack to use it for future // coordinates. Matrix TextMatrix(F16[0], F16[1], F16[2], F16[3], L1, L2); Stack.SetXformMatrix(TextMatrix); break; } case EPSC_cd_x: // Set current fill colour (CMYK) GradFill = FALSE; if (Stack.PopColour(&Col, TINT_COREL, &TintVal, &ColName)) { GetEPSColour(&DocCol, &Col, TINT_COREL, TintVal, &ColName); // Remember this fill colour for future objects if (!SetFillColour(DocCol)) goto NoMemory; } else // Invalid colour operands goto EPSError; break; case EPSC_cd_X: // Set current line colour (CMYK) if (Stack.PopColour(&Col, TINT_COREL, &TintVal, &ColName)) { GetEPSColour(&DocCol, &Col, TINT_COREL, TintVal, &ColName); // Remember this line colour for future objects if (!SetLineColour(DocCol)) goto NoMemory; } else // Invalid colour operands goto EPSError; break; case EPSC_cd_e: // Set text fill mode - ignore break; case EPSC_cd_z: // Get and scale font - ignore; discard font name and scale if (!Stack.Discard(2)) goto EPSError; break; case EPSC_cd_Z: // Change font encosing vector - ignore; discard font names and encoding vector. if (!Stack.Discard(3) || !Stack.DiscardArray()) goto EPSError; break; case EPSC_cd_T: // Stop using text matrix for transformations. Stack.SetNoXformMatrix(); break; // MoveTo case EPSC_cd_m: // Get the co-ordinate from the stack if (Stack.PopCoordPair(&Coords[0])) { if (pPath == NULL) { ERROR3IF(pInkPath != NULL,"Already got a path"); if (pInkPath != NULL) goto EPSError; // Create a new NodePath object pPath = new NodePath; // No attributes on the path yet EPSFlags.NoAttributes = TRUE; if ((pPath == NULL) || (!pPath->SetUpPath())) // Not enough memory to initialise path goto NoMemory; // Position tag at start of path. pPath->InkPath.FindStartOfPath(); // Point inkpath pointer at the nodepath's path object. pInkPath = &pPath->InkPath; } // Insert a moveto into the path if (!pPath->InkPath.InsertMoveTo(Coords[0])) // Not enough dynamic heap to insert the moveto command goto NoMemory; } else // Invalid number/type of coordinate operands goto EPSError; break; case EPSC_matrix: // NOT IMPLEMENTED IN FULL // Push dummy argument on Stack.Push((INT32) 0); break; case EPSC_currentmatrix: // NOT IMPLEMENTED IN FULL // Ignore this command break; case EPSC_def: // Pretend to do a 'def' - discard name and defn from stack if (!Stack.Discard(2)) goto EPSError; break; case EPSC_begin: // Pretend to do a 'begin' - discard dictionary if (!Stack.Discard()) goto EPSError; break; default: // Token not understood - pass onto base class. return EPSFilter::ProcessToken(); } // No errors encountered while parsing this token and its operands. return TRUE; // Error handlers: EPSError: HandleEPSError(); return FALSE; NoMemory: HandleNoMemory(); return FALSE; }

---

Member Data Documentation

CommandMap CorelEPSFilter::CorelCommands [static, protected]

Definition at line 139 of file coreleps.h.

DocColour CorelEPSFilter::EndColour [protected]

Definition at line 155 of file coreleps.h.

BOOL CorelEPSFilter::GradFill [protected]

Definition at line 152 of file coreleps.h.

struct CorelEPSFilter::CCAPI CorelEPSFilter::GradFillInfo [protected]

DocColour CorelEPSFilter::StartColour [protected]

Definition at line 155 of file coreleps.h.

---

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

• Kernel/coreleps.h (r1785/r1282)
• Kernel/coreleps.cpp (r1785/r1312)

---