EPSFilter Class Reference

Encapsulates a basic Adobe Illustrator EPS import/export filter. This filter can be used as a base class, because most EPS formats are based (more or less) on AI format. Derived filters can override whichever parts they want to implement other flavours of EPS. More...

#include <epsfiltr.h>

Inheritance diagram for EPSFilter:

List of all members.

Public Types
enum	PathType {   PATH_NORMAL, PATH_DISCARD, PATH_DISCARD_STICKY, PATH_RECT,   PATH_ELLIPSE, PATH_MANGLED }
Public Member Functions
	EPSFilter ()
	Constructor for an EPSFilter object. The object should be initialised before use.
virtual BOOL	Init ()
	Initialise an EPSFilter object. This is a base class and so should never actually be initialised so this function will always return FALSE, and also ENSURE in debug builds.
INT32	HowCompatible (PathName &Filename, ADDR HeaderStart, UINT32 HeaderSize, UINT32 FileSize)
	Looks at the start of the file to see if it recognises the file as belonging to it.
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 laod 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	DoImport (SelOperation *Op, CCLexFile *, Document *DestDoc, BOOL, ImportPosition *Pos=NULL, KernelBitmap **ppImportedBitmap=NULL, DocCoord *pPosTranslate=NULL, String_256 *URL=NULL)
	Read EPS data from an EPS file, and convert it into Camelot tree data structures. When the file reading is complete, a forced redraw is issued for the area affected by the new data. At the moment, the data is just put on the first layer of the first spread of the first chapter in the document, and this is a bodge. The operation is terminated (i.e. its End() function is called) if the operation completed succesfully.
BOOL	DoExport (Operation *, CCLexFile *, PathName *, Document *, BOOL)
	Exports the File as EPS. The various forms of EPS are to be found in the classes derived from this one.
BOOL	ExportBinaryHeader (CCLexFile *)
	Outputs the initial binary Header for EPS files that contain a TIFF preview of the EPS. This format is described on page 729 of the Big Red Postscript book (PostScript Language Reference Manual Second Edition). The basic form is as follows :- MonoOn: Bytes 0-3 C5D0D3C6 Bytes 4-7 Byte pos of start of PostScript in file Bytes 8-11 Length of PostScript section in Bytes Bytes 12-15 Start of MetaFile (always 0 from Camelot) Bytes 16-19 Length of MetaFile (always 0 from Camelot) Bytes 20-23 Start of TIFF file Bytes 24-27 Length of TIFF file Bytes 28-29 Checksum or FFFF.
BOOL	CorrectBinaryHeader (CCLexFile *)
	Goes back to the binary header at the start of the file and fills in the correct values to all the fields.
virtual BOOL	WriteEPSProlog ()
	Allows the filter a chance to write out something in the Prolog section.
virtual BOOL	WriteEPSSetup ()
	Allows the filter a chance to write out something in the Prolog section.
virtual BOOL	WriteEPSComments ()
	Allows the filter a chance to write out something in the Prolog section.
virtual BOOL	WriteScript ()
	Allows the filter a chance to write out something in the Prolog section.
virtual BOOL	NeedsPrintComponents (void)
	Allows the program to determine whether print components are needed for this flavour of EPS.
TCHAR *	GetEPSCommand (EPSCommand Cmd)
	Given an EPS token, return the string representation of it; mainly for debugging purposes.
EPSExportDC *	GetExportDC ()
EPSRenderRegion *	GetExportRegion ()
virtual INT32	ImportBinary (ADDR pData, INT32 Length)
	Converts EPS hex strings into binary data. Attempts to read the number of bytes specified from the file.
virtual BOOL	AddNewNode (Node *pNewNode)
	When a new node is created, this function puts it into the tree in the correct place. It may add it into a group, or a new layer which is currently being constructed, or onto an existing layer.
void	HandleEPSError ()
	Cleans up when a syntax error is encountered in the EPS file. Any objects constructed so far are deleted, and the error message ID is set.
INT32	DecodeHexString (ADDR pData, INT32 Length, INT32 nStart=0)
	Treat the current token as a hex string, and decode it into binary data and place it in the buffer provided by the caller. No more than Length bytes should be placed in the buffer.
BOOL	ResetImportOrigin ()
	If the importer changes the pages in the document when loading, this allows it to reset the origin.
