ArtWorksEPSFilter Class Reference

A filter that imports EPS files in ArtWorks EPS format. More...

#include <aw_eps.h>

Inheritance diagram for ArtWorksEPSFilter:

List of all members.

Public Member Functions
	ArtWorksEPSFilter ()
	Constructor for an ArtWorksEPSFilter object. The object should be initialised before use.
BOOL	Init ()
	Initialise an ArtWorksEPSFilter object.
BOOL	PrepareToExport (CCLexFile *, Spread *pSpread)
	Prepare to import EPS data using this filter. This sets up the filter to a sensible state for reading.
TCHAR *	GetEPSCommand (EPSCommand Cmd)
	Given an EPS token, return the string representation of it; mainly for debugging purposes.
virtual BOOL	NeedsPrintComponents (void)
	Informs the print components code that no data should be written.
virtual BitmapFilterSupport	GetBitmapSupportLevel ()
	Determine how well this filter supports bitmaps when exporting.
Protected Member Functions
virtual void	LookUpToken ()
	Compare the current token against the ArtWorks keywords to see if it is one of them.
virtual BOOL	ProcessToken ()
	Processes EPS tokens that are not part of the standard Illustrator set, or which need to be handled differently to the standard Illustrator meanings. i.e. this is the function that handles all the ArtWorks EPS operators.
INT32	EPSHeaderIsOk (ADDR pFileHeader, UINT32 HeaderSize)
	Checks to see if the EPS comment headers specify that this is an ArtWorks generated EPS file, as required.
BOOL	ProcessBlend ()
	Reads in all the elements of a blend structure in the EPS file.
BOOL	ProcessBlender ()
	Reads in all the elements of a blender structure in the EPS file.
BOOL	StartBlend ()
	Used when a blend structure needs to be created - after this is called, all new nodes added with AddNewNode() will be added as children of this new blend, until EndBlend is called.
BOOL	StartBlender ()
	Used when a blender structure needs to be created - after this is called, all new paths will be discarded, until EndBlender is called.
BOOL	EndBlend ()
	Used when a blend has finished being constructed and we want to return to normal node positioning. The blend is added to the document when this function is called (although that depending on the current filter mode, i.e. whether this is a new or existing layer, it may not be added directly to the documnent tree straight away - it may be deferred until the next layer is found, or the import has ended).
BOOL	EndBlender ()
	Used when a blender has finished being constructed. Paths are not longer discarded.
BOOL	ProcessEnvelope ()
	Reads in all the elements of an envelope structure in the ArtWorksEPS file and builds the camelot envelope tree.
BOOL	ProcessPerspective ()
	Reads in all the elements of an perspective structure in the EPS file.
BOOL	StartMould (MouldSpace mSpace)
	Used when an mould structure needs to be created - after this is called, all new nodes added with AddNewNode() will be added as children of this new mould, until EndMould is called.
BOOL	EndMould ()
	Used when a envelope has finished being constructed and we want to return to normal node positioning.
BOOL	ProcessMould ()
	Processes tokens inside a mould object. Tokens specific to mould objects are processed along with some overridding of default tokens such as groups.
BOOL	ProcessMouldShape ()
	Reads in all the elements of a mould geometry held in the EPS file. The description of the geometry for this particular file type is that of a path. Depending on the geometry type (perspective or envelope) we will obviously expect a slightly different path. The rules are, that currently perspective geometry is described as {m,l,l,l,l} and envelope geometry is {m,c,c,c,c}. Internally we are not restricted to these but ArtworksEPS certainly is. Input Stack = coord, coord.
BOOL	ProcessMangledObjs ()
	On finding a 'apc' token in the input stream, this function is executed. It will process all further tokens in the stream until a path termination has been found. A path terminator is considered any of { s,S,b,B,f,F,h,H } Its purpose is strictly defined. It must place the next set of attributes and single path as children of the last object imported rather than the default action which would be to stick them in as siblings of the object.
