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 off the move stacked coordinate BOOL ok = Stack.PopCoordPair(&Ta); if (!ok) { HandleEPSError(); return FALSE; } // Add this first element as a move to if (!TempPath.AddMoveTo(Ta, &flags)) { HandleNoMemory(); return FALSE; } // increase the number of tokens read numt++; BOOL done = FALSE; // Keep processing tokens until we find the end of the mould path while (!done && (!EPSFile->eof())) { GetToken(); // {m,c,c,c,c,c,c,c,c,e} is current maximum // if more complex, then illegal if ((numt++)>60) { HandleEPSError(); return FALSE; } switch (Token) { case EPSC_aml: // lineto (x,y) found ok = Stack.PopCoordPair(&Ta); if (ok) ok = TempPath.AddLineTo(Ta, &flags); break; case EPSC_amc: // curveto (x0,y0,x1,y1,x2,y2) found ok = Stack.PopCoordPair(&Tc); if (ok) ok = Stack.PopCoordPair(&Tb); if (ok) ok = Stack.PopCoordPair(&Ta); if (ok) ok = TempPath.AddCurveTo(Ta,Tb,Tc,&flags); break; case EPSC_amcp: // found a close path. That should be it for path elements ok = TempPath.CloseSubPath(); break; case EPSC_amep: // end path drawfile parameter completes the path // it contains a single 'length' parameter which seems // to be zero always ok = Stack.Discard(); done = TRUE; break; default: // try to handle whatever token this is. ok = HandleToken(); break; } if (!ok) { HandleNoMemory(); return FALSE; } } // We have read the path so now lets try and build the geometry // check the shape we've been given is fine and lovely UINT32 errID; if (!pNodeMould->GetGeometry()->Validate(&TempPath,errID)) { // ok the path we read is invalid so lets try to build a valid one Path* pPath = NULL; INT32 Corners[4] = {0, 3, 6, 9}; if (!pNodeMould->GetGeometry()->MakeValidFrom(&pPath, &TempPath, Corners)) { ERROR2(FALSE,"Unable to rectify invalid mould path in ProcessMouldShape()"); } if (!TempPath.CloneFrom(*pPath)) { delete pPath; HandleNoMemory(); return FALSE; } delete pPath; } // Build and if necessary fit the geometry NodeMouldPath* pNodeMPath = pNodeMould->CreateNewMouldShape(&TempPath,NULL,NULL); if (pNodeMPath==NULL) { HandleNoMemory(); return FALSE; } // set the geometry using this new mould shape if (!pNodeMould->GetGeometry()->Define(&(pNodeMPath->InkPath), &MouldRect)) { HandleNoMemory(); return FALSE; } // having created the shape bung it in the tree. if (!AddNewNode(pNodeMPath)) { delete pNodeMPath; HandleNoMemory(); return FALSE; } // Create a mould group object NodeMouldGroup* pMouldGroup = pNodeMould->CreateNewMouldGroup(NULL); if (pMouldGroup==NULL) { HandleNoMemory(); return FALSE; } if (!AddNewNode(pMouldGroup)) { delete pMouldGroup; HandleNoMemory(); return FALSE; } // finally leave the insert pointer on the MouldGroup object pNode = pMouldGroup; return TRUE; }

BOOL ArtWorksEPSFilter::ProcessPerspective (   )  [protected]

