CamelotEPSFilter Class Reference

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

#include <cameleps.h>

Inheritance diagram for CamelotEPSFilter:

List of all members.

Public Member Functions
	CamelotEPSFilter ()
	Constructor for an CamelotEPSFilter object. The object should be initialised before use.
BOOL	Init ()
	Initialise an CamelotEPSFilter object.
BOOL	IsDefaultDocRequired (const TCHAR *pcszPathName)
	Works out if opening a file of this type requires a default document to be loaded. If the file format supplies the document then return FALSE otherwise return TRUE. An example would be opening a bitmap file. This has no document defined in the file format and so we need to load the default document before importing the bitmap into this file. In this baseclass version return FALSE and hence assume that the filters that need to will override this function to return TRUE.
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.
BOOL	ExportBitmap (KernelBitmap &)
	Export a bitmap to a Camelot EPS file. This outputs the standard tokens and data required to embed a bitmap in a Camelot EPS file.
virtual BOOL	CanIncludePreviewBmp ()
	Admits that Camelot EPS is able to have a Preview Bitmap attached to the document. To actually put a bitmap into the file, call the IncludePreviewBmp(TRUE).
Protected Member Functions
virtual void	LookUpToken ()
	Compare the current token against the Camelot 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 Camelot EPS operators.
INT32	EPSHeaderIsOk (ADDR pFileHeader, UINT32 HeaderSize)
	Checks to see if the EPS comment headers specify that this is an Camelot generated EPS file, as required.
BOOL	PrepareToImport ()
	See base class. This just sets up the bitmap fill flag for Camelot EPS.
void	CleanUpAfterImport (BOOL Successful)
	stops stuff happening after clearing up for a Camelot EPS import
virtual BOOL	GetExportOptions ()
	Allows the user to be prompted to get information for export. In this Camelot EPS case, we are affectively exporting a printable EPS and so require the user to set a few options. Moves the code from OilFilters to a proper function. Scope: Protected.
virtual BOOL	ReadBitmap ()
	Reads the bitmap info from the eps stack and loads in the bitmap data It loads a type 0 bitmap.