BOOL	ResetImportOrigin (DocCoord NewOrigin)
	Instructs the filter to use the new origin, because we are importing and otherwise QuickShapes and Text Stories will be incorrectly positioned.
Static Public Member Functions
static BOOL	InitPrefs ()
	Initialise preferences for EPS formats. This is used by the Camelot EPS export filter, and includes font mappings, DPI, PostScript language level control, and exporting text as curves.
Static Public Attributes
static INT32	XSEPSExportPSType = 2
static INT32	XSEPSExportDPI = 200
static BOOL	XSEPSExportTextAsCurves = FALSE
Protected Member Functions
virtual BOOL	PrepareToImport ()
	Prepare to import EPS data using this filter. This sets up the filter to a sensible state for reading.
virtual void	CleanUpAfterImport (BOOL Successful)
	Cleans up the memory allocated by EPSFilter::PrepareToImport() - used when the import process ends, either normally or abnormally.
void	DecodeToken ()
	Decode the PostScript token that is contained in the 'TokenBuf' buffer. This is not used for strings, comments, or array brackets, but is used to detect tokens which are floating point numbers, integers, EPS keywords, or PostScript 'names' (e.g. font names). In other words, any token which cannot be identified solely by its first character.
virtual void	LookUpToken ()
	Determines if the current token is one of the standard Illustrator tokens. The 'Token' variable is set accordingly. If the token is not recognised, it is assumed to be a PostScript 'name'.
virtual BOOL	ProcessToken ()
	Examines the current token and performs whatever actions are necessary to process its meaning. Operands are simply pushed onto the EPS stack, and keywords are either acted upon, or ignored if they describe something that Camelot does not yet support (in the latter case, the operands of the keyword, if any, are simply discarded from the stack).
BOOL	GetToken ()
	Extract a token from the input stream. The Token variable holds the type of the token, and TokenBuf holds the characters that make up the token (be it a command, a string. a number, or whatever).
BOOL	GetLineToken ()
	Extract a token from the input stream in a line-based manner. The Token variable holds the type of the token, and TokenBuf holds the characters that make up the token (be it a command, a string. a number, or whatever).
BOOL	HandleToken ()
	'Handles' the current EPS token - if it's an EOL or EOF token, it updates the progress display, otherwise it just calls ProcessToken();
BOOL	ProcessEndOfPath (void)
	Processes the end-of-path directive.
BOOL	ProcessUnfilledPath (void)
	Processes the end-of-path directive of an unfilled or unstroked path.
BOOL	ProcessGroup ()
	Reads in all the elements of a group structure in the EPS file.
virtual BOOL	ProcessComment (BOOL BypassDocComponents=FALSE)
	Decodes an EPS comment - usually starting with "%%", e.g. %BeginProlog etc.
BOOL	ProcessRectangle (NodeRect *pRect, NodeRegularShape *pQuickShape)
	Having read in a rectangle path, this function builds a QuickShape rectangle as defined by the path.
BOOL	ProcessEllipse (NodeEllipse *pEllipse, NodeRegularShape *pQuickShape)
	Having read in a ellipse path, this function builds a QuickShape ellipse as defined by the path.
virtual BOOL	ProcessFilterComment ()
	Override this function to claim EPS comments for the filter to decode. This function is called after the usual comments are checked for such as %BeginProlog etc, but *before* the doc components are called. If you want to claim the current token (i.e. as held in TokenBuf), return TRUE.
void	HandleNoMemory ()
	Cleans up when the filter runs out of memory when importing a file. Any objects constructed so far are deleted, and the error message ID is set.
virtual BOOL	AddAttributes (NodeRenderableBounded *pNode, BOOL Stroked, BOOL Filled)
	Add attributes to an object being constructed. The attributes are optimised so that if they are the same as the document's default attributes, they are not applied.
virtual INT32	EPSHeaderIsOk (ADDR pFileHeader, UINT32 HeaderSize)
	Checks to see if the EPS comment headers specify that this is an Illustrator generated EPS file, as required.
BOOL	UseLayer (String_256 &LayerName, BOOL GuideLayer=FALSE)
	This is a wrapper around the new AddLayer method, which now returns a pointer to the newly created layer, which is where all the work is done. I've done this to preserve the original interface.