Reads in all the elements of an perspective structure in the EPS file. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 06/03/94 Returns: TRUE if the perspective object was processed correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory See also: ProcessEnvelope() for furher details Reimplemented in CamelotEPSFilter. Definition at line 1424 of file aw_eps.cpp. { // NOT IMPLEMENTED if (!StartMould(MOULDSPACE_PERSPECTIVE)) return FALSE; // If we've completed then all is well if (ProcessMould()) return EndMould(); if (EPSFile->eof()) { // Didn't find end of perspective - syntax error; deal with it HandleEPSError(); } // if made it here all is not well return FALSE; }

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

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. 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 CamelotEPSFilter, and CamelotNativeEPSFilter. Definition at line 453 of file aw_eps.cpp. { // Variables used to extract operands from the stack DocCoord Coords[3]; String_64 ColName; PColourCMYK Col; TintType Tint = TINT_NONE; FIXEDPOINT TintVal; INT32 Long; DocCoord StartPoint, EndPoint; PathFlags Flags; // Decode the command, and execute it... switch (Token) { // LineTo - overridden to overcome ArtWorks EPS incompatibility with AI EPS. case EPSC_l: if (ThePathType == PATH_DISCARD || ThePathType == PATH_DISCARD_STICKY) { if (!Stack.PopCoordPair(&Coords[0])) goto EPSError; break; } if (pInkPath == NULL) // Paths must start with a moveto goto EPSError; // Get the co-ordinate from the stack if (Stack.PopCoordPair(&Coords[0])) { // ArtWorks doesn't save smoothing bit of the point, so default to // no smoothing (it's the logical default). Flags.IsSmooth = FALSE; if (!pInkPath->InsertLineTo(Coords[0], &Flags)) // Not enough dynamic heap to insert the lineto command goto NoMemory; } else // Invalid number/type of coordinate operands goto EPSError; break; // Curveto - overridden to overcome ArtWorks EPS incompatibility with AI EPS. case EPSC_c: if (ThePathType == PATH_DISCARD || ThePathType == PATH_DISCARD_STICKY) { if (!Stack.PopCoordPair(&Coords[2]) || !Stack.PopCoordPair(&Coords[1]) || !Stack.PopCoordPair(&Coords[0])) goto EPSError; break; } if (pInkPath == NULL) // Paths must start with a moveto goto EPSError; // Get the co-ordinate from the stack if (Stack.PopCoordPair(&Coords[2]) && Stack.PopCoordPair(&Coords[1]) && Stack.PopCoordPair(&Coords[0])) { // ArtWorks doesn't save smoothing bit of the point, so default to // no smoothing (it's the logical default). Flags.IsSmooth = FALSE; if (!pInkPath->InsertCurveTo(Coords[0], Coords[1], Coords[2], &Flags)) // Not enough dynamic heap to insert the curveto command goto NoMemory; } else // Invalid number/type of coordinate operands goto EPSError; break; case EPSC_aoa: // NOT IMPLEMENTED if (!Stack.Discard()) goto EPSError; break; case EPSC_aafs: // NOT IMPLEMENTED if (!Stack.Discard(3)) goto EPSError; break; // Path related procedures case EPSC_ar: // ArtWorks rectangle ThePathType = PATH_RECT; break; case EPSC_arr: // NOT IMPLEMENTED if (!Stack.Discard(7)) goto EPSError; break; case EPSC_ae: { // ArtWorks ellipse ThePathType = PATH_ELLIPSE; // Read in parallelogram bounding box. if (!Stack.PopCoordPair(&ShapeBBox[0]) || !Stack.PopCoordPair(&ShapeBBox[1]) || !Stack.PopCoordPair(&ShapeBBox[2])) goto EPSError; // Fill in the 4th co-ordinate ShapeBBox[3].x = ShapeBBox[0].x + (ShapeBBox[2].x - ShapeBBox[1].x); ShapeBBox[3].y = ShapeBBox[0].y + (ShapeBBox[2].y - ShapeBBox[1].y); break; } case EPSC_apl: // NOT IMPLEMENTED if (!Stack.Discard()) goto EPSError; break; case EPSC_apc: // NOT IMPLEMENTED break; case EPSC_aof: // NOT IMPLEMENTED if (!Stack.Discard(2)) goto EPSError; break; // Text related procedures case EPSC_asto: // NOT IMPLEMENTED break; case EPSC_aeto: // NOT IMPLEMENTED break; case EPSC_aco: // NOT IMPLEMENTED if (!Stack.Discard(2)) goto EPSError; break; case EPSC_atc: // NOT IMPLEMENTED if (!Stack.Discard()) goto EPSError; break; case EPSC_atph: // NOT IMPLEMENTED if (!Stack.Discard()) goto EPSError; break; case EPSC_atof: // NOT IMPLEMENTED if (!Stack.Discard(2)) goto EPSError; break; // Blend related procedures case EPSC_asbd: return ProcessBlend(); case EPSC_aebd: goto EPSError; case EPSC_asbr: return ProcessBlender(); case EPSC_aebr: goto EPSError; // Mould related procedures case EPSC_asev: return ProcessEnvelope(); case EPSC_aeev: goto EPSError; case EPSC_aspr: return ProcessPerspective(); case EPSC_aepr: goto EPSError; case EPSC_amm: return ProcessMouldShape(); case EPSC_aml: case EPSC_amc: case EPSC_amcp: case EPSC_amep: // all these tokens are mould path related and are // delt with inside ProcessMouldShape(). If they are found // on their own elsewhere then we obviously have an error goto EPSError; // Group related procedures case EPSC_anu: // Discard the name - we don't do named groups. if (!Stack.Discard()) goto EPSError; // Process as a normal EPS group. GroupNesting++; return ProcessGroup(); // Linear/radial fills case EPSC_ax: // Colours are described using a name and tint as well as CMYK. Tint = TINT_ILLUSTRATOR; case EPSC_az: { DocColour StartColour, EndColour; DocCoord StartPoint, EndPoint; // Get start and end positions for grad-fills if (!Stack.PopCoordPair(&EndPoint) || !Stack.PopCoordPair(&StartPoint)) goto EPSError; // Get start and end colours for grad-fills if (!Stack.PopColour(&Col, Tint, &TintVal, &ColName)) // Invalid colour operands goto EPSError; // Keep hold of this colour definition LastEndColour.Col = Col; LastEndColour.Tint = Tint; LastEndColour.TintVal = TintVal; LastEndColour.ColName = ColName; GetEPSColour(&EndColour, &Col, Tint, TintVal, &ColName); if (!Stack.PopColour(&Col, Tint, &TintVal, &ColName)) // Invalid colour operands goto EPSError; // Keep hold of this colour definition LastStartColour.Col = Col; LastStartColour.Tint = Tint; LastStartColour.TintVal = TintVal; LastStartColour.ColName = ColName; GetEPSColour(&StartColour, &Col, Tint, TintVal, &ColName); // Get fill type if (!Stack.Pop(&Long)) goto EPSError; // Also save the last fill style LastFillType = Long; switch (Long) { // Decode ArtWorks EPS grad fill codes case 1: // Check for silly grad fills first... if (StartPoint == EndPoint) { // Zero length grad fill line! // Just set a flat fill using the first colour, cos that is // how Arc GDraw renders such fills. if (!SetFillColour(StartColour)) goto NoMemory; } else { if (!SetLinearFill(StartColour, EndColour, StartPoint, EndPoint)) goto NoMemory; } break; case 2: // Check for silly grad fills first... if (StartPoint == EndPoint) { // Zero length grad fill line! // Just set a flat fill using the second colour, cos that is // how Arc GDraw renders such fills. // // NB. This is different to linear fills above, which use the first // colour - that is how the GDraw cookie crumbles, cos that's // the kind of guys we are! :-) if (!SetFillColour(EndColour)) goto NoMemory; } else { if (!SetRadialFill(StartColour, EndColour, StartPoint, EndPoint)) goto NoMemory; } break; default: ENSURE(FALSE, "Unknown fill type found!"); break; // Don't know this fill type } break; } case EPSC_axm: { // ignore axm in this context if (!HandleMouldedFill()) goto EPSError; break; } case EPSC_axop: // NOT IMPLEMENTED if (!Stack.Discard(4)) goto EPSError; break; // Others(!) case EPSC_awr: if (!Stack.Pop(&Long)) goto EPSError; // Decode winding rule ENSURE((Long == 0) || (Long == 1), "Bad winding rule found in Artworks EPS"); if (Long == 0) { if (!SetWindingRule(NonZeroWinding)) goto NoMemory; } else if (Long == 1) { if (!SetWindingRule(EvenOddWinding)) goto NoMemory; } break; case EPSC_asc: // NOT IMPLEMENTED if (!Stack.Discard(3)) goto EPSError; break; case EPSC_aec: // NOT IMPLEMENTED if (!Stack.Discard(3)) goto EPSError; break; case EPSC_aca: // NOT IMPLEMENTED break; case EPSC_asah: // NOT IMPLEMENTED if (!Stack.Discard(3)) goto EPSError; break; case EPSC_aeah: // NOT IMPLEMENTED if (!Stack.Discard(3)) goto EPSError; break; case EPSC_asat: // NOT IMPLEMENTED if (!Stack.Discard(6)) goto EPSError; break; case EPSC_aeat: // NOT IMPLEMENTED if (!Stack.Discard(6)) goto EPSError; break; // Procedures that define a text object case EPSC_atp: // NOT IMPLEMENTED if (!Stack.Discard(2)) goto EPSError; break; case EPSC_atf: // NOT IMPLEMENTED if (!Stack.Discard()) goto EPSError; break; case EPSC_atxy: // NOT IMPLEMENTED if (!Stack.Discard(2)) goto EPSError; break; case EPSC_atrk: // NOT IMPLEMENTED if (!Stack.Discard(4)) goto EPSError; break; case EPSC_akrn: // NOT IMPLEMENTED if (!Stack.Discard(2)) goto EPSError; break; // Layer procedure case EPSC_alyr: { String_256 LayerName; INT32 Visible; INT32 Locked; INT32 Foreground; INT32 Printable; // We ignore the layer type and print over-ride flag (for now) if (!Stack.Pop(&Locked) || !Stack.Pop(&Printable) || !Stack.Pop(&Visible) || !Stack.Pop(&Foreground) || !Stack.Pop(&LayerName)) goto EPSError; if (Filter::ImportWithLayers) { // We are importing layers, so put all new nodes on this layer. UseLayer(LayerName); // Try to set the visible/locked flags on this layer, but only if // we created a new one (i.e. don't change the flags of existing layers. if (EPSFlags.AddToNewLayer) { // Here we force layers to be printable if they are in the foreground - just in case // This will have to change if the UI allows Printable & Foreground to be specified // independantly. Printable = Foreground; // Visible flag pLayer->SetVisible(!(Visible == 0)); // Locked flag pLayer->SetLocked(!(Locked == 0)); // Printable flag pLayer->SetPrintable(!(Printable == 0)); // Background flag pLayer->SetBackground(Foreground == 0); } } break; } // Sprite procedure case EPSC_ass: // NOT IMPLEMENTED ERROR2RAW("EPS reader cannot handle Acorn sprites - Dream On!"); goto EPSError; break; case EPSC_aes: // NOT IMPLEMENTED ERROR2RAW("EPS reader cannot handle Acorn sprites! - Dream On!"); goto EPSError; 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 ArtWorksEPSFilter::PromoteMangled (  Node *  rNode  )  [protected]

Promote all mangled child nodes to siblings of their parents. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 09/03/95 Parameters: rNode  = a pointer to a mangled node to promote [INPUTS] Returns: - Definition at line 2203 of file aw_eps.cpp. { Node* sNode; sNode=rNode->FindFirstChild(); while (sNode) { if (sNode->IsMangled()) { sNode->SetMangled(FALSE); sNode->MoveNode(rNode,NEXT); rNode->CascadeDelete(); delete rNode; return TRUE; } sNode=sNode->FindNext(); } return FALSE; }

BOOL ArtWorksEPSFilter::StartBlend (   )  [protected]

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. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Returns: TRUE if the new blend was created ok; FALSE if not. Errors: Out of memory See also: ArtWorksEPSFilter::EndBlend Reimplemented in CamelotEPSFilter. Definition at line 1061 of file aw_eps.cpp. { INT32 NumBlendShapes,Version,Expanded; // Read in the params BOOL ok = Stack.Pop(&NumBlendShapes); if (ok) ok = Stack.Pop(&Expanded); if (ok) ok = Stack.Pop(&Version); if (!ok) { HandleEPSError(); return FALSE; } // If the version isn;t one we know, go b-b-b-bang! ERROR1IF(Version != 1,FALSE,_R(IDT_EPS_BADSYNTAX)); // Make a new blend node for this blend NodeBlend *pBlend = new NodeBlend; if (pBlend==NULL) { HandleNoMemory(); return FALSE; } // Add it into the tree if (!AddNewNode(pBlend)) { HandleNoMemory(); return FALSE; } // Make sure new objects are added as children of the node pNode = pBlend; // All ok return TRUE; }

BOOL ArtWorksEPSFilter::StartBlender (   )  [protected]

Used when a blender structure needs to be created - after this is called, all new paths will be discarded, until EndBlender is called. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Returns: TRUE if the new blender was created ok; FALSE if not. Errors: Out of memory See also: ArtWorksEPSFilter::EndBlender Reimplemented in CamelotEPSFilter. Definition at line 1226 of file aw_eps.cpp. { UINT32 NumBlendSteps; INT32 Expanded,OneToOne,Complex; INT32 PathIndexStart,PathIndexEnd; // Get the blender params BOOL ok = Stack.Pop(&PathIndexEnd); if (ok) ok = Stack.Pop(&PathIndexStart); if (ok) ok = Stack.Pop(&NumBlendSteps); if (ok) ok = Stack.Pop(&OneToOne); if (ok) ok = Stack.Pop(&Complex); if (ok) ok = Stack.Pop(&Expanded); if (!ok) { HandleEPSError(); return FALSE; } // Make a new blender node for this blender NodeBlender *pNodeBlender = new NodeBlender; if (pNodeBlender == NULL) { HandleNoMemory(); return FALSE; } // Add it into the tree if (!AddNewNode(pNodeBlender)) { delete pNodeBlender; HandleNoMemory(); return FALSE; } // If both indexes are -ve, don't change the start points of the paths when blending if (PathIndexEnd < 0 && PathIndexEnd < 0) PathIndexStart = PathIndexEnd = 0; // Set the AW path indexes to be used when we get an "aebd" (end blend) token pNodeBlender->SetPathIndexStart(PathIndexStart); pNodeBlender->SetPathIndexEnd (PathIndexEnd); // Some of these flags are stored in the parent blend node in Camelot - so set them! if (!IS_A(pNode,NodeBlend)) { ERROR2(FALSE,"Found a blender token without finding a blend"); } NodeBlend* pNodeBlend = (NodeBlend*)pNode; pNodeBlend->SetNumBlendSteps(NumBlendSteps-1); pNodeBlend->SetOneToOne(OneToOne); // Discard all paths between this and the aebr tokens ThePathType = PATH_DISCARD_STICKY; // All ok return TRUE; }

BOOL ArtWorksEPSFilter::StartMould (  MouldSpace  mSpace  )  [protected]

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. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> (from MarkN's) Date: 06/03/95 Parameters: mSpace  = Mould geometry to define, either envelope or perspective [INPUTS] Returns: TRUE if the new mould object was created ok; FALSE if not. Errors: Out of memory See also: ArtWorksEPSFilter::EndMould Reimplemented in CamelotEPSFilter. Definition at line 1464 of file aw_eps.cpp. { // Read in the bounding box of the original objects if (!Stack.PopCoordPair(&MouldRect.hi) || !Stack.PopCoordPair(&MouldRect.lo)) { HandleEPSError(); return FALSE; } // create a mould parent and insert it in the tree NodeMould* pMouldParent = new NodeMould; if (pMouldParent==NULL) { HandleNoMemory(); return FALSE; } // give the parent mould object a shape and mould space to work with and stick it // in the tree if (!pMouldParent->CreateGeometry(mSpace)) { delete pMouldParent; HandleNoMemory(); return FALSE; } if (!AddNewNode(pMouldParent)) { HandleNoMemory(); return FALSE; } // Make sure new objects are added as children of the mould pNode = pMouldParent; // All ok return TRUE; }

---

Member Data Documentation

CommandMap ArtWorksEPSFilter::ArtWorksCommands [static, protected]

Definition at line 149 of file aw_eps.h.

GradEndCol ArtWorksEPSFilter::LastEndColour [private]

Definition at line 179 of file aw_eps.h.

INT32 ArtWorksEPSFilter::LastFillType [private]

Definition at line 177 of file aw_eps.h.

GradEndCol ArtWorksEPSFilter::LastStartColour [private]

Definition at line 178 of file aw_eps.h.

DocRect ArtWorksEPSFilter::MouldRect [private]

Definition at line 176 of file aw_eps.h.

---

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

• Kernel/aw_eps.h (r1785/r1302)
• Kernel/aw_eps.cpp (r1785/r1319)

---