CDRFilter Class Reference

Corel Draw file importing class. More...

#include <cdrfiltr.h>

Inheritance diagram for CDRFilter:

List of all members.

Public Member Functions
	CDRFilter ()
	Constructor.
BOOL	Init ()
	Initialisation.
INT32	HowCompatible (PathName &Filename, ADDR HeaderStart, UINT32 HeaderSize, UINT32 FileSize)
	Examines a file to see how compatable it is with this filter.
BOOL	DoImport (SelOperation *, CCLexFile *, Document *, BOOL AutoChosen=FALSE, ImportPosition *Pos=NULL, KernelBitmap **ppImportedBitmap=NULL, DocCoord *pPosTranslate=NULL, String_256 *=NULL)
BOOL	DoExport (Operation *, CCLexFile *, PathName *, Document *, BOOL)
	Refuses to export a Corel Palette file.
Static Public Member Functions
static void	DeleteNodeList (Node *)
	Deletes a linked list of nodes (forward direction only).
static BOOL	GetCorelBBox (NodeRenderableBounded *pNode, DocRect *BBox)
	gets the Corel simple union bbox of an object
static ADDR	FindDataInObject (cdrfOffsetHeader *Header, WORD Type)
	returns the address of data of the given type in an objects with a standard offset header
static BOOL	AddElementsToPath (Path *pPath, INT32 NCoords, cdrfCoord *Coords, BYTE *Types, BOOL *IsClosed)
	Adds elements to a path from a CDR path data.
static BOOL	AddStandardColourSet (Document *pDocument)
	Adds the standard set of colours to a Corel file.
static BOOL	HasCDRFileGotCMXFile (PathName *FileName, CCLexFile *pFile=NULL)
	to find out whether a CDR file has got a CMX file in it, and therefore whether the CMX filter should grab it instead of this one
Static Public Attributes
static INT32	BitmapNumber = 0
static INT32	PatternNumber = 0
Private Member Functions
	CC_DECLARE_DYNAMIC (CDRFilter)
BOOL	ClearUp (void)
	Clears up after an CDR file import.
BOOL	UpdateProgress (BOOL Now=FALSE)
	Updating the progress everysooften - called at every significant place to get a nice smooth update on that progress bar thingy.
BOOL	ProcessDoc (void)
	Processes the root level doc chunk of a CDR file.
BOOL	ProcessPage (void)
	Processes a page list of a CDR file.
BOOL	ProcessLayer (void)
	Processes a layer list of a CDR file. This is the function which actually grabs objects to convert.
BOOL	ProcessObjectTree (UINT32 Level)
	process objects from the CDR file - they end up linked to pLevelNodeList.
BOOL	ProcessObject (void)
	Converts an object. If there's a problem with the object, then it's skipped rather than reporting an error, and the count of problem objects incremented.
BOOL	ProcessGroup (UINT32 Level, BOOL FromLink=FALSE)
	Sets up a group end action and alters the level node list to be a new list.
BOOL	ProcessLink (void)
	Sets up a group end action and a post transform action and alters the level node list to be a new list.
BOOL	ProcessVectorList (ADDR Block, INT32 Size)
	processes the vector list at the beginning of CDR files. This contains a list of objects which are used for things such as full colour fills, texture fills, mould shapes, that sort of thing.
BOOL	ProcessVectorListEntry ()
	processes an entry in the vector list
BOOL	ProcessTextList4 ()
	Processes the list of text objects for a version 4 CDR file creating text lines and textchars with partially applied attributes.
BOOL	ProcessTextListItem4 ()
	Processes a item from the list of text objects for a version 4 CDR file creating text lines and textchars with partially applied attributes.
BOOL	ConvertRectangle (cdrfOffsetHeader *)
BOOL	ConvertEllipse (cdrfOffsetHeader *)
	generates an ellipse object
BOOL	ConvertPath (cdrfOffsetHeader *)
	actually converts a path object to a node. If the object has an unexpected format, then FormatError is set and it return *TRUE* - the return value only indicated environmental errors such as lack of memory
BOOL	ConvertText (cdrfOffsetHeader *)
	converts a text object to a node. If the object has an unexpected format, then FormatError is set and it return *TRUE* - the return value only indicated environmental errors such as lack of memory
BOOL	ConvertText4Art (cdrfOffsetHeader *)
	converts a version 4 artisitic text object
BOOL	ConvertText4Para (cdrfOffsetHeader *)
	converts a version 4 paragraph text object
BOOL	ConvertText3 (cdrfOffsetHeader *)
	converts a version 3 text object to a node. If the object has an unexpected format, then FormatError is set and it return *TRUE* - the return value only indicated environmental errors such as lack of memory
BOOL	ConvertBitmap (cdrfOffsetHeader *)
BOOL	SetLineAttr (cdrfOffsetHeader *Object)
BOOL	SetFillAttr (cdrfOffsetHeader *Object)
	sets the fill attributes
BOOL	SetLineAttr3 (cdrfOffsetHeader *Object)
BOOL	SetFillAttr3 (cdrfOffsetHeader *Object)
	sets the fill attributes for version 3
BOOL	SetFillAttrFlat (cdrfFillHeader *Fill, INT32 Size)
	sets flat fill attributes
BOOL	SetFillAttrGrad (cdrfFillHeader *Fill, INT32 Size)
	sets graduated fill attributes
BOOL	SetUKFill (void)
	sets a fill attribute for unknown fills
BOOL	SetLinearGrad (CDRFillInfo *GFill, DocRect &BBox, DocColour *StartColour, DocColour *EndColour)
	sets a linear graduated fill from fill definition in the file Copied from coreleps.cpp and modified
BOOL	SetRadialGrad (CDRFillInfo *GFill, DocRect &BBox, DocColour *StartColour, DocColour *EndColour)
	sets a radial graduated fill from fill definition in the file
BOOL	SetConicalGrad (CDRFillInfo *GFill, DocRect &BBox, DocColour *StartColour, DocColour *EndColour)
	sets a conical graduated fill from fill definition in the file Copied from coreleps.cpp and modified
BOOL	SetFillAttrPattern (CDRTiledFillInfo *Info, DocColour *Colour1, DocColour *Colour2)
	set pattern fill attributes
BOOL	SetFillAttrTexture (cdrfFillHeader *Fill, INT32 Size)
	sets texture fill attributes
BOOL	SetFillAttrVector (CDRTiledFillInfo *Info)
	set vector fill attributes
BOOL	NoFill (void)
	makes an object not filled
BOOL	AddAttributesToArrowheadNode (NodeRenderableBounded *N, DocColour *Col, INT32 LineWidth, LineCapType Cap, JointType Join)
	apply attributes to a arrow head node
BOOL	AddAttributesToArrowheadPath (NodePath *P, DocColour *Col, INT32 LineWidth, LineCapType Cap, JointType Join)
	apply attributes to a arrow head path
BOOL	DoesPathNeedArrowheads (NodePath *P)
	To find out whether a path need attributes.
BOOL	TransformArrowhead (NodeRenderableBounded *N, DocCoord *Point, DocCoord *Other, BOOL Start, INT32 LineWidth, INT32 Distance)
	transform an arrowhead path to be the correct size and orientation
BOOL	AddArrowheadsToPath (DWORD StartArrow, DWORD EndArrow, DocColour *Col, INT32 LineWidth, LineCapType Cap, JointType Join)
	adds arrowheads to a path. Changes pMadeNode from a path to a group
BOOL	ConvertColour (cdrfColour *Col, DocColour *Out)
	converts a colour from the CDR definition taking into account the version
BOOL	IsTransformJustMatrices (ADDR Trans, INT32 Size)
	scans a transform chunk. Returns TRUE if the transform was just composed of matrices and unknown transforms.
BOOL	TransformConvertedObject (NodeRenderable **N, ADDR Trans, INT32 Size, BOOL TranslateForPage=TRUE, BOOL IsAGroupTransform=FALSE, BOOL WorkAtOrigin=FALSE)
	transforms an object we converted, given a trfd chunk. If TranslateForPage is true (defaults to TRUE) then the object will also be translated to get the origin in the right place. The pointer may be modified to be a pointer to a different object. WorkAtOrigin causes the object to be translated back to the origin before being hacked apon, except if it's in a CDR3 file when it's ignored as the file is mass-translated at the end of the conversion..
BOOL	TransformConvertedObjectDoMatrix (NodeRenderable **N, cdrMatrix *Ma, BOOL TranslateForPage)
	transforms an object given a CDR matrix
BOOL	TransformConvertedObjectDoPerspective (NodeRenderable **N, cdrPerspective *P, BOOL TranslateShapeForPage=FALSE)
BOOL	TransformConvertedObjectDoEnvelope (NodeRenderable **N, Path *P, DocRect *OriginalBBox, INT32 *Corners, BOOL TranslateShapeForPage=FALSE)
	transforms an object given a path to envelope into
BOOL	TransformConvertedObjectDoExtrude (NodeRenderable **N, cdrExtrudeInfo *Info, BOOL TranslateShapeForPage=FALSE)
	performs a extrude transform
BOOL	TransformConvertedObjectDoExtrudeTransPath (NodePath *pPath, cdrExtrudeInfo *Info)
	does the extrude transform on a path
BOOL	GetMatrixFromTransform (Matrix *M, ADDR Trans, INT32 Size, BOOL TranslateForPage=TRUE)
	given some transform data, works out a matrix. This ignores any 3D transforms, TransformConvertedObject should be used in preference.
BOOL	GetObjCorelBBox (NodeRenderableBounded *pNode, DocRect *BBox)
	gets the corel bbox of a converted object, looking up the bbox of text objects
KernelBitmap *	BitmapFromNodeList (Node *List)
	given a list of nodes, if it only contains one bitmap then return a pointer to that bitmap
BOOL	MakeTextOnPathLinkList ()
	creates the list of paths which should be linked to text stories to get text on paths.
BOOL	AttachTextToPaths ()
	attachs paths to text stories from the list of links.
BOOL	CheckTextForLinks (TextStory *pTextStory, cdrfOffsetHeader *Header)
	checks to see if this text story is in the link table
BOOL	GetTextStyleFromCDRStyle (CDRTextStyle *TS, WORD StyleRef, BOOL SearchForParent=TRUE)
	gets a text style from a CDR style. If it can't be found, you get the default text style. If SearchForParent is TRUE, the parent style of this style will be located
BOOL	GetTextStyleFromDefn (CDRTextStyle *TS, cdrfTextInfoFontDefn *FontDefn, const CDRTextStyle *BasedOn)
	gets a font style from a font definition stored in a txsm chunk. Anything not defined comes from the BasedOn style.
BOOL	ApplyTextAttr (Node *ContextNode, const CDRTextStyle *TS, const CDRTextStyle *BasedOn)
	Applies text attributes to a node from a CDRTextStyle. If BasedOn != 0 then the attributes will only be applied if they are different from those in *BasedOn.
BOOL	ApplyTextAttrDoApply (Node *ContextNode, TxtBaseClassAttribute *Attr, BOOL CheckExisting)
	Given a text attribute, apply it to a node. If CheckExising is TRUE, the existing attributes will be checked, and this attribute will not be applied if one of it's type already exists.
TCHAR *	GetFontName (WORD FontRef)
	finds a font name
BOOL	GetTextStyle3 (CDRTextStyle *TS, WORD Style, CDRTextStyle *BasedOn=0)
	gets a style for version 3 text from the global text styles table
BOOL	GetTextStyleFromChar4 (CDRTextStyle *TS, cdrfTextCharStyledV4 *Char, CDRTextStyle *BasedOn)
	gets a text style from a styled version 4 text character
Private Attributes
friend	CDRActionTransform
friend	CDRActionGroupEnd
friend	CDRBitmapStore
friend	CDRBitmap
Document *	pDocument
Spread *	pSpread
Page *	pPage
CDRVersion	Version
BOOL	Success
RIFFFile *	RIFF
UndoableOperation *	ThisOp
BOOL	SlowJobStarted
UINT32	ProgressCount
BOOL	InMasterPage
BOOL	DoneMasterPage
BOOL	DoneDoc
BOOL	UseLayers
CDRAttributeStore	Fills
CDRAttributeStore	Outlines
CDRAttributeStore	Styles
CDRFontnameStore	Fonts
CDRArrowheadStore	Arrowheads
CDRBitmapStore	Patterns
CDRBitmapStore	Bitmaps
CDRVectorStore	Vectors
CDRVectorStore	TextV4
CDRPageList	Pages
CDRPageListItem *	ThisPage
CDRLayerListItem *	ThisLayer
CDRActionList	Actions
CDRBBoxList	TextBBoxes
INT32	PageX
INT32	PageY
BOOL	Landscape
DocCoord	Origin
INT32	TranslateByX
INT32	TranslateByY
INT32	ObjectsConverted
INT32	ObjectsFormatWrong
INT32	ObjectsUnknown
INT32	EnvelopesApproximated
BOOL	FormatError
NodeRenderable *	pLevelNodeList
NodeRenderable *	pMadeNode
INT32	SerialNumber
BOOL	ObjFilled
BOOL	ObjStroked
BOOL	IsText
BOOL	IsTextStory
BOOL	AttrsAlreadyApplied
ADDR	ObjDataBlock
INT32	ObjDataBlockSize
ColourList *	ColList
ADDR	TransformChunk
INT32	TransformChunkSize
ADDR	FontTableV3
INT32	FontTableEntriesV3
ADDR	FontStylesV3
ADDR	LinkTable
BOOL	LinkTransformsExist
List	TextOnPathLinks
BOOL	IsTextOnAPath

---

Detailed Description

Corel Draw file importing class.

Author:

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

Date:

21 03 95

Definition at line 764 of file cdrfiltr.h.

---

Constructor & Destructor Documentation

CDRFilter::CDRFilter (  void   )