Layer *	AddLayer (String_256 &LayerName, BOOL GuideLayer)
	Given a layer name, construct a new layer, or find an existing layer with the same name, and cause new nodes to be added to the resulting layer.
BOOL	StartGroup ()
	Used when a group structure needs to be created - after this is called, all new nodes added with AddNewNode() will be added as children of this new group, until EndGroup is called.
BOOL	EndGroup (BOOL Masked=FALSE)
	Used when a group has finished being constructed and we want to return to normal node positioning. The group 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).
virtual BOOL	ValidateGroup (Node *Group)
	Validate a group. Can be overridden to, for example, ensure that groups have at least two children.
virtual BOOL	MaskedGroupEnding ()
	Function to call when a masked group ends. Gives a chance to restore graphic states and the like.
virtual void	ProcessTextMatrix (Matrix *pMatrix)
	Having read a text object position matrix from the file, we may (dependent on the filter type), need to process it in some way, ie add in the spread origin.
BOOL	AttachAllNodes ()
	Called at the end of an import - attaches any nodes to the tree that have not yet been attached. e.g. a new layer node, or a group node if layers are being ignored.
BOOL	InsertNewNode (Node *pNewNode)
	This function adds a node to the tree in an undoable way. It uses DoInsertNewNode() to do this. If it fails then 'pNewNode' and all its children are deleted. It adds the node as a child of the node pointed to by 'pNode'.
virtual BOOL	Import_gsave ()
	stores the current path and attributes to emulate a gsave in the imported EPS file. All things are copied. States can be nested.
virtual BOOL	Import_grestore ()
	restores path and attributes saved by the matching Import_gsave.
virtual BOOL	PrepareToExport (CCLexFile *, Spread *pSpread)
	Prepare to import EPS data using this filter. This sets up the filter to a sensible state for reading.
virtual void	CleanUpAfterExport ()
	Cleans up the memory allocated by EPSFilter::PrepareToImport() - used when the import process ends, either normally or abnormally.
virtual EPSExportDC *	CreateExportDC ()
	This allows the EPS filter to choose which sort of EPSExportDC to use. Most filters will use this default one, but some (Native Save/Load eps) will make use of a different ExportDC derived from EPSExportDC. This function simply returns the result of a 'new' and does no checking on the returned parameter. It is perfectly valid for this function to return NULL (meaning no ExportDC could be created) and the calling function should handle this appropriatly.
void	RemoveMessage (CCLexFile *pFile)
	Removes the Copyright message that appears in the middle of our native file format.
virtual BOOL	GetExportOptions ()
	Allows the user to be prompted to get information for export. Base class returns True so that nothing happens by default. Scope: Protected.
virtual BOOL	ProcessEPSComment ()
	Tries to process the contents of a comment. First it asks the filter and then it tries the document and all the doc components to see if it is one of thiers.
virtual BOOL	ProcessEPSTrailer ()
	Handles the end of the page (I think).
virtual BOOL	ProcessBoundingBox ()
	Tries to make use of the BoundingBox info in the EPS file.
void	ProcessEPSProlog ()
void	ProcessEPSSetup ()
void	GetEPSColour (DocColour *DestCol, PColourCMYK *pCMYK, TintType Tint, FIXEDPOINT TintVal, String_64 *ColName)
	Used when an EPS colour definition has just been read off the stack. Provides a centralised way of interpreting the usual colour definitions and getting a valid DocColour out of it. This copes with all sorts of things such as creating an indexed colour for named colours, and even handles creation of special colours for tinted named colours. Basically, it's a fire-and-forget function :-). If all else fails, it falls back to an immediate DocColour.
void	GetEPSColourRGB (DocColour *DestCol, INT32 red, INT32 green, INT32 blue, TintType Tint, FIXEDPOINT TintVal, String_64 *ColName)
	Identical to EPSFilter::GetEPSColour, except that it deals with RGB colours instead of CMYK ones.
void	MakeLayerNameUnique (String_256 &LayerName, Spread *pSpread)
	Given a layer name, ensure it is unique within the spread. If a clash occurs then the following layer names are tried until a unique one is found. (Assuming layer name is "Foreground" in this example).
BOOL	ProcessText ()
	Reads in all the elements of a Text structure in the EPS file.
