CamelotNativeEPSFilter Class Reference

This filter will be almost the same as Camelot EPS, only it will hold a little more information and store data slightly more efficiently. Mainly, it will save out bitmaps as binary. It won't really be valid EPS as it will not always be ascii. The Native file format is being done this way as it will take little or no effort to do this. More...

#include <nativeps.h>

Inheritance diagram for CamelotNativeEPSFilter:

List of all members.

Public Member Functions
	CamelotNativeEPSFilter ()
	Constructor for the Native save/load filter.
	~CamelotNativeEPSFilter ()
	Tidies up when the filter is destroyed. Mostly takes care of the bitmap pool references that may have been built during the import.
BOOL	Init ()
	Initalises the Filter ready for use. Will fail if it can not get enough memory to work with.
BOOL	PrepareToExport (CCLexFile *pFile, Spread *pSpread)
	Gets things ready for the export. Creates the render region to do all the exporting with.
virtual EPSExportDC *	CreateExportDC ()
	Creates a new export DC (NativeExportDC) ready to export the Native file to.
virtual BOOL	ExportBitmap (KernelBitmap &)
	Export a bitmap to a Camelot EPS file. This does one of 2 things. If we are in the middle of exporting the bitmap pool it will save out all the bitmap data, just as CamelotEPS does. If we are not in the bitmap pool it will simply save out a reference to the bitmap in the pool.
BOOL	PrepareToImport ()
	See base class.
virtual INT32	ImportBinary (ADDR pData, INT32 Length)
	Reads the binary data out of the file and puts it into the buffer supplied. It also makes checks to see if the appropriate chars are found surounding the Binary stream.
virtual BOOL	ProcessFilterComment ()
	This deals with the page info held in comments in the EPS stream.
virtual void	CleanUpAfterImport (BOOL Successful)
	Happens at the end of the import to allow the filters to clean up after themselves.
BitmapFilterSupport	GetBitmapSupportLevel ()
	Determine how well this filter supports bitmaps when exporting.
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.
double	SmartGetBuildNumber ()
	Determines a monotomic build version number based on BuildVersionNumber which unfortunately jumps to v1.00/a/b/c/d but these are mapped back to real build numbers. v1.00/a/b/c/d all have BuildVersionNumbers of 1.00 and are all descended from an isolated liniage based on 0.586 so all map to this number Note: Only guaranteed for build versions greater than 0.586!
double	GetBuildNumber ()
Static Public Member Functions
static BOOL	SetNativeCompression (BOOL NewState)
	Set the prefernece as to whether we are to compress the native files or not.
static BOOL	GetNativeCompression ()
	Set the prefernece as to whether we are to compress the native files or not.
Public Attributes
BOOL	IsSavingBitmapPool
Static Public Attributes
static BOOL	CompressNative = TRUE
	Flag for whether we compress the native files saved from Xara Studio. True means do compress the files.
Protected Member Functions
virtual void	LookUpToken ()
	Look up one of the tokens used by the Camelot Native EPS file format.
virtual BOOL	ProcessToken ()
	Deals with the current token. This function deals with tokens that are specific to the Camelot Native EPS format, or different from Camelot EPS.
INT32	EPSHeaderIsOk (ADDR pFileHeader, UINT32 HeaderSize)
	Checks to see if the EPS comment headers specify that this is an Camelot Native file, as required.
virtual BOOL	GetExportOptions ()
	Allows the user to be prompted to get information for export. This overriden version returns True so that nothing happens. Scope: Protected.
virtual BOOL	ReadBitmap ()
	Reads in a bitmap. If it is a Type 0 bitmap (ie one with all its data) it will ask the base class to import it. If it is a Type 1 bitmap it will look up the reference in the bitmap pool and use that.
virtual BOOL	SetFileCompressionState (BOOL NewState)
	Set a new file compression status into action.
virtual BOOL	GetFileCompressionState ()
	Get the current file compression state. True if compressing.
Protected Attributes
INT32	BitmapCount
INT32	PendingBitmapNum
KernelBitmapRef *	BitmapPoolRefs
BOOL	OldImportWithLayers
BOOL	OldOpenWithLayers
INT32	CompressionType
BOOL	CompressionOn
double	FileVersionNumber
double	BuildVersionNumber
INT32	OldMinLineWidth
Static Protected Attributes
static CommandMap	NativeCommands []
Private Member Functions
	CC_DECLARE_DYNAMIC (CamelotNativeEPSFilter)

---

Detailed Description

This filter will be almost the same as Camelot EPS, only it will hold a little more information and store data slightly more efficiently. Mainly, it will save out bitmaps as binary. It won't really be valid EPS as it will not always be ascii. The Native file format is being done this way as it will take little or no effort to do this.

Author:

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

Date:

15/12/94

Definition at line 132 of file nativeps.h.

---

Constructor & Destructor Documentation

CamelotNativeEPSFilter::CamelotNativeEPSFilter (   )

