CMXExportDC Class Reference

Export device context for CMX files. More...

#include <cmxexdc.h>

Inheritance diagram for CMXExportDC:

List of all members.

Public Types
enum	CMXSectionType {   CMXSECTION_NONE, CMXSECTION_HEADER, CMXSECTION_PAGE, CMXSECTION_REFLIST,   CMXSECTION_INDEX, CMXSECTION_ARROW, CMXSECTION_ARROWHEADS, CMXSECTION_COLOUR,   CMXSECTION_DOTDASH, CMXSECTION_FONT, CMXSECTION_IMAGE, CMXSECTION_OUTLINE,   CMXSECTION_LINESTYLE, CMXSECTION_PEN, CMXSECTION_LENS, CMXSECTION_SCREEN,   CMXSECTION_TRAILER, CMXSECTION_IMAGINFO, CMXSECTION_IMAGDATA, CMXSECTION_PROCBITFILL,   CMXSECTION_PREVIEWBITMAP }
enum	CMXBitmapColourSource { CMXBITMAPCOLOURSOURCE_NONE, CMXBITMAPCOLOURSOURCE_LINEANDFILL, CMXBITMAPCOLOURSOURCE_FILLGEOMETRY }
Public Member Functions
	CMXExportDC (Filter *)
	Initialise a DC for exporting EPS.
BOOL	Init (CCLexFile *, CMXRenderRegion *pReg, BOOL bThirtyTwoBit, BOOL ClipboardExport)
	Calls the base class Init function and then sets up the DC to throw exceptions when it gets errors as that is how the EPS stuff expects errors to be reported.
BOOL	StartSection (CMXSectionType Type)
	Start writing a section to a CMX file.
BOOL	EndSection (void)
	Finish off writing a section to a CMX file.
BOOL	StartRIFFList (INT32 Type)
	Start writing a section to a CMX file.
BOOL	EndRIFFList (void)
	Finish off writing a section to a CMX file.
BOOL	CreateHeader (DocRect *pFileBBox)
	Write the file's header, and name notes of the location of things like the relevant sizes and indices and other stuff which can only be written after the export.
BOOL	PolishOffThatFile (void)
	Finish off the file, update indexes and all that.
BOOL	WriteNumber (INT32 Position, UINT32 DataSize, INT32 Value)
	Finish off the file, update indexes and all that.
BOOL	WriteBBox (DocRect *BBox, BOOL Transform=TRUE)
	Write a bounding box to the file.
BOOL	WriteString (StringBase *Str)
	Write a bounding box to the file.
void	CleanUp (void)
	Cleans up after writing to a file.
BOOL	WriteReferenceList (void)
	writes the reference list for the page we've just done
BOOL	WriteData (void *data, INT32 Size)
void	WriteByte (BYTE Thing)
BOOL	WriteIndex (void)
	writes the index for the file
BOOL	WriteAnIndex (INT32 Which)
	writes the a particular index to the file
BOOL	WriteADesc (INT32 Which)
	writes the a particular index to the file
BOOL	WriteDescriptionSections (void)
BOOL	WriteMatrix (Matrix *pMatrix=NULL)
	writes a matrix to the file
INT32	GetGroupCount (void)
void	WriteAngle (double theta)
	writes an angle to the file
BOOL	WriteReferSections (void)
	gets all refer list items which are sections to write themselves
void	WriteSizeInFile (WORD Size)
BOOL	WriteCamComment (void)
	writes a helpful comment so we can see where dodgy cam cmx files come from
BOOL	WritePreviewBitmap (void)
	writes a preview bitmap type thing
void	SetTransMatrix (Matrix *pM)
Matrix *	GetTransMatrix (void)
INT32	GetFilePosition ()
	returns the position of the current file pointer in the export file
BOOL	IsThirtyTwoBit ()
INT32	GetFirstInstrFilePosition (void)
INT32	GetCurrentInstrFilePosition (void)
INT32	GetRefListOffset (void)
INT32	GetInstructionTally (void)
WORD	GetLayerNumber (void)
CMXRenderRegion *	GetRenderRegion (void)
double	GetScaleFactor (void)
void	SetInfo (Operation *op, PathName *ptPath, Document *ptDoc)
BOOL	StartPage (DocRect *BBox, BOOL IsProcedure=FALSE)
	starts a Page
BOOL	EndPage (void)
	ends a Page
BOOL	StartLayer (String_256 &Name)
	starts a layer
BOOL	EndLayer (void)
	ends a layer
BOOL	StartGroup (DocRect *BBox, BOOL TransformBBox=TRUE)
	starts a group
BOOL	EndGroup (void)
	ends a group
void	SetCMXFlag (INT32 flag)
	sets a flag for pages, layers
BOOL	WriteCommand (UINT32 Tag, void *Data=0, UINT32 Size=0)
	Write a command to the file -- one off operation, writes command and data in one go. Use default params for a no-data command.
BOOL	StartCommand (UINT32 Tag)
	starts writing a command for a command where the data is of indetermant size. Use EndCommand to finish it off
BOOL	EndCommand (void)
	ends a command
BOOL	WriteTag (INT32 Tag, void *Data=0, UINT32 Size=0)
BOOL	StartTag (INT32 Tag)
	starts writing a tag to the file
BOOL	EndTag (void)
	ends a tag
BOOL	StartNestedTag (INT32 Tag)
	starts writing a nested tag to the file
BOOL	EndNestedTag (void)
	ends a nested tag
BOOL	WriteNestedTag (INT32 Tag, void *Data=0, UINT32 Size=0)
BOOL	WriteMinEndTag (void)
BOOL	WriteAttributes (CMXRenderRegion *pReg, INT32 Tag, DocCoord *Coords, INT32 NumCoords, BOOL ForceNoFill=FALSE)
	Writes the attributes to the DC. if ForceNoFill == TRUE, the path will not be filled whatever the colour.
BOOL	WriteBlankAttributes (INT32 Tag)
	writes a blank attribute tag and contents, which specifies nothing but keeps everything happy