BOOL	ConvertArtMould (NodeMould *)
	Right here comes the difficult bit. What we have now is a really interresting structure. We should have a complete tree beneath the mould group node containing invisible source objects and visible moulded shapes. So if we were to render this tree, it would look sensible. Now we need to disassemble this tree by placing all the moulded objects and their attributes inside our moulder object. This we will do by copying the entire tree and deleting the right bits. (Isn't it yuk but there you go, its the only sensible and simple way of doing it, without massively duplicating bits of code.
BOOL	ConvertMouldStyles (Node *pNode)
	Scan through all moulded objects, copying their fill and stroke styles to the original objects (which are currently their parents).
void	DeleteAllMangled (Node *pNode)
	Delete all nodes with their mangled bits set at and below pNode.
BOOL	DeleteAllNoneMangled (Node *pNode)
	Delete all renderable parents of mangled objects from pNode onwards. This really is a specialised function and should be used with care. It scans through the tree, hunting for mangled objects. When one is found it will attempt to promote the node to become a sibling of its parent and delete the parent. It will only do so if the parent is renderable. We know or are assuming this is a confined and sensible action. It is only so having loaded an ArtWorksEPS envelope or perspective object.
BOOL	PromoteMangled (Node *pNode)
	Promote all mangled child nodes to siblings of their parents.
BOOL	HandleMouldedFill ()
	On finding a 'axm' token in the input stream, this function is executed. It will build a graduated fill structure and set it as the current fill style to be applied to future objects. The function has been split off from the main structure for one very important reason. Fills applied to moulds work in a random way. Imagine the senario, you have a rectangle, and you envelope it. You then apply a linear grad fill to it. If this gets exported as AWEPS what you get are two objects, one moulded and one rectangle. Now you also get a moulded and none moulded fill style represented by ax and axm. Unfortunately although ax stands for 'standard fill style' and axm is used as an override describing the coordinates of a moulded fill (hence the m) the coordinates of both fills are reversed. DONT ASK ME WHY, ASK THE AUTHOR OF AWEPS! So we have to perform some brain dead processing here to get the right attributes applied to the right objects.
Static Protected Attributes
static CommandMap	ArtWorksCommands []
Private Member Functions
	CC_DECLARE_DYNAMIC (ArtWorksEPSFilter)
Private Attributes
DocRect	MouldRect
INT32	LastFillType
GradEndCol	LastStartColour
GradEndCol	LastEndColour

---

Detailed Description

A filter that imports EPS files in ArtWorks EPS format.

Author:

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

Date:

08/03/94

See also:

EPSFilter

Definition at line 130 of file aw_eps.h.

---

Constructor & Destructor Documentation

ArtWorksEPSFilter::ArtWorksEPSFilter (   )

Constructor for an ArtWorksEPSFilter 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 223 of file aw_eps.cpp. { // Set up filter descriptions. FilterNameID = _R(IDT_AWEPS_FILTERNAME); FilterInfoID = _R(IDT_AWEPS_FILTERINFO); ImportMsgID = _R(IDT_IMPORTMSG_ARTWORKS); FilterID = FILTERID_ARTWORKS_EPS; #ifndef STANDALONE Flags.CanImport = TRUE; //WEBSTER-Martin-27/01/97 #ifdef WEBSTER Flags.CanExport = FALSE; #else Flags.CanExport = TRUE; #endif //WEBSTER #else Flags.CanImport = FALSE; Flags.CanExport = FALSE; #endif LastFillType = 0; }

---

Member Function Documentation

ArtWorksEPSFilter::CC_DECLARE_DYNAMIC (  ArtWorksEPSFilter   )  [private]

BOOL ArtWorksEPSFilter::ConvertArtMould (  NodeMould *  pNodeMould  )  [protected]

Right here comes the difficult bit. What we have now is a really interresting structure. We should have a complete tree beneath the mould group node containing invisible source objects and visible moulded shapes. So if we were to render this tree, it would look sensible. Now we need to disassemble this tree by placing all the moulded objects and their attributes inside our moulder object. This we will do by copying the entire tree and deleting the right bits. (Isn't it yuk but there you go, its the only sensible and simple way of doing it, without massively duplicating bits of code. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 06/03/94 Parameters: pNodeMould  - a pointer to the mould object [INPUTS] Returns: TRUE if the artworks mould has been converted correctly FALSE if not. Errors: Syntax error in EPS file, Out of memory Definition at line 2082 of file aw_eps.cpp. { ERROR2IF(pNodeMould==NULL, FALSE, "NULL mould pointer passed to ConvertArtMould()"); NodeMouldGroup* pNodeMGroup = pNodeMould->FindMouldGroup(); if (pNodeMGroup==NULL) return FALSE; NodeMoulder* pMoulder = pNodeMould->FindFirstMoulder(); if (pMoulder==NULL) return FALSE; Node *pNode; // Stage 1 // Copy all objects from the mould group to this new moulder object pNode = pNodeMGroup->FindFirstChild(); while (pNode) { if (!pNode->CopyNode(pMoulder,LASTCHILD)) { pMoulder->CascadeDelete(); return FALSE; } pNode=pNode->FindNext(); } // Stage2 // Scan through deleting all mangled objects in the source tree pNode=pNodeMGroup->FindFirstChild(); DeleteAllMangled(pNode); //Stage 3 //Scan through deleting all none mangled objects in the destination tree //but leaving the mangled versions! pNode=pMoulder->FindFirstChild(); DeleteAllNoneMangled(pNode); return TRUE; }

BOOL ArtWorksEPSFilter::ConvertMouldStyles (  Node *  pNode  )  [protected]

Scan through all moulded objects, copying their fill and stroke styles to the original objects (which are currently their parents). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 06/03/94 Parameters: pNode  - a pointer to an object to start scanning from [INPUTS] Returns: TRUE if the mould styles have been converted correctly FALSE if not. Definition at line 2018 of file aw_eps.cpp. { Node *qNode, *rNode; BOOL IsFilled = FALSE, IsStroked = FALSE; while (pNode) { qNode=pNode; pNode=pNode->FindNext(); // if its mangled delete it otherwise scan its kids if (qNode->IsMangled()) { rNode = qNode->FindParent(); if (rNode) { // this should be polymorphic but there's no virtual func to // do it so I'll have to be explicit. if (IS_A(qNode, NodePath)) { IsFilled = ((NodePath*)qNode)->InkPath.IsFilled; IsStroked = ((NodePath*)qNode)->InkPath.IsStroked; if (rNode->IsKindOf(CC_RUNTIME_CLASS(NodePath))) { ((NodePath*)rNode)->InkPath.IsFilled = IsFilled; ((NodePath*)rNode)->InkPath.IsStroked = IsStroked; } else if (rNode->IsKindOf(CC_RUNTIME_CLASS(NodeSimpleShape))) { ((NodePath*)rNode)->InkPath.IsFilled = IsFilled; ((NodePath*)rNode)->InkPath.IsStroked = IsStroked; } } } } else ConvertMouldStyles(qNode->FindFirstChild()); } return TRUE; }

void ArtWorksEPSFilter::DeleteAllMangled (  Node *  pNode  )  [protected]

Delete all nodes with their mangled bits set at and below pNode. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 09/03/95 Parameters: pNode  = a pointer to a node to start deleting from [INPUTS] Returns: - See also: Definition at line 2139 of file aw_eps.cpp. { Node *qNode; while (pNode) { qNode=pNode; pNode=pNode->FindNext(); // if its mangled delete it otherwise scan its kids if (qNode->IsMangled()) { qNode->CascadeDelete(); delete qNode; } else DeleteAllMangled(qNode->FindFirstChild()); } }

BOOL ArtWorksEPSFilter::DeleteAllNoneMangled (  Node *  pNode  )  [protected]

Delete all renderable parents of mangled objects from pNode onwards. This really is a specialised function and should be used with care. It scans through the tree, hunting for mangled objects. When one is found it will attempt to promote the node to become a sibling of its parent and delete the parent. It will only do so if the parent is renderable. We know or are assuming this is a confined and sensible action. It is only so having loaded an ArtWorksEPS envelope or perspective object. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 09/03/95 Parameters: pNode  = a pointer to a node to start deleting from [INPUTS] Returns: - See also: Definition at line 2178 of file aw_eps.cpp. { Node* qNode; while (pNode) { qNode=pNode; pNode=pNode->FindNext(); if (!PromoteMangled(qNode)) DeleteAllNoneMangled(qNode->FindFirstChild()); } return TRUE; }

BOOL ArtWorksEPSFilter::EndBlend (   )  [protected]

Used when a blend has finished being constructed and we want to return to normal node positioning. The blend is added to the document when this function is called (although that depending on the current filter mode, i.e. whether this is a new or existing layer, it may not be added directly to the documnent tree straight away - it may be deferred until the next layer is found, or the import has ended). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Returns: TRUE if the blend was ended ok; FALSE if not. Errors: Out of memory See also: ArtWorksEPSFilter::StartBlend Reimplemented in CamelotEPSFilter. Definition at line 1119 of file aw_eps.cpp. { // Sanity check ENSURE(pNode->IsKindOf(CC_RUNTIME_CLASS(NodeBlend)), "No blend in ArtWorksEPSFilter::EndBlend"); // Keep the blend ptr and find the first child of the node before we reset pNode. Node* pBlend = pNode; Node* pChildNode = pNode->FindFirstChild(); // Get the parent of the blend node, and use that to add new objects to pNode = pBlend->FindParent(); ERROR2IF(pNode==NULL, FALSE, "Blend has no parent in EndBlend()"); // Initialise all the child blender nodes UINT32 BlenderCount=0; while (pChildNode != NULL) { if (IS_A(pChildNode,NodeBlender)) { NodeBlender* pNodeBlender = (NodeBlender*)pChildNode; INT32 PathIndexStart = pNodeBlender->GetPathIndexStart(); INT32 PathIndexEnd = pNodeBlender->GetPathIndexEnd(); // Convert the AW path indexes into Camelot path indexes if (!pNodeBlender->ConvertAWPathIndexesToCamelot(&PathIndexStart,&PathIndexEnd)) { ERROR2(FALSE,"Unable to convert artworks path indexes in EndBlend()"); } // Init the blender to blend the prev and next ink nodes together if (!pNodeBlender->Initialise(NULL,NULL,PathIndexStart,PathIndexEnd,ImportInfo.pOp,NULL,TRUE)) { ERROR2(FALSE,"Unable to initialise a node blender in EndBlend()"); } BlenderCount++; } pChildNode = pChildNode->FindNext(); } if (BlenderCount == 0) { ERROR3("Imported Blend node doesn't contain any blender nodes"); if (!ImportInfo.pOp->DoHideNode(pBlend, TRUE)) return FALSE; } return TRUE; }

BOOL ArtWorksEPSFilter::EndBlender (   )  [protected]

Used when a blender has finished being constructed. Paths are not longer discarded. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Returns: TRUE if the blender was ended ok; FALSE if not. Errors: - See also: ArtWorksEPSFilter::StartBlender Reimplemented in CamelotEPSFilter. Definition at line 1301 of file aw_eps.cpp. { ThePathType = PATH_NORMAL; return TRUE; }

BOOL ArtWorksEPSFilter::EndMould (   )  [protected]

Used when a envelope has finished being constructed and we want to return to normal node positioning. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 06/03/95 Returns: TRUE if the envelope was ended ok; FALSE if not. See also: ArtWorksEPSFilter::StartEnvelope() Reimplemented in CamelotEPSFilter. Definition at line 1520 of file aw_eps.cpp. { // Sanity check ERROR3IF(!pNode->IsKindOf(CC_RUNTIME_CLASS(NodeMouldGroup)), "No mouldgroup in ArtWorksEPSFilter::EndMould"); // NodeMouldGroup* pNodeMGroup = (NodeMouldGroup*)pNode; pNode = pNode->FindParent(); ERROR3IF(!pNode->IsKindOf(CC_RUNTIME_CLASS(NodeMould)), "No MouldParent in ArtWorksEPSFilter::EndMould"); NodeMould* pNodeMould = (NodeMould*)pNode; NodeMoulder* pMoulder = pNodeMould->CreateNewMoulder(NULL); if (!pMoulder) { HandleNoMemory(); return FALSE; } // Add it into the tree as the last child of the mould if (!AddNewNode(pMoulder)) { HandleNoMemory(); return FALSE; } // Right, now we need to scan through all moulded objects and copy their fill and // stroke styles to the originals. We need to do this because the original objects // within the file are terminated by h and H functions. These describe closed and open // (none filled,none stroked) paths ie invisible paths. Hence to create the correct // original styles we need to take the definitions from the destination objects // instead. This means when we edit the imported mould the drawing doesn't suddenly // take on random fill and stroke styles. // Right here comes the difficult bit. What we have now is a really interresting // structure. We should have a complete tree beneath the mould group node. This tree // contains invisible source objects and visible moulded shapes. So if we we're to // render this tree, it would look sensible. Now we need to disassemble this tree // by placing all the moulded objects and their attributes inside our moulder object. // This we will do by copying the entire tree and deleting the right bits. (Isn't it // yuk but there you go, its the only sensible and simple way of doing it, without // massively duplicating bits of code. // go and convert the artworks tree if (!ConvertArtMould(pNodeMould)) { HandleNoMemory(); return FALSE; } // and finally move pNode up one level pNode = pNode->FindParent(); ERROR3IF(pNode==NULL, "No parent of envelope in ArtWorksEPSFilter::EndMould"); return TRUE; }

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

Checks to see if the EPS comment headers specify that this is an ArtWorks generated EPS file, as required. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/02/94 Returns: TRUE if the header is ok and import should proceed, FALSE if not. Reimplemented from EPSFilter. Reimplemented in CamelotEPSFilter, and CamelotNativeEPSFilter. Definition at line 289 of file aw_eps.cpp. { // this function is not Unicode // Check the first line in EPS file if (strncmp((char *) pFileHeader, "%!PS-Adobe-2.0 EPSF-1.2", 23) != 0) { // Incorrect version of EPS header line - we don't want this return 0; } // !PS-Adobe line is ok - check creator line... std::istringstream HeaderFile((char *) pFileHeader, ios_base::in /*, HeaderSize*/); char Buffer[200]; UINT32 Lines = 0; while ((Lines < 20) && !HeaderFile.eof()) { HeaderFile.getline(Buffer, 200); Lines++; // Return TRUE if this file was created by ArtWorks if (strncmp(Buffer, "%%Creator: ArtWorks", 19) == 0) { // ArtWorks is the creator - but has it exported it in an alien format? // Return 10 if it hasn't, 1 if it has. if (strstr(Buffer, "exported") == NULL) return 10; else // 5 because it *might* be "ArtWorks (exported by Mr. Blobby)", and // we don't want to let the user not load this at all... return 5; } // If we find the compression token then stop the search as we don't want to start // looking in the compressed data! if (strncmp(Buffer, "%%Compression:", 14)==0) break; } // Didn't find a suitable Creator line, but we did find an EPS line, so indicate // that we're interested, but not sure. return 5; }

BitmapFilterSupport ArtWorksEPSFilter::GetBitmapSupportLevel (   )  [virtual]

Determine how well this filter supports bitmaps when exporting. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/01/95 Returns: SimpleBitmapSupport - This filter has simple support for bitmap images; they must be saved into the file whenever they are used. Reimplemented from Filter. Reimplemented in CamelotNativeEPSFilter. Definition at line 2235 of file aw_eps.cpp. { // ArtWorks EPS has simple bitmap support return SimpleBitmapSupport; }

TCHAR * ArtWorksEPSFilter::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_aoa [INPUTS] Returns: Pointer to the string representation of the token, e.g. "aoa" Reimplemented from EPSFilter. Reimplemented in CamelotEPSFilter. Definition at line 971 of file aw_eps.cpp. { INT32 i = 0; while (ArtWorksCommands[i].Cmd != EPSC_Invalid) { if (ArtWorksCommands[i].Cmd == Cmd) return ArtWorksCommands[i].CmdStr; // Try next command i++; } // Couldn't find it - default to base class method return EPSFilter::GetEPSCommand(Cmd); }

BOOL ArtWorksEPSFilter::HandleMouldedFill (   )  [protected]

On finding a 'axm' token in the input stream, this function is executed. It will build a graduated fill structure and set it as the current fill style to be applied to future objects. The function has been split off from the main structure for one very important reason. Fills applied to moulds work in a random way. Imagine the senario, you have a rectangle, and you envelope it. You then apply a linear grad fill to it. If this gets exported as AWEPS what you get are two objects, one moulded and one rectangle. Now you also get a moulded and none moulded fill style represented by ax and axm. Unfortunately although ax stands for 'standard fill style' and axm is used as an override describing the coordinates of a moulded fill (hence the m) the coordinates of both fills are reversed. DONT ASK ME WHY, ASK THE AUTHOR OF AWEPS! So we have to perform some brain dead processing here to get the right attributes applied to the right objects. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 06/03/94 Parameters: -  [INPUTS] Returns: TRUE if the mangled fill has been dealt with correctly FALSE if not. Errors: Syntax error in EPS file, Out of memory Definition at line 1949 of file aw_eps.cpp. { BOOL ok; DocCoord StartPoint, EndPoint; DocColour StartColour, EndColour; // Get start and end positions for grad-fills if (!Stack.PopCoordPair(&EndPoint) || !Stack.PopCoordPair(&StartPoint)) return FALSE; // read the last definitions of set colours if (LastFillType>0) { GetEPSColour(&StartColour, &LastStartColour.Col, LastStartColour.Tint, LastStartColour.TintVal, &LastStartColour.ColName); GetEPSColour(&EndColour, &LastEndColour.Col, LastEndColour.Tint, LastEndColour.TintVal, &LastEndColour.ColName); } switch (LastFillType) { // Decode ArtWorks EPS grad fill codes case 1: // Check for silly grad fills first... if (StartPoint==EndPoint) ok = SetFillColour(StartColour); else ok = SetLinearFill(StartColour, EndColour, StartPoint, EndPoint); break; case 2: // Check for silly grad fills first... if (StartPoint==EndPoint) ok=SetFillColour(EndColour); else ok=SetRadialFill(StartColour, EndColour, StartPoint, EndPoint); break; default: // if there's no fill applied previously then this is rampant so ignore it. ok=Stack.Discard(4); } return ok; }

BOOL ArtWorksEPSFilter::Init (  void   )  [virtual]

Initialise an ArtWorksEPSFilter 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 CamelotEPSFilter, and CamelotNativeEPSFilter. Definition at line 262 of file aw_eps.cpp. { // Get the OILFilter object pOILFilter = new ArtWorksEPSOILFilter(this); if (pOILFilter == NULL) return FALSE; // Load the description strings FilterName.Load(FilterNameID); FilterInfo.Load(FilterInfoID); // All ok return TRUE; }

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

Compare the current token against the ArtWorks 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 ArtWorks EPS token; FALSE if not. See also: EPSFilter::LookUpToken; EPSFilter::DecodeToken Reimplemented from EPSFilter. Reimplemented in CamelotEPSFilter, and CamelotNativeEPSFilter. Definition at line 413 of file aw_eps.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 (ArtWorksCommands[i].Cmd != EPSC_Invalid) { if (camStrcmp(TokenBuf, ArtWorksCommands[i].CmdStr) == 0) { // Found the token - set the token variable and return success Token = ArtWorksCommands[i].Cmd; return; } // Try next command i++; } // Did not find this token - pass on to base class. EPSFilter::LookUpToken(); }

BOOL ArtWorksEPSFilter::NeedsPrintComponents (  void   )  [virtual]

Informs the print components code that no data should be written. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 23/5/00 Returns: FALSE - ArtWorks files don't need print components. Reimplemented from EPSFilter. Definition at line 998 of file aw_eps.cpp. { // We don't want print components! return FALSE; }

BOOL ArtWorksEPSFilter::PrepareToExport (  CCLexFile *  pFile, Spread *  pSpread )  [virtual]

Prepare to import EPS data using this filter. This sets up the filter to a sensible state for reading. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 15/04/94 Parameters: pFile  - The File to export to [INPUTS] pSpread - The spread to export Returns: TRUE if succeeded, FALSE if not (e.g. no memory for EPS stack) Errors: Out of memory. See also: EPSFilter::DoImport; EPSFilter::CleanUpAfterImport Scope: Private Reimplemented from EPSFilter. Reimplemented in CamelotEPSFilter, and CamelotNativeEPSFilter. Definition at line 351 of file aw_eps.cpp. { #ifdef DO_EXPORT // Created the 'file' DC for rendering and try to open the specified file. ExportDCPtr = new EPSExportDC(this); if (ExportDCPtr == NULL) return FALSE; // Tell it about the file if (!ExportDCPtr->Init(pFile)) return FALSE; // Get the position of the first page, and use this to set the origin. Page *pPage = pSpread->FindFirstPageInSpread(); ENSURE(pPage != NULL, "Spread has no pages"); ERRORIF(pPage == NULL, _R(IDT_DOC_BADSTRUCTURE), FALSE); // Use bottom left of page as origin DocRect PageRect = pPage->GetPageRect(); ExportDCPtr->SetOrigin(PageRect.lo); // Create a new render region to export to: // Don't care about clip regions when exporting - create a null region. DocRect NullClipRect; NullClipRect.MakeEmpty(); if (IS_A(this, ArtWorksEPSFilter)) { // Don't use rendering matrix when exporting EPS as it uses fractional coordinates. Matrix Identity; // Don't use view scale; set to 1 FIXED16 Scale(1); // Create the region ExportRegion = new ArtWorksEPSRenderRegion(NullClipRect, Identity, Scale); if (ExportRegion == NULL) return FALSE; // Attach to the right device. ExportRegion->AttachDevice(DocView::GetSelected(), ExportDCPtr->GetDC(), pSpread); } // All ok return TRUE; #else return FALSE; #endif };

BOOL ArtWorksEPSFilter::ProcessBlend (   )  [protected]

Reads in all the elements of a blend structure in the EPS file. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Returns: TRUE if the blend was processed correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory Reimplemented in CamelotEPSFilter. Definition at line 1016 of file aw_eps.cpp. { if (!StartBlend()) return FALSE; // Keep processing tokens until we find the end of the blend do { GetToken(); // Look for the end of the blend token... if (Token == EPSC_aebd) { return EndBlend(); } } // Otherwise keep going until an error or eof is encountered while (HandleToken() && (!EPSFile->eof())); if (EPSFile->eof()) { // Didn't find end of blend - syntax error; deal with it HandleEPSError(); } // If we're here, something went wrong return FALSE; }

BOOL ArtWorksEPSFilter::ProcessBlender (   )  [protected]

Reads in all the elements of a blender structure in the EPS file. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Returns: TRUE if the blender was processed correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory Reimplemented in CamelotEPSFilter. Definition at line 1182 of file aw_eps.cpp. { if (!StartBlender()) return FALSE; // Keep processing tokens until we find the end of the blender do { GetToken(); // Look for the end of the blender token... if (Token == EPSC_aebr) { return EndBlender(); } } // Otherwise keep going until an error or eof is encountered while (HandleToken() && (!EPSFile->eof())); if (EPSFile->eof()) { // Didn't find end of blender - syntax error; deal with it HandleEPSError(); } // If we're here, something went wrong return FALSE; }

BOOL ArtWorksEPSFilter::ProcessEnvelope (   )  [protected]

Reads in all the elements of an envelope structure in the ArtWorksEPS file and builds the camelot envelope tree. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 06/03/94 Returns: TRUE if the envelope object was processed correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory Notes: This reader is reasonably complex. It is made so soley by the problem of being unable to calculate an inverse transform of an envelope. The crux of the matter is this. If you apply attributes to an already enveloped set of objects (lets call them the Dset), then in some way the attributes need to be applied to the source objects (the Sset). Now when you do this in ArtWorks eg, apply a linear fill to the Dset, the same fill is exported as applied to the Sset. Import the file back in and ArtWorks rebuilds both Sset and Dset from the file applying all necessary attributes there in. This works. But now we have a Dset attribute applied to an Sset object. As soon as you regenerate the Dset from the Sset (by tweeking the envelope shape) the new attributes created are wrong, as it transforms already transformed attributes. Ok, this problem prevents me from simply loading all Sset members from the file and recreating the Dset automatically. The loaded image does not look correct when grad fills are applied. (ie more often than not). Complexity level 1. To combat this problem, I'll do as ArtWorks did and load both Sset & Dset members. However, another problem arrises here.... ArtWorks envelope structure is as follows line col fill col start env envelope shape fill col invisible path (Sset) mangled path (Dset) fill col invisible path (Sset) mangled path (Dset) end env and this is saved as such in its EPS structure. Now Camelots structure is slightly different. It creates a source tree for Sset and a destination tree for Dset. Hence we need to disassemble the AW structure into two trees with the correct attributes in each. How do we do this? Complexity level 2. We could do this while importing, keeping two trees on the go, importing the correct bits into the correct tree. However this has many problems associated with it. Globally applied atts will need to be created in both trees. Groups too. We would have to intercept far more than the envelope tokens during import to do it. - no chance. So the only way to do it is to import the structure as is, creating an Artworks envelope inside Camelot. This will be structured as follows Env | > EnvShape => MouldGroup => Moulder | > { Sset + Dset objects } Having done this, we will convert this into Env | > EnvShape => MouldGroup => Moulder | | > Sset > Dset So long as we can tell the difference between Sset and Dset objects, which we can (all Dset objs are primary children of an Sset obj and Dset objects never contain Sset objs as children) we can use object move technology to build the correct moulder. Attributes will move (via inheritance) correctly with objects. Reimplemented in CamelotEPSFilter. Definition at line 1390 of file aw_eps.cpp. { // NOT IMPLEMENTED if (!StartMould(MOULDSPACE_ENVELOPE)) return FALSE; if (ProcessMould()) // If we've completed then all is well return EndMould(); if (EPSFile->eof()) { // Didn't find end of envelope - syntax error; deal with it HandleEPSError(); } // if made it here all is not well return FALSE; }

BOOL ArtWorksEPSFilter::ProcessMangledObjs (   )  [protected]

On finding a 'apc' token in the input stream, this function is executed. It will process all further tokens in the stream until a path termination has been found. A path terminator is considered any of { s,S,b,B,f,F,h,H } Its purpose is strictly defined. It must place the next set of attributes and single path as children of the last object imported rather than the default action which would be to stick them in as siblings of the object. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 06/03/94 Returns: TRUE if the mangled object has been dealt with correctly FALSE if not. Errors: Syntax error in EPS file, Out of memory Definition at line 1866 of file aw_eps.cpp. { // Set the new position of pNode, our insert indicator Node *pOldPos = pNode; pNode=pNode->FindLastChild(); if (pNode==NULL) { pNode=pOldPos; return FALSE; } BOOL ok = TRUE, end = FALSE; // The next path we create should be mangled ThePathType = PATH_MANGLED; while ((!end) && (!EPSFile->eof()) && (ok)) { GetToken(); switch (Token) { case EPSC_axm: // ignore axm in this context // See notes on func HandleMouldedFill below ok = Stack.Discard(4); break; case EPSC_s: case EPSC_f: case EPSC_b: case EPSC_h: case EPSC_S: case EPSC_F: case EPSC_B: case EPSC_H: // We've finished so set term flag end = TRUE; ok = HandleToken(); break; default: // try to handle whatever token it was. ok = HandleToken(); break; } } // Set the path back to something sensible ThePathType=PATH_NORMAL; pNode=pOldPos; if (ok && !(EPSFile->eof())) return TRUE; // Arrgh didn't find an end-of-path token - syntax error; deal with it HandleEPSError(); return FALSE; }

BOOL ArtWorksEPSFilter::ProcessMould (   )  [protected]

Processes tokens inside a mould object. Tokens specific to mould objects are processed along with some overridding of default tokens such as groups. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 06/03/95 Returns: TRUE if the mould was processed ok; FALSE if not. See also: Reimplemented in CamelotEPSFilter. Definition at line 1589 of file aw_eps.cpp. { // Keep processing tokens until we find the end of the envelope while (!EPSFile->eof()) { GetToken(); // Look for the end of the envelope token... switch (Token) { case EPSC_aeev: case EPSC_aepr: // if we've found the envelope/perspective end then // all is well. return TRUE; break; case EPSC_apc: // Create next object as a child if (!ProcessMangledObjs()) return FALSE; break; case EPSC_u: // NOT IMPLEMENTED INSIDE MOULDS break; case EPSC_U: // NOT IMPLEMENTED INSIDE MOULDS break; case EPSC_aof: // don't need this token if (!Stack.Discard(2)) { HandleEPSError(); return FALSE; } break; case EPSC_h: Token = EPSC_b; if (!HandleToken()) return FALSE; break; case EPSC_H: Token = EPSC_B; if (!HandleToken()) return FALSE; break; default: // try to handle whatever token this is. if (!HandleToken()) return FALSE; break; } } HandleEPSError(); return FALSE; }

BOOL ArtWorksEPSFilter::ProcessMouldShape (   )  [protected]

Reads in all the elements of a mould geometry held in the EPS file. The description of the geometry for this particular file type is that of a path. Depending on the geometry type (perspective or envelope) we will obviously expect a slightly different path. The rules are, that currently perspective geometry is described as {m,l,l,l,l} and envelope geometry is {m,c,c,c,c}. Internally we are not restricted to these but ArtworksEPS certainly is. Input Stack = coord, coord. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 06/03/94 Returns: TRUE if the shape has been read correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory Reimplemented in CamelotEPSFilter. Definition at line 1677 of file aw_eps.cpp. { // We really should be inside a mould object at this stage if (!IS_A(pNode,NodeMould)) { ERROR3("Mould shape found outside a mould object"); return FALSE; } NodeMould* pNodeMould = (NodeMould*)pNode; // Create a path object to read the mould geometry into Path TempPath; if (!TempPath.Initialise(24,12)) { HandleNoMemory(); return FALSE; } // Set the current used slots to none INT32 numt = 0; DocCoord Ta,Tb,Tc; PathFlags flags; flags.IsSelected = FALSE; // ok, pop of