BOOL	GetStoryMatrix (Matrix *pMatrix)
	Reads in all the elements of a Text Story Matrix.
BOOL	SetStrokeColourNone ()
	Updates the current attribute for StrokeColour with the value of COLOUR_NONE.
BOOL	SetFillColourNone ()
	Updates the current attribute for FillColour with the value of COLOUR_NONE.
BOOL	MakeNewTextLine (Node *pParent)
	Reads in all the elements of a Text structure in the EPS file.
Protected Attributes
FilePos	EPSStart
FilePos	EPSEnd
FilePos	PreviewStart
FilePos	PreviewEnd
UINT32	FilterNameID
UINT32	FilterInfoID
EPSCommentList	EPSComments
CCLexFile *	EPSFile
const TCHAR *	TokenBuf
INT32	LastProgressUpdate
EPSCommand	Token
union {
INT32   Long
FIXEDPOINT   FixedPoint
double   Double
TCHAR *   String
TCHAR *   Comment
}	TokenData
EPSStack	Stack
DocRect	SpreadRect
NodePath *	pPath
Layer *	pLayer
Page *	pPage
Node *	pNode
EPSFlagsDefn	EPSFlags
struct {
SelOperation *   pOp
ImportPosition *   Pos
Spread *   pSpread
}	ImportInfo
PathType	ThePathType
EPSRenderRegion *	ExportRegion
EPSExportDC *	ExportDCPtr
ColourListComponent *	pColours
DocCoord	ShapeBBox [4]
Node *	pFirstNodeInRange
Node *	pLastNodeInRange
BOOL	AdjustOrigin
BOOL	SupportsLayers
BOOL	UseLayers
INT32	GroupNesting
INT32	MaskedGroupNesting
BOOL	InvalidPathFound
Path *	pInkPath
EPSClipContext	ClipRegion
INT32	TextComment [3]
List	GraphicStateStack
EPSFilter::_FontFlags	FontFlags
FontClass	ClassOfFont
INT32	NewMouldThreshold
BOOL	EPS_Group
FilePos	EndOfEPS
Static Protected Attributes
static CommandMap	Commands []
static RangeList	ImportRange
Private Member Functions
	CC_DECLARE_DYNAMIC (EPSFilter)
Classes
struct	_FontFlags

---

Detailed Description

Encapsulates a basic Adobe Illustrator EPS import/export filter. This filter can be used as a base class, because most EPS formats are based (more or less) on AI format. Derived filters can override whichever parts they want to implement other flavours of EPS.

Author:

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

Date:

13/10/93

See also:

EPSFilter::Init; EPSFilter::DoImport; EPSFilter::DoExport; Filter; ArtWorksEPSFilter; Corel3Filter; Corel4Filter

Definition at line 455 of file epsfiltr.h.

---

Member Enumeration Documentation

enum EPSFilter::PathType

Enumerator: PATH_NORMAL  PATH_DISCARD  PATH_DISCARD_STICKY  PATH_RECT  PATH_ELLIPSE  PATH_MANGLED  Definition at line 494 of file epsfiltr.h. { PATH_NORMAL, PATH_DISCARD, PATH_DISCARD_STICKY, PATH_RECT, PATH_ELLIPSE, PATH_MANGLED } PathType;

---

Constructor & Destructor Documentation

EPSFilter::EPSFilter (   )

