FreeHandEPSFilter Class Reference

Aldus FreeHand 3.0 filter. More...

#include <freeeps.h>

Inheritance diagram for FreeHandEPSFilter:

List of all members.

Public Member Functions
	FreeHandEPSFilter ()
	Constructor for an FreeHandEPSFilter object. The object should be initialised before use.
BOOL	Init ()
	Initialise an FreeHandEPSFilter object.
Protected Member Functions
BOOL	PrepareToImport ()
	prepares to import a freehand EPS file
INT32	EPSHeaderIsOk (ADDR pFileHeader, UINT32 HeaderSize)
	Checks to see if the EPS comment headers specify that this is an FreeHand 3.0 generated EPS file, as required.
void	LookUpToken ()
	Compare the current token against the AI keywords to see if it is one of them.
BOOL	ProcessToken ()
	Examines the current token and performs whatever actions are necessary to process its meaning. Operands are simply pushed onto the EPS stack, and keywords are either acted upon, or ignored if they describe something that Camelot does not yet support (in the latter case, the operands of the keyword, if any, are simply discarded from the stack).
void	CleanUpAfterImport (BOOL Successful)
	clears up after importing a FreeHand 3.0 EPS file
BOOL	ValidateGroup (Node *pGroup)
	validates a group created by the filter. As all objects have a group around then, this removes groups which only have one entry.
BOOL	MaskedGroupEnding ()
	Restores the graphic state after a masked group ends.
virtual BOOL	AddNewNode (Node *pNewNode)
	checks to see if we're in complex path mode before passing on the node to the base class. If we are, it joins it to the last one and fiddles about with the attributes.
Private Member Functions
	CC_DECLARE_DYNAMIC (FreeHandEPSFilter)
BOOL	PopColour (DocColour *Col)
	Pops a FreeHand colour off the stack.
BOOL	PopNamedColour (DocColour *Col)
	Pops a FreeHand named colour off the stack.
BOOL	DiscardFillSubType ()
	discards a fill sub type from the stack ('{}' or '{logtaper}' or something)
BOOL	SaveCurrentFill ()
	stores the current fill attribute
BOOL	RestoreCurrentFill ()
	restores the current fill attribute from the stored one
BOOL	RemoveLastSubPathIfNotUnique (Path *pPath)
	Removes the last subpath from a path if an sub path with it's exact coords already exists.
Private Attributes
BOOL	HadhToken
BOOL	DoingGradFill
AttributeValue *	OldFill
BOOL	InColours
BOOL	InText
ImportedColours *	pNewColours
IndexedColour **	ColourArray
INT32	ColourArrayEntries
INT32	ColourArraySize
BOOL	ComplexPathMode
BOOL	HadFirstOfComplexPath
NodePath *	pLastPathSeen
Static Private Attributes
static CommandMap	FHCommands []

---

Detailed Description

Aldus FreeHand 3.0 filter.

Author:

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

Date:

31/05/95

Definition at line 121 of file freeeps.h.

---

Constructor & Destructor Documentation

FreeHandEPSFilter::FreeHandEPSFilter (   )