Constructor for the Native save/load filter. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 15/12/94 Definition at line 208 of file nativeps.cpp. { // Set up filter descriptions. FilterNameID = _R(IDS_NATIVE_EPS_FILTERNAME); FilterInfoID = _R(IDS_NATIVE_EPS_FILTERINFO); ImportMsgID = _R(IDS_IMPORTMSG_NATIVE_EPS); ExportMsgID = _R(IDS_EXPORTMSG_NATIVE_EPS); FilterID = FILTERID_NATIVE_EPS; #ifndef STANDALONE Flags.CanImport = TRUE; //WEBSTER-Martin-27/01/97 #ifdef WEBSTER Flags.CanExport = FALSE; #else Flags.CanExport = FALSE; #endif //WEBSTER #else Flags.CanImport = TRUE; 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; // Prepare the bitmap pool data IsSavingBitmapPool = FALSE; BitmapCount = 0; BitmapPoolRefs = NULL; PendingBitmapNum = 0; // A flag to store the Value of the ImportWithLayers flag in OldImportWithLayers = TRUE; OldOpenWithLayers = TRUE; // Items to handle the file compression CompressionType = 0; // type of compression in use (0 at present) CompressionOn = FALSE; // on/off flag FileVersionNumber = 0.0; BuildVersionNumber = 0.0; }

CamelotNativeEPSFilter::~CamelotNativeEPSFilter (   )

Tidies up when the filter is destroyed. Mostly takes care of the bitmap pool references that may have been built during the import. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/95 Definition at line 267 of file nativeps.cpp. { // Get rid of the bitmap references if we have any if (BitmapPoolRefs != NULL) delete [] BitmapPoolRefs; }

---

Member Function Documentation

void CamelotNativeEPSFilter::BitmapPoolAttach (  KernelBitmap *  pBitmap  )  [virtual]

Makes a reference to the bitmap so that it can be used throughout the eps file with repeating the data. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/95 Parameters: pBitmap  - The bitmap to attach [INPUTS] Reimplemented from CamelotEPSFilter. Definition at line 1134 of file nativeps.cpp. { // Make sure we have some refs and its in range if ((BitmapPoolRefs!=NULL) && (PendingBitmapNum < BitmapCount)) { // yep, so attach the bitmap to the reference BitmapPoolRefs[PendingBitmapNum].Attach(pBitmap, GetDocument()); if (BitmapPoolRefs[PendingBitmapNum].GetBitmap() != pBitmap) { // It didn't use the bitmap we gave it, so we can delete it delete pBitmap; } } }

CamelotNativeEPSFilter::CC_DECLARE_DYNAMIC (  CamelotNativeEPSFilter   )  [private]

void CamelotNativeEPSFilter::CleanUpAfterImport (  BOOL  Successful  )  [virtual]

Happens at the end of the import to allow the filters to clean up after themselves. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/95 Parameters: Successful  - TRUE if the import went OK, FALSE if it failed [INPUTS] Reimplemented from CamelotEPSFilter. Definition at line 1091 of file nativeps.cpp. { // Call the base class CamelotEPSFilter::CleanUpAfterImport(Successful); // restore the old min line width MinLineWidth = OldMinLineWidth; // Get rid of the bitmap references if we have any // This will cause all bitmaps that were loaded, but are not used to be thrown away if (BitmapPoolRefs != NULL) delete [] BitmapPoolRefs; // Ready for the next one BitmapPoolRefs = NULL; // Put the Import with layers flag back as it was ImportWithLayers = OldImportWithLayers; OpenWithLayers = OldOpenWithLayers; // Flag this as an old format document if (TheDocument && Successful) { // But only flag it if we are opening the document rather than importing into an exisiting one if (!TheDocument->IsImporting()) TheDocument->SetLoadedAsVersion1File(TRUE); } }

EPSExportDC * CamelotNativeEPSFilter::CreateExportDC (   )  [virtual]

Creates a new export DC (NativeExportDC) ready to export the Native file to. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Returns: Pointer to a new ExportDC. Reimplemented from EPSFilter. Definition at line 1474 of file nativeps.cpp. { #if !defined(EXCLUDE_FROM_RALPH) return new NativeExportDC(this); #else return NULL; #endif }

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

Checks to see if the EPS comment headers specify that this is an Camelot Native file, as required. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/94 Returns: 0 - 10. 0 means not interested in this file, 10 means I know all about this file. Reimplemented from CamelotEPSFilter. Definition at line 963 of file nativeps.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++; // if the file is native camelot, return indicating strong 'interest'! if (strncmp(Buffer, "%%Creator: Xara Studio (Native)", 31) == 0) 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. Since this is not really an eps filter it // will claim to know nothing about it. Camelot EPS will have a go at this file // but we can not really try. return 0; }

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

Export a bitmap to a Camelot EPS file. This does one of 2 things. If we are in the middle of exporting the bitmap pool it will save out all the bitmap data, just as CamelotEPS does. If we are not in the bitmap pool it will simply save out a reference to the bitmap in the pool. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/95 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 CamelotEPSFilter. Definition at line 1577 of file nativeps.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // If this is the bitmap pool, then save out some data if (IsSavingBitmapPool) { TRACEUSER( "Rik", _T("In the bitmap pool, so saving out real data\n")); return CamelotEPSFilter::ExportBitmap(TheBitmap); } // If we get here then we must be saving out a reference to a bitmap saved earlier in the pool TRACEUSER( "Rik", _T("Trying to save a reference to a bitmap\n")); // Try and find the bitmap in the bitmap pool // Get the document that we are saving Document* pDoc = GetDocument(); if (pDoc==NULL) return FALSE; // Find the doccomponent with the list of bitmaps in it DocComponent* DocBitmapList = pDoc->GetDocComponent(CC_RUNTIME_CLASS(BitmapListComponent)); if (DocBitmapList==NULL) return FALSE; ExportedBitmaps* pBitmapExportPool = ((BitmapListComponent*)DocBitmapList)->GetBitmapExportPool(); ERROR3IF(pBitmapExportPool == NULL, "No BitmapExportPool in CamelotNativeEPSFilter::ExportBitmap"); if (pBitmapExportPool==NULL) return FALSE; INT32 BitmapPoolNum = -1; // Get ready to look for our bitmap class ExportBitmap* pExportBitmap = pBitmapExportPool->GetBitmap(&TheBitmap); // The 'class' statement is because this filter has a function called 'ExportBitmap' ERROR3IF(pExportBitmap == NULL, "Couldn't find the bitmap in the pool in CamelotNativeEPSFilter::ExportBitmap"); if (pExportBitmap) { BitmapPoolNum = pExportBitmap->RecordNumber; } // Did we find it if (BitmapPoolNum >= 0) { // Export the number of the bitmap ExportDCPtr->OutputValue((UINT32) BitmapPoolNum); // Bitmap type is always 1 to represent a reference (0 is an actual bitmap) ExportDCPtr->OutputToken(_T("1")); // Write out the bitmap start token ExportDCPtr->OutputToken(_T("csbm")); ExportDCPtr->OutputNewLine(); // Write out the bitmap end token ExportDCPtr->OutputToken(_T("cebm")); ExportDCPtr->OutputNewLine(); // All ok return TRUE; } #endif // Did not find the bitmap return FALSE; }

BitmapFilterSupport CamelotNativeEPSFilter::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: IndirectedBitmapSupport - This filter supports bitmap indirection; i.e. a bitmap pool of some type is saved and then this can be referenced in the file. Reimplemented from ArtWorksEPSFilter. Definition at line 1658 of file nativeps.cpp. { return IndirectedBitmapSupport; }

double CamelotNativeEPSFilter::GetBuildNumber (   )  [inline]

Definition at line 160 of file nativeps.h. { return BuildVersionNumber; }

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

Allows the user to be prompted to get information for export. This overriden version returns True so that nothing happens. 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 CamelotEPSFilter. Definition at line 1498 of file nativeps.cpp. { // Overide the CamelotEPS form so that we do nothing again i.e. just return TRUE return TRUE; }

BOOL CamelotNativeEPSFilter::GetFileCompressionState (   )  [protected, virtual]

Get the current file compression state. True if compressing. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 19/5/95 Returns: The current state of the file compression. Definition at line 379 of file nativeps.cpp. { return CompressionOn; }

BOOL CamelotNativeEPSFilter::GetNativeCompression (   )  [static]

Set the prefernece as to whether we are to compress the native files or not. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 27/5/95 Parameters: New  state for native file compression, TRUE if want on, FALSE if want off. [INPUTS] Returns: The old state of the compression. Definition at line 342 of file nativeps.cpp. { return CompressNative; }

INT32 CamelotNativeEPSFilter::ImportBinary (  ADDR  pData, INT32  Length )  [virtual]

Reads the binary data out of the file and puts it into the buffer supplied. It also makes checks to see if the appropriate chars are found surounding the Binary stream. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: Length  - the number of bytes to read, in terms of binary data imported, as [INPUTS] opposed to how many bytes the file format takes to represent this binary data. pData  - the buffer to put the data into. [OUTPUTS] Returns: TRUE if it imported the specified number of bytes correctly; FALSE if not. Errors: File input errors; EOF See also: Filter::ImportBinary Reimplemented from EPSFilter. Definition at line 1240 of file nativeps.cpp. { // read chars until we get a > INT32 CountDown = 50; TCHAR Ch; do { // Read a TCHAR if (EPSFile->read(&Ch, 1).fail()) { HandleEPSError(); return FALSE; } // Count it CountDown--; } while ((CountDown>0) && (Ch!='>')); // See if we found it if (CountDown==0) { HandleEPSError(); return FALSE; } // Read binary section if (EPSFile->read(pData, Length).fail()) { HandleEPSError(); return FALSE; } // Read TCHAR and check that it is a < if (EPSFile->read(&Ch, 1).fail()) { HandleEPSError(); return FALSE; } if (Ch!='<') { HandleEPSError(); return FALSE; } // Find out how much of the file we have read INT32 CharsRead = EPSFile->GetCharsRead(); if (CharsRead > (LastProgressUpdate + 2048)) { if (!ContinueSlowJob(CharsRead)) { // Abort operation - make sure nodes are deleted and not added to the tree. ERROR(_R(IDT_IMPORT_USERABORT), FALSE); } else { LastProgressUpdate = CharsRead; } } // Re-sync the tokeniser EPSFile->GetLine(); EPSFile->GetCh(); // Must have worked return TRUE; }

BOOL CamelotNativeEPSFilter::Init (  void   )  [virtual]

Initalises the Filter ready for use. Will fail if it can not get enough memory to work with. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 15/12/94 Returns: TRUE if it worked, FALSE if it failed Reimplemented from CamelotEPSFilter. Definition at line 289 of file nativeps.cpp. { // Get the OILFilter object pOILFilter = new NativeEPSOILFilter(this); if (pOILFilter == NULL) return FALSE; // Load the description strings FilterName.Load(FilterNameID); FilterInfo.Load(FilterInfoID); // Preference to turn native file compression on or off if (Camelot.DeclareSection(_T("Filters"), 10)) { Camelot.DeclarePref( NULL, _T("CompressNative"), &CompressNative, 0, 1 ); } // All ok return TRUE; }

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

Look up one of the tokens used by the Camelot Native EPS file format. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/95 Reimplemented from CamelotEPSFilter. Definition at line 395 of file nativeps.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 (NativeCommands[i].Cmd != EPSC_Invalid) { if (camStrcmp(TokenBuf, NativeCommands[i].CmdStr) == 0) { // Found the token - set the token variable and return success Token = NativeCommands[i].Cmd; return; } // Try next command i++; } // Did not find this token - pass on to base class. CamelotEPSFilter::LookUpToken(); }

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

Gets things ready for the export. Creates the render region to do all the exporting with. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 15/12/94 Parameters: pFile  - the path name [INPUTS] pSpread - The spread to save Returns: TRUE if it worked, FALSE if it failed Reimplemented from CamelotEPSFilter. Definition at line 1519 of file nativeps.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Use base class to do most of it if (!CamelotEPSFilter::PrepareToExport(pFile, pSpread)) return FALSE; // Try and create a render region if we are really a // Native filter and not something derived from it if (IS_A(this, CamelotNativeEPSFilter)) { // 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); // Create the render region ExportRegion = new NativeRenderRegion(NullClipRect, Identity, Scale); if (ExportRegion == NULL) return FALSE; // use the first docview DocView * pDocView = TheDocument->GetFirstDocView(); // fallback - help no docviews if ((!pDocView) || (!pDocView->IsKindOf(CC_RUNTIME_CLASS(DocView)))) pDocView = DocView::GetSelected(); // help! use selected docview // Attach to the right device. ExportRegion->AttachDevice(pDocView, ExportDCPtr->GetDC(), pSpread); } #endif // Thats it return TRUE; }

BOOL CamelotNativeEPSFilter::PrepareToImport (   )  [virtual]

See base class. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/94 Returns: TRUE if filter initialised ok; FALSE if not. Errors: See base class. See also: EPSFilter::PrepareToImport; Reimplemented from CamelotEPSFilter. Definition at line 1014 of file nativeps.cpp. { // Note the old state so we can put it back at the end OldImportWithLayers = Filter::ImportWithLayers; OldOpenWithLayers = Filter::OpenWithLayers; // Neville 7/8/97 - Layers are bad in Webster as they conflict with frames #ifndef WEBSTER // We always wanted to import with layers in the native filter // Nowadays, its a bit more complicated // If we are during template loading then always load the layers if (TheDocument->IsTemplateLoading()) { ImportWithLayers = TRUE; OpenWithLayers = TRUE; } else { // Otherwise if we are in:- // - a framed document then remove all layers from importing // - a layered document then import with layers if (TheDocument->IsImporting()) { ERROR2IF(ImportInfo.pSpread == NULL,FALSE,"CamelotNativeEPSFilter::PrepareToImport No spread"); Layer * pFrame = ImportInfo.pSpread->FindFirstFrameLayer(); if (pFrame == NULL) ImportWithLayers = TRUE; // Layered = allow layers else ImportWithLayers = FALSE; // Framed = disallow layers } else ImportWithLayers = TRUE; OpenWithLayers = TRUE; // Always open with layers } #else // If we are during template loading then always load the layers if (TheDocument->IsTemplateLoading()) { ImportWithLayers = TRUE; OpenWithLayers = TRUE; } else // Otherwise remove all layers from importing { ImportWithLayers = FALSE; OpenWithLayers = FALSE; } #endif // WEBSTER */ // reset version numbers so files without this info have numbers 0.0 FileVersionNumber = 0.0; BuildVersionNumber = 0.0; // Initialise base class first. if (!CamelotEPSFilter::PrepareToImport()) return FALSE; // set min line width to zero and store old value OldMinLineWidth = MinLineWidth; MinLineWidth = 0; return TRUE; }

BOOL CamelotNativeEPSFilter::ProcessFilterComment (   )  [virtual]

This deals with the page info held in comments in the EPS stream. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/12/94 Returns: TRUE if it finds something it likes, FALSE if not Reimplemented from EPSFilter. Definition at line 1319 of file nativeps.cpp. { // read the build version number of the app which saved this file if (camStrncmp(TokenBuf, _T("%%Creator: Xara Studio (Native)"), 31) == 0) { return TRUE; } // Go and have a look at the token buffer and see if it is our special // file version comment. If so, then extract the version number from it. if (camStrncmp(TokenBuf, _T("%%File version:"), 15)==0) { TCHAR* pVersion = &(((TCHAR*)TokenBuf)[15]); double Version=0.0; camSscanf(pVersion, _T("%lf"), &Version); TRACEUSER( "Neville", _T("Native file version = %f\n"), Version); FileVersionNumber = Version; // Must stop later file versions loading back into this version. if (Version > ReadNativeVersion) { InformWarning(_R(IDW_FILEISWRONGVERSION)); // flag the error state EPSFlags.EPSErrorEncountered = TRUE; // set the user has cancelled the error message so that this one is not reported Error::SetError(_R(IDN_USER_CANCELLED), 0); // We recokonised the token but it is invalid return TRUE; } } // Go and have a look at the token buffer and see if it is our special // compression comment if (camStrncmp(TokenBuf, _T("%%Compression:"), 14)==0) { //#ifdef STANDALONE // // First release of the file viewer will not have the native file compression // // loading code in. Therefore, we must abort if the compression tokens are // // encountered. // //if (FileVersionNumber < 0.500) // InformWarning(_R(IDW_FILEISCOMPRESSED)); // // flag the error state // EPSFlags.EPSErrorEncountered = TRUE; // // set the user has cancelled the error message so that this one is not reported // Error::SetError(_R(IDN_USER_CANCELLED), 0); // // // We recokonised the token but it is invalid // return TRUE; //#endif TCHAR* pType = &(((TCHAR*)TokenBuf)[14]); camSscanf(pType, _T("%d"), &CompressionType); TRACEUSER( "Neville", _T("CamelotNativeEPSFilter::ProcessFilterComment compression type %d\n"), CompressionType); // We have found our compression token so turn compression on BOOL ok = EPSFile->SetCompression(TRUE); if (!ok) { // We had a problem starting up the decompressor // flag the error state EPSFlags.EPSErrorEncountered = TRUE; // set up a useful error message, this one seems to say that we ran out of memory // and this is the most likely reason why Error::SetError(_R(IDT_EPS_NOMEMORY), 0); // We recokonised the token but it is invalid return TRUE; } return TRUE; } if (camStrncmp(TokenBuf, _T("%%Compression info:"), 19)==0) { TCHAR* pVersion = &(((TCHAR*)TokenBuf)[19]); double CompVersion=0.0; camSscanf(pVersion, _T("%lf"), &CompVersion); TRACEUSER( "Neville", _T("Compression version = %f\n"), CompVersion); double StreamVersion = GZipFile::GetStreamVersionNo(); // If the version stored in the file is later than the one in the stream class // then we cannot cope with this data, so error. if (CompVersion > StreamVersion) { InformWarning(_R(IDW_FILEISCOMPRESSED)); // flag the error state EPSFlags.EPSErrorEncountered = TRUE; // set the user has cancelled the error message so that this one is not reported Error::SetError(_R(IDN_USER_CANCELLED), 0); // We recokonised the token but it is invalid return TRUE; } return TRUE; } if (camStrncmp(TokenBuf, _T("%%EndCompression:"), 17)==0) { // We have found our compression token so turn compression on BOOL ok = EPSFile->SetCompression(FALSE); if (!ok) { // We had a problem stoping up the decompressor // flag the error state EPSFlags.EPSErrorEncountered = TRUE; // We will assume that an error has been set up. At present, the only one // most likely is a CRC error. // We recokonised the token but it is invalid return TRUE; } return TRUE; } if (camStrncmp(TokenBuf, _T("%%EndCompressionInfo:"), 21)==0) { return TRUE; } // Go and have a look at the token buffer and see if it looks like bitmap count if (camStrncmp(TokenBuf, _T("%%BitmapPoolCount"), 17)==0) { TCHAR* pCount = &(((TCHAR*)TokenBuf)[17]); camSscanf(pCount, _T("%d"), &BitmapCount); TRACEUSER( "Rik", _T("%d\n"), BitmapCount); // There are no bitmaps in this file if (BitmapCount==0) return TRUE; // Make sure that we have not already found one of these if (BitmapPoolRefs!=NULL) ERROR3("Bitmap Pool already in use!"); // Allocate a few references to bitmaps BitmapPoolRefs = new KernelBitmapRef[BitmapCount]; return TRUE; } // Check for any text comments if (camStrncmp(TokenBuf, _T("%%XSScript"), 10)==0) { TextComment[0]=2; return TRUE; } return FALSE; }

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

Deals with the current token. This function deals with tokens that are specific to the Camelot Native EPS format, or different from Camelot EPS. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/95 Returns: TRUE if it was able to process the token, FALSE if not. Reimplemented from CamelotEPSFilter. Definition at line 434 of file nativeps.cpp. { ArrowRec Arrow; double ArrowWidth; double ArrowHeight; INT32 ArrowID; DashRec Dash; INT32 DashID; DashPatternAttribute* pDash; // Decode the command, and execute it... switch (Token) { // Bitmap Pool Token case EPSC_cbmp: { INT32 PoolType; // Find out what type of bitmap pool thing this is (currently 0 is only valid option) if ((!Stack.Pop(&PoolType)) || (PoolType!=0)) goto EPSError; // get the bitmap number if (!Stack.Pop(&PendingBitmapNum)) goto EPSError; // Next thing will be a pool item TRACEUSER( "Rik", _T("Got a Bitmap pool item....\n")); m_PendingBitmap = PENDING_BITMAP_POOLITEM; break; } // Stroke transparency case EPSC_cst: INT32 TranspType, Transp; // Get transparency type... if (!Stack.Pop(&TranspType)) goto EPSError; // Get line transparency value if (!Stack.Pop(&Transp)) goto EPSError; TRACEUSER( "Will", _T("Importing Line transp, Val=%d, Type=%d\n"),Transp, TranspType); if (!SetLineTransp((UINT32)TranspType, (UINT32)Transp)) goto NoMemory; break; // Start Arrow head case EPSC_csah: if (!Stack.Pop(&ArrowHeight)) goto EPSError; if (!Stack.Pop(&ArrowWidth)) goto EPSError; if (!Stack.Pop(&ArrowID)) goto EPSError; TRACEUSER( "Will", _T("Importing StartArrow, ID=%d\n"),ArrowID); if (!Arrow.CreateStockArrow((StockArrow)ArrowID)) goto NoMemory; Arrow.SetArrowSize(FIXED16(ArrowWidth), FIXED16(ArrowHeight)); if (!SetStartArrow(Arrow)) goto NoMemory; break; // End Arrow head case EPSC_ceah: if (!Stack.Pop(&ArrowHeight)) goto EPSError; if (!Stack.Pop(&ArrowWidth)) goto EPSError; if (!Stack.Pop(&ArrowID)) goto EPSError; TRACEUSER( "Will", _T("Importing EndArrow, ID=%d\n"),ArrowID); if (!Arrow.CreateStockArrow((StockArrow)ArrowID)) goto NoMemory; Arrow.SetArrowSize(FIXED16(ArrowWidth), FIXED16(ArrowHeight)); if (!SetEndArrow(Arrow)) goto NoMemory; break; // Dash Patterns case EPSC_cdp: if (!Stack.Pop(&DashID)) goto EPSError; TRACEUSER( "Will", _T("Importing Dash Pattern, ID=%d\n"),DashID); pDash = new DashPatternAttribute; if (pDash == NULL) goto NoMemory; if (!pDash->SetStockDashPattern((StockDash)DashID)) goto NoMemory; Dash = pDash->DashPattern; delete pDash; if (!SetDashPattern(Dash)) goto NoMemory; break; // Transparency fills. case EPSC_cxt: { DocCoord StartPoint, EndPoint, EndPoint2; INT32 StartTransp, EndTransp, TranspType; INT32 FillType; INT32 Tileable; // Used for fractal fills INT32 Seed; double Graininess, Gravity, Squash; UINT32 DPI; // Get fill type if (!Stack.Pop(&FillType)) goto EPSError; TRACEUSER( "Will", _T("Importing Transp Fill, Type=%d\n"),FillType); // Read in transparency type and levels... if (FillType != TRANSPFILL_NONE) { // Get transparency type... if (!Stack.Pop(&TranspType)) goto EPSError; if ((FillType != TRANSPFILL_TEXTURE) && (FillType != TRANSPFILL_FRACTAL)) { // Get second transparency level if there is one. switch (FillType) { case TRANSPFILL_LINEAR: case TRANSPFILL_ELLIPTICAL: case TRANSPFILL_CIRCULAR: case TRANSPFILL_CONICAL: case TRANSPFILL_NEWLINEAR: case TRANSPFILL_NEWTEXTURE: case TRANSPFILL_NEWFRACTAL: if (!Stack.Pop(&EndTransp)) goto EPSError; break; default: // This is a valid situation - no second transparency level. break; } // Get first transparency level if (!Stack.Pop(&StartTransp)) goto EPSError; } } if (FillType == TRANSPFILL_FRACTAL || FillType == TRANSPFILL_NEWFRACTAL) { // If it's a fractal fill type, discard the 'sub-type' parameter (should // always be zero or one currently!) INT32 SubType; if (!Stack.Pop(&SubType)) goto EPSError; // Default to no tiling Tileable = FALSE; // Work out the sub-type, either it has no tileable flag, or it does, // or it's a type that is not supported. if (SubType != 0) { if (SubType == 1) { // Get the tileable flag if (!Stack.Pop(&Tileable)) goto EPSError; } else { ERROR2RAW("Bad fractal fill sub-type"); goto EPSError; } } // Now get the fractal parameters: if (!Stack.Pop(&DPI) || !Stack.Pop(&Squash) || !Stack.Pop(&Gravity) || !Stack.Pop(&Graininess) || !Stack.Pop(&Seed)) { // Error in fractal parameteres goto EPSError; } } // For elliptical & texture/fractal fills, get the second end-point of the fill if ((FillType == TRANSPFILL_ELLIPTICAL) || (FillType == TRANSPFILL_TEXTURE) || (FillType == TRANSPFILL_FRACTAL) || (FillType == TRANSPFILL_NEWTEXTURE) || (FillType == TRANSPFILL_NEWFRACTAL) || (FillType == TRANSPFILL_NEWLINEAR)) { if (!Stack.PopCoordPair(&EndPoint2)) goto EPSError; } // Get start and end positions for variable transparency fills if ((FillType == TRANSPFILL_ELLIPTICAL) || (FillType == TRANSPFILL_CIRCULAR) || (FillType == TRANSPFILL_LINEAR) || (FillType == TRANSPFILL_CONICAL) || (FillType == TRANSPFILL_TEXTURE) || (FillType == TRANSPFILL_FRACTAL) || (FillType == TRANSPFILL_NEWLINEAR) || (FillType == TRANSPFILL_NEWFRACTAL) || (FillType == TRANSPFILL_NEWTEXTURE)) { if (!Stack.PopCoordPair(&EndPoint) || !Stack.PopCoordPair(&StartPoint)) goto EPSError; } switch (FillType) { // Decode Camelot EPS transparency fill codes case TRANSPFILL_NONE: if (!SetNoTranspFill()) goto NoMemory; break; case TRANSPFILL_FLAT: if (!SetFlatTranspFill(TranspType, StartTransp)) goto NoMemory; break; case TRANSPFILL_LINEAR: if (!SetLinearTranspFill(TranspType, StartTransp, EndTransp, StartPoint, EndPoint)) goto NoMemory; break; case TRANSPFILL_NEWLINEAR: if (!SetLinearTranspFill(TranspType, StartTransp, EndTransp, StartPoint, EndPoint, &EndPoint2)) goto NoMemory; break; case TRANSPFILL_ELLIPTICAL: if (!SetRadialTranspFill(TranspType, StartTransp, EndTransp, StartPoint, EndPoint, EndPoint2)) goto NoMemory; break; case TRANSPFILL_CIRCULAR: if (!SetRadialTranspFill(TranspType, StartTransp, EndTransp, StartPoint, EndPoint)) goto NoMemory; break; case TRANSPFILL_CONICAL: if (!SetConicalTranspFill(TranspType, StartTransp, EndTransp, StartPoint, EndPoint)) goto NoMemory; break; case TRANSPFILL_TEXTURE: m_PendingBitmap = PENDING_BITMAP_TRANSPFILL; BitmapAttrs.Coords[0] = StartPoint; BitmapAttrs.Coords[1] = EndPoint; BitmapAttrs.Coords[2] = EndPoint2; BitmapAttrs.TranspType = TranspType; BitmapAttrs.Transp = 0; BitmapAttrs.EndTransp = 255; break; case TRANSPFILL_NEWTEXTURE: m_PendingBitmap = PENDING_BITMAP_TRANSPFILL; BitmapAttrs.Coords[0] = StartPoint; BitmapAttrs.Coords[1] = EndPoint; BitmapAttrs.Coords[2] = EndPoint2; BitmapAttrs.TranspType = TranspType; BitmapAttrs.Transp = StartTransp; BitmapAttrs.EndTransp = EndTransp; break; case TRANSPFILL_FRACTAL: if (!SetFractalTranspFill(TranspType, StartPoint, EndPoint, EndPoint2, Seed, Graininess, Gravity, Squash, DPI, Tileable)) goto NoMemory; break; case TRANSPFILL_NEWFRACTAL: if (!SetFractalTranspFill(TranspType, StartPoint, EndPoint, EndPoint2, Seed, Graininess, Gravity, Squash, DPI, Tileable, StartTransp, EndTransp)) goto NoMemory; break; default: ENSURE(FALSE, "Unknown fill type found!"); break; // Don't know this fill type } break; } case EPSC_cxmt: { INT32 MappingType; INT32 Repeat; // Get fill mapping type (should always be 0) if (!Stack.Pop(&MappingType)) goto EPSError; if (MappingType != 0) { ERROR2RAW("Bad mapping type in EPS"); goto EPSError; } // Get proper fill mapping type (should be 1, 2 or 3) if (!Stack.Pop(&Repeat)) goto EPSError; if ((Repeat < 1) || (Repeat > 3)) { ERROR2RAW("Bad mapping type in EPS"); goto EPSError; } // Call base class to use it if (Token == EPSC_cxm) { if (!SetLinearFillMapping(Repeat)) goto NoMemory; } else { if (!SetLinearTranspFillMapping(Repeat)) goto NoMemory; } break; } case EPSC_ctf: { // <FontName> ctf String_64 FName; if (!Stack.Pop(&FName)) goto EPSError; FName.SwapChar('-',' '); if ((FONTMANAGER->CacheNamedFont(&FName, EPSFilter::ClassOfFont) == ILLEGALFHANDLE)) goto EPSError; if (!SetTextTypeFace(&FName, EPSFilter::ClassOfFont)) goto EPSError; // Reset the font class to true type. EPSFilter::ClassOfFont = FC_TRUETYPE; break; } case EPSC_ctb: { // <0|1> ctb INT32 Bold; if (!Stack.Pop(&Bold)) goto EPSError; BOOL Boldon = (Bold==1); // Build any style definitions we need if (FontFlags.Bold) { if (!SetTextBoldFont(Boldon)) goto EPSError; } else { if (!SetTextBold(Boldon)) goto EPSError; } // Turn it off again FontFlags.Bold = FALSE; break; } case EPSC_cti: { // <0|1> cti INT32 Italic; if (!Stack.Pop(&Italic)) goto EPSError; BOOL ItalicOn = (Italic==1); // Build any style definitions we need if (FontFlags.Italic) { if (!SetTextItalicFont(ItalicOn)) goto EPSError; } else { if (!SetTextItalic(ItalicOn)) goto EPSError; } FontFlags.Italic = FALSE; break; } case EPSC_cts: { // <absolute millipoint rise> <absolute millipoint pointsize> cts INT32 rise,ptsize; if (!Stack.Pop(&ptsize)) goto EPSError; if (!Stack.Pop(&rise)) goto EPSError; if (!SetTextScript(rise,ptsize)) goto EPSError; break; } case EPSC_ctp: { // <absolute millipoint size> ctp INT32 ptsize; if (!Stack.Pop(&ptsize)) goto EPSError; if (!SetTextSize(ptsize)) goto EPSError; break; } case EPSC_ctls: { INT32 type; if (!Stack.Pop(&type)) goto EPSError; switch (type) { case 0: { MILLIPOINT linespace; if (!Stack.Pop(&linespace)) goto EPSError; if (!SetTextLineSpacing(1,0,linespace,0)) goto EPSError; break; } case 1: { double proportional; if (!Stack.Pop(&proportional)) goto EPSError; if (!SetTextLineSpacing(2,0,0,proportional)) goto EPSError; break; } } break; } default: // Token not understood - pass on to base class return CamelotEPSFilter::ProcessToken(); } // All seemed to work OK return TRUE; // Error handlers EPSError: HandleEPSError(); return FALSE; NoMemory: HandleNoMemory(); return FALSE; }

BOOL CamelotNativeEPSFilter::ReadBitmap (   )  [protected, virtual]

Reads in a bitmap. If it is a Type 0 bitmap (ie one with all its data) it will ask the base class to import it. If it is a Type 1 bitmap it will look up the reference in the bitmap pool and use that. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/95 Returns: TRUE if it worked, FALSE if it found an error Reimplemented from CamelotEPSFilter. Definition at line 1166 of file nativeps.cpp. { TRACEUSER( "Rik", _T("ReadBitmap...\n")); // Find out what kind of bitmap it is - always type 0 or 1 at present. INT32 BitmapType; if (!Stack.Pop(&BitmapType)) { // Error - not enough operands HandleEPSError(); return FALSE; } // if it is the old type 0 bitmap get the base class to do all the work if (BitmapType == 0) { // Need to push the type back on the stack again ready for the base class to read it TRACEUSER( "Rik", _T("Bitmap with data (in the pool I hope)\n")); Stack.Push(BitmapType); return CamelotEPSFilter::ReadBitmap(); } // OK, see if we have a type we do not know about if (BitmapType != 1) { // Error - Bad Type HandleEPSError(); return FALSE; } // Right, we have a type 1 bitmap.... INT32 BitmapIndex = 0; // Read in info on the bitmap (ie, which bitmap from the pool do we want) ... if ((!Stack.Pop(&BitmapIndex)) /*|| (BitmapIndex >= BitmapCount)*/) { // Error - not enough operands HandleEPSError(); return FALSE; } // ... and make sure that is in the range of bitmaps we have. // If the Index is out of range then use the Last one rather than just erroring. if (BitmapIndex >= BitmapCount) BitmapIndex = (BitmapCount-1); TRACEUSER( "Rik", _T("Bitmap reference found - refers to bitmap %d\n"), BitmapIndex); // Want to find bitmap 'BitmapIndex' and set pBitmap to point at it pBitmap = BitmapPoolRefs[BitmapIndex].GetBitmap(); return TRUE; }

BOOL CamelotNativeEPSFilter::SetFileCompressionState (  BOOL  NewState  )  [protected, virtual]

Set a new file compression status into action. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 19/5/95 Parameters: New  state for file compression, TRUE if want on, FALSE if want off. [INPUTS] Returns: True if succesful or False if not. Definition at line 359 of file nativeps.cpp. { TRACEUSER( "Neville", _T("CamelotNativeEPSFilter::SetFileCompressionState new state= %d\n"),NewState); CompressionOn = NewState; return TRUE; }

BOOL CamelotNativeEPSFilter::SetNativeCompression (  BOOL  NewState  )  [static]

Set the prefernece as to whether we are to compress the native files or not. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 27/5/95 Parameters: New  state for native file compression, TRUE if want on, FALSE if want off. [INPUTS] Returns: The old state of the compression. Definition at line 322 of file nativeps.cpp. { // BOOL OldState = CompressNative; CompressNative = NewState; return CompressNative; }

double CamelotNativeEPSFilter::SmartGetBuildNumber (   )

Determines a monotomic build version number based on BuildVersionNumber which unfortunately jumps to v1.00/a/b/c/d but these are mapped back to real build numbers. v1.00/a/b/c/d all have BuildVersionNumbers of 1.00 and are all descended from an isolated liniage based on 0.586 so all map to this number Note: Only guaranteed for build versions greater than 0.586! Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 17/10/95 Returns: Build version number Definition at line 1677 of file nativeps.cpp. { double BuildNumber = GetBuildNumber(); if (BuildNumber==1.00) BuildNumber = 0.586; return BuildNumber; }

---

Member Data Documentation

INT32 CamelotNativeEPSFilter::BitmapCount [protected]

Definition at line 174 of file nativeps.h.

KernelBitmapRef* CamelotNativeEPSFilter::BitmapPoolRefs [protected]

Definition at line 176 of file nativeps.h.

double CamelotNativeEPSFilter::BuildVersionNumber [protected]

Definition at line 192 of file nativeps.h.

BOOL CamelotNativeEPSFilter::CompressionOn [protected]

Definition at line 186 of file nativeps.h.

INT32 CamelotNativeEPSFilter::CompressionType [protected]

Definition at line 185 of file nativeps.h.

BOOL CamelotNativeEPSFilter::CompressNative = TRUE [static]

Flag for whether we compress the native files saved from Xara Studio. True means do compress the files. Preference: CompressNative Section: Filters Range: 0 to 1 See also: - Definition at line 200 of file nativeps.h.

double CamelotNativeEPSFilter::FileVersionNumber [protected]

Definition at line 191 of file nativeps.h.

BOOL CamelotNativeEPSFilter::IsSavingBitmapPool

Definition at line 157 of file nativeps.h.

CommandMap CamelotNativeEPSFilter::NativeCommands [static, protected]

Initial value: { { EPSC_cbmp, _T("cbmp") }, { EPSC_Invalid, _T("Invalid") } } Definition at line 182 of file nativeps.h.

BOOL CamelotNativeEPSFilter::OldImportWithLayers [protected]

Definition at line 179 of file nativeps.h.

INT32 CamelotNativeEPSFilter::OldMinLineWidth [protected]

Definition at line 194 of file nativeps.h.

BOOL CamelotNativeEPSFilter::OldOpenWithLayers [protected]

Definition at line 180 of file nativeps.h.

INT32 CamelotNativeEPSFilter::PendingBitmapNum [protected]

Definition at line 175 of file nativeps.h.

---

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

• Kernel/nativeps.h (r1785/r751)
• Kernel/nativeps.cpp (r1785/r1668)

---