BOOL	WriteAttrCheckLens (CMXRenderRegion *pReg, INT32 Tag, DocCoord *Coords, INT32 NumCoords, BOOL *WasLens)
	checks to see if this object should be outputed as a lens. If so, we need to output the attributes for it ourselves (as we can't use the full range of possible things) and add things to the list
BOOL	WriteAttrCheckIgnoreLens (CMXRenderRegion *pReg, DocCoord *Coords, INT32 NumCoords)
	checks to see if we should ignore this lens -- it sees if it's going to overlap with too many lenses. This is basically as bodge as CorelDRAW will just fall over if we export a file with lots of overlapped lenses in it.
BOOL	WriteOutlineSpec (CMXRenderRegion *pReg)
	writes the outline specification to the file
BOOL	WriteFillSpec (CMXRenderRegion *pReg, DocCoord *Coords, INT32 NumCoords, BOOL NoFill)
	Writes the fill specifcation to the DC.
BOOL	WriteFillType (WORD FillID)
	Writes the fill type to the DC.
BOOL	WriteFillSpecFlat (CMXRenderRegion *pReg, FillGeometryAttribute *pAttr)
	Writes the flat fill specifcation to the DC.
BOOL	WriteFillSpecGrad (CMXRenderRegion *pReg, FillGeometryAttribute *pAttr, DocCoord *Coords, INT32 NumCoords)
	Writes the grad fill specifcation to the DC.
BOOL	WriteFillSpecBitmap (CMXRenderRegion *pReg, FillGeometryAttribute *pAttr, DocCoord *Coords, INT32 NumCoords)
	Writes the bitmap fill specifcation to the DC (also does fractals).
WORD	GetColourReference (DocColour *pTheLovelyColour)
	to find a reference number for the colour when writing a CMX file
WORD	GetBitmapReference (KernelBitmap *pTheLovelyBitmap, DocColour *pStartCol, DocColour *pEndCol, EFFECTTYPE Effect, CMXReferBitmap **ppRB=NULL)
	to find a reference number for the bitmap when writing a CMX file. ppRB is set to a pointer to the CMXReferBitmap object if ppRB != 0
WORD	GetProcedureReference (CMXReferListItem *pProc)
	checks to see if this object should be outputed as a lens. If so, we need to output the attributes for it ourselves (as we can't use the full range of possible things) and add things to the list
WORD	GetArrowReference (ArrowRec *pArrow)
	to find a reference number for the arrow when writing a CMX file will return 0 (ie no arrowhead) if it isn't one
BOOL	WritePath (DocCoord *Coords, PathVerb *Verbs, INT32 NumCoords, BOOL Filled)
	Writes a path instruction -- transformed by matrix.
BOOL	WriteBitmap (KernelBitmap *pBitmap, DocCoord *pParallelogram, CMXBitmapColourSource ColSource=CMXBITMAPCOLOURSOURCE_NONE, BOOL TransformParallelogram=TRUE, WORD BitmapReference=0)
	writes a bitmap object to the file
Static Public Member Functions
static void	CalcCorelBBox (DocCoord *Coords, INT32 NumCoords, DocRect *Result)
	calculates the corel bounding box of a path. This is just a simple union of all point. The result is not transformed by the export transform matrix.
static double	Round (double ToRound)
	Rounds a value up or down to the nearest integer.
Protected Member Functions
	DoWriteTag (INT32 Tag, void *Data=0, UINT32 Size=0, BOOL Nested=FALSE)
	writes a tag in one go
BOOL	WriteFutureDataCache ()
	Write the Numbers from the cache to the file See also:.
Private Attributes
CMXRenderRegion *	pRenderRegion
CMXSectionType	CurrentSection
CMXFutureLength	SectionLengthFuture
BOOL	ThirtyTwoBit
CMXFutureLength	FileLengthFuture
CMXFutureNumber	Tally
CMXFutureIndex	PageEndIndexFuture
CMXFutureNumber	PageInstructionCount
CMXFutureNumber	PageGroupCount
CMXFutureNumber	PageFlags
CMXFutureNumber	LayerInstructionCount
CMXFutureNumber	LayerFlags
CMXFutureLength	CommandLengthFuture
CMXFutureIndex	IndexSectionFuture
CMXFutureIndex	TrailerIndexFuture
CMXFutureIndex	ThumbnailIndexFuture
CMXFutureLength	TagLengthFuture
CMXFutureLength	RIFFListLengthFuture
BOOL	DoingCommand
BOOL	DoingPage
BOOL	DoingLayer
BOOL	DoingTag
WORD	LayerNumber
BOOL	DoingRIFFList
BOOL	PageIsProc
INT32	NestedTagLevel
List	NestedTagList
List	ReferList
CMXReferPage *	PageRefer
INT32	RefListOffset
List	GroupList
Matrix *	pMatrix
INT32	FirstInstrFilePosition
INT32	CurrentInstrFilePosition
INT32	NumberOfEntriesUsedInCache
CMXFutureDataCacheEntry	FutureDataCache [128]
double	ScaleFactor
List	LensBBoxes
BOOL	OverlappedLensesHaveBeenIgnored
BOOL	AreIgnoreingOverlappedLenses
BOOL	HaveAskedUserAboutLenses
Document *	TheDocument
Operation *	pOp
PathName *	pPath
Classes
struct	CMXFutureDataCacheEntry

---

Detailed Description

Export device context for CMX files.

Author:

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

Date:

18/6/96

See also:

ExportDC

Definition at line 232 of file cmxexdc.h.

---

Member Enumeration Documentation

enum CMXExportDC::CMXBitmapColourSource

Enumerator: CMXBITMAPCOLOURSOURCE_NONE  CMXBITMAPCOLOURSOURCE_LINEANDFILL  CMXBITMAPCOLOURSOURCE_FILLGEOMETRY  Definition at line 362 of file cmxexdc.h. { CMXBITMAPCOLOURSOURCE_NONE, CMXBITMAPCOLOURSOURCE_LINEANDFILL, CMXBITMAPCOLOURSOURCE_FILLGEOMETRY } CMXBitmapColourSource;

enum CMXExportDC::CMXSectionType

Enumerator: CMXSECTION_NONE  CMXSECTION_HEADER  CMXSECTION_PAGE  CMXSECTION_REFLIST  CMXSECTION_INDEX  CMXSECTION_ARROW  CMXSECTION_ARROWHEADS  CMXSECTION_COLOUR  CMXSECTION_DOTDASH  CMXSECTION_FONT  CMXSECTION_IMAGE  CMXSECTION_OUTLINE  CMXSECTION_LINESTYLE  CMXSECTION_PEN  CMXSECTION_LENS  CMXSECTION_SCREEN  CMXSECTION_TRAILER  CMXSECTION_IMAGINFO  CMXSECTION_IMAGDATA  CMXSECTION_PROCBITFILL  CMXSECTION_PREVIEWBITMAP  Definition at line 239 of file cmxexdc.h. { CMXSECTION_NONE, // not proccessing one CMXSECTION_HEADER, CMXSECTION_PAGE, CMXSECTION_REFLIST, CMXSECTION_INDEX, CMXSECTION_ARROW, CMXSECTION_ARROWHEADS, CMXSECTION_COLOUR, CMXSECTION_DOTDASH, CMXSECTION_FONT, CMXSECTION_IMAGE, CMXSECTION_OUTLINE, CMXSECTION_LINESTYLE, CMXSECTION_PEN, CMXSECTION_LENS, CMXSECTION_SCREEN, CMXSECTION_TRAILER, CMXSECTION_IMAGINFO, CMXSECTION_IMAGDATA, CMXSECTION_PROCBITFILL, CMXSECTION_PREVIEWBITMAP } CMXSectionType;

---

Constructor & Destructor Documentation

CMXExportDC::CMXExportDC (  Filter *  Parent  )

Initialise a DC for exporting EPS. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 18/6/96 Parameters: The  filter object associated with this export DC. [INPUTS] Definition at line 792 of file cmxexdc.cpp. : ExportDC(Parent) { }

---

Member Function Documentation

void CMXExportDC::CalcCorelBBox (  DocCoord *  Coords, INT32  NumCoords, DocRect *  Result )  [static]

calculates the corel bounding box of a path. This is just a simple union of all point. The result is not transformed by the export transform matrix. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 10/07/96 Parameters: coords,num  coords and output rec [INPUTS] Returns: - Definition at line 1855 of file cmxdcobj.cpp. { ERROR3IF(Coords == NULL || NumCoords < 1, "dodgy coords"); // write some sensible starting values Result->lo = Coords[0]; Result->hi = Coords[0]; // run through the rest for(INT32 l = 1; l < NumCoords; l++) { if(Result->lo.x > Coords[l].x) Result->lo.x = Coords[l].x; if(Result->lo.y > Coords[l].y) Result->lo.y = Coords[l].y; if(Result->hi.x < Coords[l].x) Result->hi.x = Coords[l].x; if(Result->hi.y < Coords[l].y) Result->hi.y = Coords[l].y; } // sorted }

void CMXExportDC::CleanUp (  void   )

Cleans up after writing to a file. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 26/06/96 Parameters: none  [INPUTS] Returns: none See also: Definition at line 894 of file cmxexdc.cpp. { WriteFutureDataCache(); ReferList.DeleteAll(); LensBBoxes.DeleteAll(); }

BOOL CMXExportDC::CreateHeader (  DocRect *  pFileBBox  )

Write the file's header, and name notes of the location of things like the relevant sizes and indices and other stuff which can only be written after the export. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/96 Parameters: bounding  box of file [INPUTS] Returns: success This fn is called Create rather than Write because it's not finished off properly until the end of the file. See also: Definition at line 1412 of file cmxexdc.cpp. { ERROR2IF(pMatrix == NULL, FALSE, "No matrix yet"); // first of all, think about the riff file header RIFFFile_Header rhdr; rhdr.CK.ckID = RIFFTYPE_RIFF; rhdr.CK.ckSize = 0; rhdr.FormType = cmxRIFFFORMTYPE_CMX; ExportFile->write(&rhdr, sizeof(rhdr)); // set up the future length object FileLengthFuture.Init(this, FUTURE_BACKLOC(&rhdr, CK.ckSize), sizeof(rhdr.CK.ckSize)); FileLengthFuture.SetLengthStartPos(this, /*-((INT32)sizeof(rhdr))*/ -(INT32)sizeof(DWORD)); // start the CMX header section if(!StartSection(CMXSECTION_HEADER)) return FALSE; // write the CMX header cmxHeader fhdr; memset(&fhdr, 0, sizeof(fhdr)); // set everything to zero camStrcpy((char *)fhdr.Id, cmxID); camStrcpy((char *)fhdr.OS, cmxOS); fhdr.ByteOrder = cmxBYTEORDER_INTEL | 0x30; if(ThirtyTwoBit) { fhdr.CoordSize = cmxCOORDSIZE_32 | 0x30; fhdr.Major = cmxMAJOR_32 | 0x30; fhdr.Factor = cmxFACTOR_32; fhdr.Unit = cmxUNIT_MILLIMETER; } else { fhdr.CoordSize = cmxCOORDSIZE_16 | 0x30; fhdr.Major = cmxMAJOR_16 | 0x30; fhdr.Factor = cmxFACTOR_16; fhdr.Unit = cmxUNIT_INCH; } fhdr.Minor = cmxMINOR | 0x30; // bounding box DocRect bb = *pFileBBox; pMatrix->TransformBounds(&bb); fhdr.IBBLeft = bb.lo.x; fhdr.IBBTop = bb.hi.y; fhdr.IBBRight = bb.hi.x; fhdr.IBBBottom = bb.lo.y; fhdr.IThumbnail = -1; ExportFile->write(&fhdr, sizeof(fhdr)); // set up it's future value objects Tally.Init(this, FUTURE_BACKLOC(&fhdr, ITally), sizeof(fhdr.ITally)); Tally = 0; IndexSectionFuture.Init(this, FUTURE_BACKLOC(&fhdr, IIndexSection), sizeof(fhdr.IIndexSection)); TrailerIndexFuture.Init(this, FUTURE_BACKLOC(&fhdr, IInfoSection), sizeof(fhdr.IInfoSection)); ThumbnailIndexFuture.Init(this, FUTURE_BACKLOC(&fhdr, IThumbnail), sizeof(fhdr.IThumbnail)); // end the CMX header section if(!EndSection()) return FALSE; return TRUE; }

BOOL CMXExportDC::DoWriteTag (  INT32  Tag, void *  Data = 0, UINT32  Size = 0, BOOL  Nested = FALSE )  [protected]

writes a tag in one go Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1245 of file cmxexdc.cpp. { if(!Nested) { ERROR2IF(DoingTag == TRUE, FALSE, "already doing a tag"); } // if we're not doing a 32 bit file, we just want to export the data if(ThirtyTwoBit) { // write the tag header cmxTagHdr hdr; hdr.ID = (BYTE)Tag; hdr.Size = sizeof(hdr)+Size; ExportFile->write(&hdr, sizeof(hdr)); } // write the data, if required if(Size != 0) ExportFile->write(Data, Size); return TRUE; }

BOOL CMXExportDC::EndCommand (  void   )

ends a command Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1373 of file cmxexdc.cpp. { ERROR2IF(DoingCommand != TRUE, FALSE, "Already writing a command"); // word align the file if((GetFilePosition() & 1) != 0) { // put an extra byte in the file ExportFile->put('\0'); } CommandLengthFuture.Write(this); DoingCommand = FALSE; CurrentInstrFilePosition = -1; return TRUE; }

BOOL CMXExportDC::EndGroup (  void   )

ends a group Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 2203 of file cmxexdc.cpp. { // get the last entry off the group list CMXGroupRecord *pGRec = (CMXGroupRecord *)GroupList.GetTail(); // get it to write itself if(!pGRec->Write(this)) return FALSE; // delete the group record delete GroupList.RemoveTail(); // write the end group command if(!WriteCommand(cmxINSTR_EndGroup)) return FALSE; return TRUE; }

BOOL CMXExportDC::EndLayer (  void   )

ends a layer Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 2114 of file cmxexdc.cpp. { ERROR2IF(DoingLayer == FALSE, FALSE, "Already doing a layer"); // write the end layer command WriteCommand(cmxINSTR_EndLayer); // write the count of instructions in the layer LayerInstructionCount.Write(this); LayerFlags.Write(this); DoingLayer = FALSE; return TRUE; }

BOOL CMXExportDC::EndNestedTag (  void   )

ends a nested tag Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 04/07/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1205 of file cmxexdc.cpp. { if(!ThirtyTwoBit) return TRUE; // 16 bit files don't have tags ERROR2IF(DoingTag == FALSE, FALSE, "not doing a tag"); ERROR2IF(NestedTagLevel <= 0, FALSE, "not doing a nested tag"); // get the last tag record CMXNestedTagRecord *pRec = (CMXNestedTagRecord *)NestedTagList.GetTail(); // check it's OK ERROR2IF(!IS_A(pRec, CMXNestedTagRecord), FALSE, "tag record not a tag record"); // write the length pRec->LengthFuture.Write(this); // delete the record delete NestedTagList.RemoveTail(); // flag NestedTagLevel--; return TRUE; }

BOOL CMXExportDC::EndPage (  void   )

ends a Page Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1991 of file cmxexdc.cpp. { ERROR2IF(DoingPage == FALSE, FALSE, "Not doing a page"); // write the index of the end page command PageEndIndexFuture.Write(this); // write the end page command if(!PageIsProc) WriteCommand(cmxINSTR_EndPage); else WriteCommand(cmxINSTR_EndSection); // write future values PageFlags.Write(this); PageInstructionCount.Write(this); PageGroupCount.Write(this); // finish the section if(!PageIsProc) EndSection(); DoingPage = FALSE; return TRUE; }

BOOL CMXExportDC::EndRIFFList (  void   )

Finish off writing a section to a CMX file. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 16/07/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1058 of file cmxexdc.cpp. { ERROR2IF(!DoingRIFFList, FALSE, "Tried to end a riff list which didn't exist"); // write the length RIFFListLengthFuture.Write(this); // word align the file if((GetFilePosition() & 1) != 0) { // put an extra byte in the file ExportFile->put('\0'); } // flag DoingRIFFList = FALSE; return TRUE; }

BOOL CMXExportDC::EndSection (  void   )

Finish off writing a section to a CMX file. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 986 of file cmxexdc.cpp. { ERROR2IF(CurrentSection == CMXSECTION_NONE, FALSE, "Tried to end a section which didn't exist"); // write the length SectionLengthFuture.Write(this); // set the section type to none CurrentSection = CMXSECTION_NONE; // word align the file if((GetFilePosition() & 1) != 0) { // put an extra byte in the file ExportFile->put('\0'); } return TRUE; }

BOOL CMXExportDC::EndTag (  void   )

ends a tag Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1129 of file cmxexdc.cpp. { if(!ThirtyTwoBit) return TRUE; // 16 bit files don't have tags ERROR2IF(DoingTag == FALSE, FALSE, "not doing a tag"); ERROR2IF(NestedTagLevel != 0, FALSE, "tried to end a main tag when nested tags are active"); // write the length TagLengthFuture.Write(this); // flag DoingTag = FALSE; return TRUE; }

WORD CMXExportDC::GetArrowReference (  ArrowRec *  pArrow  )

to find a reference number for the arrow when writing a CMX file will return 0 (ie no arrowhead) if it isn't one Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/07/96 Parameters: colour  [INPUTS] Returns: reference number of a colour Definition at line 1201 of file cmxdcobj.cpp. { // check to see if the arrowrec is in fact an arrowhead if(pArrow->IsNullArrow()) return 0; // ie no arrow on here mate // the reference we need -- references count up from 1 INT32 Ref = 0; // scan that list! CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); if(pEn->IsInWhichDesc() == cmxDESC_ARROW) { Ref++; CMXReferArrow *pAr = (CMXReferArrow *)pEn; ERROR3IF(!pAr->IsKindOf(CC_RUNTIME_CLASS(CMXReferArrow)), "not an arrow, when it said it was"); // is it this colour? if(pAr->AreYouThisArrow(pArrow)) { // yep. return the reference number return Ref; } } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } // we haven't got one... make a new one, set it up and add it to the list CMXReferArrow *pNewArrow = new CMXReferArrow(this); if(pNewArrow == 0) return 0; pNewArrow->Set(pArrow); ReferList.AddTail(pNewArrow); // return the next reference number, Ref is the ref of the last one in the list return (WORD)Ref + 1; }

WORD CMXExportDC::GetBitmapReference (  KernelBitmap *  pTheLovelyBitmap, DocColour *  pStartCol, DocColour *  pEndCol, EFFECTTYPE  Effect, CMXReferBitmap **  ppRB = NULL )

to find a reference number for the bitmap when writing a CMX file. ppRB is set to a pointer to the CMXReferBitmap object if ppRB != 0 Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 16/07/96 Parameters: bitmap  [INPUTS] Returns: refernce number of a bitmap Definition at line 1261 of file cmxdcobj.cpp. { // the reference we need -- references count up from 1 INT32 Ref = 0; // scan that list! CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); if(pEn->IsInWhichIndex() == cmxINDEX_EMBEDFILE && IS_A(pEn, CMXReferBitmap)) { Ref++; CMXReferBitmap *pBitty = (CMXReferBitmap *)pEn; // is it this bitmap? if(pBitty->AreYouThisBitmap(pTheLovelyBitmap, pStartCol, pEndCol, Effect)) { // yep. set bitmap object addr and return the reference number if(ppRB != 0) (*ppRB) = pBitty; return Ref; } } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } // we haven't got one... make a new one, set it up and add it to the list CMXReferBitmap *pNewRefBit = new CMXReferBitmap(this); if(pNewRefBit == 0) return 0; pNewRefBit->Set(pTheLovelyBitmap, pStartCol, pEndCol, Effect); ReferList.AddTail(pNewRefBit); // set bitmap object addr if(ppRB != 0) (*ppRB) = pNewRefBit; // return the next reference number, Ref is the ref of the last one in the list return (WORD)Ref + 1; }

WORD CMXExportDC::GetColourReference (  DocColour *  pTheLovelyColour  )

to find a reference number for the colour when writing a CMX file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 04/07/96 Parameters: colour  [INPUTS] Returns: refernce number of a colour Definition at line 1140 of file cmxdcobj.cpp. { // algorithm: // scan the refer list to see if the colour is already there. // if it is, return it's index. // if it isn't add the colour to the refer list, and return the new index. // the reference we need -- references count up from 1 INT32 Ref = 0; // scan that list! CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); if(pEn->IsInWhichDesc() == cmxDESC_COLOUR) { Ref++; CMXReferColour *pLC = (CMXReferColour *)pEn; ERROR3IF(!pLC->IsKindOf(CC_RUNTIME_CLASS(CMXReferColour)), "not a refer colour, when it said it was"); // is it this colour? if(pLC->AreYouThisColour(pTheLovelyColour)) { // yep. return the reference number return Ref; } } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } // we haven't got one... make a new one, set it up and add it to the list CMXReferColour *pNewRefCol = new CMXReferColour(this); if(pNewRefCol == 0) return 0; pNewRefCol->SetColour(pTheLovelyColour); ReferList.AddTail(pNewRefCol); // return the next reference number, Ref is the ref of the last one in the list return (WORD)Ref + 1; }

INT32 CMXExportDC::GetCurrentInstrFilePosition (  void   )  [inline]

Definition at line 310 of file cmxexdc.h. {return CurrentInstrFilePosition;};

INT32 CMXExportDC::GetFilePosition (   )

returns the position of the current file pointer in the export file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1535 of file cmxexdc.cpp. { return ExportFile->tell(); }

INT32 CMXExportDC::GetFirstInstrFilePosition (  void   )  [inline]

Definition at line 309 of file cmxexdc.h. {return FirstInstrFilePosition;};

INT32 CMXExportDC::GetGroupCount (  void   )  [inline]

Definition at line 289 of file cmxexdc.h. {return PageGroupCount;};

INT32 CMXExportDC::GetInstructionTally (  void   )  [inline]

Definition at line 312 of file cmxexdc.h. {return Tally;};

WORD CMXExportDC::GetLayerNumber (  void   )  [inline]

Definition at line 313 of file cmxexdc.h. {return LayerNumber;};

WORD CMXExportDC::GetProcedureReference (  CMXReferListItem *  pProc  )

checks to see if this object should be outputed as a lens. If so, we need to output the attributes for it ourselves (as we can't use the full range of possible things) and add things to the list Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 12/07/96 Parameters: render  region, tag, pointer to flag [INPUTS] Returns: error flag Definition at line 1890 of file cmxdcobj.cpp. { ERROR3IF(!pProc->IsAProcedure(), "item is not a procedure"); // scan the refer list for this item, counting procedures before it WORD Ref = 0; CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); if(pEn->IsAProcedure()) { // inc reference number Ref++; // is it this one? if(pEn == pProc) return Ref; } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } return 1; // fairly OK default }

INT32 CMXExportDC::GetRefListOffset (  void   )  [inline]

Definition at line 311 of file cmxexdc.h. {return RefListOffset;};

CMXRenderRegion* CMXExportDC::GetRenderRegion (  void   )  [inline]

Definition at line 314 of file cmxexdc.h. {return pRenderRegion;};

double CMXExportDC::GetScaleFactor (  void   )  [inline]

Definition at line 315 of file cmxexdc.h. {return ScaleFactor;};

Matrix* CMXExportDC::GetTransMatrix (  void   )  [inline]

Definition at line 306 of file cmxexdc.h. {return pMatrix;};

BOOL CMXExportDC::Init (  CCLexFile *  pFile, CMXRenderRegion *  pReg, BOOL  bThirtyTwoBit, BOOL  ClipboardExport )

Calls the base class Init function and then sets up the DC to throw exceptions when it gets errors as that is how the EPS stuff expects errors to be reported. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 18/6/96 Parameters: pFile  - The file to attach to the DC [INPUTS] Returns: TRUE if all went well, FALSE if not See also: ExportDC::Init Definition at line 812 of file cmxexdc.cpp. { // First get the base class to do its thing if (!ExportDC::Init(pFile)) return FALSE; // now do what I want done. // We want export files to throw exceptions, and not report errors. ExportFile->SetThrowExceptions(TRUE); ExportFile->SetReportErrors(FALSE); // set the bitness of the file ThirtyTwoBit = bThirtyTwoBit; // mark the fact that we've not actually doing a section at all CurrentSection = CMXSECTION_NONE; // set up a few more variables DoingCommand = FALSE; DoingPage = FALSE; DoingLayer = FALSE; PageRefer = NULL; DoingTag = FALSE; pMatrix = NULL; NestedTagLevel = 0; CurrentInstrFilePosition = -1; pRenderRegion = pReg; DoingRIFFList = FALSE; NumberOfEntriesUsedInCache = 0; // overlapped lenses flag if(!ClipboardExport) { // normal ask the user mode AreIgnoreingOverlappedLenses = FALSE; OverlappedLensesHaveBeenIgnored = FALSE; HaveAskedUserAboutLenses = FALSE; } else { // don't ask the user AreIgnoreingOverlappedLenses = TRUE; OverlappedLensesHaveBeenIgnored = FALSE; HaveAskedUserAboutLenses = TRUE; } for(INT32 i = 0 ; i < CMXFUTUREVALUECACHESIZE ; i++) { // init the write-cache FutureDataCache[i].Location = INT32_MAX; FutureDataCache[i].Data = 0; FutureDataCache[i].DataSize = 0; } // pop in the default screen thingy CMXReferDefaultScreen *pDefScreen = new CMXReferDefaultScreen(this); if(pDefScreen == NULL) return FALSE; // and add it to the list ReferList.AddTail(pDefScreen); // pop in the default dot dash thingy CMXReferDefaultDotDash *pDefdd = new CMXReferDefaultDotDash(this); if(pDefdd == NULL) return FALSE; // and add it to the list ReferList.AddTail(pDefdd); return TRUE; }

BOOL CMXExportDC::IsThirtyTwoBit (   )  [inline]

Definition at line 308 of file cmxexdc.h. {return ThirtyTwoBit;};

BOOL CMXExportDC::PolishOffThatFile (  void   )

Finish off the file, update indexes and all that. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1494 of file cmxexdc.cpp. { ERROR2IF(CurrentSection != CMXSECTION_NONE, FALSE, "Didn't end the section before ending the file"); // write some future values if(!Tally.Write(this)) return FALSE; // write the info section if(!TrailerIndexFuture.Write(this)) return FALSE; if(!StartSection(CMXSECTION_TRAILER)) return FALSE; if(!EndSection()) return FALSE; // and pop the length in if(!FileLengthFuture.Write(this)) return FALSE; WriteFutureDataCache(); return TRUE; }

double CMXExportDC::Round (  double  ToRound  )  [static]

Rounds a value up or down to the nearest integer. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 8/5/00 Parameters: ToRound  - The value to be rounded up. [INPUTS] Returns: double - The rounded value. Definition at line 3207 of file cmxexdc.cpp. { // Add 0.5 to the value, and floor it. This will return the nearest integer. return floor ( ToRound + 0.5 ); }

void CMXExportDC::SetCMXFlag (  INT32  flag  )

sets a flag for pages, layers Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/07/96 Parameters: none  [INPUTS] Returns: none See also: Definition at line 2677 of file cmxexdc.cpp. { PageFlags = ((INT32)PageFlags) | flag; LayerFlags = ((INT32)LayerFlags) | flag; }

void CMXExportDC::SetInfo (  Operation *  op, PathName *  ptPath, Document *  ptDoc )  [inline]

Definition at line 316 of file cmxexdc.h. {pOp = op, pPath = ptPath, TheDocument = ptDoc;};

void CMXExportDC::SetTransMatrix (  Matrix *  pM  )  [inline]

Definition at line 298 of file cmxexdc.h. { pMatrix = pM; FIXED16 sf; pMatrix->Decompose(&sf); ScaleFactor = sf.MakeDouble(); };

BOOL CMXExportDC::StartCommand (  UINT32  Tag  )

starts writing a command for a command where the data is of indetermant size. Use EndCommand to finish it off Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/96 Parameters: none  [INPUTS] Returns: success See also: WriteCommand -- use for one off commands Definition at line 1334 of file cmxexdc.cpp. { ERROR2IF(DoingCommand != FALSE, FALSE, "Already writing a command"); // record the start of the file CurrentInstrFilePosition = GetFilePosition(); // write the header cmxInstrHdr hdr = {0, ThirtyTwoBit?Tag:(0 - (SWORD)Tag)}; ExportFile->write(&hdr, sizeof(hdr)); Tally++; PageInstructionCount++; LayerInstructionCount++; // set the future length CommandLengthFuture.Init(this, FUTURE_BACKLOC(&hdr, Size), sizeof(hdr.Size)); CommandLengthFuture.SetLengthStartPos(this, 0 - (INT32)sizeof(hdr)); // set whether we're doing a command DoingCommand = TRUE; return TRUE; }

BOOL CMXExportDC::StartGroup (  DocRect *  BBox, BOOL  TransformBBox = TRUE )

starts a group Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 2145 of file cmxexdc.cpp. { ERROR2IF(DoingLayer == FALSE && !PageIsProc, FALSE, "Groups should be in layers"); // increment the group count PageGroupCount++; // start the command if(!StartCommand(cmxINSTR_BeginGroup)) return FALSE; // start the tag if(!StartTag(cmxTAG_BeginGroup_GroupSpecification)) return FALSE; // write the bounding box if(!WriteBBox(BBox, TransformBBox)) return FALSE; // get a group record object CMXGroupRecord *pGRec = new CMXGroupRecord(this); if(pGRec == NULL) return FALSE; // add the group record object to the list GroupList.AddTail(pGRec); // write a place holder data chunk cmxGroupInfo gi = {0,0,0}; ExportFile->write(&gi, sizeof(gi)); if(!EndTag()) return FALSE; if(!WriteMinEndTag()) return FALSE; // end the command if(!EndCommand()) return FALSE; return TRUE; }

BOOL CMXExportDC::StartLayer (  String_256 &  Name  )

starts a layer Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: layer  name [INPUTS] Returns: success See also: Definition at line 2032 of file cmxexdc.cpp. { ERROR2IF(DoingPage == FALSE, FALSE, "Layers should be in pages"); ERROR2IF(DoingLayer == TRUE, FALSE, "Already doing a layer"); LayerNumber++; // get a entry for this thingy in the reference list CMXReferLayer *pRL = new CMXReferLayer(this); if(pRL == NULL) return FALSE; pRL->SetLayerDetails(LayerNumber, &Name); ReferList.AddTail(pRL); // add it to the list // start the command StartCommand(cmxINSTR_BeginLayer); // tag if(!StartTag(cmxTAG_BeginLayer_LayerSpecification)) return FALSE; // write the first bit of the instruction cmxInstrLayer1 chdr1; chdr1.PageNumber = 1; chdr1.LayerNumber = (WORD)LayerNumber; chdr1.LayerFlags = 0; chdr1.InstructionCount = 0; ExportFile->write(&chdr1, sizeof(chdr1)); // set up the instruciton count future LayerInstructionCount.Init(this, FUTURE_BACKLOC(&chdr1, InstructionCount), sizeof(chdr1.InstructionCount)); LayerFlags.Init(this, FUTURE_BACKLOC(&chdr1, LayerFlags), sizeof(chdr1.LayerFlags)); LayerFlags = 0; // write it's name out WriteString(&Name); // end the tag if(!EndTag()) return FALSE; // write the second bit of the thingy if(!StartTag(cmxTAG_BeginLayer_Matrix)) return FALSE; if(!WriteMatrix()) return FALSE; if(!EndTag()) return FALSE; // mapping mode... BYTE MapMode = 0; if(!WriteTag(cmxTAG_BeginLayer_MappingMode, &MapMode, sizeof(MapMode))) return FALSE; // end tag if(!WriteMinEndTag()) return FALSE; // end the command EndCommand(); LayerInstructionCount = 1; // to include this one DoingLayer = TRUE; return TRUE; }

BOOL CMXExportDC::StartNestedTag (  INT32  Tag  )

starts writing a nested tag to the file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27/06/96 Parameters: Tag  for the command [INPUTS] Returns: success See also: Definition at line 1160 of file cmxexdc.cpp. { if(!ThirtyTwoBit) return TRUE; // 16 bit files don't have tags ERROR2IF(DoingTag == FALSE, FALSE, "tried to start a nested tag outside a tag"); // write the tag header cmxTagHdr hdr; hdr.ID = (BYTE)Tag; hdr.Size = 0; ExportFile->write(&hdr, sizeof(hdr)); // get one of those nested tag record things CMXNestedTagRecord *pRec = new CMXNestedTagRecord; if(pRec == NULL) return FALSE; // initialise the future value pRec->LengthFuture.Init(this, FUTURE_BACKLOC(&hdr, Size), sizeof(hdr.Size)); pRec->LengthFuture.SetLengthStartPos(this, 0-(INT32)sizeof(hdr)); // add the record to the list NestedTagList.AddTail(pRec); // flag NestedTagLevel++; return TRUE; }

BOOL CMXExportDC::StartPage (  DocRect *  BBox, BOOL  IsProcedure = FALSE )

starts a Page Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1833 of file cmxexdc.cpp. { ERROR2IF(DoingPage == TRUE, FALSE, "Already doing a page"); if(!IsProcedure) { // make the page reference object PageRefer = new CMXReferPage(this); if(PageRefer == NULL) return FALSE; ReferList.AddTail(PageRefer); // start the section StartSection(CMXSECTION_PAGE); // write the page start StartCommand(cmxINSTR_BeginPage); // tag this bit if(!StartTag(cmxTAG_BeginPage_PageSpecification)) return FALSE; cmxInstrPage1 phdr1; phdr1.PageNumber = 1; phdr1.Flags = 0; ExportFile->write(&phdr1, sizeof(phdr1)); // set the future flags value PageFlags.Init(this, FUTURE_BACKLOC(&phdr1, Flags), sizeof(phdr1.Flags)); PageFlags = 0; // write the bbox, transforming the thing of course WriteBBox(BBox); // write the rest of the page command cmxInstrPage2 phdr2; phdr2.EndPageOffset = 0; phdr2.GroupCount = 0; phdr2.InstructionCount = 0; ExportFile->write(&phdr2, sizeof(phdr2)); // set up some future values PageEndIndexFuture.Init(this, FUTURE_BACKLOC(&phdr2, EndPageOffset), sizeof(phdr2.EndPageOffset)); PageGroupCount.Init(this, FUTURE_BACKLOC(&phdr2, GroupCount), sizeof(phdr2.GroupCount)); PageGroupCount = 0; PageInstructionCount.Init(this, FUTURE_BACKLOC(&phdr2, InstructionCount), sizeof(phdr2.InstructionCount)); PageInstructionCount = 1; // to include this instr // end the tag if(!EndTag()) return FALSE; // matrix tag... if(!StartTag(cmxTAG_BeginPage_Matrix)) return FALSE; // write the matrix if(!WriteMatrix()) return FALSE; // end the tag if(!EndTag()) return FALSE; // mapping mode... BYTE MapMode = 0; if(!WriteTag(cmxTAG_BeginPage_MappingMode, &MapMode, sizeof(MapMode))) return FALSE; // end tag if(!WriteMinEndTag()) return FALSE; // end the command EndCommand(); // flag PageIsProc = FALSE; } else { // write the procedure start StartCommand(cmxINSTR_BeginProcedure); // tag this bit if(!StartTag(cmxTAG_BeginProcedure_ProcedureSpecification)) return FALSE; cmxInstrProc1 phdr1; phdr1.Flags = 0; ExportFile->write(&phdr1, sizeof(phdr1)); // set the future flags value PageFlags.Init(this, FUTURE_BACKLOC(&phdr1, Flags), sizeof(phdr1.Flags)); PageFlags = 0; // write the bbox, not transforming it as we've already done that WriteBBox(BBox, FALSE); // write the rest of the page command cmxInstrProc2 phdr2; phdr2.EndPageOffset = 0; phdr2.GroupCount = 0; phdr2.InstructionCount = 0; ExportFile->write(&phdr2, sizeof(phdr2)); // set up some future values PageEndIndexFuture.Init(this, FUTURE_BACKLOC(&phdr2, EndPageOffset), sizeof(phdr2.EndPageOffset)); PageGroupCount.Init(this, FUTURE_BACKLOC(&phdr2, GroupCount), sizeof(phdr2.GroupCount)); PageGroupCount = 0; PageInstructionCount.Init(this, FUTURE_BACKLOC(&phdr2, InstructionCount), sizeof(phdr2.InstructionCount)); PageInstructionCount = 1; // to include this instr // end the tag if(!EndTag()) return FALSE; // end tag if(!WriteMinEndTag()) return FALSE; // end the command EndCommand(); // flag PageIsProc = TRUE; } DoingPage = TRUE; LayerNumber = 0; // record the location of the first instruction in the file, which will follow immediately if(!IsProcedure) FirstInstrFilePosition = GetFilePosition(); // write a comment to say where this file came from // return WriteCamComment(); return TRUE; // Graeme (10-2-00) replaced above return with return TRUE. }

BOOL CMXExportDC::StartRIFFList (  INT32  Type  )

Start writing a section to a CMX file. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 16/07/96 Parameters: The  type of section to start [INPUTS] Returns: success See also: Definition at line 1020 of file cmxexdc.cpp. { ERROR2IF(DoingRIFFList, FALSE, "Tried to start a riff list without ending the previous one"); // write the riff list header RIFFck chdr; chdr.ckID = RIFFTYPE_LIST; chdr.ckSize = 0; ExportFile->write(&chdr, sizeof(chdr)); // set the future length RIFFListLengthFuture.Init(this, FUTURE_BACKLOC(&chdr, ckSize), sizeof(chdr.ckSize)); RIFFListLengthFuture.SetLengthStartPos(this, 0); // write the list type, if we're doing a list DWORD id = Type; ExportFile->write(&id, sizeof(id)); // flag... DoingRIFFList = TRUE; return TRUE; }

BOOL CMXExportDC::StartSection (  CMXSectionType  Type  )

Start writing a section to a CMX file. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 18/6/96 Parameters: The  type of section to start [INPUTS] Returns: success See also: Definition at line 915 of file cmxexdc.cpp. { ERROR2IF(CurrentSection != CMXSECTION_NONE, FALSE, "Tried to start a section without ending the previous one"); // write the riff file header // first, decide what riff chunck id we want DWORD id; BOOL IsAList = FALSE; // whether in fact it's a list switch(Type) { case CMXSECTION_NONE: ERROR2(FALSE, "Tried to start a section of type none. Oh dear"); break; case CMXSECTION_HEADER: id = cmxRIFFCI_Header; break; case CMXSECTION_PAGE: id = cmxRIFFCI_Page; break; case CMXSECTION_REFLIST: id = cmxRIFFCI_ReferenceList; break; case CMXSECTION_INDEX: id = cmxRIFFLIST_Index; IsAList=TRUE; break; case CMXSECTION_TRAILER: id = cmxRIFFLIST_Trail; IsAList=TRUE; break; case CMXSECTION_ARROW: id = cmxRIFFCI_Desc_Arrow; break; case CMXSECTION_ARROWHEADS: id = cmxRIFFCI_Desc_Arrowheads; break; case CMXSECTION_COLOUR: id = cmxRIFFCI_Desc_Colour; break; case CMXSECTION_DOTDASH: id = cmxRIFFCI_Desc_DotDash; break; case CMXSECTION_FONT: id = cmxRIFFCI_Desc_Font; break; case CMXSECTION_OUTLINE: id = cmxRIFFCI_Desc_Outline; break; case CMXSECTION_LINESTYLE: id = cmxRIFFCI_Desc_LineStyle; break; case CMXSECTION_PEN: id = cmxRIFFCI_Desc_Pen; break; case CMXSECTION_LENS: id = cmxRIFFCI_Desc_Lens; break; case CMXSECTION_SCREEN: id = cmxRIFFCI_Desc_Screen; break; case CMXSECTION_IMAGINFO: id = cmxRIFFCI_ImageInfo; break; case CMXSECTION_IMAGDATA: id = cmxRIFFCI_ImageData; break; case CMXSECTION_PROCBITFILL:id = cmxRIFFCI_Procedure; break; case CMXSECTION_PREVIEWBITMAP: id = cmxRIFFCI_Thumbnail; break; default: ERROR2(FALSE, "Unknown section type"); break; } // OK, write the RIFF header RIFFck chdr; chdr.ckID = IsAList?RIFFTYPE_LIST:id; chdr.ckSize = 0; ExportFile->write(&chdr, sizeof(chdr)); // set the future length SectionLengthFuture.Init(this, FUTURE_BACKLOC(&chdr, ckSize), sizeof(chdr.ckSize)); SectionLengthFuture.SetLengthStartPos(this, 0 /* - (INT32)sizeof(chdr)*/); // write the list type, if we're doing a list if(IsAList) ExportFile->write(&id, sizeof(id)); // note which section type we just did CurrentSection = Type; return TRUE; }

BOOL CMXExportDC::StartTag (  INT32  Tag  )

starts writing a tag to the file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27/06/96 Parameters: Tag  for the command [INPUTS] Returns: success See also: Definition at line 1092 of file cmxexdc.cpp. { if(!ThirtyTwoBit) return TRUE; // 16 bit files don't have tags ERROR2IF(DoingTag == TRUE, FALSE, "already doing a tag"); // write the tag header cmxTagHdr hdr; hdr.ID = (BYTE)Tag; hdr.Size = 0; ExportFile->write(&hdr, sizeof(hdr)); // initialise the future value TagLengthFuture.Init(this, FUTURE_BACKLOC(&hdr, Size), sizeof(hdr.Size)); TagLengthFuture.SetLengthStartPos(this, 0-(INT32)sizeof(hdr)); // flag DoingTag = TRUE; return TRUE; }

BOOL CMXExportDC::WriteADesc (  INT32  Which  )

writes the a particular index to the file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 2728 of file cmxexdc.cpp. { // get some types and sort out the master index entry for this table // and do any special actions for certain index types INT32 Section; CMXReferMasterIndex *pMIE = new CMXReferMasterIndex(this); if(pMIE == NULL) return FALSE; BOOL NoMIE = FALSE; BOOL HasRecordCount = TRUE; BOOL CanOmit = FALSE; switch(Which) { case cmxDESC_ARROW: Section = CMXSECTION_ARROW; CanOmit = TRUE; pMIE->SetType(cmxMASTERIN_ARROW); HasRecordCount = FALSE; break; case cmxDESC_ARROWHEADS: Section = CMXSECTION_ARROWHEADS; pMIE->SetType(cmxMASTERIN_ARROWHEADS); break; case cmxDESC_COLOUR: Section = CMXSECTION_COLOUR; pMIE->SetType(cmxMASTERIN_COLOUR); break; case cmxDESC_DOTDASH: Section = CMXSECTION_DOTDASH; pMIE->SetType(cmxMASTERIN_DOTDASH); break; case cmxDESC_FONT: Section = CMXSECTION_FONT; pMIE->SetType(cmxMASTERIN_FONT); CanOmit = TRUE; HasRecordCount = FALSE; break; /* case cmxDESC_IMAGE: Section = CMXSECTION_IMAGE; pMIE->SetType(cmxMASTERIN_IMAGE); CanOmit = TRUE; HasRecordCount = FALSE; break; */ case cmxDESC_OUTLINE: Section = CMXSECTION_OUTLINE; pMIE->SetType(cmxMASTERIN_OUTLINE); break; case cmxDESC_LINESTYLE: Section = CMXSECTION_LINESTYLE; pMIE->SetType(cmxMASTERIN_LINESTYLE); break; case cmxDESC_PEN: Section = CMXSECTION_PEN; pMIE->SetType(cmxMASTERIN_PEN); break; case cmxDESC_SCREEN: Section = CMXSECTION_SCREEN; pMIE->SetType(cmxMASTERIN_SCREEN); break; default: ERROR3("Don't know what type of desc to write!"); } // scan the refer list and see how many entries we've got, and how long they are WORD Entries = 0; CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); if(pEn->IsInWhichDesc() == Which) { Entries++; } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } // do we need to save this section? if(Entries == 0 && CanOmit) { delete pMIE; // delete the record return TRUE; // don't do anything } // add this section to the master entry list if(NoMIE) { delete pMIE; // don't need this } else { ReferList.AddTail(pMIE); } // start the section, and maybe write a record count if(!StartSection((CMXExportDC::CMXSectionType)Section)) return FALSE; if(HasRecordCount) ExportFile->write(&Entries, sizeof(Entries)); // write record count // write the entries pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); if(pEn->IsInWhichDesc() == Which) { if(!pEn->WriteInDesc(this)) return FALSE; } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } // end the section if(!EndSection()) return FALSE; // done return TRUE; }

void CMXExportDC::WriteAngle (  double  theta  )

writes an angle to the file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 10/07/96 Parameters: angle,in  radians [INPUTS] Returns: - See also: Definition at line 1595 of file cmxexdc.cpp. { // Convert theta to be measured in degrees. theta = ( theta * 360.0 ) / ( 2.0 * PI ); // 32-bit export uses a larger scale factor. if(ThirtyTwoBit) { INT32 Angle32 = ( INT32 ) ( theta * 1000000.0 ); ExportFile->write ( &Angle32, sizeof ( Angle32 ) ); } else { short Angle16 = ( short ) ( theta * 10.0); ExportFile->write ( &Angle16, sizeof ( Angle16 ) ); } }

BOOL CMXExportDC::WriteAnIndex (  INT32  Which  )

writes the a particular index to the file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 2498 of file cmxexdc.cpp. { // size of the table -- special actions may add some stuff to it INT32 TableSize = sizeof(WORD); // for record count // get some types and sort out the master index entry for this table // and do any special actions for certain index types INT32 id; CMXReferMasterIndex *pMIE = new CMXReferMasterIndex(this); if(pMIE == NULL) return FALSE; BOOL NoMIE = FALSE; switch(Which) { case cmxINDEX_LAYER: { ERROR2IF(PageRefer == NULL, FALSE, "no page refer set up"); PageRefer->SetLayerTableOffset(GetFilePosition()); id = cmxRIFFCI_LayerIndex; NoMIE = TRUE; TableSize += sizeof(WORD); // for page number // add an entry for the master layer table CMXReferMasterLayer *pML = new CMXReferMasterLayer(this); if(pML == NULL) return FALSE; ReferList.AddTail(pML); // add it -- nothing else to set } break; case cmxINDEX_PAGE: id = cmxRIFFCI_PageIndex; pMIE->SetType(cmxMASTERIN_PAGE); break; case cmxINDEX_MASTERINDEX: // note the start of the index section in the file header IndexSectionFuture.Write(this); TableSize += sizeof(cmxMasterIndexHeader); id = cmxRIFFCI_MasterIndex; pMIE->SetType(cmxMASTERIN_MASTERIN); break; case cmxINDEX_MASTERLAYER: // remember this is single entry table and is fudged id = cmxRIFFCI_MasterLayerIndex; // in the refer list object pMIE->SetType(cmxMASTERIN_MASTERLAYER); break; case cmxINDEX_PROCEDURE: id = cmxRIFFCI_ProcIndex; pMIE->SetType(cmxMASTERIN_PROCEDURE); break; case cmxINDEX_EMBEDFILE: id = cmxRIFFCI_EmbeddedFileIndex; pMIE->SetType(cmxMASTERIN_EMBEDFILE); break; case cmxINDEX_ARROW: id = cmxRIFFCI_ArrowIndex; pMIE->SetType(cmxMASTERIN_ARROW); TableSize += sizeof(cmxArrowIndexHeader) + (ThirtyTwoBit?sizeof(WORD):0); break; default: ERROR3("Don't know what type of index to write!"); } if(NoMIE) { delete pMIE; // don't need this } else { ReferList.AddTail(pMIE); } // scan the refer list and see how many entries we've got, and how long they are WORD Entries = 0; CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); if(pEn->IsInWhichIndex() == Which) { Entries++; TableSize += pEn->IndexEntrySize(this); } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } if(Entries == 0) { // nothing to write -- go away now after removing the entry from the master index delete ReferList.RemoveItem(pMIE); return TRUE; } // write the header RIFFck ck; ck.ckID = id; ck.ckSize = TableSize; ExportFile->write(&ck, sizeof(ck)); if(Which == cmxINDEX_MASTERINDEX) { // write it's special header cmxMasterIndexHeader mih = {cmxMASTERIN_MASTERIN, ThirtyTwoBit?0xfff:0x18}; ExportFile->write(&mih, sizeof(mih)); } ExportFile->write(&Entries, sizeof(Entries)); // write record count // do specials switch(Which) { case cmxINDEX_LAYER: { WORD PageNumber = 1; ExportFile->write(&PageNumber, sizeof(PageNumber)); } break; case cmxINDEX_ARROW: { cmxArrowIndexHeader aih; WriteSizeInFile(sizeof(cmxArrowIndexEntry)); aih.Type = cmxARROWINDEXTYPE; ExportFile->write(&aih, sizeof(aih)); } break; default: break; } // write the entries pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); if(pEn->IsInWhichIndex() == Which) { if(!pEn->WriteInIndex(this)) return FALSE; } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } // if necessary, word align the thingy if((GetFilePosition() & 1) != 0) { // put an extra byte in the file ExportFile->put('\0'); } // done return TRUE; }

BOOL CMXExportDC::WriteAttrCheckIgnoreLens (  CMXRenderRegion *  pReg, DocCoord *  Coords, INT32  NumCoords )

checks to see if we should ignore this lens -- it sees if it's going to overlap with too many lenses. This is basically as bodge as CorelDRAW will just fall over if we export a file with lots of overlapped lenses in it. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/96 Parameters: region,coords,num  coords [INPUTS] Returns: whether to ignore a lens on this object Definition at line 2099 of file cmxdcobj.cpp. { // first thing, find the bbox of the object we're about to lens to DocRect BBox; CalcCorelBBox(Coords, NumCoords, &BBox); // now search the list to see how many existing lenses intersect with it INT32 LensesBehindThisOne = 0; CMXLensBBox *pEn = (CMXLensBBox *)LensBBoxes.GetHead(); while(pEn != 0) { // check for intersection if(pEn->DoesIntersect(&BBox)) LensesBehindThisOne++; // next, please pEn = (CMXLensBBox *)LensBBoxes.GetNext(pEn); } // make up a new object to add to the nice list thingy CMXLensBBox *pNewLensBBox = new CMXLensBBox(&BBox); if(pNewLensBBox != NULL) LensBBoxes.AddTail(pNewLensBBox); // do we want to ignore this? if(LensesBehindThisOne > CMX_MAX_OVERLAP_LENSES) { TRACEUSER( "Ben", _T("found transparency to ignore, %d lenses behind\n"), LensesBehindThisOne); // maybe we could ask the user if it wanted to ignore the overlapped things if(!AreIgnoreingOverlappedLenses && !HaveAskedUserAboutLenses) { HaveAskedUserAboutLenses = TRUE; INT32 Result = InformWarning(_R(IDW_CMXOVERLAPPEDLENS), _R(IDB_CMXDOLENSES), _R(IDB_CMXIGNORELENSES), 0, 0, 2, 1); switch(Result) { case 1: //_R(IDB_CMXDOLENSES): AreIgnoreingOverlappedLenses = FALSE; break; case 2: //_R(IDB_CMXIGNORELENSES): default: AreIgnoreingOverlappedLenses = TRUE; break; } } // ignore it? if(AreIgnoreingOverlappedLenses) { // OK, we've got to ignore this -- mark the fact OverlappedLensesHaveBeenIgnored = TRUE; return TRUE; // ignore it } } return FALSE; // don't ignore this one }

BOOL CMXExportDC::WriteAttrCheckLens (  CMXRenderRegion *  pReg, INT32  Tag, DocCoord *  Coords, INT32  NumCoords, BOOL *  WasLens )

checks to see if this object should be outputed as a lens. If so, we need to output the attributes for it ourselves (as we can't use the full range of possible things) and add things to the list Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 12/07/96 Parameters: render  region, tag, pointer to flag [INPUTS] Returns: error flag Definition at line 1932 of file cmxdcobj.cpp. { // set the flag for no lens *WasLens = FALSE; // get the transparency attr TranspFillAttribute *pTra = (TranspFillAttribute *)pReg->GetCurrentAttribute(ATTR_TRANSPFILLGEOMETRY); // check it out if(pTra == NULL) { TRACEUSER( "Ben", _T("No transparent fill attribute -- assuming it's not transparent\n")); return TRUE; } ERROR3IF(!pTra->IsKindOf(CC_RUNTIME_CLASS(TranspFillAttribute)), "not a transparent fill attribute"); // right then, let's work out what transparency value we've got here UINT32 TransparencyValue = 0; if(pTra->IsAFlatFill()) { TransparencyValue = *pTra->GetStartTransp(); } else { // average the start and end values TransparencyValue = (*pTra->GetStartTransp() + *pTra->GetEndTransp()) / 2; } // check to see if we really want to do this thingy if (TransparencyValue == 0) return TRUE; // nothing to do, it's not transparent TRACEUSER( "Ben", _T("transparent, has value %d\n"), TransparencyValue); // OK, do we want to ignore this lens to stop CorelDRAW from dieing when we import the file if(WriteAttrCheckIgnoreLens(pReg, Coords, NumCoords)) { // yes, ignore the damn thing return TRUE; } // transparency has the range 0-255 in Cam, but 0-1000 in CMX WORD UniformRate = 1000 - ((TransparencyValue * 1000) / 255); // the value to export // now we need to work out what colour the thingy will be WORD ColourReference = 1; // nice default value // get the attribute FillGeometryAttribute *pFillGeometry = (FillGeometryAttribute *)pReg->GetCurrentAttribute(ATTR_FILLGEOMETRY); // check it out ERROR2IF(pFillGeometry == 0, FALSE, "No fill geometry"); ERROR3IF(!pFillGeometry->IsKindOf(CC_RUNTIME_CLASS(FillGeometryAttribute)), "not one of them there fill geometries"); // get the start colour of the attribute DocColour *pColour = pFillGeometry->GetStartColour(); if(pColour != 0 && !pColour->IsTransparent()) { // get a reference for this nice colour ColourReference = GetColourReference(pColour); } // right then, we now need to create one of those lens refer list items CMXReferLens *pLens = new CMXReferLens(this); if(pLens == NULL) return FALSE; // get the bounding box DocRect bb; CalcCorelBBox(Coords, NumCoords, &bb); // set up the lens list item if(!pLens->Set(this, &bb)) return FALSE; // add it to the list ReferList.AddTail(pLens); // right then, we now need to write some attributes to the file // start the tag if(Tag != -1) if(!StartTag(Tag)) return FALSE; // write the attribute mask thingy WriteByte(cmxRENDATTRMASK_FILL | cmxRENDATTRMASK_OUTLINE | cmxRENDATTRMASK_LENS); // write the fill specification if(!StartNestedTag(cmxTAG_RenderAttr_FillSpec) ||!WriteFillType(cmxFILLID_UNIFORM)) return FALSE; struct { WORD FillReference; WORD ScreenReference; } filldef = {ColourReference, cmxSCREENREFERENCE}; if(!WriteNestedTag(cmxTAG_RenderAttr_FillSpec_Uniform, &filldef, sizeof(filldef)) || !WriteMinEndTag() || !EndNestedTag() || !WriteMinEndTag()) return FALSE; // write the outline specification if(!WriteOutlineSpec(pReg)) return FALSE; // and write the lens specification cmxGlassLensDefn lendef; lendef.LensType = cmxLENSTYPE_GLASS; switch(pTra->GetTranspType()) { default: lendef.TintMethod = cmxLENSTINTMETH_AVERAGE; break; case TT_StainGlass: lendef.TintMethod = cmxLENSTINTMETH_SUBTRACT; break; case TT_Bleach: lendef.TintMethod = cmxLENSTINTMETH_ADD; break; } lendef.UniformRate = UniformRate; lendef.ColourReference = ColourReference; lendef.RangeProcReference = GetProcedureReference(pLens); if(!WriteNestedTag(cmxTAG_RenderAttr_LensSpec_Base, &lendef, sizeof(lendef))) return FALSE; if(ThirtyTwoBit) { cmxLensFrozView fv; // no idea what this is fv.FlagFrozen = 0; fv.FlagActive = 0; fv.ViewPointX = 0; fv.ViewPointY = 0; if(!WriteNestedTag(cmxTAG_RenderAttr_LensSpec_FrozViewp, &fv, sizeof(fv)) || !WriteMinEndTag()) return FALSE; } // end the tag if(Tag != -1) if(!EndTag()) return FALSE; // tell the caller that we did something *WasLens = TRUE; // set the page flag to say we had a lens SetCMXFlag(cmxSTRUCTFLAGS_HASLENS); return TRUE; }

BOOL CMXExportDC::WriteAttributes (  CMXRenderRegion *  pReg, INT32  Tag, DocCoord *  Coords, INT32  NumCoords, BOOL  ForceNoFill = FALSE )

Writes the attributes to the DC. if ForceNoFill == TRUE, the path will not be filled whatever the colour. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 01/07/96 Parameters: render  region [INPUTS] Returns: success Definition at line 158 of file cmxdcobj.cpp. { // give lenses a chance BOOL WasLens = FALSE; if(!WriteAttrCheckLens(pReg, Tag, Coords, NumCoords, &WasLens)) return FALSE; // now did the lens checking bit output something? if(WasLens) return TRUE; // yep, so we don't want to output them too // start the tag if(Tag != -1) if(!StartTag(Tag)) return FALSE; // write the attribute mask thingy WriteByte((ForceNoFill?0:cmxRENDATTRMASK_FILL) | cmxRENDATTRMASK_OUTLINE); // write the fill specification if(!ForceNoFill) if(!WriteFillSpec(pReg, Coords, NumCoords, ForceNoFill)) return FALSE; // write the outline specification if(!WriteOutlineSpec(pReg)) return FALSE; // end the tag if(Tag != -1) if(!EndTag()) return FALSE; return TRUE; }

BOOL CMXExportDC::WriteBBox (  DocRect *  BBox, BOOL  Transform = TRUE )

Write a bounding box to the file. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1553 of file cmxexdc.cpp. { ERROR2IF(pMatrix == NULL, FALSE, "No matrix"); if(ThirtyTwoBit) { DocRect bb = *BBox; if(Transform) pMatrix->TransformBounds(&bb); cmxBBox32 b = {bb.lo.x, bb.hi.y, bb.hi.x, bb.lo.y}; ExportFile->write(&b, sizeof(b)); } else { DocRect bb = *BBox; if(Transform) pMatrix->TransformBounds(&bb); cmxBBox16 b = {(SWORD)bb.lo.x, (SWORD)bb.hi.y, (SWORD)bb.hi.x, (SWORD)bb.lo.y}; ExportFile->write(&b, sizeof(b)); } return TRUE; }

BOOL CMXExportDC::WriteBitmap (  KernelBitmap *  pBitmap, DocCoord *  pParallelogram, CMXBitmapColourSource  ColSource = CMXBITMAPCOLOURSOURCE_NONE, BOOL  TransformParallelogram = TRUE, WORD  BitmapReference = 0 )

writes a bitmap object to the file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 15/07/96 Parameters: render  region, bitmap, parllelogram for the bitmap [INPUTS] Returns: success See also: Definition at line 2469 of file cmxdcobj.cpp. { // sort out some colours for contoning the bitmap DocColour *pStartColour = 0; DocColour *pEndColour = 0; EFFECTTYPE Effect = EFFECT_RGB; // we have three possible methods for getting some colours... switch(ColSource) { case CMXBITMAPCOLOURSOURCE_FILLGEOMETRY: ERROR2(FALSE, "fill geometry bitmap colour source not implemented"); break; case CMXBITMAPCOLOURSOURCE_LINEANDFILL: { // right then, we get the start colour from the line effect // get the attribute StrokeColourAttribute *pColA = (StrokeColourAttribute *)pRenderRegion->GetCurrentAttribute(ATTR_STROKECOLOUR); // check it out ERROR2IF(pColA == 0, FALSE, "No stroke colour attribute"); ERROR3IF(!pColA->IsKindOf(CC_RUNTIME_CLASS(StrokeColourAttribute)), "not a stroke colour attribute"); pStartColour = pColA->GetStartColour(); // check to see if we need to do contoning if(pStartColour != 0 && pStartColour->IsTransparent()) pStartColour = 0; // get the end colour from a fill attribute if(pStartColour != 0) { // get the attribute FillGeometryAttribute *pFillGeometry = (FillGeometryAttribute *)pRenderRegion->GetCurrentAttribute(ATTR_FILLGEOMETRY); // check it out ERROR2IF(pFillGeometry == 0, FALSE, "No fill geometry"); ERROR3IF(!pFillGeometry->IsKindOf(CC_RUNTIME_CLASS(FillGeometryAttribute)), "not one of them there fill geometries"); // get the start colour of the fill attribute pEndColour = pFillGeometry->GetStartColour(); if(pEndColour == NULL || pEndColour->IsTransparent()) { // no end colour -- can't be contoned then pStartColour = 0; pEndColour = 0; } else { // get the fill effect Effect = pRenderRegion->GetFillEffect(); } } } break; default: case CMXBITMAPCOLOURSOURCE_NONE: break; // do nothing } // get a reference number for the bitmap WORD BitmapRef = 0; if(pBitmap == 0) { BitmapRef = BitmapReference; } else { BitmapRef = GetBitmapReference(pBitmap, pStartColour, pEndColour, Effect); } if(BitmapRef == 0) return TRUE; // if it isn't able to be got, sod it. // make a new transformed parallelogram thingy DocCoord Para[4]; ERROR2IF(pMatrix == NULL, FALSE, "no matrix"); for(INT32 z = 0; z < (sizeof(Para) / sizeof(DocCoord)); z++) { Para[z] = pParallelogram[z]; if(TransformParallelogram) pMatrix->transform(&(Para[z])); } // begin the command if(!StartCommand(cmxINSTR_DrawImage)) return FALSE; // output the rendering attributes if(!WriteBlankAttributes(cmxTAG_DrawImage_RenderingAttr)) return FALSE; // write the image data if(!StartTag(cmxTAG_DrawImage_DrawImageSpecification)) return FALSE; // image extent and cropping rectangle, in pixels DocRect ImEx; if(ThirtyTwoBit) { ImEx.lo.x = ImEx.lo.y = 0; ImEx.hi.x = 2048; ImEx.hi.y = 2048; } else { ImEx.lo.x = 0; ImEx.lo.y = -2048; ImEx.hi.x = 2048; ImEx.hi.y = 0; } if(!WriteBBox(&ImEx, FALSE) || !WriteBBox(&ImEx, FALSE)) return FALSE; // construct a transformation matrix -- no point in going through the write matrix fn double magX = 2048.0; double magY = 2048.0; cmxMatrix Matrix = {cmxMATRIXTYPE_GENERAL, (double)(Para[2].x - Para[3].x) / magX, (double)(Para[2].y - Para[3].y) / magY, (double)(Para[0].x - Para[3].x) / magX, (double)(Para[0].y - Para[3].y) / magY, Para[3].x, Para[3].y}; if(!ThirtyTwoBit) { // add correction for bitmapnesses in 16 bit CMX files Matrix.f += Matrix.d * 2048; } // save out the matrix ExportFile->write(&Matrix, sizeof(Matrix)); // other bits and pieces cmxDrawImageEndBits eb; eb.ImageType = cmxDRAWIMAGE_IMAGETYPE_COLOUR; eb.FileRef1 = BitmapRef; eb.FileRef2 = 0; // nothing associated with this if(!WriteData(&eb, sizeof(eb))) return FALSE; // end the specification thingy if(!EndTag()) return FALSE; // end the command if(!WriteMinEndTag() || !EndCommand()) return FALSE; return TRUE; }

BOOL CMXExportDC::WriteBlankAttributes (  INT32  Tag  )

writes a blank attribute tag and contents, which specifies nothing but keeps everything happy Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 16/07/96 Parameters: render  region [INPUTS] Returns: success Definition at line 126 of file cmxdcobj.cpp. { // start the tag if(Tag != -1) if(!StartTag(Tag)) return FALSE; // write the attribute mask thingy WriteByte(0); // end the tag if(Tag != -1) if(!EndTag()) return FALSE; return TRUE; }

void CMXExportDC::WriteByte (  BYTE  Thing  )  [inline]

Definition at line 283 of file cmxexdc.h. {ExportFile->put(Thing);}; // will exception not return false

BOOL CMXExportDC::WriteCamComment (  void   )

writes a helpful comment so we can see where dodgy cam cmx files come from Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 01/08/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 2401 of file cmxexdc.cpp. { if(PageIsProc) return TRUE; // only write comments in pages CCamApp* Application; String_64 Text; String_256 TheText = String_256("saved from " PRODUCT_NAME " "); // WEBSTER - markn 26/11/96 // munge an info string together Application = (CCamApp*) AfxGetApp(); // Find our main application object Application->GetCamelotVersion(&Text); Text += TEXT("(v"); Text += TEXT(PRODUCT_VERSION_NO); Text += TEXT(")"); TheText += Text; // Text.MakeMsg(_R(IDS_CAMVERSION), &Text1); Text._MakeMsg(TEXT(" (#1%d) "), (INT32) CAMELOT_VERSION_MINOR); TheText += Text; Application->GetCamelotType(&Text); TheText += Text; TheText += " on "; Application->GetHostOSName(&Text); // ... plonk info from it into the dlog TheText += Text; TRACEUSER( "Ben", _T("setting comment = %s\n"), (TCHAR *)TheText); // now start a command and a tag if(!StartCommand(cmxINSTR_Comment) || !StartTag(cmxTAG_Comment_CommentSpecification)) return FALSE; WORD Size = TheText.Length(); ExportFile->write(&Size, sizeof(Size)); ExportFile->write((TCHAR *)TheText, Size); // end the command if(!EndTag() || !WriteMinEndTag() || !EndCommand()) return FALSE; return TRUE; }

BOOL CMXExportDC::WriteCommand (  UINT32  Tag, void *  Data = 0, UINT32  Size = 0 )

Write a command to the file -- one off operation, writes command and data in one go. Use default params for a no-data command. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 18/6/96 Parameters: Tag  for the command, the data, and the size [INPUTS] Returns: success See also: Definition at line 1284 of file cmxexdc.cpp. { ERROR2IF(DoingCommand != FALSE, FALSE, "Already writing a command"); // write the header cmxInstrHdr hdr = {Size + sizeof(hdr), ThirtyTwoBit?Tag:(0 - (SWORD)Tag)}; // word align the size if((hdr.Size & 1) != 0) hdr.Size++; ExportFile->write(&hdr, sizeof(hdr)); if(Size != 0) { ERROR2IF(Data == 0, FALSE, "didn't get some data"); // write the command ExportFile->write(Data, Size); } Tally++; PageInstructionCount++; LayerInstructionCount++; // word align the file if((/*GetFilePosition()*/ Size & 1) != 0) { // put an extra byte in the file ExportFile->put('\0'); } return TRUE; }

BOOL CMXExportDC::WriteData (  void *  data, INT32  Size )  [inline]

Definition at line 282 of file cmxexdc.h. {ExportFile->write(data, Size); return TRUE;};

BOOL CMXExportDC::WriteDescriptionSections (  void   )

Definition at line 2699 of file cmxexdc.cpp. { WRITEDESC(cmxDESC_ARROW) WRITEDESC(cmxDESC_ARROWHEADS) WRITEDESC(cmxDESC_DOTDASH) WRITEDESC(cmxDESC_FONT) WRITEDESC(cmxDESC_OUTLINE) WRITEDESC(cmxDESC_LINESTYLE) WRITEDESC(cmxDESC_PEN) WRITEDESC(cmxDESC_SCREEN) WRITEDESC(cmxDESC_COLOUR) return TRUE; }

BOOL CMXExportDC::WriteFillSpec (  CMXRenderRegion *  pReg, DocCoord *  Coords, INT32  NumCoords, BOOL  NoFill )

Writes the fill specifcation to the DC. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 04/07/96 Parameters: render  region [INPUTS] Returns: success Definition at line 227 of file cmxdcobj.cpp. { // tag the start if(!StartNestedTag(cmxTAG_RenderAttr_FillSpec)) return FALSE; if(NoFill) { if(!WriteFillType(cmxFILLID_NONE)) return FALSE; } else { // get the attribute FillGeometryAttribute *pFillGeometry = (FillGeometryAttribute *)pReg->GetCurrentAttribute(ATTR_FILLGEOMETRY); // check it out ERROR2IF(pFillGeometry == 0, FALSE, "No fill geometry"); ERROR3IF(!pFillGeometry->IsKindOf(CC_RUNTIME_CLASS(FillGeometryAttribute)), "not one of them there fill geometries"); // right then, decide what to do with the thingy if(pFillGeometry->IsAFlatFill()) { // flat fill -- check to see if it's transparent DocColour *pCol = pFillGeometry->GetStartColour(); ERROR2IF(pCol == NULL, FALSE, "not one of your earth colours"); if(pCol->IsTransparent()) { // it's transparent, write no fill if(!WriteFillType(cmxFILLID_NONE)) return FALSE; } else { // it's OK, it is. Write it. if(!WriteFillType(cmxFILLID_UNIFORM) || !WriteFillSpecFlat(pReg, pFillGeometry)) return FALSE; } } else if(pFillGeometry->IsAKindOfBitmapFill()) { // bitmap type fill -- do nothing for now if(!WriteFillType(9) //cmxFILLID_COLPATTERN) || !WriteFillSpecBitmap(pReg, pFillGeometry, Coords, NumCoords)) return FALSE; } else if(pFillGeometry->IsAGradFill()) { // grad fill if(!WriteFillType(cmxFILLID_FOUNTAIN) || !WriteFillSpecGrad(pReg, pFillGeometry, Coords, NumCoords)) return FALSE; } else { // catch all -- write a no fill thingy if(!WriteFillType(cmxFILLID_NONE)) return FALSE; } } // end the tag if(!EndNestedTag()) return FALSE; // write the end tag if(!WriteMinEndTag()) return FALSE; return TRUE; }

BOOL CMXExportDC::WriteFillSpecBitmap (  CMXRenderRegion *  pReg, FillGeometryAttribute *  pFill, DocCoord *  Coords, INT32  NumCoords )

Writes the bitmap fill specifcation to the DC (also does fractals). Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: render  region [INPUTS] Returns: success Definition at line 838 of file cmxdcobj.cpp. { // make up a bitmap fill object -- first find the refer bitmap object necessary BitmapFillAttribute *pBFillAttr = (BitmapFillAttribute *)pFill; ERROR3IF(!pBFillAttr->IsKindOf(CC_RUNTIME_CLASS(BitmapFillAttribute)), "not a bitmap fill attr"); // colours DocColour *pStartColour = 0; DocColour *pEndColour = 0; EFFECTTYPE Effect = EFFECT_RGB; // get the colours we should use, and the fill effect pStartColour = pFill->GetStartColour(); pEndColour = pFill->GetEndColour(); if(pStartColour == 0 || pEndColour == 0 || pStartColour->IsTransparent() || pEndColour->IsTransparent()) { pStartColour = 0; pEndColour = 0; } if(pStartColour != 0) { // get the fill effect Effect = pReg->GetFillEffect(); } // get the reference for the bitmap KernelBitmap *pBitmap = pBFillAttr->BitmapRef.GetBitmap(); WORD BitmapRef = GetBitmapReference(pBitmap, pStartColour, pEndColour, Effect); // make a new bitmap fill object CMXReferBitmapFill *pBFill = new CMXReferBitmapFill(this); if(pBFill == 0) return FALSE; pBFill->Set(BitmapRef); // add it to the refer list ReferList.AddTail(pBFill); // get it's reference WORD BitmapFillProcReference = GetProcedureReference(pBFill); // ready to write... if(!StartNestedTag(cmxTAG_RenderAttr_FillSpec_ColorBM)) return FALSE; ExportFile->write(&BitmapFillProcReference, sizeof(BitmapFillProcReference)); // write tiling if(!StartNestedTag(cmxTAG_Tiling)) return FALSE; // get points from the attribute DocCoord *Start = pFill->GetStartPoint(); DocCoord *End1 = pFill->GetEndPoint(); DocCoord *End2 = pFill->GetEndPoint2(); // get a tiling structure cmxTilingEnd tile; // Variables for rendering the texture to the file. I've deferred the scaling of // the image until it's written. It's slightly ugly doing it this way, but it // removes a few multipications, and so should get rid of some rounding errors // along the way. DocRect cBBox; double TileWidth = Start->Distance ( *End1 ); double TileHeight = Start->Distance ( *End2 ); // Calculate the untransformed Corel bounding box. CalcCorelBBox(Coords, NumCoords, &cBBox); // Graeme (9-5-00) - I've simplified Ben's code a little, and removed the // repeated bits in both branches of the if statement. if ( ThirtyTwoBit ) { cmxTilingBegin32 Tile32; Tile32.Width = static_cast<DWORD> ( Round ( TileWidth * ScaleFactor ) ); Tile32.Height = static_cast<DWORD> ( Round ( TileHeight * ScaleFactor ) ); WriteData ( &Tile32, sizeof ( Tile32 ) ); } else { cmxTilingBegin16 Tile16; Tile16.Width = static_cast<WORD> ( Round ( TileWidth * ScaleFactor ) ); Tile16.Height = static_cast<WORD> ( Round ( TileHeight * ScaleFactor ) ); WriteData ( &Tile16, sizeof ( Tile16 ) ); } // now work out the offsets to the start of the tile double dX = static_cast<double> ( Start->x - cBBox.lo.x ); double dY = static_cast<double> ( cBBox.hi.y - Start->y ); // Graeme (9-5-00) - Round the offset up. tile.XOffset = ( static_cast<WORD> ( Round ( ( dX * 100.0 ) / TileWidth ) ) ) % 100; tile.YOffset = ( static_cast<WORD> ( Round ( ( dY * 100.0 ) / TileHeight ) ) ) % 100; tile.InterTileOffset = tile.TilingFlags = 0; // write the structure to the file ExportFile->write(&tile, sizeof(tile)); if(!EndNestedTag() || !WriteMinEndTag()) return FALSE; // bounding box of bit to use DocRect bbox = DocRect(0, 0, cmxBITMAPFILLTILESIZE_X, cmxBITMAPFILLTILESIZE_Y); if(!WriteBBox(&bbox, FALSE)) return FALSE; if(!EndNestedTag() || !WriteMinEndTag()) return FALSE; return TRUE; }

BOOL CMXExportDC::WriteFillSpecFlat (  CMXRenderRegion *  pReg, FillGeometryAttribute *  pFill )

Writes the flat fill specifcation to the DC. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 04/07/96 Parameters: render  region [INPUTS] Returns: success Definition at line 313 of file cmxdcobj.cpp. { // get the colour DocColour *pFillColour = pFill->GetStartColour(); ERROR2IF(pFillColour == NULL, FALSE, "Wibble. No fill colour on this here flat fill"); // find a reference for it WORD FillReference = GetColourReference(pFillColour); // write some stuff struct { WORD FillReference; WORD ScreenReference; } filldef = {FillReference, cmxSCREENREFERENCE}; if(!WriteNestedTag(cmxTAG_RenderAttr_FillSpec_Uniform, &filldef, sizeof(filldef)) || !WriteMinEndTag()) return FALSE; return TRUE; }

BOOL CMXExportDC::WriteFillSpecGrad (  CMXRenderRegion *  pReg, FillGeometryAttribute *  pFill, DocCoord *  Coords, INT32  NumCoords )

Writes the grad fill specifcation to the DC. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 10/07/96 Parameters: render  region [INPUTS] Returns: success Definition at line 351 of file cmxdcobj.cpp. { DocColour StartColour; // The first colour in the fill. DocColour EndColour; // The end colour of the fill. DocColour MidColour; // Only used to approximate four colour fills. BOOL Radial = FALSE; // Is it a radial fill? BOOL FourColour = FALSE; // Is it a four colour fill? // is this a radial type derivative? if ( pFill->IsARadialFill () ) { // We need to swap the colours over as Corel has a different idea // of start and finish colours to Camelot. StartColour = *( pFill->GetEndColour () ); EndColour = *( pFill->GetStartColour () ); Radial = TRUE; } else if ( pFill->IsAConicalFill () || pFill->IsASquareFill () ) { // Set up the colour values. StartColour = *( pFill->GetStartColour () ); EndColour = *( pFill->GetEndColour () ); Radial = TRUE; } else if ( pFill->IsAFourColFill () ) { // Set up the start and end colours as usual, but create a third colour value to // help fake the four colour fill. StartColour = *( pFill->GetStartColour () ); EndColour = *( pFill->GetEndColour3 () ); MidColour.Mix ( pFill->GetEndColour (), pFill->GetEndColour2 (), 0.5f, NULL, FALSE, NULL ); // Reset the four colour flag. FourColour = TRUE; } else if ( pFill->IsAThreeColFill () ) { // Set up the colour values. I'm blending the colours of the two endpoints // to get a better approximation of a three colour fill. StartColour = *( pFill->GetStartColour () ); EndColour.Mix ( pFill->GetEndColour (), pFill->GetEndColour2 (), 0.5f, NULL, FALSE, NULL ); } else { // Default behaviour: Store the start and end colours. StartColour = *( pFill->GetStartColour () ); EndColour = *( pFill->GetEndColour () ); } // Find references for the color, and sort out the fill effect. WORD StartColReference = GetColourReference ( &StartColour ); WORD EndColReference = GetColourReference ( &EndColour ); WORD MidColReference = 0; WORD FillMode = cmxFILLMODE_RGB; // Get a colour reference to MidColour if it's been declared. (i.e. the fill is a // four colour fill.) if ( FourColour ) { MidColReference = GetColourReference ( &MidColour ); } // get the fill effect attribute FillEffectAttribute *pFillEff = (FillEffectAttribute *)pReg->GetCurrentAttribute(ATTR_FILLEFFECT); ERROR2IF(pFillEff == NULL || !pFillEff->IsKindOf(CC_RUNTIME_CLASS(FillEffectAttribute)), FALSE, "not a fill effect"); BOOL Rainbow = FALSE, Alt = FALSE; if(IS_A(pFillEff, FillEffectRainbowAttribute)) Rainbow = TRUE; if(IS_A(pFillEff, FillEffectAltRainbowAttribute)) Rainbow = Alt = TRUE; if(Rainbow) { // right, we need to work out which direction we want the colour to go // around the HSV colour wheel. Convert both colours to HSV. ColourContext *Conv = ColourContext::GetGlobalDefault(COLOURMODEL_HSVT); ColourHSVT StartC; ColourHSVT EndC; Conv->ConvertColour( &StartColour, (ColourGeneric *)&StartC); Conv->ConvertColour( &EndColour, (ColourGeneric *)&EndC); // compare the hues and work out a difference double Difference = (EndC.Hue.MakeDouble()) - (StartC.Hue.MakeDouble()); BOOL ClockWise = (Difference < 0); if(fabs(Difference) >= 0.5) ClockWise = !ClockWise; if(Alt = TRUE) ClockWise = !ClockWise; // set the correct thingy attribute if(ClockWise) FillMode = cmxFILLMODE_HSB_CW; else FillMode = cmxFILLMODE_HSB_CCW; } // find the start and end coords of the fill DocCoord StartPoint = *( pFill->GetStartPoint() ); DocCoord EndPoint; // Graeme (18-2-00) - Modifications to handle three and four colour fills better. if ( pFill->IsAFourColFill () ) { // Use EndPoint3 to get a diagonal across the bounding box. EndPoint = *( pFill->GetEndPoint3 () ); } else if ( pFill->IsAThreeColFill () ) { // Merge the existing two endpoints to get the correct endpoint for the fill. EndPoint = *( pFill->GetEndPoint () ) + *( pFill->GetEndPoint2 () ) - *( pFill->GetStartPoint () ); } else { // Default: Use the standard endpoint. EndPoint = *( pFill->GetEndPoint () ); } // find the corel bounding box of the path we're about to fiddle with DocRect cBBox; CalcCorelBBox(Coords, NumCoords, &cBBox); // run the chicken out clause for extreme cases I can't be bothered to handle if ( StartPoint == EndPoint || cBBox.Width () == 0 || cBBox.Height () == 0 ) return WriteFillSpecFlat(pReg, pFill); // calc the central coord DocCoord Centre; Centre.x = cBBox.lo.x + cBBox.Width() / 2; Centre.y = cBBox.lo.y + cBBox.Height() / 2; // calc the fill parameters // first work out the distance between the start and end points double dx = EndPoint.x - StartPoint.x; double dy = EndPoint.y - StartPoint.y; double PointDist = sqrt(((dx * dx) + (dy * dy))); // now we need to work out the angle of the fill double Angle = atan2(dy, dx); // atan2 is defined if dx == 0 // but not at the origin -- however we've filtered out this case INT32 StartPercent; INT32 EndPercent; cmxFillBase1 fb1; fb1.Padding = 0; cmxFillBase2 fb2; fb2.XOffset = 0; fb2.YOffset = 0; if(Radial) { //------------------------------------------------- radial type fill calucations // ...and for my first trick, I will calculate the X and Y // offsets of the centre of this fill DocCoord dCentre = StartPoint - Centre; fb2.XOffset = (dCentre.x * 100) / cBBox.Width(); fb2.YOffset = (dCentre.y * 100) / cBBox.Height(); // get these values within the required range if(fb2.XOffset > 100) fb2.XOffset = 100; if(fb2.XOffset < -100) fb2.XOffset = -100; if(fb2.YOffset > 100) fb2.YOffset = 100; if(fb2.YOffset < -100) fb2.YOffset = -100; // now this is the scary bit. Corel use a complex method for specifing // their radial type fills. double w = cBBox.Width(), h = cBBox.Height(); double bboxdiagonal = sqrt(w*w + h*h); double cdx = dCentre.x, cdy = dCentre.y; double cendist = sqrt(cdx*cdx + cdy*cdy); double BodgeFactor = 1 + (cendist / (bboxdiagonal / 2)); double targetradius = PointDist / BodgeFactor; double Pad = 50 * (1 - (2 * targetradius) / bboxdiagonal); // munge the Pad value to the allowed range if(Pad < 0) Pad = 0; if(Pad > 44) Pad = 44; // and bung in the structure for export fb1.Padding = (WORD)Pad; // set the percentages to 0 StartPercent = 0; EndPercent = 0; // if it's a square fill, swap the colours over if(pFill->IsASquareFill()) { WORD t = StartColReference; StartColReference = EndColReference; EndColReference = t; } } // if ( Radial ) else // if ( !Radial ) { //------------------------------------------------- linear type fill calucations // now work out the coords of the intersection of a line through the // centre of the bbox and the edges of the bbox // right then, we want the angle within 0 and PI/2 double cAngle = Angle; INT32 cAR = 0; while(cAngle > (PI/2)) { cAngle -= PI/2; cAR++; } // luckily, everything is symmetrical so all we need do is calc the // intersect in the top quadrant. INT32 qdx = cBBox.Width() / 2; INT32 qdy = cBBox.Height() / 2; if((cAR & 1) != 0) { // we rotated by an odd multiple of PI/2 radians. Rotate the box as well. INT32 t = qdy; qdy = qdx; qdx = t; } DocCoord i; if(qdy == 0) { // special case to avoid division by tan(0) = 0 i.x = qdx; i.y = 0; } else { double predqdy = qdx * tan(cAngle); if(predqdy > qdy) { // intersects on the horizontal i.x = (INT32)(((double)qdy) / tan(cAngle)); i.y = qdy; } else { // intersects on the vertical i.x = qdx; i.y = (INT32)(((double)qdx) * tan(cAngle)); } } // i is the offset from the centre of the bbox where the line of the // grad fill rotated to the top right quadrent intersects with the // rectange of the bounding box. // now we need to work out the percentages along this line of the start // and stop bit. INT32 linelength = (INT32)sqrt(((double)(i.x) * (double)(i.x)) + ((double)(i.y) * (double)(i.y))); // chicken out clause #2 if(linelength == 0) return WriteFillSpecFlat(pReg, pFill); // work out the start and end points as offsets from the centre point DocCoord dStartPoint = StartPoint - Centre; DocCoord dEndPoint = EndPoint - Centre; // rotate these points around the origin // TODO: do the rotation myself, instead of going through matrices Matrix Mat(((- Angle) * 360.0) / (2*PI)); // why can't people use proper measure? Mat.transform(&dStartPoint); Mat.transform(&dEndPoint); // find out the smallest distance from the end of the line INT32 dStart = dStartPoint.x + linelength; INT32 dEnd = linelength - dEndPoint.x; if(dStart < 0) dStart = 0; if(dEnd < 0) dEnd = 0; INT32 dPad; // smallest of dStart and dEnd if(dStart < dEnd) dPad = dStart; else dPad = dEnd; INT32 padval = (dPad * 100) / (linelength * 2); if(padval < 0) padval = 0; if(padval > 44) padval = 44; fb1.Padding = (WORD)padval; // right, now munge the line length value to take account of this padding linelength -= dPad; // right then, we can now simply compare the x coords of the start and end // with the linelength above to find the start and end percentages StartPercent = (INT32)((dStartPoint.x + linelength) * 100); EndPercent = (INT32)((dEndPoint.x + linelength) * 100); StartPercent /= (linelength * 2); EndPercent /= (linelength * 2); // sanity check the numbers so Corel is happy if(StartPercent < 0) StartPercent = 0; if(StartPercent > 100) StartPercent = 100; if(EndPercent < 0) EndPercent = 0; if(EndPercent > 100) EndPercent = 100; if(EndPercent < StartPercent) { INT32 t = StartPercent; StartPercent = EndPercent; EndPercent = t; } } // else if ( !Radial ) // I allege we now know enough to get this thing to the file // start the tag if(!StartNestedTag(cmxTAG_RenderAttr_FillSpec_Fountain_Base)) return FALSE; if(pFill->IsARadialFill()) fb1.Type = cmxFOUNTAINTYPE_RADIAL; else if(pFill->IsASquareFill()) fb1.Type = cmxFOUNTAINTYPE_SQUARE; else if(pFill->IsAConicalFill()) fb1.Type = cmxFOUNTAINTYPE_CONICAL; else fb1.Type = cmxFOUNTAINTYPE_LINEAR; fb1.Screen = cmxSCREENREFERENCE; // padding set earlier // offsets set earlier fb2.StepCount = 0; fb2.FillMode = FillMode; fb2.RateMethod = 0; fb2.RateValue = 50; // 50% is the centre, a commonly held belief if(!Radial) { if(FillMode == cmxFILLMODE_RGB) { // if it's an RGB mix in a linear fill, we can accurately // specify the fill by using a custom fill mode, and specifing // the end points presicely. fb2.FillMode = cmxFILLMODE_CUSTOM; } else { // if it's not an RGB mix, we need to approximate the fill using the // padding (set already) as we can't specify where we want the // colours to start and finish along the line of the fill StartPercent = 0; EndPercent = 0; } } // write the data ExportFile->write(&fb1, sizeof(fb1)); WriteAngle(Angle); if(ThirtyTwoBit) { ExportFile->write(&fb2, sizeof(fb2)); } else { // OK, so this way is a bit of a bodge cmxFillBase2_16 b = {0, (SWORD)fb2.XOffset, (SWORD)fb2.YOffset, fb2.StepCount, fb2.FillMode}; ExportFile->write(&b, sizeof(b)); } // end the tag if(!EndNestedTag()) return FALSE; // write the colours if(!StartNestedTag(cmxTAG_RenderAttr_FillSpec_Fountain_Color)) return FALSE; cmxGradFillColour col; ColourRamp *pRamp = pFill->GetColourRamp (); WORD NCol = 2 + ( ( StartPercent != 0 ) ? 1 : 0 ) + ( ( EndPercent != 100 ) ? 1 : 0 ) + ( FourColour ? 1 : 0 ); // If the fill has a colour ramp, calculate the number of entries within it. if ( pRamp != NULL ) { UINT32 FirstIndex = 0; UINT32 LastIndex = 0; // Call a member function to get the indices to the first and last elements within // the colour ramp. pRamp->GetIndexRange ( &FirstIndex, &LastIndex ); // Add the difference between these to the number of colours to be exported. The +1 // in this sum is necessary since the index values include the number of the element // that they represent. E.g. for a one element ramp, we have 1024 for both the first // and last items. Thus, without the +1, we would get 0 colours in the index. NCol += 1 + LastIndex - FirstIndex; } // Write the number of colours. ExportFile->write ( &NCol, sizeof ( NCol ) ); // Write as many colours as necessary to get accurate fills. First the start colour. if(StartPercent != 0) { col.ColRef = StartColReference; col.ColPos = 0; ExportFile->write(&col, sizeof(col)); } col.ColRef = StartColReference; col.ColPos = (WORD)StartPercent; ExportFile->write(&col, sizeof(col)); // If it's a four colour fill, add the middle colour to the mix. if ( FourColour ) { col.ColRef = MidColReference; col.ColPos = ( WORD ) ( ( StartPercent + EndPercent ) / 2 ); ExportFile->write ( &col, sizeof ( col ) ); } // Process the colour ramp. if ( pRamp != NULL ) { ColRampItem *pColour = pRamp->GetFirstCol (); // Write in the ramp's colour values. while ( pColour != NULL ) { cmxGradFillColour RampColour; // Get the position of the colour in the fill. RampColour.ColPos = ( WORD ) ( 100.0f * pColour->GetPosition () ); RampColour.ColRef = GetColourReference ( &( pColour->GetColour () ) ); // Write the colour. ExportFile->write ( &RampColour, sizeof ( RampColour ) ); // Increment the pointer onto the next item. pColour = pRamp->GetNextCol ( pColour ); } } // And finally the end colour. col.ColRef = EndColReference; col.ColPos = (WORD)EndPercent; ExportFile->write(&col, sizeof(col)); if(EndPercent != 100) { col.ColPos = 100; ExportFile->write(&col, sizeof(col)); } if(!EndNestedTag()) return FALSE; // write the ending bit if(!WriteMinEndTag()) return FALSE; return TRUE; }

BOOL CMXExportDC::WriteFillType (  WORD  FillID  )

Writes the fill type to the DC. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 04/07/96 Parameters: fill  type [INPUTS] Returns: success Definition at line 207 of file cmxdcobj.cpp. { ExportFile->write(&FillID, sizeof(FillID)); return TRUE; }

BOOL CMXExportDC::WriteFutureDataCache (   )  [protected]

Write the Numbers from the cache to the file See also:. Author: Claude_Quemerais (Xara Group Ltd) <camelotdev@xara.com> Date: 15/07/96 Parameters: none  [INPUTS] Returns: Success Definition at line 1758 of file cmxexdc.cpp. { // Find out the current position in the file INT32 here = ExportFile->tell(); for(INT32 i = 0 ; i < NumberOfEntriesUsedInCache ; i++) { // write the numbers to file TRACEUSER( "Claude", _T("Writing cache %x at %d, size %d\n"), FutureDataCache[i].Data, FutureDataCache[i].Location, FutureDataCache[i].DataSize); // Get the location where to put the info in the file ExportFile->seek(FutureDataCache[i].Location); if(FutureDataCache[i].DataSize != 0) { // If there is something flush it (there should always be something) switch(FutureDataCache[i].DataSize) { case sizeof(BYTE): { // If it's a BYTE, write a BYTE BYTE Num = (BYTE)FutureDataCache[i].Data; ExportFile->write(&Num, sizeof(Num)); } break; case sizeof(WORD): { // If it's a WORD, write a WORD WORD Num = (WORD)FutureDataCache[i].Data; ExportFile->write(&Num, sizeof(Num)); } break; case sizeof(INT32): { // If it's a INT32, write a INT32 INT32 Num = FutureDataCache[i].Data; ExportFile->write(&Num, sizeof(Num)); } break; default: // If it's anything else, something went wrong ERROR3("OOOKK! Non supported data size"); break; } // Empty that entry of the cache, putting the Location to the maximum possible FutureDataCache[i].Location = INT32_MAX; FutureDataCache[i].Data = 0; FutureDataCache[i].DataSize = 0; } } // Put the file back to wherever it was before we used it ExportFile->seek(here); // reset the cache count thingy NumberOfEntriesUsedInCache = 0; return TRUE; }

BOOL CMXExportDC::WriteIndex (  void   )

writes the index for the file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 2346 of file cmxexdc.cpp. { // start the section if(!StartSection(CMXSECTION_INDEX)) return FALSE; // write the layer index if(!WriteAnIndex(cmxINDEX_LAYER)) return FALSE; // write the master layer index if(!WriteAnIndex(cmxINDEX_MASTERLAYER)) return FALSE; // write the page index if(!WriteAnIndex(cmxINDEX_PAGE)) return FALSE; // write the procedure index if(!WriteAnIndex(cmxINDEX_PROCEDURE)) return FALSE; // write the embedded file index if(!WriteAnIndex(cmxINDEX_EMBEDFILE)) return FALSE; // write the embedded file index if(!WriteAnIndex(cmxINDEX_ARROW)) return FALSE; // write the master index if(!WriteAnIndex(cmxINDEX_MASTERINDEX)) return FALSE; // end the section if(!EndSection()) return FALSE; return TRUE; }

BOOL CMXExportDC::WriteMatrix (  Matrix *  pMatrix = NULL  )

writes a matrix to the file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27/06/96 Parameters: matrix  to write, NULL for identity matrix [INPUTS] Returns: success See also: Definition at line 1652 of file cmxexdc.cpp. { if(pMatrix == NULL) { // write an identity matrix WORD MatrixType = cmxMATRIXTYPE_IDENTITY; ExportFile->write(&MatrixType, sizeof(MatrixType)); } else { // write the matrix cmxMatrix Thingy; FIXED16 abcd[4]; INT32 ef[2]; pMatrix->GetComponents((FIXED16 *)(&abcd), (INT32 *)(&ef)); Thingy.Type = cmxMATRIXTYPE_GENERAL; Thingy.a = abcd[0].MakeDouble(); Thingy.b = abcd[1].MakeDouble(); Thingy.c = abcd[2].MakeDouble(); Thingy.d = abcd[3].MakeDouble(); Thingy.e = (DOUBLE)ef[0]; Thingy.f = (DOUBLE)ef[1]; ExportFile->write(&Thingy, sizeof(Thingy)); } return TRUE; }

BOOL CMXExportDC::WriteMinEndTag (  void   )  [inline]

Definition at line 341 of file cmxexdc.h. {if(ThirtyTwoBit) WriteByte(cmxTAG_EndTag); return TRUE;};

BOOL CMXExportDC::WriteNestedTag (  INT32  Tag, void *  Data = 0, UINT32  Size = 0 )  [inline]

Definition at line 337 of file cmxexdc.h. {return DoWriteTag(Tag, Data, Size, TRUE);};

BOOL CMXExportDC::WriteNumber (  INT32  Position, UINT32  DataSize, INT32  Value )

Finish off the file, update indexes and all that. Author: Claude_Quemerais (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/96 Parameters: none  [INPUTS] Returns: success Fixed by Ben so it doesn't write over the end of the array and screw up the other variables in the class and cause nasty AVs in retail builds which annoy Charles and take me ages to find. Definition at line 1697 of file cmxexdc.cpp. { TRACEUSER( "Claude", _T("Writing number %x at %d, size %d\n"), Value, Position, DataSize); // When cache full => Flush it to the file. if(NumberOfEntriesUsedInCache >= (CMXFUTUREVALUECACHESIZE - 1)) WriteFutureDataCache(); // Variable used to find out what entry is to be used INT32 theEntryInCache = 0; // Search for the right place in the cache, i.e. sort the cache as // it's generated while((theEntryInCache < NumberOfEntriesUsedInCache) && (Position > FutureDataCache[theEntryInCache].Location)) theEntryInCache++; TRACEUSER( "Claude", _T("Writing entry %d"), theEntryInCache); if(theEntryInCache < NumberOfEntriesUsedInCache) { // If the entry to use is before the last entry already used in the cache // Push all entries used from the one we want onward. // Variable used to determine which entry is to be pushed // Starting from the end. for(INT32 entrySorting = NumberOfEntriesUsedInCache; entrySorting >= theEntryInCache; entrySorting--) { // Copy the entry onto the next one FutureDataCache[entrySorting+1] = FutureDataCache[entrySorting]; } } // Copy the information into the cache FutureDataCache[theEntryInCache].Location = Position; FutureDataCache[theEntryInCache].Data = Value; FutureDataCache[theEntryInCache].DataSize = DataSize; TRACEUSER( "Claude", _T("Writing number %x at %d, size %d\n"), FutureDataCache[theEntryInCache].Data, FutureDataCache[theEntryInCache].Location, FutureDataCache[theEntryInCache].DataSize); // Put the entry to use on the next one. NumberOfEntriesUsedInCache++; return TRUE; }

BOOL CMXExportDC::WriteOutlineSpec (  CMXRenderRegion *  pReg  )

writes the outline specification to the file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 05/07/96 Parameters: render  region [INPUTS] Returns: sucess Definition at line 1499 of file cmxdcobj.cpp. { // algorithm: // examine the render region and create the structures we want // this involves scanning the refer list to find the components of the // outline, and possibly adding new bits to it. // then, once we've got this structure, we need to scan the list // to see if it's already there. However, if we needed to create // anything new in the first phase, we can just skip this. // but we need to know how many outlines are in there, so // keep a count in the first bit. // find out the line width MILLIPOINT Width; // get the attribute LineWidthAttribute *pLineWidthA = (LineWidthAttribute *)pReg->GetCurrentAttribute(ATTR_LINEWIDTH); // check it out ERROR2IF(pLineWidthA == 0, FALSE, "No line width attribute"); ERROR3IF(!pLineWidthA->IsKindOf(CC_RUNTIME_CLASS(LineWidthAttribute)), "not a line width attribute"); Width = pLineWidthA->LineWidth; // find the colour DocColour *pColour; // get the attribute StrokeColourAttribute *pColA = (StrokeColourAttribute *)pReg->GetCurrentAttribute(ATTR_STROKECOLOUR); // check it out ERROR2IF(pColA == 0, FALSE, "No stroke colour attribute"); ERROR3IF(!pColA->IsKindOf(CC_RUNTIME_CLASS(StrokeColourAttribute)), "not a stroke colour attribute"); pColour = pColA->GetStartColour(); // get the reference for the colour -- check to see if it's transparent BOOL TransparentLine = FALSE; WORD ColRef; if(pColour->IsTransparent()) { TransparentLine = TRUE; Width = 0; // Graeme (15-2-00) - Remove line if transparent. } else ColRef = GetColourReference(pColour); // sort out the line style cmxLineStyle LineStyle; LineStyle.Spec = TransparentLine?cmxLINESPEC_NONE:0; LineStyle.CapAndJoin = 0; // find the join type // get the attribute JoinTypeAttribute *pJTA = (JoinTypeAttribute *)pReg->GetCurrentAttribute(ATTR_JOINTYPE); // check it out ERROR2IF(pJTA == 0, FALSE, "No join type attribute"); ERROR3IF(!pJTA->IsKindOf(CC_RUNTIME_CLASS(JoinTypeAttribute)), "not a join type attribute"); // set switch(pJTA->JoinType) { case RoundJoin: LineStyle.CapAndJoin |= cmxCAPJOIN_ROUNDJOIN; break; case BevelledJoin: LineStyle.CapAndJoin |= cmxCAPJOIN_BEVELJOIN; break; default: break; } // find the end cap // get the attribute StartCapAttribute *pSCA = (StartCapAttribute *)pReg->GetCurrentAttribute(ATTR_STARTCAP); // check it out ERROR2IF(pSCA == 0, FALSE, "No start cap attribute"); ERROR3IF(!pSCA->IsKindOf(CC_RUNTIME_CLASS(StartCapAttribute)), "not a start cap attribute"); // set switch(pSCA->StartCap) { case LineCapRound: LineStyle.CapAndJoin |= cmxCAPJOIN_ROUNDCAP; break; case LineCapSquare: LineStyle.CapAndJoin |= cmxCAPJOIN_SQUARECAP; break; default: break; } // find the dotdash pattern DashRec *pDash; DashPatternAttribute *pDas = (DashPatternAttribute *)pReg->GetCurrentAttribute(ATTR_DASHPATTERN); // check it out ERROR2IF(pDas == 0, FALSE, "No dash pattern attribute"); ERROR3IF(!pDas->IsKindOf(CC_RUNTIME_CLASS(DashPatternAttribute)), "not a dash pattern attribute"); // get it... pDash = &pDas->DashPattern; if(pDash->Elements != 0) LineStyle.Spec |= cmxLINESPEC_DOTDASH; else LineStyle.Spec |= cmxLINESPEC_SOLIDOUTLINE; // now we want to aquire some arrowhead references EndArrowAttribute *pEa = (EndArrowAttribute *)pReg->GetCurrentAttribute(ATTR_ENDARROW); // check it out ERROR2IF(pEa == 0, FALSE, "No arrow attribute"); ERROR3IF(!pEa->IsKindOf(CC_RUNTIME_CLASS(EndArrowAttribute)), "not a arrow attribute"); StartArrowAttribute *pSa = (StartArrowAttribute *)pReg->GetCurrentAttribute(ATTR_STARTARROW); // check it out ERROR2IF(pSa == 0, FALSE, "No arrow attribute"); ERROR3IF(!pSa->IsKindOf(CC_RUNTIME_CLASS(StartArrowAttribute)), "not a arrow attribute"); // get the arrow references WORD StartArrow = GetArrowReference(&pSa->StartArrow); WORD EndArrow = GetArrowReference(&pEa->EndArrow); // right then, we need to run through the table to construct the specification BOOL FoundPen = FALSE; // whether we found the pen WORD PenRef = 0; // reference number for the pen BOOL FoundLineStyle = FALSE; WORD LineStyleRef = 0; BOOL FoundArrowheads = FALSE; WORD ArrowheadsRef = 0; BOOL FoundDotDash = FALSE; WORD DotDashRef = 0; WORD LastOutlineRef = 0; // count up the outlines to find out the ref of the last one CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); switch(pEn->IsInWhichDesc()) { case cmxDESC_PEN: if(!FoundPen) { PenRef++; CMXReferPen *pPen = (CMXReferPen *)pEn; ERROR3IF(!pPen->IsKindOf(CC_RUNTIME_CLASS(CMXReferPen)), "not a refer pen, when it said it was"); // is it this width? if(pPen->AreYouThisWidth(Width)) { // yes FoundPen = TRUE; } } break; case cmxDESC_LINESTYLE: if(!FoundLineStyle) { LineStyleRef++; CMXReferLineStyle *pSt = (CMXReferLineStyle *)pEn; ERROR3IF(!pSt->IsKindOf(CC_RUNTIME_CLASS(CMXReferLineStyle)), "not a refer LineStyle, when it said it was"); // is it this style? if(pSt->AreYouThisStyle(&LineStyle)) { // yes FoundLineStyle = TRUE; } } break; case cmxDESC_ARROWHEADS: if(!FoundArrowheads) { ArrowheadsRef++; CMXReferArrowheads *pAh = (CMXReferArrowheads *)pEn; ERROR3IF(!pAh->IsKindOf(CC_RUNTIME_CLASS(CMXReferArrowheads)), "not a arrowheads, when it said it was"); // is it this arrowheads? if(pAh->AreYouThisArrowheads(StartArrow, EndArrow)) { // yes FoundArrowheads = TRUE; } } break; case cmxDESC_DOTDASH: if(!FoundDotDash) { DotDashRef++; CMXReferDotDash *pDd = (CMXReferDotDash *)pEn; ERROR3IF(!pDd->IsKindOf(CC_RUNTIME_CLASS(CMXReferDotDash)), "not a refer dot dash, when it said it was"); // is it this style? if(pDd->AreYouThisDotDash(pDash)) { // yes FoundDotDash = TRUE; } } break; case cmxDESC_OUTLINE: LastOutlineRef++; // inc the ref for each outline object enountered break; default: // do nothing break; } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } // right then, create some new refer objects if necessary BOOL NewReferObjectCreated = FALSE; // whether an refer object was created if(!FoundPen) { NewReferObjectCreated = TRUE; // knock up a pen object CMXReferPen *pPen = new CMXReferPen(this); if(pPen == NULL) return FALSE; pPen->SetWidth(Width); PenRef++; // the reference ReferList.AddTail(pPen); } if(!FoundLineStyle) { NewReferObjectCreated = TRUE; // knock up a pen object CMXReferLineStyle *pLs = new CMXReferLineStyle(this); if(pLs == NULL) return FALSE; pLs->SetLineStyle(&LineStyle); LineStyleRef++; // the reference ReferList.AddTail(pLs); } if(!FoundArrowheads) { NewReferObjectCreated = TRUE; // knock up a pen object CMXReferArrowheads *pAh = new CMXReferArrowheads(this); if(pAh == NULL) return FALSE; pAh->SetArrowheads(StartArrow, EndArrow); ArrowheadsRef++; // the reference ReferList.AddTail(pAh); } if(!FoundDotDash) { NewReferObjectCreated = TRUE; // knock up a pen object CMXReferDotDash *pDd = new CMXReferDotDash(this); if(pDd == NULL) return FALSE; pDd->Set(pDash); DotDashRef++; // the reference ReferList.AddTail(pDd); } // make up an outline def cmxOutline Outline; memset(&Outline, 0, sizeof(Outline)); Outline.LineStyle = LineStyleRef; Outline.Screen = cmxSCREENREFERENCE; if(TransparentLine) Outline.Colour = 1; // any random number will do as long the colour exists else Outline.Colour = ColRef; Outline.Arrowheads = ArrowheadsRef; Outline.Pen = PenRef; Outline.DotDash = DotDashRef; // run through the table to see if there's a BOOL FoundOutline = FALSE; WORD OutlineRef = 0; if(NewReferObjectCreated == FALSE) // only bother looking if no new objects have been created { CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); if(pEn->IsInWhichDesc() == cmxDESC_OUTLINE) { OutlineRef++; CMXReferOutline *pLC = (CMXReferOutline *)pEn; ERROR3IF(!pLC->IsKindOf(CC_RUNTIME_CLASS(CMXReferOutline)), "not a refer outline, when it said it was"); // is it this outline? if(pLC->AreYouThisOutline(&Outline)) { FoundOutline = TRUE; break; } } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } } // right then, maybe we want to create a new outline object? if(FoundOutline == FALSE) { OutlineRef = LastOutlineRef + 1; // make a new object CMXReferOutline *pOlt = new CMXReferOutline(this); if(pOlt == NULL) return FALSE; // set it's outline thingy pOlt->SetOutline(&Outline); // and add it to the list ReferList.AddTail(pOlt); } // finally, write the reference to the file if(!WriteNestedTag(cmxTAG_RenderAttr_OutlineSpec, &OutlineRef, sizeof(OutlineRef))) return FALSE; // and the end tag if(!WriteMinEndTag()) return FALSE; return TRUE; }

BOOL CMXExportDC::WritePath (  DocCoord *  Coords, PathVerb *  Verbs, INT32  NumCoords, BOOL  Filled )

Writes a path instruction -- transformed by matrix. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 01/07/96 Parameters: render  region, coords, verbs and number of coords [INPUTS] Returns: success Definition at line 973 of file cmxdcobj.cpp. { // if this is one of those nasty 16 bit files, sort out a transform matrix // scan the verbs to see if there's a close path in it // as if there isn't, we need to force no fill on the thingy BOOL ForceNoFill = TRUE; for(INT32 p = 0; p < NumCoords; p++) { if((Verbs[p] & PT_CLOSEFIGURE) != 0) ForceNoFill = FALSE; } if(!Filled) ForceNoFill = TRUE; // begin the command if(!StartCommand(cmxINSTR_PolyCurve)) return FALSE; // output the rendering attributes if(!WriteAttributes(pRenderRegion, cmxTAG_PolyCurve_RenderingAttr, Coords, NumCoords, ForceNoFill)) return FALSE; // write the point list, transformed of course. Start by tagging it if(!StartTag(cmxTAG_PolyCurve_PointList)) return FALSE; // we have to collect a bounding box as we go through as Corel use a // naff bbox which is simply the union of all points DocRect bb; // which is written as a corel one DocCoord fc = Coords[0]; pMatrix->transform(&fc); bb.lo = fc; // start with sensible coords to begin with bb.hi = fc; // write the point count WORD Count = (WORD)NumCoords; ExportFile->write(&Count, sizeof(Count)); // run through the coords writing and transforming INT32 l; TRACEUSER( "Ben", _T("\nPath\n")); for(l = 0; l < NumCoords; l++) { DocCoord Coord = Coords[l]; pMatrix->transform(&Coord); // write it... if(ThirtyTwoBit) { cmxPoint32 p = {Coord.x, Coord.y}; ExportFile->write(&p, sizeof(p)); } else { TRACEUSER( "Ben", _T("Coord %d %d\n"), Coord.x, Coord.y); cmxPoint16 p = {(SWORD)Coord.x, (SWORD)Coord.y}; ExportFile->write(&p, sizeof(p)); } // flibble the bounding box with those lovely new coords if(Coord.x < bb.lo.x) bb.lo.x = Coord.x; if(Coord.y < bb.lo.y) bb.lo.y = Coord.y; if(Coord.x > bb.hi.x) bb.hi.x = Coord.x; if(Coord.y > bb.hi.y) bb.hi.y = Coord.y; } // run through the verbs writing point types INT32 BezCount = 0; // for counting Bez for(l = 0; l < NumCoords; l++) { BYTE Type; switch(Verbs[l] & (PT_LINETO | PT_MOVETO | PT_BEZIERTO)) { case PT_MOVETO: { Type = CMXNODETYPE_TYPE_MOVE | CMXNODETYPE_USER; // wibble forwards through the verbs to see if the correspondingness is closed for(INT32 lp = l + 1; lp < NumCoords; lp++) { // OK, is this a move? if((Verbs[lp] & (PT_LINETO | PT_MOVETO | PT_BEZIERTO)) == PT_MOVETO) break; // is closefigure set? if((Verbs[lp] & PT_CLOSEFIGURE) != 0) { Type |= CMXNODETYPE_CLOSED; break; } } } BezCount = 0; break; case PT_LINETO: Type = CMXNODETYPE_TYPE_LINE | CMXNODETYPE_USER; BezCount = 0; break; case PT_BEZIERTO: // in CMX, the control points have type ARC, and the end points // have type CURVE. This code does the trickery. if(BezCount == 2) { Type = CMXNODETYPE_TYPE_CURVE | CMXNODETYPE_USER; } else { Type = CMXNODETYPE_TYPE_ARC; } BezCount++; if(BezCount > 2) BezCount = 0; // so that only the end points of beziers get user flag break; default: ERROR3("Unknown node type"); break; } if((Verbs[l] & PT_CLOSEFIGURE) != 0) { Type |= CMXNODETYPE_CLOSED; } ExportFile->write(&Type, sizeof(Type)); } // end the point list if(!EndTag()) return FALSE; // write bbox we've collected if(!StartTag(cmxTAG_PolyCurve_BoundingBox) || !WriteBBox(&bb, FALSE) || !EndTag()) return FALSE; // end the command if(!WriteMinEndTag() || !EndCommand()) return FALSE; // if necessary, get rid of the horrid transform matrix return TRUE; }

BOOL CMXExportDC::WritePreviewBitmap (  void   )

writes a preview bitmap type thing Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 29/08/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 3128 of file cmxexdc.cpp. { Filter* pFilter = NULL; pFilter = Filter::GetFirst(); while ((pFilter != NULL) && (pFilter->FilterID != FILTERID_PREVIEW_BMP)) { // Try the next filter pFilter = Filter::GetNext(pFilter); } // Make sure that we found the preview bitmap filter if ((pFilter != NULL) && (pFilter->IS_KIND_OF(BaseBitmapFilter))) { // write the index of this thumbnail section ThumbnailIndexFuture.Write(this); // start the section if(!StartSection(CMXSECTION_PREVIEWBITMAP)) return FALSE; // write a number DWORD Eight = 8; Eight = NativetoLE(Eight); ExportFile->write(&Eight, sizeof(Eight)); // fudge things a bit INT32 Start = ExportFile->tell(); BITMAPFILEHEADER hdr; ExportFile->seek(Start - sizeof(hdr)); ExportFile->read(&hdr, sizeof(hdr)); ExportFile->seek(Start - sizeof(hdr)); //WEBSTER-Martin-03/01/97 // force the Preview to a fixed size INT32 OldPreviewSize = PreviewFilter::PreviewBitmapSize; // Set the Preview to be just over an inch accross PreviewFilter::PreviewBitmapSize = 96000; // Get as Bitmap Filter and set it up BaseBitmapFilter* pBitmapFilter = (BaseBitmapFilter*) pFilter; pBitmapFilter->SetPreviewBitmap(TRUE); // Export the Preview to the file BOOL ok = pFilter->DoExport(pOp, ExportFile, pPath, TheDocument); // If the Preview bitmap failed to export then we still need to clean up // Set it back pBitmapFilter->SetPreviewBitmap(FALSE); // Set the Preview back to its default setting PreviewFilter::PreviewBitmapSize = OldPreviewSize; // replace the data which was overwritten INT32 Here = ExportFile->tell(); ExportFile->seek(Start - sizeof(hdr)); ExportFile->write(&hdr, sizeof(hdr)); ExportFile->seek(Here); // finish the section if(!EndSection()) return FALSE; return ok; } return TRUE; }

BOOL CMXExportDC::WriteReferenceList (  void   )

writes the reference list for the page we've just done Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 2286 of file cmxexdc.cpp. { // first, find the number of entries in this list WORD RefListEntries = 0; CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "Entry in the refer list isn't a correct list item"); if(pEn->IsInReferenceList()) RefListEntries++; pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } // set the location in the page reference item ERROR2IF(PageRefer == NULL, FALSE, "no page reference item"); PageRefer->SetRefListOffset(GetFilePosition()); RefListOffset = GetFilePosition(); // start the section if(!StartSection(CMXSECTION_REFLIST)) return FALSE; // write the number of entries in the list ExportFile->write(&RefListEntries, sizeof(RefListEntries)); // write the entries pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "Entry in the refer list isn't a correct list item"); if(!pEn->WriteInReferenceList(this)) return FALSE; pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } // end the section if(!EndSection()) return FALSE; return TRUE; }

BOOL CMXExportDC::WriteReferSections (  void   )

gets all refer list items which are sections to write themselves Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 12/07/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 2464 of file cmxexdc.cpp. { // wander through the list CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead(); while(pEn != 0) { ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list"); if(pEn->IsASection()) { if(!pEn->WriteSection(this)) return FALSE; } pEn = (CMXReferListItem *)ReferList.GetNext(pEn); } return TRUE; }

void CMXExportDC::WriteSizeInFile (  WORD  Size  )  [inline]

Definition at line 293 of file cmxexdc.h. {if(ThirtyTwoBit) ExportFile->write(&Size, sizeof(Size));};

BOOL CMXExportDC::WriteString (  StringBase *  Str  )

Write a bounding box to the file. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/96 Parameters: none  [INPUTS] Returns: success See also: Definition at line 1626 of file cmxexdc.cpp. { INT32 StrLen = Str->Length(); cmxString h; h.Length = (WORD)StrLen; ExportFile->write(&h, sizeof(h)); ExportFile->write((TCHAR *)(*Str), StrLen); return TRUE; }

BOOL CMXExportDC::WriteTag (  INT32  Tag, void *  Data = 0, UINT32  Size = 0 )  [inline]

Definition at line 331 of file cmxexdc.h. {return DoWriteTag(Tag, Data, Size, FALSE);};

---

Member Data Documentation

BOOL CMXExportDC::AreIgnoreingOverlappedLenses [private]

Definition at line 435 of file cmxexdc.h.

CMXFutureLength CMXExportDC::CommandLengthFuture [private]

Definition at line 402 of file cmxexdc.h.

INT32 CMXExportDC::CurrentInstrFilePosition [private]

Definition at line 425 of file cmxexdc.h.

CMXSectionType CMXExportDC::CurrentSection [private]

Definition at line 389 of file cmxexdc.h.

BOOL CMXExportDC::DoingCommand [private]

Definition at line 409 of file cmxexdc.h.

BOOL CMXExportDC::DoingLayer [private]

Definition at line 411 of file cmxexdc.h.

BOOL CMXExportDC::DoingPage [private]

Definition at line 410 of file cmxexdc.h.

BOOL CMXExportDC::DoingRIFFList [private]

Definition at line 414 of file cmxexdc.h.

BOOL CMXExportDC::DoingTag [private]

Definition at line 412 of file cmxexdc.h.

CMXFutureLength CMXExportDC::FileLengthFuture [private]

Definition at line 394 of file cmxexdc.h.

INT32 CMXExportDC::FirstInstrFilePosition [private]

Definition at line 424 of file cmxexdc.h.

CMXFutureDataCacheEntry CMXExportDC::FutureDataCache[128] [private]

Definition at line 428 of file cmxexdc.h.

List CMXExportDC::GroupList [private]

Definition at line 422 of file cmxexdc.h.

BOOL CMXExportDC::HaveAskedUserAboutLenses [private]

Definition at line 436 of file cmxexdc.h.

CMXFutureIndex CMXExportDC::IndexSectionFuture [private]

Definition at line 403 of file cmxexdc.h.

CMXFutureNumber CMXExportDC::LayerFlags [private]

Definition at line 401 of file cmxexdc.h.

CMXFutureNumber CMXExportDC::LayerInstructionCount [private]

Definition at line 400 of file cmxexdc.h.

WORD CMXExportDC::LayerNumber [private]

Definition at line 413 of file cmxexdc.h.

List CMXExportDC::LensBBoxes [private]

Definition at line 433 of file cmxexdc.h.

INT32 CMXExportDC::NestedTagLevel [private]

Definition at line 417 of file cmxexdc.h.

List CMXExportDC::NestedTagList [private]

Definition at line 418 of file cmxexdc.h.

INT32 CMXExportDC::NumberOfEntriesUsedInCache [private]

Definition at line 427 of file cmxexdc.h.

BOOL CMXExportDC::OverlappedLensesHaveBeenIgnored [private]

Definition at line 434 of file cmxexdc.h.

CMXFutureIndex CMXExportDC::PageEndIndexFuture [private]

Definition at line 396 of file cmxexdc.h.

CMXFutureNumber CMXExportDC::PageFlags [private]

Definition at line 399 of file cmxexdc.h.

CMXFutureNumber CMXExportDC::PageGroupCount [private]

Definition at line 398 of file cmxexdc.h.

CMXFutureNumber CMXExportDC::PageInstructionCount [private]

Definition at line 397 of file cmxexdc.h.

BOOL CMXExportDC::PageIsProc [private]

Definition at line 415 of file cmxexdc.h.

CMXReferPage* CMXExportDC::PageRefer [private]

Definition at line 420 of file cmxexdc.h.

Matrix* CMXExportDC::pMatrix [private]

Definition at line 423 of file cmxexdc.h.

Operation* CMXExportDC::pOp [private]

Definition at line 439 of file cmxexdc.h.

PathName* CMXExportDC::pPath [private]

Definition at line 440 of file cmxexdc.h.

CMXRenderRegion* CMXExportDC::pRenderRegion [private]

Definition at line 387 of file cmxexdc.h.

List CMXExportDC::ReferList [private]

Definition at line 419 of file cmxexdc.h.

INT32 CMXExportDC::RefListOffset [private]

Definition at line 421 of file cmxexdc.h.

CMXFutureLength CMXExportDC::RIFFListLengthFuture [private]

Definition at line 407 of file cmxexdc.h.

double CMXExportDC::ScaleFactor [private]

Definition at line 430 of file cmxexdc.h.

CMXFutureLength CMXExportDC::SectionLengthFuture [private]

Definition at line 390 of file cmxexdc.h.

CMXFutureLength CMXExportDC::TagLengthFuture [private]

Definition at line 406 of file cmxexdc.h.

CMXFutureNumber CMXExportDC::Tally [private]

Definition at line 395 of file cmxexdc.h.

Document* CMXExportDC::TheDocument [private]

Definition at line 438 of file cmxexdc.h.

BOOL CMXExportDC::ThirtyTwoBit [private]

Definition at line 392 of file cmxexdc.h.

CMXFutureIndex CMXExportDC::ThumbnailIndexFuture [private]

Definition at line 405 of file cmxexdc.h.

CMXFutureIndex CMXExportDC::TrailerIndexFuture [private]

Definition at line 404 of file cmxexdc.h.

---

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

• Kernel/cmxexdc.h (r1785/r1282)
• Kernel/cmxdcobj.cpp (r1785/r1282)
• Kernel/cmxexdc.cpp (r1785/r1282)

---