Constructor. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21 03 95 Parameters: As  for the Filter class [INPUTS] Returns: As for the Filter class See also: Filter Definition at line 234 of file cdrfiltr.cpp. { // Set up filter descriptions. FilterName.Load(_R(IDT_CDRFILTER_FILTERNAME)); FilterInfo.Load(_R(IDT_CDRFILTER_FILTERINFO)); FilterID = FILTERID_CDR; Flags.CanImport = TRUE; Flags.CanExport = FALSE; Version = CDRVERSION_NULL; }

---

Member Function Documentation

BOOL CDRFilter::AddArrowheadsToPath (  DWORD  StartArrow, DWORD  EndArrow, DocColour *  Col, INT32  LineWidth, LineCapType  Cap, JointType  Join )  [private]

adds arrowheads to a path. Changes pMadeNode from a path to a group Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 29 03 95 Parameters: [INPUTS]  Returns: error flag See also: Filter Definition at line 632 of file cdroutl.cpp. { if(!IS_A(pMadeNode, NodePath)) return TRUE; // don't apply arrowheads to non path things NodePath *pPath = (NodePath *)pMadeNode; // check that the path actaully needs some arrow heads if(!DoesPathNeedArrowheads(pPath) || (StartArrow == 0 && EndArrow == 0)) return TRUE; // get pointers to nodes of the arrow heads to copy NodeRenderableBounded *StartA = 0; NodeRenderableBounded *EndA = 0; INT32 StartDistance; INT32 EndDistance; if(StartArrow != 0) { BOOL NotPresent; StartA = Arrowheads.GetConvertedNode(StartArrow, &StartDistance, &NotPresent); if(StartA == 0 && NotPresent == FALSE) return FALSE; // error occurred } if(EndArrow != 0) { BOOL NotPresent; EndA = Arrowheads.GetConvertedNode(EndArrow, &EndDistance, &NotPresent); if(EndA == 0 && NotPresent == FALSE) return FALSE; // error occurred } // check that enough arrowheads were found to do something with if(StartA == 0 && EndA == 0) return TRUE; // get rid of any dash patterns DashRec NoDash; NoDash = SD_SOLID; SetDashPattern(NoDash); // get some info about the path DocCoord *Coords = pPath->InkPath.GetCoordArray(); PathVerb *Verbs = pPath->InkPath.GetVerbArray(); INT32 NCoords = pPath->InkPath.GetNumCoords(); INT32 SubPathStart = -1; // the number of the coord the sub path starts on INT32 SubPathEnd = -1; // the number of the coord the sub path ends on // set up a pointers for the nodes we're about to create - it points to the made // at first, but shuffles on as nodes are copied. You see, we have to copy nodes which // are attached to something NodeRenderableBounded *ThisNode = pPath; // work out the trim distances double StartTrimDistance; double EndTrimDistance; if(StartA != 0) StartTrimDistance = ((double)LineWidth / (double)cdrfARROWHEAD_LINEWIDTH) * (double)StartDistance; if(EndA != 0) EndTrimDistance = ((double)LineWidth / (double)cdrfARROWHEAD_LINEWIDTH) * (double)EndDistance; // run through all the coords INT32 c; for(c = 0; c < NCoords; c++) { UINT32 Verb = Verbs[c] & ~PT_CLOSEFIGURE; BOOL CloseHere = ((Verbs[c] & PT_CLOSEFIGURE) != 0)?TRUE:FALSE; // if the verb is a close figure, this sub path is close, so we can't add arrowheads // to it. Invalidate the path start to avoid getting any arrowheads if(CloseHere) SubPathStart = -1; // if we get a new moveto and the sub path start is valid then we have a applying arrowheads // situation if((Verb == PT_MOVETO || ((c == (NCoords - 1)) && !CloseHere)) && c != 0) { // set the sub path end if(Verb == PT_MOVETO) { // if it's a moveto, then the sub path end was at the previous coord SubPathEnd = c - 1; } else { // if it wasn't, then it's this one (end of path) SubPathEnd = c; } } // have we got a valid start path marker? if(SubPathStart != -1 && SubPathEnd != -1) { // OK, now we need to trim the sub path if(StartA != 0) { // trim the start of the path if the next element is a line if((Verbs[SubPathStart + 1] & ~PT_CLOSEFIGURE) == PT_LINETO) { double dx, dy; dx = Coords[SubPathStart + 1].x - Coords[SubPathStart].x; dy = Coords[SubPathStart + 1].y - Coords[SubPathStart].y; double len = sqrt((dx * dx) + (dy * dy)); // if the resulting path line leaves enough room, trim it if((len - StartTrimDistance) >= 32.0) { double factor = StartTrimDistance / len; dx *= factor; Coords[SubPathStart].x += (INT32)dx; dy *= factor; Coords[SubPathStart].y += (INT32)dy; } } // now pop an arrowhead on the resulting point // first, make a copy of our node if(!StartA->CopyNode(ThisNode, NEXT)) return FALSE; // error! ThisNode = (NodeRenderableBounded *)ThisNode->FindNext(); ERROR3IF(ThisNode == 0, "CopyNode returned a zero path but didn't complain"); ERROR3IF(ThisNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded)) == FALSE, "copied thing isn't a renderable bounded node"); // transform it if(!TransformArrowhead(ThisNode, &Coords[SubPathStart], &Coords[SubPathStart + 1], TRUE, LineWidth, StartDistance)) return FALSE; // and apply attributes to it if(!AddAttributesToArrowheadNode(ThisNode, Col, LineWidth, Cap, Join)) return FALSE; } // and the same for the end path if(EndA != 0) { if((Verbs[SubPathEnd] & ~PT_CLOSEFIGURE) == PT_LINETO) { double dx, dy; dx = Coords[SubPathEnd].x - Coords[SubPathEnd - 1].x; dy = Coords[SubPathEnd].y - Coords[SubPathEnd - 1].y; double len = sqrt((dx * dx) + (dy * dy)); // if the resulting path line leaves enough room, trim it if((len - EndTrimDistance) >= 32.0) { double factor = EndTrimDistance / len; dx *= factor; Coords[SubPathEnd].x += (INT32)dx; dy *= factor; Coords[SubPathEnd].y += (INT32)dy; } } // now pop an arrowhead on the resulting point // first, make a copy of our node if(!EndA->CopyNode(ThisNode, NEXT)) return FALSE; // error! ThisNode = (NodeRenderableBounded *)ThisNode->FindNext(); ERROR3IF(ThisNode == 0, "CopyNode returned a zero path but didn't complain"); ERROR3IF(ThisNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded)) == FALSE, "copied thing isn't a renderable bounded node"); // transform it if(!TransformArrowhead(ThisNode, &Coords[SubPathEnd], &Coords[SubPathEnd - 1], FALSE, LineWidth, EndDistance)) return FALSE; // and apply attributes to it if(!AddAttributesToArrowheadNode(ThisNode, Col, LineWidth, Cap, Join)) return FALSE; } } // set the new sub path start marker and invalidate the end point marker if(Verb == PT_MOVETO) { SubPathStart = c; SubPathEnd = -1; } } // ensure that the bounding rectangle is updated pPath->InvalidateBoundingRect(); // get a new group node NodeGroup *pGroup = new NodeGroup; if(pGroup == 0) return FALSE; // attach everything to it pMadeNode->InsertChainSimple(pGroup, FIRSTCHILD); // and make the made node the group pMadeNode = pGroup; return TRUE; }

BOOL CDRFilter::AddAttributesToArrowheadNode (  NodeRenderableBounded *  N, DocColour *  Col, INT32  LineWidth, LineCapType  Cap, JointType  Join )  [private]

apply attributes to a arrow head node Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 29 03 95 Parameters: node,colour  and line width [INPUTS] Returns: error flag See also: Filter Definition at line 442 of file cdroutl.cpp. { if(IS_A(N, NodeGroup)) { // go through all the members of the group setting their attributes Node *pNode; pNode = N->FindFirstChild(); while(pNode != 0) { if(IS_A(pNode, NodePath)) AddAttributesToArrowheadPath((NodePath *)pNode, Col, LineWidth, Cap, Join); pNode = pNode->FindNext(); } } else if(IS_A(N, NodePath)) { // simply apply the attributes to this path AddAttributesToArrowheadPath((NodePath *)N, Col, LineWidth, Cap, Join); } else { ERROR3("Something unexpected passed to AddAttributesToArrowheadNode"); } return TRUE; }

BOOL CDRFilter::AddAttributesToArrowheadPath (  NodePath *  P, DocColour *  Col, INT32  LineWidth, LineCapType  Cap, JointType  Join )  [private]

apply attributes to a arrow head path Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 29 03 95 Parameters: node,colour  and line width [INPUTS] Returns: error flag See also: Filter Definition at line 485 of file cdroutl.cpp. { if(P->InkPath.IsFilled) { // it's a filled path, so it need to be filled with the colour and have no line // colour SetPathFilled(TRUE); if(!SetLineColour(DocColour(COLOUR_TRANS)) || !SetFillColour(*Col)) return FALSE; } else { // it's not a filled colour, so don't fill it and stroke it with the line width and colour if(!SetLineColour(*Col) || !SetLineWidth(LineWidth) || !SetLineCap(Cap) || !SetJoinType(Join)) return FALSE; } // apply the attributes to the object // If not filled, then set the ignore bit on the fill attribute. // if (P->InkPath.IsFilled == FALSE) // CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = TRUE; // else CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = FALSE; // Add attributes to the path, if they are different from the default... BOOL Result = AttributeManager::ApplyBasedOnDefaults(P, CurrentAttrs); // DeleteCurrentAttrs(); // SetUpCurrentAttrs(); // Enable the fill attribute again CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = FALSE; return Result; }

BOOL CDRFilter::AddElementsToPath (  Path *  pPath, INT32  NCoords, cdrfCoord *  Coords, BYTE *  Types, BOOL *  IsClosed )  [static]

Adds elements to a path from a CDR path data. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 06/05/95 Parameters: path  to add too, number of coords, pointer to coord data, pointer to types [INPUTS] Returns: error flag See also: Definition at line 2476 of file cdrfiltr.cpp. { // go through the coordinates in the CDR path adding them to the Camelot path INT32 c; // coord counter UINT32 CoordType; // type of this coordinate UINT32 Control1 = 0; // number of first control point UINT32 Control2 = 0; // of second DocCoord co, cn1, cn2; // coordinates PathFlags Flags; BOOL NeedMoveTo = TRUE; if(IsClosed != 0) (*IsClosed) = FALSE; // go though converting all the coords for(c = 0; c < NCoords; c++) { CoordType = Types[c] & cdrfPATHCOORDTYPE_MASK; co.x = CDRDATA_SWORD(Coords[c].X) * CDRCOORDS_TO_MILLIPOINTS; co.y = CDRDATA_SWORD(Coords[c].Y) * CDRCOORDS_TO_MILLIPOINTS; // add in a move to if necessary if(NeedMoveTo && CoordType != cdrfPATHCOORDTYPE_MOVE) { if(!pPath->InsertMoveTo(co)) return FALSE; } NeedMoveTo = FALSE; // process the coordinate switch(CoordType) { case cdrfPATHCOORDTYPE_MOVE: // add a move to this path if(!pPath->InsertMoveTo(co)) return FALSE; break; case cdrfPATHCOORDTYPE_LINETO: // add a line to this coord to the path if(!pPath->InsertLineTo(co)) return FALSE; break; case cdrfPATHCOORDTYPE_CURVE: // check we have some control points for this curve // a control point cannot be the first coord, so it's OK to check against 0 if(Control1 == 0 || Control2 == 0) { TRACEUSER( "Ben", _T("No control points for curve element\n")); break; } // convert the control points cn1.x = CDRDATA_SWORD(Coords[Control1].X) * CDRCOORDS_TO_MILLIPOINTS; cn1.y = CDRDATA_SWORD(Coords[Control1].Y) * CDRCOORDS_TO_MILLIPOINTS; cn2.x = CDRDATA_SWORD(Coords[Control2].X) * CDRCOORDS_TO_MILLIPOINTS; cn2.y = CDRDATA_SWORD(Coords[Control2].Y) * CDRCOORDS_TO_MILLIPOINTS; // create the curve Flags.IsSelected = FALSE; Flags.IsSmooth = Flags.IsRotate = ((Types[c] & cdrfPATHCOORDATTR_SMOOTH) != 0)?TRUE:FALSE; Flags.IsEndPoint; // insert it into the path if(!pPath->InsertCurveTo(cn1, cn2, co, &Flags)) return FALSE; break; case cdrfPATHCOORDTYPE_CONTROL: // shuffle the control points we've already got and add the new one Control1 = Control2; Control2 = c; break; default: // can't get here as mask won't allow any other value than the ones above. break; } // is this a close subpath situtation? if((Types[c] & cdrfPATHCOORDATTR_CLOSE) != 0) { if(IsClosed != 0) (*IsClosed) = TRUE; // path has at least one closed element and should be filled // close the sub path if(CoordType != cdrfPATHCOORDTYPE_MOVE) { if(!pPath->CloseSubPath()) return FALSE; // ensure that the next coord is a moveto NeedMoveTo = TRUE; } } } return TRUE; }

BOOL CDRFilter::AddStandardColourSet (  Document *  pDocument  )  [static]

Adds the standard set of colours to a Corel file. / typedef struct { BYTE C, M, Y, K; TCHAR *Name; } StandardCDRColour; static StandardCDRColour StandardCDRColours[] = { {0, 0, 0, 100, "Black"}, {0, 0, 0, 90, "90% Black"}, {0, 0, 0, 80, "80% Black"}, {0, 0, 0, 70, "70% Black"}, {0, 0, 0, 60, "60% Black"}, {0, 0, 0, 50, "50% Black"}, {0, 0, 0, 40, "40% Black"}, {0, 0, 0, 30, "30% Black"}, {0, 0, 0, 20, "20% Black"}, {0, 0, 0, 10, "10% Black"}, {0, 0, 0, 0, "White"}, {100, 100, 0, 0, "Blue"}, {100, 0, 0, 0, "Cyan"}, {100, 0, 100, 0, "Green"}, {0, 0, 100, 0, "Yellow"}, {0, 100, 100, 0, "Red"}, {0, 100, 0, 0, "Magenta"}, {20, 80, 0, 20, "Purple"}, {0, 60, 100, 0, "Orange"}, {0, 40, 20, 0, "Pink"}, {0, 20, 20, 60, "Dark Brown"}, {20, 20, 0, 0, "Powder Blue"}, {40, 40, 0, 0, "Pastel Blue"}, {60, 40, 0, 0, "Baby Blue"}, {60, 60, 0, 0, "Electric Blue"}, {40, 40, 0, 20, "Twilight Blue"}, {60, 40, 0, 40, "Navy Blue"}, {40, 40, 0, 60, "Deep Navy Blue"}, {40, 20, 0, 40, "Desert Blue"}, {100, 20, 0, 0, "Sky Blue"}, {40, 0, 0, 0, "Ice Blue"}, {20, 0, 0, 20, "Light BlueGreen"}, {20, 0, 0, 40, "Ocean Green"}, {20, 0, 0, 60, "Moss Green"}, {20, 0, 0, 80, "Dark Green"}, {40, 0, 20, 60, "Forest Green"}, {60, 0, 40, 40, "Grass Green"}, {40, 0, 20, 40, "Kentucky Green"}, {60, 0, 40, 20, "Light Green"}, {60, 0, 60, 20, "Spring Green"}, {60, 0, 20, 0, "Turquoise"}, {60, 0, 20, 20, "Sea Green"}, {20, 0, 20, 20, "Faded Green"}, {20, 0, 20, 0, "Ghost Green"}, {40, 0, 40, 0, "Mint Green"}, {20, 0, 20, 40, "Army Green"}, {20, 0, 40, 40, "Avocado Green"}, {20, 0, 60, 20, "Martian Green"}, {20, 0, 40, 20, "Dull Green"}, {40, 0, 100, 0, "Chartreuse"}, {20, 0, 60, 0, "Moon Green"}, {0, 0, 20, 80, "Murky Green"}, {0, 0, 20, 60, "Olive Drab"}, {0, 0, 20, 40, "Khaki"}, {0, 0, 40, 40, "Olive"}, {0, 0, 60, 20, "Banana Yellow"}, {0, 0, 60, 0, "Light Yellow"}, {0, 0, 40, 0, "Chalk"}, {0, 0, 20, 0, "Pale Yellow"}, {0, 20, 40, 40, "Brown"}, {0, 40, 60, 20, "Red Brown"}, {0, 20, 60, 20, "Gold"}, {0, 60, 80, 0, "Autumn Orange"}, {0, 40, 80, 0, "Light Orange"}, {0, 40, 60, 0, "Peach"}, {0, 20, 100, 0, "Deep Yellow"}, {0, 20, 40, 0, "Sand"}, {0, 20, 40, 60, "Walnut"}, {0, 60, 60, 40, "Ruby Red"}, {0, 60, 80, 20, "Brick Red"}, {0, 60, 60, 0, "Tropical Pink"}, {0, 40, 40, 0, "Soft Pink"}, {0, 20, 20, 0, "Faded Pink"}, {0, 40, 20, 40, "Crimson"}, {0, 60, 40, 20, "Regal Red"}, {0, 60, 20, 20, "Deep Rose"}, {0, 100, 60, 0, "Neon Red"}, {0, 60, 40, 0, "Deep Pink"}, {0, 80, 40, 0, "Hot Pink"}, {0, 40, 20, 20, "Dusty Rose"}, {0, 40, 0, 60, "Plum"}, {0, 60, 0, 40, "Deep Violet"}, {0, 40, 0, 0, "Light Violet"}, {0, 40, 0, 20, "Violet"}, {0, 20, 0, 40, "Dusty Plum"}, {0, 20, 0, 20, "Pale Purple"}, {20, 60, 0, 20, "Majestic Purple"}, {20, 80, 0, 0, "Neon Purple"}, {20, 60, 0, 0, "Light Purple"}, {20, 40, 0, 20, "Twilight Violet"}, {20, 40, 0, 0, "Easter Purple"}, {20, 40, 0, 60, "Deep Purple"}, {20, 40, 0, 40, "Grape"}, {40, 60, 0, 0, "Blue Violet"}, {40, 100, 0, 0, "Blue Purple"}, {40, 80, 0, 20, "Deep River"}, {60, 80, 0, 0, "Deep Azure"}, {40, 60, 0, 40, "Storm Blue"}, {60, 80, 0, 20, "Deep Blue"}, {100, 100, 100, 100, "100C100M100Y100K"} }; /*! Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 05/06/95 Parameters: [INPUTS]  Returns: Definition at line 1322 of file cdroutl.cpp. { ColourListComponent *pColours = 0; DocComponent *pComponent = pDocument->EnumerateDocComponents(NULL); while (pComponent != NULL) { // If this is the colour component, remember it if (pComponent->GetRuntimeClass() == CC_RUNTIME_CLASS(ColourListComponent)) { pColours = (ColourListComponent *) pComponent; break; } // Look for next doc component pComponent = pDocument->EnumerateDocComponents(pComponent); } if(pColours == 0) return TRUE; // can't be bothered to complain nicely about this very unlikely error // get an importedcolours object ImportedColours *pNewColours = new ImportedColours(pColours, FALSE); if(pNewColours == 0 || !pNewColours->Init()) return FALSE; BOOL ok = TRUE; // add colours to it... ColourCMYK NewColour; for(INT32 l = 0; l < (sizeof(StandardCDRColours) / sizeof(StandardCDRColour)); l++) { NewColour.Cyan = ((double)StandardCDRColours[l].C) / 100; NewColour.Magenta = ((double)StandardCDRColours[l].M) / 100; NewColour.Yellow = ((double)StandardCDRColours[l].Y) / 100; NewColour.Key = ((double)StandardCDRColours[l].K) / 100; String_64 ColNameS(StandardCDRColours[l].Name); if(!pNewColours->AddColour(&ColNameS, &NewColour)) { ok = FALSE; break; } } // add the colours to the document if(ok) { pNewColours->AddColoursToDocument(); } else { pNewColours->DestroyColours(); } // delete the imported colours object delete pNewColours; return ok; }

BOOL CDRFilter::ApplyTextAttr (  Node *  ContextNode, const CDRTextStyle *  TS, const CDRTextStyle *  BasedOn )  [private]

Applies text attributes to a node from a CDRTextStyle. If BasedOn != 0 then the attributes will only be applied if they are different from those in *BasedOn. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27/04/95 Parameters: [INPUTS]  Returns: error flag See also: Definition at line 1623 of file cdrtext.cpp. { BOOL CheckExisting = FALSE; // if the node has children, then we want to check existing attributes if(ContextNode->FindFirstChild() != 0) CheckExisting = TRUE; // apply italicness if(BasedOn == 0 || TS->Italic != BasedOn->Italic) { // make a font size attribute TxtItalicAttribute Attr(TS->Italic); // attach if(!ApplyTextAttrDoApply(ContextNode, &Attr, CheckExisting)) return FALSE; } // apply boldness if(BasedOn == 0 || TS->Bold != BasedOn->Bold) { // make a font size attribute TxtBoldAttribute Attr(TS->Bold); // attach if(!ApplyTextAttrDoApply(ContextNode, &Attr, CheckExisting)) return FALSE; } // apply underline if(BasedOn == 0 || TS->Underline != BasedOn->Underline) { // make a font size attribute TxtUnderlineAttribute Attr(TS->Underline); // attach if(!ApplyTextAttrDoApply(ContextNode, &Attr, CheckExisting)) return FALSE; } // apply the scriptness if(BasedOn == 0 || TS->Script != BasedOn->Script) { if(TS->Script != CDRSCRIPT_NONE) { TxtScriptAttribute Attr((TS->Script == CDRSCRIPT_SUB)?-0.1:0.33, 0.5); // attach if(!ApplyTextAttrDoApply(ContextNode, &Attr, CheckExisting)) return FALSE; } } // apply font size if(BasedOn == 0 || TS->FontSize != BasedOn->FontSize) { // make a font size attribute TxtFontSizeAttribute Attr(TS->FontSize); // attach if(!ApplyTextAttrDoApply(ContextNode, &Attr, CheckExisting)) return FALSE; } // apply font name // if(BasedOn == 0 || TS->FontName != BasedOn->FontName) if(BasedOn == 0 || TS->FontReference != BasedOn->FontReference) { // get a font handle WORD hTypeface = Fonts.GetHandleForReference(TS->FontReference); //WORD hTypeface = FONTMANAGER->GetFontHandle(&String_64(TS->FontName)); // make a typeface attribute TxtFontTypefaceAttribute Attr(hTypeface); // attach if(!ApplyTextAttrDoApply(ContextNode, &Attr, CheckExisting)) return FALSE; } // apply the justification stuff if((BasedOn == 0 || TS->Just != BasedOn->Just) && TS->Just != JLEFT) { // make a justification attribute TxtJustificationAttribute Attr(TS->Just); // attach if(!ApplyTextAttrDoApply(ContextNode, &Attr, CheckExisting)) return FALSE; } // slap on a aspect ratio thingy so it gets transformed OK TxtAspectRatioAttribute Attr(1); if(!ApplyTextAttrDoApply(ContextNode, &Attr, CheckExisting)) return FALSE; return TRUE; }

BOOL CDRFilter::ApplyTextAttrDoApply (  Node *  ContextNode, TxtBaseClassAttribute *  Attr, BOOL  CheckExisting )  [private]

Given a text attribute, apply it to a node. If CheckExising is TRUE, the existing attributes will be checked, and this attribute will not be applied if one of it's type already exists. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27/04/95 Parameters: [INPUTS]  Returns: error flag See also: Definition at line 1740 of file cdrtext.cpp. { // check given attribute if(Attr == 0) return FALSE; // make a node out of it NodeAttribute *pNode = Attr->MakeNode(); if(pNode == 0) return FALSE; // if necessary check existing attributes if(CheckExisting) { Node *SearchNode = ContextNode->FindFirstChild(); // run through it's children while(SearchNode != 0) { if(IS_SAME_CLASS(pNode, SearchNode)) { // found an attribute just like the one we're thinking of applying... delete pNode; return TRUE; // don't need to do anything more } SearchNode = SearchNode->FindNext(); } } // attach the node pNode->AttachNode(ContextNode, FIRSTCHILD); return TRUE; }

BOOL CDRFilter::AttachTextToPaths (   )  [private]

attachs paths to text stories from the list of links. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 09/06/95 Parameters: -  [INPUTS] Returns: error flag See also: CDRFilter Definition at line 2621 of file cdrtext.cpp. { // set attributes to no colours - we mustn't render these here paths if(!SetFillColour(DocColour(COLOUR_TRANS))) return FALSE; if(!SetLineColour(DocColour(COLOUR_TRANS))) return FALSE; CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = TRUE; // go through the entries in the list... CDRTextOnPathLink *Item = (CDRTextOnPathLink *)TextOnPathLinks.GetHead(); while(Item != 0) { // if this is complete, process it if(Item->pPath != 0 && Item->pTextStory != 0) { // both things were found, so join them up nicely... // make a copy of the path NodePath *pPath; if(!Item->pPath->NodeCopy((Node **)&pPath)) return FALSE; // delete it's old attributes pPath->DeleteChildren(pPath->FindFirstChild()); // apply some attributes to the path pPath->InkPath.IsFilled = FALSE; pPath->InkPath.IsStroked = FALSE; if(!AttributeManager::ApplyBasedOnDefaults(pPath, CurrentAttrs)) return FALSE; // and attach the nodes together Node *pFirstLine = Item->pTextStory->FindFirstChild(CC_RUNTIME_CLASS(TextLine)); ERROR2IF(pFirstLine == 0, FALSE, "TextStory had no line when attaching path"); pPath->AttachNode(pFirstLine, PREV); // now sort out justification along the path if(Item->Justi != JLEFT) { // knock up an attribute and pop it on TxtJustificationAttribute Attr(Item->Justi); NodeAttribute *pNode = Attr.MakeNode(); if(pNode == 0) return FALSE; pNode->AttachNode(Item->pTextStory, FIRSTCHILD); } else { TRACEUSER( "Ben", _T("Text on path not completed: path serial = %d, path ptr = %X\ntext serial = %d, text ptr = %X\n\n"), Item->PathSerialNumber, Item->pPath, Item->TextSerialNumber, Item->pTextStory); } // and the positioning Item->pTextStory->SetImportBaseShift((BaseShiftEnum)Item->Position); } // next! Item = (CDRTextOnPathLink *)TextOnPathLinks.GetNext(Item); } return TRUE; }

KernelBitmap * CDRFilter::BitmapFromNodeList (  Node *  List  )  [private]

given a list of nodes, if it only contains one bitmap then return a pointer to that bitmap Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 20/04/95 Parameters: pointer  to first node in a list [INPUTS] Returns: a pointer to the relevant bitmap, or zero if one couldn't be found See also: Filter Definition at line 1716 of file cdrfill.cpp. { // make sure we've got something if(List == 0) return 0; // is there's more than one item? if(List->FindNext() != 0) return 0; // is it a bitmap? if(IS_A(List, NodeBitmap)) { // right then, woz it's bitmap den? NodeBitmap *NB = (NodeBitmap *)List; // return the bitmap... return NB->GetBitmap(); } return 0; }

CDRFilter::CC_DECLARE_DYNAMIC (  CDRFilter   )  [private]

BOOL CDRFilter::CheckTextForLinks (  TextStory *  pTextStory, cdrfOffsetHeader *  Header )  [private]

checks to see if this text story is in the link table Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 09/06/95 Parameters: -  [INPUTS] Returns: error flag See also: CDRFilter Definition at line 2699 of file cdrtext.cpp. { if(IsTextOnAPath != TRUE) return TRUE; // not on a path, so don't search // go through the entries in the list... CDRTextOnPathLink *Item = (CDRTextOnPathLink *)TextOnPathLinks.GetHead(); while(Item != 0) { // does this link refer to this text story? if(SerialNumber == Item->TextSerialNumber) { // yep - make the entry refer to this text story Item->pTextStory = pTextStory; // set up some justification and positioning stuff cdrfTextOnPathInfo *Info; if((Info = (cdrfTextOnPathInfo *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_PATHTEXT1)) != 0) { switch(CDRDATA_WORD(Info->Alignment)) { case cdrfTEXTONPATHALIGN_RIGHT: Item->Justi = JRIGHT; break; case cdrfTEXTONPATHALIGN_CENTRE: Item->Justi = JCENTRE; break; default: case cdrfTEXTONPATHALIGN_LEFT: Item->Justi = JLEFT; break; } switch(CDRDATA_WORD(Info->Position)) { case cdrfTEXTONPATHPOS_BOTTOM: Item->Position = AlignDescenders; break; case cdrfTEXTONPATHPOS_TOP: Item->Position = AlignAscenders; break; case cdrfTEXTONPATHPOS_CENTRE: Item->Position = AlignCentres; break; case cdrfTEXTONPATHPOS_BASELINE: default: Item->Position = AlignBaseline; break; } } // return now so we don't get duplicates... return TRUE; } // next! Item = (CDRTextOnPathLink *)TextOnPathLinks.GetNext(Item); } return TRUE; }

BOOL CDRFilter::ClearUp (  void   )  [private]

Clears up after an CDR file import. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21 03 95 Parameters: [INPUTS]  Returns: See also: Filter Definition at line 4632 of file cdrfiltr.cpp. { Version = CDRVERSION_NULL; if(SlowJobStarted == TRUE) EndSlowJob(); if(Success == FALSE) { // get rid of the actions list while(!Actions.IsEmpty()) { CDRActionListItem *Act = (CDRActionListItem *)Actions.GetTail(); ERROR3IF(Act == 0, "Returned tail in a non-empty Action list is 0"); Act->ImportFailure(this); delete Actions.RemoveItem(Act); } // get rid of the level's list of nodes DeleteNodeList(pLevelNodeList); // tell everyone about some new layers, if we were doing them if(UseLayers) { LayerSGallery::MakeTopLayerActive(pSpread); BROADCAST_TO_ALL(SpreadMsg(pSpread, SpreadMsg::LAYERCHANGES)); } } TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), Fills has %d entries\n"), Fills.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), Outlines has %d entries\n"), Outlines.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), Styles has %d entries\n"), Styles.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), Fonts has %d entries\n"), Fonts.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), Arrowheads has %d entries\n"), Arrowheads.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), Patterns has %d entries\n"), Patterns.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), Bitmaps has %d entries\n"), Bitmaps.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), Vectors has %d entries\n"), Vectors.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), TextV4 has %d entries\n"), TextV4.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), Pages has %d entries\n"), Pages.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), Actions has %d entries\n"), Actions.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), TextBBoxes has %d entries\n"), TextBBoxes.GetCount()); TRACEUSER( "Ben", _T("At CDRFilter::ClearUp(), TextOnPathLinks has %d entries\n"), TextOnPathLinks.GetCount()); TRACEUSER( "Ben", _T("ObjectsConverted = %d\nObjectsFormatWrong = %d\nObjectsUnknown = %d\nEnvelopesApproximated = %d\n"), ObjectsConverted, ObjectsFormatWrong, ObjectsUnknown, EnvelopesApproximated); ERROR3IF(Success == TRUE && Actions.GetCount() != 0, "Not all actions used at the end of a successful CDR convert!"); Fills.DeleteAll(); Outlines.DeleteAll(); Styles.DeleteAll(); Fonts.DeleteAll(); Arrowheads.DeleteAll(); Patterns.DeleteAll(); Bitmaps.DeleteAll(); Vectors.DeleteAll(); TextV4.DeleteAll(); Pages.DeleteAll(); Actions.DeleteAll(); TextBBoxes.DeleteAll(); TextOnPathLinks.DeleteAll(); // avoid indexedcolour in uses ColourCMYK CNullCol; CNullCol.Cyan = 1; CNullCol.Magenta = 1; CNullCol.Yellow = 1; CNullCol.Key = 1; DocColour NullCol = DocColour(COLOURMODEL_CMYK, (ColourGeneric *)&CNullCol); SetLineColour(NullCol); SetFillColour(NullCol); // delete the current attributes DeleteCurrentAttrs(); // free a few data blocks CCFree(ObjDataBlock); CCFree(FontTableV3); CCFree(FontStylesV3); CCFree(LinkTable); TRACEUSER( "Ben", _T("ClearUp finished - import of CDR over\n")); return Success; }

BOOL CDRFilter::ConvertBitmap (  cdrfOffsetHeader *   )  [private]

Definition at line 2743 of file cdrfiltr.cpp. { // find the address of the coordinates in the header cdrfBitmapData *BInfo = (cdrfBitmapData *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS); // it has got some object data, hasn't it? if(BInfo == 0) { FormatError = TRUE; return TRUE; } // OK, let's get the information in a nice structure to start off with struct { DWORD Reference; INT32 SizeX; INT32 SizeY; INT32 Left; // cropping coordinates INT32 Right; INT32 Bottom; INT32 Top; } Info; // choose the right reference - it's in a slightly different place in CDR 3 files if(Version != CDRVERSION_3) { Info.Reference = CDRDATA_WORD(BInfo->BitmapReference); Info.SizeX = CDRDATA_SWORD(BInfo->SizeX) * CDRCOORDS_TO_MILLIPOINTS; Info.SizeY = CDRDATA_SWORD(BInfo->SizeY) * CDRCOORDS_TO_MILLIPOINTS; Info.Left = CDRDATA_SWORD(BInfo->Left) * CDRCOORDS_TO_MILLIPOINTS; Info.Right = CDRDATA_SWORD(BInfo->Right) * CDRCOORDS_TO_MILLIPOINTS; Info.Bottom = CDRDATA_SWORD(BInfo->Bottom) * CDRCOORDS_TO_MILLIPOINTS; Info.Top = CDRDATA_SWORD(BInfo->Top) * CDRCOORDS_TO_MILLIPOINTS; } else { cdrfBitmapData3 *B3Info = (cdrfBitmapData3 *)BInfo; Info.Reference = CDRDATA_WORD(B3Info->BitmapReference); Info.SizeX = CDRDATA_SWORD(B3Info->SizeX) * CDRCOORDS_TO_MILLIPOINTS; Info.SizeY = CDRDATA_SWORD(B3Info->SizeY) * CDRCOORDS_TO_MILLIPOINTS; Info.Left = CDRDATA_SWORD(B3Info->Left) * CDRCOORDS_TO_MILLIPOINTS; Info.Right = CDRDATA_SWORD(B3Info->Right) * CDRCOORDS_TO_MILLIPOINTS; Info.Bottom = CDRDATA_SWORD(B3Info->Bottom) * CDRCOORDS_TO_MILLIPOINTS; Info.Top = CDRDATA_SWORD(B3Info->Top) * CDRCOORDS_TO_MILLIPOINTS; } // find that there bitmap KernelBitmap *pBitmap = Bitmaps.FindBitmap(Info.Reference); if(pBitmap == 0) { FormatError = TRUE; return TRUE; } // find a bounding box for the bitmap on the page DocRect BoundsRect; if(Info.SizeX > 0) { BoundsRect.lo.x = 0; BoundsRect.hi.x = Info.SizeX; } else { BoundsRect.lo.x = Info.SizeX; BoundsRect.hi.x = 0; } if(Info.SizeY > 0) { BoundsRect.lo.y = 0; BoundsRect.hi.y = Info.SizeY; } else { BoundsRect.lo.y = Info.SizeY; BoundsRect.hi.y = 0; } // OK, if the bitmap isn't cropped, create a bitmap object, otherwise // create a rectangle which is the right size and pop a bitmap fill on it if(Info.Left == 0 && Info.Right == Info.SizeX && Info.Top == 0 && Info.Bottom == Info.SizeY) { // create a bitmap object NodeBitmap *NewBitmap = new NodeBitmap; if((NewBitmap == NULL) || !NewBitmap->SetUpPath()) return FALSE; NewBitmap->CreateShape(BoundsRect); // set the reference to the bitmap NewBitmap->GetBitmapRef()->Attach(pBitmap, GetDocument()); if (NewBitmap->GetBitmap() != pBitmap) { // It didn't use the bitmap we gave it, so we can delete it delete pBitmap; } // apply a few nice attributes to it NewBitmap->ApplyDefaultBitmapAttrs(0); // invalidate the bounding rectangle NewBitmap->InvalidateBoundingRect(); // cool. ObjFilled = FALSE; ObjStroked = FALSE; // we don't want any of those fancy attributes things on this object. AttrsAlreadyApplied = TRUE; // set the made node pMadeNode = NewBitmap; } else { // create a rectangular path object... // generate a path NodePath *pPath = new NodePath; if(pPath == 0 || (!pPath->SetUpPath())) { delete pPath; return FALSE; // no room to create it } // position the new elements at the beginning of the path pPath->InkPath.FindStartOfPath(); DocCoord co, cn1, cn2; // make the rectangle shape BITM_MOVE(Info.Left, Info.Bottom) BITM_LINE(Info.Right, Info.Bottom) BITM_LINE(Info.Right, Info.Top) BITM_LINE(Info.Left, Info.Top) BITM_LINE(Info.Left, Info.Bottom) BITM_CLOSE // finish off the path pPath->InvalidateBoundingRect(); pPath->InkPath.IsFilled = TRUE; // set up an attribute or two ObjFilled = TRUE; ObjStroked = FALSE; // set up a nice attribute for this thingy if(!SetLineColour(DocColour(COLOUR_TRANS))) return FALSE; // set a nice bitmap fill DocCoord Start = DocCoord(BoundsRect.lo.x, BoundsRect.lo.y); DocCoord End1 = DocCoord(BoundsRect.hi.x, BoundsRect.lo.y); DocCoord End2 = DocCoord(BoundsRect.lo.x, BoundsRect.hi.y); if(!SetBitmapFill(pBitmap, Start, End1, End2)) return FALSE; // apply attributes SetPathFilled(TRUE); CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = FALSE; if(!AttributeManager::ApplyBasedOnDefaults(pPath, CurrentAttrs)) return FALSE; // don't apply attributes later AttrsAlreadyApplied = TRUE; // set the made node pMadeNode = pPath; } return TRUE; }

BOOL CDRFilter::ConvertColour (  cdrfColour *  Col, DocColour *  Out )  [private]

converts a colour from the CDR definition taking into account the version Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 28 03 95 Parameters: cdr  colour and a DocColour to put it into [INPUTS] Returns: error flag See also: Filter Definition at line 1970 of file cdrfiltr.cpp. { ERROR3IF(Col == 0 || Out == 0, "Null pointers passed to ConvertColour"); ImportedNewColour ICol; switch(Version) { case CDRVERSION_5: CDRColour::Convert5(Col, &ICol); break; case CDRVERSION_4: CDRColour::Convert4(Col, &ICol); break; default: CDRColour::Convert3(Col, &ICol); break; } IndexedColour *NewCol = new IndexedColour(ICol.Model, &ICol.Colour); if(NewCol == 0) return FALSE; ColList->GetUnnamedColours()->AddTail(NewCol); Out->MakeRefToIndexedColour(NewCol); return TRUE; }

BOOL CDRFilter::ConvertEllipse (  cdrfOffsetHeader *  Header  )  [private]

generates an ellipse object Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27 03 95 Parameters: pointer  to header [INPUTS] Returns: error flag See also: Definition at line 2671 of file cdrfiltr.cpp. { // find the address of the coordinates in the header cdrfEllipseData *Size = (cdrfEllipseData *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS); // it has got some coords, hasn't it? if(Size == 0) { FormatError = TRUE; return TRUE; } // Create the ellipse NodeRegularShape *NewShape = new (NodeRegularShape); if ((NewShape == NULL) || !NewShape->SetUpShape() ) { ERROR1(FALSE, _R(IDS_OUT_OF_MEMORY)); } // fill it all in for an ellipse NewShape->SetNumSides(4); INT32 Width = CDRDATA_SWORD(Size->Width) * CDRCOORDS_TO_MILLIPOINTS; INT32 Height = CDRDATA_SWORD(Size->Height) * CDRCOORDS_TO_MILLIPOINTS; DocCoord co; co.x = Width / 2; // centre - it all starts at (0,0) co.y = Height / 2; NewShape->SetCentrePoint(co); co.x = Width; NewShape->SetMajorAxes(co); co.x /= 2; co.y = Height; NewShape->SetMinorAxes(co); NewShape->SetCircular(TRUE); NewShape->SetStellated(FALSE); NewShape->SetPrimaryCurvature(TRUE); NewShape->SetStellationCurvature(FALSE); // finish off the path NewShape->InvalidateBoundingRect(); // set up an attribute or two ObjFilled = TRUE; ObjStroked = TRUE; // set the made node pMadeNode = NewShape; return TRUE; }

BOOL CDRFilter::ConvertPath (  cdrfOffsetHeader *  Header  )  [private]

actually converts a path object to a node. If the object has an unexpected format, then FormatError is set and it return *TRUE* - the return value only indicated environmental errors such as lack of memory Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24 03 95 Parameters: none  [INPUTS] Returns: error flag See also: Definition at line 2371 of file cdrfiltr.cpp. { // find the address of the coordinates in the header cdrfPathCoordHeader *CHdr = (cdrfPathCoordHeader *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS); // it has got some coords, hasn't it? if(CHdr == 0) { FormatError = TRUE; return TRUE; } // find the address of the types and the coordinates cdrfCoord *Coords = (cdrfCoord *)(CHdr + 1); // and the address of the types UINT32 NCoords = CDRDATA_WORD(CHdr->NCoords); BYTE *Types = (BYTE *)(Coords + NCoords); // check the path a little if((NCoords * (sizeof(cdrfCoord) + sizeof(BYTE))) > CDRDATA_WORD(Header->Size) || NCoords < 2) { FormatError = TRUE; return TRUE; } // knock up a path node NodePath *pPath = new NodePath; if(pPath == 0 || (!pPath->SetUpPath())) { delete pPath; return FALSE; // no room to create it } // position the new elements at the beginning of the path pPath->InkPath.FindStartOfPath(); // flag the initial status of the fill/stokedness of the path ObjFilled = FALSE; ObjStroked = TRUE; if(!AddElementsToPath(&pPath->InkPath, NCoords, Coords, Types, &ObjFilled)) goto NoMemory; // check that the path is OK if(!pPath->InkPath.EnsureValid()) { // no, it's completely knackered delete pPath; FormatError = TRUE; return TRUE; } // finish off the path pPath->InvalidateBoundingRect(); pPath->InkPath.IsFilled = ObjFilled; // save node pointer pMadeNode = pPath; // check to see if text goes along this... { CDRTextOnPathLink *Item = (CDRTextOnPathLink *)TextOnPathLinks.GetHead(); while(Item != 0) { // does this link refer to this text story? if(SerialNumber == Item->PathSerialNumber) { // yep - store a pointer to this path Item->pPath = pPath; } // next! Item = (CDRTextOnPathLink *)TextOnPathLinks.GetNext(Item); } } // everything was nice return TRUE; NoMemory: // get rid of any path which is in the process of being created if(pPath != 0) pPath->CascadeDelete(); delete pPath; return FALSE; }

BOOL CDRFilter::ConvertRectangle (  cdrfOffsetHeader *   )  [private]

Definition at line 2602 of file cdrfiltr.cpp. { // find the address of the coordinates in the header cdrfRectangleData *Size = (cdrfRectangleData *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS); // it has got some coords, hasn't it? if(Size == 0) { FormatError = TRUE; return TRUE; } // get the dimensions from the object INT32 Width = CDRDATA_SWORD(Size->Width) * CDRCOORDS_TO_MILLIPOINTS; INT32 Height = CDRDATA_SWORD(Size->Height) * CDRCOORDS_TO_MILLIPOINTS; INT32 CornerRadius = CDRDATA_SWORD(Size->CornerRadius) * CDRCOORDS_TO_MILLIPOINTS; if(CornerRadius < 0) CornerRadius = 0 - CornerRadius; // make a rectangle quickshape... NodeRegularShape *NewShape = new (NodeRegularShape); if ((NewShape == NULL) || !NewShape->SetUpShape() ) { ERROR1(FALSE, _R(IDS_OUT_OF_MEMORY)); } INT32 AWidth = Width; INT32 AHeight = Height; if(AWidth < 0) AWidth = 0 - AWidth; if(AHeight < 0) AHeight = 0 - AHeight; if(!NewShape->MakeRectangle(AWidth, AHeight, CornerRadius)) return FALSE; // translate it a bit so the corner is on the origin, not the thingy Trans2DMatrix Trans(Width / 2, Height / 2); NewShape->Transform(Trans); // finish off the shape NewShape->InvalidateBoundingRect(); // set up an attribute or two ObjFilled = TRUE; ObjStroked = TRUE; // set the made node pMadeNode = NewShape; return TRUE; }

BOOL CDRFilter::ConvertText (  cdrfOffsetHeader *  Header  )  [private]

converts a text object to a node. If the object has an unexpected format, then FormatError is set and it return *TRUE* - the return value only indicated environmental errors such as lack of memory Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24 03 95 Parameters: none  [INPUTS] Returns: error flag See also: 1.2 Definition at line 136 of file cdrtext.cpp. { // check to see if this has an offset for text on a path if(FindDataInObject(Header, cdrfOBJOFFSETTYPE_PATHTEXT1) != 0 && FindDataInObject(Header, cdrfOBJOFFSETTYPE_PATHTEXT2) != 0) { IsTextOnAPath = TRUE; } else { IsTextOnAPath = FALSE; } // hey, this is text! IsText = TRUE; IsTextStory = FALSE; // dispatch conversion to appropriate routine if(Version == CDRVERSION_3) return ConvertText3(Header); if(Version == CDRVERSION_4) { if(CDRDATA_WORD(Header->ObjectType) == cdrfOBJTYPE_TEXT) { return ConvertText4Art(Header); } else { return ConvertText4Para(Header); } } // if it's a text story we're fiddling with, see how big the frame is INT32 FrameX = 0, FrameY = 0; DocCoord Trans = DocCoord(0,0); if(Header->ObjectType == cdrfOBJTYPE_TEXTSTORY) { // find the size of the object cdrfTextStoryCoordData *Coords = (cdrfTextStoryCoordData *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS); if(Coords == 0) { FormatError = TRUE; return TRUE; } FrameX = CDRDATA_WORD(Coords->XSize); FrameY = CDRDATA_WORD(Coords->YSize); TRACEUSER( "Ben", _T("Initial frame dimensions: X = %d Y = %d\n"), FrameX, FrameY); IsTextStory = TRUE; } else { IsTextStory = FALSE; } // OK, the header supplied here is in a block of it's own so we can aquire a new RIFF block // for the text info // the RIFF object will be at a loda chunk, which is at a one higher level than that of // the txsm chunk - find level we don't want to seek over ERROR3IF(RIFF->GetObjType() != RIFFOBJECTTYPE_CHUNK || RIFF->GetObjChunkType() != cdrT_loda, "CDFFilter::ConvertText called with RIFF on a non-loda chunk"); UINT32 EndLevel = RIFF->GetObjLevel() - 1; // now stroll though the RIFF file // stop when we find a txsm chunk, and store any trfd chunks we might meet on the way BOOL Found = FALSE; do { if(RIFF->GetObjType() == RIFFOBJECTTYPE_CHUNK && RIFF->GetObjChunkType() == cdrT_txsm) { // found the text info thingy Found = TRUE; } else if(RIFF->GetObjType() == RIFFOBJECTTYPE_LISTSTART && RIFF->GetObjChunkType() == cdrT_trfl) { // grab the list contents if(!RIFF->GetListContents(&TransformChunk, &TransformChunkSize)) return FALSE; } UpdateProgress(); if(!Found) if(!RIFF->NextObject()) return FALSE; } while(Found == FALSE && (RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() >= EndLevel)); if(RIFF->GetObjType() != RIFFOBJECTTYPE_CHUNK || RIFF->GetObjChunkType() != cdrT_txsm) { FormatError = TRUE; return TRUE; } // get size of chunk INT32 TextInfoSize = RIFF->GetObjSize(); // aquire the chunk data if(!RIFF->AquireChunkData()) return FALSE; // and get a pointer to the 'nice' info chunk ADDR TextInfo; if((TextInfo = RIFF->GetAquiredData()) == 0) { return FALSE; } cdrfTextInfoHdr *TIH = (cdrfTextInfoHdr *)TextInfo; // make a new text story node TextStory *TSNode = new TextStory; if(TSNode == 0) return FALSE; // get the number of paragraphs UINT32 NParagraphs = CDRDATA_WORD(TIH->NParagraphs); // set up some variables INT32 Loc = sizeof(cdrfTextInfoHdr); INT32 FirstLineSpace = -1; INT32 InitialFirstLineSpace = -1; INT32 ThisLineSpace = 0; INT32 PreviousLineSpace = 0; INT32 MaximumLineX = 0; // MaximumLineX and INT32 Lines = 1; // Lines only used for artisitic text Justification Just; // the justification // convert the paragraph UINT32 CurrentPara; INT32 LineX; for(CurrentPara = 0; CurrentPara < NParagraphs; CurrentPara++) { // set up a few things LineX = 0; // current position in the line // check sizes if((Loc + (INT32)sizeof(cdrfTextInfoParaHdr)) > TextInfoSize) break; // get paragraph header info cdrfTextInfoParaHdr *ParaHdr = (cdrfTextInfoParaHdr *)(TextInfo + Loc); Loc += sizeof(cdrfTextInfoParaHdr); // sort out font style definitions INT32 NFontDefns = CDRDATA_WORD(ParaHdr->NFontDefns); if((Loc + ((INT32)sizeof(cdrfTextInfoFontDefn) * NFontDefns)) > TextInfoSize) break; cdrfTextInfoFontDefn *FontDefns = (cdrfTextInfoFontDefn *)(TextInfo + Loc); Loc += (sizeof(cdrfTextInfoFontDefn) * NFontDefns); // get some memory for the converted font styles if(NFontDefns <= 0) break; CDRTextStyle *Styles = new CDRTextStyle[NFontDefns]; // convert the first definiton from the style if(!GetTextStyleFromCDRStyle(&Styles[0], ParaHdr->Style)) goto NoMemory; // store the justificationness Just = Styles[0].Just; // just in case of random Corel behaviour... PreviousLineSpace = (Styles[0].FontSize * 12) / 10; // go through translating all the other styles for(INT32 l = 1; l < NFontDefns; l++) { if(!GetTextStyleFromDefn(&Styles[l], &FontDefns[l], &Styles[0])) return FALSE; } // get the paragraph info if((Loc + (INT32)sizeof(cdrfTextInfoParaInfo)) > TextInfoSize) break; cdrfTextInfoParaInfo *PInfo = (cdrfTextInfoParaInfo *)(TextInfo + Loc); Loc += sizeof(cdrfTextInfoParaInfo); INT32 NChars = CDRDATA_WORD(PInfo->NChars); // sort out the character array if((Loc + ((INT32)sizeof(cdrfTextInfoChar) * NChars)) > TextInfoSize) break; cdrfTextInfoChar *Chars = (cdrfTextInfoChar *)(TextInfo + Loc); Loc += (sizeof(cdrfTextInfoChar) * NChars); // make a new text line for this paragraph TextLine *CurrentLine = new TextLine(TSNode, LASTCHILD); if(CurrentLine == 0) goto NoMemory; // and run through adding all those nice characters INT32 CurrentChar; for(CurrentChar = 0; CurrentChar < NChars; CurrentChar++) { BOOL NewLine = FALSE; // whether to create a new line here if(IsTextStory == FALSE && CDRDATA_WORD(Chars[CurrentChar].Code) == cdrfTEXT_NEWLINE) { // update a couple of artisitic text only variables Lines++; if(LineX > MaximumLineX) MaximumLineX = LineX; // create a new line NewLine = TRUE; } // find the style of the character INT32 Style = ((CDRDATA_WORD(Chars[CurrentChar].Info)) & cdrfTEXTINFOCHAR_INFO_DEFNMASK) >> cdrfTEXTINFOCHAR_INFO_DEFNMASKSBY; // create it if(CDRDATA_WORD(Chars[CurrentChar].Code) >= ' ') { TextChar *C = new TextChar(CurrentLine, LASTCHILD, CDRDATA_WORD(Chars[CurrentChar].Code)); if(C == 0) goto NoMemory; if(Style < 0 || Style >= NFontDefns) Style = 0; // apply attributes if(!ApplyTextAttr(C, &Styles[Style], 0 /*&Styles[0]*/)) // for now, we can't base attributes on anything 'cos the optimiser can't hack it goto NoMemory; } // add the character width LineX += CDRDATA_SWORD(Chars[CurrentChar].XSize); // update this line's spacing thingy if(Styles[Style].LineSpace > ThisLineSpace) ThisLineSpace = Styles[Style].LineSpace; // sort out first line spaceing thing if(InitialFirstLineSpace == -1) InitialFirstLineSpace = Styles[Style].LineSpace; if(NewLine) { // apply the line spacing attribute - make a font size attribute if(ThisLineSpace < 512) ThisLineSpace = PreviousLineSpace; TxtLineSpaceAttribute Attr((FIXED16)(((double)Styles[0].ParaLineSpacePercent) /* * 1.2*/ / 100)); // attach if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE)) return FALSE; // add an EOL EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD); if(EOL == 0) goto NoMemory; // make a new line CurrentLine = new TextLine(TSNode, LASTCHILD); if(CurrentLine == 0) goto NoMemory; // sort out first line spacing thing if(FirstLineSpace == -1) FirstLineSpace = ThisLineSpace; // reset things LineX = 0; PreviousLineSpace = ThisLineSpace; ThisLineSpace = 0; } } // sort out first line spaceing thing if(FirstLineSpace == -1) FirstLineSpace = ThisLineSpace; // apply the line spacing attribute - make a font size attribute if(ThisLineSpace < 512) ThisLineSpace = PreviousLineSpace; TxtLineSpaceAttribute Attr((FIXED16)(((double)Styles[0].ParaLineSpacePercent) / 100)); // attach if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE)) return FALSE; // pop on an end of line node EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD); if(EOL == 0) goto NoMemory; // get rid of the font styles delete [] Styles; PreviousLineSpace = ThisLineSpace; } // pop a caret at the end of the last line { Node *LastLine = TSNode->FindLastChild(); if(LastLine == 0) goto FormError; Node *LastLineNode = LastLine->FindLastChild(); ERROR3IF(LastLineNode == 0, "Line node doesn't have any children"); ERROR3IF(!LastLineNode->IsKindOf(CC_RUNTIME_CLASS(EOLNode)), "Last entry of a line is not an EOL node"); CaretNode *C = new CaretNode(LastLineNode, PREV); if(C == 0) goto NoMemory; } // set up maximumlinex - only valid for artisitic text if(LineX > MaximumLineX) MaximumLineX = LineX; // set up a bounding box for this text object and // if this is a text story, translate it down a bit // so that the top of the first line is at the top of the frame if(IsTextStory) { if(FirstLineSpace == -1) goto FormError; // no first line? How strange... // work out the distance to move the text line down = the first line un 120%ed INT32 Down = (FirstLineSpace * 10) / 12; // work out the rightness shifting INT32 Right = 0; if(Just == JCENTRE) { Right = (FrameX / 2) * CDRCOORDS_TO_MILLIPOINTS; } else if(Just == JRIGHT) { Right = FrameX * CDRCOORDS_TO_MILLIPOINTS; } // transform the story TSNode->SetStoryMatrix(Matrix(Trans.x+Right, Trans.y-Down)); // set the format width TSNode->SetImportFormatWidth(FrameX * CDRCOORDS_TO_MILLIPOINTS); TRACEUSER( "Ben", _T("Import format width initially %d\n"), TSNode->GetImportFormatWidth()); // bounding box for text story DocRect BBox = DocRect(Trans.x, Trans.y - (FrameY * CDRCOORDS_TO_MILLIPOINTS), Trans.x + (FrameX * CDRCOORDS_TO_MILLIPOINTS), Trans.y); TextBBoxes.Add(TSNode, &BBox, JLEFT); } else { // set the matrix of the story TSNode->SetStoryMatrix(Matrix(0,0)); // bounding box for a text object DocRect BBox = DocRect(0, 0 - FirstLineSpace * Lines, (MaximumLineX * CDRCOORDS_TO_MILLIPOINTS), FirstLineSpace); TextBBoxes.Add(TSNode, &BBox, Just); // see if this is linked to a path CheckTextForLinks(TSNode, Header); } // set some essential variables ObjFilled = TRUE; ObjStroked = FALSE; // all done return... pMadeNode = TSNode; return TRUE; NoMemory: TSNode->CascadeDelete(); delete TSNode; return FALSE; FormError: FormatError = TRUE; TSNode->CascadeDelete(); delete TSNode; return TRUE; }

BOOL CDRFilter::ConvertText3 (  cdrfOffsetHeader *  Header  )  [private]

converts a version 3 text object to a node. If the object has an unexpected format, then FormatError is set and it return *TRUE* - the return value only indicated environmental errors such as lack of memory Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24 03 95 Parameters: none  [INPUTS] Returns: error flag See also: 1.2 1.2 Definition at line 1025 of file cdrtext.cpp. { // is it a text story? if(Header->ObjectType == (cdrfOBJTYPE_TEXTSTORY - cdrfOBJTYPE_V3ADD)) IsTextStory = TRUE; // get the data from this object cdrfTextHeaderV3 *Hdr = (cdrfTextHeaderV3 *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS); // it has got some coords, hasn't it? if(Hdr == 0) { FormatError = TRUE; return TRUE; } //TRACEUSER( "Ben", _T("FrameX = %d, FrameY = %d\n"), Hdr->FrameX, Hdr->FrameY); INT32 FrameX = CDRDATA_WORD(Hdr->FrameX) * CDRCOORDS_TO_MILLIPOINTS; INT32 FrameY = CDRDATA_WORD(Hdr->FrameY) * CDRCOORDS_TO_MILLIPOINTS; // find pointer to the characters cdrfTextCharV3 *ThisChar = (cdrfTextCharV3 *)(Hdr + 1); // get the base style CDRTextStyle BaseStyle; if(!GetTextStyle3(&BaseStyle, CDRDATA_WORD(Hdr->BaseFontStyle))) return FALSE; // add the justifcation stuff to it TRACEUSER( "Ben", _T("Justificatoin V3 = %d\n"), Hdr->Justification); switch(Hdr->Justification) { case cdrfJUSTIFICATIONV3_LEFT: default: BaseStyle.Just = JLEFT; break; case cdrfJUSTIFICATIONV3_CENTRE: BaseStyle.Just = JCENTRE; break; case cdrfJUSTIFICATIONV3_RIGHT: BaseStyle.Just = JRIGHT; break; } // make a new text story node TextStory *TSNode = new TextStory; if(TSNode == 0) return FALSE; // run through the text... INT32 NChars = CDRDATA_WORD(Hdr->NCharacters); INT32 CurrentChar; INT32 MaximumLineSpace = BaseStyle.LineSpace; INT32 Lines = 1; INT32 Depth = 0; // make a new text line TextLine *CurrentLine = new TextLine(TSNode, LASTCHILD); if(CurrentLine == 0) goto NoMemory; for(CurrentChar = 0; CurrentChar < NChars; CurrentChar++) { BOOL HasStyles = FALSE; if(ThisChar->Info != 0) HasStyles = TRUE; if(ThisChar->Code >= ' ') { TextChar *C = new TextChar(CurrentLine, LASTCHILD, ThisChar->Code); if(C == 0) goto NoMemory; // apply attributes if(HasStyles) { // it's got styles of it's own, find and apply them cdrfTextCharStyledV3 *SC = (cdrfTextCharStyledV3 *)ThisChar; CDRTextStyle ThisStyle; if(!GetTextStyle3(&ThisStyle, CDRDATA_WORD(SC->Style), &BaseStyle)) return FALSE; if(!ApplyTextAttr(C, &ThisStyle, 0)) goto NoMemory; if(ThisStyle.LineSpace > MaximumLineSpace) MaximumLineSpace = ThisStyle.LineSpace; } else { // just apply the normal attributes if(!ApplyTextAttr(C, &BaseStyle, 0)) goto NoMemory; } } if(ThisChar->Code == cdrfTEXT_NEWLINE) { // create a new line... // apply the line spacing attribute - make a font size attribute // TxtLineSpaceAttribute Attr(MaximumLineSpace); TxtLineSpaceAttribute Attr((FIXED16)(((double)BaseStyle.ParaLineSpacePercent) / 100)); // attach if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE)) return FALSE; // add an EOL EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD); if(EOL == 0) goto NoMemory; // make a new line CurrentLine = new TextLine(TSNode, LASTCHILD); if(CurrentLine == 0) goto NoMemory; // set things Lines++; Depth += MaximumLineSpace; MaximumLineSpace = BaseStyle.LineSpace; } if(HasStyles) { //TRACEUSER( "Ben", _T("Char has styles, code %d (%c)\n"), ThisChar->Code, ThisChar->Code); // it's got more than normal bytes in it, so add a few more than usual ThisChar = (cdrfTextCharV3 *)(((cdrfTextCharStyledV3 *)ThisChar) + 1); } else { //TRACEUSER( "Ben", _T("Char, code %d (%c)\n"), ThisChar->Code, ThisChar->Code); // just a normal character, so simply increment it ThisChar++; } } // pop a line space attribute on the last line { // TxtLineSpaceAttribute Attr(MaximumLineSpace); TxtLineSpaceAttribute Attr((FIXED16)(((double)BaseStyle.ParaLineSpacePercent) / 100)); // attach if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE)) return FALSE; } Depth += MaximumLineSpace; // finish the last line with an end of line node { EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD); if(EOL == 0) goto NoMemory; // pop a caret at the end of the last line Node *LastLine = TSNode->FindLastChild(); if(LastLine == 0) goto FormError; Node *LastLineNode = LastLine->FindLastChild(); ERROR3IF(LastLineNode == 0, "Line node doesn't have any children"); ERROR3IF(!LastLineNode->IsKindOf(CC_RUNTIME_CLASS(EOLNode)), "Last entry of a line is not an EOL node"); CaretNode *C = new CaretNode(LastLineNode, PREV); if(C == 0) goto NoMemory; } if(IsTextStory) { // get a first line height INT32 FirstLineHeight = (BaseStyle.LineSpace * 10) / 12; // work out the rightness shifting INT32 Right = 0; if(BaseStyle.Just == JCENTRE) { Right = FrameX / 2; } else if(BaseStyle.Just == JRIGHT) { Right = FrameX; } // set the matrix of the story TSNode->SetStoryMatrix(Matrix(Right, -FirstLineHeight)); // bounding box for a text frame DocRect BBox = DocRect(0, 0 - FrameY, FrameX, 0); TextBBoxes.Add(TSNode, &BBox, JLEFT); // set it's width to be formatted to TSNode->SetImportFormatWidth(FrameX); } else { // set the matrix of the story TSNode->SetStoryMatrix(Matrix(0,0)); // bounding box for a artisitic text object - approximate it's width INT32 Width = (MaximumLineSpace * NChars) / (Lines * 3); DocRect BBox = DocRect(0, 0 - Depth, Width, MaximumLineSpace); TextBBoxes.Add(TSNode, &BBox, BaseStyle.Just); // check it for path on a text CheckTextForLinks(TSNode, Header); } // set some essential variables ObjFilled = TRUE; ObjStroked = FALSE; // all done, return... pMadeNode = TSNode; return TRUE; NoMemory: TSNode->CascadeDelete(); delete TSNode; return FALSE; FormError: FormatError = TRUE; TSNode->CascadeDelete(); delete TSNode; return TRUE; }

BOOL CDRFilter::ConvertText4Art (  cdrfOffsetHeader *  Header  )  [private]

converts a version 4 artisitic text object Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24 03 95 Parameters: none  [INPUTS] Returns: error flag See also: 1.2 1.2 Definition at line 552 of file cdrtext.cpp. { // get the data from this object cdrfTextHeaderV4 *Hdr = (cdrfTextHeaderV4 *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS); // it has got some coords, hasn't it? if(Hdr == 0) { FormatError = TRUE; return TRUE; } // find pointer to the characters cdrfTextCharV4 *ThisChar = (cdrfTextCharV4 *)(Hdr + 1); // get the base style CDRTextStyle BaseStyle; WORD *StyleRef = (WORD *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_STYLE); if(StyleRef == 0) { FormatError = TRUE; return TRUE; } if(!GetTextStyleFromCDRStyle(&BaseStyle, CDRDATA_WORD(*StyleRef))) return FALSE; // make a new text story node TextStory *TSNode = new TextStory; if(TSNode == 0) return FALSE; // run through the text... INT32 NChars = CDRDATA_WORD(Hdr->NCharacters); INT32 CurrentChar; INT32 MaximumLineSpace = BaseStyle.LineSpace; INT32 Lines = 1; INT32 Depth = 0; // make a new text line TextLine *CurrentLine = new TextLine(TSNode, LASTCHILD); if(CurrentLine == 0) goto NoMemory; for(CurrentChar = 0; CurrentChar < NChars; CurrentChar++) { BOOL HasStyles = FALSE; if(ThisChar->Info != 0) HasStyles = TRUE; if(ThisChar->Code >= ' ') { TextChar *C = new TextChar(CurrentLine, LASTCHILD, ThisChar->Code); if(C == 0) goto NoMemory; // apply attributes if(HasStyles) { // it's got styles of it's own, find and apply them cdrfTextCharStyledV4 *SC = (cdrfTextCharStyledV4 *)ThisChar; CDRTextStyle ThisStyle; if(!GetTextStyleFromChar4(&ThisStyle, SC, &BaseStyle)) return FALSE; if(!ApplyTextAttr(C, &ThisStyle, 0)) goto NoMemory; if(ThisStyle.LineSpace > MaximumLineSpace) MaximumLineSpace = ThisStyle.LineSpace; } else { // just apply the normal attributes if(!ApplyTextAttr(C, &BaseStyle, 0)) goto NoMemory; } } if(ThisChar->Code == cdrfTEXT_NEWLINE) { // create a new line... // apply the line spacing attribute - make a font size attribute // TxtLineSpaceAttribute Attr(MaximumLineSpace); TxtLineSpaceAttribute Attr((FIXED16)(((double)BaseStyle.ParaLineSpacePercent) / 100)); // attach if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE)) return FALSE; // add an EOL EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD); if(EOL == 0) goto NoMemory; // make a new line CurrentLine = new TextLine(TSNode, LASTCHILD); if(CurrentLine == 0) goto NoMemory; // set things Lines++; Depth += MaximumLineSpace; MaximumLineSpace = BaseStyle.LineSpace; } if(HasStyles) { // it's got more than normal bytes in it, so add a few more than usual ThisChar = (cdrfTextCharV4 *)(((cdrfTextCharStyledV4 *)ThisChar) + 1); } else { // just a normal character, so simply increment it ThisChar++; } } // pop a line space attribute on the last line { // TxtLineSpaceAttribute Attr(MaximumLineSpace); TxtLineSpaceAttribute Attr((FIXED16)(((double)BaseStyle.ParaLineSpacePercent) / 100)); // attach if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE)) return FALSE; } Depth += MaximumLineSpace; // finish the last line with an end of line node { EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD); if(EOL == 0) goto NoMemory; // pop a caret at the end of the last line Node *LastLine = TSNode->FindLastChild(); if(LastLine == 0) goto FormError; Node *LastLineNode = LastLine->FindLastChild(); ERROR3IF(LastLineNode == 0, "Line node doesn't have any children"); ERROR3IF(!LastLineNode->IsKindOf(CC_RUNTIME_CLASS(EOLNode)), "Last entry of a line is not an EOL node"); CaretNode *C = new CaretNode(LastLineNode, PREV); if(C == 0) goto NoMemory; } // set the matrix of the story { TSNode->SetStoryMatrix(Matrix(0,0)); // bounding box for a artisitic text object - approximate it's width INT32 Width = (MaximumLineSpace * NChars) / (Lines * 3); DocRect BBox = DocRect(0, 0 - Depth, Width, MaximumLineSpace); TextBBoxes.Add(TSNode, &BBox, BaseStyle.Just); } // check it for paths... CheckTextForLinks(TSNode, Header); // set some essential variables ObjFilled = TRUE; ObjStroked = FALSE; IsTextStory = FALSE; // all done, return... pMadeNode = TSNode; return TRUE; NoMemory: TSNode->CascadeDelete(); delete TSNode; return FALSE; FormError: FormatError = TRUE; TSNode->CascadeDelete(); delete TSNode; return TRUE; }

BOOL CDRFilter::ConvertText4Para (  cdrfOffsetHeader *  Header  )  [private]

converts a version 4 paragraph text object Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24 03 95 Parameters: none  [INPUTS] Returns: error flag See also: 1.2 Definition at line 763 of file cdrtext.cpp. { // get the data from this object cdrfParaTextHeaderV4 *Hdr = (cdrfParaTextHeaderV4 *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS); // set the var... IsTextStory = TRUE; // it has got some coords, hasn't it? if(Hdr == 0) { FormatError = TRUE; return TRUE; } // find out what text item we need if(LinkTable == 0) { // no link table, oh dear FormatError = TRUE; return TRUE; } cdrfLinkTableHdr *th = (cdrfLinkTableHdr *)LinkTable; INT32 Entries = CDRDATA_WORD(th->Entries); BOOL Found = FALSE; WORD *Offsets = (WORD *)(LinkTable + CDRDATA_WORD(th->OffsetsOffset)); cdrfLinkTableEntryTextV4 *En; for(INT32 l = 0; l < Entries; l++) { En = (cdrfLinkTableEntryTextV4 *)(LinkTable + CDRDATA_WORD(Offsets[l])); if(CDRDATA_WORD(En->Type) == cdrfLINKTABLEENTRYV4_TEXT && CDRDATA_WORD(En->ObjectSerial) == SerialNumber) { Found = TRUE; break; } } if(Found == FALSE) { FormatError = TRUE; return TRUE; } // locate the text item with those attributes CDRVectorStoredItem *Item = (CDRVectorStoredItem *)TextV4.GetHead(); // go through the list of items searching for the reference number given while(Item != 0) { if(Item->Reference == CDRDATA_WORD(En->TextID)) { // OK, we found it... break; } Item = (CDRVectorStoredItem *)TextV4.GetNext(Item); } if(Item == 0) { FormatError = TRUE; return TRUE; } Node *Text = Item->Objects; // find the base attributes CDRTextStyle BaseStyle; WORD *StyleRef = (WORD *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_STYLE); if(StyleRef == 0) { FormatError = TRUE; return TRUE; } if(!GetTextStyleFromCDRStyle(&BaseStyle, CDRDATA_WORD(*StyleRef))) return FALSE; // get the maximum height of the first line ERROR2IF(!IS_A(Text, TextLine), FALSE, "Node in text list is not a text line"); // apply attributes to the lines TextLine *CurrentLine = (TextLine *)Text; while(CurrentLine != 0) { if(IS_A(CurrentLine, TextLine)) { /* Node *pNode = CurrentLine->FindFirstChild(); while(pNode != 0) { if(IS_A(pNode, TextChar)) { if(!ApplyTextAttr(pNode, &BaseStyle, 0)) return FALSE; } pNode = pNode->FindNext(); } */ // attach the line spacing onto it TxtLineSpaceAttribute Attr((FIXED16)(((double)BaseStyle.ParaLineSpacePercent) / 100)); if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE)) return FALSE; } CurrentLine = (TextLine *)CurrentLine->FindNext(); } // add it to a text story TextStory *TSNode = new TextStory; if(TSNode == 0) return FALSE; Text->InsertChainSimple(TSNode, FIRSTCHILD); // remove references to the nodes now inserted from the item Item->Objects = 0; // set the matrix and add the bbox { INT32 FirstLineSpace = Item->BBox.hi.y; // get the line spacing from the bbox defn // get the frame size INT32 FrameX = CDRDATA_WORD(Hdr->FrameX) * CDRCOORDS_TO_MILLIPOINTS; INT32 FrameY = CDRDATA_WORD(Hdr->FrameY) * CDRCOORDS_TO_MILLIPOINTS; // work out the distance to move the text line down = the first line un 120%ed INT32 Down = (FirstLineSpace * 10) / 12; // work out the shift... INT32 Right = 0; if(BaseStyle.Just == JCENTRE) { Right = FrameX / 2; } else if(BaseStyle.Just == JRIGHT) { Right = FrameX; } // transform the story TSNode->SetStoryMatrix(Matrix(Right,-Down)); // bounding box for text story DocRect BBox = DocRect(0, 0 - FrameY, FrameX, 0); TextBBoxes.Add(TSNode, &BBox, JLEFT); // set it's width to be formatted to TSNode->SetImportFormatWidth(FrameX); } // delete the item delete TextV4.RemoveItem(Item); // set a few variables pMadeNode = TSNode; ObjFilled = TRUE; ObjStroked = FALSE; return TRUE; }

void CDRFilter::DeleteNodeList (  Node *  Start  )  [static]

Deletes a linked list of nodes (forward direction only). Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27 03 95 Parameters: [INPUTS]  Returns: See also: Filter Definition at line 4732 of file cdrfiltr.cpp. { Node *This, *Next; This = Start; while(This != 0) { Next = This->FindNext(); This->CascadeDelete(); delete This; This = Next; } }

BOOL CDRFilter::DoesPathNeedArrowheads (  NodePath *  P  )  [private]

To find out whether a path need attributes. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 29 03 95 Parameters: NodePath  to search [INPUTS] Returns: whether the path need some arrowheads See also: Filter Definition at line 533 of file cdroutl.cpp. { // if the number of end points is greater than 0, then it needs some arrowheads if(P->InkPath.GetNumEndPoints() > 0) return TRUE; return FALSE; }

BOOL CDRFilter::DoExport (  Operation *  , CCLexFile *  , PathName *  , Document *  , BOOL  )  [virtual]

Refuses to export a Corel Palette file. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21 03 95 Parameters: As  for the Filter class [INPUTS] Returns: As for the Filter class See also: Filter Reimplemented from Filter. Definition at line 4764 of file cdrfiltr.cpp. { // No exporting here return FALSE; }

BOOL CDRFilter::DoImport (  SelOperation *  , CCLexFile *  , Document *  , BOOL  AutoChosen = FALSE, ImportPosition *  Pos = NULL, KernelBitmap **  ppImportedBitmap = NULL, DocCoord *  pPosTranslate = NULL, String_256 *  = NULL )  [virtual]

Reimplemented from Filter. Definition at line 367 of file cdrfiltr.cpp. { // check to see if we've got a CMX file in there, but only if we weren't autochosen if(!AutoChosen && HasCDRFileGotCMXFile(NULL, pDiskFile)) { TRACEUSER( "Ben", _T(">>> loading CDR file with new CMXImportFilter\n")); // right, somehow we got here -- probably because the user specifically // asked to see CorelDRAW files only CMXImportFilter *pFilter = new CMXImportFilter; if(pFilter == NULL) return FALSE; BOOL ok = pFilter->DoImport(Op, pDiskFile, DestDoc, AutoChosen, Pos); delete pFilter; pFilter = NULL; return ok; } // normal CDR import stuff BOOL ExtensionMatches = pOILFilter->DoesExtensionOfFileMatch(pDiskFile); RIFFFile RIFFo; TRACEUSER( "Ben", _T("In CDRFilter::DoImport\n")); //ERROR2IF(Version == CDRVERSION_NULL, FALSE, "CDRFilter::HowCompatible failed to set recognised version\n"); // in debug builds, warn about fills hanging around ERROR3IF(Fills.IsEmpty() == FALSE, "Fills store not empty"); ERROR3IF(Outlines.IsEmpty() == FALSE, "Outlines store not empty"); ERROR3IF(Styles.IsEmpty() == FALSE, "Styles store not empty"); ERROR3IF(Fonts.IsEmpty() == FALSE, "Fonts store not empty"); ERROR3IF(Arrowheads.IsEmpty() == FALSE, "Arrowheads store not empty"); ERROR3IF(Patterns.IsEmpty() == FALSE, "Patterns store not empty"); ERROR3IF(Bitmaps.IsEmpty() == FALSE, "Bitmap store not empty"); ERROR3IF(Vectors.IsEmpty() == FALSE, "Vector store not empty"); ERROR3IF(TextBBoxes.IsEmpty() == FALSE, "TextBBoxes list not empty"); ERROR3IF(TextV4.IsEmpty() == FALSE, "TextV4 store not empty"); ERROR3IF(TextOnPathLinks.IsEmpty() == FALSE, "TextOnPathLinks not empty"); // in retail builds, just vape any contents Fills.DeleteAll(); Outlines.DeleteAll(); Styles.DeleteAll(); Fonts.DeleteAll(); Arrowheads.DeleteAll(); Patterns.DeleteAll(); Bitmaps.DeleteAll(); Vectors.DeleteAll(); TextV4.DeleteAll(); Pages.DeleteAll(); Actions.DeleteAll(); TextBBoxes.DeleteAll(); TextOnPathLinks.DeleteAll(); // set a few flags and initialise some variables pDocument = DestDoc; Success = TRUE; SlowJobStarted = FALSE; TranslateByX = 0; TranslateByY = 0; PageX = 0; PageY = 0; pLevelNodeList = 0; DoneDoc = FALSE; DoneMasterPage = FALSE; InMasterPage = FALSE; ThisPage = 0; ThisLayer = 0; pMadeNode = 0; ObjectsConverted = 0; ObjectsFormatWrong = 0; ObjectsUnknown = 0; EnvelopesApproximated = 0; ObjDataBlock = 0; ObjDataBlockSize = 0; AttrsAlreadyApplied = FALSE; TransformChunk = 0; FontTableV3 = 0; FontStylesV3 = 0; LinkTable = 0; ThisOp = Op; LinkTransformsExist = FALSE; TheDocument = DestDoc; // if the extension matches, check it for being a 2.xx file if(ExtensionMatches) { // get the first few bytes TCHAR FirstBit[8]; if(pDiskFile->read((void *)FirstBit, sizeof(FirstBit)).bad()) return FALSE; ERROR1IF(camStrncmp((char *)FirstBit, "WL", 2) == 0, FALSE, _R(IDT_CDRFILTER_ISAV2FILE)); // let's pop the file back to the beginning if(pDiskFile->seek(0).bad()) return FALSE; } // sort out the RIFF file RIFF = &RIFFo; FOURCC FormType = RIFF->Init(pDiskFile); if(FormType == 1) // error { CDRFILTER_DI_RETURNERROR; } // sort out which version we're on switch(FormType) { case cdrT_CDR: Version = CDRVERSION_3; break; case cdrT_CDR4: case cdrT_CDST: // version 4 template Version = CDRVERSION_4; break; case cdrT_CDR5: case cdrT_CDT5: Version = CDRVERSION_5; break; case cdrT_CDR6: case cdrT_CDT6: // version 6 file -- we don't support these ERROR1(FALSE, _R(IDE_CDRFILTER_CDR6)); break; default: TRACEUSER( "Ben", _T("Attempted to load something which wasn't a CDR file. I don't think so...")); ERROR1(FALSE, _R(IDE_CDRFILTER_NOTCDR)); break; } // sort out a colour list ColList = DestDoc->GetIndexedColours(); // do we want to import with layers? UseLayers = FALSE; #ifdef WEBSTER // In Webster, just use the default preference settings as these should be set to // ImportWithLayers to False. if ( (!DestDoc->IsImporting() && Filter::OpenWithLayers) || (DestDoc->IsImporting() && Filter::ImportWithLayers) ) UseLayers = TRUE; #else // In Camelot, we must check to see if the document is being imported and if so if // there are any frames present. If there are then don't use layers, if there are // then use the preference setting. if (DestDoc->IsImporting()) { Spread * pTheSpread = DestDoc->GetSelectedSpread(); Layer * pFrame = NULL; if (pTheSpread != NULL) pFrame = pTheSpread->FindFirstFrameLayer(); if (pFrame != NULL) UseLayers = FALSE; // Frames present so do not import layers else UseLayers = Filter::ImportWithLayers; // No frames so use the preference setting } else { UseLayers = Filter::OpenWithLayers; } #endif // If importing without layers, make sure there is a layer to put things on, and make one if not if(UseLayers == FALSE) { if (!MakeSureLayerExists(DestDoc)) { // clean up and return and error CDRFILTER_DI_RETURNERROR; } } // For now, position Draw objects on 1st page of spread 1 pSpread = DestDoc->GetSelectedSpread(); pPage = (Page *) pSpread->FindFirstPageInSpread(); // Use bottom left of page as origin DocRect PageRect = pPage->GetPageRect(); Origin = PageRect.lo; // OK, let's get into the swing of things! // Get a default set of attributes for ink objects. if (!SetUpCurrentAttrs()) return FALSE; // Let start off by setting the progress indicatorx UINT32 id; switch(Version) { case CDRVERSION_4: id = _R(IDT_IMPORTMSG_CDR4); break; case CDRVERSION_5: id = _R(IDT_IMPORTMSG_CDR5); break; default: id = _R(IDT_IMPORTMSG_CDR3); break; } if(!DestDoc->IsImporting()) id += _R(IDT_OPENMSG_CDR3) - _R(IDT_IMPORTMSG_CDR3); //String_64 ImportMessage(id); String_64 ImportMessage = GetImportProgressString(pDiskFile, id); // this slow job doesn't have a delay because if the CDR file has a bitmap at the // beginning, ContinueSlowJob can't be called for rather a long time (sometimes) // and you get 'Nothing Selected' instead of a message telling you what's happening. BeginSlowJob(RIFF->ProgressLimit(), FALSE, &ImportMessage); SlowJobStarted = TRUE; // loop through looking at top level lists, and dispatch them to various handlers do { // get the next object in the file if(!RIFF->NextObject()) CDRFILTER_DI_RETURNERROR; if(RIFF->GetObjType() == RIFFOBJECTTYPE_LISTSTART) { switch(RIFF->GetObjChunkType()) { case cdrT_doc: if(!ProcessDoc()) { TRACEUSER( "Ben", _T("ProcessDoc returned FALSE\n")); CDRFILTER_DI_RETURNERROR; } break; case cdrT_page: if(!ProcessPage()) { TRACEUSER( "Ben", _T("ProcessPage returned FALSE\n")); CDRFILTER_DI_RETURNERROR; } break; default: // we're not interested in any other root level list, so skip it if(!RIFF->SkipToListEnd(RIFF->GetObjLevel())) CDRFILTER_DI_RETURNERROR; break; } } if(!UpdateProgress()) return FALSE; } while(RIFF->GetObjType() != RIFFOBJECTTYPE_FILEEND); // make sure we're at the end ContinueSlowJob(RIFF->ProgressLimit()); // attach paths to text stories if(!AttachTextToPaths()) return FALSE; // only stick objects into the document if some were converted if(ObjectsConverted > 0) { // check that there were at least two pages if(Pages.GetCount() < 1) { TRACEUSER( "Ben", _T("not enough pages in file\n")); CDRFILTER_DI_RETURNERROR; } // get the pointer to the list of levels on the master pages CDRLayerList *MasterLayers; CDRPageListItem *En = (CDRPageListItem *)Pages.GetHead(); if(En == 0) CDRFILTER_DI_RETURNERROR; MasterLayers = &En->Layers; // get the list of levels on the actual page CDRLayerList *PageLayers; En = (CDRPageListItem *)Pages.GetNext(En); if(Version != CDRVERSION_3) { if(En == 0) CDRFILTER_DI_RETURNERROR; PageLayers = &En->Layers; // check that they have the same number of layers in their lists if(MasterLayers->GetCount() != PageLayers->GetCount()) { TRACEUSER( "Ben", _T("not the same number of layers on master page and on page\n")); CDRFILTER_DI_RETURNERROR; } } else { PageLayers = 0; } if(MasterLayers->GetCount() <= 0) CDRFILTER_DI_RETURNERROR; // if it's a CDR 3 file set the page size and translation things if(Version == CDRVERSION_3) { // set the page size? if(!DestDoc->IsImporting() && PageX > 0 && PageY > 0) { // Make the pasteboard an extra page width either side of the page and an extra // half page height above and below the page. That should be nicely proportional. INT32 ms = (PageX > PageY)?PageX:PageY; // we're opening the file, so set the page size if (pSpread) { BOOL ok = pSpread->SetPageSize(PageX, PageY, ms, 0, FALSE, TRUE); // Must set the origin of the grid to the bottom left corner of the // union rectangle of all pages on the spread as this is where the x,y // measurements are made from. DocRect PagesRect; NodeGrid* pGrid = pSpread->FindFirstDefaultGridInSpread(); ok = ok && pSpread->GetPagesRect(&PagesRect); if (pGrid) pGrid->SetOrigin(PagesRect.lox, PagesRect.loy); if (!ok) CDRFILTER_DI_RETURNERROR; } } DocRect PageRect = pPage->GetPageRect(); Origin = PageRect.lo; TranslateByX = Origin.x + (PageX / 2); TranslateByY = Origin.y + (PageY / 2); } // set up pointers to the layers CDRLayerListItem *MasterEn = (CDRLayerListItem *)MasterLayers->GetTail(); CDRLayerListItem *PageEn = 0; if(PageLayers != 0) PageEn = (CDRLayerListItem *)PageLayers->GetTail(); EndSlowJob(); BeginSlowJob(); // insert everything into the document if(UseLayers) { // go through inserting every layer which has sometime on it while(MasterEn != 0) { // check to see if we have objects to import if(MasterEn->Objects != 0 || (PageEn != 0 && PageEn->Objects != 0)) { // OK, we've got some objects to import, create a layer to put them in Layer *pLayer = new Layer(); if(pLayer == 0) CDRFILTER_DI_RETURNERROR; // set it's name and attributes pLayer->SetLayerID(MasterEn->Name); pLayer->SetVisible(MasterEn->IsVisible); pLayer->SetLocked(MasterEn->IsLocked); pLayer->SetActive(FALSE); pLayer->SetPrintable(TRUE); pLayer->SetBackground(FALSE); pLayer->SetOutline(FALSE); // stick objects below it Node *Objects = 0; if(MasterEn->Objects != 0) { Objects = MasterEn->Objects; MasterEn->LayerInDocument = TRUE; } else { Objects = PageEn->Objects; PageEn->LayerInDocument = TRUE; } ERROR3IF(Objects == 0, "Er, tried to make a layer for objects which didn't exist"); // attach the objects to the layer Objects->InsertChainSimple(pLayer, FIRSTCHILD); // if it's a CDR 3 file and translate it if(Version == CDRVERSION_3) { Trans2DMatrix Trans(TranslateByX, TranslateByY); pLayer->Transform(Trans); } // insert the layer... if (!Op->DoInsertNewNode(pLayer, (Node *)pSpread, LASTCHILD, TRUE)) { // It didn't work - delete the sub-tree we just created pLayer->CascadeDelete(); delete pLayer; pLayer = NULL; CDRFILTER_DI_RETURNERROR; } // make sure it's name is unique pLayer->EnsureUniqueLayerID(); // ... and finally optimise it's attributes if(!pLayer->OptimiseAttributes()) CDRFILTER_DI_RETURNERROR; } // get the next (previous) layer to import MasterEn = (CDRLayerListItem *)MasterLayers->GetPrev(MasterEn); if(PageEn != 0) PageEn = (CDRLayerListItem *)PageLayers->GetPrev(PageEn); } // get the insertation node set up DestDoc->ResetInsertionPosition(); } else { // get a group node to put everything in as we're not using layers here. NodeGroup *pGroup = new NodeGroup; if(pGroup == 0) CDRFILTER_DI_RETURNERROR; // run through the layers putting in the stuff - remember they're in reverse order while(MasterEn != 0) { TRACEUSER( "Ben", _T("Putting layer '%s' into document\n"), (TCHAR *)MasterEn->Name); // put the master pages objects onto this group if(MasterEn->Objects != 0) { MasterEn->Objects->InsertChainSimple(pGroup, LASTCHILD); MasterEn->LayerInDocument = TRUE; } // put the page objects into this group if(PageEn != 0 && PageEn->Objects != 0) { PageEn->Objects->InsertChainSimple(pGroup, LASTCHILD); PageEn->LayerInDocument = TRUE; } // get the next (previous) layer to import MasterEn = (CDRLayerListItem *)MasterLayers->GetPrev(MasterEn); if(PageEn != 0) PageEn = (CDRLayerListItem *)PageLayers->GetPrev(PageEn); } // if it's a CDR 3 file translate it if(Version == CDRVERSION_3) { Trans2DMatrix Trans(TranslateByX, TranslateByY); pGroup->Transform(Trans); } // check to see if the group node has more than one child // if it doesn't just insert the child and not the group, and then // delete the group node afterwards NodeRenderableBounded *InsertNode = pGroup; NodeRenderableBounded *FirstChild = (NodeRenderableBounded *)pGroup->FindFirstChild(); if(FirstChild != 0) { // if the first child hasn't got a sibling, then there's only one // child to the group, so just insert the child if(FirstChild->FindNext() == 0) InsertNode = FirstChild; } // and slap the group into the document if (!Op->DoInsertNewNode(InsertNode, pSpread, TRUE)) { // It didn't work - delete the sub-tree we just created pGroup->CascadeDelete(); delete pGroup; pGroup = NULL; CDRFILTER_DI_RETURNERROR; } if(InsertNode != pGroup) delete pGroup; // optimise the attributes in our nice new group if(!InsertNode->OptimiseAttributes()) CDRFILTER_DI_RETURNERROR; } } else { // if we were opening the document, then we need make a layer and set the insertation node if(!DestDoc->IsImporting()) { if (!MakeSureLayerExists(DestDoc)) CDRFILTER_DI_RETURNERROR; DestDoc->ResetInsertionPosition(); } } // add some standard colours if(!AddStandardColourSet(pDocument)) CDRFILTER_DI_RETURNERROR; // do a quick post import on it DestDoc->PostImport(); // find out how many dodgy objects were encountered along the way INT32 ObjNotConv = ObjectsFormatWrong + ObjectsUnknown; if(ObjNotConv > 0) { // tell the user that some objects couldn't be converted String_256 WarnMsg; WarnMsg.MakeMsg((ObjNotConv == 1)?_R(IDT_CDRFILTER_OBJWARNING1):_R(IDT_CDRFILTER_OBJWARNING), ObjNotConv); Error::SetError(0, WarnMsg, 0); InformWarning(); Error::ClearError(); } if(EnvelopesApproximated > 0) { // tell the user that some envelopes were approximated String_256 WarnMsg; WarnMsg.MakeMsg((EnvelopesApproximated == 1)?_R(IDT_CDRFILTER_ENVAPPROXWARNING1):_R(IDT_CDRFILTER_ENVAPPROXWARNING), EnvelopesApproximated); Error::SetError(0, WarnMsg, 0); InformWarning(); Error::ClearError(); } TRACEUSER( "Ben", _T("Do import finished\n")); return ClearUp(); }

ADDR CDRFilter::FindDataInObject (  cdrfOffsetHeader *  Header, WORD  Type )  [static]

returns the address of data of the given type in an objects with a standard offset header Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25 03 95 Parameters: none  [INPUTS] Returns: error flag See also: Filter Definition at line 2931 of file cdrfiltr.cpp. { WORD *Types; WORD *Offsets; Types = (WORD *)(((BYTE *)Header) + CDRDATA_WORD(Header->TypesOffset)); Offsets = (WORD *)(((BYTE *)Header) + CDRDATA_WORD(Header->OffsetsOffset)); UINT32 l; for(l = 0; l < CDRDATA_WORD(Header->NOffsets); l++) { if(CDRDATA_WORD(Types[l]) == Type) { UINT32 Off = CDRDATA_WORD(Offsets[Header->NOffsets - l - 1]); if(Off > CDRDATA_WORD(Header->Size)) return 0; return (ADDR)(((BYTE *)Header) + Off); } } return 0; }

BOOL CDRFilter::GetCorelBBox (  NodeRenderableBounded *  pNode, DocRect *  BBox )  [static]

gets the Corel simple union bbox of an object Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 28 03 95 Parameters: converted  node (after transformation) and a pointer to bbox to fill in [INPUTS] Returns: error flag See also: Filter Definition at line 664 of file cdrfill.cpp. { if(pNode->IsKindOf(CC_RUNTIME_CLASS(NodePath))) { // ok, so it's a path. That means we can run through it to find out the simple // union of all points. That's cool. Nice of corel not to do proper bboxes, isn't // it? NodePath *pNodePath = (NodePath *)pNode; // get a pointer to the array of coords in the nice path INT32 NCoords = pNodePath->InkPath.GetNumCoords(); DocCoord *Coords = pNodePath->InkPath.GetCoordArray(); ERROR3IF(NCoords < 1, "Awooga! Trying to find a corel bbox of a path with less than one coord."); INT32 c; INT32 x0, y0, x1, y1; // initialise my bbox variables x0 = x1 = Coords[0].x; y0 = y1 = Coords[0].y; for(c = 1; c < NCoords; c++) { // update my bbox if(Coords[c].x < x0) x0 = Coords[c].x; if(Coords[c].y < y0) y0 = Coords[c].y; if(Coords[c].x > x1) x1 = Coords[c].x; if(Coords[c].y > y1) y1 = Coords[c].y; } // fill in *BBox BBox->lo.x = x0; BBox->lo.y = y0; BBox->hi.x = x1; BBox->hi.y = y1; } else { // if it's not a path object, ask the node what it's bounding box is - we'll just // have to make do with a *correct* bounding box instead of simply corel union. *BBox = pNode->GetBoundingRect(); } return TRUE; }

TCHAR * CDRFilter::GetFontName (  WORD  FontRef  )  [private]

finds a font name Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27/04/95 Parameters: [INPUTS]  Returns: pointer to font name or 0 for not found See also: Definition at line 1789 of file cdrtext.cpp. { INT32 Size; cdrfFontDefn *FD = (cdrfFontDefn *)Fonts.Find(FontRef, &Size); if(Version == CDRVERSION_5) { if(FD != 0) return FD->Name; } else { cdrfFontDefnV4 *FD4 = (cdrfFontDefnV4 *)FD; if(FD4 != 0) return FD4->Name; } return 0; }

BOOL CDRFilter::GetMatrixFromTransform (  Matrix *  M, ADDR  Trans, INT32  Size, BOOL  TranslateForPage = TRUE )  [private]

given some transform data, works out a matrix. This ignores any 3D transforms, TransformConvertedObject should be used in preference. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25 03 95 Parameters: the  node to transform, and the trfd chunk to transform it by [INPUTS] Returns: error flag See also: Filter Definition at line 2971 of file cdrfiltr.cpp. { // set up a matrix conversion object CDRTransformConvertor *Conv; // putting the convertors here is probably more efficicent than allocating // a new one in the heap as they're not very big at all CDRTransformConvertor5 Conv5; CDRTransformConvertor4 Conv4; CDRTransformConvertor3 Conv3; switch(Version) { case CDRVERSION_5: Conv = &Conv5; break; case CDRVERSION_4: Conv = &Conv4; break; case CDRVERSION_3: Conv = &Conv3; break; default: return FALSE; break; } // initialise the convertor object Conv->Init(Trans, Size); // set up the initial matrix which just converts to millipoints // note that these elements are in Corel order cdrMatrix Ma, Mb, Mt; BOOL DoneFirst = FALSE; // apply all the transformations in the chunk INT32 t; for(t = Conv->GetNTransforms() - 1; t >= 0; t--) { // check that the transform is a matrix - for now we can only do matrices if(Conv->GetTransformType(t) != CDRTRANSFORMTYPE_MATRIX) continue; if(DoneFirst) { // done the first matrix, so we need get the matrix into another one and then combine. // get the matrix if(!Conv->GetMatrix(&Mb, t)) return FALSE; // and combine it with the matrix we've already got Mt.a = (Mb.a * Ma.a) + (Mb.d * Ma.b); Mt.b = (Mb.b * Ma.a) + (Mb.e * Ma.b); Mt.c = (Mb.c * Ma.a) + (Mb.f * Ma.b) + Ma.c; Mt.d = (Mb.a * Ma.d) + (Mb.d * Ma.e); Mt.e = (Mb.b * Ma.d) + (Mb.e * Ma.e); Mt.f = (Mb.c * Ma.d) + (Mb.f * Ma.e) + Ma.f; Ma = Mt; } else { // just get the matrix if(!Conv->GetMatrix(&Ma, t)) return FALSE; DoneFirst = TRUE; } } // if we didn't get a matrix at all, knock up a quick dummy one if(!DoneFirst) { cdrMatrix Mx = {1, 0, 0, 0, 1, 0}; Ma = Mx; } // add in the translation bit if(TranslateForPage) { Ma.c += TranslateByX; Ma.f += TranslateByY; } // convert the final matrix into a Camelot matrix *M = Matrix(Ma.a, Ma.d, Ma.b, Ma.e, (INT32)Ma.c, (INT32)Ma.f); return TRUE; }

BOOL CDRFilter::GetObjCorelBBox (  NodeRenderableBounded *  pNode, DocRect *  BBox )  [private]

gets the corel bbox of a converted object, looking up the bbox of text objects Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 28 03 95 Parameters: converted  node (after transformation) and a pointer to bbox to fill in [INPUTS] Returns: error flag See also: Filter Definition at line 643 of file cdrfill.cpp. { if(IS_A(pNode, TextStory) && TextBBoxes.Find(pNode, BBox) == TRUE) return TRUE; return GetCorelBBox(pNode, BBox); }

BOOL CDRFilter::GetTextStyle3 (  CDRTextStyle *  TS, WORD  Style, CDRTextStyle *  BasedOn = 0 )  [private]

gets a style for version 3 text from the global text styles table Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 04/05/95 Parameters: none  [INPUTS] Returns: error flag See also: Definition at line 1285 of file cdrtext.cpp. { // copy in the default text style if(BasedOn == 0) *TS = CDRDefaultTextStyle; else *TS = *BasedOn; // if the styles chunk isn't present, return now if(FontStylesV3 == 0) return TRUE; // find the font definition cdrfFontStyleTableHeaderV3 *Hdr = (cdrfFontStyleTableHeaderV3 *)FontStylesV3; if(Style >= CDRDATA_WORD(Hdr->NOffsets)) return TRUE; // if there aren't enough entries to find this style cdrfFontStyleTableEntryV3 *En = (cdrfFontStyleTableEntryV3 *)(FontStylesV3 + CDRDATA_WORD(Hdr->Offsets[Style])); // convert it // find the font name /* if(FontTableV3 == 0) return FALSE; cdrfFontTableEntryV3 *FEn = (cdrfFontTableEntryV3 *)FontTableV3; for(INT32 l = 0; l < FontTableEntriesV3; l++) { if(FEn[l].Reference == En->FontRef) // don't need to bother with CDRDATA stuff { TS->FontName = (char *)FEn[l].Name; break; } } */ // store the font reference TS->FontReference = CDRDATA_DWORD(En->FontRef); TRACEUSER( "Ben", _T("Font reference = %d\n"), TS->FontReference); // font size TS->FontSize = CDRDATA_WORD(En->FontSize) * CDRCOORDS_TO_MILLIPOINTS; // style... INT32 S = CDRDATA_WORD(En->FontStyle) & cdrfFONTSTYLEV3_WEIGHT_MASK; switch(S) { case cdrfFONTSTYLEV3_WEIGHT_NORMAL: default: TS->Bold = FALSE; TS->Italic = FALSE; break; case cdrfFONTSTYLEV3_WEIGHT_BOLD: TS->Bold = TRUE; TS->Italic = FALSE; break; case cdrfFONTSTYLEV3_WEIGHT_ITALIC: TS->Bold = FALSE; TS->Italic = TRUE; break; case cdrfFONTSTYLEV3_WEIGHT_BOLDITALIC: TS->Bold = TRUE; TS->Italic = TRUE; break; } // super or subscriptness if((CDRDATA_WORD(En->FontStyle) & cdrfFONTSTYLEV3_FLAG_SUPERSCRIPT) != 0) { TS->Script = CDRSCRIPT_SUPER; } else if((CDRDATA_WORD(En->FontStyle) & cdrfFONTSTYLEV3_FLAG_SUPERSCRIPT) != 0) { TS->Script = CDRSCRIPT_SUB; } // the line spacing is a para wide thingy, so we need to reworkout the linespace value // the line spacing value is a percentage of 120% of the font size TS->LineSpace = (TS->FontSize * (12 * TS->ParaLineSpacePercent)) / 1000; return TRUE; }

BOOL CDRFilter::GetTextStyleFromCDRStyle (  CDRTextStyle *  TS, WORD  StyleRef, BOOL  SearchForParent = TRUE )  [private]

gets a text style from a CDR style. If it can't be found, you get the default text style. If SearchForParent is TRUE, the parent style of this style will be located Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27/04/95 Parameters: [INPUTS]  Returns: error flag See also: Definition at line 1388 of file cdrtext.cpp. { // copy in the default text style *TS = CDRDefaultTextStyle; // find the style INT32 Size; cdrfTextStyleHdr *Hdr = (cdrfTextStyleHdr *)Styles.Find(StyleRef, &Size); if(Hdr == 0) return TRUE; // don't error if it can't be found // if necessary, search for the parent style... if(SearchForParent) { if(CDRDATA_WORD(Hdr->Hdr.ObjectType) < 0x7fff) { if(!GetTextStyleFromCDRStyle(TS, CDRDATA_WORD(Hdr->Hdr.ObjectType), FALSE)) return FALSE; } } // find the font size and stuff. cdrfTextStyleFont *FontStyle = (cdrfTextStyleFont *)FindDataInObject(&Hdr->Hdr, cdrfTEXTSTYLE_OFFSETTYPE_FONT); if(FontStyle != 0) { // set fontname /* TCHAR *FontName = GetFontName(CDRDATA_WORD(FontStyle->FontRef)); if(FontName != 0) TS->FontName = FontName; else TS->FontName = CDRDefaultFontName; */ // set font reference TS->FontReference = CDRDATA_WORD(FontStyle->FontRef); // set font size TS->FontSize = CDRDATA_WORD(FontStyle->FontSize) * CDRCOORDS_TO_MILLIPOINTS; // set font bold and italicness if(Version == CDRVERSION_5) { switch(CDRDATA_WORD(FontStyle->FontType)) { case cdrfFONTTYPE_BOLD: TS->Bold = TRUE; TS->Italic = FALSE; break; case cdrfFONTTYPE_ITALIC: TS->Bold = FALSE; TS->Italic = TRUE; break; case cdrfFONTTYPE_BOLDITALIC: TS->Bold = TRUE; TS->Italic = TRUE; break; default: TS->Bold = FALSE; TS->Italic = FALSE; break; } } else { switch(CDRDATA_WORD(FontStyle->FontType)) { case cdrfFONTTYPEV4_BOLD: TS->Bold = TRUE; TS->Italic = FALSE; break; case cdrfFONTTYPEV4_ITALIC: TS->Bold = FALSE; TS->Italic = TRUE; break; case cdrfFONTTYPEV4_BOLDITALIC: TS->Bold = TRUE; TS->Italic = TRUE; break; default: TS->Bold = FALSE; TS->Italic = FALSE; break; } } } // find the spacing info cdrfTextStyleSpacing *Spacing = (cdrfTextStyleSpacing *)FindDataInObject(&Hdr->Hdr, cdrfTEXTSTYLE_OFFSETTYPE_SPACING); if(Spacing != 0) { // set the paragraph line spacing TS->ParaLineSpacePercent = CDRDATA_SWORD(Spacing->LineSpacing); } // work out the line spacing for this thingy // the line spacing value is a percentage of 120% of the font size TS->LineSpace = (TS->FontSize * (12 * TS->ParaLineSpacePercent)) / 1000; // find the alignment cdrfTextStyleAlignment *Align = (cdrfTextStyleAlignment *)FindDataInObject(&Hdr->Hdr, cdrfTEXTSTYLE_OFFSETTYPE_ALIGNMENT); if(Align != 0) { switch(CDRDATA_WORD(Align->Alignment)) { case cdrfALIGNMENT_RIGHT: TS->Just = JRIGHT; break; case cdrfALIGNMENT_CENTRE: TS->Just = JCENTRE; break; case cdrfALIGNMENT_FULL: TS->Just = JFULL; break; default: TS->Just = JLEFT; break; } } return TRUE; }

BOOL CDRFilter::GetTextStyleFromChar4 (  CDRTextStyle *  TS, cdrfTextCharStyledV4 *  Char, CDRTextStyle *  BasedOn )  [private]

gets a text style from a styled version 4 text character Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24 03 95 Parameters: none  [INPUTS] Returns: error flag See also: Definition at line 949 of file cdrtext.cpp. { if(BasedOn != 0) *TS = *BasedOn; else *TS = CDRDefaultTextStyle; // font name if((CDRDATA_WORD(Char->Changes) & cdrfSTYLECHANGEV4_FONTNAME) != 0) { /* TCHAR *FontName = GetFontName(Char->FontRef); if(FontName != 0) { TS->FontName = FontName; } */ TS->FontReference = CDRDATA_DWORD(Char->FontRef); } // font size if((CDRDATA_WORD(Char->Changes) & cdrfSTYLECHANGEV4_FONTSIZE) != 0) { if(CDRDATA_WORD(Char->FontSize) != 0) { TS->FontSize = CDRDATA_WORD(Char->FontSize) * CDRCOORDS_TO_MILLIPOINTS; } } // update line spacing TS->LineSpace = (TS->FontSize * (12 * TS->ParaLineSpacePercent)) / 1000; // weight if((CDRDATA_WORD(Char->Changes) & cdrfSTYLECHANGEV4_WEIGHT) != 0) { switch(CDRDATA_WORD(Char->FontType)) { case cdrfFONTTYPEV4_BOLD: TS->Bold = TRUE; TS->Italic = FALSE; break; case cdrfFONTTYPEV4_ITALIC: TS->Bold = FALSE; TS->Italic = TRUE; break; case cdrfFONTTYPEV4_BOLDITALIC: TS->Bold = TRUE; TS->Italic = TRUE; break; default: TS->Bold = FALSE; TS->Italic = FALSE; break; } } return TRUE; }

BOOL CDRFilter::GetTextStyleFromDefn (  CDRTextStyle *  TS, cdrfTextInfoFontDefn *  FontDefn, const CDRTextStyle *  BasedOn )  [private]

gets a font style from a font definition stored in a txsm chunk. Anything not defined comes from the BasedOn style. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27/04/95 Parameters: [INPUTS]  Returns: error flag See also: Definition at line 1524 of file cdrtext.cpp. { // set up the defaults if(BasedOn != 0) *TS = *BasedOn; else *TS = CDRDefaultTextStyle; // add in things which are changed... if((CDRDATA_WORD(FontDefn->Changes) & cdrfTEXTINFODEFNCHANGES_FONT) != 0) { // change the font reference /* TCHAR *NewName = GetFontName(CDRDATA_WORD(FontDefn->FontRef)); if(NewName != 0) TS->FontName = NewName; */ TS->FontReference = CDRDATA_WORD(FontDefn->FontRef); } if((CDRDATA_WORD(FontDefn->Changes) & cdrfTEXTINFODEFNCHANGES_SIZE) != 0) { // new font size TS->FontSize = CDRDATA_WORD(FontDefn->FontSize) * CDRCOORDS_TO_MILLIPOINTS; } if((CDRDATA_WORD(FontDefn->Changes) & cdrfTEXTINFODEFNCHANGES_ATTR) != 0) { // weightness of the font if(CDRDATA_WORD(FontDefn->FontType) != 0) { // set font bold and italicness switch(CDRDATA_WORD(FontDefn->FontType)) { case cdrfFONTTYPE_BOLD: TS->Bold = TRUE; TS->Italic = FALSE; break; case cdrfFONTTYPE_ITALIC: TS->Bold = FALSE; TS->Italic = TRUE; break; case cdrfFONTTYPE_BOLDITALIC: TS->Bold = TRUE; TS->Italic = TRUE; break; default: TS->Bold = FALSE; TS->Italic = FALSE; break; } } // new attributes if(FontDefn->FontAttr.Underline != cdrfLINETYPE_NONE || FontDefn->FontAttr.Overline != cdrfLINETYPE_NONE || FontDefn->FontAttr.StrikeOut != cdrfLINETYPE_NONE) { TS->Underline = TRUE; } else { TS->Underline = FALSE; } switch(FontDefn->FontAttr.Placement) { default: TS->Script = CDRSCRIPT_NONE; break; case cdrfPLACEMENTTYPE_SUPERSCRIPT: TS->Script = CDRSCRIPT_SUPER; break; case cdrfPLACEMENTTYPE_SUBSCRIPT: TS->Script = CDRSCRIPT_SUB; break; } } // the line spacing is a para wide thingy, so we need to reworkout the linespace value // the line spacing value is a percentage of 120% of the font size TS->LineSpace = (TS->FontSize * (12 * TS->ParaLineSpacePercent)) / 1000; return TRUE; }

BOOL CDRFilter::HasCDRFileGotCMXFile (  PathName *  FileName, CCLexFile *  pFile = NULL )  [static]

to find out whether a CDR file has got a CMX file in it, and therefore whether the CMX filter should grab it instead of this one Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 20/08/96 Parameters: pathname  of file to check, or pointer to disk file [INPUTS] Returns: whether it has got a cmx file embedded in it Definition at line 5152 of file cdrfiltr.cpp. { CCDiskFile oTheFile; CCLexFile *pTheFile; INT32 pos; if(pFile == NULL) { if (!(oTheFile.open(*FileName, ios::in | ios::binary))) { TRACEUSER( "Ben", _T("couldn't open file to check it for CMX\n")); return FALSE; } pTheFile = &oTheFile; } else { pTheFile = pFile; pos = pFile->tellIn(); } // read in the file header, and check it's a riff file RIFFFile_Header Hdr; pTheFile->read(&Hdr, sizeof(Hdr)); if(Hdr.CK.ckID != RIFFTYPE_RIFF) return FALSE; // file is not a riff form UINT32 loc = sizeof(Hdr); // run through the thingys BOOL Found = FALSE; while(loc < Hdr.CK.ckSize) { RIFFck ck; pTheFile->read(&ck, sizeof(ck)); loc += sizeof(ck); if(ck.ckID == cdrT_cmx1) { // found the cmx section Found = TRUE; break; // we can stop now } // skip to start of next chunk loc += ck.ckSize; pTheFile->seekIn(loc); } // close it or clear up... if(pFile == NULL) { oTheFile.close(); } else { pFile->seekIn(pos); } return Found; }

INT32 CDRFilter::HowCompatible (  PathName &  Filename, ADDR  HeaderStart, UINT32  HeaderSize, UINT32  FileSize )  [virtual]

Examines a file to see how compatable it is with this filter. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21 03 95 Parameters: As  for the Filter class [INPUTS] Returns: As for the Filter class See also: Filter Reimplemented from Filter. Definition at line 289 of file cdrfiltr.cpp. { PORTNOTE("byteorder", "TODO: Check byte ordering") BOOL ExtensionMatches = pOILFilter->DoesExtensionOfPathNameMatch(&Filename); // check for version 2 files if the extension matches... if (ExtensionMatches) { if(camStrncmp((char *)HeaderStart, "WL", 2) == 0) return 10; // a version 2.xx CDR file } // check for version 3 - 5 files... FOURCC FormType; FormType = RIFFFile::CheckRIFFHeader(HeaderStart, FileSize); Version = CDRVERSION_NULL; switch (FormType) { case cdrT_CDR: Version = CDRVERSION_3; break; case cdrT_CDR4: case cdrT_CDST: // version 4 template Version = CDRVERSION_4; break; case cdrT_CDR5: case cdrT_CDT5: Version = CDRVERSION_5; break; case cdrT_CDR6: case cdrT_CDT6: Version = CDRVERSION_6; break; default: break; } INT32 HowMuchWeLikedThisFile = 0; if(Version != CDRVERSION_NULL) { HowMuchWeLikedThisFile = 10; // loved the file // check to see if there is a CMX file embedded in there if(HasCDRFileGotCMXFile(&Filename)) { HowMuchWeLikedThisFile = 5; // didn't like it so much then -- let the CMX filter grab it } } return HowMuchWeLikedThisFile; }

BOOL CDRFilter::Init (  void   )  [virtual]

Initialisation. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21 03 95 Parameters: As  for the Filter class [INPUTS] Returns: As for the Filter class See also: Filter Implements Filter. Definition at line 261 of file cdrfiltr.cpp. { // Get the OILFilter object pOILFilter = new CDROILFilter(this); if (pOILFilter == NULL) return FALSE; // make sure we'll complain about life if HowCompatable isn't called Version = CDRVERSION_NULL; // All ok return TRUE; }

BOOL CDRFilter::IsTransformJustMatrices (  ADDR  Trans, INT32  Size )  [private]

scans a transform chunk. Returns TRUE if the transform was just composed of matrices and unknown transforms. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 22/05/95 Parameters: trfd  chunk to examine [INPUTS] Returns: error flag See also: Filter Definition at line 3068 of file cdrfiltr.cpp. { // set up a matrix conversion object CDRTransformConvertor *Conv; // putting the convertors here is probably more efficicent than allocating // a new one in the heap as they're not very big at all CDRTransformConvertor5 Conv5; CDRTransformConvertor4 Conv4; CDRTransformConvertor3 Conv3; switch(Version) { case CDRVERSION_5: Conv = &Conv5; break; case CDRVERSION_4: Conv = &Conv4; break; case CDRVERSION_3: Conv = &Conv3; break; default: return FALSE; break; } // initialise the convertor object Conv->Init(Trans, Size); // check all the transformations in the chunk for(INT32 t = Conv->GetNTransforms() - 1; t >= 0; t--) { switch(Conv->GetTransformType(t)) { case CDRTRANSFORMTYPE_MATRIX: case CDRTRANSFORMTYPE_UNKNOWN: break; default: return FALSE; break; } } return TRUE; }

BOOL CDRFilter::MakeTextOnPathLinkList (   )  [private]

creates the list of paths which should be linked to text stories to get text on paths. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 09/06/95 Parameters: -  [INPUTS] Returns: error flag See also: CDRFilter Definition at line 2545 of file cdrtext.cpp. { if(LinkTable == 0) return TRUE; // no link table, no list... // run through the table creating entries cdrfLinkTableHdr *Table = (cdrfLinkTableHdr *)LinkTable; INT32 Entries = CDRDATA_WORD(Table->Entries); WORD *Offsets = (WORD *)(LinkTable + CDRDATA_WORD(Table->OffsetsOffset)); if(Version != CDRVERSION_3) { // make for versions 4 and 5 for(INT32 l = 0; l < Entries; l++) { cdrfLinkTableEntryTextOnPath *En = (cdrfLinkTableEntryTextOnPath *)(LinkTable + CDRDATA_WORD(Offsets[l])); if(En->Type == cdrfLINKTABLEENTRY_TEXTONPATH) { // make a new list item for this thingy CDRTextOnPathLink *Item = new CDRTextOnPathLink; if(Item == 0) return FALSE; // pop in the serial numbers Item->PathSerialNumber = CDRDATA_WORD(En->PathSerialNumber); Item->TextSerialNumber = CDRDATA_WORD(En->TextSerialNumber); // add the item to the list TextOnPathLinks.AddTail(Item); } } } else { // make for version 3 for(INT32 l = 0; l < Entries; l++) { cdrfLinkTableEntryTextOnPathV3 *En = (cdrfLinkTableEntryTextOnPathV3 *)(LinkTable + CDRDATA_WORD(Offsets[l])); if(En->Type == cdrfLINKTABLEENTRYV3_TEXTONPATH) { // make a new list item for this thingy CDRTextOnPathLink *Item = new CDRTextOnPathLink; if(Item == 0) return FALSE; // pop in the serial numbers Item->PathSerialNumber = CDRDATA_WORD(En->PathSerialNumber); Item->TextSerialNumber = CDRDATA_WORD(En->TextSerialNumber); // add the item to the list TextOnPathLinks.AddTail(Item); } } } return TRUE; }

BOOL CDRFilter::NoFill (  void   )  [private]

makes an object not filled Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24/04/95 Parameters: -  [INPUTS] Returns: error flag See also: Filter Definition at line 272 of file cdrfill.cpp. { if(pMadeNode->IsKindOf(CC_RUNTIME_CLASS(NodePath))) { NodePath *pPath = (NodePath *)pMadeNode; pPath->InkPath.IsFilled = FALSE; } ObjFilled = FALSE; SetFillColour(DocColour(COLOUR_TRANS)); return SetPathFilled(FALSE); }

BOOL CDRFilter::ProcessDoc (  void   )  [private]

Processes the root level doc chunk of a CDR file. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 22 03 95 Parameters: none  [INPUTS] Returns: error flag See also: Filter Definition at line 935 of file cdrfiltr.cpp. { BOOL InFillTable = FALSE; BOOL InOutlineTable = FALSE; BOOL InStyleTable = FALSE; BOOL InFontTable = FALSE; BOOL InArrowheadTable = FALSE; BOOL InPatternTable = FALSE; BOOL InBitmapTable = FALSE; BOOL GotPageInfo = FALSE; ADDR VectorListContents = 0; INT32 VectorListContentsSize; TRACEUSER( "Ben", _T("In ProcessDoc\n")); // store the level we're working on UINT32 StartLevel = RIFF->GetObjLevel(); do { switch(RIFF->GetObjType()) { case RIFFOBJECTTYPE_LISTSTART: // list start - attributes are stored in lists switch(RIFF->GetObjChunkType()) { case cdrT_filt: InFillTable = TRUE; break; case cdrT_otlt: InOutlineTable = TRUE; break; case cdrT_stlt: InStyleTable = TRUE; break; case cdrT_fntt: InFontTable = TRUE; break; case cdrT_arrt: InArrowheadTable = TRUE; break; case cdrT_bpft: InPatternTable = TRUE; break; case cdrT_bmpt: InBitmapTable = TRUE; break; default: break; case cdrT_vect: // get the contents of this list for later if(!RIFF->GetListContents(&VectorListContents, &VectorListContentsSize)) return FALSE; // and skip to the end of it if(!RIFF->SkipToListEnd(RIFF->GetObjLevel())) return FALSE; break; case cdrT_btxt: if(Version == CDRVERSION_4) { // if we're in a version 4 file, this contains text for the paragraph text objects if(!ProcessTextList4()) return FALSE; } break; } break; case RIFFOBJECTTYPE_LISTEND: switch(RIFF->GetObjChunkType()) { case cdrT_filt: InFillTable = FALSE; break; case cdrT_otlt: InOutlineTable = FALSE; break; case cdrT_stlt: InStyleTable = FALSE; break; case cdrT_fntt: InFontTable = FALSE; break; case cdrT_arrt: InArrowheadTable = FALSE; break; case cdrT_bpft: InPatternTable = FALSE; break; case cdrT_bmpt: InBitmapTable = FALSE; break; default: break; } break; case RIFFOBJECTTYPE_CHUNK: // got a chunk to be interested about! switch(RIFF->GetObjChunkType()) { case cdrT_fill: if(InFillTable) Fills.AddChunkToStore(RIFF); break; case cdrT_outl: if(InOutlineTable) Outlines.AddChunkToStore(RIFF); break; case cdrT_styd: if(InStyleTable) Styles.AddChunkToStore(RIFF); break; case cdrT_font: if(InFontTable) Fonts.AddChunkToStore(RIFF, Version); break; case cdrT_arrw: if(InArrowheadTable) Arrowheads.AddChunkToStore(RIFF); break; case cdrT_bmpf: if(InPatternTable) Patterns.AddChunkToStore(RIFF, TRUE, this); UpdateProgress(TRUE); break; case cdrT_bmp: // a couple of forced progress updates here to ensure a // resonably often updated progress bar UpdateProgress(TRUE); if(InBitmapTable) Bitmaps.AddChunkToStore(RIFF, FALSE, this); UpdateProgress(TRUE); break; case cdrT_mcfg: { // get the chunk and read the page size if(GotPageInfo) // if we've already got it, then there's a problem with the file { TRACEUSER( "Ben", _T("mcfg chunk encountered twice in doc list\n")); ERROR1(FALSE, _R(IDE_CDRFILTER_FORMATERROR)); } if(!RIFF->AquireChunkData()) return FALSE; cdrfPageInfo *i = (cdrfPageInfo *)RIFF->GetAquiredData(); ERROR3IF(i == 0, "No aquired data returned from RIFF chunk"); PageX = CDRDATA_WORD(i->PageX) * CDRCOORDS_TO_MILLIPOINTS; PageY = CDRDATA_WORD(i->PageY) * CDRCOORDS_TO_MILLIPOINTS; Landscape = (CDRDATA_WORD(i->Orientation) == cdrf_ORIENTATION_LANDSCAPE)?TRUE:FALSE; GotPageInfo = TRUE; } break; case cdrT_tspc: // font style table for version 3 if(Version == CDRVERSION_3) { // store the font styles if((FontStylesV3 = (ADDR)CCMalloc(RIFF->GetObjSize())) == 0) return FALSE; if(!RIFF->GetChunkData(FontStylesV3, RIFF->GetObjSize())) return FALSE; } break; case cdrT_ftbl: // font name table for version 3 if(Version == CDRVERSION_3) { // store the font names if((FontTableV3 = (ADDR)CCMalloc(RIFF->GetObjSize())) == 0) return FALSE; if(!RIFF->GetChunkData(FontTableV3, RIFF->GetObjSize())) return FALSE; // store number of entries FontTableEntriesV3 = RIFF->GetObjSize() / sizeof(cdrfFontTableEntryV3); // cache the font names cdrfFontTableEntryV3 *FT = (cdrfFontTableEntryV3 *)FontTableV3; for(INT32 l = 0; l < FontTableEntriesV3; l++) { if(FT[l].Name[0] != '\0' && FT[l].Name[0] != ' ') { //GetApplication()->GetFontManager()->CacheNamedFont(&String_64((TCHAR *)&FT[l].Name)); Fonts.AddFontToStore(FT[l].Reference, (TCHAR *)&FT[l].Name); } } } break; case cdrT_lnkt: // store the link table - it's a pretty useful piece of kit if((LinkTable = (ADDR)CCMalloc(RIFF->GetObjSize())) == 0) return FALSE; if(!RIFF->GetChunkData(LinkTable, RIFF->GetObjSize())) return FALSE; // generate the links from paths to text text from it if(!MakeTextOnPathLinkList()) return FALSE; break; default: break; } break; default: break; } UpdateProgress(); if(!RIFF->NextObject()) return FALSE; ERROR3IF(RIFF->GetObjType() == RIFFOBJECTTYPE_FILEEND, "Unexpected end of RIFF file in ProcessDoc"); } while(RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() > StartLevel); // process the vector list, if we got one if(VectorListContents != 0) { if(!ProcessVectorList(VectorListContents, VectorListContentsSize)) { CCFree(VectorListContents); return FALSE; } CCFree(VectorListContents); } // if this isn't a version 3 file, check that we got some page info if(Version != CDRVERSION_3) { if(GotPageInfo == FALSE) { TRACEUSER( "Ben", _T("mcfg chunk not found in doc list\n")); ERROR1(FALSE, _R(IDE_CDRFILTER_FORMATERROR)); } // set the page size? if(!pDocument->IsImporting() && PageX > 0 && PageY > 0) { // Make the pasteboard an extra page width either side of the page and an extra // half page height above and below the page. That should be nicely proportional. INT32 ms = (PageX > PageY)?PageX:PageY; // we're opening the file, so set the page size if (pSpread) { BOOL ok = pSpread->SetPageSize(PageX, PageY, ms, 0, FALSE, TRUE); // Must set the origin of the grid to the bottom left corner of the // union rectangle of all pages on the spread as this is where the x,y // measurements are made from. DocRect PagesRect; NodeGrid* pGrid = pSpread->FindFirstDefaultGridInSpread(); ok = ok && pSpread->GetPagesRect(&PagesRect); if (pGrid) pGrid->SetOrigin(PagesRect.lox, PagesRect.loy); if (!ok) return FALSE; } } // Use bottom left of page as origin DocRect PageRect = pPage->GetPageRect(); Origin = PageRect.lo; // set the translation variables to position the bottom left hand corner of the page // at the bottom left hand corner of the page we're importing onto. The origin of // a CDR file is in the centre of the page TranslateByX = Origin.x + (PageX / 2); TranslateByY = Origin.y + (PageY / 2); } TRACEUSER( "Ben", _T("PageX = %d, PageY = %d\n"), PageX, PageY); return TRUE; }

BOOL CDRFilter::ProcessGroup (  UINT32  Level, BOOL  FromLink = FALSE )  [private]

Sets up a group end action and alters the level node list to be a new list. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 26 03 95 Parameters: none  [INPUTS] Returns: error flag See also: Definition at line 1535 of file cdrfiltr.cpp. { // if it's a CDR3 file we need a transform action if(Version == CDRVERSION_3) { // see if there's a transform object around BOOL Found = FALSE; do { if(!RIFF->NextObject()) return FALSE; FOURCC id = RIFF->GetObjChunkType(); // the group need not have a transform chunk, so we've got to be a little careful if(id == cdrT_grp || id == cdrT_lnkg || id == cdrT_obj) { // oh dear, it didn't - make sure this object we've just run onto is seen again RIFF->RepeatCurrent(); break; } if(id == cdrT_lobj && RIFF->GetObjType() == RIFFOBJECTTYPE_CHUNK) { // found a transform chunk Found = TRUE; } } while(Found == FALSE); // if there is, set up a post transform action if(Found) { TRACEUSER( "Ben", _T("Setting transform for CDR3 group at level %d\n"), Level); CDRActionTransform *TAct = new CDRActionTransform; if(TAct == 0) return FALSE; // initialise my new action, giving it the RIFFFile we're using // it takes the current chunk as it's data. if(!TAct->Init(RIFF, Version)) return FALSE; // set it to act on the same level ending as the group TAct->SetLevel(Level); // add my new action to the action list Actions.AddTail(TAct); } } else if(!FromLink) { // see if there's a transform chunk, and if there is, whether it's got a non matrix transform in it or not BOOL Found = FALSE; do { if(!RIFF->NextObject()) return FALSE; FOURCC id = RIFF->GetObjChunkType(); // the group need not have a transform chunk, so we've got to be a little careful if(id == cdrT_grp || id == cdrT_lnkg || id == cdrT_obj) { // oh dear, it didn't - make sure this object we've just run onto is seen again RIFF->RepeatCurrent(); break; } if(id == cdrT_trfl && RIFF->GetObjType() == RIFFOBJECTTYPE_LISTSTART) { // found a transform list Found = TRUE; } } while(Found == FALSE); // if there is, set up a post transform action if(Found) { CDRActionTransform *Act = new CDRActionTransform; if(Act == 0) return FALSE; // initialise my new action, giving it the RIFFFile we're using // it takes the current chunk as it's data. if(!Act->Init(RIFF, Version)) return FALSE; // check to see if the transform contains a non-matrix thingy if(IsTransformJustMatrices(Act->Chunk, Act->ChunkSize)) { // just matrices - don't do this action delete Act; } else { // set it to act on the same level ending as the group Act->SetLevel(Level); // set it to ignore matrices Act->SetIsAGroupTransform(TRUE); // add my new action to the action list Actions.AddTail(Act); } } } CDRActionGroupEnd *Act = new CDRActionGroupEnd; if(Act == 0) return FALSE; // store this levels node list Act->pOldLevelNodeList = pLevelNodeList; // set up the level it's interested in Act->SetLevel(Level); // and start a new level node list for this group pLevelNodeList = 0; Actions.AddTail(Act); return TRUE; }

BOOL CDRFilter::ProcessLayer (  void   )  [private]

Processes a layer list of a CDR file. This is the function which actually grabs objects to convert. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24 03 95 Parameters: none  [INPUTS] Returns: error flag See also: Definition at line 1313 of file cdrfiltr.cpp. { TRACEUSER( "Ben", _T("In ProcessLayer\n")); // first of all, create a new layer item in the page list ERROR3IF(ThisLayer != 0, "ThisLayer is not null - ProcessLayer called in wrong context"); ThisLayer = new CDRLayerListItem; if(ThisLayer == 0) return FALSE; // link it into the layer list on the page we're working on ThisPage->Layers.AddTail(ThisLayer); // store the level we're working on UINT32 StartLevel = RIFF->GetObjLevel(); ThisLayer->Objects = 0; ThisLayer->IsVisible = TRUE; ThisLayer->IsLocked = FALSE; // set up the pointer to the node list to add to ERROR3IF(pLevelNodeList != 0, "Level node list is not empty"); pLevelNodeList = 0; // if we're on the master page, find the layer name if(InMasterPage) { BOOL Done = FALSE; FOURCC LookingFor = (Version == CDRVERSION_3)?cdrT_lobj:cdrT_loda; do { if(RIFF->GetObjType() == RIFFOBJECTTYPE_CHUNK && RIFF->GetObjChunkType() == LookingFor) { // found the interesting chunk of data if(!RIFF->AquireChunkData()) return FALSE; cdrfMasterLayerInfo *i = (cdrfMasterLayerInfo *)RIFF->GetAquiredData(); if(i == 0) // data couldn't be got return FALSE; if(i->Size != RIFF->GetObjSize()) { TRACEUSER( "Ben", _T("level data in master page has wrong size\n")); ERROR1(FALSE, _R(IDE_CDRFILTER_FORMATERROR)); } // different format of layer info for version 3 if(Version == CDRVERSION_3) { cdrfMasterLayerInfoV3 *ii = (cdrfMasterLayerInfoV3 *)RIFF->GetAquiredData(); TRACEUSER( "Ben", _T("name of layer = %s\n"), ii->Name); ThisLayer->Name = (char *)ii->Name; } else { TRACEUSER( "Ben", _T("name of layer = %s\n"), i->Name); ThisLayer->Name = (char *)i->Name; } Done = TRUE; } else if(RIFF->GetObjType() == RIFFOBJECTTYPE_CHUNK && RIFF->GetObjChunkType() == cdrT_flgs) { // look at the flags of the layer... if(!RIFF->AquireChunkData()) return FALSE; WORD *pFlags = (WORD *)RIFF->GetAquiredData(); ERROR3IF(pFlags == 0, "RIFF class shouldn't have done that"); INT32 Flags = CDRDATA_WORD(*pFlags); if((Flags & cdrfLAYERFLAGS_INVISIBLE) != 0) ThisLayer->IsVisible = FALSE; if((Flags & cdrfLAYERFLAGS_LOCKED) != 0) ThisLayer->IsLocked = TRUE; } if(!RIFF->NextObject()) return FALSE; } while(Done == FALSE && (RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() > StartLevel)); if(Done == FALSE) { TRACEUSER( "Ben", _T("Reached level end in master page layer without finding layer attributes\n")); ERROR1(FALSE, _R(IDE_CDRFILTER_FORMATERROR)); } } else { ThisLayer->Name = ""; } // go through the layer list processing the objects if(!ProcessObjectTree(StartLevel)) return FALSE; // put the nodes we got onto the layer we're processing ThisLayer->Objects = pLevelNodeList; pLevelNodeList = 0; // finally mark ThisLayer as not used ThisLayer = 0; TRACEUSER( "Ben", _T("End ProcessLayer\n")); return TRUE; }

BOOL CDRFilter::ProcessLink (  void   )  [private]

Sets up a group end action and a post transform action and alters the level node list to be a new list. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 26 03 95 Parameters: none  [INPUTS] Returns: error flag See also: Definition at line 1750 of file cdrfiltr.cpp. { // store the level we're on UINT32 GroupLevel = RIFF->GetObjLevel(); // only search for a transform block if this isn't a CDR3 file - ProcessGroup // takes care of it in that case if(Version != CDRVERSION_3) { // we want to set up the transform object first so that it's done *after* the group end // object as the transform object acts on the last object converted // see if there's a transform object around BOOL Found = FALSE; do { if(!RIFF->NextObject()) return FALSE; FOURCC id = RIFF->GetObjChunkType(); // the group need not have a transform chunk, so we've got to be a little careful if(id == cdrT_grp || id == cdrT_lnkg || id == cdrT_obj) { // oh dear, it didn't - make sure this object we've just run onto is seen again RIFF->RepeatCurrent(); break; } if(id == cdrT_trfl && RIFF->GetObjType() == RIFFOBJECTTYPE_LISTSTART) { // found a transform list Found = TRUE; } } while(Found == FALSE); // if there is, set up a post transform action if(Found) { CDRActionTransform *Act = new CDRActionTransform; if(Act == 0) return FALSE; // initialise my new action, giving it the RIFFFile we're using // it takes the current chunk as it's data. if(!Act->Init(RIFF, Version)) return FALSE; // set it to act on the same level ending as the group Act->SetLevel(GroupLevel); // set up link translation things Act->LinkTrans = TRUE; LinkTransformsExist = TRUE; // add my new action to the action list Actions.AddTail(Act); } } // set up a group end action if(!ProcessGroup(GroupLevel, TRUE)) return FALSE; return TRUE; }

BOOL CDRFilter::ProcessObject (  void   )  [private]

Converts an object. If there's a problem with the object, then it's skipped rather than reporting an error, and the count of problem objects incremented. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 24 03 95 Parameters: none  [INPUTS] Returns: error flag See also: Definition at line 2010 of file cdrfiltr.cpp. { UINT32 StartLevel = RIFF->GetObjLevel(); // set the made node to none pMadeNode = 0; // set the already applied flag AttrsAlreadyApplied = FALSE; // set the is text things to make sure bodges don't happen IsText = FALSE; IsTextStory = FALSE; // find the loda (4 or 5) or lobj (3) chunk... contains the object header BOOL Found = FALSE; FOURCC LookingFor = (Version == CDRVERSION_3)?cdrT_lobj:cdrT_loda; do { // is the serial number? if(RIFF->GetObjType() == RIFFOBJECTTYPE_CHUNK && RIFF->GetObjChunkType() == cdrT_spnd) { // got the serial number block - get it... if(!RIFF->AquireChunkData()) return FALSE; WORD *Data = (WORD *)RIFF->GetAquiredData(); if(Data == 0) return FALSE; // store it... SerialNumber = CDRDATA_WORD(*Data); } if(RIFF->GetObjType() == RIFFOBJECTTYPE_CHUNK && RIFF->GetObjChunkType() == LookingFor) { Found = TRUE; break; } if(!UpdateProgress()) return FALSE; if(!RIFF->NextObject()) return FALSE; } while(RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() > StartLevel); // if we didn't find anything, then the object has a wrong format if(Found == FALSE) { TRACEUSER( "Ben", _T("Could not find loda (or lobj) chunk in object\n")); ObjectsFormatWrong++; return TRUE; } // get the header - but get it into our block, not the one in RIFFFile as we need // to refer to it later. It shouldn't be too big to make this inefficient... cdrfOffsetHeader *Header; // ensure we have a block big enough if(ObjDataBlock == 0 || ObjDataBlockSize < RIFF->GetObjSize()) { // free the old one CCFree(ObjDataBlock); // size? INT32 Size = RIFF->GetObjSize(); if((ObjDataBlock = (ADDR)CCMalloc(Size)) == 0) return FALSE; ObjDataBlockSize = Size; } if(!RIFF->GetChunkData(ObjDataBlock, ObjDataBlockSize)) return FALSE; Header = (cdrfOffsetHeader *)ObjDataBlock; // look at the type and dispatch to appropriate processing function FormatError = FALSE; INT32 ObjectType = CDRDATA_WORD(Header->ObjectType); // if this is a version 3 object, alter it's type if(Version == CDRVERSION_3) ObjectType += cdrfOBJTYPE_V3ADD; switch(ObjectType) { case cdrfOBJTYPE_RECTANGLE: if(!ConvertRectangle(Header)) return FALSE; break; case cdrfOBJTYPE_ELLIPSE: if(!ConvertEllipse(Header)) return FALSE; break; case cdrfOBJTYPE_PATH: if(!ConvertPath(Header)) return FALSE; break; case cdrfOBJTYPE_TEXT: case cdrfOBJTYPE_TEXTSTORY: if(!ConvertText(Header)) return FALSE; break; case cdrfOBJTYPE_BITMAP: if(!ConvertBitmap(Header)) return FALSE; break; default: // unknown object type ObjectsUnknown++; RIFF->SkipToListEnd(StartLevel); return TRUE; break; } // check to see if the format was OK if(FormatError) { TRACEUSER( "Ben", _T("A convert object function returned a format error\n")); ObjectsFormatWrong++; if(TransformChunk != 0) { CCFree(TransformChunk); TransformChunk = 0; } return TRUE; } ERROR3IF(pMadeNode == 0, "No node made, but still nothing errored\n"); // think about lenses BOOL UnsetTransparency = FALSE; if(Version == CDRVERSION_5) { cdrfLensDefn *Lens = (cdrfLensDefn *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_LENS); if(Lens != 0) { // we have a lens to worry about... what type is it? if(Lens->Type == cdrfLENSTYPE_TRANSPARENT) { // check the percentage UINT32 Percent = CDRDATA_WORD(Lens->Percent) / 10; if(Percent <= 100) { // munge the percentage a bit to get it to a Camelot definition Percent = 256 - ((Percent * 256) / 100); // what subtype is it? switch(Lens->SubType) { case cdrfTRANSPARENTTYPE_MIX: SetFlatTranspFill(T_REFLECTIVE, Percent); UnsetTransparency = TRUE; break; case cdrfTRANSPARENTTYPE_STAINED: SetFlatTranspFill(T_SUBTRACTIVE, Percent); UnsetTransparency = TRUE; break; case cdrfTRANSPARENTTYPE_BLEACH: SetFlatTranspFill(T_ADDITIVE, Percent); UnsetTransparency = TRUE; break; default: break; } } } } } // find the transform chunk - it's in a seperate chunk for version 4 or 5 file, // and in the data chunk for version 3 files ADDR TransformData = 0; INT32 TransformDataSize = 0; if(TransformChunk != 0) { // if something had to move forward in the file (for example, text objects) // past the transform chunk, it will have stored it here. TransformData = TransformChunk; TransformDataSize = TransformChunkSize; } else if(Version == CDRVERSION_3) { TransformData = FindDataInObject(Header, cdrfOBJOFFSETTYPE_TRANSFORM_V3); } else { Found = FALSE; do { if(RIFF->GetObjType() == RIFFOBJECTTYPE_LISTSTART && RIFF->GetObjChunkType() == cdrT_trfl) { Found = TRUE; break; } UpdateProgress(); if(!RIFF->NextObject()) return FALSE; } while(RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() > StartLevel); // if we didn't find anything, then the object has a wrong format if(Found == FALSE) { TRACEUSER( "Ben", _T("Could not find trfd chunk in object\n")); ObjectsFormatWrong++; // delete the current node delete pMadeNode; return TRUE; } // aquire the chunk data if(!RIFF->AquireListContents(&TransformDataSize)) { delete pMadeNode; return FALSE; } TransformData = RIFF->GetAquiredData(); } if(TransformData == 0) { ObjectsFormatWrong++; // delete the current node delete pMadeNode; return TRUE; } // go through any link transforms which may exist if(Version != CDRVERSION_3) { if(LinkTransformsExist) { BOOL FoundSome = FALSE; CDRActionListItem *Act = (CDRActionListItem *)Actions.GetTail(); while(Act != 0) { if(IS_A(Act, CDRActionTransform)) { CDRActionTransform *Tran = (CDRActionTransform *)Act; if(Tran->LinkTrans) { // set the flag to say we found a link transform FoundSome = TRUE; // transform the converte object if(!TransformConvertedObject(&pMadeNode, Tran->Chunk, Tran->ChunkSize, FALSE)) { delete pMadeNode; return FALSE; } } } Act = (CDRActionListItem *)Actions.GetPrev(Act); } LinkTransformsExist = FoundSome; } } // apply the transform to the converted node if(!TransformConvertedObject(&pMadeNode, TransformData, TransformDataSize)) { delete pMadeNode; return FALSE; } // apply attributes if(AttrsAlreadyApplied == FALSE) { // look at fill attributes if(!SetFillAttr(Header)) return FALSE; // look at line attributes if(!SetLineAttr(Header)) return FALSE; } BOOL Result; if(AttrsAlreadyApplied == FALSE) { // apply the attributes to the object // If not filled, then set the ignore bit on the fill attribute. if (ObjFilled == FALSE) CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = TRUE; // Add attributes to the path, if they are different from the default... Result = AttributeManager::ApplyBasedOnDefaults(pMadeNode, CurrentAttrs); // Enable the fill attribute again CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = FALSE; } else { Result = TRUE; } if(!Result) return FALSE; if(UnsetTransparency) { SetNoTranspFill(); } // attach the node to the level list if(pLevelNodeList != 0) pMadeNode->AttachNode(pLevelNodeList, PREV); pLevelNodeList = pMadeNode; // set the made node pointer to zero to prevent accidents pMadeNode = 0; // increment the count of converted objects ObjectsConverted++; // if necessary, get rid of any transform chunk if(TransformChunk != 0) { CCFree(TransformChunk); TransformChunk = 0; } return TRUE; }

BOOL CDRFilter::ProcessObjectTree (  UINT32  Level  )  [private]

process objects from the CDR file - they end up linked to pLevelNodeList. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 19/04/95 Parameters: the  RIFF level the list we're processing starts at [INPUTS] Returns: error flag See also: Filter, CDRFilter::ProcessLayer, CDRFilter::ProcessVectorList Definition at line 1437 of file cdrfiltr.cpp. { do { switch(RIFF->GetObjType()) { case RIFFOBJECTTYPE_LISTSTART: // see if it's anything we're interested in switch(RIFF->GetObjChunkType()) { case cdrT_obj: // found an object if(!ProcessObject()) return FALSE; break; case cdrT_grp: // found a group type objects if(!ProcessGroup(RIFF->GetObjLevel())) return FALSE; break; case cdrT_lnkg: // found a link object - treated as the same as a group, but searched for a // transformation matrix if(!ProcessLink()) return FALSE; break; default: break; } break; case RIFFOBJECTTYPE_LISTEND: // check to see if any actions are associated with this list end if(!Actions.IsEmpty()) { CDRActionListItem *Act, *Previous; Act = (CDRActionListItem *)Actions.GetTail(); // perform the actions which end on this level while(Act != 0) { if(Act->GetLevel() >= RIFF->GetObjLevel()) { // the last action ended on this level - perform the action if(!Act->DoAction(this)) return FALSE; // get the previous item Previous = (CDRActionListItem *)Actions.GetPrev(Act); // remove and delete the action we just performed delete Actions.RemoveTail(); // and set up the pointer to the next action to look at Act = Previous; } else { // the action shouldn't be performed yet - stop looking break; } } } break; default: break; } if(!UpdateProgress()) return FALSE; if(!RIFF->NextObject()) return FALSE; ERROR3IF(RIFF->GetObjType() == RIFFOBJECTTYPE_FILEEND, "Unexpected end of RIFF file in ProcessLayer"); } while(RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() > Level); return TRUE; }

BOOL CDRFilter::ProcessPage (  void   )  [private]

Processes a page list of a CDR file. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 22 03 95 Parameters: none  [INPUTS] Returns: error flag See also: Filter Definition at line 1224 of file cdrfiltr.cpp. { TRACEUSER( "Ben", _T("In ProcessPage\n")); // first of all, create a new page item in the page list ERROR3IF(ThisPage != 0, "ThisPage is not null - ProcessPage called in wrong context"); ThisPage = new CDRPageListItem; if(ThisPage == 0) return FALSE; // link it into the page list Pages.AddTail(ThisPage); // set the master page flag if(DoneMasterPage == FALSE) InMasterPage = TRUE; // go through the page list processing the layers // store the level we're working on UINT32 StartLevel = RIFF->GetObjLevel(); do { if(RIFF->GetObjType() == RIFFOBJECTTYPE_LISTSTART && RIFF->GetObjChunkType() == cdrT_layr) { // it's a layer, process it if(!ProcessLayer()) { TRACEUSER( "Ben", _T("ProcessLayer returned FALSE\n")); return FALSE; } } // if we're doing a version 3 file, have we got a page // size chunk to play with? if(Version == CDRVERSION_3 && RIFF->GetObjType() == RIFFOBJECTTYPE_CHUNK && RIFF->GetObjChunkType() == cdrT_mcfg) { if(!RIFF->AquireChunkData()) return FALSE; cdrfPageInfoV3 *i = (cdrfPageInfoV3 *)RIFF->GetAquiredData(); // in a CDR 3 file, the page size is half what it should be PageX = CDRDATA_WORD(i->PageX) * CDRCOORDS_TO_MILLIPOINTS * 2; PageY = CDRDATA_WORD(i->PageY) * CDRCOORDS_TO_MILLIPOINTS * 2; Landscape = FALSE; } UpdateProgress(); if(!RIFF->NextObject()) return FALSE; ERROR3IF(RIFF->GetObjType() == RIFFOBJECTTYPE_FILEEND, "Unexpected end of RIFF file in ProcessDoc"); } while(RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() > StartLevel); // finally make ThisPage as not used ThisPage = 0; // sort out master page flags if(InMasterPage) { InMasterPage = FALSE; DoneMasterPage = TRUE; } TRACEUSER( "Ben", _T("End ProcessPage\n")); return TRUE; }

BOOL CDRFilter::ProcessTextList4 (   )  [private]

Processes the list of text objects for a version 4 CDR file creating text lines and textchars with partially applied attributes. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 12/05/95 Parameters: -  [INPUTS] Returns: error flag See also: CDRFilter Definition at line 2240 of file cdrtext.cpp. { // What we've got... // btxt the list we're current on // strl contains text for a paragraph object // btid the id of the text // parl a pargraph // para paragraph info // then any number of... // bnch n plain characters // bsch a character with styles applied to it ERROR3IF(RIFF->GetObjType() != RIFFOBJECTTYPE_LISTSTART || RIFF->GetObjChunkType() != cdrT_btxt, "ProcessTextList4 called in the wrong context"); UINT32 EndLevel = RIFF->GetObjLevel(); do { if(RIFF->GetObjType() == RIFFOBJECTTYPE_LISTSTART && RIFF->GetObjChunkType() == cdrT_strl) { if(!ProcessTextListItem4()) return FALSE; } if(!RIFF->NextObject()) return FALSE; } while(RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() > EndLevel); return TRUE; }

BOOL CDRFilter::ProcessTextListItem4 (   )  [private]

Processes a item from the list of text objects for a version 4 CDR file creating text lines and textchars with partially applied attributes. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 12/05/95 Parameters: -  [INPUTS] Returns: error flag See also: CDRFilter Definition at line 2287 of file cdrtext.cpp. { // What we've got... // strl contains text for a paragraph object // btid the id of the text // parl a pargraph // para paragraph info // then any number of... // bnch n plain characters // bsch a character with styles applied to it ERROR3IF(RIFF->GetObjType() != RIFFOBJECTTYPE_LISTSTART || RIFF->GetObjChunkType() != cdrT_strl, "ProcessTextListItem4 called in the wrong context"); UINT32 EndLevel = RIFF->GetObjLevel(); TextLine *FirstLine = 0; TextLine *CurrentLine = 0; INT32 MaxFirstLineSpace = 0; BOOL IsFirstLine = TRUE; WORD ID = 0; CDRTextStyle BaseStyle = CDRDefaultTextStyle; do { if(RIFF->GetObjType() == RIFFOBJECTTYPE_CHUNK) { switch(RIFF->GetObjChunkType()) { case cdrT_btid: // id of thingy, store { if(!RIFF->AquireChunkData()) return FALSE; WORD *Thingy = (WORD *)RIFF->GetAquiredData(); ERROR2IF(Thingy == 0, FALSE, "Couldn't get aquired data"); ID = CDRDATA_WORD(*Thingy); } break; case cdrT_para: { // do we need an end of line node for something? if(CurrentLine != 0) { EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD); if(EOL == 0) return FALSE; } // new paragraph start - create a new line if(CurrentLine == 0) { CurrentLine = new TextLine; } else { CurrentLine = new TextLine(CurrentLine, NEXT); } if(CurrentLine == 0) return FALSE; if(FirstLine == 0) FirstLine = CurrentLine; else IsFirstLine = FALSE; // get the style of this paragraph if(!RIFF->AquireChunkData()) return FALSE; cdrfParaDefnV4 *Para = (cdrfParaDefnV4 *)RIFF->GetAquiredData(); if(Para == 0) return FALSE; if(!GetTextStyleFromCDRStyle(&BaseStyle, CDRDATA_WORD(Para->Style))) return FALSE; if(IsFirstLine && BaseStyle.LineSpace > MaxFirstLineSpace) MaxFirstLineSpace = BaseStyle.LineSpace; } break; case cdrT_bnch: // a load of characters ERROR2IF(CurrentLine == 0, FALSE, "CurrentLine is zero when characters found"); { // get the chunk data if(!RIFF->AquireChunkData()) return FALSE; // process it... cdrfTextListCharV4 *Chars = (cdrfTextListCharV4 *)RIFF->GetAquiredData(); ERROR2IF(Chars == 0, FALSE, "no data from aquire data"); INT32 NChars = RIFF->GetObjSize() / sizeof(cdrfTextListCharV4); // add all the nice characters we've got for(INT32 l = 0; l < NChars; l++) { if(CDRDATA_WORD(Chars[l].Char) >= ' ') { TextChar *NewChar = new TextChar(CurrentLine, LASTCHILD, CDRDATA_WORD(Chars[l].Char)); if(NewChar == 0) return FALSE; // apply attributes if(!ApplyTextAttr(NewChar, &BaseStyle, 0)) return FALSE; } } } break; case cdrT_bsch: // a character with styles attached ERROR2IF(CurrentLine == 0, FALSE, "CurrentLine is zero when characters found"); { // get the chunk data if(!RIFF->AquireChunkData()) return FALSE; // process it... cdrfTextListCharStyledV4 *Char = (cdrfTextListCharStyledV4 *)RIFF->GetAquiredData(); ERROR2IF(Char == 0, FALSE, "no data from aquire data"); if(CDRDATA_WORD(Char->Char) >= ' ') { TextChar *NewChar = new TextChar(CurrentLine, LASTCHILD, CDRDATA_WORD(Char->Char)); if(NewChar == 0) return FALSE; // apply attributes to it CDRTextStyle ThisStyle = BaseStyle; // font size ThisStyle.FontSize = CDRDATA_WORD(Char->FontSize) * CDRCOORDS_TO_MILLIPOINTS; // font name /* TCHAR *FontName = GetFontName(CDRDATA_WORD(Char->FontRef)); if(FontName != 0) { ThisStyle.FontName = FontName; } */ ThisStyle.FontReference = CDRDATA_WORD(Char->FontRef); // bold and italicness switch(Char->Weight) { case cdrfFONTTYPEV4_BOLD: ThisStyle.Bold = TRUE; ThisStyle.Italic = FALSE; break; case cdrfFONTTYPEV4_ITALIC: ThisStyle.Bold = FALSE; ThisStyle.Italic = TRUE; break; case cdrfFONTTYPEV4_BOLDITALIC: ThisStyle.Bold = TRUE; ThisStyle.Italic = TRUE; break; default: ThisStyle.Bold = FALSE; ThisStyle.Italic = FALSE; break; } // placement switch(Char->Placement) { default: case cdrfPLACEMENTV4_NONE: ThisStyle.Script = CDRSCRIPT_NONE; break; case cdrfPLACEMENTV4_SUPER: ThisStyle.Script = CDRSCRIPT_SUPER; break; case cdrfPLACEMENTV4_SUB: ThisStyle.Script = CDRSCRIPT_SUB; break; } // apply attributes if(!ApplyTextAttr(NewChar, &ThisStyle, 0)) return FALSE; // sort out max first line space if(IsFirstLine && ThisStyle.LineSpace > MaxFirstLineSpace) MaxFirstLineSpace = ThisStyle.LineSpace; } } break; default: break; } } UpdateProgress(); if(!RIFF->NextObject()) return FALSE; } while(RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() > EndLevel); if(CurrentLine != 0) { // pop some ending stuff on it CaretNode *Caret = new CaretNode(CurrentLine, LASTCHILD); EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD); if(Caret == 0 || EOL == 0) return FALSE; } if(FirstLine != 0) { // got something - add it to the list of text stuff CDRVectorStoredItem *Item = new CDRVectorStoredItem; if(Item == 0) return FALSE; // store objects Item->Objects = FirstLine; Item->Reference = ID; // pop max first line in the bbox Item->BBox.hi.y = MaxFirstLineSpace; TextV4.AddTail(Item); } return TRUE; }

BOOL CDRFilter::ProcessVectorList (  ADDR  Block, INT32  Size )  [private]

processes the vector list at the beginning of CDR files. This contains a list of objects which are used for things such as full colour fills, texture fills, mould shapes, that sort of thing. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 19/04/95 Parameters: vect  list contents and size [INPUTS] Returns: error flag They are referenced by the objects serial number. This function takes a block containing the vect list contents and it's size as Corel store all these vectors *before* the fill and outline definitions. Are these people really crazy? See also: Filter Definition at line 1455 of file cdrfill.cpp. { ERROR3IF(pLevelNodeList != 0, "ProcessVectorList called when LevelNodeList was in use"); // first of all, make a CCMemFile out of the block so we can do RIFF stuff on it CCMemFile MFile; MFile.open(Block, Size); // make a RIFF file out of it - but we don't have a header RIFFFile RFile; RFile.Init(&MFile, TRUE); // OK, change a few variables over... INT32 oTranslateByX = TranslateByX; INT32 oTranslateByY = TranslateByY; RIFFFile *oRIFF = RIFF; TranslateByX = 0; TranslateByY = 0; RIFF = &RFile; // get on and process the block // what we've got it a load of 'grp' lists containing the objects we're interested in // they contain a serial number which is used to identify the vector and a bbox, // which we need to find and store in the list do { // is it a group list? if(RIFF->GetObjType() == RIFFOBJECTTYPE_LISTSTART && RIFF->GetObjChunkType() == cdrT_grp) { if(!ProcessVectorListEntry()) return FALSE; } if(!RIFF->NextObject()) goto Failure; } while(RIFF->GetObjType() != RIFFOBJECTTYPE_FILEEND); // close everything down and put the variables back MFile.close(); TranslateByX = oTranslateByX; TranslateByY = oTranslateByY; RIFF = oRIFF; return TRUE; Failure: // clear everything up... MFile.close(); TranslateByX = oTranslateByX; TranslateByY = oTranslateByY; RIFF = oRIFF; return FALSE; }

BOOL CDRFilter::ProcessVectorListEntry (   )  [private]

processes an entry in the vector list Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 19/04/95 Parameters: -  [INPUTS] Returns: error flag See also: Filter Definition at line 1530 of file cdrfill.cpp. { UINT32 StartLevel = RIFF->GetObjLevel(); ERROR3IF(RIFF->GetObjType() != RIFFOBJECTTYPE_LISTSTART && RIFF->GetObjChunkType() != cdrT_grp, "ProcessVectorListEntry called without RIFF set up correctly"); // OK, wander though to find the serial number and the bbox WORD Reference; // the serial number DocRect BBox; BOOL GotReference = FALSE; BOOL GotBBox = FALSE; do { if(RIFF->GetObjType() == RIFFOBJECTTYPE_CHUNK) { switch(RIFF->GetObjChunkType()) { case cdrT_spnd: { // got the serial number block - get it... if(!RIFF->AquireChunkData()) return FALSE; WORD *Data = (WORD *)RIFF->GetAquiredData(); if(Data == 0) return FALSE; // store it... Reference = CDRDATA_WORD(*Data); GotReference = TRUE; } break; case cdrT_bbox: { // is it large enought? if(RIFF->GetObjSize() < sizeof(cdrfBBox)) { // no - ignore this entry RIFF->SkipToListEnd(StartLevel); return TRUE; } // found the bbox... get the data if(!RIFF->AquireChunkData()) return FALSE; cdrfBBox *Data = (cdrfBBox *)RIFF->GetAquiredData(); if(Data == 0) return FALSE; // get the bounding box BBox.lo.x = CDRDATA_SWORD(Data->x0) * CDRCOORDS_TO_MILLIPOINTS; BBox.lo.y = CDRDATA_SWORD(Data->y0) * CDRCOORDS_TO_MILLIPOINTS; BBox.hi.x = CDRDATA_SWORD(Data->x1) * CDRCOORDS_TO_MILLIPOINTS; BBox.hi.y = CDRDATA_SWORD(Data->y1) * CDRCOORDS_TO_MILLIPOINTS; GotBBox = TRUE; } break; default: break; } } if(!RIFF->NextObject()) return FALSE; } while((GotReference == FALSE || GotBBox == FALSE) && (RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() > StartLevel)); // OK, now get the object tree if(!ProcessObjectTree(StartLevel)) return FALSE; // right then, the converted nodes are in pLevelNodeList // create a nice list entry CDRVectorStoredItem *Item = new CDRVectorStoredItem; if(Item == 0) return FALSE; // set the object data Item->Objects = pLevelNodeList; Item->Reference = Reference; Item->BBox = BBox; // make the node list unused pLevelNodeList = 0; // add the list entry Vectors.AddTail(Item); return TRUE; }

BOOL CDRFilter::SetConicalGrad (  CDRFillInfo *  GFill, DocRect &  BBox, DocColour *  StartColour, DocColour *  EndColour )  [private]

sets a conical graduated fill from fill definition in the file Copied from coreleps.cpp and modified Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 28 03 95 Parameters: grad  fill defn and converted colours for the fill [INPUTS] Returns: error flag See also: Filter Definition at line 941 of file cdrfill.cpp. { // The desired start and end points of the grad fill 'arrow'. DocCoord Start, End; // Calculate width and height MILLIPOINT Width = BBox.Width(); MILLIPOINT Height = BBox.Height(); // Start point is the centre given by Corel. // This centre is percentage offsets from the centre of the object, i.e. (0,0) is // the centre of the bounding box. Start.x = BBox.lo.x + (Width / 2); Start.y = BBox.lo.y + (Height / 2); Start.x += ((GFill->HorizontalCentreOffset * Width) / 100); Start.y += ((GFill->VerticalCentreOffset * Height) / 100); // End point is start point + radius but takes into account the angle double Radius = Width / 2; // angle is * 10, and needs to be in radians double Theta = ((((double)(GFill->Angle)) / 10.0) / 360.0) * (2 * PI); // make the angle go anti-clockwise Theta = 0 - Theta; // rotate by PI / 2 Theta -= PI / 2; // angle can be negative, ensure it's positive while(Theta < 0) Theta += (2 * PI); // calculate the triangle double dx, dy; dx = Radius * sin(Theta); dy = Radius * cos(Theta); End.x = Start.x + (INT32)dx; End.y = Start.y + (INT32)dy; // Seems that we need to swap start and end colours... // Set the fill type according to these calculations. return SetConicalFill(*EndColour, *StartColour, Start, End); }

BOOL CDRFilter::SetFillAttr (  cdrfOffsetHeader *  Object  )  [private]

sets the fill attributes Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 27 03 95 Parameters: address  of the object [INPUTS] Returns: error flag See also: Filter Definition at line 128 of file cdrfill.cpp. { if(Version == CDRVERSION_3) { return SetFillAttr3(Object); } // find the reference... DWORD *pReference = (DWORD *)FindDataInObject(Object, cdrfOBJOFFSETTYPE_FILL); // if the pointer to the reference is zero, then the reference is probably // within some random style definition if(pReference == 0) { // OK, try and find a style number within the style reference WORD *pStyleReference = (WORD *)FindDataInObject(Object, cdrfOBJOFFSETTYPE_STYLE); if(pStyleReference != 0) { // OK, see if we can find a the style... cdrfStyle *pStyle; INT32 StyleSize; if((pStyle = (cdrfStyle *)Styles.Find(*pStyleReference, &StyleSize)) != 0) { // OK, got a style... now find a fill reference within it pReference = (DWORD *)FindDataInObject(&pStyle->Header, cdrfSTYLEOFFSETTYPE_FILL); } } } // should this be filled? if(pReference == 0 || ObjFilled == FALSE) { // set not filled attribute return NoFill(); } cdrfFillHeader *Fill; INT32 FillSize; // set is filled attribute if(!SetPathFilled(TRUE)) return FALSE; // try and find the data for a version 4 or 5 fill if((Fill = (cdrfFillHeader *)Fills.Find(*pReference, &FillSize)) == 0) return SetUKFill(); // check the fill's size if(FillSize < sizeof(cdrfFillHeader)) { // if no fill defn or it's just a tad to small, set the unknown fill colour return SetUKFill(); } // OK, what's this fill then? switch(CDRDATA_WORD(Fill->FillType)) { case cdrfFILLTYPE_NONE: // no fill - set things up to be hoopy about that. return NoFill(); break; case cdrfFILLTYPE_FLAT: return SetFillAttrFlat(Fill, FillSize); break; case cdrfFILLTYPE_GRADUATED: return SetFillAttrGrad(Fill, FillSize); break; case cdrfFILLTYPE_PATTERN: { CDRTiledFillInfo i; cdrfFillPattern *PFill = (cdrfFillPattern *)Fill; // check the size and set an unknown fill if it's too small if(FillSize < sizeof(cdrfFillPattern)) return SetUKFill(); // set the info structure i.SizeX = CDRDATA_SWORD(PFill->SizeX); i.SizeY = CDRDATA_SWORD(PFill->SizeY); i.OffsetX = CDRDATA_SWORD(PFill->OffsetX); i.OffsetY = CDRDATA_SWORD(PFill->OffsetY); i.Reference = CDRDATA_DWORD(PFill->Reference); // convert the colours DocColour Colour1; DocColour Colour2; ConvertColour(&PFill->Colour1, &Colour1); ConvertColour(&PFill->Colour2, &Colour2); return SetFillAttrPattern(&i, &Colour1, &Colour2); } break; case cdrfFILLTYPE_VECTOR: { CDRTiledFillInfo i; cdrfFillVector *VFill = (cdrfFillVector *)Fill; // check the size and set an unknown fill if it's too small if(FillSize < sizeof(cdrfFillVector)) return SetUKFill(); // set the info structure i.SizeX = CDRDATA_SWORD(VFill->SizeX); i.SizeY = CDRDATA_SWORD(VFill->SizeY); i.OffsetX = CDRDATA_SWORD(VFill->OffsetX); i.OffsetY = CDRDATA_SWORD(VFill->OffsetY); i.Reference = CDRDATA_DWORD(VFill->VectorReference); return SetFillAttrVector(&i); } break; case cdrfFILLTYPE_TEXTURE: return SetFillAttrTexture(Fill, FillSize); break; default: return SetUKFill(); break; } return TRUE; }

BOOL CDRFilter::SetFillAttr3 (  cdrfOffsetHeader *  Object  )  [private]

sets the fill attributes for version 3 Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/95 Parameters: address  of object [INPUTS] Returns: error flag See also: Filter Definition at line 299 of file cdrfill.cpp. { cdrfFillV3 *Fill = (cdrfFillV3 *)FindDataInObject(Object, cdrfOBJOFFSETTYPE_FILL); if(Fill == 0) { // set not filled attribute return NoFill(); } // info about the fill CDRFillInfo fi; // find the bounding box of this lovely node DocRect BBox; if(!GetObjCorelBBox((NodeRenderableBounded *)pMadeNode, &BBox)) return FALSE; // convert colours and things as necessary DocColour Col1; DocColour Col2; if(Fill->Type == cdrfFILLTYPEV3_FLAT) { if(!ConvertColour((cdrfColour *)&Fill->Data.Flat.Colour, &Col1)) return FALSE; } else if(Fill->Type == cdrfFILLTYPEV3_LINEAR || Fill->Type == cdrfFILLTYPEV3_RADIAL) { fi.Angle = CDRDATA_SWORD(Fill->Data.Grad.Angle); fi.Pad = CDRDATA_SWORD(Fill->Data.Grad.Pad); fi.HorizontalCentreOffset = CDRDATA_SWORD(Fill->Data.Grad.HorizontalCentreOffset); fi.VerticalCentreOffset = CDRDATA_SWORD(Fill->Data.Grad.VerticalCentreOffset); if(!ConvertColour((cdrfColour *)&Fill->Data.Grad.Colour1, &Col1)) return FALSE; if(!ConvertColour((cdrfColour *)&Fill->Data.Grad.Colour2, &Col2)) return FALSE; } // make the path filled if(!SetPathFilled(TRUE)) return FALSE; // set the fill switch(Fill->Type) { case cdrfFILLTYPEV3_NONE: return NoFill(); break; case cdrfFILLTYPEV3_FLAT: if(!SetFillColour(Col1)) return FALSE; break; case cdrfFILLTYPEV3_LINEAR: if(!SetLinearGrad(&fi, BBox, &Col1, &Col2)) return SetUKFill(); break; case cdrfFILLTYPEV3_RADIAL: if(!SetRadialGrad(&fi, BBox, &Col1, &Col2)) return SetUKFill(); break; case cdrfFILLTYPEV3_PATTERN: { CDRTiledFillInfo i; // set the info structure i.SizeX = CDRDATA_SWORD(Fill->Data.Pattern.SizeX); i.SizeY = CDRDATA_SWORD(Fill->Data.Pattern.SizeY); i.OffsetX = CDRDATA_SWORD(Fill->Data.Pattern.OffsetX); i.OffsetY = CDRDATA_SWORD(Fill->Data.Pattern.OffsetY); i.Reference = CDRDATA_DWORD(Fill->Data.Pattern.Reference); // convert the colours ConvertColour((cdrfColour *)&Fill->Data.Pattern.Colour1, &Col1); ConvertColour((cdrfColour *)&Fill->Data.Pattern.Colour2, &Col2); return SetFillAttrPattern(&i, &Col1, &Col2); } break; case cdrfFILLTYPEV3_VECTOR: { CDRTiledFillInfo i; // set the info structure i.SizeX = CDRDATA_SWORD(Fill->Data.Vector.SizeX); i.SizeY = CDRDATA_SWORD(Fill->Data.Vector.SizeY); i.OffsetX = CDRDATA_SWORD(Fill->Data.Vector.OffsetX); i.OffsetY = CDRDATA_SWORD(Fill->Data.Vector.OffsetY); i.Reference = CDRDATA_DWORD(Fill->Data.Vector.Reference); return SetFillAttrVector(&i); } break; default: return SetUKFill(); break; } return TRUE; }

BOOL CDRFilter::SetFillAttrFlat (  cdrfFillHeader *  Fill, INT32  Size )  [private]

sets flat fill attributes Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 28 03 95 Parameters: pointer  to fill header [INPUTS] Returns: error flag See also: Filter Definition at line 422 of file cdrfill.cpp. { cdrfFillFlat *FFill = (cdrfFillFlat *)Fill; // check the size and set an unknown fill if it's too small if(Size < sizeof(cdrfFillFlat)) return SetUKFill(); // convert and set the line colour DocColour Col; ConvertColour(&FFill->Colour, &Col); if(!SetFillColour(Col)) return FALSE; return TRUE; }

BOOL CDRFilter::SetFillAttrGrad (  cdrfFillHeader *  Fill, INT32  Size )  [private]

sets graduated fill attributes Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 28 03 95 Parameters: pointer  to fill header [INPUTS] Returns: error flag See also: Filter Definition at line 454 of file cdrfill.cpp. { // check that it's big enought to be a realistic grad fill if(Size < (sizeof(cdrfFillGraduated) + sizeof(cdrfFillGradColour))) { TRACEUSER( "Ben", _T("fill too small, size = %d\n"), Size); return SetUKFill(); } // make a new pointer cdrfFillGraduated *GFill = (cdrfFillGraduated *)Fill; // has it got enough colours in it? if(CDRDATA_WORD(GFill->NColours) < 1) return SetUKFill(); // find the bounding box of this lovely node DocRect BBox; if(!GetObjCorelBBox((NodeRenderableBounded *)pMadeNode, &BBox)) return FALSE; // sort out the colours on this fill - ATM we can only go from one colour to // another, so we just need to find the last and first ones and use those. cdrfFillGradColour *Cols = (cdrfFillGradColour *)(GFill + 1); UINT32 min = CDRDATA_WORD(Cols[0].Percentage); UINT32 max = min; UINT32 minO = 0; UINT32 maxO = 0; UINT32 l; for(l = 1; l < CDRDATA_WORD(GFill->NColours); l++) { UINT32 p = CDRDATA_WORD(Cols[l].Percentage); if(p < min) { min = p; minO = l; } if(p > max) { max = p; maxO = l; } } // OK, found the minimum and maximim percentages along the grad fill line. // get and convert the colours DocColour StartColour; DocColour EndColour; ConvertColour(&Cols[minO].Colour, &StartColour); ConvertColour(&Cols[maxO].Colour, &EndColour); // now work out what kind of fade we need here UINT32 FadeType = CDRDATA_WORD(GFill->ColourType); // if it's a rainbow effect, work out whether an anti-clockwise thingy will be a // a normal or alt rainbow fill BOOL NormalRainbow = TRUE; if(FadeType == cdrfGRADFILLCOLOURTYPE_RAINBOW_CLOCKWISE || FadeType == cdrfGRADFILLCOLOURTYPE_RAINBOW_ANTICLOCKWISE) { // convert both colours to HSV to find their hue 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 ColourValue Difference; if(EndC.Hue > StartC.Hue) { Difference = EndC.Hue - StartC.Hue; } else { Difference = 1.0 - (StartC.Hue - EndC.Hue); } // if the difference is more than 0.5 then it's a alt rainbow thingy if(Difference > fixed24(0.5)) NormalRainbow = FALSE; } // set the fade effect switch(FadeType) { case cdrfGRADFILLCOLOURTYPE_DIRECT: case cdrfGRADFILLCOLOURTYPE_CUSTOM: default: SetFadeFillEffect(); break; case cdrfGRADFILLCOLOURTYPE_RAINBOW_ANTICLOCKWISE: if(NormalRainbow) SetRainbowFillEffect(); else SetAltRainbowFillEffect(); break; case cdrfGRADFILLCOLOURTYPE_RAINBOW_CLOCKWISE: if(NormalRainbow) SetAltRainbowFillEffect(); else SetRainbowFillEffect(); break; } // get the info about the fill CDRFillInfo fi; fi.Angle = CDRDATA_SWORD(GFill->Angle); fi.Pad = CDRDATA_SWORD(GFill->Pad); fi.HorizontalCentreOffset = CDRDATA_SWORD(GFill->HorizontalCentreOffset); fi.VerticalCentreOffset = CDRDATA_SWORD(GFill->VerticalCentreOffset); // and finally, sort out the start and end points of the thingy DocCoord StartPoint; DocCoord EndPoint; switch(CDRDATA_WORD(GFill->GradFillType)) { case cdrfGRADFILLTYPE_LINEAR: if(!SetLinearGrad(&fi, BBox, &StartColour, &EndColour)) return SetUKFill(); break; case cdrfGRADFILLTYPE_RADIAL: case cdrfGRADFILLTYPE_SQUARE: // radial is the nearest Camelot fill to a square fill if(!SetRadialGrad(&fi, BBox, &StartColour, &EndColour)) return SetUKFill(); break; case cdrfGRADFILLTYPE_CONICAL: if(!SetConicalGrad(&fi, BBox, &StartColour, &EndColour)) return SetUKFill(); break; default: return SetUKFill(); break; } return TRUE; }

BOOL CDRFilter::SetFillAttrPattern (  CDRTiledFillInfo *  Info, DocColour *  Colour1, DocColour *  Colour2 )  [private]

set pattern fill attributes Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 10/04/95 Parameters: pointer  to fill header [INPUTS] Returns: error flag See also: Filter Definition at line 1212 of file cdrfill.cpp. { // find the bitmap we're going to use KernelBitmap *pBitmap = Patterns.FindBitmap(Info->Reference); if(pBitmap == 0) return SetUKFill(); // work out where it's going to go. // find the size of the tile INT32 SizeX = Info->SizeX * CDRCOORDS_TO_MILLIPOINTS; INT32 SizeY = Info->SizeY * CDRCOORDS_TO_MILLIPOINTS; // find the bounding box of this lovely node DocRect BBox; if(!GetObjCorelBBox((NodeRenderableBounded *)pMadeNode, &BBox)) return FALSE; // set to the top left + the first tile offset INT32 XPos = BBox.lo.x + ((SizeX * Info->OffsetX) / 100); INT32 YPos = BBox.hi.y - SizeY - ((SizeY * Info->OffsetY) / 100); // can't do anything with the row/column staggering thingy // set the bitmap fill DocCoord Start = DocCoord(XPos, YPos); DocCoord End1 = DocCoord(XPos + SizeX, YPos); DocCoord End2 = DocCoord(XPos, YPos + SizeY); if(!SetBitmapFill(pBitmap, Start, End1, End2, Colour1, Colour2)) return FALSE; return TRUE; }

BOOL CDRFilter::SetFillAttrTexture (  cdrfFillHeader *  Fill, INT32  Size )  [private]

sets texture fill attributes Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 20/04/95 Parameters: pointer  to fill header [INPUTS] Returns: error flag See also: Filter Definition at line 1319 of file cdrfill.cpp. { cdrfFillTexture *TFill = (cdrfFillTexture *)Fill; // check the size and set an unknown fill if it's too small if(Size < sizeof(cdrfFillTexture)) return SetUKFill(); // OK, let's try and find the vector thing it represents DocRect fBBox; Node *FillNodes; FillNodes = Vectors.Find(CDRDATA_WORD(TFill->VectorReference), &fBBox); // did we get any? if(FillNodes == 0) return SetUKFill(); // find the associated bitmap KernelBitmap *pBitmap; pBitmap = BitmapFromNodeList(FillNodes); // got one? if(pBitmap == 0) return SetUKFill(); // right then, set the fill to cover the object // what's it's bounding box? DocRect BBox; if(!GetObjCorelBBox((NodeRenderableBounded *)pMadeNode, &BBox)) return FALSE; // set the bitmap fill DocCoord Start = DocCoord(BBox.lo.x, BBox.lo.y); DocCoord End1 = DocCoord(BBox.hi.x, BBox.lo.y); DocCoord End2 = DocCoord(BBox.lo.x, BBox.hi.y); if(!SetBitmapFill(pBitmap, Start, End1, End2)) return FALSE; return TRUE; }

BOOL CDRFilter::SetFillAttrVector (  CDRTiledFillInfo *  Info  )  [private]

set vector fill attributes Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 20/04/95 Parameters: pointer  to fill header [INPUTS] Returns: error flag See also: Filter Definition at line 1261 of file cdrfill.cpp. { // find the bitmap we're going to use - at the moment, we can't only do a vector fill // if it actually referes to a bitmap // first things first - find the entry in the vectors list CDRVectorStoredItem *Item = Vectors.Find(Info->Reference); if(Item->Objects == 0) return SetUKFill(); // now, does this just refer to a bitmap? KernelBitmap *pBitmap = BitmapFromNodeList(Item->Objects); if(pBitmap == 0) return SetUKFill(); // no bitmap generation possible // work out where it's going to go. // find the size of the tile INT32 SizeX = Info->SizeX * CDRCOORDS_TO_MILLIPOINTS; INT32 SizeY = Info->SizeY * CDRCOORDS_TO_MILLIPOINTS; // find the bounding box of this lovely node DocRect BBox; if(!GetObjCorelBBox((NodeRenderableBounded *)pMadeNode, &BBox)) return FALSE; // set to the top left + the first tile offset INT32 XPos = BBox.lo.x + ((SizeX * Info->OffsetX) / 100); INT32 YPos = BBox.hi.y - SizeY - ((SizeY * Info->OffsetY) / 100); // can't do anything with the row/column staggering thingy // set the bitmap fill DocCoord Start = DocCoord(XPos, YPos); DocCoord End1 = DocCoord(XPos + SizeX, YPos); DocCoord End2 = DocCoord(XPos, YPos + SizeY); if(!SetBitmapFill(pBitmap, Start, End1, End2)) return FALSE; return TRUE; }

BOOL CDRFilter::SetLinearGrad (  CDRFillInfo *  GFill, DocRect &  BBox, DocColour *  StartColour, DocColour *  EndColour )  [private]

sets a linear graduated fill from fill definition in the file Copied from coreleps.cpp and modified Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 28 03 95 Parameters: grad  fill defn and converted colours for the fill [INPUTS] Returns: error flag See also: Filter Definition at line 726 of file cdrfill.cpp. { // NB. this function is (hopefully!) over-complex and will be simplified. // However, it's like this atm so I can get my head around the weird maths Corel // forces us to use. // The desired start and end points of the grad fill 'arrow'. DocCoord Start, End; // Calculate width and height MILLIPOINT Width = BBox.Width(); MILLIPOINT Height = BBox.Height(); // bodge just in case of zero height or widths if(Width < 16) Width = 16; if(Height < 16) Height = 16; // Find centre of box DocCoord Centre; Centre.x = BBox.lo.x + (Width / 2); Centre.y = BBox.lo.y + (Height / 2); // Find total area of BBox double TotalArea = (double) Width * (double) Height; // Cope with angles > 180 BOOL Mirror = FALSE; INT32 Angle = GFill->Angle; // note angle is * 10 if (Angle >= 1800) { Angle -= 1800; Mirror = TRUE; } else if (Angle < 00) { Angle += 1800; Mirror = TRUE; } Angle += 900; if (Angle >= 1800) { Angle -= 1800; } // get edge pad value INT32 EdgePad = GFill->Pad; // Calculate tan of the angle - convert angle to radians first. double Radians = (((double) Angle) / 1800.0) * PI; double TanTheta; if (Angle == 900) { // Special case for horizontal grad fill arrow. // Make 0% padding first Start.x = BBox.lo.x; Start.y = Centre.y; End.x = BBox.hi.x; End.y = Centre.y; // Find out width of padding INT32 Padding = (Width * EdgePad) / 100; Start.x += Padding; End.x -= Padding; } else if (Angle == 0) { // Special case for vertical grad fill arrow. // Make 0% padding first Start.x = Centre.x; Start.y = BBox.lo.y; End.x = Centre.x; End.y = BBox.hi.y; // Find out width of padding INT32 Padding = (Height * EdgePad) / 100; Start.y += Padding; End.y -= Padding; } else { TanTheta = tan(Radians); // Find out what the maximum padding is that we can achieve using just triangles: // Find the maximum triangle width MILLIPOINT TriWidth = (MILLIPOINT) ((double) Height / TanTheta); // Limit it to sensible value if (TriWidth < 0) TriWidth = -TriWidth; if (TriWidth > Width) TriWidth = Width; // Find the maximum triangle width MILLIPOINT TriHeight = (MILLIPOINT) ((double) Width * TanTheta); // Limit it to sensible value if (TriHeight < 0) TriHeight = -TriHeight; if (TriHeight > Height) TriHeight = Height; // The 'c' values of the y = mx+c equation. MILLIPOINT StartC, EndC; // Work out the maximum percentage/edge padding this gives us // (50 because it's 100 / 2 because we want area of triangle, not rectangle). double Percentage = (50.0 * (double) TriWidth * (double) TriHeight) / TotalArea; INT32 Diff = 0; // Is this enough? if (((INT32) Percentage) >= EdgePad) { // Yes - calculate exactly how big the triangle needs to be. TriHeight = (MILLIPOINT) sqrt(ABS(((double) EdgePad * TotalArea * TanTheta) / 100.0)); TriWidth = (MILLIPOINT) ((double) TriHeight / TanTheta); if (TriWidth < 0) TriWidth = -TriWidth; ENSURE(TriWidth < Width, "Error in Corel Grad fill decoding logic"); } else { // How much percentage do we need to add with each rectangle? Percentage = (EdgePad - Percentage) / 2; // Handle the rectangle stuff. if (TriWidth == Width) { // Need to add rectangles to the top and bottom. Diff = (MILLIPOINT) ((Percentage * Height) / 100.0); } else { // Need to add rectangles to left and right Diff = (MILLIPOINT) ((Percentage * Width) / 100.0); Diff = (MILLIPOINT) (Diff / tan(PI - Radians)); Diff = ABS(Diff); } } // Work out the C value for the start line (c = y - mx) // (m = tan(angle) ) if (Angle == 900) { //ENSURE(FALSE, "90 degree angle found!"); } else if (Angle < 900) { StartC = (MILLIPOINT) (BBox.lo.y - ((BBox.hi.x - TriWidth) * TanTheta)); EndC = (MILLIPOINT) (BBox.hi.y - ((BBox.lo.x + TriWidth) * TanTheta)); } else { StartC = (MILLIPOINT) (BBox.lo.y - ((BBox.lo.x + TriWidth) * TanTheta)); EndC = (MILLIPOINT) (BBox.hi.y - ((BBox.hi.x - TriWidth) * TanTheta)); } // Add on difference for rectangles, if any. StartC += Diff; EndC -= Diff; // Work out m and c for the grad fill line. // We know m is -1/m of the triangle's hypotenuse. // c = roy - (rox/m) double FillM = -1.00 / TanTheta; MILLIPOINT FillC = (MILLIPOINT) (Centre.y - (Centre.x * FillM)); // Work out intersections: x = (c2 - c1) / (2m) Start.x = (MILLIPOINT) ( (FillC - StartC) / (TanTheta + (1.00 / TanTheta)) ); Start.y = (MILLIPOINT) ((FillM * Start.x) + FillC); End.x = (MILLIPOINT) ( (FillC - EndC) / (TanTheta + (1.00 / TanTheta)) ); End.y = (MILLIPOINT) ((FillM * End.x) + FillC); } if (Mirror) { // Swap the grid fill end-points over. DocCoord Tmp = Start; Start = End; End = Tmp; } // Set the fill type according to these calculations. return SetLinearFill(*StartColour, *EndColour, Start, End); }

BOOL CDRFilter::SetLineAttr (  cdrfOffsetHeader *  Object  )  [private]

Definition at line 129 of file cdroutl.cpp. { if(Version == CDRVERSION_3) { return SetLineAttr3(Object); } // find the reference... DWORD *pReference = (DWORD *)FindDataInObject(Object, cdrfOBJOFFSETTYPE_LINE); // if the pointer to the reference is zero, then the reference is probably // within some random style definition if(pReference == 0) { // OK, try and find a style number within the style reference WORD *pStyleReference = (WORD *)FindDataInObject(Object, cdrfOBJOFFSETTYPE_STYLE); if(pStyleReference != 0) { // OK, see if we can find a the style... cdrfStyle *pStyle; INT32 StyleSize; if((pStyle = (cdrfStyle *)Styles.Find(*pStyleReference, &StyleSize)) != 0) { // OK, got a style... now find a fill reference within it pReference = (DWORD *)FindDataInObject(&pStyle->Header, cdrfSTYLEOFFSETTYPE_OUTLINE); } } } cdrfOutline *Out; INT32 OutSize; if(pReference == 0 || (Out = (cdrfOutline *)Outlines.Find(*pReference, &OutSize)) == 0 || OutSize < sizeof(cdrfOutline)) { // if no outline data, or outline definitions couldn't be found, or outline // definition is too small, set up the default line attributes if(!SetLineWidth(cdrfOUTLINE_DEFAULT_WIDTH)) return FALSE; PColourCMYK cmyk; cmyk.Cyan = cmyk.Magenta = cmyk.Yellow = 0; cmyk.Key = 255; DocColour Col; Col.SetCMYKValue(&cmyk); if(!SetLineColour(Col)) return FALSE; return TRUE; } // check that this thingy should have an outline if((CDRDATA_WORD(Out->Flags) & cdrfOUTLINEFLAGS_NOOUTLINE) != 0) { if (!SetLineColour(DocColour(COLOUR_TRANS))) return FALSE; return TRUE; } // convert the line colour DocColour Col; ConvertColour(&Out->Colour, &Col); // find the line width INT32 LineWidth = CDRDATA_WORD(Out->LineThickness) * CDRCOORDS_TO_MILLIPOINTS; if(LineWidth > MAX_LINE_WIDTH) LineWidth = MAX_LINE_WIDTH; // find the join type JointType JType; switch(CDRDATA_WORD(Out->JoinStyle)) { case cdrfJOINSTYLE_SQUARE: JType = MitreJoin; break; case cdrfJOINSTYLE_ROUNDED: JType = RoundJoin; break; default: case cdrfJOINSTYLE_BEVEL: JType = BevelledJoin; break; } // set the cap style LineCapType CType; switch(CDRDATA_WORD(Out->EndStyle)) { case cdrfENDSTYLE_BUTT: CType = LineCapButt; break; case cdrfENDSTYLE_ROUNDED: CType = LineCapRound; break; default: case cdrfENDSTYLE_SQUARE: CType = LineCapSquare; break; } // set the dash pattern DashRec Dash; DashElement DashArray[cdrfMAX_DASH_ELEMENTS]; if(CDRDATA_WORD(Out->NDashSegments) > 0 && (CDRDATA_WORD(Out->Flags) & cdrfOUTLINEFLAGS_NODASH) == 0) { // set a dash pattern INT32 NSeg = CDRDATA_WORD(Out->NDashSegments); if(NSeg > cdrfMAX_DASH_ELEMENTS) NSeg = cdrfMAX_DASH_ELEMENTS; INT32 l; for(l = 0; l < NSeg; l++) { DashArray[l] = CDRDATA_WORD(Out->DashSegments[l]) * LineWidth; } Dash.Elements = NSeg; Dash.DashStart = 0; Dash.ElementData = DashArray; Dash.LineWidth = LineWidth; Dash.ScaleWithLineWidth = TRUE; Dash.DashID = -1; } else { // no dash pattern Dash = SD_SOLID; } // set the attributes if(!SetLineWidth(LineWidth) || !SetLineColour(Col) || !SetJoinType(JType) || !SetLineCap(CType) || !SetDashPattern(Dash)) return FALSE; // check for arrowheads if(CDRDATA_DWORD(Out->StartArrowReference) != 0 || CDRDATA_DWORD(Out->EndArrowReference) != 0) { // apply the attributes to the object // If not filled, then set the ignore bit on the fill attribute. if (ObjFilled == FALSE) CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = TRUE; // Add attributes to the path, if they are different from the default... AttributeManager::ApplyBasedOnDefaults(pMadeNode, CurrentAttrs); // DeleteCurrentAttrs(); // SetUpCurrentAttrs(); // Enable the fill attribute again CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = FALSE; // ensure that the attributes won't be applied again AttrsAlreadyApplied = TRUE; // apply arrow heads to the path AddArrowheadsToPath(CDRDATA_DWORD(Out->StartArrowReference), CDRDATA_DWORD(Out->EndArrowReference), &Col, LineWidth, CType, JType); } return TRUE; }

BOOL CDRFilter::SetLineAttr3 (  cdrfOffsetHeader *  Object  )  [private]

Definition at line 303 of file cdroutl.cpp. { cdrfOutlineV3 *Out = (cdrfOutlineV3 *)FindDataInObject(Object, cdrfOBJOFFSETTYPE_LINE); if(Out == 0) { // if no outline data, or outline definitions couldn't be found, or outline // definition is too small, set up the default line attributes if(!SetLineWidth(cdrfOUTLINE_DEFAULT_WIDTH)) return FALSE; PColourCMYK cmyk; cmyk.Cyan = cmyk.Magenta = cmyk.Yellow = 0; cmyk.Key = 255; DocColour Col; Col.SetCMYKValue(&cmyk); if(!SetLineColour(Col)) return FALSE; return TRUE; } // check that this thingy should have an outline if((Out->Flags & cdrfOUTLINEFLAGSV3_STROKED) == 0) { if (!SetLineColour(DocColour(COLOUR_TRANS))) return FALSE; return TRUE; } // convert the line colour DocColour Col; ConvertColour((cdrfColour *)&Out->Colour, &Col); // find the line width INT32 LineWidth = CDRDATA_WORD(Out->LineThickness) * CDRCOORDS_TO_MILLIPOINTS; if(LineWidth > MAX_LINE_WIDTH) LineWidth = MAX_LINE_WIDTH; // find the join type JointType JType; switch(CDRDATA_WORD(Out->JoinStyle)) { case cdrfJOINSTYLE_SQUARE: JType = MitreJoin; break; case cdrfJOINSTYLE_ROUNDED: JType = RoundJoin; break; default: case cdrfJOINSTYLE_BEVEL: JType = BevelledJoin; break; } // set the cap style LineCapType CType; switch(Out->EndStyle) // byte { case cdrfENDSTYLE_BUTT: CType = LineCapButt; break; case cdrfENDSTYLE_ROUNDED: CType = LineCapRound; break; default: case cdrfENDSTYLE_SQUARE: CType = LineCapSquare; break; } // set the dash pattern /* DashRec Dash; DashElement DashArray[cdrfMAX_DASH_ELEMENTS]; if((ObjectFlagsV3 & cdrfOBJFLAGSV3_NODASH) == 0 && Out->NDashSegments > 0) // byte { // set a dash pattern INT32 NSeg = CDRDATA_WORD(Out->NDashSegments); if(NSeg > cdrfMAX_DASH_ELEMENTS) NSeg = cdrfMAX_DASH_ELEMENTS; INT32 l; for(l = 0; l < NSeg; l++) { DashArray[l] = Out->DashSegments[l] * LineWidth; // byte } Dash.Elements = NSeg; Dash.DashStart = 0; Dash.ElementData = DashArray; Dash.LineWidth = LineWidth; Dash.ScaleWithLineWidth = TRUE; Dash.DashID = -1; } else { // no dash pattern Dash = SD_SOLID; } */ // set the attributes if(!SetLineWidth(LineWidth) || !SetLineColour(Col) || !SetJoinType(JType) || !SetLineCap(CType)/* || !SetDashPattern(Dash)*/) return FALSE; // check for arrowheads if(CDRDATA_DWORD(Out->StartArrowReference) != 0 || CDRDATA_DWORD(Out->EndArrowReference) != 0) { // apply the attributes to the object // If not filled, then set the ignore bit on the fill attribute. if (ObjFilled == FALSE) CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = TRUE; // Add attributes to the path, if they are different from the default... AttributeManager::ApplyBasedOnDefaults(pMadeNode, CurrentAttrs); // Enable the fill attribute again CurrentAttrs[ATTR_FILLGEOMETRY].Ignore = FALSE; // ensure that the attributes won't be applied again AttrsAlreadyApplied = TRUE; // apply arrow heads to the path AddArrowheadsToPath(CDRDATA_DWORD(Out->StartArrowReference), CDRDATA_DWORD(Out->EndArrowReference), &Col, LineWidth, CType, JType); } return TRUE; }

BOOL CDRFilter::SetRadialGrad (  CDRFillInfo *  GFill, DocRect &  BBox, DocColour *  StartColour, DocColour *  EndColour )  [private]

sets a radial graduated fill from fill definition in the file Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 21/04/95 Parameters: grad  fill defn and converted colours for the fill [INPUTS] Returns: error flag See also: Filter Definition at line 1002 of file cdrfill.cpp. { // The desired start and end points of the grad fill 'arrow'. DocCoord Start, End; // Calculate width and height MILLIPOINT Width = BBox.Width(); MILLIPOINT Height = BBox.Height(); // caluculate the source area // first, what's the diagonal length double dWidth = Width; double dHeight = Height; INT32 Diagonal = (INT32)sqrt(dWidth*dWidth + dHeight*dHeight); // and from that calculate area of the box containing the bit of the // bit of the circle in the bbox INT32 Edge = (Diagonal * (100 - (GFill->Pad * 2))) / 100; // Start point is the centre given by Corel. // This centre is percentage offsets from the centre of the object, i.e. (0,0) is // the centre of the bounding box. DocCoord Centre = DocCoord(BBox.lo.x + (Width / 2), BBox.lo.y + (Height / 2)); INT32 OffX = (GFill->HorizontalCentreOffset * Width) / 100; INT32 OffY = (GFill->VerticalCentreOffset * Height) / 100; Start.x = Centre.x + OffX; Start.y = Centre.y + OffY; // Find required radius of circle. double Radius = Edge / 2; // how far away is the centre of the fill from the centre of the bbox? double dOffX = OffX; double dOffY = OffY; double Dist = (INT32)sqrt(dOffX*dOffX + dOffY*dOffY); // and increase the radius by a bodge factor double BodgeFactor = 1 + (Dist / (double)(Diagonal / 2)); Radius *= BodgeFactor; // End point is start point + radius End.x = Start.x + ((MILLIPOINT) Radius); End.y = Start.y; // Seems that we need to swap start and end colours... // Set the fill type according to these calculations. return SetRadialFill(*EndColour, *StartColour, Start, End); }

BOOL CDRFilter::SetUKFill (  void   )  [private]

sets a fill attribute for unknown fills Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 28 03 95 Parameters: pointer  to fill header [INPUTS] Returns: error flag See also: Filter Definition at line 617 of file cdrfill.cpp. { PColourCMYK cmyk; cmyk.Cyan = cmyk.Magenta = cmyk.Yellow = 0; cmyk.Key = 255; DocColour Col; Col.SetCMYKValue(&cmyk); return SetFillColour(Col); }

BOOL CDRFilter::TransformArrowhead (  NodeRenderableBounded *  N, DocCoord *  Point, DocCoord *  Other, BOOL  Start, INT32  LineWidth, INT32  Distance )  [private]

transform an arrowhead path to be the correct size and orientation Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 29 03 95 Parameters: The  path to transform, the This coordsinate (the coordinate to apply it to) and the [INPUTS] previous coordinate (the one before or after it), whether it's a start one or not and the line width and the distance to shift it from the arrow definition. Returns: error flag See also: Filter Definition at line 559 of file cdroutl.cpp. { // first of all, work out how much we need to scale this thingy by double Scale = (double)LineWidth / (double)cdrfARROWHEAD_LINEWIDTH; // work out the adj and opp side of the triangle we're going to rotate around double Adj = (double)Point->x - (double)Other->x; double Opp = (double)Point->y - (double)Other->y; // work out the hyp of the triangle double Hyp = sqrt((Adj * Adj) + (Opp * Opp)); // how far we need to move the arrowhead by double Move = Scale * (double)Distance; // calculate a matrix double a, b, c, d, e, f; if(Hyp == 0) { // default thing which shouldn't do too much hard - avoid div by zero a = Scale; b = 0; c = 0; d = Scale; e = Point->x + Move; f = Point->y; } else { double cosTheta = (Adj / Hyp); double sinTheta = (Opp / Hyp); a = Scale * cosTheta; b = Scale * sinTheta; c = 0 - (Scale * sinTheta); d = Scale * cosTheta; e = Point->x + (Move * cosTheta); f = Point->y + (Move * sinTheta); } // knock up a matrix Matrix M = Matrix(a, b, c, d, (INT32)e, (INT32)f); // need to flip it over? if(Start) { Matrix F = Matrix(1, 0, 0, -1, 0, 0); M = F * M; } // transform the node Trans2DMatrix Trans(M); N->Transform(Trans); return TRUE; }

BOOL CDRFilter::TransformConvertedObject (  NodeRenderable **  N, ADDR  Trans, INT32  Size, BOOL  TranslateForPage = TRUE, BOOL  IsAGroupTransform = FALSE, BOOL  WorkAtOrigin = FALSE )  [private]

transforms an object we converted, given a trfd chunk. If TranslateForPage is true (defaults to TRUE) then the object will also be translated to get the origin in the right place. The pointer may be modified to be a pointer to a different object. WorkAtOrigin causes the object to be translated back to the origin before being hacked apon, except if it's in a CDR3 file when it's ignored as the file is mass-translated at the end of the conversion.. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 25 03 95 Parameters: the  node to transform, and the trfd chunk to transform it by [INPUTS] Returns: error flag See also: Filter Definition at line 3130 of file cdrfiltr.cpp. { if(IsText) { (*N)->OptimiseAttributes(); } // make sure the WorkAtOrigin flag is set correctly - we mustn't use it if we're fiddling with a v3 file if(Version == CDRVERSION_3) WorkAtOrigin = FALSE; // transform it back to the origin if necessary if(WorkAtOrigin) { Trans2DMatrix Trans(-TranslateByX, -TranslateByY); (*N)->Transform(Trans); } // set up a transform conversion object CDRTransformConvertor *Conv; // putting the convertors here is probably more efficicent than allocating // a new one in the heap as they're not very big at all CDRTransformConvertor5 Conv5; CDRTransformConvertor4 Conv4; CDRTransformConvertor3 Conv3; switch(Version) { case CDRVERSION_5: Conv = &Conv5; break; case CDRVERSION_4: Conv = &Conv4; break; case CDRVERSION_3: Conv = &Conv3; break; default: return FALSE; break; } // initialise the convertor object Conv->Init(Trans, Size); // note that these elements are in Corel order cdrMatrix Ma, Mb, Mt; BOOL HaveMatrix = FALSE; BOOL ApplyMatrices = IsAGroupTransform?FALSE:TRUE; #ifdef CDR_DOEXTRUDE for(UINT32 g = 0; g < Conv->GetNTransforms(); g++) { CDRTransformType Type = Conv->GetTransformType(t); if(Type == CDRTRANSFORMTYPE_EXTRUDE) ApplyMatrices = FALSE; } #endif // apply all the transformations in the chunk for(UINT32 t = 0; t < Conv->GetNTransforms(); t++) { CDRTransformType Type = Conv->GetTransformType(t); // check that the transform is something we know about if(Type == CDRTRANSFORMTYPE_UNKNOWN) continue; // if it's a matrix, then append it to the previous one, if any if(Type == CDRTRANSFORMTYPE_MATRIX) { if(ApplyMatrices) { if(HaveMatrix) { // done the first matrix, so we need get the matrix into another one and then combine. // get the matrix if(!Conv->GetMatrix(&Mb, t)) return FALSE; // and combine it with the matrix we've already got Mt.a = (Ma.a * Mb.a) + (Ma.d * Mb.b); Mt.b = (Ma.b * Mb.a) + (Ma.e * Mb.b); Mt.c = (Ma.c * Mb.a) + (Ma.f * Mb.b) + Mb.c; Mt.d = (Ma.a * Mb.d) + (Ma.d * Mb.e); Mt.e = (Ma.b * Mb.d) + (Ma.e * Mb.e); Mt.f = (Ma.c * Mb.d) + (Ma.f * Mb.e) + Mb.f; Ma = Mt; } else { // just get the matrix if(!Conv->GetMatrix(&Ma, t)) return FALSE; HaveMatrix = TRUE; } } } else { // wasn't a matrix - apply a matrix if we've got one if(HaveMatrix) { // apply it if(!ApplyMatrices) { if(!TransformConvertedObjectDoMatrix(N, &Ma, FALSE)) return FALSE; } } // unset the flag HaveMatrix = FALSE; // deal with the transformation ERROR3IF(Type == CDRTRANSFORMTYPE_MATRIX, "Matrix got through in TransformConvertedObject") switch(Type) { case CDRTRANSFORMTYPE_PERSPECTIVE: { // convert the perpective cdrPerspective P; if(!Conv->GetPerspective(&P, t)) return FALSE; // apply it to the object if(!TransformConvertedObjectDoPerspective(N, &P, IsAGroupTransform)) return FALSE; } break; case CDRTRANSFORMTYPE_ENVELOPE: if(!(Version != CDRVERSION_3 && IsTextStory)) // text stories don't get enveloped - this is used as the frame shape { // convert the envelope into a path DocRect OBBox; Path *Shape = 0; INT32 Corners[4]; if(Conv->GetEnvelope(&Shape, &OBBox, (INT32 *)&Corners, t)) { // apply to object if(!TransformConvertedObjectDoEnvelope(N, Shape, &OBBox, (INT32 *)&Corners, IsAGroupTransform)) return FALSE; // delete the shape delete Shape; } } break; case CDRTRANSFORMTYPE_EXTRUDE: { cdrExtrudeInfo Info; if(Conv->GetExtrude(&Info, t)) { // apply to object if(!TransformConvertedObjectDoExtrude(N, &Info, IsAGroupTransform)) return FALSE; } ApplyMatrices = TRUE; // start applying the matrices... } break; default: break; } if(Version == CDRVERSION_5) { // we want to apply matrices from now on ApplyMatrices = TRUE; } } } // if we've got a matrix still to do... if(HaveMatrix) { // apply it if(ApplyMatrices) { if(!TransformConvertedObjectDoMatrix(N, &Ma, TranslateForPage)) return FALSE; } } else if(!HaveMatrix && TranslateForPage) { // we need to apply an identity matrix which then gets translated, but only if we need to cdrMatrix Mi = {1, 0, 0, 0, 1, 0}; // apply it if(!TransformConvertedObjectDoMatrix(N, &Mi, TranslateForPage)) return FALSE; } // reverse the effect of the previous translation if(WorkAtOrigin) { Trans2DMatrix Trans(TranslateByX, TranslateByY); (*N)->Transform(Trans); } return TRUE; }

BOOL CDRFilter::TransformConvertedObjectDoEnvelope (  NodeRenderable **  N, Path *  P, DocRect *  pOriginalBBox, INT32 *  Corners, BOOL  TranslateShapeForPage = FALSE )  [private]

transforms an object given a path to envelope into Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 23/05/95 Parameters: the  node to transform, and the trfd chunk to transform it by [INPUTS] Returns: error flag See also: Filter Definition at line 3499 of file cdrfiltr.cpp. { TRACEUSER( "Ben", _T("applying envelope\n")); // create a mould parent and insert it in the tree NodeMould* pMouldParent = new NodeMould; if (pMouldParent == 0) return FALSE; // give the parent mould object a shape and mould space to work with and stick it // in the tree if(!pMouldParent->CreateGeometry(MOULDSPACE_ENVELOPE)) { delete pMouldParent; return FALSE; } // validate the path a bit, and get a good one if this is duff Path *Shape = P; UINT32 errID; if(pMouldParent->GetGeometry()->Validate(Shape,errID) == FALSE) { // OK, it's not suitiable so try to create an approximation which is Path *NewShape; if(!pMouldParent->GetGeometry()->MakeValidFrom(&NewShape, Shape, Corners)) { // couldn't make a proper one, so return TRUE to ignore the moulding return TRUE; } Shape = NewShape; // inc count of approximated envelopes so the user can be warned later EnvelopesApproximated++; } // maybe translate it a bit DocRect OriginalBBox = *pOriginalBBox; if(TranslateShapeForPage) { Shape->Translate(TranslateByX, TranslateByY); OriginalBBox.Translate(TranslateByX, TranslateByY); } // Create and add a mould shape object NodeMouldPath* pNodeMPath = pMouldParent->AddNewMouldShape(Shape, 0, NULL); if (!pNodeMPath) return FALSE; // set the geometry using this new mould shape if(!pMouldParent->GetGeometry()->Define(&(pNodeMPath->InkPath), &OriginalBBox)) return FALSE; // now create the mould group object NodeMouldGroup* pMouldGroup = pMouldParent->AddNewMouldGroup(NULL); if (!pMouldGroup) return FALSE; // and attach the node to the molder group (*N)->AttachNode((Node *) pMouldGroup, FIRSTCHILD, FALSE); // set the node to the converted one *N = pMouldParent; // delete any created paths if(Shape != P) delete Shape; return TRUE; }

BOOL CDRFilter::TransformConvertedObjectDoExtrude (  NodeRenderable **  N, cdrExtrudeInfo *  Info, BOOL  TranslateShapeForPage = FALSE )  [private]

performs a extrude transform Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 08/01/96 Parameters: node  to transform, extrude info [INPUTS] Returns: error flag See also: CDRFilter Definition at line 3586 of file cdrfiltr.cpp. { // the plan here is to create a new group, and slap the node onto it (it could possibly be // a group with lots of other stuff under it, but we won't worry about that for the moment) // Then, wander down the sub-tree attempting to convert all NodeRenderableInk object into // NodePaths. This will hopefully result in a load of object which can then be transformed // first, get one of them there group thingynesseses. NodeGroup *pTempGroup = new NodeGroup; if(pTempGroup == 0) return FALSE; // no room, oh dear. // now attach the thing to it. It isn't attached to anything, so it's easy. (*N)->AttachNode(pTempGroup, FIRSTCHILD); // scan the tree converting non-NodePaths to NodePaths where possible BecomeA ParamBecomeA(BECOMEA_REPLACE, CC_RUNTIME_CLASS(NodePath), NULL); // find the first node to think about Node* Current = (*N); while (Current->FindFirstChild() != NULL && !(Current->FindFirstChild())->IsKindOf(CC_RUNTIME_CLASS(TextStory))) { Current = Current->FindFirstChild(); } // check each renderable node for not being a path while(Current != 0) { if(Current->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)) && !Current->IsKindOf(CC_RUNTIME_CLASS(NodePath))) { if (Current->CanBecomeA(&ParamBecomeA)) { // is it a text story? if (Current->IsKindOf(CC_RUNTIME_CLASS(TextStory))) { // give formatting it a go ((TextStory *)Current)->FormatAndChildren(); } if (!(Current)->DoBecomeA(&ParamBecomeA)) { return FALSE; } } } // get the next one Current = Current->FindNextDepthFirst(*N); } // now wander through the tree doing the funky transform - find the first one again Current = pTempGroup; while (Current->FindFirstChild() != NULL) { Current = Current->FindFirstChild(); } // transform each NodePath while(Current != 0) { if(IS_A(Current, NodePath)) { if(!TransformConvertedObjectDoExtrudeTransPath((NodePath *)Current, Info)) return FALSE; // something very wrong happened } // get the next one Current = Current->FindNextDepthFirst(pTempGroup); } // update the *N pointer to the node (*N) = (NodeRenderable *)pTempGroup->FindFirstChild(); ERROR2IF((*N) == 0, FALSE, "Oi! there that node just vanished"); ERROR2IF(!(*N)->IsKindOf(CC_RUNTIME_CLASS(NodeRenderable)), FALSE, "Oh! Mr. Node changing into something non-renderable"); // remove it from the group (*N)->UnlinkNodeFromTree(); // finally, vape that temperary group delete pTempGroup; return TRUE; }

BOOL CDRFilter::TransformConvertedObjectDoExtrudeTransPath (  NodePath *  pPath, cdrExtrudeInfo *  Info )  [private]

does the extrude transform on a path Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 09/01/96 Parameters: path  to transform, info about the transform [INPUTS] Returns: error flag See also: CDRFilter Definition at line 3685 of file cdrfiltr.cpp. { // check the inputs ERROR2IF(pPath == 0 || Info == 0, FALSE, "Null something supplied where a raspberry is required"); ERROR2IF(!IS_A(pPath, NodePath), FALSE, "Oi! I asked for a NodePath you silly person"); // get some useful info about that there path DocCoord *Coords = pPath->InkPath.GetCoordArray(); ERROR2IF(Coords == 0, FALSE, "Hmmm. I think that path is a bit of a dodgy one really"); INT32 NCoords = pPath->InkPath.GetNumCoords(); // mild sanity check... if(Info->Camera.z == 0) return TRUE; // don't try this one at home, kiddies // prepare a few handy values FLOAT8 projA = - Info->Camera.x / Info->Camera.z; FLOAT8 projB = - Info->Camera.y / Info->Camera.z; FLOAT8 projC = - 1 / Info->Camera.z; // run through that path transforming all those lovely cheeky little coordinates for(INT32 c = 0; c < NCoords; c++) { FLOAT8 x = (FLOAT8)Coords[c].x, y = (FLOAT8)Coords[c].y; FLOAT8 alpha = x * Info->Trans.cf11 + y * Info->Trans.cf21 + Info->Trans.cf41; FLOAT8 beta = x * Info->Trans.cf12 + y * Info->Trans.cf22 + Info->Trans.cf42; FLOAT8 gamma = x * Info->Trans.cf13 + y * Info->Trans.cf23 + Info->Trans.cf43; FLOAT8 norm = gamma * projC + 1; Coords[c].x = (INT32)((alpha + gamma * projA) / norm); Coords[c].y = (INT32)((beta + gamma * projB) / norm); } // well, wasn't that squishy? return TRUE; }

BOOL CDRFilter::TransformConvertedObjectDoMatrix (  NodeRenderable **  N, cdrMatrix *  Ma, BOOL  TranslateForPage )  [private]

transforms an object given a CDR matrix Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 18/05/95 Parameters: the  node to transform, and the trfd chunk to transform it by [INPUTS] Returns: error flag See also: Filter Definition at line 3350 of file cdrfiltr.cpp. { // make a camelot matrix Matrix M(Ma->a, Ma->d, Ma->b, Ma->e, (INT32)Ma->c + (TranslateForPage?TranslateByX:0), (INT32)Ma->f + (TranslateForPage?TranslateByY:0)); // if it's a text story node, then it needs to be dealt with differently, and it's got // an associated bounding box which need transforming if(IS_A(*N, TextStory)) { // find it's bounding box DocRect *BBox = TextBBoxes.Find(*N); // transform it with the unmodifed matrix Trans2DMatrix TTransform(M); if(BBox != 0) TTransform.GetMatrix().TransformBounds(BBox); // if it's a text story, not just an artisitic text then don't scale it, but scale the import width if(IsTextStory) { // work out the scale factors along the axes double ScaleX = sqrt((Ma->a * Ma->a) + (Ma->b * Ma->b)); double ScaleY = sqrt((Ma->d * Ma->d) + (Ma->e * Ma->e)); // knock up a new matrix which isn't scaled along these axes M = Matrix(Ma->a / ScaleX, Ma->d / ScaleY, Ma->b / ScaleX, Ma->e / ScaleY, (INT32)Ma->c + (TranslateForPage?TranslateByX:0), (INT32)Ma->f + (TranslateForPage?TranslateByY:0)); // get the import format width scaled nicely TextStory *TSNode = (TextStory *)(*N); double Width = ((double)TSNode->GetImportFormatWidth()) * ScaleX; TSNode->SetImportFormatWidth((INT32)Width); } } // transform the node Trans2DMatrix Transform(M); (*N)->Transform(Transform); return TRUE; }

BOOL CDRFilter::TransformConvertedObjectDoPerspective (  NodeRenderable **  N, cdrPerspective *  P, BOOL  TranslateShapeForPage = FALSE )  [private]

Definition at line 3412 of file cdrfiltr.cpp. { TRACEUSER( "Ben", _T("applying perspective\n")); // create a mould parent and insert it in the tree NodeMould* pMouldParent = new NodeMould; if (pMouldParent == 0) return FALSE; // give the parent mould object a shape and mould space to work with and stick it // in the tree if(!pMouldParent->CreateGeometry(MOULDSPACE_PERSPECTIVE)) { delete pMouldParent; return FALSE; } // create a nice shape to mould into NodePath *pShape = new NodePath; if(pShape == 0 || (!pShape->SetUpPath())) { delete pMouldParent; return FALSE; } // position the new elements at the beginning of the path pShape->InkPath.FindStartOfPath(); // make a nice shape out of the corners DocCoord co; PERS_MOVE(P->NewCorners[0]) PERS_LINE(P->NewCorners[1]) PERS_LINE(P->NewCorners[2]) PERS_LINE(P->NewCorners[3]) PERS_LINE(P->NewCorners[0]) PERS_CLOSE // maybe translate it a bit DocRect OriginalBBox = P->OriginalBBox; if(TranslateShapeForPage) { Trans2DMatrix Transform(Matrix(TranslateByX, TranslateByY)); pShape->Transform(Transform); OriginalBBox.Translate(TranslateByX, TranslateByY); } // Create and add a mould shape object NodeMouldPath* pNodeMPath = pMouldParent->AddNewMouldShape(&pShape->InkPath, 0, NULL); if (!pNodeMPath) return FALSE; // set the geometry using this new mould shape if(!pMouldParent->GetGeometry()->Define(&(pNodeMPath->InkPath), &OriginalBBox)) return FALSE; // now create the mould group object NodeMouldGroup* pMouldGroup = pMouldParent->AddNewMouldGroup(NULL); if (!pMouldGroup) return FALSE; // and attach the node to the molder group (*N)->AttachNode((Node *) pMouldGroup, FIRSTCHILD, FALSE); // set the node to the converted one *N = pMouldParent; // delete the shape delete pShape; return TRUE; }

BOOL CDRFilter::UpdateProgress (  BOOL  Now = FALSE  )  [private]

Updating the progress everysooften - called at every significant place to get a nice smooth update on that progress bar thingy. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 22 03 95 Parameters: None  [INPUTS] Returns: None See also: Filter Definition at line 194 of file cdrfiltr.cpp. { BOOL Result = TRUE; if(Now) { Result = ContinueSlowJob(RIFF->ProgressNow()); ProgressCount = 0; } else { if((ProgressCount & PROGRESSUPDATE_MASK) == 0) { Result = ContinueSlowJob(RIFF->ProgressNow()); } ProgressCount++; } if(!Result) { Error::ClearError(); // because this may not be handled the first time around Error::SetError(_R(IDN_USER_CANCELLED)); } return Result; }

---

Member Data Documentation

CDRActionList CDRFilter::Actions [private]

Definition at line 834 of file cdrfiltr.h.

CDRArrowheadStore CDRFilter::Arrowheads [private]

Definition at line 822 of file cdrfiltr.h.

BOOL CDRFilter::AttrsAlreadyApplied [private]

Definition at line 865 of file cdrfiltr.h.

INT32 CDRFilter::BitmapNumber = 0 [static]

Definition at line 790 of file cdrfiltr.h.

CDRBitmapStore CDRFilter::Bitmaps [private]

Definition at line 825 of file cdrfiltr.h.

friend CDRFilter::CDRActionGroupEnd [private]

Definition at line 767 of file cdrfiltr.h.

friend CDRFilter::CDRActionTransform [private]

Definition at line 766 of file cdrfiltr.h.

friend CDRFilter::CDRBitmap [private]

Definition at line 769 of file cdrfiltr.h.

friend CDRFilter::CDRBitmapStore [private]

Definition at line 768 of file cdrfiltr.h.

ColourList* CDRFilter::ColList [private]

Definition at line 870 of file cdrfiltr.h.

BOOL CDRFilter::DoneDoc [private]

Definition at line 814 of file cdrfiltr.h.

BOOL CDRFilter::DoneMasterPage [private]

Definition at line 812 of file cdrfiltr.h.

INT32 CDRFilter::EnvelopesApproximated [private]

Definition at line 850 of file cdrfiltr.h.

CDRAttributeStore CDRFilter::Fills [private]

Definition at line 818 of file cdrfiltr.h.

CDRFontnameStore CDRFilter::Fonts [private]

Definition at line 821 of file cdrfiltr.h.

ADDR CDRFilter::FontStylesV3 [private]

Definition at line 877 of file cdrfiltr.h.

INT32 CDRFilter::FontTableEntriesV3 [private]

Definition at line 876 of file cdrfiltr.h.

ADDR CDRFilter::FontTableV3 [private]

Definition at line 875 of file cdrfiltr.h.

BOOL CDRFilter::FormatError [private]

Definition at line 852 of file cdrfiltr.h.

BOOL CDRFilter::InMasterPage [private]

Definition at line 811 of file cdrfiltr.h.

BOOL CDRFilter::IsText [private]

Definition at line 862 of file cdrfiltr.h.

BOOL CDRFilter::IsTextOnAPath [private]

Definition at line 884 of file cdrfiltr.h.

BOOL CDRFilter::IsTextStory [private]

Definition at line 863 of file cdrfiltr.h.

BOOL CDRFilter::Landscape [private]

Definition at line 840 of file cdrfiltr.h.

ADDR CDRFilter::LinkTable [private]

Definition at line 879 of file cdrfiltr.h.

BOOL CDRFilter::LinkTransformsExist [private]

Definition at line 881 of file cdrfiltr.h.

ADDR CDRFilter::ObjDataBlock [private]

Definition at line 867 of file cdrfiltr.h.

INT32 CDRFilter::ObjDataBlockSize [private]

Definition at line 868 of file cdrfiltr.h.

INT32 CDRFilter::ObjectsConverted [private]

Definition at line 847 of file cdrfiltr.h.

INT32 CDRFilter::ObjectsFormatWrong [private]

Definition at line 848 of file cdrfiltr.h.

INT32 CDRFilter::ObjectsUnknown [private]

Definition at line 849 of file cdrfiltr.h.

BOOL CDRFilter::ObjFilled [private]

Definition at line 859 of file cdrfiltr.h.

BOOL CDRFilter::ObjStroked [private]

Definition at line 860 of file cdrfiltr.h.

DocCoord CDRFilter::Origin [private]

Definition at line 842 of file cdrfiltr.h.

CDRAttributeStore CDRFilter::Outlines [private]

Definition at line 819 of file cdrfiltr.h.

CDRPageList CDRFilter::Pages [private]

Definition at line 830 of file cdrfiltr.h.

INT32 CDRFilter::PageX [private]

Definition at line 838 of file cdrfiltr.h.

INT32 CDRFilter::PageY [private]

Definition at line 839 of file cdrfiltr.h.

INT32 CDRFilter::PatternNumber = 0 [static]

Definition at line 791 of file cdrfiltr.h.

CDRBitmapStore CDRFilter::Patterns [private]

Definition at line 824 of file cdrfiltr.h.

class Document* CDRFilter::pDocument [private]

Definition at line 798 of file cdrfiltr.h.

NodeRenderable* CDRFilter::pLevelNodeList [private]

Definition at line 854 of file cdrfiltr.h.

NodeRenderable* CDRFilter::pMadeNode [private]

Definition at line 855 of file cdrfiltr.h.

class Page* CDRFilter::pPage [private]

Definition at line 800 of file cdrfiltr.h.

UINT32 CDRFilter::ProgressCount [private]

Definition at line 809 of file cdrfiltr.h.

class Spread* CDRFilter::pSpread [private]

Definition at line 799 of file cdrfiltr.h.

RIFFFile* CDRFilter::RIFF [private]

Definition at line 805 of file cdrfiltr.h.

INT32 CDRFilter::SerialNumber [private]

Definition at line 857 of file cdrfiltr.h.

BOOL CDRFilter::SlowJobStarted [private]

Definition at line 808 of file cdrfiltr.h.

CDRAttributeStore CDRFilter::Styles [private]

Definition at line 820 of file cdrfiltr.h.

BOOL CDRFilter::Success [private]

Definition at line 803 of file cdrfiltr.h.

CDRBBoxList CDRFilter::TextBBoxes [private]

Definition at line 836 of file cdrfiltr.h.

List CDRFilter::TextOnPathLinks [private]

Definition at line 883 of file cdrfiltr.h.

CDRVectorStore CDRFilter::TextV4 [private]

Definition at line 828 of file cdrfiltr.h.

CDRLayerListItem* CDRFilter::ThisLayer [private]

Definition at line 832 of file cdrfiltr.h.

UndoableOperation* CDRFilter::ThisOp [private]

Definition at line 806 of file cdrfiltr.h.

CDRPageListItem* CDRFilter::ThisPage [private]

Definition at line 831 of file cdrfiltr.h.

ADDR CDRFilter::TransformChunk [private]

Definition at line 872 of file cdrfiltr.h.

INT32 CDRFilter::TransformChunkSize [private]

Definition at line 873 of file cdrfiltr.h.

INT32 CDRFilter::TranslateByX [private]

Definition at line 844 of file cdrfiltr.h.

INT32 CDRFilter::TranslateByY [private]

Definition at line 845 of file cdrfiltr.h.

BOOL CDRFilter::UseLayers [private]

Definition at line 816 of file cdrfiltr.h.

CDRVectorStore CDRFilter::Vectors [private]

Definition at line 826 of file cdrfiltr.h.

CDRVersion CDRFilter::Version [private]

Definition at line 802 of file cdrfiltr.h.

---

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

• Kernel/cdrfiltr.h (r1785/r1282)
• Kernel/cdrfill.cpp (r1785/r751)
• Kernel/cdrfiltr.cpp (r1785/r1282)
• Kernel/cdroutl.cpp (r1785/r1282)
• Kernel/cdrtext.cpp (r1785/r1282)

---