Constructor for an EPSFilter 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 942 of file epsfiltr.cpp. { ImportMsgID = _R(IDT_IMPORTMSG_AI); Flags.CanImport = TRUE; //WEBSTER-Martin-27/01/97 #ifdef WEBSTER Flags.CanExport = FALSE; #else Flags.CanExport = TRUE; #endif //WEBSTER FilterID = FILTERID_AIEPS; #ifndef DO_EXPORT Flags.CanExport = FALSE; #endif EPSFile = NULL; TokenBuf = NULL; pColours = NULL; ExportDCPtr = NULL; ExportRegion = NULL; ExportMsgID = _R(IDT_EXPORTMSG_AI); AdjustOrigin = TRUE; SupportsLayers = TRUE; // The offsets into the file for the Preview thing EPSStart = 0; EPSEnd = 0; PreviewStart = 0; PreviewEnd = 0; TextComment[0] = 0; TextComment[1] = 0; TextComment[2] = 1; // set the font extras block vars. These indicate to the // filter to do something special with the next set of font attributes FontFlags.Bold = FALSE; FontFlags.Italic = FALSE; // Set the font type to assume we are loading true type fonts unless // told otherwise. ClassOfFont = FC_TRUETYPE; // Define the mould threshold default value. NewMouldThreshold = MOULD_V1THRESHOLD; // We're not in a group at first. EPS_Group = FALSE; // Clear the length of the file to the end of the EPS code. EndOfEPS = 0; // Set up the comment list. These are the known DSC comments, and how to handle them. EPSComments.Add ( _T("%%BeginProlog"), _T("%%EndProlog"), TRUE, 0 ); EPSComments.Add ( _T("%%BeginSetup"), _T("%%EndSetup"), TRUE, 0 ); EPSComments.Add ( _T("%%BeginDocument"), _T("%%EndDocument"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginPageSetup"), _T("%%EndPageSetup"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginDefaults"), _T("%%EndDefaults"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginEmulation"), _T("%%EndEmulation"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginPreview"), _T("%%EndPreview"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginFeature"), _T("%%EndFeature"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginFile"), _T("%%EndFile"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginFont"), _T("%%EndFont"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginProcSet"), _T("%%EndProcSet"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginResource"), _T("%%EndResource"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginCustomColor"), _T("%%EndCustomColor"), FALSE, 0 ); EPSComments.Add ( _T("%%BeginProcessColor"), _T("%%EndProcessColor"), FALSE, 0 ); }

---

Member Function Documentation

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

Add attributes to an object being constructed. The attributes are optimised so that if they are the same as the document's default attributes, they are not applied. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/10/93 Parameters: pNode  - the bounded renderable node to add atributes to. [INPUTS] Stroked - TRUE if the object to add attributes to should be stroked, FALSE if not. Stroked - TRUE if the object to add attributes to should be filled, FALSE if not. Returns: TRUE if the attributes were added ok, FALSE if not. Errors: Fails (returns FALSE) if not enough memory to add attributes. Scope: Private Reimplemented in CorelEPSFilter. Definition at line 2695 of file epsfiltr.cpp. { DocColour OldCol; // If not stroked, temporarily set the ignore bit on the line colour attribute. if (!Stroked) { StrokeColourAttribute *pAttr = (StrokeColourAttribute *) CurrentAttrs[ATTR_STROKECOLOUR].pAttr; OldCol = pAttr->Colour; DocColour trans(COLOUR_TRANS); if (!SetLineColour(trans)) return FALSE; } // If not filled, then set the ignore bit on the fill attribute. if (!Filled) //pPath->InkPath.IsFilled) { CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = TRUE; } // Add attributes to the path, if they are different from the default... BOOL Result = AttributeManager::ApplyBasedOnDefaults(pNode, CurrentAttrs); // If not stroked, reinstall old line colour. if (!Stroked) // This can't fail. (tempting fate or wot!) SetLineColour(OldCol); // Enable the fill attribute again CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = FALSE; // Re-enable path-filling, in case it was disabled for this object SetPathFilled(TRUE); // Return success or failure return Result; }

Layer * EPSFilter::AddLayer (  String_256 &  LayerName, BOOL  GuideLayer )  [protected]

Given a layer name, construct a new layer, or find an existing layer with the same name, and cause new nodes to be added to the resulting layer. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> (based on Tim's code) Date: 17/4/00 (originally 16/08/94) Parameters: LayerName  - The name of the new layer. [INPUTS] GuideLayer - TRUE to create a guide layer, FALSE to create a standard layer. Returns: pLayer - A pointer to the newly creaded layer. Errors: An error is thrown if the layer is not created. See also: EPSFilter::AddNewNode Definition at line 2389 of file epsfiltr.cpp. { // Have we currently got a pending new layer to add to the tree? if (EPSFlags.AddToNewLayer) { // Yes - add the new layer to the tree. EPSFlags.AddToNewLayer = FALSE; pNode = ImportInfo.pSpread; if (!InsertNewNode((Node *) pLayer)) return FALSE; // Remember it ImportRange.AddRange(pLayer, pLayer); } else if (pFirstNodeInRange != NULL) { // We have just finished adding a range of nodes to an existing layer so let's // remember the nodes. ImportRange.AddRange(pFirstNodeInRange, pLastNodeInRange); pFirstNodeInRange = NULL; pLastNodeInRange = NULL; } // Find out if we need a new layer name, because there is already one with this name. String_256 NewLayerName = LayerName; MakeLayerNameUnique(NewLayerName, ImportInfo.pSpread); // Make a new layer using this name. if (GuideLayer) { #if !defined(EXCLUDE_FROM_RALPH) // WEBSTER - markn 15/1/97 // CreateGuideLayer() used to be part of OpGuideline class, now part of Layer class pLayer = Layer::CreateGuideLayer(); #else ERROR3("EPSFilter::UseLayer GuideLayer == TRUE - whoop whoop ! BAD !"); #endif } else pLayer = new Layer; ERRORIF(pLayer == NULL, _R(IDT_EPS_NOMEMORY), FALSE); pLayer->SetLayerID(NewLayerName); EPSFlags.AddToNewLayer = TRUE; // Make it the new destination node for all new nodes. pNode = (Node *) pLayer; // Pass the layer pointer out. return pLayer; }

BOOL EPSFilter::AddNewNode (  Node *  pNewNode  )  [virtual]

When a new node is created, this function puts it into the tree in the correct place. It may add it into a group, or a new layer which is currently being constructed, or onto an existing layer. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 16/08/94 Parameters: pNewNode  - the new node to add [INPUTS] Returns: TRUE if it worked, FALSE if not. Errors: Out of memory See also: EPSFilter::UseLayer Reimplemented in FreeHandEPSFilter. Definition at line 2088 of file epsfiltr.cpp. { if ((EPSFlags.AddToNewLayer) || (!UseLayers)) { // Simple case - just add to the new layer node pNewNode->AttachNode(pNode, LASTCHILD); if (pNewNode->IsBounded()) { // Update the bounds for this object NodeRenderableBounded *pBounded = (NodeRenderableBounded *) pNewNode; pBounded->InvalidateBoundingRect(); } } else { // Tricky case - we have to add the node to the existing layer in the // document in an undoable way. return InsertNewNode(pNewNode); } // All went ok. return TRUE; }

BOOL EPSFilter::AttachAllNodes (   )  [protected]

Called at the end of an import - attaches any nodes to the tree that have not yet been attached. e.g. a new layer node, or a group node if layers are being ignored. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 16/08/94 Returns: TRUE if it worked ok; FALSE if not. Errors: Out of memory See also: EPSFilter::AddNewNode Definition at line 2237 of file epsfiltr.cpp. { BOOL Success = TRUE; NodeGroup *pGroup=NULL; if (UseLayers) { // Check to see if there is an outstanding layer node to add... if (EPSFlags.AddToNewLayer) { // Yes - add it... // We're adding the layer to the spread now EPSFlags.AddToNewLayer = FALSE; Node *pLayer = pNode; pNode = ImportInfo.pSpread; // Do it. Success = AddNewNode(pLayer); // Remember it if (Success) ImportRange.AddRange(pLayer, pLayer); } else if (pFirstNodeInRange != NULL) { // We have just finished adding a range of nodes to an existing layer so let's // remember the nodes. ImportRange.AddRange(pFirstNodeInRange, pLastNodeInRange); pFirstNodeInRange = NULL; pLastNodeInRange = NULL; } } else { // No layers - always imported as a group, so add it into the tree. pGroup = (NodeGroup *) pNode; pNode = (Node *) pLayer; Success = InsertNewNode(pGroup); } if (!Success) return FALSE; // we need the bounding rect to do this (not the one with attributes) DocRect BoundsRect; if (UseLayers) BoundsRect = ImportRange.GetBoundingRect(); else BoundsRect = pGroup->GetBoundingRect(TRUE); // Translate objects to the drag and drop position if necessary... Coord Offset; if (GetDragAndDropTranslation(ImportInfo.Pos, BoundsRect, &Offset)) { Trans2DMatrix Xlate(Offset.x, Offset.y); if (UseLayers) { // Transform the range of nodes and then delete the range info. ImportRange.Transform(Xlate); // Transform the bounding rect too because we use it to invalidate the region. BoundsRect.Translate(Offset.x, Offset.y); } else { // Just transform the group node pGroup->Transform(Xlate); } } // Invalidate the region if (UseLayers) { // Importing with layers - invalidate the bounds of all the inserted nodes Success = ImportInfo.pOp->DoInvalidateRegion(ImportInfo.pSpread, BoundsRect); } else { // When importing as a group, we select the group node at the end, so we need to // invalidate the blob bounding rect to get the redraw correct. Success = ImportInfo.pOp->DoInvalidateNodeRegion(pGroup, TRUE, FALSE); } if (!Success) { // Need to add tidy up code here. return FALSE; } // Make sure the node insertion position is in the correct place TheDocument->ResetInsertionPosition(); return Success; }

EPSFilter::CC_DECLARE_DYNAMIC (  EPSFilter   )  [private]

void EPSFilter::CleanUpAfterExport (   )  [protected, virtual]

Cleans up the memory allocated by EPSFilter::PrepareToImport() - used when the import process ends, either normally or abnormally. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 24/02/94 See also: EPSFilter::PrepareToImport; EPSFilter::DoImport Scope: Private Definition at line 4839 of file epsfiltr.cpp. { #ifdef DO_EXPORT // Get rid of our dynamic objects if (ExportDCPtr!=NULL) delete ExportDCPtr; ExportDCPtr = NULL; if (ExportRegion!=NULL) delete ExportRegion; ExportRegion = NULL; // Inform all the document components that we have finished exporting DocComponent *pComponent = TheDocument->EnumerateDocComponents(NULL); while (pComponent != NULL) { // Inform this document component that we have finished exporting pComponent->EPSEndExport(this); // Look for next doc component pComponent = TheDocument->EnumerateDocComponents(pComponent); } #endif }

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

Cleans up the memory allocated by EPSFilter::PrepareToImport() - used when the import process ends, either normally or abnormally. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 24/02/94 Parameters: Successful,:  TRUE => the import succeeded [INPUTS] FALSE => something went wrong with the import, so abandon all changes made. See also: EPSFilter::PrepareToImport; EPSFilter::DoImport Scope: Private Reimplemented in AI5EPSFilter, PhotoShopEPSFilter, CamelotEPSFilter, FreeHandEPSFilter, and CamelotNativeEPSFilter. Definition at line 1264 of file epsfiltr.cpp. { DeleteCurrentAttrs(); // Get rid of file object EPSFile->DeinitLexer(); EPSFile = NULL; TokenBuf = NULL; // get rid of anything on the graphic state stack TRACEUSER( "Ben", _T("Entries on GraphicStateStack = %d\n"), GraphicStateStack.GetCount()); GraphicStateStack.DeleteAll(); // Throw away handle to colour list component. pColours = NULL; // Inform all the document components that we have finished importing TheDocument->EPSEndImport(this, Successful); DocComponent *pComponent = TheDocument->EnumerateDocComponents(NULL); while (pComponent != NULL) { // Inform this document component that we have finished importing pComponent->EPSEndImport(this, Successful); // Look for next doc component pComponent = TheDocument->EnumerateDocComponents(pComponent); } // If imported with layers, make sure the top layer becomes the active one. if (Successful) // && UseLayers) { LayerSGallery::MakeTopLayerActive(ImportInfo.pSpread); BROADCAST_TO_ALL(SpreadMsg(ImportInfo.pSpread,SpreadMsg::LAYERCHANGES)); } // Inform the user if we found any bad paths // BODGE: This is disabled while we are doing the clipart so the batch converter // can run unattended. if (0 && InvalidPathFound) InformWarning(_R(IDT_IMPORT_BAD_PATH_FOUND)); // Clean up import range items. ImportRange.DeleteAll(); TheDocument->PostImport(); }

BOOL EPSFilter::CorrectBinaryHeader (  CCLexFile *  pFile  )

Goes back to the binary header at the start of the file and fills in the correct values to all the fields. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 2/2/95 Parameters: pFile  - The file we are saving to [INPUTS] Returns: TRUE if it worked, FALSE if there was an error See also: EPSFilter::ExportBinaryHeader Definition at line 4571 of file epsfiltr.cpp. { #ifdef DO_EXPORT INT32 Length = 0; INT32 Zero = 0; // Seek back to the first thing that needs changing // The Start of PostScript pFile->seek(4); // Write out the start of postscript (4-7) if (pFile->write(&EPSStart, 4).fail()) return FALSE; // Write out the length of postscript (8-11) Length = EPSEnd - EPSStart; if (pFile->write(&Length, 4).fail()) return FALSE; // Write out the Start of metafile (12-15) if (pFile->write(&Zero, 4).fail()) return FALSE; // Write out the length of metafile (16-19) if (pFile->write(&Zero, 4).fail()) return FALSE; // Write out the start of TIFF if (pFile->write(&PreviewStart, 4).fail()) return FALSE; // Write out the legth of TIFF Length = PreviewEnd - PreviewStart; if (pFile->write(&Length, 4).fail()) return FALSE; #endif // All seemed to work return TRUE; }

EPSExportDC * EPSFilter::CreateExportDC (   )  [protected, virtual]

This allows the EPS filter to choose which sort of EPSExportDC to use. Most filters will use this default one, but some (Native Save/Load eps) will make use of a different ExportDC derived from EPSExportDC. This function simply returns the result of a 'new' and does no checking on the returned parameter. It is perfectly valid for this function to return NULL (meaning no ExportDC could be created) and the calling function should handle this appropriatly. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Returns: pointer to EPSExportDC or NULL Reimplemented in CamelotNativeEPSFilter. Definition at line 4710 of file epsfiltr.cpp. { #ifdef DO_EXPORT // Create and return a DC return new EPSExportDC(this); #else return NULL; #endif }

INT32 EPSFilter::DecodeHexString (  ADDR  pData, INT32  Length, INT32  nStart = 0 )

Treat the current token as a hex string, and decode it into binary data and place it in the buffer provided by the caller. No more than Length bytes should be placed in the buffer. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 23/08/94 Parameters: Length  - the maximum number of bytes to read from the hex string. [INPUTS] nStart - where in TokenBuf (the member that contains the semantic value of the token) to start the decoding pData  - the buffer to place the binary data into. [OUTPUTS] Returns: The number of bytes read from the current token. If an error occurs (i.e. invalid hex data) then -1 is returned. See also: EPSFilter::ImportBinary Definition at line 5242 of file epsfiltr.cpp. { INT32 TokenLen = camStrlen(TokenBuf + nStart); INT32 Ofs = 0; // Assume hex strings are even-numbered in length for the moment ENSURE((TokenLen & 1) == 0, "Bad hex string length in DecodeHexString"); // Work out how much of the string we should decode INT32 MaxOfs = Length * 2; // Decode the string two characters at a time for (INT32 i = nStart; (i < TokenLen) && (i < MaxOfs); i += 2) { TCHAR Ch = camToupper(TokenBuf[i]); BYTE Byte; // Decode first digit. if ((Ch >= '0') && (Ch <= '9')) { Byte = (BYTE) (Ch - '0'); } else if ((Ch >= 'A') && (Ch <= 'F')) { Byte = (BYTE) (Ch - 'A') + 10; } else { // Error in hex data return -1; } Ch = camToupper(TokenBuf[i+1]); Byte <<= 4; // Decode swcond digit. if ((Ch >= '0') && (Ch <= '9')) { Byte |= (BYTE) (Ch - '0'); } else if ((Ch >= 'A') && (Ch <= 'F')) { Byte |= (BYTE) (Ch - 'A') + 10; } else { // Error in hex data return -1; } pData[Ofs++] = Byte; } // How much data did we read? return Ofs; }

void EPSFilter::DecodeToken (   )  [protected]

Decode the PostScript token that is contained in the 'TokenBuf' buffer. This is not used for strings, comments, or array brackets, but is used to detect tokens which are floating point numbers, integers, EPS keywords, or PostScript 'names' (e.g. font names). In other words, any token which cannot be identified solely by its first character. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 28/10/93 See also: EPSFilter::GetToken Scope: Private Definition at line 1781 of file epsfiltr.cpp. { // // Determine what we just read into TokenBuf. // ENSURE(camStrcmp(TokenBuf,_T("}bd")) != 0, "Found a }bd token!"); // Not interested in comments, unless it's actually a strange token if (Token == EPSC_Comment) { LookUpToken();