Constructor for an FreeHandEPSFilter object. The object should be initialised before use. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 31/05/95 See also: EPSFilter::Init Definition at line 213 of file freeeps.cpp. { // Set up filter descriptions. FilterNameID = _R(IDT_FREEHANDEPS_FILTERNAME); FilterInfoID = _R(IDT_FREEHANDEPS_FILTERINFO); ImportMsgID = _R(IDT_IMPORTMSG_FREEHANDEPS); FilterID = FILTERID_FREEHAND_EPS; Flags.CanImport = TRUE; Flags.CanExport = FALSE; AdjustOrigin = FALSE; }

---

Member Function Documentation

BOOL FreeHandEPSFilter::AddNewNode (  Node *  pNewNode  )  [protected, virtual]

checks to see if we're in complex path mode before passing on the node to the base class. If we are, it joins it to the last one and fiddles about with the attributes. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 19/06/95 Returns: error flag Reimplemented from EPSFilter. Definition at line 1409 of file freeeps.cpp. { if(IS_A(pNewNode, NodePath)) pLastPathSeen = (NodePath *)pNewNode; // check to see if we want to handle this if((ComplexPathMode == FALSE) || (pNewNode == 0) || (pNode == 0) || (!IS_A(pNewNode, NodePath))) return EPSFilter::AddNewNode(pNewNode); // check to see if this is the first... if(HadFirstOfComplexPath == FALSE) { HadFirstOfComplexPath = TRUE; return EPSFilter::AddNewNode(pNewNode); } // find the last child of the node Node *pLastChild = pNode->FindLastChild(); if(pLastChild == 0 || !IS_A(pLastChild, NodePath)) return EPSFilter::AddNewNode(pNewNode); // we know that both of these things are NodePaths. Path *pTarget = &((NodePath *)pLastChild)->InkPath; Path *pAddition = &((NodePath *)pNewNode)->InkPath; // work out the new flags for the target BOOL TargetFilled = pTarget->IsFilled; BOOL TargetStroked = pTarget->IsStroked; if(pAddition->IsFilled) TargetFilled = TRUE; if(pAddition->IsStroked) TargetStroked = TRUE; // add this new path to the old one... if(!pTarget->MergeTwoPaths(*pAddition)) return FALSE; // check that the thing we just added isn't already there if(!RemoveLastSubPathIfNotUnique(pTarget)) return FALSE; // set it's flags pTarget->IsFilled = TargetFilled; pTarget->IsStroked = TargetStroked; // vape it's attributes pLastChild->DeleteChildren(pLastChild->FindFirstChild()); // apply some new ones SetPathFilled(TargetFilled); if(!AddAttributes((NodePath *)pLastChild, TargetStroked, TargetFilled)) return FALSE; // hide the nice additional path //if(!ImportInfo.pOp->DoHideNode(pNewNode, TRUE)) // return FALSE; pNewNode->CascadeDelete(); delete pNewNode; // set the last seen path bollox pLastPathSeen = (NodePath *)pLastChild; // done! return TRUE; }

FreeHandEPSFilter::CC_DECLARE_DYNAMIC (  FreeHandEPSFilter   )  [private]

void FreeHandEPSFilter::CleanUpAfterImport (  BOOL  Successful  )  [protected, virtual]

clears up after importing a FreeHand 3.0 EPS file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 02/06/95 Returns: error flag See also: EPSFilter Reimplemented from EPSFilter. Definition at line 316 of file freeeps.cpp. { // ensure that there's no old fill hanging around if(OldFill != 0) delete OldFill; OldFill = 0; // add new colours if successful, destroy them if not if(Successful) { pNewColours->AddColoursToDocument(); } else { pNewColours->DestroyColours(); } // delete the colour reference array if(ColourArray != 0) { CCFree(ColourArray); ColourArray = 0; } // get rid of any stuff in the stack Stack.DeleteAll (); EPSFilter::CleanUpAfterImport(Successful); }

BOOL FreeHandEPSFilter::DiscardFillSubType (   )  [private]

discards a fill sub type from the stack ('{}' or '{logtaper}' or something) Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 02/06/95 Returns: EPS error Definition at line 1063 of file freeeps.cpp. { BOOL Done = FALSE; EPSType Type; while(Done == FALSE) { Type = Stack.GetType(); if(Type == EPSTYPE_NONE) { // not enough stuff on the stack return FALSE;; } else if(Type == EPSTYPE_STRING) { // string - is this the ending? String_64 Str; if(!Stack.Pop(&Str)) return FALSE; if(camStrcmp(Str, _T("{")) == 0) Done = TRUE; // found end of this bit } else { // just something unimportant - discard it if(!Stack.Discard()) return FALSE; } } return TRUE; }

INT32 FreeHandEPSFilter::EPSHeaderIsOk (  ADDR  pFileHeader, UINT32  HeaderSize )  [protected, virtual]

Checks to see if the EPS comment headers specify that this is an FreeHand 3.0 generated EPS file, as required. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 01/06/95 Returns: TRUE if the header is ok and import should proceed, FALSE if not. Reimplemented from EPSFilter. Definition at line 360 of file freeeps.cpp. { // Check the first line in EPS file if (strncmp((char *) pFileHeader, "%!PS-Adobe", 10) != 0) { // Incorrect version of EPS header line - we don't want this return 0; } // !PS-Adobe line is ok - check creator line... TCHAR *Buffer; CCMemTextFile HeaderFile((char *)pFileHeader, HeaderSize); if(HeaderFile.IsMemFileInited() == FALSE || HeaderFile.InitLexer() == FALSE) { HeaderFile.close(); return 0; } BOOL HaveCreatorString = FALSE; UINT32 Lines = 0; while ((Lines < 20) && !HeaderFile.eof()) { HeaderFile.GetLineToken(); Buffer = (TCHAR *)HeaderFile.GetTokenBuf(); ERROR2IF(Buffer == 0, 0, "Returned buffer from lex file == 0"); Lines++; // Return TRUE if this file was created by Illustrator, or has been exported in // Illustrator format. if (camStrncmp( (const TCHAR *)Buffer, _T("%%Creator: "), 11) == 0 && camStrstr( (const TCHAR*)Buffer, _T("FreeHand")) != 0) { // found a plausible creator string - but it could be any version // (3.0 for the Mac gives it's version number here, but the PC one doesn't) HaveCreatorString = TRUE; } if (camStrncmp(Buffer, _T("%%DocumentProcSets: FreeHand_header 3 "), 38) == 0 && HaveCreatorString) { // I'll have that then. HeaderFile.close(); return 10; } // If we find the compression token then stop the search as we don't want to start // looking in the compressed data! if (camStrncmp(Buffer, _T("%%Compression:"), 14)==0) break; } HeaderFile.close(); return 0; }

BOOL FreeHandEPSFilter::Init (  void   )  [virtual]

Initialise an FreeHandEPSFilter object. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 31/05/95 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. Definition at line 241 of file freeeps.cpp. { // Get the OILFilter object pOILFilter = new FreeHandEPSOILFilter(this); if (pOILFilter == NULL) return FALSE; // Load the description strings FilterName.Load(FilterNameID); FilterInfo.Load(FilterInfoID); // All ok return TRUE; }

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

Compare the current token against the AI keywords to see if it is one of them. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 25/02/94 Returns: TRUE if the token is an FreeHand EPS token; FALSE if not. See also: EPSFilter::LookUpToken; EPSFilter::DecodeToken Reimplemented from EPSFilter. Definition at line 431 of file freeeps.cpp. { // 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 (FHCommands[i].Cmd != EPSC_Invalid) { if (camStrcmp(TokenBuf, FHCommands[i].CmdStr) == 0) { // Found the token - set the token variable and return success Token = FHCommands[i].Cmd; return; } // Try next command i++; } // Did not find this token - pass on to base class. EPSFilter::LookUpToken(); }

BOOL FreeHandEPSFilter::MaskedGroupEnding (   )  [protected, virtual]

Restores the graphic state after a masked group ends. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 02/06/95 Returns: EPS error flag Reimplemented from EPSFilter. Definition at line 1322 of file freeeps.cpp. { // make the path type normal if(ThePathType == PATH_DISCARD || ThePathType == PATH_DISCARD_STICKY) { ThePathType = PATH_NORMAL; } return TRUE; }

BOOL FreeHandEPSFilter::PopColour (  DocColour *  Col  )  [private]

Pops a FreeHand colour off the stack. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 01/06/95 Returns: TRUE if colour understood and processed ok, FALSE if not. Errors: Syntax error in EPS, Out of memory. See also: EPSFilter::ProcessToken Definition at line 1109 of file freeeps.cpp. { // OK, we expect an array of four values in the order (of popping) K, Y, M, C // check that we've got a array end EPSCommand Cmd; if(!Stack.PopCmd(&Cmd)) return FALSE; if(Cmd != EPSC_ArrayEnd) return FALSE; // pop the colours double C, M, Y, K; if(!Stack.Pop(&K) || !Stack.Pop(&Y) || !Stack.Pop(&M) || !Stack.Pop(&C)) return FALSE; // check that we've got a array start if(!Stack.PopCmd(&Cmd)) return FALSE; if(Cmd != EPSC_ArrayStart) return FALSE; // knock up the colour... ColourCMYK Colour; Colour.Cyan = C; Colour.Magenta = M; Colour.Yellow = Y; Colour.Key = K; IndexedColour *NewCol = new IndexedColour(COLOURMODEL_CMYK, (ColourGeneric *)&Colour); if(NewCol == 0) return FALSE; pColours->GetColourList()->GetUnnamedColours()->AddTail(NewCol); Col->MakeRefToIndexedColour(NewCol); return TRUE; }

BOOL FreeHandEPSFilter::PopNamedColour (  DocColour *  Col  )  [private]

Pops a FreeHand named colour off the stack. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 01/06/95 Returns: TRUE if colour understood and processed ok, FALSE if not. Errors: Syntax error in EPS, Out of memory. See also: EPSFilter::ProcessToken Definition at line 1168 of file freeeps.cpp. { // OK, we expect an array of two values in the order (of popping) random, index // and we can use the index to look up the indexed colour we should use in our // nice list in ColourArray. // 'random'? Maybe it's a tint or something? Which doesn't seem to be used. // check that we've got a array end EPSCommand Cmd; if(!Stack.PopCmd(&Cmd)) return FALSE; if(Cmd != EPSC_ArrayEnd) return FALSE; // pop the index double Random; INT32 Index; if(!Stack.Pop(&Index) || !Stack.Pop(&Random)) return FALSE; // check that we've got a array start if(!Stack.PopCmd(&Cmd)) return FALSE; if(Cmd != EPSC_ArrayStart) return FALSE; // check that the index is valid if(Index < 0 || Index >= ColourArrayEntries) return FALSE; // knock up the colour... Col->MakeRefToIndexedColour(ColourArray[Index]); return TRUE; }

BOOL FreeHandEPSFilter::PrepareToImport (   )  [protected, virtual]

prepares to import a freehand EPS file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 02/06/95 Returns: error flag See also: EPSFilter Reimplemented from EPSFilter. Definition at line 268 of file freeeps.cpp. { if(!EPSFilter::PrepareToImport()) return FALSE; // set some nice variables HadhToken = FALSE; DoingGradFill = FALSE; OldFill = 0; InColours = FALSE; InText = FALSE; ComplexPathMode = FALSE; pLastPathSeen = 0; // set the clipping flags ClipRegion.SetClippingFlags(2); // get an importedcolours object pNewColours = new ImportedColours(pColours, FALSE); if(pNewColours == 0 || !pNewColours->Init()) return FALSE; // get a colour array ColourArray = (IndexedColour **)CCMalloc(FHEF_COLOURARRAY_INITIALSIZE * sizeof(IndexedColour *)); if(ColourArray == 0) { delete pNewColours; pNewColours = 0; return FALSE; } ColourArrayEntries = 0; ColourArraySize = FHEF_COLOURARRAY_INITIALSIZE; return TRUE; }

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

Examines the current token and performs whatever actions are necessary to process its meaning. Operands are simply pushed onto the EPS stack, and keywords are either acted upon, or ignored if they describe something that Camelot does not yet support (in the latter case, the operands of the keyword, if any, are simply discarded from the stack). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/10/93 Returns: TRUE if the token was processed ok, FALSE if an error occured. Errors: Fails (returns FALSE) if a syntax/error is detected in the EPS file, or if there is insufficient memory to complete the operation. See also: EPSFilter::GetToken Scope: Private Reimplemented from EPSFilter. Definition at line 477 of file freeeps.cpp. { // Decode the command, and execute it... switch (Token) { // state saving case EPSC_vms: if(!Import_gsave()) return FALSE; break; case EPSC_vmr: if(!Import_grestore()) return FALSE; break; case EPSC_vmrs: if(!Import_grestore()) return FALSE; if(!Import_gsave()) return FALSE; break; // tokens to ignore case EPSC_FREEHAND_IGNOREDTOKEN: break; // tokens which should be ignored and one entry discarded case EPSC_load: // the load part of a fill - discard the /clipper before it case EPSC_fhsetspreadallow: if(!Stack.Discard(1)) goto EPSError; break; case EPSC_concat: if(!Stack.DiscardArray()) goto EPSError; break; // complex paths... case EPSC_eomode: { INT32 ComplexStart; if(!Stack.Pop(&ComplexStart)) goto EPSError; // is this a start of a complex path? if(ComplexStart != TRUE) { ComplexPathMode = FALSE; } else { HadFirstOfComplexPath = FALSE; ComplexPathMode = TRUE; } } break; case EPSC_true: Stack.Push((INT32)TRUE); break; case EPSC_false: Stack.Push((INT32)FALSE); break; case EPSC_u: HadFirstOfComplexPath = FALSE; return EPSFilter::ProcessToken(); break; // colours case EPSC_Ka: case EPSC_ka: { DocColour Colour; if(PopColour(&Colour)) { // Remember this colour for future objects if (Token == EPSC_ka) { if (!SetFillColour(Colour)) goto NoMemory; } else { if (!SetLineColour(Colour)) goto NoMemory; } } else // Invalid colour operands goto EPSError; } break; case EPSC_Xa: case EPSC_xa: { DocColour Colour; if(PopNamedColour(&Colour)) { // Remember this colour for future objects if (Token == EPSC_xa) { if (!SetFillColour(Colour)) goto NoMemory; } else { if (!SetLineColour(Colour)) goto NoMemory; } } else // Invalid colour operands goto EPSError; } break; case EPSC_H: if(ComplexPathMode) { // in complex path mode - make this a filled one, not a discarded one Token = EPSC_S; } return EPSFilter::ProcessToken(); break; case EPSC_h: if(ComplexPathMode) { // in complex path mode - modify and process Token = EPSC_s; return EPSFilter::ProcessToken(); break; } // the hidden path closing operator - a grad fill thingy will follow shortly maybe... // this will prevent it being processed now, although it may get processed later on. HadhToken = TRUE; break; // for clipping masks, do some funky stuff case EPSC_q: // if there's a pending grad fill... if(DoingGradFill) { if(pPath != 0) { // right then, make a copy of the path... NodePath *pPathClone; if(!pPath->NodeCopy((Node **)&pPathClone)) { goto NoMemory; } // copy the flags EPSFlagsDefn EPSFlagsClone = EPSFlags; // send a token to finish and fill the path... Token = (pInkPath->IsFilled)?EPSC_f:EPSC_s; if(!EPSFilter::ProcessToken()) return FALSE; // restore the old fill if(!RestoreCurrentFill()) goto NoMemory; // restore the copy of the path pPath = pPathClone; pInkPath = &pPath->InkPath; // restore the flags EPSFlags = EPSFlagsClone; // definately want to send an h HadhToken = TRUE; } // done the grad fill DoingGradFill = FALSE; // restore the old token Token = EPSC_q; } // clipping started - have we got an h token to send? if(HadhToken) FHEF_SENDh // process this return EPSFilter::ProcessToken(); break; // for now, if there's no path, don't return a W case EPSC_W: if(pPath == 0) { // OK, now we want to get the last path we created, make a copy of it and then install it as the current one if(pLastPathSeen == 0) goto EPSError; // make a copy of it NodePath *pClone; if(!pLastPathSeen->NodeCopy((Node **)&pClone)) goto NoMemory; // delete it's attributes pClone->DeleteChildren(pClone->FindFirstChild()); // make it the current path pPath = pClone; pInkPath = &pPath->InkPath; ThePathType = PATH_NORMAL; EPSFlags.NoAttributes = TRUE; } if(pPath != 0) return EPSFilter::ProcessToken(); break; // we may need to modify path closing things if we're doing a grad fill case EPSC_s: case EPSC_S: if(Token == EPSC_S) { // if we've had an h token but no grad fill, send the h now if(HadhToken) FHEF_SENDh // if we've got a grad fill, modify the token we got if(DoingGradFill) Token = EPSC_b; } // process the possily modified token normally HadhToken = FALSE; return EPSFilter::ProcessToken(); break; // modify path closing for grad fills. case EPSC_n: if(DoingGradFill) { Token = EPSC_f; // we want to fill the thing HadhToken = FALSE; return EPSFilter::ProcessToken(); break; } HadhToken = FALSE; // ignore h's as this is another end path thingy... if(pPath != 0) return EPSFilter::ProcessToken(); break; // unset the had h token for other path closing things case EPSC_N: case EPSC_F: case EPSC_f: case EPSC_B: case EPSC_b: HadhToken = FALSE; return EPSFilter::ProcessToken(); break; // interested in path element things to switch off grad fills case EPSC_m: if(InText) { // if we're doing some text, discard the moveto command if(!Stack.Discard(2)) goto EPSError; break; } case EPSC_l: case EPSC_L: case EPSC_c: case EPSC_C: case EPSC_v: case EPSC_V: case EPSC_y: case EPSC_Y: // maybe we need an h token to be sent if(HadhToken) FHEF_SENDh // stop grad fill if(DoingGradFill) { // turn the grad fill state off DoingGradFill = FALSE; // restore the old fill type RestoreCurrentFill(); } return EPSFilter::ProcessToken(); break; case EPSC_recfill: { // get the colours DocColour StartColour, EndColour; if(!PopColour(&EndColour) || !PopColour(&StartColour)) goto EPSError; // discard the fill type thingy - we can only do colours if(!DiscardFillSubType()) goto EPSError; // OK, now a few coords DocCoord Centre; double Angle; DocRect BBox; if(!Stack.PopCoordPair(&BBox.hi) || !Stack.PopCoordPair(&BBox.lo) || !Stack.Pop(&Angle) || !Stack.PopCoordPair(&Centre)) goto EPSError; // munge the angle a little and get it into radians Angle += 225; Angle = (Angle * (2 * PI)) / 360; // see if we can get a more accurate BBox if(pPath != 0) { BBox = pPath->GetBoundingRect(); Centre.x = BBox.lo.x + (BBox.Width() / 2); Centre.y = BBox.lo.y + (BBox.Height() / 2); } // OK, we've got all the stuff we need to do some niceness on it BBox.Translate(0 - Centre.x, 0 - Centre.y); DocCoord StartPoint, EndPoint; StartPoint.x = Centre.x + (INT32)(((double)BBox.lo.x * cos(Angle)) - ((double)BBox.lo.y * sin(Angle))); StartPoint.y = Centre.y + (INT32)(((double)BBox.lo.x * sin(Angle)) + ((double)BBox.lo.y * cos(Angle))); EndPoint.x = Centre.x + (INT32)(((double)BBox.hi.x * cos(Angle)) - ((double)BBox.hi.y * sin(Angle))); EndPoint.y = Centre.y + (INT32)(((double)BBox.hi.x * sin(Angle)) + ((double)BBox.hi.y * cos(Angle))); // store current fill attribute SaveCurrentFill(); // set the fill if(!SetLinearFill(StartColour, EndColour, StartPoint, EndPoint)) goto NoMemory; // say we're doing a grad fill DoingGradFill = TRUE; HadhToken = FALSE; // absorb this } break; case EPSC_radfill: { // get the colours DocColour StartColour, EndColour; if(!PopColour(&StartColour) || !PopColour(&EndColour)) goto EPSError; // get the radius and centre coordinate DocCoord Centre; INT32 Radius; if(!Stack.PopCoord(&Radius) || !Stack.PopCoordPair(&Centre)) goto EPSError; // store current fill attribute SaveCurrentFill(); // set the fill DocCoord EndPoint(Centre.x + Radius, Centre.y); if(!SetRadialFill(StartColour, EndColour, Centre, EndPoint)) goto NoMemory; // say we're doing a grad fill DoingGradFill = TRUE; HadhToken = FALSE; } break; case EPSC_BeginSetup: // there's probably a colour list or something in that there setup thingy - search for the spots token { BOOL Found = FALSE; while(Found == FALSE) { if(!EPSFile->GetToken()) return FALSE; if(EPSFile->GetTokenType() == TOKEN_NORMAL) { if(camStrcmp(TokenBuf, _T("spots")) == 0) { // check to see if the array is about to start if(!EPSFile->GetToken()) return FALSE; if(TokenBuf[0] == '[') { TRACEUSER( "Ben", _T("Found spots\n")); Found = TRUE; } } } if(camStrncmp(TokenBuf, _T("%%EndSetup"), 10) == 0) { TRACEUSER( "Ben", _T("Met end of setup without finding spots\n")); break; } if(EPSFile->eof()) goto EPSError; } if(Found == TRUE) { InColours = TRUE; } } break; case EPSC_def: if(InColours) { // finished the colours... TRACEUSER( "Ben", _T("Finished spot colours\n")); // scan for the end of the setup section BOOL Found = FALSE; while(Found == FALSE) { if(!EPSFile->GetToken()) return FALSE; if(EPSFile->GetTokenType() == TOKEN_COMMENT) { if(camStrncmp(TokenBuf, _T("%%EndSetup"), 10) == 0) { TRACEUSER( "Ben", _T("Found end of setup\n")); Found = TRUE; } } if(EPSFile->eof()) goto EPSError; } // get the ] off the stack EPSCommand Ignored; Stack.PopCmd(&Ignored); // empty it... Stack.DeleteAll (); InColours = FALSE; } else { // probably a font type thingy - empty the stack including commands Stack.DeleteAll (); } break; case EPSC_newcmykcustomcolor: // OK, here's a named colour... add it to those known { // discard some random thingy if(!Stack.Discard()) goto EPSError; // get the name String_64 ColourName; if(!Stack.Pop(&ColourName)) goto EPSError; // get the components double C, M, Y, K; if(!Stack.Pop(&K) || !Stack.Pop(&Y) || !Stack.Pop(&M) || !Stack.Pop(&C)) goto EPSError; // make the new colour ColourCMYK Colour; Colour.Cyan = C; Colour.Magenta = M; Colour.Yellow = Y; Colour.Key = K; // add it if(!pNewColours->AddColour(&ColourName, &Colour)) goto NoMemory; // add it to the list of colours // this is a bit of a bodge, but never mind. Shouldn't be that bad. IndexedColour *TheNewColour = pNewColours->GetColour(ColourName); if(TheNewColour == 0) goto NoMemory; // add it to the list of colours // enough space? if((ColourArrayEntries + 1) >= ColourArraySize) { TRACEUSER( "Ben", _T("Extening colour array\n")); IndexedColour **NewPtr = (IndexedColour **)CCRealloc(ColourArray, (ColourArraySize + FHEF_COLOURARRAY_CHUNK) * sizeof(IndexedColour *)); if(NewPtr == 0) goto NoMemory; ColourArray = NewPtr; ColourArraySize += FHEF_COLOURARRAY_CHUNK; } // add ColourArray[ColourArrayEntries] = TheNewColour; ColourArrayEntries++; } break; // ignore text stuff case EPSC_makesetfont: if(!Stack.DiscardArray()) goto EPSError; if(!Stack.Discard(1)) goto EPSError; InText = TRUE; break; case EPSC_ts: if(!Stack.Discard(6)) goto EPSError; break; case EPSC_stob: case EPSC_sts: Stack.DeleteAll (); InText = FALSE; break; default: // Token not understood - pass on to 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; }

BOOL FreeHandEPSFilter::RemoveLastSubPathIfNotUnique (  Path *  pIPath  )  [private]

Removes the last subpath from a path if an sub path with it's exact coords already exists. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 15/06/95 Returns: error flag Definition at line 1346 of file freeeps.cpp. { // get coord arrays INT32 NCoords = pIPath->GetNumCoords(); DocCoord *Coords = pIPath->GetCoordArray(); PathVerb *Verbs = pIPath->GetVerbArray(); // find the last moveto INT32 LastMoveTo = -1; INT32 c; for(c = 0; c < NCoords; c++) { if((Verbs[c] & ~PT_CLOSEFIGURE) == PT_MOVETO) { LastMoveTo = c; } } // check that there is a last moveto and it's not the first coord... if(LastMoveTo == -1 || LastMoveTo == 0) return TRUE; // nothing more to do // go through the coords matching subpaths... for(c = 0; c < LastMoveTo; c++) { if((Verbs[c] & ~PT_CLOSEFIGURE) == PT_MOVETO) { // found a moveto... compare the subpaths INT32 n = 0; while(((Verbs[c+n] & ~PT_CLOSEFIGURE) == (Verbs[LastMoveTo+n] & ~PT_CLOSEFIGURE)) && (Coords[c+n] == Coords[LastMoveTo+n])) { // this was ok... is the next a moveto and the subpath the right length? if((LastMoveTo+n+1) == NCoords) { // yes, delete and return return pIPath->DeleteFromElement(LastMoveTo); } n++; } } } return TRUE; }

BOOL FreeHandEPSFilter::RestoreCurrentFill (   )  [private]

restores the current fill attribute from the stored one Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 02/06/95 Returns: error flag See also: EPSFilter::ProcessToken Definition at line 1252 of file freeeps.cpp. { if(OldFill == 0) return TRUE; // no saved state // delete the old attribute if(CurrentAttrs[ATTR_FILLGEOMETRY].pAttr != 0) delete CurrentAttrs[ATTR_FILLGEOMETRY].pAttr; // make the current one the old one CurrentAttrs[ATTR_FILLGEOMETRY].pAttr = OldFill; // mark this as used so it doesn't get deleted OldFill = 0; return TRUE; }

BOOL FreeHandEPSFilter::SaveCurrentFill (   )  [private]

stores the current fill attribute Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 02/06/95 Returns: error flag See also: EPSFilter::ProcessToken Definition at line 1218 of file freeeps.cpp. { // get rid of any stored fill if(OldFill != 0) delete OldFill; // create a copy of the current fill attribute CCRuntimeClass* ObjectType = CurrentAttrs[ATTR_FILLGEOMETRY].pAttr->GetRuntimeClass(); AttributeValue* AttrClone = (AttributeValue*)ObjectType->CreateObject(); if(AttrClone == 0) return FALSE; AttrClone->SimpleCopy(CurrentAttrs[ATTR_FILLGEOMETRY].pAttr); // set the old fill pointer to the nice clone we've made OldFill = AttrClone; return TRUE; }

BOOL FreeHandEPSFilter::ValidateGroup (  Node *  pGroup  )  [protected, virtual]

validates a group created by the filter. As all objects have a group around then, this removes groups which only have one entry. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 02/06/95 Returns: error flag Reimplemented from EPSFilter. Definition at line 1282 of file freeeps.cpp. { ERROR2IF(pGroup == 0, FALSE, "Group passed to validateGroup is null"); Node *pFirstChild = pGroup->FindFirstChild(); ERROR2IF(pFirstChild == 0, FALSE, "Group without children passed to ValidateGroup - should have been deleted by EndGroup"); if(pFirstChild->FindNext() == 0) { // there was only one object - delete this group. // if pFirstNodeInRange is this node, set it to the child if(pFirstNodeInRange == pGroup) pFirstNodeInRange = pFirstChild; // move the child to the parent of the group if (!ImportInfo.pOp->DoMoveNode(pFirstChild, pNode, LASTCHILD)) return FALSE; // see EPSFilter::EndGroup for the reason why it's hidden rather than deleted if (!ImportInfo.pOp->DoHideNode(pGroup, TRUE)) return FALSE; } return TRUE; }

---

Member Data Documentation

IndexedColour** FreeHandEPSFilter::ColourArray [private]

Definition at line 155 of file freeeps.h.

INT32 FreeHandEPSFilter::ColourArrayEntries [private]

Definition at line 156 of file freeeps.h.

INT32 FreeHandEPSFilter::ColourArraySize [private]

Definition at line 157 of file freeeps.h.

BOOL FreeHandEPSFilter::ComplexPathMode [private]

Definition at line 158 of file freeeps.h.

BOOL FreeHandEPSFilter::DoingGradFill [private]

Definition at line 150 of file freeeps.h.

CommandMap FreeHandEPSFilter::FHCommands [static, private]

Definition at line 140 of file freeeps.h.

BOOL FreeHandEPSFilter::HadFirstOfComplexPath [private]

Definition at line 159 of file freeeps.h.

BOOL FreeHandEPSFilter::HadhToken [private]

Definition at line 149 of file freeeps.h.

BOOL FreeHandEPSFilter::InColours [private]

Definition at line 152 of file freeeps.h.

BOOL FreeHandEPSFilter::InText [private]

Definition at line 153 of file freeeps.h.

AttributeValue* FreeHandEPSFilter::OldFill [private]

Definition at line 151 of file freeeps.h.

NodePath* FreeHandEPSFilter::pLastPathSeen [private]

Definition at line 160 of file freeeps.h.

ImportedColours* FreeHandEPSFilter::pNewColours [private]

Definition at line 154 of file freeeps.h.

---

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

• Kernel/freeeps.h (r1785/r1282)
• Kernel/freeeps.cpp (r1785/r1314)

---