virtual void	BitmapPoolAttach (KernelBitmap *pBitmap)
	Makes a reference to the bitmap so that it can be used throughout the eps file with repeating the data. This base class version actually does nothing but delete the bitmap. CamelotNativeEPS is where the real processing is done.
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 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. Path importing is returned to normal (i.e. they're no longer discarded).
BOOL	ProcessRegularShape ()
	Reads in all the elements of a blend structure in the EPS file.
BOOL	ProcessRegularShapeParams ()
	Reads in all the parameters of a regular shape structure in the EPS file.
BOOL	ProcessEnvelope ()
	Reads in all the elements of an envelope structure in the EPS file.
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 mould has finished being constructed and we want to return to normal node positioning.
BOOL	RemoveUnwantedAttributes (NodeMould *pNodeMould)
	Removes unwanted attributes added as first children of the node mould. It does this by scanning the children of the nodemouldgroup and determining what attributes are applied here.
void	BuildSubtreeAttrMap (CCAttrMap *pAttribMap, Node *pNode)
	Adds all attribute pointers to the pAttribMap which it finds as children of pParent. Notes: Told off by MarkN for not commenting ... oopps.
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	ProcessMouldTokens ()
	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. Input Stack = coord, coord.
BOOL	ProcessMouldSourceObjs ()
	Reads in all the objects within the mould source grouping.
BOOL	ProcessMouldDestinObjs ()
	Reads in all the objects within the mould destination grouping.
BOOL	ProcessMouldThreshold ()
	Reads in all the elements of a mould threshold structure in the EPS file. The threshold structure is defined as an extension token as it only came into existance after version 1.1 documents. This function is called from the extension token parser. We read the threshold value and set the EPSFilter variable NewMouldThreshold. Having read in the mould, the threshold will be read from this variable and overwrite the default constructed threshold.
BOOL	ReadSimplePath (Path *TempPath)
	Reads in the defined mould path shape.
BOOL	ProcessFontFlags ()
	Reads in all the elements of a font flags structure in the EPS file.
BOOL	ProcessBitmapFlags ()
	Reads in all the elements of a bitmap flags structure in the EPS file.
BOOL	ProcessFontType ()
	Reads in all the elements of a font type structure in the EPS file.
BOOL	FindEndOfTag ()
	Continues reading tokens until the ceo token is found.
BOOL	ProcessGuideLayer ()
	Reads in a guide layer object.
BOOL	ProcessGuideline ()
	Reads in a guide line object.
Protected Attributes
PendingBitmap	m_PendingBitmap
INT32	BitmapTransparencyIndex
KernelBitmap *	pBitmap
NodeRegularShape *	pRegularShape
BOOL	RegularShapeIsFilled
BOOL	RegularShapeIsStroked
CamelotEPSFilter::_BitmapAttrs	BitmapAttrs
Static Protected Attributes
static CommandMap	CamelotCommands []
Private Member Functions
	CC_DECLARE_DYNAMIC (CamelotEPSFilter)
Classes
struct	_BitmapAttrs

---

Detailed Description

A filter that imports EPS files in Camelot EPS format.

Author:

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

Date:

08/03/94

See also:

EPSFilter; ArtWorksEPSFilter

Definition at line 262 of file cameleps.h.

---

Constructor & Destructor Documentation

CamelotEPSFilter::CamelotEPSFilter (   )

Constructor for an CamelotEPSFilter 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 293 of file cameleps.cpp. { // Set up filter descriptions. FilterNameID = _R(IDT_CAMEPS_FILTERNAME); FilterInfoID = _R(IDT_CAMEPS_FILTERINFO); ImportMsgID = _R(IDT_IMPORTMSG_CAMELOT); ExportMsgID = _R(IDT_EXPORTMSG_CAMEPS); FilterID = FILTERID_CAMELOT_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 // We don't want to re-position Camelot files because they should be ok and // Charles gets upset if his drawings move. AdjustOrigin = FALSE; }

---

Member Function Documentation

void CamelotEPSFilter::BitmapPoolAttach (  KernelBitmap *  pBitmap  )  [protected, virtual]

Makes a reference to the bitmap so that it can be used throughout the eps file with repeating the data. This base class version actually does nothing but delete the bitmap. CamelotNativeEPS is where the real processing is done. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/95 Parameters: pBitmap  - The bitmap to attach [INPUTS] Reimplemented in CamelotNativeEPSFilter. Definition at line 1494 of file cameleps.cpp. { // Base class version of the function just deletes the bitmap as it does not really know // what it needs to do with it if (pBitmap!=NULL) delete pBitmap; }

void CamelotEPSFilter::BuildSubtreeAttrMap (  CCAttrMap *  pAttribMap, Node *  pParent )  [protected]

Adds all attribute pointers to the pAttribMap which it finds as children of pParent. Notes: Told off by MarkN for not commenting ... oopps. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 18/10/95 Parameters: pAttribMap  = a pointer to an attribute map [INPUTS] pParent = a pointer to the parent node Returns: - Definition at line 2519 of file cameleps.cpp. { CCRuntimeClass* pTypeInfo; void* pDummy; Node* qNode = pParent->FindFirstChild(); while (qNode) { if (qNode->IsAnAttribute()) { NodeAttribute* pAttrib = (NodeAttribute*)qNode; pTypeInfo = pAttrib->GetAttributeType(); if (!pAttribMap->Lookup(pTypeInfo, pDummy)) pAttribMap->SetAt(pTypeInfo, qNode); } if (qNode->FindFirstChild()) { BuildSubtreeAttrMap(pAttribMap, qNode); } qNode = qNode->FindNext(); } }

BOOL CamelotEPSFilter::CanIncludePreviewBmp (   )  [virtual]

Admits that Camelot EPS is able to have a Preview Bitmap attached to the document. To actually put a bitmap into the file, call the IncludePreviewBmp(TRUE). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 2/2/95 Returns: TRUE See also: Filters::CanIncludePreviewBmp Reimplemented from Filter. Definition at line 364 of file cameleps.cpp. { return TRUE; }

CamelotEPSFilter::CC_DECLARE_DYNAMIC (  CamelotEPSFilter   )  [private]

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

stops stuff happening after clearing up for a Camelot EPS import Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 15/07/95 Parameters: [INPUTS]  Returns: - Errors: - Reimplemented from EPSFilter. Reimplemented in CamelotNativeEPSFilter. Definition at line 524 of file cameleps.cpp. { if(IS_A(this, CamelotEPSFilter)) return; ArtWorksEPSFilter::CleanUpAfterImport(Successful); }

BOOL CamelotEPSFilter::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: 29/11/94 Returns: TRUE if the blend was ended ok; FALSE if not. Errors: Out of memory See also: CamelotEPSFilter::StartBlend Reimplemented from ArtWorksEPSFilter. Definition at line 1912 of file cameleps.cpp. { // Sanity check ENSURE(pNode->IsKindOf(CC_RUNTIME_CLASS(NodeBlend)), "No blend in CamelotEPSFilter::EndBlend"); // Keep the blend ptr and find the first child of the node before we reset pNode. Node* pNodeBlend = pNode; Node* pChildNode = pNode->FindFirstChild(); // Get the parent of the blend node, and use that to add new objects to pNode = pNodeBlend->FindParent(); ENSURE(pNode != NULL, "Blend has no parent in ProcessBlend()"); // Initialise all the child blender nodes UINT32 BlenderCount=0; while (pChildNode != NULL) { if (IS_A(pChildNode,NodeBlender)) { NodeBlender* pNodeBlender = (NodeBlender*)pChildNode; // Get the imported blender params INT32 PathIndexStart = pNodeBlender->GetPathIndexStart(); INT32 PathIndexEnd = pNodeBlender->GetPathIndexEnd(); INT32 ObjIndexStart = pNodeBlender->GetObjIndexStart(); INT32 ObjIndexEnd = pNodeBlender->GetObjIndexEnd(); // Find the nodes this blender is to blend together NodeRenderableInk* pNodeStart = pNodeBlender->FindObjIndexedNode(ObjIndexStart); NodeRenderableInk* pNodeEnd = pNodeBlender->FindObjIndexedNode(ObjIndexEnd); // They should not be NULL if (pNodeStart == NULL || pNodeEnd == NULL) return FALSE; // Init the blender with the start and end nodes. if (!pNodeBlender->Initialise(pNodeStart,pNodeEnd,PathIndexStart,PathIndexEnd,ImportInfo.pOp,NULL,TRUE)) return FALSE; BlenderCount++; } pChildNode = pChildNode->FindNext(); } if (BlenderCount == 0) { ERROR3("Imported Blend node doesn't contain any blender nodes"); if (!ImportInfo.pOp->DoHideNode(pNodeBlend, TRUE)) return FALSE; } return TRUE; }

BOOL CamelotEPSFilter::EndBlender (   )  [protected]

Used when a blender has finished being constructed. Path importing is returned to normal (i.e. they're no longer discarded). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/11/94 Returns: TRUE if the blender was ended ok; FALSE if not. Errors: - See also: CamelotEPSFilter::StartBlender Reimplemented from ArtWorksEPSFilter. Definition at line 2077 of file cameleps.cpp. { ThePathType = PATH_NORMAL; return TRUE; }

BOOL CamelotEPSFilter::EndMould (   )  [protected]

Used when a mould 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: CamelotEPSFilter::StartMould() Reimplemented from ArtWorksEPSFilter. Definition at line 2408 of file cameleps.cpp. { // Sanity check ERROR3IF(!pNode->IsKindOf(CC_RUNTIME_CLASS(NodeMould)), "No MouldParent in CamelotEPSFilter::EndMould"); // Get a pointer to the mould object NodeMould* pNodeMould = (NodeMould*)pNode; // move pNode up one level pNode = pNode->FindParent(); ERROR3IF(pNode==NULL, "No parent of mould in CamelotEPSFilter::EndMould"); // for loaded docs we need to set the default threshold to the // old 1024 threshold until such time as it changes by way of parsing // the threshold token. This avoids blends from remapping! pNodeMould->GetGeometry()->SetThreshold(EPSFilter::NewMouldThreshold); // We should really have these items, otherwise well, we have nothing whatsoever NodeMouldPath* pNodeMouldPath = (NodeMouldPath*)pNodeMould->FindFirstChild(CC_RUNTIME_CLASS(NodeMouldPath)); NodeMouldGroup* pNodeMouldGroup = (NodeMouldGroup*)pNodeMould->FindFirstChild(CC_RUNTIME_CLASS(NodeMouldGroup)); if (pNodeMouldPath==NULL || pNodeMouldGroup==NULL) { // delete the object and all its children pNodeMould->CascadeDelete(); } // Finally trash any unwanted attributes which may have been added // by SnapShotCurrentAttributes. RemoveUnwantedAttributes(pNodeMould); // All is well and lovely return TRUE; }

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

Checks to see if the EPS comment headers specify that this is an Camelot 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 ArtWorksEPSFilter. Reimplemented in CamelotNativeEPSFilter. Definition at line 408 of file cameleps.cpp. { // THIS ROUTINE 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... istringstream HeaderFile( (char*)pFileHeader ); char Buffer[200]; UINT32 Lines = 0; while ((Lines < 20) && !HeaderFile.eof()) { HeaderFile.getline(Buffer, 200); Lines++; // Return TRUE if this file was created by Camelot if (strncmp(Buffer, "%%Creator: Camelot", 18) == 0) { // Camelot is the creator. return 10; } // (ChrisG 8/11/00) Changed creator type to "Xara X") else if (strncmp (Buffer, "%%Creator: Xara X", 17) == 0) { // New Xara X string was set as the creator. 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 (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; }

BOOL CamelotEPSFilter::ExportBitmap (  KernelBitmap &  TheBitmap  )  [virtual]

Export a bitmap to a Camelot EPS file. This outputs the standard tokens and data required to embed a bitmap in a Camelot EPS file. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 01/09/94 Parameters: TheBitmap  - the bitmap to export [INPUTS] Returns: TRUE if the bitmap was exported ok (or if it wasn't exported because the file format does not support it; FALSE if an error occured. Errors: Usual disk/file errors. See also: Filter::ExportBitmap Reimplemented from Filter. Reimplemented in CamelotNativeEPSFilter. Definition at line 1520 of file cameleps.cpp. { #if !defined(EXCLUDE_FROM_RALPH) BitmapInfo Info; String_256 BitmapName; // Check to seed if the bitmap has a transparent Index, // and output a special token if so if (TheBitmap.ActualBitmap->GetBPP() <= 8) { INT32 TransparencyIndex; if (TheBitmap.ActualBitmap->GetTransparencyIndex(&TransparencyIndex)) { TRACEUSER( "Will", _T("Exporting bitmap with Transparent Index %d\n"), TransparencyIndex); ExportDCPtr->OutputValue((INT32) EOTAG_BITMAPFLAGS); ExportDCPtr->OutputToken(_T("cso")); // Start of new object type ExportDCPtr->OutputValue((INT32) TransparencyIndex); ExportDCPtr->OutputToken(_T("cbti")); // Index of the colour that is transparent ExportDCPtr->OutputToken(_T("ceo")); // End of new object type ExportDCPtr->OutputNewLine(); } } // Get details of the bitmap TheBitmap.ActualBitmap->GetInfo(&Info); BitmapName = TheBitmap.ActualBitmap->GetName(); // Write them out to the EPS file. ExportDCPtr->OutputString((TCHAR*)BitmapName); ExportDCPtr->OutputValue((UINT32) Info.PixelWidth); ExportDCPtr->OutputValue((UINT32) Info.PixelHeight); ExportDCPtr->OutputValue((UINT32) Info.PixelDepth); ExportDCPtr->OutputValue((UINT32) Info.NumPaletteEntries); ExportDCPtr->OutputUserSpaceValue(Info.RecommendedWidth); ExportDCPtr->OutputUserSpaceValue(Info.RecommendedHeight); // Bitmap type is 0 as this is the type that exports all the bitmap data // Type 1 is used as a reference to a bitmap in the pool ExportDCPtr->OutputToken(_T("0")); // Write out the bitmap start token ExportDCPtr->OutputToken(_T("csbm")); ExportDCPtr->OutputNewLine(); // Write out the bitmap data TheBitmap.ActualBitmap->ExportBitmap(ExportRegion); // Write out the bitmap end token ExportDCPtr->OutputToken(_T("cebm")); ExportDCPtr->OutputNewLine(); #endif // All ok return TRUE; }

BOOL CamelotEPSFilter::FindEndOfTag (   )  [protected]

Continues reading tokens until the ceo token is found. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 17/06/95 Returns: TRUE if the end of tag token was found, FALSE if not. Errors: Syntax error in EPS file, Out of memory Definition at line 1703 of file cameleps.cpp. { // Keep processing tokens until we find the 'end of tag' token while (!EPSFile->eof()) { GetToken(); switch (Token) { case EPSC_ceo: return TRUE; break; default: if (!HandleToken()) return FALSE; break; } } HandleEPSError(); return FALSE; }

TCHAR * CamelotEPSFilter::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 ArtWorksEPSFilter. Definition at line 1399 of file cameleps.cpp. { INT32 i = 0; while (CamelotCommands[i].Cmd != EPSC_Invalid) { if (CamelotCommands[i].Cmd == Cmd) return CamelotCommands[i].CmdStr; // Try next command i++; } // Couldn't find it - default to base class method return ArtWorksEPSFilter::GetEPSCommand(Cmd); }

BOOL CamelotEPSFilter::GetExportOptions (   )  [protected, virtual]

Allows the user to be prompted to get information for export. In this Camelot EPS case, we are affectively exporting a printable EPS and so require the user to set a few options. Moves the code from OilFilters to a proper function. Scope: Protected. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> HUmphrys Date: 22/12/95 Parameters: -  [INPUTS] Returns: TRUE if OK, FALSE if user pressed Cancel. Reimplemented from EPSFilter. Reimplemented in CamelotNativeEPSFilter. Definition at line 548 of file cameleps.cpp. { #if !defined(EXCLUDE_FROM_RALPH) OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(XSEPSExportOptions)); if ( pOpDesc ) pOpDesc->Invoke(); return !XSEPSExportOptions::Aborted; #endif return TRUE; }

BOOL CamelotEPSFilter::Init (  void   )  [virtual]

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

BOOL CamelotEPSFilter::IsDefaultDocRequired (  const TCHAR *  pcszPathName  )  [virtual]

Works out if opening a file of this type requires a default document to be loaded. If the file format supplies the document then return FALSE otherwise return TRUE. An example would be opening a bitmap file. This has no document defined in the file format and so we need to load the default document before importing the bitmap into this file. In this baseclass version return FALSE and hence assume that the filters that need to will override this function to return TRUE. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/10/95 Parameters: pcszPathName  pointer to the pathname to check [INPUTS] Returns: TRUE if the filter requires a default document, FALSE if not. See also: Filter; Filter::IsDefaultDocRequired; CCamDoc::OnOpenDocument; FilterFamily::DoImport; Filter::DoImport; Reimplemented from EPSFilter. Definition at line 389 of file cameleps.cpp. { // Return false here. All derived classes should return what they need return FALSE; }

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

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

BOOL CamelotEPSFilter::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 ArtWorksEPSFilter. Reimplemented in CamelotNativeEPSFilter. Definition at line 577 of file cameleps.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Use base class to do most of it if (!EPSFilter::PrepareToExport(pFile, pSpread)) return FALSE; // Set export device to use full Camelot accuracy for user space values. ExportDCPtr->SetFullAccuracy(TRUE); // Create the region if it is this class if (IS_A(this, CamelotEPSFilter)) { // Don't care about clip regions when exporting - create a null region. DocRect NullClipRect; NullClipRect.MakeEmpty(); // 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); ExportRegion = new CamelotEPSRenderRegion(NullClipRect, Identity, Scale); if (ExportRegion == NULL) return FALSE; // Attach to the right device. ExportRegion->AttachDevice(DocView::GetSelected(), ExportDCPtr->GetDC(), pSpread); } #endif // All ok return TRUE; };

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

See base class. This just sets up the bitmap fill flag for Camelot EPS. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 23/08/94 Returns: TRUE if filter initialised ok; FALSE if not. Errors: See base class. See also: EPSFilter::PrepareToImport; Reimplemented from EPSFilter. Reimplemented in CamelotNativeEPSFilter. Definition at line 466 of file cameleps.cpp. { if(IS_A(this, CamelotEPSFilter)) { // tell the user that we can't do it PathName Path; String_256 FileName; BOOL HaveName = FALSE; if(EPSFile->IsKindOf(CC_RUNTIME_CLASS(CCDiskFile))) { CCDiskFile *DF = (CCDiskFile *)EPSFile; Path = DF->GetPathName(); FileName = Path.GetFileName(); HaveName = TRUE; } String_256 ErrMsg; if(HaveName) { String_256 ErrMsg; ErrMsg.MakeMsg(_R(IDE_LOADCAMELOTEPSITHINKNOTNAMED), (TCHAR *)FileName); Error::SetError(0, ErrMsg, 0); } else { Error::SetError(_R(IDE_LOADCAMELOTEPSITHINKNOT)); } return FALSE; } else { // Initialise base class first. if (!ArtWorksEPSFilter::PrepareToImport()) return FALSE; // Not expecting a bitmap fill initially m_PendingBitmap = PENDING_BITMAP_NONE; BitmapTransparencyIndex = -1; pBitmap = FALSE; pRegularShape = NULL; } return TRUE; }

BOOL CamelotEPSFilter::ProcessBitmapFlags (   )  [protected]

Reads in all the elements of a bitmap flags structure in the EPS file. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/06/95 Returns: TRUE if the bitmap flags were processed correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory Definition at line 1745 of file cameleps.cpp. { // Keep processing tokens until we find the end of the bitmap flags tag object while (!EPSFile->eof()) { GetToken(); // Look for the only bitmap tokens we're interested in switch (Token) { case EPSC_ceo: // found the end of the bitmap flags block so return done. return TRUE; break; case EPSC_cbot: // This token indicates that the next bitmap fill is really // a bitmap object m_PendingBitmap = PENDING_BITMAP_OBJECT_FILL; break; case EPSC_cbti: // The next bitmap must have a transparency Index INT32 Index; if (!Stack.Pop(&Index)) { HandleEPSError(); return FALSE; } BitmapTransparencyIndex = Index; break; default: // try to handle whatever token this is. if (!HandleToken()) return FALSE; break; } } HandleEPSError(); return FALSE; }

BOOL CamelotEPSFilter::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: 29/11/94 Returns: TRUE if the blend was processed correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory Reimplemented from ArtWorksEPSFilter. Definition at line 1803 of file cameleps.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_cebd) { 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 CamelotEPSFilter::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: 29/11/94 Returns: TRUE if the blender was processed correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory Reimplemented from ArtWorksEPSFilter. Definition at line 1979 of file cameleps.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_cebr) { 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 CamelotEPSFilter::ProcessEnvelope (   )  [protected]

Reads in all the elements of an envelope structure in the EPS file. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 14/03/95 Returns: TRUE if the envelope object was processed correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory Reimplemented from ArtWorksEPSFilter. Definition at line 2280 of file cameleps.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 CamelotEPSFilter::ProcessFontFlags (   )  [protected]

Reads in all the elements of a font flags structure in the EPS file. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/06/95 Returns: TRUE if the font flags were processed correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory Definition at line 1593 of file cameleps.cpp. { FontFlags.Bold = FALSE; FontFlags.Italic = FALSE; // Keep processing tokens until we find the end of the font flags tag object while (!EPSFile->eof()) { GetToken(); // Look for the only font tokens we're interrested in switch (Token) { case EPSC_ceo: // found the end of the font flags block so return done. return TRUE; break; case EPSC_cfft: // This flag indicates that the next bold/italic attributes are to // be applied to the current font style rather than as physical attributes FontFlags.Bold = TRUE; FontFlags.Italic = TRUE; break; default: // try to handle whatever token this is. if (!HandleToken()) return FALSE; break; } } HandleEPSError(); return FALSE; }

BOOL CamelotEPSFilter::ProcessFontType (   )  [protected]

Reads in all the elements of a font type structure in the EPS file. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/06/95 Returns: TRUE if the font type was processed correctly, FALSE if not. Errors: Syntax error in EPS file, Out of memory Definition at line 1643 of file cameleps.cpp. { EPSFilter::ClassOfFont = FC_TRUETYPE; // Keep processing tokens until we find the end of the font flags tag object while (!EPSFile->eof()) { GetToken(); // Look for the only font tokens we're interrested in switch (Token) { case EPSC_ceo: // found the end of the font flags block so return done. return TRUE; break;