Path Class Reference

Creation, manipulation and use of Paths. A path is an arbitary collection of MoveTo, LineTo and CurveTo segments Public Member variables :- BOOL IsFilled - TRUE if this path if filled, FALSE otherwise. More...

#include <paths.h>

List of all members.

Public Member Functions
	Path ()
	constructor - just sets a few things to sensible values
	~Path ()
	Destructor - releases the memory that the path has been using to store coords in.
BOOL	CopyPathDataFrom (Path *SrcPath)
	Copy the coords, verbs and flags from the SrcPath to this path. You must already have initialised this path by calling Path::Initialise(). Pass it an Initial size big enough the hold the path you want to copy.
BOOL	CopyPathDataFrom (DocCoord *Coords, PathVerb *Verbs, INT32 NumCoords, BOOL Filled=FALSE, BOOL Stroked=TRUE)
	Copy the specified coords and verbs to this path. The path's flags will be the defaults as specified in the constructors. You must already have initialised this path by calling Path::Initialise(). Pass it an Initial size big enough to hold the path you want to copy.
BOOL	CreatePathFromDocRect (DocRect *pRect)
	Creates a filled path from a given DocRect.
BOOL	Initialise (INT32 InitialSize=24, INT32 BlockSize=12)
	Allocates memory in the path for the three arrays - The Verbs, Coordinates and the Flags.
BOOL	FindStartOfPath ()
	Sets Pos to the first element in the path.
void	FindStartOfSubPath ()
	Searches backwards from the current position until it finds the start of the sub path that the current position is in.
void	FindStartOfSubPath (INT32 *Index) const
	Searches backwards from the current position from Index until it find the start of the subpath (always a moveto).
void	FindEndOfSubPath ()
	Searches forwards until it finds the end of the current sub-path. ie pos will point at the last element in the sub path.
void	FindEndOfSubPath (INT32 *Index) const
	Searches forwards until it finds the end of the current sub-path. ie Index will point at the last element in the sub path.
void	FindEndElOfSubPath (INT32 *Index) const
	Searches forwards until it finds the last element of the current sub-path. ie 0 1 2 3 {MT,CT,CT,CT} => Index = 3. See Also: FindEndOfSubPath (Note equivelent).
void	ExpandRange (INT32 *start, INT32 *end, INT32 num)
	given the region [*start, *end] expand the region in both directions by num elements. The region will not be expanded beyond its outer limits described by the set {moveto,.....,endofsubpath}.
BOOL	FindNext ()
	Finds the next path element in this path. The position will become invalid if you try to search past the start of the path. This can be checked by using Pos->IsValid.
BOOL	FindNext (INT32 *Index) const
	Finds the next path element in this path. The position will become invalid if you try to search past the start of the path. This can be checked by using Pos->IsValid.
BOOL	FindPrev ()
	Finds the prev path element in this path starting the search from CurrentPos.
BOOL	FindPrev (INT32 *Index) const
	Finds the previous path element in this path starting from the value (index).
BOOL	FindPrevEndPoint (INT32 *index) const
	Finds the previous path endpoint in this path.
BOOL	FindNextEndPoint (INT32 *index) const
	Finds the next path endpoint in this path.
BOOL	GetSubPathEnds (DocCoord *start, DocCoord *end)
	This function returns whether the path is open or closed. This is independent of the IsFilled flag, because some programs allow open paths to be filled. Basically, if there's no gap in the subpath, it's closed, otherwise it's open. These are the same rules as ArtWorks followed. Initial implementation just scans the subpath and checks the last element in the subpath.
BOOL	FindNearestPoint (DocCoord pos, UINT32 flags, INT32 *position)
	This function searches for a point in the path which is both selected and lies inside the largest blob bounding rectangle surrounding 'pos'. Points checked for are as follows... if ENDPOINTS is set check all selected endpoints in this path. if CONTROLPOINTS is set check all control points lying directly next to selected endpoints The rules are that control points are only enabled when a single end point is selected and hence a maximum of 2 control points will be checked. If any of these points are close enough to be clicked on, the function returns TRUE, with position holding the index to the point that was clicked.
BOOL	PointCloseToLine (DocCoord pos, INT32 *position)
	This function takes the coordinate pos, and sees if it is close to a line (close enough to drag the line around). It returns TRUE if the point is close enough, and position is an index to the element that it was closest to.
BOOL	ClosestSelectedEndpoint (DocCoord pos, INT32 *position, double *distance)
	This function finds the closest selected line end to the cursor position passed in. If the path has no selected line ends, the function returns FALSE.
BOOL	FindNextSelected (INT32 *Index)
	Searches the point set {*index, usedslots-1} for a selected end point and returns its index if found.
BOOL	FindSelectionLimits (INT32 index, INT32 *p, INT32 *q)
	Finds the next connected region of selected control handles.
INT32	FindOppositeControlPoint (INT32 ThisIndex)
	Given a bezier control point, this function returns the index of the control point that is opposite this one (with an endpoint between). This routine takes closed paths into account.
INT32	FindPrevControlPoint (INT32 position)
	This routine will scan back from an endpoint to find the attached bezier control point. It takes account of closed and open paths and complex paths, and will wrap around the path if necessary.
INT32	FindNextControlPoint (INT32 position)
	This routine will scan forwards from an endpoint to find the attached bezier control point. It takes account of closed and open paths and complex paths, and will wrap around the path if necessary.
double	SqrDistanceToPoint (const DocCoord pt, INT32 *NearEl, double *mu)
	Finds the distance to the closest point on the path. For efficiency it does not evaluate the closest point. Use this routine in conjunction with ClosestPoint to find the actual closest point.
DocCoord	ClosestPointTo (const double t, const INT32 index)
	This function returns the point at which the closest distance on the path occurs.
BOOL	IsPointCloseTo (const DocCoord ICoord, INT32 range, INT32 *NearElement, double *mu)
	This routine can be used to determin whether a point is close enough to a path to allow some action to occur. The range input parameter can be used to determin the size of the sensitive area.
double	SqrLength ()
	Find the length of a path in millipoints. The length is calculated by flattening the path and finding straight line segment lengths and so is a discrete numeric approximation to a line integral.
double	GetPathLength (double dFlatness=64.0)
	Find the length of a path in millipoints.
double	DistReparameterise (const double sqrdist, INT32 *Element)
DocCoord	ConvSqrDistToCoord (const double sqrdist)
	Finds the coordinate which is dist units along 'this' path.
INT32	BreakInTwo (Path *pChildPath)
	Tests a path to see if it is valid. This is only built into DEBUG versions of Camelot so always surround calls to it with an ifdef _DEBUG block. If the path is not valid in some way, this function will dump an explanation to the debug terminal and return FALSE.This function will attempt to break the current path at its first selected point. All selected points should still be in place in both parent and child.
INT32	NumSplinters ()
	Returns the number of splinters a selected path will be broken into when calls to BreakPath is called. Splinters include opened subpaths, ie if the algorithm will open a closed subpath, this is classed as a spinter along with breaking a path in two.
BOOL	DistanceTo (INT32 index, double t, double *distance, double dFlatness=64.0)
	This function takes a description of a point lying on a path. The point is described by (i,t) where i is the index of the element t lies in, and t is a parametric variable 0<=t<=1. The function calculates the distance along this path to the point described by (i,t). This routine complements SqrDistanceToPoint() which calculates the pair (i,t) for a given coordinate close to the path.
BOOL	DistanceTo (DocCoord Coord, double *dist, double dFlatness=64.0)
	This function takes as input a coordinate (usually a mouse click point). It will calculate the closest point on the path to this coordinate and return the distance along the path from its start point to this coordinate.
BOOL	SplitAtPoint (const DocCoord &SplitPoint, INT32 *SplitAt, INT32 *NewElements)
	This function takes a coordinate (typically not on but) close to this path and splits the path at a calculated point on the path which happens to be closest to the input coord. By Split I mean a new coordinate in will appear in the path, but the path will not have changed its shape in anyway.
BOOL	GetPointAtDistance (MILLIPOINT Distance, DocCoord *pPoint, double *pTangent=NULL, UINT32 *pPressure=NULL)
	Gets the coordinate of a point a certain distance along this path.
BOOL	GetDistanceToPoint (DocCoord Point, MILLIPOINT *Distance)
	Gets the distance along the path for a given point.
void	Scale (const DocCoord dcOrigin, const double dDPI=96.0)
	This function is called on a path specified in DocCoords, to convert it into pixel coordinates.
INT32	GetPathPosition ()
	Find out where in the path we are.
void	SetPathPosition (INT32)
	Sets the current path position to the value supplied. This represents the Coord number in the path.
BOOL	IsInPath ()
	Determine if the path current position is still inside the path.
PathVerb	GetVerb () const
	finds the verb associated with the path position
DocCoord	GetCoord () const
	finds the DocCoord associated with the path position
PathFlags	GetFlags () const
	finds the flags associated with the path position
PathWidth	GetWidth () const
	Fetches width values from the path.
PathTypeEnum	GetPathType () const
	This determines whether the path is a line or a shape. It does this by seeing if it has a PT_CLOSEFIGURE bit set in its last verb.
INT32	GetPathByteLength () const
	Calculates the length of the path in bytes. This figures includes the size of the 3 arrays (Coordinates, Verbs and Flags) only.
INT32	GetNumElements () const
	This function counts the number of elements in the path. This ignores MoveTos, hence giving you the total number of visible path elements (i.e. all the lines and curves).
INT32	GetNumCoords () const
	This returns the number of coordinates that make the path up.
INT32	GetNumEndPoints () const
	Goes through the path and counts all open ends in the path. For example, a straight line has 2 open ends, a closed shape has no open ends and a complex path could have any number of open ends. You should use this function before calling GetAllOpenEnds that will fill an array for their coords for you.
INT32	GetAllOpenEnds (INT32 MaxElements, DocCoord *EndCoords) const
	Goes through the path and copies the coordinates of all the Open ends of the path into the array, until MaxElements elements have been added to the array. Call GetNumEndPoints to find out how big to make your array in the first place.
INT32	GetNumSelEndPoints () const
	determine how many selected endpoints there are within this path. Useful indirectly for finding whether there's a subselection.
INT32	GetNumSubpaths () const
	Gets the number of subpaths in this path.
DocRect	GetBoundingRect () const
	Calculates the bounding rectangle of the paths coordinates. This is calculated on the fly, so don't over use it.
DocRect	GetBlobRect () const
	Calculates the bounding rectangle of the paths coordinates expanded by the current blob size. This is calculated on the fly, so don't over use it.
BOOL	GetTrueBoundingRect (DocRect *pRect, MILLIPOINT LineWidth=0, CCAttrMap *pAttrMap=NULL)
	Calculate the bounding rectangle of a path using GDraw.
DocCoord	GetEndPoint ()
	Finds the endpoint of a given path element and returns it. For MoveTos and LineTos, the point returned will be its associated coord, but for a CurveTo the last coord will be returned.
DocCoord	GetControl1 ()
	Finds the first control point of a bezier.
DocCoord	GetControl2 ()
	Finds the second control point of a Bezier.
DocCoord *	GetCoordArray () const
	Gives you access to the coordinate array. This array is simply a list of all the coordinates in the path, in order. This should be very useful if you need to perform transformations or other actions that effect all the coordinates. The coordinates are in the corect order for the NT PolyDraw() function handle.
PathVerb *	GetVerbArray () const
	This array holds a list of all the path elements used in the path. The structure used is the same as the NT structure and can in fact be passed striaght on to the NT PolyDraw function. The verbs must be one of the following PC_MoveTo, PC_LineTo or PC_CurveTo. LineTo and CurveTo verbs can be combined with a ClosePath Flag.
PathFlags *	GetFlagArray () const
	This array holds a set of flags for each and every coordinate in the path. These flags are used to record information specific to each coordinate, such as its selection state, to determine if it should smooth this part of the path etc.
PathWidth *	GetWidthArray ()
	The array holds the width of all the points in the path. DO NOT MODIFY THE CONTENTS OF THE ARRAY.
void	GetPathArrays (PathVerb **pV, DocCoord **pC=NULL, PathFlags **pF=NULL)
	Easy way of getting the path pointers into variables. Combines three function calls into one.
void	GetFlags (PathFlags *NewFlags)
	returns all the flags for the current path position
void	SetFlags (const PathFlags &NewFlags)
	Sets the flags at the current path position to the flags provided.
void	InitialiseFlags ()
	This generates a legal path flags array based on the all path verbs. It sets all flags to default values and then scans all end points setting their end point flag to TRUE.
void	InitialiseFlags (const INT32 Startindex, const INT32 Len)
	This generates a legal path flags array based on the path verbs within the specified region. It sets all flags to default values and then scans all end points setting their end point flag to TRUE.
void	InitialiseFlags (PathVerb *pVerbs, PathFlags *pFlags, const INT32 Len)
	This generates a legal path flags array based on the path verbs in pVerbs within the specified region. It sets all flags in pFlags to default values and then scans all end points setting their end point flag to TRUE.
BOOL	InsertMoveTo (DocCoord p1, PathFlags *NewFlags=NULL)
	Inserts a MoveTo element into the middle of the Path and asks for extra memory if we need it. It will return FALSE if we fail to get the memory.
BOOL	InsertLineTo (DocCoord p1, PathFlags *NewFlags=NULL)
	Inserts a LineTo into the path at the Current Path Position.
BOOL	InsertCurveTo (DocCoord p1, DocCoord p2, DocCoord p3, PathFlags *NewFlags=NULL)
	Inserts a Curve into the path at the Current Path Position.
BOOL	CloseSubPath ()
	To indicate that a path is closed with a line, you should call CloseSubPath with the Current Path Position indicator somewhere inside the sub-path that you want closed. This function will adjust the verb of the last line segment in the sub-path by adding the PT_CLOSEFIGURE element into as described in the NT Prog Reference guides for the PolyDraw() function (page 304 of book 4 at last count) The Current Path Position is left on the element at the end of the subpath.
BOOL	InsertSection (INT32 StartSlot, INT32 NumSlots)
	This routine is the corollary to DeleteSection - it inserts a section into the path at a given position and a given size, but does not put any data into the path. Note that this routine is likely to move the path data around in memory, so after calling it you should re-read any pointers to the path you might have had.
BOOL	AddMoveTo (DocCoord p1, PathFlags *NewFlags=NULL)
	Adds a new MoveTo to the end of the path.
BOOL	AddLineTo (DocCoord p1, PathFlags *NewFlags=NULL)
	Adds a new LineTo to the end of the path.
BOOL	AddCurveTo (DocCoord p1, DocCoord p2, DocCoord p3, PathFlags *NewFlags=NULL)
	Adds a Curve to the end of the path.
BOOL	AddCurveTo (DocCoord p1, PathFlags *NewFlags=NULL)
	Adds a straight line version of a curve to the end of the path. The control points are positioned 1/3 and 2/3 along the line between its end points.
BOOL	DeleteSection (INT32 StartSlot, INT32 NumSlots)
	Deletes sections out of the middle of the path. Used by DeleteElement and for Deleting sub paths etc.
BOOL	DeleteElement ()
	Deletes the element at the Current Path Position. May free some memory if the path gets to have too much unused space in the path. The Current Path Position points at the slot before the one being deleted.
BOOL	DeleteFromElement (INT32 ElementNum)
	Deletes all the elements in the path from ElementNum to the end of the path.
BOOL	ClearPath ()
	Empties the path of all its entries and tries to free up excessive amounts of unused memory left over at the end. It does keep some memory though, ready for a new path to be put into it. It also now resets CurrentPos back to zero.
BOOL	ClearPath (BOOL compress)
	Empties the path of all its entries. If compress is TRUE the routine will try to free up excessive amounts of unused memory left over at the end. It also now resets CurrentPos back to zero.
BOOL	Compact ()
	Removes any extraneous unused slots in a path. It will a maximum of 2n-1 slots free where n is the size of an allocation chunk when increasing the buffer (see Path::Initialise).
BOOL	IsSelected ()
	return the Selected flag for the coordinate
BOOL	IsSmooth ()
	returns the Smooth flag for the Current Path Position
BOOL	IsRotate ()
	returns the Rotate flag for the coordinate
BOOL	IsEndPoint ()
	return the IsEndPoint flag for the coordinate
BOOL	IsSubSelection ()
	determine if the path has a subselection
BOOL	IsNearOpenEnd (const DocRect &BlobRect, INT32 *SlotNum)
	Determines if the Coordinate is near any of the path open ends. This function looks through all the open ends in complex paths and returns TRUE if any of them are near the TestCoord.
BOOL	IsOpenEnd (const INT32 index)
	Tests to see if the index provided specifies either the first or last element in an open subpath. ie the index is a true end point.
BOOL	IsComplexPath ()
	Tests to see if the path is a complex path (ie it has multiple sub-paths).
BOOL	IsIsometric (const Path &OtherPath, Matrix *pTransform, const double &Tolerance=1.0) const
	Determines whether two paths are isometric. In this context, isometric does not include true isomtric paths with different starting points. This can then be used to provide a transformation of this path, resulting in the given otherPath.
INT32	CalcCRC ()
	Calculates a cyclic redundancy check value for a path. This CRC is invariant under translation only. It can be used to determine whether a new path matches that of an old path whose CRC we already know, whether the new path has been translated or not.
INT32	CalcRegionCRC (const INT32 StartIndex, const INT32 EndIndex)
	Calculates a cyclic redundancy check value for a path region. This CRC is only invariant under translation. It can be used to determine whether a new path matches that of an old path whose CRC we already know, whether the new path has been translated or not.
INT32	CalcSelectedCRC ()
	Calculates a cyclic redundancy check value for a paths selected coordinates. This CRC is invariant under translation only. It can be used to determine whether a new path matches that of an old path whose CRC we already know, whether the new path has been translated or not.
INT32	CalcSelPointsCRC (const INT32 StartIndex, const INT32 EndIndex)
	Calculates a cyclic redundancy check value for a paths selected coordinates. This CRC is invariant under translation only. It can be used to determine whether a new path matches that of an old path whose CRC we already know, whether the new path has been translated or not.
XLONG	CalcArea ()
	Calculate the area of this path.
INT32	ComparePathToPath (Path *pComparePath, BOOL QuickCheck=TRUE)
	Compares athis path to a passed in path. It firswt does a quick check on the number of coords and if they are equal does a more thoughour check on the verb array and coord array.
void	DumpPath ()
	Dumps the whole path out to the debug terminal.
void	GetDebugDetails (StringBase *Str)
	Dumps the whole path out during tree display debugging.
void	RenderPathBlobs (Spread *pSpread)
	Draws all the selection blobs for a path. Useful for putting the blobs on or taking them back off again. This goes into its own RenderOnTop loop and calls RenderPathBlobs(RenderRegion* pRender).
void	RenderPathBlobs (RenderRegion *pRender)
	Draws all the selection blobs for a path. Useful for putting the blobs on or taking them back off again.
void	RenderPathControlBlobs (Spread *Spread, INT32 EndPtIndex)
	Draws the control points selection blobs for an endpoint on a path. Used by RenderPathBlobs and also the Bezier tool. This goes into its own RenderOnTop loop.
void	RenderPathControlBlobs (RenderRegion *pRender, INT32 EndPtIndex)
	Draws all the control points selection blobs for a path. Used by RenderPathBlobs and also the Bezier tool.
void	RenderPathSelectedControlBlobs (Spread *pSpread, BOOL Removing=TRUE)
	Draws all the control points selection blobs for an entire path. If you are to change the selection flags on a path then call this to remove all selection blobs, do your change, then call this again to draw the new blobs. This goes into its own RenderOnTop loop.
void	RenderPathSelectedControlBlobs (Spread *pSpread, RenderRegion *pRender)
	Draws all the control points selection blobs for an entire path into a specified render region. Called by the above function.
void	RenderSelectedControlBlobsToPendingRegions (Spread *pSpread)
	Draws all the control points selection blobs for an entire path into all the pending render regions.
void	RenderPathPenBlobs (Spread *pSpread)
	Draws all the selection blobs and pen blobs for a path. Useful for putting the blobs on or taking them back off again.
void	RenderPathPenBlobs (RenderRegion *pRegion)
	Draws all the selection blobs and pen blobs for a path. Useful for putting the blobs on or taking them back off again.
void	DrawBlob (RenderRegion *, const DocCoord &, BOOL)
	Draws a single blob, either selected or un-selected.
void	DrawControlBlob (RenderRegion *, const DocCoord &)
	Draws a blob for a Bezier control point.
void	DrawControlLine (RenderRegion *, const DocCoord &, const DocCoord &)
	Draws a line from the Bezier control point to its endpoint.
void	ClearSubSelection ()
	Goes through the path and sets all the IsSelected flags to FALSE, clearing any selected control points in the path.
void	SetAllSubSelection ()
	Goes through the path and sets all the IsSelected flags to TRUE, also selecting all control points in the path.
void	EnsureSelection (BOOL UseStarts)
	Goes through the path ensuring that the selection status of the ends/starts of subpaths equal the selection state of the start/ends of that subpath Also selects/deselectes control points as appropiate.
void	SmoothCurve (BOOL SetRenderFlags=FALSE, BOOL SnapEnds=FALSE, INT32 SnapIndex=0)
	Smooths the path on the areas that have the IsSmooth flag set to TRUE. This can change any or all of the path.
void	CalcDoubleCurve (DocCoord &, DocCoord &, DocCoord &, DocCoord *, DocCoord *)
	Calculates the position of the two control points on either side of p2, using the position of the coords of either side of it to help (p1 & p3).
void	CalcPointCurve (DocCoord &, DocCoord &, DocCoord &, DocCoord *)
	Calculates the position of the control point adjacent to p2 between p2 and p3, using the position of the coords of either side of it to help (p1 & p3).
void	CalcPointLine (DocCoord &, DocCoord &, DocCoord &, DocCoord *)
	Calculates the position of the control point that appears after p2, which is part of the curve ending at p3. The control point should be colinear with p1 & p2 and 1/3 the distance between p2 & p3 from p2!
void	CalcPointEnd (DocCoord &, DocCoord &, DocCoord *)
	Calculates the position of the last control point in the sub-path.
void	CalcRotate (DocCoord &, DocCoord *, DocCoord *, DocCoord &)
void	Reverse ()
	Reverses this path, so that it is rendered and traversed etc in the other direction. This involves reversing the order of all the coords etc in the path.
void	ReverseSection (INT32 StartSlot, INT32 SubPathLen)
	Reverses the direction of the section of the path specified. This is typically used to reverse subpaths of a complex path. It is also called by Reverse, to reverse the entire path.
void	TryToClose ()
	Tries to close the path. If the start coord and the end coord are the same, it will close the path with a PT_CLOSEFIGURE and set the IsFilled flag. It searches all the sub-paths in the path and if any of them are closed, the whole path is marked as filled.
void	RotateElementsLeft (const INT32 Start, const INT32 End, INT32 Rotate)
	Rotates the specified elements in a path by the number of positions indicated. Elements will be rotated from right to left.
BOOL	MergeTwoPaths (const Path &Other)
	Combines the two paths into a single complex path.
BOOL	MergeTwoPaths (DocCoord *OtherCoords, PathVerb *OtherVerbs, PathFlags *OtherFlags, INT32 Length, BOOL Filled)
	Appends the data in the three given arrays to the arrays in this path.
BOOL	SplitAtPoint (const DocCoord SplitPt, INT32 *SplitElement, UINT32 *NumElements, PathVerb *Verbs, DocCoord *Coords)
	This function finds the element (line or curve) on which the closest point to SplitPt occurs. A parameter t describes the point on this element and is used to split the element into two distinct pieces. The verbs and coordinates of these pieces are returned to the caller in the output lists. NumElements will describe how many path components have been created and stored in the lists This will be a value of 2 for lines and 6 for curves.
BOOL	ChangeStartElement (INT32 StartIndex)
	This will rotate the path so that the element that was at StartIndex is now at index 0. You should only call this for closed paths that don't contain subpaths.
void	Translate (const INT32 x, const INT32 y)
	Translate all coordinate within 'this' path.
void	Translate (const DocCoord &coord)
	Translate all coordinate within 'this' path.
INT32	ClipPathToPath (const Path &Src, Path *const pDest, UINT32 Flags, UINT32 Tolerance=100, double SrcFlatness=750.0, double ClipFlatness=750.0)
	This is an interface to Gavin's ClipPathToPath.
BOOL	StrokePathToPath (MILLIPOINT LineWidth=250, LineCapType LineCap=LineCapButt, JointType JoinStyle=MitreJoin, DashType *pDash=NULL, Path *pDest=NULL, double Flatness=200.0, BOOL Close=FALSE)
	Strokes the path, and places result in pDest. If pDest == NULL, the result is placed back in this path.
double	CalculateFlatnessValueFromPath (double DividerValue=375.0, double LowerLimit=1.0, double UpperLimit=375.0)
	To calculate a suitable flatness value to be used with Contouring, Clipping and Stroking. The value is based on the actual size of the paths dimensions.
INT32	InitializeContourValues (UINT32 Width, JoinStyles JoinS=JOIN_ROUND, BOOL IsAnOuterContour=TRUE, double Flatness=200.0, BOOL ClosePath=TRUE, BOOL UseContourMode=TRUE, CapStyles CapS=CAPS_ROUND, UINT32 MitreLimit=751941)
INT32	GetContourForStep (Path *pDest, double StepValue=1.0)
void	ClearNeedToRender ()
	Sets the NeedToRender flags on all of the path elements to FALSE.
BOOL	CopySectionFrom (const Path &Other, INT32 StartIndex, INT32 NumToCopy)
	Copies a specified section from a path to the end of this one.
BOOL	CopySectionTo (Path *Dest, INT32 StartIndex, INT32 NumToCopy)
	Copies a specified section from this path to the end of another path.
BOOL	MergeSectionFrom (INT32 DestinPos, const Path &Source, INT32 SourcePos, INT32 Length)
	Copies a specified section from a source path to a specified position in this path.
BOOL	MergeSectionTo (INT32 SourcePos, INT32 Length, Path *Destin, INT32 DestinPos)
	Copies a specified section from this path to a specific position within another path. A gap is created if necessary to copy the data into.
BOOL	MakePathFromSection (const INT32 Start, const INT32 Length, Path *pDestin)
	Copies a specified section from this path to a specific position within another path. A gap is created if necessary to copy the data into.
BOOL	MakePathFromSubPath (const INT32 lSubpathIndex, Path *pDestin)
	Makes a subpath into a path in its own right.
BOOL	CloneFrom (const Path &Other)
	Replace the data within this path with that of Other path.
BOOL	SimpleJoin (Path *Other, INT32 *, BOOL *, BOOL *Reversed=NULL)
	Joins two paths to form a new, longer path. Both the paths invloved are simple (ie not complex).
BOOL	ComplexJoin (Path *Other, INT32 *, BOOL *)
	Tries to Join the New Path (must be simple) to a complex path.
BOOL	ComplexToSameComplexJoin (Path *Other, INT32 *, BOOL *)
	This path is assumed to be complex and Other is assumed to be a simple path. The start and end point of the Simple Path must be the same as the start or end point of one of the sub paths of this complex path. The function Moves the two sub paths that are touched by the simple path to the end of the path, and inserts the simple path between them. This means that the two touched sub-paths and the new simple path are combined into a single sub path. This may also mean that this complex path is no longer complex.
BOOL	FindJoinedSubPathInfo (const DocCoord &JoinCoord, INT32 *Start, INT32 *Length, BOOL *JoinAtStart)
	This function searchs the path, compareing JoinCoord with the start and end points of each of the Sub-paths in the path. If it is the same as one of the start or end points, then the output params are filled and TRUE is returned.
BOOL	JoinToAnother (Path *OtherPath, INT32 MainIndex, INT32 OtherIndex)
	This routine is used to join the end of a line to the end of another line. It will cope with the various possiblities: That both subpaths are in the same complex paths, that one or other of the subpaths are in different complex paths, and that one of the paths might need reversing. The other path is left untouched. This path will contain all subpaths from that one. This routine assumes that the two subpaths are different - it will not join the start and end of the same subpath.
BOOL	RetroReplaceSection (INT32 StartSlot, INT32 NumSlots, Path *NewPath, BOOL KeepStart)
	Deletes all the elements in the path from StartSlot to StartSlot+NumSlots and then inserts the whole of NewPath into the hole. If the hole is not big enough, then it is made bigger and if it is too big, then it is shrunk.
BOOL	SmoothRegions (const double error, BOOL smoothall, BOOL reselect)
	Given a path, search for regions of interest and smooth these regions. Regions are defined by sequences of connected selected points ie.
BOOL	SmoothSection (INT32 index1, INT32 *index2, const double error, INT32 selection)
	Given a path, search for regions of interest and smooth these regions. Regions are defined by (start/end) selected points with any number of none selected points inbetween. If smoothall is true or there are no selected regions within the path, the whole path is smoothed. You should call this function with a path which you do not mind being corrupted, ie changed in an unpredictable way. The function may successfully smooth a number of regions within the path, then fail on one particular region. The result will be a path with m out of n regions smoothed.Smooth a path between the given section delimited by [index1,index2].
BOOL	Smooth (const double error)
	Smooth a path, using the fitcurve function, which may turn out to be NOT the way to do it but I'll give it a try. You should generally call this funcion with a copy of the path you want to smooth. This smooth function will corrupt the path if it fails. Call the function SmoothSection() describing your entire path if you wish to smooth a path without corrupting anything on failure.
BOOL	Quantise (const double threshold, Path *pOutput)
	Quantise a path. All curves within the path will be approximated by straight lines. pOutput may point at 'this' path ie a path can be quantised to itself. If the quantising fails for some reason, the output path will be unaffected EVEN if you're quantising a path to itself. Note, Quantising differs from flattening in that it will approximate straight lines within a path, generating n colinear points for each line it meets. Whereas flattening does nothing with lines.
BOOL	Flatten (const double flatness, Path *pOutput)
	Flatten a path. All curves within the path will be approximated by straight lines. pOutput may point at 'this' path ie a path can be flattened to itself. If the flattening fails for some reason, the output path will be unaffected even if you are flattening a path to itself.
BOOL	CreateFlatPath (const ProcessFlags &PFlags, const double flatness, Path *pOutput)
	Flatten a path. All curves within the path will be approximated by straight lines. pOutput may point at 'this' path ie a path can be flattened to itself. If the flattening fails for some reason, the output path will be unaffected even if you're flattening a path to itself.
BOOL	MakeSpaceInPath (INT32 NumSlots)
	Checks to see if there is already enough memory available to make the insertion and if not will try to allocate some more memory. If this works it will move the path (after the position indicated by the path class variable CurrentPos) along to make room for the correct number of slots at that point.
BOOL	MakeSpaceInPath (INT32 NumSlots, INT32 Position)
	Checks to see if there is already enough memory available to make the insertion and if not will try to allocate some more memory. If this works it will move the path after the position indicated by Position along to make room for the correct number of slots at that point.
BOOL	MakeSpaceAtEnd (INT32 NumSlots)
	Will make enough room for NumSlots unused slots at the end of the path.
BOOL	OpenGap (INT32 NumSlots)
	Will open a gap of NumSlots size in this path. The gap is positioned at CurrentPos (A path class variable).
BOOL	OpenGap (INT32 NumSlots, INT32 Position)
	Will open up a gap of NumSlots at the position Position within the path. If Position is set to the end of the path ie the same value as usedslots, no data will be moved. FALSE will ofcourse always be returned if there is not enough free space in the form of unused slots on the end of the path for the gap to open. Use MakeSpaceInPath() if you know there isn't enough room. See Also: MakeSpaceInPath, MakeSpaceAtEnd.
BOOL	EnsureVolume (INT32 NumSlots)
	This function ensures there are >= NumSlots in the path arrays. It may try to alter the size of the path arrays by increasing the number of unused slots to satisfy the request. It will never decrease the size of the arrays, if NumSlots < UsedSlots+UnusedSlots then the volume is automatically ensured. This allows path buffers to be resized ready for cloning.
BOOL	ExternalArraysAdded (const INT32 Added)
	A hidden function to adjust the number of elements in a path. This has been added by me as a last resort and should not be used by others. (Hence hidden from the documentation). It is required to cope with changes in the path data external to the path class. This occurs when doing really nasty things like moulding paths.
BOOL	ExternalArraysReplaced (const INT32 Size)
	A hidden function to adjust the number of elements in a path. This has been added by me as a last resort and should not be used by others. (Hence hidden from the documentation).
BOOL	HasWidth ()
	To determine if the path has any width information.
void	MapWidth (ChannelIndex)
	Alters the mapping of the Width Information to one of the ExtraInfo channels.
BOOL	InitExtraInfo (ChannelIndex)
	Allocates memory in the path for the extra info arrays.
BOOL	AddExtraInfo (ChannelIndex, INT32)
	Adds an extra Info Value at the current path position.
void	SyncExtraInfo ()
	Sets the Extra Info Ptr to the current Path Position.
void	NextExtraInfo ()
DocCoord	SmoothControlPoint (INT32 Index, BOOL StartAndEndSnapped=FALSE, BOOL JoinedToAnother=FALSE, BOOL OtherIsCurve=TRUE, const DocCoord &OtherCoord=DocCoord(0, 0))
	This function will handle the smoothing of a path. It is designed to take account of all the possibilities that might occur (hence the huge list of parameters). The various places where this function might be needed are:Calculates the smoothed position of a control point in a path. The smoothing is calculated based on the endpoint to which the control point is attached, and the endpoints on either side of this point. Since we are guaranteed that one of these segments is a curve (that's where the control point comes from) the other possibilities are: The curve just terminates (at the end of a path); The curve is attached to another curve; It is attached to a line; It is at the end, but the end joins the start of the same path, which could be a line or a curve; and the curve could be at the end, but snapping to a completely separate path segment which might either be a line or curve (this is what the JoinedToAnother, OtherIsCurve and OtherCoord parameters indicate.
BOOL	IsSubPathClosed (INT32 Index)
	Scans to the end of this subpath to see if it has the PT_CLOSEFIGURE flag set.
BOOL	IsClosed ()
	Tells you whether all subpaths of this path are closed.
BOOL	EnsureValid (BOOL *ChangesMade=NULL)
	Will attempt to make a path into a correct state. Checks are :- 1. All subpaths must start with a MoveTo 2. Consecutive MoveTos are removed 3. Zero element paths are unrepairable 4. MoveTos at the end of the path are removed 5. Should be three BezierTos in a row, only the last can be CloseFigure 6. A LineTo to the same location as the previous point is removed.
INT32	GetUsedSlots ()
Public Attributes
BOOL	IsFilled
BOOL	IsStroked
Private Member Functions
BOOL	InsertSectionAtEnd (const Path *Other, INT32 StartPos, INT32 NumSlots)
	Copies a section (usually a sub-path) of a path to the end of another path. This is used extensivly to Join Paths together. If there is not enougth space in this path, then the operation will fail - It will NOT try to make the path bigger. It is up to the caller to ensure that there are sufficent UnUsedSlots in the path before calling.
Private Attributes
INT32	m_ContourWidth
JoinStyles	m_ContourJoinS
CapStyles	m_ContourCapS
double	m_ContourFlatness
UINT32	m_ContourMitreLimit
UINT32	m_ContourLength
BOOL	m_IsAnOuterContour
BOOL	m_DoClosePath
BOOL	m_UseContourMode
MHANDLE	VerbHandle
MHANDLE	CoordHandle
MHANDLE	FlagsHandle
PathExtraInfo *	ExtraInfo
INT32	UnUsedSlots
INT32	UsedSlots
INT32	SlotAllocSize
INT32	SlotInitSize
INT32	CurrentPos

---

Detailed Description

Creation, manipulation and use of Paths. A path is an arbitary collection of MoveTo, LineTo and CurveTo segments Public Member variables :- BOOL IsFilled - TRUE if this path if filled, FALSE otherwise.

Author:

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

Date:

28/01/94

Definition at line 253 of file paths.h.

---

Constructor & Destructor Documentation

Path::Path (   )

constructor - just sets a few things to sensible values Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/94 Definition at line 182 of file paths.cpp. { // We do not have any memory yet UnUsedSlots = 0; UsedSlots = 0; SlotInitSize = 0; SlotAllocSize = 0; // set all the handles to bad in case they are used VerbHandle = BAD_MHANDLE; CoordHandle = BAD_MHANDLE; FlagsHandle = BAD_MHANDLE; // Set the path flags IsFilled = FALSE; IsStroked = TRUE; // Set the current path position CurrentPos = 0; // Setup the Extra Info Channels ExtraInfo = NULL; #if !defined(EXCLUDE_FROM_XARLIB) // Set up the contouring variables // m_pGPC = NULL; // m_pGSC = NULL; m_ContourLength = 0; m_IsAnOuterContour = true; m_DoClosePath = false; // MRH New! m_ContourWidth = 100; m_ContourJoinS = JOIN_MITER; m_ContourCapS = CAPS_BUTT; m_ContourFlatness = 200.0; // Set the mitre limit to 10 shifted 16. It`s done in two parts as it can cause overflow // problems if done as one call. m_ContourMitreLimit = 10; m_ContourMitreLimit <<= 16; m_UseContourMode = TRUE; #endif }

Path::~Path (   )

Destructor - releases the memory that the path has been using to store coords in. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/94 Definition at line 238 of file paths.cpp. { // Free the memory that the path is using to store its data in if (VerbHandle != BAD_MHANDLE) ReleaseBlock(VerbHandle); if (CoordHandle != BAD_MHANDLE) ReleaseBlock(CoordHandle); if (FlagsHandle != BAD_MHANDLE) ReleaseBlock(FlagsHandle); if (ExtraInfo != NULL) delete ExtraInfo; /* if(m_pGPC != NULL) { delete m_pGPC; m_pGPC = NULL; } if(m_pGSC != NULL) { delete m_pGSC; m_pGSC = NULL; } */ }

---

Member Function Documentation

BOOL Path::AddCurveTo (  DocCoord  p3, PathFlags *  NewFlags = NULL )

Adds a straight line version of a curve to the end of the path. The control points are positioned 1/3 and 2/3 along the line between its end points. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/12/94 Parameters: p3  - The endpoint [INPUTS] NewFlags - The flags to set the new coords to Returns: FALSE if there was an error, TRUE otherwise Errors: Can fail if it can not get enough memory to add the curve See also: Path::AddLineTo; Path::AddMoveTo Definition at line 2008 of file paths.cpp. { ERROR1IF( UsedSlots==0,FALSE,"No previous path elements when calling Path::AddCurveTo()" ); // set the current pos. CurrentPos = UsedSlots; // Find the coord of the last point in the path DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); DocCoord prev = Coords[CurrentPos-1]; // Create some temp coords DocCoord p1,p2; // calculate the intermediary control points p1.x = (2*prev.x + p3.x)/3; p1.y = (2*prev.y + p3.y)/3; p2.x = (prev.x + 2*p3.x)/3; p2.y = (prev.y + 2*p3.y)/3; return InsertCurveTo(p1,p2,p3,NewFlags); }

BOOL Path::AddCurveTo (  DocCoord  p1, DocCoord  p2, DocCoord  p3, PathFlags *  NewFlags = NULL )

Adds a Curve to the end of the path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/11/94 Parameters: p1  - The first control point [INPUTS] p2 - The second control point p3 - The endpoint NewFlags - The flags to set the new coords to Returns: FALSE if there was an error, TRUE otherwise Errors: Can fail if it can not get enough memory to add the curve See also: Path::AddLineTo; Path::AddMoveTo Definition at line 1986 of file paths.cpp. { CurrentPos = UsedSlots; return InsertCurveTo(p1,p2,p3,NewFlags); }

BOOL Path::AddExtraInfo (  ChannelIndex  Index, INT32  ExtraValue )

Adds an extra Info Value at the current path position. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 08/06/94 Parameters: -  [INPUTS] Returns: TRUE if all went well, FALSE if not Errors: Can fail if it runs out of memory Definition at line 8215 of file paths.cpp. { ENSURE(ExtraInfo != NULL, "ExtraInfo Pointer is NULL in AddExtraInfo"); return ExtraInfo->Add(Index, ExtraValue); }

BOOL Path::AddLineTo (  DocCoord  p1, PathFlags *  NewFlags = NULL )

Adds a new LineTo to the end of the path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/11/94 Parameters: p1  - the coord to draw the line to [INPUTS] NewFlags - Flags associtaed with the coord Returns: TRUE if it worked, FALSE if it failed to get more memory See also: Path::AddMoveTo; Path::AddCurveTo Definition at line 1961 of file paths.cpp. { CurrentPos = UsedSlots; return InsertLineTo(p1, NewFlags); }

BOOL Path::AddMoveTo (  DocCoord  p1, PathFlags *  NewFlags = NULL )

Adds a new MoveTo to the end of the path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/11/94 Parameters: p1  - the coord to draw the line to [INPUTS] NewFlags - Flags associtaed with the coord Returns: TRUE if it worked, FALSE if it failed to get more memory See also: Path::AddLineTo; Path::AddCurveTo Definition at line 1933 of file paths.cpp. { // Sadly there is no way for the outside world to set the insert position // to the end of the path!! SetPathPosition() for instance sets the currentpos to // usedslots-1, when passed usedslots which means you can never ever call InsertLineTo // and expect a line to be added to the pathend, it will be inserted before the element // which is the last in the path. Ok so this function does the job. CurrentPos = UsedSlots; return InsertMoveTo(p1, NewFlags); }

INT32 Path::BreakInTwo (  Path *  pChildPath  )

Tests a path to see if it is valid. This is only built into DEBUG versions of Camelot so always surround calls to it with an ifdef _DEBUG block. If the path is not valid in some way, this function will dump an explanation to the debug terminal and return FALSE.This function will attempt to break the current path at its first selected point. All selected points should still be in place in both parent and child. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 30/8/94 Parameters: pChildPath,a  pointer to a split path which should have been passed to new() [INPUTS] -  [OUTPUTS] Returns: -1 If unable to claim enough memory to split the path. Note pChildPath is unchanged and 'this' is also unaffected 0 If no selected points were found in the path. 1 Then the current path is opened at the first selected point. pChildPath is unaffected. 2 Then the current path now contains the left child data of the split and pChildPath points at a new path object containing the right child data. Errors: - See also: - Definition at line 8780 of file paths.cpp. { // Get arrays of flags,verbs and points. PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); // p,q indexes to selected point and endof(sub)path INT32 p = -1; INT32 q = -1; INT32 s = 0; // vp,vq local verb holders PathVerb vp; PathVerb vq; while (p++, FindNextSelected(&p)) { q = p; FindEndElOfSubPath(&q); // returns index of last element in this subpath/path if (p>q) return 0; // just a quick check on sanity. s = p; FindStartOfSubPath(&s); // grab the start of the subpath if (p==q) { if (!(Verbs[p] & PT_CLOSEFIGURE)) continue; // ignore selected points at end of open subpaths p=s; } vp = (Verbs[p] & ~PT_CLOSEFIGURE); vq = (Verbs[q]); // Have we found a selected start point? if (vp == PT_MOVETO) { if (vq & PT_CLOSEFIGURE) { // subpath figure is closed, so open the path and resolve flags Verbs[q] &= ~PT_CLOSEFIGURE; if (Flags[q].IsSelected) { Flags[q].IsSelected = FALSE; Flags[q].IsSmooth = FALSE; if (Verbs[q] == PT_BEZIERTO) { Flags[q-1].IsSelected = FALSE; Flags[q-1].IsSmooth = FALSE; } if (Verbs[p+1] == PT_BEZIERTO) Flags[p+1].IsSmooth = FALSE; } return 1; } continue; } // Note these elements should not need to be checked against PT_CLOSEFIGURE as // (p!=q) and q is the following close element. if ((vp == PT_LINETO) || (vp == PT_BEZIERTO)) { // ok, we have a selected element on a lineto/curveto. We need to check // whether we are in a closed subpath or an open one if ( vq & PT_CLOSEFIGURE ) // is this sub path closed? { // We need to reorder the subpath points and open the path. // This involves // (1) insert moveto(p) at p+1 // (2) increment q // (3) remove closefigure at q // (4) replace moveto(s) by lineto(s) // (5) rotate the whole path left/right until element p // lies at element s // subpath figure is closed, so open the path in parent if ((Coords[s].x == Coords[q].x) && (Coords[s].y == Coords[q].y)) { // I'm not totally convinced about this but here goes nothing! // When dealing with a chain of bezier control points, the previous // and following points are selected also. What we select and deselect // depends on which point (the start or end) we want selected when the // path is opened. I thought it would be sensible to leave the end point // selected but the click logic then does not allow you to drag the damn // point around! as it still lies on top of the deselected start point. // So lets try to select the new moveto and see what happens. Flags[p].IsSelected = FALSE; // deselect the current control point Flags[p].IsSmooth = FALSE; if (vp == PT_BEZIERTO) { Flags[p-1].IsSelected = FALSE; Flags[p-1].IsSmooth = FALSE; } CurrentPos = s; DeleteElement(); // Get rid of the original moveto CurrentPos = p; InsertMoveTo(Coords[p-1]); Flags = (PathFlags*) DescribeHandle(FlagsHandle); Verbs = (PathVerb*) DescribeHandle(VerbHandle); Flags[p].IsSelected = TRUE; // make sure the moveto is selected Flags[p].IsSmooth = FALSE; // but not smooth if ((Verbs[p+1] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) Flags[p+1].IsSmooth = FALSE; Verbs[q] &= ~PT_CLOSEFIGURE; // open the subpath. RotateElementsLeft(s,q,p-s); // rotate elements return 1; } else { // this section definitely needs more work! CurrentPos = p+1; if (!InsertMoveTo(Coords[p])) return -1; q++; Verbs = (PathVerb*) DescribeHandle(VerbHandle); Verbs[q] &= ~PT_CLOSEFIGURE; // open the subpath. Verbs[s] = PT_LINETO; // alter move to line RotateElementsLeft(s,q,p-s+1); // rotate elements return 1; } } else { // I need to alter the current path object and create a completely new // path object in the tree. This will contain the split section of the // parent path. This involves // (1) create newpath(p => q) by // (1.1) creating enough space for elements (p-q + 1) // (1.2) copying elements in // (1.3) replacing verb(p) by moveto // (2) removal of elements (p+1 => q) // Initialise the path with enough space for splinter q = UsedSlots-1; if (!pChildPath->Initialise(q-p+1,12)) return -1; // Copy the section out of the current path into the child if (!(CopySectionTo(pChildPath, p, q-p+1))) return -1; // Alter the childs first element once split, to a moveto. PathVerb* pChildVerbs = (PathVerb*) DescribeHandle(pChildPath->VerbHandle); PathFlags* pChildFlags = (PathFlags*) DescribeHandle(pChildPath->FlagsHandle); pChildVerbs[0] = PT_MOVETO; // Make sure the child paths first element is no longer smooth pChildFlags[0].IsSmooth = FALSE; if (pChildVerbs[1] == PT_BEZIERTO) pChildFlags[1].IsSmooth = FALSE; // Make sure the parent subpath start is deselected. It may have been selected // by the previous instructions from a previous iteration. Flags[s].IsSelected = FALSE; if (Verbs[s] == PT_BEZIERTO) Flags[s+1].IsSelected = FALSE; // Remove the parents end point smooth bit, but leave it selected Flags[p].IsSmooth = FALSE; if (vp == PT_BEZIERTO) Flags[p-1].IsSmooth = FALSE; // ok remove the necessary elements from the original path DeleteFromElement(p+1); return 2; } } } return 0; }

XLONG Path::CalcArea (   )

Calculate the area of this path. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 01/03/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Area of path in path units (typically millipoints) Or -1 if no area could be calculated See also: - Definition at line 10290 of file paths.cpp. { // Check whether it's closed! if (!IsFilled) return 0; // First, use ClipPathToPath to get a path that has no self-intersections... // Next flatten it Path FlatPath; FlatPath.Initialise(); BOOL bOK = Flatten(64, &FlatPath); if (!bOK) return -1; // Finally, compute the area under each flattened segment and sum them // (+dx adds to area, -dx subtracts from area) INT32 i = 0; XLONG area = 0; XLONG dx = 0; DocRect bounds = GetBoundingRect(); INT32 baseline = bounds.lo.y; // PathFlags* pFlags = FlatPath.GetFlagArray(); DocCoord* pCoords = FlatPath.GetCoordArray(); PathVerb* pVerbs = FlatPath.GetVerbArray(); DocCoord origin(0,0); for (i=0; i < FlatPath.GetNumCoords(); i++) { if (pVerbs[i] == PT_MOVETO) origin = pCoords[i]; else if (pVerbs[i] == PT_LINETO) { // area of this segment is area of rectangle under origin.y + area of triangle from origin to current point dx = pCoords[i].x - origin.x; area += dx*(XLONG)(origin.y-baseline) + dx*(XLONG)((ABS(pCoords[i].y - origin.y))/2); origin = pCoords[i]; } else if (pVerbs[i] == PT_CLOSEFIGURE) { // do nothing } else ERROR3("Unexpected path verb"); } // Counter-clockwise paths will generate -ve areas return ABS(area); }

INT32 Path::CalcCRC (   )

Calculates a cyclic redundancy check value for a path. This CRC is invariant under translation only. It can be used to determine whether a new path matches that of an old path whose CRC we already know, whether the new path has been translated or not. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/11/94 Parameters: -  [INPUTS] Returns: The CRC checksum for the path, relative to the first coord Definition at line 8024 of file paths.cpp. { return CalcRegionCRC(0,UsedSlots-1); }

void Path::CalcDoubleCurve (  DocCoord &  p1, DocCoord &  p2, DocCoord &  p3, DocCoord *  ControlPoint1, DocCoord *  ControlPoint2 )

Calculates the position of the two control points on either side of p2, using the position of the coords of either side of it to help (p1 & p3). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/93 Parameters: p1,p2,p3  - The End points of the path elements before, after and at the [INPUTS] the current position in the path ControlPoint1,ControlPoint2  - Pointers to the control points on either [OUTPUTS] side of the current point See also: Path::CalcPointLine; Path::CalcPointEnd Definition at line 4797 of file paths.cpp. { // The positions of the two control points adjacent to p2 depend on: // a) The distance from p2 of p1 and p3, and // b) The angle between p1p2p3. The following logic is used: // // The distance from p2 to ControlPoint1 is 1/3 the distance from p2 to p1 // The angle from p2 to ControlPoint1 and the horizontal is 90 degrees from the angle of the line // bisecting the angle p1p2p3. Whether it is -90 or +90 depends on whether the acute angle between p1p2p3 // is negative or positive // Work out the angles double Alpha, Beta, Theta; Alpha = atan2((double)p3.y-p2.y, (double)p3.x-p2.x); // Alpha = angle between line p2p3 and horizontal Beta = atan2((double)p1.y-p2.y, (double)p1.x-p2.x); // beta = angle between line p2p1 and horizontal Theta = (Beta + ((Alpha - Beta)/2.0)); // Theta = bisection of Alpha and Beta // And calculate the distance between the various control points double Distp2p1, Distp2p3, lx, ly; lx = p2.x - p1.x; ly = p2.y - p1.y; Distp2p1 = sqrt( lx*lx + ly*ly ) / 3.0; lx = p2.x - p3.x; ly = p2.y - p3.y; Distp2p3 = sqrt( lx*lx + ly*ly ) / 3.0; if (Alpha - Beta < 0) { // Angle p2p1 is greater than p2p3, so we have to swap the angle used ControlPoint1->x = p2.x + (INT32)(Distp2p1 * cos(Theta + PI/2.0)); ControlPoint1->y = p2.y + (INT32)(Distp2p1 * sin(Theta + PI/2.0)); ControlPoint2->x = p2.x + (INT32)(Distp2p3 * cos(Theta - PI/2.0)); ControlPoint2->y = p2.y + (INT32)(Distp2p3 * sin(Theta - PI/2.0)); } else { ControlPoint1->x = p2.x + (INT32)(Distp2p1 * cos(Theta - PI/2.0)); ControlPoint1->y = p2.y + (INT32)(Distp2p1 * sin(Theta - PI/2.0)); ControlPoint2->x = p2.x + (INT32)(Distp2p3 * cos(Theta + PI/2.0)); ControlPoint2->y = p2.y + (INT32)(Distp2p3 * sin(Theta + PI/2.0)); } // // Work out all the angles // double Alpha, Beta, Theta; // Alpha = atan2( (p3.y-p2.y), (p3.x - p2.x) ); // Beta = atan2( (p2.x - p1.x), (p2.y - p1.y) ); // Theta = (PI/2.0 - Alpha - Beta) / 2.0; // // And calculate the distance between the various control points // double DistA, DistB, lx, ly; // lx = p2.x - p1.x; // ly = p2.y - p1.y; // DistA = sqrt( lx*lx + ly*ly ) / 3.0; // lx = p2.x - p3.x; // ly = p2.y - p3.y; // DistB = sqrt( lx*lx + ly*ly ) / 3.0; // // if (Theta < PI/2.0) // { // // // Set the control point // ControlPoint1->x = p2.x - (INT32)(DistA*sin(Theta+Beta)); // ControlPoint1->y = p2.y - (INT32)(DistA*cos(Theta+Beta)); // ControlPoint2->x = p2.x + (INT32)(DistB*cos(Theta+Alpha)); // ControlPoint2->y = p2.y + (INT32)(DistB*sin(Theta+Alpha)); // } // else // { // // Set the control point // ControlPoint1->x = p2.x + (INT32)(DistA*sin(Theta+Beta)); // ControlPoint1->y = p2.y + (INT32)(DistA*cos(Theta+Beta)); // ControlPoint2->x = p2.x - (INT32)(DistB*cos(Theta+Alpha)); // ControlPoint2->y = p2.y - (INT32)(DistB*sin(Theta+Alpha)); // // } }

void Path::CalcPointCurve (  DocCoord &  p1, DocCoord &  p2, DocCoord &  p3, DocCoord *  ControlPoint )

Calculates the position of the control point adjacent to p2 between p2 and p3, using the position of the coords of either side of it to help (p1 & p3). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/93 Parameters: p1,p2,p3  - The End points of the path elements before, after and at the [INPUTS] the current position in the path ControlPoint  - Pointer to the control point that appears just after p2. [OUTPUTS] imagine the following path structure: moveto p1 curveto pa curveto pb curveto p2 <- This is the endpoint to which the ctrl point is attached curveto pc <- This is the control point being calculated curveto pd curveto p3 See also: Path::CalcPointLine; Path::CalcPointEnd Definition at line 4913 of file paths.cpp. { // Work out all the angles double Alpha, Beta, Theta; Alpha = atan2((double)p3.y-p2.y, (double)p3.x-p2.x); Beta = atan2((double)p1.y-p2.y, (double)p1.x-p2.x); Theta = Beta - ((Beta - Alpha)/2.0); // And calculate the distance between the various control points double Dist, lx, ly; lx = p2.x - p3.x; ly = p2.y - p3.y; Dist = sqrt( lx*lx + ly*ly ) / 3.0; if (Beta - Alpha < 0) Theta += PI/2.0; else Theta -= PI/2.0; ControlPoint->x = p2.x + (INT32)(Dist * cos(Theta)); ControlPoint->y = p2.y + (INT32)(Dist * sin(Theta)); /* if (Theta < PI/2.0) { // Set the control point ControlPoint->x = p2.x - (INT32)(Dist*sin(Theta+Beta)); ControlPoint->y = p2.y - (INT32)(Dist*cos(Theta+Beta)); } else { // Set the control point ControlPoint->x = p2.x + (INT32)(Dist*sin(Theta+Beta)); ControlPoint->y = p2.y + (INT32)(Dist*cos(Theta+Beta)); } */ }

void Path::CalcPointEnd (  DocCoord &  p1, DocCoord &  p2, DocCoord *  ControlPoint )

Calculates the position of the last control point in the sub-path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/93 Parameters: p1,p2  - The coords of the last two points in the curve [INPUTS] ControlPoint  - The Coord of the last control point [OUTPUTS] See also: Path::CalcPointLine; Path::CalcPointCurve Definition at line 5009 of file paths.cpp. { ControlPoint->x = p1.x + ((p2.x - p1.x) / 3); ControlPoint->y = p1.y + ((p2.y - p1.y) / 3); }

void Path::CalcPointLine (  DocCoord &  p1, DocCoord &  p2, DocCoord &  p3, DocCoord *  ControlPoint )

Calculates the position of the control point that appears after p2, which is part of the curve ending at p3. The control point should be colinear with p1 & p2 and 1/3 the distance between p2 & p3 from p2! Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/93 Parameters: p1,p2,p3  - The End points of the path elements before, after and at the [INPUTS] the current position in the path ControlPoint  - Pointers to the control point between p2 and p3 [OUTPUTS] See also: Path::CalcPointLine; Path::CalcPointEnd Definition at line 4972 of file paths.cpp. { // Calc 1/3 the distance from p2 to p3 double DistA, DistB, lx, ly; lx = p2.x - p3.x; ly = p2.y - p3.y; DistA = sqrt( lx*lx + ly*ly ) / 3.0; // calc the length of p1 to p2 lx = p2.x - p1.x; ly = p2.y - p1.y; DistB = sqrt( lx*lx + ly*ly ); // Calculate the scale factor double Factor = (DistB==0.0) ? 1.0 : (DistA / DistB); lx *= Factor; ly *= Factor; // Calc the position of the new control points ControlPoint->x = p2.x + (INT32)lx; ControlPoint->y = p2.y + (INT32)ly; }

INT32 Path::CalcRegionCRC (  const INT32  StartIndex, const INT32  EndIndex )

Calculates a cyclic redundancy check value for a path region. This CRC is only invariant under translation. It can be used to determine whether a new path matches that of an old path whose CRC we already know, whether the new path has been translated or not. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>/Mike Date: 11/11/94 Parameters: StartIndex  = index into coord array to start calculating from [INPUTS] EndIndex = index into coord array to end calculation (inclusive) Returns: The CRC checksum for the region, relative to StartIndex Definition at line 8047 of file paths.cpp. { INT32 TotalCRC = 0; DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); for (INT32 i=StartIndex; i<(EndIndex+1); i++) { // Get the coords relative from the first coord // making this process transparent to translation // Add it in to the CRC total TotalCRC += (Coords[i].x-Coords[StartIndex].x) + (Coords[i].y-Coords[StartIndex].y); } return TotalCRC; }

void Path::CalcRotate (  DocCoord &  p2, DocCoord *  p1, DocCoord *  p3, DocCoord &  MouseOffset )

Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/11/93 Parameters: p1,p2,p3  - The End points of the path elements before, after and at the [INPUTS] the current position in the path ControlPoint  - Pointers to the control point between p2 and p3 [OUTPUTS] See also: Path::CalcPointLine; Path::CalcPointEnd Definition at line 5033 of file paths.cpp. { double dx, dy, Length; // Find the length of the vector from the middle to the point not being dragged dx = p2.x - p3->x; dy = p2.y - p3->y; Length = sqrt( dx*dx + dy*dy ); // Move the point being dragged p1->x += MouseOffset.x; p1->y += MouseOffset.y; // Calculate the vector from the point being dragged to the centre double VecLen; dx = p1->x - p2.x; dy = p1->y - p2.y; VecLen = sqrt( dx*dx + dy*dy ); if (VecLen == 0.0) // the dragged point is over the centre point, so leave the other control point where it is return; // Normalise the vector and // Scale the vector by the Length of the other side dx = dx * Length / VecLen; dy = dy * Length / VecLen; // Set the opposite point to the centre offset by the vector p3->x = p2.x - (INT32)dx; p3->y = p2.y - (INT32)dy; }

INT32 Path::CalcSelectedCRC (   )

Calculates a cyclic redundancy check value for a paths selected coordinates. This CRC is invariant under translation only. It can be used to determine whether a new path matches that of an old path whose CRC we already know, whether the new path has been translated or not. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/11/94 Parameters: -  [INPUTS] Returns: The CRC checksum for the path, relative to the first coord Definition at line 8081 of file paths.cpp. { return CalcSelPointsCRC(0,UsedSlots-1); }

INT32 Path::CalcSelPointsCRC (  const INT32  StartIndex, const INT32  EndIndex )

Calculates a cyclic redundancy check value for a paths selected coordinates. This CRC is invariant under translation only. It can be used to determine whether a new path matches that of an old path whose CRC we already know, whether the new path has been translated or not. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>/Mike Date: 11/11/94 Parameters: StartIndex  = index into coord array to start calculating from [INPUTS] EndIndex = index into coord array to end calculation (inclusive) Returns: The CRC checksum for the region, relative to StartIndex Definition at line 8104 of file paths.cpp. { INT32 TotalCRC = 0; DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); for (INT32 i=StartIndex; i<(EndIndex+1); i++) { if (Flags[i].IsSelected) TotalCRC += (Coords[i].x-Coords[StartIndex].x) + (Coords[i].y-Coords[StartIndex].y); } return TotalCRC; }

double Path::CalculateFlatnessValueFromPath (  double  DividerValue = 375.0, double  LowerLimit = 1.0, double  UpperLimit = 375.0 )

To calculate a suitable flatness value to be used with Contouring, Clipping and Stroking. The value is based on the actual size of the paths dimensions. Author: Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/2000 Parameters: Divider  Value which is incorperated into the calculation. [INPUTS] Lower and Upper Limits that the return value should be within. Returns: New calculated flatness value OR 0.0 if the path is empty! Definition at line 5394 of file paths.cpp. { // Check to see if this path is empty, if so then just return 0. if(UsedSlots == 0) return 2.0; // Check to see if we`ve been given suitable values to use! if(LowerLimit < 1.0) { ERROR3("When I said give me a lower limit, I meant one larger than 1!"); LowerLimit = 2.0; } if(UpperLimit < 1.0 || UpperLimit < LowerLimit) { ERROR3("When I said give me an Upper limit, I meant one larger than the Lower limit!"); UpperLimit = 375.0; } if(DividerValue < 1.0) { ERROR3("When I said give me a Divider Value, I meant one greater than 1!"); DividerValue = 375.0; } // Set up the CalcFlatness value double CalcFlatness = 375.0; // Get the smallest dimesion, Width or Height. DocRect drBounds = GetBoundingRect(); double Smallest = drBounds.Height() < drBounds.Width() ? (double)drBounds.Height() : (double)drBounds.Width(); // now make the flatness value equal to the smallest dimesion divided by the passed in DividerValue! CalcFlatness = Smallest / DividerValue; // Check to see if we`re within the specified limits if(LowerLimit > CalcFlatness) CalcFlatness = LowerLimit; if(UpperLimit < CalcFlatness) CalcFlatness = UpperLimit; TRACEUSER( "MarkH", _T("Calculated Flatness = %lf\n"),CalcFlatness); // Return the new calculated flatness value! return CalcFlatness; }

BOOL Path::ChangeStartElement (  INT32  StartIndex  )

This will rotate the path so that the element that was at StartIndex is now at index 0. You should only call this for closed paths that don't contain subpaths. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/11/94 Parameters: StartIndex  - The index to the element in the path that you want to be the start [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise Errors: In debug builds, an error is given if the last coord != first coord Definition at line 9141 of file paths.cpp. { if (StartIndex < 1 || StartIndex >= UsedSlots) { ERROR3_PF(("StartIndex out of range : %ld",StartIndex)); return FALSE; } DocCoord* pCoords = GetCoordArray(); PathVerb* pVerbs = GetVerbArray(); PathFlags* pFlags = GetFlagArray(); ERROR3IF(pCoords[0] != pCoords[UsedSlots-1],"Not closed because first coord != last coord"); // Make sure the last verb has the PT_CLOSEFIGURE flag cleared pVerbs[UsedSlots-1] = pVerbs[UsedSlots-1] & ~PT_CLOSEFIGURE; // Delete the MoveTo CurrentPos = 0; DeleteElement(); ERROR3IF(UnUsedSlots < 1,"DeleteElement() didn't leave me any unused slots"); if (UnUsedSlots < 1) return FALSE; // Rotate the element at StartIndex to index 0 RotateElementsLeft(0,UsedSlots-1,StartIndex-1); // We need a duplicate element type & verb to finish the path off, so copy on end of arrays pCoords[UsedSlots] = pCoords[0]; pVerbs [UsedSlots] = pVerbs [0] | PT_CLOSEFIGURE; // Make sure last verb has also got this flag set pFlags [UsedSlots] = pFlags [0]; // The first element is always a MoveTo pVerbs[0] = PT_MOVETO; // Update the path vars. UsedSlots++; UnUsedSlots--; return TRUE; }

void Path::ClearNeedToRender (   )

Sets the NeedToRender flags on all of the path elements to FALSE. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 24/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 9545 of file paths.cpp. { PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); for (INT32 loop = GetNumCoords()-1; loop >= 0 ; loop--) { Flags[loop].NeedToRender = FALSE; } }

BOOL Path::ClearPath (  BOOL  compress  )

Empties the path of all its entries. If compress is TRUE the routine will try to free up excessive amounts of unused memory left over at the end. It also now resets CurrentPos back to zero. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/11/94 Parameters: compress  - a boolean, to describe whether to compress the paths memory [INPUTS] or not. Returns: TRUE if it was able to free up the unused parts of the path, FALSE if there was a memory de-alloc error See also: Path::Compact(); Definition at line 2438 of file paths.cpp. { if (UsedSlots>0) { // reset the path definitions UnUsedSlots+=UsedSlots; UsedSlots=0; CurrentPos=0; // make sure we compress memory if necessary if (compress) Compact(); // ignore any error coming from here } return TRUE; }

BOOL Path::ClearPath (   )

Empties the path of all its entries and tries to free up excessive amounts of unused memory left over at the end. It does keep some memory though, ready for a new path to be put into it. It also now resets CurrentPos back to zero. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 16/02/94 Returns: TRUE if it was able to free up the unused parts of the path, FALSE if there was a memory de-alloc error Definition at line 2408 of file paths.cpp. { if (UsedSlots==0) return TRUE; BOOL ok = DeleteSection(0,UsedSlots); if (ok) CurrentPos=0; return ok; }

void Path::ClearSubSelection (   )

Goes through the path and sets all the IsSelected flags to FALSE, clearing any selected control points in the path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/4/94 Definition at line 3572 of file paths.cpp. { // We need to find all the selected control points in the path and de-select them PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); for (INT32 i=0; i<UsedSlots; i++) Flags[i].IsSelected = FALSE; }

INT32 Path::ClipPathToPath (  const Path &  Src, Path *const   pDest, UINT32  Flags, UINT32  Tolerance = 100, double  SrcFlatness = 750.0, double  ClipFlatness = 750.0 )

This is an interface to Gavin's ClipPathToPath. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/95 Parameters: Src  = source path to clip [INPUTS] pDest = ptr to path to place the result in Flags = Gavin's ClipPathToPath flags (see below) Tolerence = Two points closer than this value are considered the same point SrcFlatness = the value used to flatten the src path ClipPath = the value used to flatten the clip path If  returned a value >=0, *pDest contains the resultant path. [OUTPUTS] Returns: The length of the resultant path in pDest, or -1 for an error. 'this' path is used as the clip path. Src is clipped to this path and the result is placed in pDest. 'Flags' controls how Src will be clipped to this path (taken from gclip.h - complaints go to Gavin) CLIPPING_STYLE - Clip style 001 - Source AND NOT Clip (subtract Clip from Source) 010 - Source AND Clip (Intersection) 011 - Source 100 - NOT Source AND Clip (subtract Source from Clip) 101 - Source EOR Clip 110 - Clip 111 - Source OR Clip (Union) If stroked then 000 - Source AND Clip (Intersection) ??? - Source AND NOT Clip CLIPPING_SOURCE_WINDING - Source path winding. CLIPPING_CLIP_WINDING - Clip path winding. CLIPPING_IS_STROKED - Source is stroked, not filled CLIPPING_IS_CLOSED - Source path is to be closed (only applicable if stroked). NOTE: The path placed in pDest will not have its flags array initialised. If you require this (e.g. the path is part of a NodePath and is going in the tree) call Path::InitialiseFlags() on pDest. If you don't, the path won't be editable via the bezier tool. Definition at line 5483 of file paths.cpp. { ERROR2IF(pDest == NULL,-1,"pDest == NULL"); // We need a temp path to place the result in (return -1 if it fails to initialise) Path Output; if (!Output.Initialise()) return -1; // Mark Howitt - 1/9/00 // Guessing is not good practice. The major problem in this function is that we need // to allocate memory before we know how much to allocate!!! This results in more memory than needed being used // and also the risk of under estimating leading to failure! // The way to fix this is get Gavin to do the allocation for us and then return the amount. This is currently the // way the contouring code works which results in no guessing and exact memory allocation. NO WASTE! // To quickly fix this problem I`m going to make it so that if it comes back with buffer overflow, we double the // allocation and try again. If this fails after 5 times then return -1 and error2 with failure. This is still not // very good but will fix a majority of the bugs we are seeing. MUST BE REPLACED!!!!! // Try and guess how big the destination path's buffers will have to be in order to take the result. INT32 NewSize = ((UsedSlots + Src.UsedSlots)*2)+1000; // Make sure the destination path is big enough if (!Output.MakeSpaceInPath(NewSize)) return -1; // Set up the params for ClipPathToPath, Gavin-style! PPOINT SPoints,CPoints,OPoints ; PBYTE STypes ,CTypes ,OTypes ; UINT32 SLength,CLength,OLength ; if ( (Flags & 7)==6 && !(Flags & 0x40) ) { SPoints = NULL; STypes = NULL; SLength = 0; } else { SPoints = (PPOINT) Src.GetCoordArray(); STypes = (PBYTE) Src.GetVerbArray(); SLength = Src.UsedSlots; } if ( (Flags & 7)==3 && !(Flags & 0x40) ) { CPoints = NULL; CTypes = NULL; CLength = 0; } else { CPoints = (PPOINT) GetCoordArray(); CTypes = (PBYTE) GetVerbArray(); CLength = UsedSlots; } OPoints = (PPOINT) Output.GetCoordArray(); OTypes = (PBYTE) Output.GetVerbArray(); OLength = NewSize; INT32 len = -2; INT32 Passes = 0; // Mark Howitt 1/9/00 // New loop to help fix under allocation bugs. NEEDS REPLACING WITH BETTER CODE!!! See above! while(len == -2 && Passes++ < 10) { len = ::ClipPathToPath( SPoints,STypes,SLength,SrcFlatness, CPoints,CTypes,CLength,ClipFlatness, Flags,Tolerance, OPoints,OTypes,OLength-10); // -10 to safe guard against possible minor buffer overflow if(len == -1) return -1; else if(len == -2) { // Ok, we under estimated so double it and reset the output path variables! OLength <<= 1; if (!Output.EnsureVolume(OLength)) return -1; Output.ClearPath(); OPoints = (PPOINT) Output.GetCoordArray(); OTypes = (PBYTE) Output.GetVerbArray(); } } // If we get here with len == -2 then we failed in 5 attempts to allocate enough space! if(len < 0) return -1; // Clear pDest and make sure there's enough space in pDest for the result pDest->ClearPath(); if (!pDest->MakeSpaceInPath(len)) return -1; // Copy the resultant path into it. if (!pDest->MergeTwoPaths(Output.GetCoordArray(),Output.GetVerbArray(),Output.GetFlagArray(),len,Src.IsFilled)) return -1; // YES! we have a result return len; }

BOOL Path::CloneFrom (  const Path &  Other  )

Replace the data within this path with that of Other path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 26/10/94 Parameters: Other  = pointer to a path to copy data from [INPUTS] Returns TRUE if successful FALSE if unable in increase the size of this path to cope with all data in 'Other' Definition at line 7277 of file paths.cpp. { // Make space to copy all the data from the other path into this one INT32 SlotsToCopy = Other.UsedSlots; INT32 SlotsToAdd = SlotsToCopy-UsedSlots; if (SlotsToAdd>0) { if (!MakeSpaceAtEnd(SlotsToAdd)) return FALSE; } // We will need all the arrays from the other path DocCoord* SCoords = (DocCoord*) DescribeHandle(Other.CoordHandle); PathVerb* SVerbs = (PathVerb*) DescribeHandle(Other.VerbHandle); PathFlags* SFlags = (PathFlags*) DescribeHandle(Other.FlagsHandle); // Get the destination arrays DocCoord* DCoords = (DocCoord*) DescribeHandle(CoordHandle); PathVerb* DVerbs = (PathVerb*) DescribeHandle(VerbHandle); PathFlags* DFlags = (PathFlags*) DescribeHandle(FlagsHandle); // copy all arrays from the source to destination if (SlotsToCopy>0) { if (SCoords != NULL) memmove((void*)(DCoords), (void*)(SCoords), SlotsToCopy*sizeof(DocCoord)); if (SVerbs != NULL) memmove((void*)(DVerbs), (void*)(SVerbs), SlotsToCopy*sizeof(PathVerb)); if (SFlags != NULL) memmove((void*)(DFlags), (void*)(SFlags), SlotsToCopy*sizeof(PathFlags)); } // Now update the array variables UsedSlots += SlotsToAdd; UnUsedSlots -= SlotsToAdd; CurrentPos = UsedSlots; return TRUE; }

DocCoord Path::ClosestPointTo (  const double  t, const INT32  index )

This function returns the point at which the closest distance on the path occurs. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/94 Parameters: t  = closest distance parameter [INPUTS] index = closest distance path element index [OUTPUTS]  Returns: DocCoord, the closest point on the path Errors: Ensures the indexed path element is either a lineto or bezierto Definition at line 7004 of file paths.cpp. { // Get the coord list and verb list for this path instance DocCoord* Coords = GetCoordArray(); PathVerb* Verbs = GetVerbArray(); PathVerb Verb = Verbs[index] & ~PT_CLOSEFIGURE; if ((t==0) && (index==0)) return Coords[0]; ENSURE(UsedSlots>1, "Not enough elements in path"); ENSURE(index>=0, "invalid formal parameter: index"); ENSURE((Verb == PT_LINETO) || (Verb == PT_BEZIERTO), "Unable to find point on path. Index does not specify line or curve"); if (index<UsedSlots) { switch (Verb) { case PT_LINETO: return PathUtil::PointOnLine(t,&Coords[index-1]); break; case PT_BEZIERTO: return PathUtil::PointOnCurve(t,&Coords[index-1]); break; } } // code should not really get here! if it does, return the first element // of the curve return (Coords[0]); }

BOOL Path::ClosestSelectedEndpoint (  DocCoord  pos, INT32 *  position, double *  distance )

This function finds the closest selected line end to the cursor position passed in. If the path has no selected line ends, the function returns FALSE. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/94 Parameters: pos  - mouse position to be tested [INPUTS] position  - index to the point that was matched [OUTPUTS] unchanged if no match distance - distance between the specified point and the closest selected endpoint (unchanged if there are none) Returns: TRUE if a match was found, FALSE if not Definition at line 7213 of file paths.cpp. { // Get arrays for this path DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); PathFlags* PFlags = (PathFlags*) DescribeHandle(FlagsHandle); double nearest = 0; double tempdistance = 0; BOOL foundany = FALSE; // Scan from the end of the path to the start. We remember the last point in the subpath // and go back until we hit a MoveTo. then we look at both the elements, and if the // CloseFigure flag isn't set in the end element, the subpath must be open, in which // case we look at the endpoints and see if they are closer to pos than others. INT32 endpoint = UsedSlots-1; for (INT32 i=UsedSlots-1;i>=0;i--) { if (Verbs[i] == PT_MOVETO) { // only check the ends if CLOSEFIGURE is not set in the end verb if (!(Verbs[endpoint] & PT_CLOSEFIGURE)) { // first check the moveto tempdistance = Coords[i].Distance(pos); if ((PFlags[i].IsSelected) && (!foundany || (nearest>tempdistance))) { *position = i; nearest = tempdistance; foundany = TRUE; } // Now check the end point tempdistance = Coords[endpoint].Distance(pos); if ((PFlags[endpoint].IsSelected) && (!foundany || (nearest>tempdistance))) { *position = endpoint; nearest = tempdistance; foundany = TRUE; } } endpoint = i-1; } } return(foundany); }

BOOL Path::CloseSubPath (   )

To indicate that a path is closed with a line, you should call CloseSubPath with the Current Path Position indicator somewhere inside the sub-path that you want closed. This function will adjust the verb of the last line segment in the sub-path by adding the PT_CLOSEFIGURE element into as described in the NT Prog Reference guides for the PolyDraw() function (page 304 of book 4 at last count) The Current Path Position is left on the element at the end of the subpath. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: TRUE if it worked, FALSE if it fails (ie you tried to close a path that only had a PT_MOVETO element in it. Definition at line 2226 of file paths.cpp. { // need to search for either a MoveTo or the end of the path and insert a close // path just before it. We start from the position supplied PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // We are inside the path somewhere while (CurrentPos+1<UsedSlots) { if (Verbs[CurrentPos+1]==PT_MOVETO) { // go back one and close the path ENSURE( Verbs[CurrentPos]!=PT_MOVETO, "You can not close a path at a moveto" ); if (Verbs[CurrentPos]==PT_MOVETO) return FALSE; Verbs[CurrentPos] = Verbs[CurrentPos] | PT_CLOSEFIGURE; return TRUE; } CurrentPos++; } // Make sure we are in the path if (CurrentPos>=UsedSlots) CurrentPos = UsedSlots-1; // We are right at the end of the path, so change the last path element ENSURE( Verbs[CurrentPos]!=PT_MOVETO, "You can not close a path at a moveto" ); if (Verbs[CurrentPos]==PT_MOVETO) return FALSE; Verbs[CurrentPos] = Verbs[CurrentPos] | PT_CLOSEFIGURE; CurrentPos++; return TRUE; }

BOOL Path::Compact (   )

Removes any extraneous unused slots in a path. It will a maximum of 2n-1 slots free where n is the size of an allocation chunk when increasing the buffer (see Path::Initialise). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 17/11/94 Parameters: -  [INPUTS] Returns: FALSE if the path failed to compact Definition at line 4025 of file paths.cpp. { // Calculate the buffer reduction factor. INT32 reduction = ((UnUsedSlots / SlotAllocSize)-1)*SlotAllocSize; if (reduction>0) { // reduce the number of free slots NOW, incase m out of the n // following reductions fail. UnUsedSlots -= reduction; if ((DecreaseBlock(VerbHandle, sizeof(PathVerb)*reduction)==FALSE) || (DecreaseBlock(FlagsHandle, sizeof(PathFlags)*reduction)==FALSE) || (DecreaseBlock(CoordHandle, sizeof(DocCoord)*reduction)==FALSE) || (ExtraInfo!=NULL && ExtraInfo->DecreaseExtraBlocks(reduction)==FALSE)) { // Memory shrink failed, so pass that back to the person using the Path // The path should still be useable at this stage so long as all handles // are valid. return FALSE; } } return TRUE; }

INT32 Path::ComparePathToPath (  Path *  pComparePath, BOOL  QuickCheck = TRUE )

Compares athis path to a passed in path. It firswt does a quick check on the number of coords and if they are equal does a more thoughour check on the verb array and coord array. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> howitt Date: 05/12/00 Parameters: A  path to compare against. [INPUTS] A flag to say wether to return as soon as it finds a difference (Default TRUE) Returns: The difference in number of coords + or -. Definition at line 1066 of file paths.cpp. { // Setup a default return value. This is basically the negative value of this paths // number of coords! INT32 ThisPathLength = (INT32)GetNumCoords(); INT32 Difference = -ThisPathLength; // Only do any comparing if we`ve got valid pointers if(pComparePath) { // quick check first! if(ThisPathLength == pComparePath->GetNumCoords()) { // Get the Coord array and Verb array for both paths. DocCoord* SPoint = GetCoordArray(); DocCoord* CPoint = pComparePath->GetCoordArray(); PBYTE SVerb = GetVerbArray(); PBYTE CVerb = pComparePath->GetVerbArray(); // Reset the Difference Value Difference = 0; // Now go throught each element of the arrays calculating the differences for( INT32 i = 0; i < ThisPathLength; i++) { // If either the points OR verbs are different then increment the Diff counter if(SPoint[i] != CPoint[i] || SVerb[i] != CVerb[i]) { Difference++; if(QuickCheck) break; } } } else { // Ok! there`s different so calcualte the difference Difference = ThisPathLength - (INT32)pComparePath->GetNumCoords(); } } // return the Differance return Difference; }

BOOL Path::ComplexJoin (  Path *  Other, INT32 *  OtherStartSlot, BOOL *  IsOtherReversed )

Tries to Join the New Path (must be simple) to a complex path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/94 Parameters: Other  - The New path that needs Joining in [INPUTS] OtherStartSlot  - The Slot number in the combined path where the path [OUTPUTS] Other starts. IsOtherReversed - TRUE if the 'Other' path was reversed during the joining process. FALSE if it was not Returns: TRUE if it worked, FALSE if it failed Definition at line 6412 of file paths.cpp. { // We have not reversed the other path yet *IsOtherReversed = FALSE; // Do we need to reverse any elements of this path INT32 StartSlot = 0; INT32 NumSlots = 0; INT32 JoinStart = 0; INT32 JoinLen = 0; BOOL JoinedAtStart = FALSE; BOOL JoinFound = FALSE; DocCoord* OtherCoords = (DocCoord*) DescribeHandle(Other->CoordHandle); // Find out if we need to reverse this path to help with the joining if (FindJoinedSubPathInfo(OtherCoords[0], &StartSlot, &NumSlots, &JoinedAtStart)) { // We found a join JoinFound = TRUE; JoinStart = StartSlot; JoinLen = NumSlots; // Maybe need to reverse this path if (JoinedAtStart) ReverseSection(StartSlot, NumSlots); } // And check to see if the other end needs checking as well. if (FindJoinedSubPathInfo(OtherCoords[Other->UsedSlots-1], &StartSlot, &NumSlots, &JoinedAtStart)) { // We found a join JoinFound = TRUE; JoinStart = StartSlot; JoinLen = NumSlots; // Reverse the joining path always Other->Reverse(); // We have reversed the other path *IsOtherReversed = TRUE; // and maybe reverse this path if (JoinedAtStart) ReverseSection(StartSlot, NumSlots); } // If we found a join then everything is fabby if (JoinFound) { // Make sure that there is room in the path to copy one of the sub-paths CurrentPos = UsedSlots; if (!MakeSpaceInPath(JoinLen)) return FALSE; // copy the sub path if (!InsertSectionAtEnd(this, JoinStart, JoinLen)) return FALSE; // delete the original version of the sub path DeleteSection(JoinStart, JoinLen); // Make sure that there is enough room for the new path CurrentPos = UsedSlots; if (!MakeSpaceInPath(Other->UsedSlots-1)) return FALSE; // copy the new path *OtherStartSlot = UsedSlots-1; if (!InsertSectionAtEnd(Other, 1, Other->UsedSlots-1)) return FALSE; } else { // We did not find a join return FALSE; } // See if we can close anything TryToClose(); // Must have worked, so Move the insertion point to the end and return happy CurrentPos = UsedSlots; return TRUE; }

BOOL Path::ComplexToSameComplexJoin (  Path *  Other, INT32 *  OtherStartSlot, BOOL *  IsOtherReversed )

This path is assumed to be complex and Other is assumed to be a simple path. The start and end point of the Simple Path must be the same as the start or end point of one of the sub paths of this complex path. The function Moves the two sub paths that are touched by the simple path to the end of the path, and inserts the simple path between them. This means that the two touched sub-paths and the new simple path are combined into a single sub path. This may also mean that this complex path is no longer complex. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/94 Parameters: Other  - The path to Join with this complex path. [INPUTS] OtherStartSlot  - The Slot number in the combined path where the path [OUTPUTS] Other starts. IsOtherReversed - TRUE if the 'Other' path was reversed during the joining process. FALSE if it was not Definition at line 6520 of file paths.cpp. { INT32 BackStartSlot, BackNumSlots; INT32 FrontStartSlot, FrontNumSlots; BOOL FrontJoinedAtStart, BackJoinedAtStart; // We have not reversed the other path yet *IsOtherReversed = FALSE; // Get a few arrays DocCoord* OtherCoords = (DocCoord*) DescribeHandle(Other->CoordHandle); // First we have to gather data about the subpaths we are joined to if (!FindJoinedSubPathInfo(OtherCoords[0], &FrontStartSlot, &FrontNumSlots, &FrontJoinedAtStart)) return FALSE; // And the other sub path, Fail if we there is no intersection if (!FindJoinedSubPathInfo(OtherCoords[Other->UsedSlots-1], &BackStartSlot, &BackNumSlots, &BackJoinedAtStart)) return FALSE; // If this was trying to join a sub path to the other end of the same sub path // then we need to use a different function if (FrontStartSlot == BackStartSlot) return ComplexJoin(Other, OtherStartSlot, IsOtherReversed); // Build a path to store the combined paths in Path InsertPath; InsertPath.Initialise(FrontNumSlots+BackNumSlots+Other->UsedSlots); // Reverse the first subpath if we need to if (FrontJoinedAtStart) ReverseSection(FrontStartSlot, FrontNumSlots); // Reverse the Second subpath if we need to if (!BackJoinedAtStart) ReverseSection(BackStartSlot, BackNumSlots); // Make copys of all the path sections // The path joined to the start of the new path if (!InsertPath.InsertSectionAtEnd(this, FrontStartSlot, FrontNumSlots)) return FALSE; // followed by the new path *OtherStartSlot = InsertPath.UsedSlots-1; if (!InsertPath.InsertSectionAtEnd(Other, 1, Other->UsedSlots-1)) return FALSE; // followed by the path joined to the end of the new path if (!InsertPath.InsertSectionAtEnd(this, BackStartSlot+1, BackNumSlots-1)) return FALSE; // Get rid of the original sub-path DeleteSection(FrontStartSlot, FrontNumSlots); // Go find the Other Coords array again as it may have moved OtherCoords = (DocCoord*) DescribeHandle(Other->CoordHandle); // Find the location of the Second path again, as deleting the first path may have moved it if (!FindJoinedSubPathInfo(OtherCoords[Other->UsedSlots-1], &BackStartSlot, &BackNumSlots, &BackJoinedAtStart)) return FALSE; // Get rid of the second sub-path DeleteSection(BackStartSlot, BackNumSlots); // Make enough space in the path to store a copy of the two subpaths and the new path CurrentPos = UsedSlots; if (!MakeSpaceInPath(InsertPath.UsedSlots)) return FALSE; // copy the Insert Path to the end of the original path *OtherStartSlot += UsedSlots; if (!InsertSectionAtEnd(&InsertPath, 0, InsertPath.UsedSlots)) return FALSE; // Must have worked, so return happy CurrentPos = UsedSlots; return TRUE; }

DocCoord Path::ConvSqrDistToCoord (  const double  sqrdist  )

Finds the coordinate which is dist units along 'this' path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 1/11/94 Parameters: sqrdist  = squared distance along the path [INPUTS] [OUTPUTS]  Returns: a doccoord which is dist units along the path Definition at line 7971 of file paths.cpp. { INT32 Index; double mu = DistReparameterise(sqrdist, &Index); return ClosestPointTo(mu, Index); }

BOOL Path::CopyPathDataFrom (  DocCoord *  Coords, PathVerb *  Verbs, INT32  NumCoords, BOOL  Filled = FALSE, BOOL  Stroked = TRUE )

Copy the specified coords and verbs to this path. The path's flags will be the defaults as specified in the constructors. You must already have initialised this path by calling Path::Initialise(). Pass it an Initial size big enough to hold the path you want to copy. BOOL Path::CopyPathDataFrom( DocCoord* Coords, PathVerb* Verbs, INT32 NumCoords, BOOL IsFilled = FALSE, BOOL IsStroked = TRUE) Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 03/02/94 Parameters: Coords  - The path coords you want to copy [INPUTS] Verbs - The verbs you want to copy NumCoords - The number of coords to copy IsFilled - Is the path filled ? IsStroked - Is the path stroked ? Returns: TRUE if it worked, FALSE otherwise. Can fail if there is not enough space in the path to copy the data into. Definition at line 452 of file paths.cpp. { // Check that this path has enough slots if (UsedSlots+UnUsedSlots < NumCoords) { // There is not enough space in this path to copy the SrcPath to TRACEUSER( "Simon", _T("Not enough space in path to copy data to\n") ); return FALSE; } // copy the data across memcpy((void*)DescribeHandle(VerbHandle), (void*)Verbs, (size_t)NumCoords*sizeof(PathVerb)); memcpy((void*)DescribeHandle(CoordHandle), (void*)Coords, (size_t)NumCoords*sizeof(DocCoord)); // Every point on the path has the default constructor flags set PathFlags f; PathFlags* pFlags = (PathFlags*) DescribeHandle(FlagsHandle); for (INT32 i = 0; i< NumCoords; i++) { pFlags[i] = f; } // Set the vars that tell us how much mem has been used UnUsedSlots = (UsedSlots+UnUsedSlots) - NumCoords; UsedSlots = NumCoords; // Keep track of the current path position CurrentPos = 0; IsFilled = Filled; IsStroked = Stroked; // Well, as far as I can tell its worked return TRUE; }

BOOL Path::CopyPathDataFrom (  Path *  SrcPath  )

Copy the coords, verbs and flags from the SrcPath to this path. You must already have initialised this path by calling Path::Initialise(). Pass it an Initial size big enough the hold the path you want to copy. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 28/01/94 Parameters: SrcPath  - The path that you want to copy data from [INPUTS] Returns: TRUE if it worked, FALSE otherwise. Can fail if there is not enough space in the path to copy SrcPaths data into. Definition at line 383 of file paths.cpp. { // Ensure that a non-null path is being used. if ( SrcPath == NULL ) return FALSE; // Find out how much space we need to alloc in this new path INT32 NumCoords = SrcPath->GetNumCoords(); if (UsedSlots+UnUsedSlots < NumCoords) { // There is not enough space in this path to copy the SrcPath to //if (IsUserName("Rik")) TRACE( _T("Not enough space in path to copy data to\n") ); ERROR3 ("Not enough space in path to copy data to!"); return FALSE; } // copy the data across memcpy((void*)DescribeHandle(VerbHandle), (void*)DescribeHandle(SrcPath->VerbHandle), (size_t)NumCoords*sizeof(PathVerb)); memcpy((void*)DescribeHandle(CoordHandle), (void*)DescribeHandle(SrcPath->CoordHandle), (size_t)NumCoords*sizeof(DocCoord)); memcpy((void*)DescribeHandle(FlagsHandle), (void*)DescribeHandle(SrcPath->FlagsHandle), (size_t)NumCoords*sizeof(PathFlags)); // If the source path has extra info in it then we need to copy that too if (SrcPath->ExtraInfo != NULL) ExtraInfo->CopyExtraInfo(SrcPath->ExtraInfo); // Set the vars that tell us how much mem has been used UnUsedSlots = (UsedSlots+UnUsedSlots) - NumCoords; UsedSlots = NumCoords; // copy any other flags of value IsFilled = SrcPath->IsFilled; IsStroked = SrcPath->IsStroked; // Keep track of the current path position CurrentPos = 0; // Well, as far as I can tell its worked return TRUE; }

BOOL Path::CopySectionFrom (  const Path &  Other, INT32  StartIndex, INT32  NumToCopy )

Copies a specified section from a path to the end of this one. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 22/7/94 Parameters: Other  - A reference to another path to merge with this one [INPUTS] Returns: TRUE if the merge was a success, FALSE if it failed (lack of memory) Definition at line 6017 of file paths.cpp. { return MergeSectionFrom(UsedSlots, Other, StartIndex, NumToCopy); }

BOOL Path::CopySectionTo (  Path *  Dest, INT32  StartIndex, INT32  NumToCopy )

Copies a specified section from this path to the end of another path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 08/09/94 Parameters: Dest  - A pointer to another path to add the data to [INPUTS] Returns: TRUE if the copy was a success, FALSE if it failed (lack of memory) Definition at line 6035 of file paths.cpp. { return MergeSectionTo(StartIndex, NumToCopy, Dest, Dest->UsedSlots); }

BOOL Path::CreateFlatPath (  const ProcessFlags &  PFlags, const double  flatness, Path *  pOutput )

Flatten a path. All curves within the path will be approximated by straight lines. pOutput may point at 'this' path ie a path can be flattened to itself. If the flattening fails for some reason, the output path will be unaffected even if you're flattening a path to itself. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/94 Parameters: PFlags  = process flags, to control the path processor function [INPUTS] (see classes ProcessPath and ProcessFlags) flatness = How flat the curves should be (around 64 is good) pOutput  = will contain the flattened path [OUTPUTS] Returns: BOOL = TRUE if the path was flattened successfully = FALSE then output path will be unaffected Definition at line 7885 of file paths.cpp. { // create a flattening object ProcessFlatten FlattenObj(flatness); // INT32 numcoords = pOutput->GetNumCoords(); // ok, generate a flattened path on the end of Output return FlattenObj.FlattenPath(PFlags, this, pOutput); }

BOOL Path::CreatePathFromDocRect (  DocRect *  pRect  )

Creates a filled path from a given DocRect. Author: Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/99 Parameters: BOOL  to say whether or not it was successful [OUTPUTS] Definition at line 506 of file paths.cpp. { DocCoord TopLeft(pRect->lo.x,pRect->hi.y); DocCoord TopRight(pRect->hi.x,pRect->hi.y); DocCoord BottomLeft(pRect->lo.x,pRect->lo.y); DocCoord BottomRight(pRect->hi.x,pRect->lo.y); InsertMoveTo(TopLeft); InsertLineTo(TopRight); InsertLineTo(BottomRight); InsertLineTo(BottomLeft); InsertLineTo(TopLeft); IsFilled = TRUE; return TRUE; }

BOOL Path::DeleteElement (   )

Deletes the element at the Current Path Position. May free some memory if the path gets to have too much unused space in the path. The Current Path Position points at the slot before the one being deleted. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Definition at line 2325 of file paths.cpp. { // Dereference the pointers PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); // Saftey Checks ENSURE( CurrentPos<UsedSlots, "PathPosition is off end of path in Path::DeleteElement" ); ENSURE( CurrentPos>=0, "PathPosition is off beginning of path in Path::DeleteElement" ); ENSURE( ((PathFlags*) DescribeHandle(FlagsHandle))[CurrentPos].IsEndPoint==TRUE, "Delete Element called when Path Position was not on an endpoint"); // Find the start of the element INT32 StartSlot = CurrentPos; // Work out how many slots we need to delete INT32 NumSlots; if ((Verbs[CurrentPos] & (~PT_CLOSEFIGURE)) == PT_BEZIERTO) { NumSlots = 3; StartSlot -= 2; } else { NumSlots = 1; } // Delete the element BOOL RetVal = DeleteSection(StartSlot, NumSlots); // tidy up the Current Path Position CurrentPos = StartSlot-1; if (CurrentPos<0) CurrentPos = 0; return RetVal; }

BOOL Path::DeleteFromElement (  INT32  ElementNum  )

Deletes all the elements in the path from ElementNum to the end of the path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 13/4/94 Parameters: ElementNum  - the number of the element to start deleting from. [INPUTS] Returns: TRUE if the deletion was a success Definition at line 2378 of file paths.cpp. { // Find out how many slots there are from ElementNum to the end INT32 SlotsToDelete = UsedSlots-ElementNum; // go and delete the end of the path BOOL RetVal = DeleteSection(ElementNum, SlotsToDelete); // Set the current Path position to just after the path, ready for further additions CurrentPos = UsedSlots; return RetVal; }

BOOL Path::DeleteSection (  INT32  StartSlot, INT32  NumSlots )

Deletes sections out of the middle of the path. Used by DeleteElement and for Deleting sub paths etc. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/94 Parameters: StartSlot  - The slot number to start deleting from [INPUTS] NumSlots - The number of slots to delete Returns: TRUE if it worked, FALSE if it failed Definition at line 2277 of file paths.cpp. { // Saftey Checks ENSURE( StartSlot<UsedSlots, "PathPosition is off end of path in Path::DeleteElement" ); ENSURE( StartSlot>=0, "PathPosition is off beginning of path in Path::DeleteElement" ); ENSURE( NumSlots>0, "Trying to delete Zero slots from the path!" ); if (NumSlots==0) return TRUE; // Find out how much memory to move about and adjust the element counters INT32 SlotsToMove = UsedSlots-StartSlot-NumSlots; // and move it all about if we need to if (SlotsToMove>0) { // Dereference the pointers PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); memmove((void*)(&Verbs[StartSlot]), (void*)(&Verbs[StartSlot+NumSlots]), SlotsToMove*sizeof(PathVerb)); memmove((void*)(&Flags[StartSlot]), (void*)(&Flags[StartSlot+NumSlots]), SlotsToMove*sizeof(PathFlags)); memmove((void*)(&Coords[StartSlot]), (void*)(&Coords[StartSlot+NumSlots]), SlotsToMove*sizeof(DocCoord)); if (ExtraInfo != NULL) ExtraInfo->ShiftDownExtraInfo(StartSlot, NumSlots, SlotsToMove); } // Update the path details UsedSlots -= NumSlots; UnUsedSlots += NumSlots; return Compact(); }

BOOL Path::DistanceTo (  DocCoord  Coord, double *  dist, double  dFlatness = 64.0 )

This function takes as input a coordinate (usually a mouse click point). It will calculate the closest point on the path to this coordinate and return the distance along the path from its start point to this coordinate. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 14/06/95 Parameters: Coord  - A coordinate [INPUTS] distance  - a 72000 inch measurement [OUTPUTS] Returns: TRUE if distance was calculated FALSE if not Definition at line 9677 of file paths.cpp. { Path TempPath; INT32 SplitAt; INT32 NumNewEl; if (!TempPath.Initialise(GetNumCoords(),24)) return FALSE; if (!TempPath.CopyPathDataFrom(this)) return FALSE; if (!TempPath.SplitAtPoint(Coord, &SplitAt, &NumNewEl)) return FALSE; ProcessLength LengthObj(dFlatness); if (!LengthObj.PathLength(&TempPath, dist, SplitAt)) return FALSE; return TRUE; }

BOOL Path::DistanceTo (  INT32  index, double  t, double *  distance, double  dFlatness = 64.0 )

This function takes a description of a point lying on a path. The point is described by (i,t) where i is the index of the element t lies in, and t is a parametric variable 0<=t<=1. The function calculates the distance along this path to the point described by (i,t). This routine complements SqrDistanceToPoint() which calculates the pair (i,t) for a given coordinate close to the path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 14/06/95 Parameters: index  = an index into the path arrays describing the first coordinate [INPUTS] of an element. t = a parameter 0..1 describing a point on the path element distance-  a 72000 inch measurement [OUTPUTS] Returns: TRUE if distance was calculated FALSE if not See also: SqrDistanceToPoint Definition at line 9579 of file paths.cpp. { PathVerb* InVerbs = GetVerbArray(); PathVerb vb = InVerbs[index] & ~PT_CLOSEFIGURE; DocCoord* InCoords = GetCoordArray(); double LoDist = 0.0; double HiDist = 0.0; if (GetNumCoords()==0) return FALSE; // If t is near 1 then we can skip forward to the next segment // this is to avoid math problems with splitting beziers near their ends INT32 IndexEP = index; if (t>=0.99995 && vb==PT_BEZIERTO) { // Move up to next complete segment if (IndexEP != GetNumCoords()-1) { if (!FindNextEndPoint(&IndexEP)) return FALSE; t = 0.0; } } // find the length to the path up to the start of the nearest element // specified by index. ProcessLength LengthObj(dFlatness); if (!LengthObj.PathLength(this, &LoDist, IndexEP-1)) return FALSE; // ok we need to evaluate the distance along the // path element i at parameter 0<=t<1 switch (vb) { case PT_LINETO: { double TotalLength = InCoords[index-1].Distance(InCoords[index]); HiDist = TotalLength * t; } break; case PT_BEZIERTO: { if ((t>0.00005) && (t<0.99995)) // avoids problems at the extremes. { UINT32 NumElements; PathVerb NewVerbs[6]; DocCoord NewCoords[6]; Path TempPath; BOOL ok = TempPath.Initialise(12,12); if (ok) ok = PathUtil::SplitCurve(t, &InCoords[index-1], &NumElements, NewVerbs, NewCoords); if (ok) ok = TempPath.CopyPathDataFrom(NewCoords, NewVerbs, 3); if (ok) { TempPath.SetPathPosition(0); ok = TempPath.InsertMoveTo(InCoords[index-1]); } if (ok) { ProcessLength LengthObj2(64); ok = LengthObj2.PathLength(&TempPath, &HiDist); } if (!ok) return FALSE; } } break; default: ERROR3("Unable to find point on path. Index does not specify line or curve"); break; } *distance = LoDist+HiDist; return TRUE; }

double Path::DistReparameterise (  const double  sqrdist, INT32 *  Element )

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 1/11/94 Parameters: sqrdist  = squared distance along the path [INPUTS] Element  = index of element which bounds dist [OUTPUTS] as a half open interval, (El.Plo < dist <= El.Phi) Returns: a double, being the parameter along the returned element, which is dist units along the whole path. See also: ConvDistToCoord() ClosestPointTo() Definition at line 7997 of file paths.cpp. { // set up a distance object and call its processor double Acc = 64; ProcessDistance DistanceObj(Acc); return DistanceObj.PathDistance(sqrdist, this, Element); }

void Path::DrawBlob (  RenderRegion *  pRender, const DocCoord &  Coord, BOOL  DrawSelected )

Draws a single blob, either selected or un-selected. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/02/94 Parameters: pRender  - Render region to draw to [INPUTS] Coord - the coord that the blob should be centred on DrawSelected - Draw a selected blob or an unselected blob Definition at line 3486 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) if (DrawSelected) { // Set the colours to draw the selected blob colours pRender->SetLineColour(COLOUR_BEZIERBLOB); pRender->SetFillColour(COLOUR_TRANS); // Draw a Selected blob to the render region pRender->DrawBlob(Coord, BT_SELECTED); } else { // Draw an UnSelected Blob to the render region // Set the colours back // pRender->SetLineColour(COLOUR_UNSELECTEDBLOB); pRender->SetLineColour(COLOUR_NONE); pRender->SetFillColour(COLOUR_UNSELECTEDBLOB); pRender->DrawBlob(Coord, BT_UNSELECTED); } #endif }

void Path::DrawControlBlob (  RenderRegion *  pRender, const DocCoord &  Coord )

Draws a blob for a Bezier control point. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/02/94 Parameters: pRender  - Render region to draw to [INPUTS] Coord - the coord that the blob should be centred on Definition at line 3523 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Draw a Control blob to the render region // pRender->SetLineColour(COLOUR_BEZIERBLOB); pRender->SetLineColour(COLOUR_NONE); // A line colour leads to bad rendering probs // on some video drivers. Best solution is not // to use one. pRender->SetFillColour(COLOUR_BEZIERBLOB); pRender->DrawBlob(Coord, BT_UNSELECTED); #endif }

void Path::DrawControlLine (  RenderRegion *  pRender, const DocCoord &  Start, const DocCoord &  End )

Draws a line from the Bezier control point to its endpoint. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/02/94 Parameters: pRender  - Render region to draw to [INPUTS] Coord - the coord that the blob should be centred on Definition at line 3549 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Draw a line to the render region pRender->SetLineColour(COLOUR_BEZIERLINE); pRender->DrawLine( Start, End ); #endif }

void Path::DumpPath (   )

Dumps the whole path out to the debug terminal. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 01/02/94 Definition at line 2841 of file paths.cpp. { #ifdef _DEBUG TRACE( _T("\nStarting Path Dump\n") ); TRACE( _T("[%d=PT_MOVETO, %d=PT_LINETO, %d=PT_BEZIERTO, %d=PT_CLOSEFIGURE]\n"), PT_MOVETO, PT_LINETO, PT_BEZIERTO, PT_CLOSEFIGURE ); TRACE( _T("UsedSlots=%ld, UnUsedSlots=%ld, CurrentPos=%ld\n"), UsedSlots, UnUsedSlots, CurrentPos ); TRACE( _T("Path Size in Bytes=%ld\n"), GetPathByteLength() ); TRACE( _T("\tVerb\tCoord\n") ); // de-reference the pointers PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // loop through all the coords, displaying their type and position for (INT32 i=0; i<UsedSlots; i++) { TRACE( _T("%d\t%d\t(%ld, %ld)"), i, Verbs[i], Coords[i].x, Coords[i].y ); if (Flags[i].IsSmooth) TRACE( _T("\tS")); else TRACE( _T("\t ")); if (Flags[i].IsRotate) TRACE( _T("R")); else TRACE( _T(" ")); if (Flags[i].IsEndPoint) TRACE( _T("E")); else TRACE( _T(" ")); if (Flags[i].IsSelected) TRACE( _T("(sel)")); TRACE( _T("\n")); } #endif }

void Path::EnsureSelection (  BOOL  UseStarts  )

Goes through the path ensuring that the selection status of the ends/starts of subpaths equal the selection state of the start/ends of that subpath Also selects/deselectes control points as appropiate. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 5/1/95 Parameters: UseStarts  - TRUE if the selection state of the start of subpaths should be used [INPUTS] the set the ends. FALSE if the end sel state should be used to set the starts Definition at line 3597 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // Ensure the selection state of the sub paths const INT32 NumCoords = GetNumCoords(); if (UseStarts) { INT32 Start = 0; INT32 End = 0; while (End < NumCoords-1) { FindEndElOfSubPath(&End); if (Verbs[End] & PT_CLOSEFIGURE) Flags[End].IsSelected = Flags[Start].IsSelected; Start = ++End; } } else { INT32 Close = NumCoords-1; INT32 Offset = NumCoords-1; while (Offset > -1) { FindStartOfSubPath(&Offset); if (Verbs[Close] & PT_CLOSEFIGURE) Flags[Offset].IsSelected = Flags[Close].IsSelected; Close = Offset-1; Offset = Close; } } // Now set the selection state of the control points.depending on their endpoints for (INT32 loop = 0; loop < NumCoords; loop++) { if (!Flags[loop].IsEndPoint) { ERROR3IF(loop==0, "Path started with a non-endpoint!"); ERROR3IF(Verbs[loop]!=PT_BEZIERTO, "Found an non-endpoint that wasn't a Bezier"); if (loop > 0) { if (Flags[loop-1].IsEndPoint) Flags[loop].IsSelected = Flags[loop-1].IsSelected; else Flags[loop].IsSelected = Flags[loop+1].IsSelected; } } } #endif }

BOOL Path::EnsureValid (  BOOL *  ChangesMade = NULL  )

Will attempt to make a path into a correct state. Checks are :- 1. All subpaths must start with a MoveTo 2. Consecutive MoveTos are removed 3. Zero element paths are unrepairable 4. MoveTos at the end of the path are removed 5. Should be three BezierTos in a row, only the last can be CloseFigure 6. A LineTo to the same location as the previous point is removed. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: Pointer  to a BOOL to return a result in (you can pass in NULL) [INPUTS] ChangesMade  will be TRUE if changes have been made to the path, FALSE if otherwise [OUTPUTS] Returns: TRUE for success, FALSE for failure (see below) ERRORs: FALSE is returned if the path was knackered OR if we encountered an error in trying to repair it. (SetError will have been called) Definition at line 9381 of file paths.cpp. { BOOL PathOK = FALSE; BOOL Temp; BOOL* pChangeFlag; pChangeFlag = (ChangesMade == NULL) ? &Temp : ChangesMade; *pChangeFlag = FALSE; while (!PathOK) { // Recache the path pointers as things may have moved PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); INT32 NumCoords = GetNumCoords(); // (3) Check for zero element path if (NumCoords == 0) { TRACEALL( _T("Empty path detected\n") ); Error::SetError(_R(IDE_INVALID_PATH)); return FALSE; } INT32 Counter = 0; while (Counter < NumCoords) { // Recache the path pointers in case the previous pass caused the arrays to move Verbs = (PathVerb*) DescribeHandle(VerbHandle); Coords = (DocCoord*) DescribeHandle(CoordHandle); Flags = (PathFlags*) DescribeHandle(FlagsHandle); // (1) Check that all subpaths start with a MoveTo if ( (Counter == 0) || (Verbs[Counter-1] & PT_CLOSEFIGURE) ) { if ((Verbs[Counter] & ~PT_CLOSEFIGURE) != PT_MOVETO) { // Insert a MoveTo at the same location as this point TRACEALL( _T("Inserting a MoveTo at %d\n"), Counter ); SetPathPosition(Counter); *pChangeFlag = TRUE; if (!InsertMoveTo(Coords[Counter])) return FALSE; break; } } // (2) Check there are no two consecutive MoveTos if ( (Counter != NumCoords-1) && (Verbs[Counter] == PT_MOVETO) ) { if (Verbs[Counter+1] == PT_MOVETO) { // Remove this MoveTo TRACEALL( _T("Removing a MoveTo at %d\n"), Counter ); SetPathPosition(Counter); *pChangeFlag = TRUE; if (!DeleteElement()) return FALSE; break; } } // (4) Check for trailing moveto at the end of a path if ( (Counter == NumCoords-1) && (Verbs[Counter] == PT_MOVETO) ) { // Remove this MoveTo TRACEALL( _T("Removing a MoveTo at the end (%d)\n"), Counter ); SetPathPosition(Counter); *pChangeFlag = TRUE; if (!DeleteElement()) return FALSE; break; } switch (Verbs[Counter] & ~PT_CLOSEFIGURE) { case PT_MOVETO: // MoveTos shouldn't have CloseFigures if (Verbs[Counter] != PT_MOVETO) { TRACEALL( _T("Detected a MoveTo+CloseFigure combination\n at %d"), Counter ); Verbs[Counter] = PT_MOVETO; *pChangeFlag = TRUE; } Counter++; break; case PT_LINETO: // If the coord of this is the same as the last (which must be a MoveTo) then delete it if ((Counter > 0) && (Coords[Counter] == Coords[Counter-1]) && (Verbs[Counter-1] == PT_MOVETO)) { TRACEALL( _T("Removing a LineTo at %d\n"), Counter ); SetPathPosition(Counter); *pChangeFlag = TRUE; // If the LineTo has the PT_CLOSEFIGURE bit set, ensure that the element // before it has this bit set. // If we don't then it is possible for shapes to become lines. if ((Verbs[Counter] & PT_CLOSEFIGURE) && (Verbs[Counter-1] != PT_MOVETO)) Verbs[Counter-1] |= PT_CLOSEFIGURE; // Delete the surplus LineTo element if (!DeleteElement()) return FALSE; Counter = NumCoords+1; // So we go round the entire path again } else { // This point should be endpoint if (!Flags[Counter].IsEndPoint) { TRACEALL( _T("Fixing endpoint status at %d\n"), Counter ); *pChangeFlag = TRUE; Flags[Counter].IsEndPoint = TRUE; } Counter ++; } break; case PT_BEZIERTO: // (5) Should be three BezierTos in a row, only the last can be CloseFigure if (Counter >= NumCoords-2) { TRACEALL( _T("Path ends with a short Bezier section\n") ); return FALSE; } if ( (Verbs[Counter] != PT_BEZIERTO) || (Verbs[Counter+1] != PT_BEZIERTO) || ((Verbs[Counter] & ~PT_CLOSEFIGURE) != PT_BEZIERTO) ) { TRACEALL( _T("InvalidBezier section detected starting at %d\n"), Counter ); return FALSE; } Flags[Counter++].IsEndPoint = FALSE; Flags[Counter++].IsEndPoint = FALSE; Flags[Counter++].IsEndPoint = TRUE; break; default: TRACEALL( _T("This path is *very* corrupt (Invalid verb found)\n") ); return FALSE; } if (Counter == NumCoords) PathOK = TRUE; } } return TRUE; }

BOOL Path::EnsureVolume (  INT32  NumSlots  )

This function ensures there are >= NumSlots in the path arrays. It may try to alter the size of the path arrays by increasing the number of unused slots to satisfy the request. It will never decrease the size of the arrays, if NumSlots < UsedSlots+UnusedSlots then the volume is automatically ensured. This allows path buffers to be resized ready for cloning. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 02/02/95 Parameters: NumSlots  - The minimum number of slots you need in the path arrays [INPUTS] Returns: TRUE if it was able to find the memory, FALSE if it failed Definition at line 4104 of file paths.cpp. { INT32 Slots=NumSlots-UsedSlots; if (Slots>0) return MakeSpaceAtEnd(Slots); return TRUE; }

void Path::ExpandRange (  INT32 *  start, INT32 *  end, INT32  num )

given the region [*start, *end] expand the region in both directions by num elements. The region will not be expanded beyond its outer limits described by the set {moveto,.....,endofsubpath}. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 3/11/94 Parameters: start  = pointer to an index holding the region start [INPUTS] end = pointer to an index holding the region end num = number of endpoints to expand the region by start  = will be updated [OUTPUTS] end = will be updated Definition at line 3784 of file paths.cpp. { ENSURE( (*start)<UsedSlots, "start index was not valid in ExpandRange" ); ENSURE( (*start)>=0, "start index less than zero in ExpandRange" ); ENSURE( (*end)<UsedSlots, "end index was not valid in ExpandRange" ); ENSURE( (*end)>=0, "end index less than zero in ExpandRange" ); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // clamp the indexes INT32 starti = *start; INT32 endi = *end; if (starti<0) starti = 0; if (endi<0) endi = 0; if (starti >= UsedSlots) starti = UsedSlots-1; if (endi >= UsedSlots) endi = UsedSlots-1; INT32 prev = starti; INT32 next = endi; while (num>0) { if (Verbs[starti] != PT_MOVETO) { if (FindPrev(&prev)) { if (Flags[prev].IsEndPoint) starti = prev; } } if (FindNextEndPoint(&next)) { if ((Flags[next].IsEndPoint) && (Verbs[next] != PT_MOVETO)) endi = next; } num-=1; } *start = starti; *end = endi; }

BOOL Path::ExternalArraysAdded (  const INT32  Added  )

A hidden function to adjust the number of elements in a path. This has been added by me as a last resort and should not be used by others. (Hence hidden from the documentation). It is required to cope with changes in the path data external to the path class. This occurs when doing really nasty things like moulding paths. BOOL Path::ExternalArraysAdded(const INT32 Added) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/94 Parameters: Added  = the number of new elements added to path arrays. [INPUTS] Returns: TRUE if the external arrays have been validated FALSE if the external array additions have been ignored Definition at line 5968 of file paths.cpp. { ERROR1IF(Added<1 || Added>UnUsedSlots, FALSE, "Path::ExternalArraysAdded() called with illegal additon"); UsedSlots+=Added; UnUsedSlots-=Added; return TRUE; }

BOOL Path::ExternalArraysReplaced (  const INT32  Size  )

A hidden function to adjust the number of elements in a path. This has been added by me as a last resort and should not be used by others. (Hence hidden from the documentation). BOOL Path::ExternalArraysReplaced(const INT32 Size) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/94 Parameters: Size  = the number of elements replaced in the path arrays [INPUTS] Returns: TRUE if the external arrays have been validated FALSE if the external array replacements have been ignored Definition at line 5994 of file paths.cpp. { ERROR1IF(Size<1 || Size>(UsedSlots+UnUsedSlots), FALSE, "Path::ExternalArraysCloned() called with an illegal clone"); UnUsedSlots = (UsedSlots+UnUsedSlots)-Size; UsedSlots = Size; return TRUE; }

void Path::FindEndElOfSubPath (  INT32 *  Index  )  const

Searches forwards until it finds the last element of the current sub-path. ie 0 1 2 3 {MT,CT,CT,CT} => Index = 3. See Also: FindEndOfSubPath (Note equivelent). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/09/94 Parameters: Index  - The position in the path to start looking from [INPUTS] Index  - the position of the last element of the subpath, ie the final bezier [OUTPUTS] control point, or the final line to etc. Definition at line 9235 of file paths.cpp. { ENSURE( (*Index)<UsedSlots, "Path position was not valid in FindEndOfSubPath" ); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); do { (*Index)++; } while (((*Index)<UsedSlots) && (Verbs[(*Index)]!=PT_MOVETO)); (*Index)--; }

void Path::FindEndOfSubPath (  INT32 *  Index  )  const

Searches forwards until it finds the end of the current sub-path. ie Index will point at the last element in the sub path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Parameters: Index  - The position in the path to start looking from [INPUTS] Index  - the position of the end of the subpath [OUTPUTS] Definition at line 653 of file paths.cpp. { ENSURE( (*Index)<UsedSlots, "Path position was not valid in FindEndOfSubPath" ); // I am already in a path, so start working backwards until I find the moveto PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); INT32 PrevIndex; do { PrevIndex = (*Index); FindNext(Index); } while (((*Index)<UsedSlots) && (Verbs[(*Index)]!=PT_MOVETO)); // So we have either fallen off the end of the world, or we are now on a MoveTo // either way we need the info from the previous position (*Index) = PrevIndex; }

void Path::FindEndOfSubPath (   )

Searches forwards until it finds the end of the current sub-path. ie pos will point at the last element in the sub path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Parameters: Pos  - The position in the path to start looking from [INPUTS] Pos  - the position of the end of the subpath [OUTPUTS] Definition at line 621 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "Path position was not valid in FindEndOfSubPath" ); // I am already in a path, so start working backwards until I find the moveto PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); INT32 PrevIndex; do { PrevIndex = CurrentPos; FindNext(); } while ((CurrentPos<UsedSlots) && (Verbs[CurrentPos]!=PT_MOVETO)); // So we have either fallen off the end of the world, or we are now on a MoveTo // either way we need the info from the previous position CurrentPos = PrevIndex; }

BOOL Path::FindJoinedSubPathInfo (  const DocCoord &  JoinCoord, INT32 *  Start, INT32 *  Length, BOOL *  JoinAtStart )

This function searchs the path, compareing JoinCoord with the start and end points of each of the Sub-paths in the path. If it is the same as one of the start or end points, then the output params are filled and TRUE is returned. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/94 Parameters: JoinCoord  - The Coord to compare with the start and end points od sub paths [INPUTS] Start  - Pointer to an INT32 to hold the starting slot number of the sub path [OUTPUTS] Length - The number of slots in the found Sub Path JoinAtStart - TRUE if JoinCoord intersected the start of the Sub Path, FALSE otherwise Returns: TRUE if an intersection was found, FALSE if not Definition at line 6619 of file paths.cpp. { // We will need all the arrays for both paths DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // walk through all the coords, looking for start and end points in SubPaths INT32 EndPos = UsedSlots-1; for (INT32 i=UsedSlots-1; i>=0; i--) { // See if we are at the start of a sub path if (Verbs[i] == PT_MOVETO) { // Set these to the start and end positions of the sub path *Start = i; *Length = EndPos - i + 1; // We are, so check the start and end of the sub path against the coord if (Coords[i] == JoinCoord) { // This is Joined at the start, so set the values and return *JoinAtStart = TRUE; return TRUE; } if (Coords[EndPos] == JoinCoord) { // This is Joined at the End, so set the values and return *JoinAtStart = FALSE; return TRUE; } EndPos = i-1; } } // We did not find an intersection with the subpaths, so fail return FALSE; }

BOOL Path::FindNearestPoint (  DocCoord  pos, UINT32  flags, INT32 *  position )

This function searches for a point in the path which is both selected and lies inside the largest blob bounding rectangle surrounding 'pos'. Points checked for are as follows... if ENDPOINTS is set check all selected endpoints in this path. if CONTROLPOINTS is set check all control points lying directly next to selected endpoints The rules are that control points are only enabled when a single end point is selected and hence a maximum of 2 control points will be checked. If any of these points are close enough to be clicked on, the function returns TRUE, with position holding the index to the point that was clicked. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/94 Parameters: pos  - mouse position to be tested [INPUTS] flags - POINTFLAG_ENDPOINTS = look at endpoints POINTFLAG_CONTROLPOINTS - look at control points (the flag POINTFLAG_ENDSFIRST has been removed and has no effect - the endpoints are always scanned first) Parameters: position  - index to the point that was matched [OUTPUTS] unchanged if no match Returns: TRUE if a match was found, FALSE if not Definition at line 6752 of file paths.cpp. { #if !defined(EXCLUDE_FROM_XARLIB) // If neither ENDPOINTS or CONTROLPOINTS flags are set, return FALSE since the caller // obviously doesn't want to look at anything! if (!(flags & (POINTFLAG_ENDPOINTS | POINTFLAG_CONTROLPOINTS))) return (FALSE); // Always set POINTFLAG_ENDSFIRST flags |= POINTFLAG_ENDSFIRST; // Get arrays for this path DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); PathFlags* PFlags = (PathFlags*) DescribeHandle(FlagsHandle); // Get a pointer to the DocView so we can do blob proximity checks DocView* pDocView = DocView::GetSelected(); ERROR3IF(pDocView == NULL, "Path::FindNearestPoint: Can't find selected DocView"); if (pDocView == NULL) return(FALSE); DocRect BlobRect; // INT32 numloops; // Now to calculate a rectangle around the pointer position which is // the same size as the biggest possible blob. We then go through the // path and see if any of the coordinates fall into that rectangle. // This is a very cunning reversal of the normal logic - go through the // path, find a blob rectangle for each point, then see if the pointer // coordinate falls inside it. The only problem with this method is that // it assumes that all blobs are the same size, but since this is only // for click detection, and we need a little bit of leeway, I think // it's all right. Anyway, the usual code for this also makes this assumption, // although it doesn't rely on it. OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), pos, BT_SELECTEDLARGEST, &BlobRect); // Now BlobRect holds a rectangle around the pointer position. // We have to first go through and look at the endpoints, counting them as we go INT32 EndCount = 0; INT32 EndIndex = 0; INT32 i; for (i=0; i<UsedSlots; i++) { // check to see if it's an endpoint, and if we want this kind of point if ((PFlags[i].IsEndPoint && (flags & POINTFLAG_ENDPOINTS))) { if (BlobRect.ContainsCoord(Coords[i])) { *position = i; return(TRUE); } } if (PFlags[i].IsEndPoint && PFlags[i].IsSelected && ((Verbs[i] & PT_CLOSEFIGURE) == 0)) { EndCount++; EndIndex = i; } } // Now we've scanned the path for endpoints, let's look at any adjacent control points // if EndCount == 1, EndIndex is the index of the selected enpoint, ie there is only one // selected endpoint and its control handles will be enabled. if ( (EndCount==1) && (flags & POINTFLAG_CONTROLPOINTS) ) { INT32 Index = FindPrevControlPoint(EndIndex); if (Index>=0) { // There is a previous control point, so look at it (and the one before it) if (BlobRect.ContainsCoord(Coords[Index])) { *position = Index; return TRUE; } if (BlobRect.ContainsCoord(Coords[Index-1])) { *position = Index-1; return TRUE; } } // Now look at the next control point (if it's there) Index = FindNextControlPoint(EndIndex); if (Index>=0) { // Look at the next one if (BlobRect.ContainsCoord(Coords[Index])) { *position = Index; return TRUE; } if (BlobRect.ContainsCoord(Coords[Index+1])) { *position = Index+1; return TRUE; } } } #endif return FALSE; }

BOOL Path::FindNext (  INT32 *  Index  )  const

Finds the next path element in this path. The position will become invalid if you try to search past the start of the path. This can be checked by using Pos->IsValid. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Parameters: Index  is a pointer to an index into the path to start from [INPUTS] Index  will point at the next element in the path [OUTPUTS] Returns: TRUE if valid next element found FALSE if there is no next element, Index is set to NumCoords See also: Path::FindPrev Definition at line 855 of file paths.cpp. { ENSURE( (*Index)<=UsedSlots, "Path position was not valid in FindNext" ); ENSURE( (*Index)>=0, "Path Position less than zero!" ); // de-reference the verb array PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // Move to the next path element if ((Verbs[(*Index)] & (~PT_CLOSEFIGURE))==PT_BEZIERTO) (*Index) += 3; else (*Index) ++; // Check to see if we fell off the end of the path if ((*Index)>=UsedSlots) { (*Index) = UsedSlots; return FALSE; } // we did it, so return happy return TRUE; }

BOOL Path::FindNext (  void   )

Finds the next path element in this path. The position will become invalid if you try to search past the start of the path. This can be checked by using Pos->IsValid. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 See also: Path::FindPrev Definition at line 733 of file paths.cpp. { ENSURE( CurrentPos<=UsedSlots, "Path position was not valid in FindNext" ); ENSURE( CurrentPos>=0, "Path Position less than zero!" ); // de-reference the verb array PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // Move to the next path element if ((Verbs[CurrentPos] & (~PT_CLOSEFIGURE))==PT_BEZIERTO) CurrentPos += 3; else CurrentPos ++; // Check to see if we fell off the end of the path if (CurrentPos>=UsedSlots) { CurrentPos = UsedSlots; return FALSE; } // we did it, so return happy return TRUE; }

INT32 Path::FindNextControlPoint (  INT32  Index  )

This routine will scan forwards from an endpoint to find the attached bezier control point. It takes account of closed and open paths and complex paths, and will wrap around the path if necessary. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/94 Parameters: Index  gives the endpoint whose next control point I want [INPUTS] -  [OUTPUTS] Returns: Index to the control point (or -1 if none) Errors: - See also: - Definition at line 3432 of file paths.cpp. { // DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); // PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // See if this is the end of a path (no more elements or next point is moveto) if (Index+1 == UsedSlots || Verbs[Index+1] == PT_MOVETO) { // This is the last element, so see if we should wrap around if (Verbs[Index] & PT_CLOSEFIGURE) { // The path is closed, so we have to scan backwards to find the start INT32 i=Index; FindStartOfSubPath(&i); // i points at start of subpath // return next control point if next element is a bezier, -1 otherwise if (Verbs[i+1] == PT_BEZIERTO) return i+1; return -1; } else { // Path is open, so no next control point return -1; } } else { // This element isn't the last in this subpath, so look at next element // if not bezier, return -1, otherwise return next element if (Verbs[Index+1] == PT_BEZIERTO) return Index+1; return -1; } return -1; }

BOOL Path::FindNextEndPoint (  INT32 *  index  )  const

Finds the next path endpoint in this path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 3/11/94 Parameters: Index  = pointer to a INT32 indicating where to start from [INPUTS] Outpus: Index = points to an index which is the next element Returns: TRUE if the next end point has been found FALSE if there are no more end points in this path See also: Path::FindPrevEndPoint Definition at line 774 of file paths.cpp. { ENSURE( (*index)<=UsedSlots, "Path position was not valid in FindNextEndPoint" ); ENSURE( (*index)>=0, "Path Position less than zero in FindNextEndPoint" ); // de-reference the verb array PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); (*index)++; if ((*index) >= UsedSlots) { ((*index) = UsedSlots-1); return FALSE; } if ((Verbs[(*index)] & (~PT_CLOSEFIGURE))==PT_BEZIERTO) (*index) += 2; return TRUE; }

BOOL Path::FindNextSelected (  INT32 *  Index  )

Searches the point set {*index, usedslots-1} for a selected end point and returns its index if found. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 01/09/94 Parameters: Index  - The position in the path to start looking from [INPUTS] Index  - the position of the next selected element [OUTPUTS] Returns: TRUE if there exists a selected point at or beyond index FALSE if there is no more selected points along the path Definition at line 9199 of file paths.cpp. { ENSURE( (*Index)<=UsedSlots, "Path position was not valid in FindNextSelected" ); ENSURE( (*Index)>=0, "Path Position less than zero in FindNextSelected" ); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); while ( ((*Index)<UsedSlots) && !( (Flags[(*Index)].IsSelected) && (Flags[*Index].IsEndPoint) ) ) (*Index)++; return ((*Index)<UsedSlots); }

INT32 Path::FindOppositeControlPoint (  INT32  ThisIndex  )

Given a bezier control point, this function returns the index of the control point that is opposite this one (with an endpoint between). This routine takes closed paths into account. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 18/8/94 Returns: The index of the control point opposite the indexed one (or -1) Definition at line 1219 of file paths.cpp. { // Get arrays of flags and verbs PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // If this isn't a control point, ensure! ENSURE(!Flags[ThisIndex].IsEndPoint,"Point is not a control point in FindOppositeControlPoint"); // First see if this is the first or second control point in a curve element. If the // previous point is an endpoint, then this is the first control point if (Flags[ThisIndex-1].IsEndPoint) { // if the previous endpoint is a moveto, we might have to wrap if (Verbs[ThisIndex-1] == PT_MOVETO) { INT32 i; for (i = ThisIndex;i<UsedSlots && Verbs[i]!=PT_MOVETO;i++); // ; deliberate i--; // Now i gives us the endpoint of the subpath // If the path is closed and the last point is a curve, return the opposite point // otherwise return -1 if ((Verbs[i] & PT_CLOSEFIGURE) && ((Verbs[i] & ~PT_CLOSEFIGURE)==PT_BEZIERTO)) return i-1; else return -1; } else { if ((Verbs[ThisIndex-1] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) return ThisIndex-2; else return -1; } } else { // This is the second control point. If the next point has the CloseFigure flag // set we'll have to scan back. Otherwise, return ThisIndex+2 unless the next element // isn't a curve, or there is no next element. if (Verbs[ThisIndex+1] & PT_CLOSEFIGURE) { // The path is closed - scan back for the moveto INT32 i; for (i=ThisIndex;Verbs[i] != PT_MOVETO;i--); // ; deliberate // Move to the next point - if it's a BezierTo we return it, otherwise return -1 if (Verbs[i+1] == PT_BEZIERTO) return i+1; else return -1; } else { // The path isn't closed here, so see if there's another element if (ThisIndex+2 >= UsedSlots || Verbs[ThisIndex+2] != PT_BEZIERTO) { // No next element so return -1 return -1; } else { // Next element is also a curve so return index of control point return ThisIndex+2; } } } }

BOOL Path::FindPrev (  INT32 *  index  )  const

Finds the previous path element in this path starting from the value (index). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 3/11/94 Parameters: Index  is a pointer to an index into the path to start from [INPUTS] Index  will point at the previous element in the path [OUTPUTS] Returns: TRUE if valid previous element found FALSE if there is no previous element See also: Path::FindNext Definition at line 948 of file paths.cpp. { ENSURE( (*index)<=UsedSlots, "Path position was not valid in FindPrev" ); ENSURE( (*index)>=0, "Path Position less than zero!" ); // de-reference the verb array PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // Move to the prev path element if ((*index)==UsedSlots) { // The current pos is at the end of the path, so move to the last element in the path (*index) --; } else { // see if we were now in the middle of a curve (*index)--; if ((Verbs[(*index)] & (~PT_CLOSEFIGURE))==PT_BEZIERTO) (*index) -= 2; } // Make sure we are still in bounds if ((*index)<0) { // we are not, so set the current pos back to the start and fail (*index) = 0; return FALSE; } // we are in the path, so succeed return TRUE; }

BOOL Path::FindPrev (   )

Finds the prev path element in this path starting the search from CurrentPos. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if valid previous element found FALSE if there is no previous element See also: Path::FindNext Definition at line 896 of file paths.cpp. { ENSURE( CurrentPos<=UsedSlots, "Path position was not valid in FindPrev" ); ENSURE( CurrentPos>=0, "Path Position less than zero!" ); // de-reference the verb array PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // Move to the prev path element if (CurrentPos==UsedSlots) { // The current pos is at the end of the path, so move to the last element in the path CurrentPos --; } else { // see if we were now in the middle of a curve CurrentPos--; if ((Verbs[CurrentPos] & (~PT_CLOSEFIGURE))==PT_BEZIERTO) CurrentPos -= 2; } // Make sure we are still in bounds if (CurrentPos<0) { // we are not, so set the current pos back to the start and fail CurrentPos = 0; return FALSE; } // we are in the path, so succeed return TRUE; }

INT32 Path::FindPrevControlPoint (  INT32  Index  )

This routine will scan back from an endpoint to find the attached bezier control point. It takes account of closed and open paths and complex paths, and will wrap around the path if necessary. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/94 Parameters: Index  gives the endpoint whose previous control point I want [INPUTS] -  [OUTPUTS] Returns: Index to the control point (or -1 if none) Errors: - See also: - Definition at line 3382 of file paths.cpp. { // DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); // PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); INT32 i; if (Verbs[Index] == PT_MOVETO) { // This is the start of a path - if the path is open, return -1 // otherwise return the index of the last control point. If the last // element is a line, return -1 i = Index; FindEndOfSubPath(&i); // If the last segment isn't a bezier, return -1 if (Verbs[i] != PT_BEZIERTO) return -1; // if the CLOSEFIGURE flag is set in the final element, return i+1 // otherwise return -1 if (Verbs[i+2] & PT_CLOSEFIGURE) return i+1; return -1; } else { // It isn't the start of a path, so see what kind of endpoint this is // and if it is a bezier, return the control point, otherwise return -1 if ((Verbs[Index] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) return Index-1; return -1; } }

BOOL Path::FindPrevEndPoint (  INT32 *  index  )  const

Finds the previous path endpoint in this path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 5/1/95 Parameters: Index  = pointer to a INT32 indicating where to start from [INPUTS] Outpus: Index = points to an index which is the previous endpoint Returns: TRUE if the previous end point has been found FALSE if there are no more end points in this path Errors: ERROR2's if Index is beyond the end of the path, OR before the start See also: Path::FindNextEndPoint Definition at line 814 of file paths.cpp. { ERROR2IF(*index > UsedSlots, FALSE, "Path position was not valid in FindPrevEndPoint" ); ERROR2IF(*index < 0, FALSE, "Path Position less than zero in FindPrevEndPoint" ); // de-reference the verb array PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); if ((Verbs[*index] & (~PT_CLOSEFIGURE))==PT_BEZIERTO) *index -= 3; else *index -= 1; if (*index < 0) { *index = 0; return FALSE; } return TRUE; }

BOOL Path::FindSelectionLimits (  INT32  index, INT32 *  p, INT32 *  q )

Finds the next connected region of selected control handles. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 3/11/94 Parameters: index  = search start point [INPUTS] p  = index of first selected point in region [OUTPUTS] q = index of last selected point in region Returns: TRUE if the point set {index,....,UsedSlots-1} contains a set of selected control handles {p,...,q} where p and q are the limits of the selection and all points between are selected. FALSE if no points are selected within the region. Definition at line 3722 of file paths.cpp. { ENSURE( index<UsedSlots, "Path position was not valid in FindSelectionLimits" ); ENSURE( index>=0, "Path Position less than zero in FindSelectionLimits" ); INT32 start = index; // clamp the index if (start<0) start=0; if (start>=UsedSlots) start=UsedSlots-1; if (!FindNextSelected(&start)) return FALSE; INT32 end = start; INT32 search = start; PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); BOOL done = FALSE; while (FindNextEndPoint(&search) && (!done)) { if ((Flags[search].IsSelected) && (Flags[search].IsEndPoint)) { if (Verbs[search] != PT_MOVETO) end = search; else done = TRUE; } else done = TRUE; } *p = start; *q = end; return TRUE; }

BOOL Path::FindStartOfPath (   )

Sets Pos to the first element in the path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Parameters: Pos  - Holds the position of the start of the path [OUTPUTS] Definition at line 536 of file paths.cpp. { // set the position to the start of the path CurrentPos = 0; // see if this a valid path position if (UsedSlots==0) return FALSE; else return TRUE; }

void Path::FindStartOfSubPath (  INT32 *  Index  )  const

Searches backwards from the current position from Index until it find the start of the subpath (always a moveto). Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 7/7/94 Parameters: Index  - the index of the current element (pointer!) [INPUTS] Index  - Holds the position of the start of the sub path [OUTPUTS] Returns: Errors: ENSUREs if the start of the path does not seem to be a MoveTo Definition at line 592 of file paths.cpp. { ENSURE( ((*Index)<UsedSlots && (Index)>=0), "Path position was not valid in FindStartOfSubPath" ); // I am already in a path, so start working backwards until I find the moveto PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); while (((*Index)>0) && (Verbs[*Index]!=PT_MOVETO)) (*Index)--; // The index will either be pointing at a moveto or the begining of the path // Either way, it should be a moveto ENSURE( (Verbs[(*Index)]==PT_MOVETO), "Did not find a start to this sub path" ); }

void Path::FindStartOfSubPath (   )

Searches backwards from the current position until it finds the start of the sub path that the current position is in. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Errors: ENSUREs if the start of the path does not seem to be a MoveTo Definition at line 563 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "Path position was not valid in FindStartOfSubPath" ); // I am already in a path, so start working backwards until I find the moveto PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); while ((CurrentPos>0) && (Verbs[CurrentPos]!=PT_MOVETO)) CurrentPos--; // The index will either be pointing at a moveto or the begining of the path // Either way, it should be a moveto ENSURE( (Verbs[CurrentPos]==PT_MOVETO), "Did not find a start to this sub path" ); }

BOOL Path::Flatten (  const double  flatness, Path *  pOutput )

Flatten a path. All curves within the path will be approximated by straight lines. pOutput may point at 'this' path ie a path can be flattened to itself. If the flattening fails for some reason, the output path will be unaffected even if you are flattening a path to itself. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/94 Parameters: flatness  = How flat the curves should be (around 64 is good) [INPUTS] pOutput  = will contain the flattened path [OUTPUTS] Returns: BOOL = TRUE if the path was flattened successfully = FALSE then output path will be unaffected Definition at line 7854 of file paths.cpp. { // when flattening, flatten curves but dont quantise lines ProcessFlags FlatFlags(TRUE,FALSE); return CreateFlatPath(FlatFlags, flatness, pOutput); }

INT32 Path::GetAllOpenEnds (  INT32  MaxElements, DocCoord *  EndCoords )  const

Goes through the path and copies the coordinates of all the Open ends of the path into the array, until MaxElements elements have been added to the array. Call GetNumEndPoints to find out how big to make your array in the first place. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/4/94 Parameters: MaxElements  - The maximum number of coords that can be written to the [INPUTS] array Coords  - A array of DocCoords [OUTPUTS] Returns: The number of coords in the array See also: Path::GetNumEndPoints Definition at line 1482 of file paths.cpp. { // de-reference the verb array PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); INT32 Count = 0; for (INT32 i=0; i<UsedSlots; i++) { if (Verbs[i]==PT_MOVETO) { // Count this moveto EndCoords[Count] = Coords[i]; Count++; // Check to see we have hit the maximum allowed entries if (Count==MaxElements) return Count; if ((i>0) && (Verbs[i-1]&PT_CLOSEFIGURE)) { // The previous element was a close figure, so it corresponding MoveTo // should not count Count--; } else { // The previous elment was not a close figure, so it was an Open End EndCoords[Count] = Coords[i-1]; Count++; // Check to see we have hit the maximum allowed entries if (Count==MaxElements) return Count; } } } // Check to see if the very last element in the path was a close figure or not if (Verbs[UsedSlots-1] & PT_CLOSEFIGURE) Count--; else { EndCoords[Count] = Coords[UsedSlots-1]; Count++; } // return the number of coords we are stored return Count; }

DocRect Path::GetBlobRect (   )  const

Calculates the bounding rectangle of the paths coordinates expanded by the current blob size. This is calculated on the fly, so don't over use it. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/12/94 Returns: The bounding box of the path and blobs Definition at line 1715 of file paths.cpp. { // If the path is empty, then return an empty rectangle if (UsedSlots==0) return DocRect(0,0,0,0); // de-reference the coord array DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); DocRect BlobRect; for (INT32 i=0; i<UsedSlots; i++) { DocRect TempRect; GetApplication()->GetBlobManager()->GetBlobRect(Coords[i],&TempRect); if (i==0) BlobRect = TempRect; // For first coord, set BlobRect = rect of blob else BlobRect = BlobRect.Union(TempRect); // for other coords, find the union } // return the completed rectangle return BlobRect; }

DocRect Path::GetBoundingRect (   )  const

Calculates the bounding rectangle of the paths coordinates. This is calculated on the fly, so don't over use it. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: The bounding box of the path Definition at line 1549 of file paths.cpp. { // If the path is empty, then return an empty rectangle if (UsedSlots==0) return DocRect(0,0,0,0); // de-reference the coord array DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); DocRect BoundingRect(Coords[0], Coords[0]); // include each point in the path to the bounding rectangle for (INT32 i=1; i<UsedSlots; i++) BoundingRect.IncludePoint(Coords[i]); // return the completed rectangle return BoundingRect; }

INT32 Path::GetContourForStep (  Path *  pDest, double  StepValue = 1.0 )

Definition at line 5725 of file paths.cpp. { // First Check to see if the Path pasted in is valid! ERROR2IF(pDest==NULL,0,"Init GenPathContour Recieved a NULL Pointer!"); PPOINT SPoints = (PPOINT)GetCoordArray(); PBYTE STypes = (PBYTE)GetVerbArray(); INT32 SLength = GetNumCoords(); PPOINT OPoints = NULL; PBYTE OTypes = NULL; PPOINT INPoints = NULL; PBYTE INTypes = NULL; ERROR3IF(SLength < 0,"We`ve got a problem got a path with negative length!"); Path CopyPath; CopyPath.Initialise(); Path StrokedPath; StrokedPath.Initialise(); INT32 PathLength = -1; INT32 Width = 100; Width = (INT32)(StepValue * m_ContourWidth); JointType JoinS = (m_ContourJoinS==JOIN_MITER) ? MitreJoin : (m_ContourJoinS==JOIN_ROUND) ? RoundJoin : BevelledJoin; LineCapType CapS = (m_ContourCapS==CAPS_BUTT) ? LineCapButt : (m_ContourCapS==CAPS_ROUND) ? LineCapRound : LineCapSquare; TRACEUSER( "MarkH", _T("Contouring with flatness %lf\n"),m_ContourFlatness); INT32 NewPathLength = -2; INT32 Passes = 0; // If we`re not using the contouring mode and we want to use the StrokePathToPAth function then do it here! if(!m_UseContourMode) PathLength = StrokePathToPath(Width, CapS, JoinS, NULL, &StrokedPath, m_ContourFlatness, m_DoClosePath); if(pDest->GetNumCoords() > 0) { // Now copy the Destination path as it needs to be clipped with the intermediate Path! CopyPath.CloneFrom(*pDest); pDest->ClearPath(); } else { pDest->SetPathPosition(0); } // Check again to see if we`re doing the contour mode or the stroke path to path mode if(m_UseContourMode) { // now initialize and get the Points and Type pointers from a tempary path // that holds the intermediate step GenPathContour GStroke; // [Phil, 18/08/2005] Should this be assigning to NewPathLength? The test marked !!! below will always fail... PathLength = GStroke.ContourPath(SPoints, STypes, SLength, &OPoints, &OTypes, Width, m_ContourMitreLimit, m_ContourFlatness, m_ContourJoinS, (m_IsAnOuterContour == TRUE)); INT32 OLength = (PathLength * 4)+1000; if ( PathLength > 0 && OPoints && OTypes) { if ( !m_IsAnOuterContour ) { // Create two new Arrays which are larger than the current OPoints and OTypes // as gavin allocates his own memory for these points! INPoints = new POINT[OLength]; INTypes = new BYTE[OLength]; if(INPoints && INTypes) { memcpy(INPoints,OPoints,sizeof(POINT) * PathLength); memcpy(INTypes,OTypes,PathLength); delete OPoints; OPoints = INPoints; delete OTypes; OTypes = INTypes; } else { delete OTypes; delete OPoints; // If the NewPathLength is 0 then there`s no point continueing so // make sure the destination path contains the data it came in with // and return! if(NewPathLength == 0) // !!! pDest->CloneFrom(CopyPath); return NewPathLength; } RECT obbox ; XaDraw_CalcSimpleBBox( OPoints,PathLength,&obbox ) ; OPoints[PathLength+0].x = obbox.right +0x1000 ; OPoints[PathLength+0].y = obbox.top -0x1000 ; OPoints[PathLength+1].x = obbox.right +0x1000 ; OPoints[PathLength+1].y = obbox.bottom+0x1000 ; OPoints[PathLength+2].x = obbox.left -0x1000 ; OPoints[PathLength+2].y = obbox.bottom+0x1000 ; OPoints[PathLength+3].x = obbox.left -0x1000 ; OPoints[PathLength+3].y = obbox.top -0x1000 ; OTypes[PathLength+0] = PT_MOVETO ; OTypes[PathLength+1] = PT_LINETO ; OTypes[PathLength+2] = PT_LINETO ; OTypes[PathLength+3] = PT_LINETO|PT_CLOSEFIGURE ; while(NewPathLength == -2 && Passes++ < 6) { NewPathLength = ::ClipPathToPath(OPoints, OTypes, PathLength+4, m_ContourFlatness, OPoints+PathLength, OTypes+PathLength, 4, m_ContourFlatness, 4 | 1<<4 | 1<<5, 30, OPoints, OTypes, OLength); } PathLength = NewPathLength; if(NewPathLength <= 0) { delete OTypes; delete OPoints; // If the NewPathLength is 0 then there`s no point continueing so // make sure the destination path contains the data it came in with // and return! if(NewPathLength == 0) pDest->CloneFrom(CopyPath); return NewPathLength; } } pDest->EnsureVolume(OLength); PPOINT DPoints = (PPOINT)pDest->GetCoordArray(); PBYTE DTypes = (PBYTE)pDest->GetVerbArray(); // INT32 DLength = pDest->GetNumCoords(); PPOINT CPoints = (PPOINT)CopyPath.GetCoordArray(); PBYTE CTypes = (PBYTE)CopyPath.GetVerbArray(); INT32 CLength = CopyPath.GetNumCoords(); NewPathLength = -2; while(NewPathLength == -2 && Passes++ < 6) { NewPathLength = ::ClipPathToPath( OPoints, OTypes, PathLength, m_ContourFlatness, CPoints, CTypes, CLength, m_ContourFlatness, 7 | 1<<4, 30, DPoints, DTypes, OLength); if(NewPathLength == -2) { OLength <<= 1; pDest->EnsureVolume(OLength); pDest->SetPathPosition(0); DPoints = (PPOINT)pDest->GetCoordArray(); DTypes = (PBYTE)pDest->GetVerbArray(); TRACEUSER( "MarkH", _T("Path to short so using new length %d\n"),OLength); } } if(NewPathLength <= 0) { delete OTypes; delete OPoints; // If the NewPathLength is 0 then there`s no point continueing so // make sure the destination path contains the data it came in with // and return! if(NewPathLength == 0) pDest->CloneFrom(CopyPath); return NewPathLength; } pDest->UsedSlots += NewPathLength; pDest->UnUsedSlots -= NewPathLength; delete OTypes; delete OPoints; // Now try to close the destination path and tidyup the slot allocations! pDest->TryToClose(); } else { delete OTypes; delete OPoints; // If the NewPathLength is 0 then there`s no point continueing so // make sure the destination path contains the data it came in with // and return! // if(NewPathLength == 0) if (NewPathLength <=0) { pDest->CloneFrom(CopyPath); return 0; } } } else { // With the stroke path to path method we need to clean up the resultant path! PathLength = CopyPath.ClipPathToPath(StrokedPath, pDest, 7|(1<<4), 30, m_ContourFlatness, m_ContourFlatness); if(PathLength <= 0) { // If the NewPathLength is 0 then there`s no point continueing so // make sure the destination path contains the data it came in with // and return! if(PathLength == 0) pDest->CloneFrom(CopyPath); TRACEUSER( "MarkH", _T("ClipFailed so copying path! PATHS\n")); } } // Return the New Path Length return PathLength; }

DocCoord Path::GetControl1 (   )

Finds the first control point of a bezier. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 Returns: DocCoord - the Coord of the first control point Definition at line 1785 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "Index out of bounds in GetEndPoint" ); // de-reference the coord array DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); ENSURE((((PathVerb*) DescribeHandle(VerbHandle)) [CurrentPos] & (~PT_CLOSEFIGURE))==PT_BEZIERTO, "Not a Bezier in Path::GetControl1()"); return Coords[CurrentPos]; }

DocCoord Path::GetControl2 (   )

Finds the second control point of a Bezier. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 Returns: DocCoord - The coord of the seconds control point Definition at line 1809 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "Index out of bounds in GetEndPoint" ); // de-reference the arrays DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); ENSURE((((PathVerb*) DescribeHandle(VerbHandle))[CurrentPos+1] & (~PT_CLOSEFIGURE))==PT_BEZIERTO, "Not a Bezier in Path::GetControl2()"); return Coords[CurrentPos+1]; }

DocCoord Path::GetCoord (   )  const

finds the DocCoord associated with the path position Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: The DocCoord at the Current Path position Errors: Ensures if the position if not valid or out of bounds Definition at line 1146 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "Index out of bounds in Path::GetCoord" ); // de-reference the coord array DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); return Coords[CurrentPos]; }

DocCoord * Path::GetCoordArray (   )  const

Gives you access to the coordinate array. This array is simply a list of all the coordinates in the path, in order. This should be very useful if you need to perform transformations or other actions that effect all the coordinates. The coordinates are in the corect order for the NT PolyDraw() function handle. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: Pointer to the Array of coords held by the path. Definition at line 1837 of file paths.cpp. { // de-reference the coord array return (DocCoord*) DescribeHandle(CoordHandle); }

void Path::GetDebugDetails (  StringBase *  Str  )

Dumps the whole path out during tree display debugging. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>; Karim 26/05/2000 Date: 20/12/94 (Karim) I'm updating this method to give a little bit more info, so's it isn't necessary to manually dump path data every time you need to. It doesn't currently seem to be called from anywhere, so my changes should have zero effect on existing code. Please feel free to use this method and alter it to display more info if required. Info returned: Number of handles and bytes used by the path data. Whether the path is filled or not. Each handle's verbs, coords and flags Verbs - L - LineTo C - CurveTo M - MoveTo S - ClosePath Notes: For example of use, see NodeClipViewController::GetDebugDetails(). Definition at line 2912 of file paths.cpp. { #ifdef _DEBUG String_256 TempStr; // output number of handles and space used by the path. INT32 nSlots = GetNumCoords(); TempStr._MakeMsg( TEXT("#1%ld handles, #2%ld bytes used\r\n"), nSlots, GetPathByteLength() ); (*Str) += TempStr; // output whether or not the path is filled. TempStr._MakeMsg( TEXT("Path is#1%s Filled and is#2%s Stroked\r\n"), IsFilled ? "" : " not", IsStroked ? "" : " not" ); (*Str) += TempStr; // output the path's handle information. (*Str) += TEXT( "Num\tType\tX Coord\tY Coord\r\n" ); PathVerb * Verbs = GetVerbArray(); DocCoord * Coords = GetCoordArray(); PathFlags * Flags = GetFlagArray(); for (INT32 i=0; i < nSlots; i ++) { String_32 VerbStr; VerbStr._MakeMsg(TEXT("#1%d ("), Verbs[i]); if (Verbs[i] & PT_CLOSEFIGURE) VerbStr += TEXT("S"); if (Verbs[i] & PT_LINETO) VerbStr += TEXT("L"); if (Verbs[i] & PT_BEZIERTO) VerbStr += TEXT("C"); if (Verbs[i] & PT_MOVETO) VerbStr += TEXT("M"); VerbStr += TEXT(")"); TempStr._MakeMsg( TEXT("#1%d.\t#2%S\t#3%ld,\t#4%ld\t"), i, &VerbStr, Coords[i].x, Coords[i].y ); if (Flags[i].IsSmooth) TempStr += TEXT("S"); if (Flags[i].IsRotate) TempStr += TEXT("R"); if (Flags[i].IsEndPoint) TempStr += TEXT("E"); if (Flags[i].IsSelected) TempStr += TEXT("(sel)"); TempStr += TEXT("\r\n"); (*Str) += TempStr; } #endif }

BOOL Path::GetDistanceToPoint (  DocCoord  Point, MILLIPOINT *  Distance )

Gets the distance along the path for a given point. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 22/8/96 Parameters: Point  - A DocCoord [INPUTS] Distance  - a length along the path [OUTPUTS] Returns: TRUE/FALSE for success/failure Definition at line 9852 of file paths.cpp. { ERROR2IF(Distance==NULL, FALSE, "NULL output parameter"); INT32 NextEndpoint = 0; double dDistance = 0.0; double mu = 0.0; BOOL ok = (SqrDistanceToPoint(Point, &NextEndpoint, &mu) != -1); ERROR3IF(!ok, "SqrDistanceToPoint failed"); if (ok) { ok = DistanceTo(NextEndpoint, mu, &dDistance); ERROR3IF(!ok, "Path::DistanceTo failed"); } *Distance = (MILLIPOINT)dDistance; return ok; }

DocCoord Path::GetEndPoint (   )

Finds the endpoint of a given path element and returns it. For MoveTos and LineTos, the point returned will be its associated coord, but for a CurveTo the last coord will be returned. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: The Endpoint of the Path Element pointed at by Current Path position Errors: Ensures if the position is not valid or out of bounds Definition at line 1756 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "Index out of bounds in GetEndPoint" ); // de-reference the verb array PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // de-reference the coord array DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); if ((Verbs[CurrentPos] & (~PT_CLOSEFIGURE))==PT_BEZIERTO) return Coords[CurrentPos+2]; else return Coords[CurrentPos]; }

PathFlags * Path::GetFlagArray (   )  const

This array holds a set of flags for each and every coordinate in the path. These flags are used to record information specific to each coordinate, such as its selection state, to determine if it should smooth this part of the path etc. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: A pointer to an array of Path Flags See also: PathFlag Definition at line 1881 of file paths.cpp. { // de-reference the Flag array return (PathFlags*) DescribeHandle(FlagsHandle); }

void Path::GetFlags (  PathFlags *  NewFlags  )

returns all the flags for the current path position Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/02/94 Parameters: NewFlags  - Holds the flags for the current path position [OUTPUTS] Definition at line 2689 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "PathPosition is out of Bounds in Path::IsEndPoint" ); // Get the flags array PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // and return the selected flag *NewFlags = Flags[CurrentPos]; }

PathFlags Path::GetFlags (   )  const

finds the flags associated with the path position Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: The flag at the current path position Errors: Ensures if the position if not valid or out of bounds Definition at line 1168 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "Index out of bounds in GetFlags" ); // de-reference the flag array PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); return Flags[CurrentPos]; }

INT32 Path::GetNumCoords (   )  const

This returns the number of coordinates that make the path up. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: The number of coordinates in the path Definition at line 1391 of file paths.cpp. { return UsedSlots; }

INT32 Path::GetNumElements (   )  const

This function counts the number of elements in the path. This ignores MoveTos, hence giving you the total number of visible path elements (i.e. all the lines and curves). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Returns: The number of path elements in all sub paths. Definition at line 1326 of file paths.cpp. { // The routine relies on the path beginning with a MoveTo PathVerb* pVerbs = (PathVerb*) DescribeHandle(VerbHandle); INT32 Index=0,Count=0; while (FindNextEndPoint(&Index)) { if ((pVerbs[Index] & ~PT_CLOSEFIGURE) != PT_MOVETO) Count++; } return Count; }

INT32 Path::GetNumEndPoints (   )  const

Goes through the path and counts all open ends in the path. For example, a straight line has 2 open ends, a closed shape has no open ends and a complex path could have any number of open ends. You should use this function before calling GetAllOpenEnds that will fill an array for their coords for you. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/4/94 Returns: The number of open ends to the path. See also: Path::GetAllOpenEnds Definition at line 1444 of file paths.cpp. { // de-reference the verb array PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); INT32 Count = 0; for (INT32 i=0; i<UsedSlots; i++) { if (Flags[i].IsEndPoint) Count++; if ((i>0) && (Verbs[i]==PT_MOVETO) && (Verbs[i-1] & PT_CLOSEFIGURE)) Count--; } // return the number of 'on the path' end points return Count; }

INT32 Path::GetNumSelEndPoints (   )  const

determine how many selected endpoints there are within this path. Useful indirectly for finding whether there's a subselection. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/94 Returns: Number of selected endpoints within this path See also: IsSubSelected() Definition at line 1411 of file paths.cpp. { // We need to find all the selected control points in the path PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); INT32 count = 0; // look for selected coords for (INT32 i=0; i<UsedSlots; i++) { if ((Flags[i].IsSelected) && (Flags[i].IsEndPoint)) count++; } return count; }

INT32 Path::GetNumSubpaths (   )  const

Gets the number of subpaths in this path. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 22/4/97 Returns: The number of subpaths in this path Definition at line 1351 of file paths.cpp. { //This variable will tell us our current position in the path INT32 lCurPos=0; //And this will keep a count of the subpaths we find INT32 lSubpaths=0; //Now, while we are still in the path while (lCurPos<GetNumCoords()) { //Set lCurPos to the end of the subpath we are in FindEndElOfSubPath(&lCurPos); //Add one to the number of subpaths found lSubpaths++; //And move the current position on by one place, to move it //either into the next subpath or off the end of the path lCurPos++; } //And return the number of subpaths we found return lSubpaths; }

void Path::GetPathArrays (  PathVerb **  VerbArray, DocCoord **  CoordArray = NULL, PathFlags **  FlagsArray = NULL )

Easy way of getting the path pointers into variables. Combines three function calls into one. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/95 Parameters: VerbArray  - pointer to a pointer to a PathVerb object [INPUTS] CoordArray - pointer to a pointer to a DocCoord FlagsArray - pointer to a pointer to a PathFlags object VerbArray  points to the verbs array [OUTPUTS] CoordArray points to the coordinates array FlagsArray points to the flags array Returns: - Errors: - Definition at line 1907 of file paths.cpp. { if (VerbArray != NULL) *VerbArray = (PathVerb*) DescribeHandle(VerbHandle); if (CoordArray != NULL) *CoordArray = (DocCoord*) DescribeHandle(CoordHandle); if (FlagsArray != NULL) *FlagsArray = (PathFlags*) DescribeHandle(FlagsHandle); }

INT32 Path::GetPathByteLength (   )  const

Calculates the length of the path in bytes. This figures includes the size of the 3 arrays (Coordinates, Verbs and Flags) only. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: The Length of the path in bytes Definition at line 1300 of file paths.cpp. { INT32 Total; // Add up the size of each of the Arrays Total = UsedSlots * sizeof(DocCoord); Total += UsedSlots * sizeof(PathVerb); Total += UsedSlots * sizeof(PathFlags); return Total; }

double Path::GetPathLength (  double  dFlatness = 64.0  )

Find the length of a path in millipoints. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/8/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The length of the path in millipoints Definition at line 7938 of file paths.cpp. { double TotalLength = 0.0; INT32 LastEndPoint = GetNumCoords()-1; if (LastEndPoint==-1) return 0.0; BOOL ok = DistanceTo(LastEndPoint, 1.0, &TotalLength, dFlatness); ERROR3IF(!ok, "Path.DistanceTo failed"); if (ok) return TotalLength; else return 0.0; }

INT32 Path::GetPathPosition (   )

Find out where in the path we are. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/02/94 Returns: The Coord number in the path that the Current Path Position is at Definition at line 999 of file paths.cpp. { return CurrentPos; }

PathTypeEnum Path::GetPathType (   )  const

This determines whether the path is a line or a shape. It does this by seeing if it has a PT_CLOSEFIGURE bit set in its last verb. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 31/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Path type Definition at line 1195 of file paths.cpp. { PathVerb* pVerbs = GetVerbArray(); if (pVerbs[UsedSlots-1] & PT_CLOSEFIGURE) return (PATHTYPE_SHAPE); else return (PATHTYPE_LINE); }

BOOL Path::GetPointAtDistance (  MILLIPOINT  Distance, DocCoord *  pPoint, double *  pTangent = NULL, UINT32 *  pPressure = NULL )

Gets the coordinate of a point a certain distance along this path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/96 Parameters: Distance  - a length along the path [INPUTS] pPoint  - the coordinate of the point that distance along the path [OUTPUTS] pTangent = tangent at this point (can be NULL if tangent not required) Returns: TRUE/FALSE for success/failure Definition at line 9828 of file paths.cpp. { ERROR2IF(pPoint==NULL, FALSE, "NULL output parameter"); ERROR2IF(Distance<0, FALSE, "-ve distance"); ProcessPathDistance PathProc(64); BOOL Found = FALSE; BOOL ok = PathProc.GetCoordAndTangent(pPoint, pTangent, &Found, Distance, this, pPressure); return ok && Found; }

BOOL Path::GetSubPathEnds (  DocCoord *  start, DocCoord *  end )

This function returns whether the path is open or closed. This is independent of the IsFilled flag, because some programs allow open paths to be filled. Basically, if there's no gap in the subpath, it's closed, otherwise it's open. These are the same rules as ArtWorks followed. Initial implementation just scans the subpath and checks the last element in the subpath. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 15/3/94 Parameters: -  [INPUTS] start,end  are the coords of the start and end (if function returned TRUE) [OUTPUTS] Returns: TRUE if subpath is open, FALSE otherwise CurrentPos in the path is set to the end of the subpath. Errors: - See also: - Definition at line 693 of file paths.cpp. { DocCoord temp1; FindStartOfSubPath(); temp1 = GetCoord(); FindEndOfSubPath(); // Find out if this path is really closed. If the PT_CLOSEFIGURE flag is set in the end // verb, the path is closed, so return FALSE, otherwise return TRUE, with *start and *end // set up accordingly. PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); if (Verbs[CurrentPos] & PT_CLOSEFIGURE) { return FALSE; } else { *end = GetEndPoint(); *start = temp1; return TRUE; } }

BOOL Path::GetTrueBoundingRect (  DocRect *  pRect, MILLIPOINT  LineWidth = 0, CCAttrMap *  pAttrMap = NULL )

Calculate the bounding rectangle of a path using GDraw. Added by Diccon 22/5/2000 LineWidth - the width of the path, note that this defaults to zero so you don't have to supply anything unless you want to. pAttrMap ptr to an attrmap, from which to take modification info. note that if we can extract a LineWidth value from it, then the attrmap's value will override that passed in directly. Parameters: if  successful, pRect will contain the bounds of the path, [OUTPUTS] otherwise pRect will be made empty. Returns: TRUE if successful, FALSE otherwise. Notes: This gives the true bounds, including all the curvy bits - not just the bounds of the control points, which is what GetBoundingRect() returns. By using one or other of the extra parameters to this method, you can find out the bounds for thick lines, or lines with arrow-heads/tails. Returns: Errors: ERROR3's with FALSE if pRect is NULL. See also: GDrawContext::CalcStrokeBBox. Definition at line 1603 of file paths.cpp. { // validate inputs. if (pRect == NULL) { ERROR3("Path::GetTrueBoundingRect; NULL input rectangle!"); return FALSE; } if (LineWidth < 0) { //ERROR3("Negative line width supplied to Path::GetTrueBoundingRect"); LineWidth = 0; // we can recover from this } // check the attr map for any attrs which we think may alter // the bounds of the path, eg line width, arrow heads. ArrowRec* pArrow1 = NULL; ArrowRec* pArrow2 = NULL; JoinStyles JoinStyle = JOIN_ROUND; if (pAttrMap != NULL) { AttrLineWidth* pLineWidth = NULL; AttrStrokeColour* pLineColour = NULL; AttrStartArrow* pStartArrow = NULL; AttrEndArrow* pEndArrow = NULL; AttrJoinType* pJoinType = NULL; // note that we only use the path's LineWidth if its outline is not transparent. pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrLineWidth), (void*&)pLineWidth); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrStrokeColour), (void*&)pLineColour); if (pLineColour != NULL && pLineWidth != NULL) { LineWidth = 0; DocColour* pCol = pLineColour->GetStartColour(); if (pCol != NULL && !pCol->IsTransparent()) LineWidth = pLineWidth->Value.LineWidth; } // ok, if we have a line width then we'll need to look for stuff like // arrowheads and join-style (esp. Mitre joins). if (LineWidth > 0) { pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrStartArrow), (void*&)pStartArrow); if (pStartArrow != NULL) pArrow1 = &(pStartArrow->Value.StartArrow); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrEndArrow), (void*&)pEndArrow); if (pEndArrow != NULL) pArrow2 = &(pEndArrow->Value.EndArrow); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrJoinType), (void*&)pJoinType); if (pJoinType != NULL) { JointType jt = pJoinType->Value.JoinType; JoinStyle = (jt == MitreJoin) ? JOIN_MITER : (jt == RoundJoin) ? JOIN_ROUND : JOIN_BEVEL; } } } // ok, let's get the path's bounds! pRect->MakeEmpty(); BOOL fSuccess = FALSE; DocRect drBounds; GDrawContext *GD = GRenderRegion::GetStaticDrawContext(); if (GD == NULL) return FALSE; fSuccess = GD->CalcStrokeBBox( (POINT*)GetCoordArray(), GetVerbArray(), GetNumCoords(), (RECT *)(&drBounds), IsFilled, (DWORD)LineWidth, CAPS_ROUND, JoinStyle, NULL ) != -1; // if the bounds are invalid then make sure that we flag a failure. if (!drBounds.IsValid()) fSuccess = FALSE; // ok so far - if we need to account for any arrowheads, do so now. if (fSuccess) { if (pArrow1 != NULL) drBounds = drBounds.Union(pArrow1->GetArrowBoundingRect(this, LineWidth, TRUE)); if (pArrow2 != NULL) drBounds = drBounds.Union(pArrow2->GetArrowBoundingRect(this, LineWidth, FALSE)); } // ok, if we're a success then record the bounds. if (fSuccess) *pRect = drBounds; return fSuccess; }

INT32 Path::GetUsedSlots (   )  [inline]

Definition at line 573 of file paths.h. { return (UsedSlots); }

PathVerb Path::GetVerb (   )  const

finds the verb associated with the path position Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: The verb at the current path position Errors: Ensures if the position if not valid or out of bounds Definition at line 1122 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "Index out of bounds in GetVerb" ); // de-reference the verb array PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // return the verb with the close path bit removed return ((Verbs[CurrentPos]) & (~PT_CLOSEFIGURE)); }

PathVerb * Path::GetVerbArray (   )  const

This array holds a list of all the path elements used in the path. The structure used is the same as the NT structure and can in fact be passed striaght on to the NT PolyDraw function. The verbs must be one of the following PC_MoveTo, PC_LineTo or PC_CurveTo. LineTo and CurveTo verbs can be combined with a ClosePath Flag. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: A pointer to the verb array held by the path. Definition at line 1859 of file paths.cpp. { // de-reference the Verb array return (PathVerb*) DescribeHandle(VerbHandle); }

PathWidth Path::GetWidth (  void   )  const

Fetches width values from the path. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/94 Parameters: -  [INPUTS] Returns: The width of the path at the current path postion. Errors: - Definition at line 8255 of file paths.cpp. { if (ExtraInfo == NULL) return 0; return ExtraInfo->GetWidthInfo(); }

PathWidth * Path::GetWidthArray (   )

The array holds the width of all the points in the path. DO NOT MODIFY THE CONTENTS OF THE ARRAY. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/94 Returns: A pointer to an array of Path Width Info. Definition at line 8275 of file paths.cpp. { if (ExtraInfo == NULL) return NULL; return ExtraInfo->GetWidthArray(); }

BOOL Path::HasWidth (   )

To determine if the path has any width information. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/94 Returns: TRUE if width information is available. Definition at line 8294 of file paths.cpp. { if (ExtraInfo == NULL) return FALSE; return ExtraInfo->HasWidthInfo(); }

BOOL Path::InitExtraInfo (  ChannelIndex  Index  )

Allocates memory in the path for the extra info arrays. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 08/06/94 Parameters: The  Index of the Channel to Initialise. [INPUTS] Returns: TRUE if we got all the memory we needed, FALSE if not Errors: May error if it runs out of memory. Definition at line 8184 of file paths.cpp. { TRACEUSER( "Will", _T("InitExtraInfo, Index=%d\n"), Index ); ENSURE(Index <= NUMEXTRACHANNELS, "Index out of range in InitExtraInfo"); // If we haven't any extra info yet then we need to create some if (ExtraInfo == NULL) { ExtraInfo = new PathExtraInfo(); if (ExtraInfo == NULL) return FALSE; } // Now we can initialise the channel. // We use the same initial slot size as was used for the main path data. return ExtraInfo->Init(Index, SlotInitSize); }

BOOL Path::Initialise (  INT32  InitialSize = 24, INT32  BlockSize = 12 )

Allocates memory in the path for the three arrays - The Verbs, Coordinates and the Flags. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Parameters: InitialSize  - The number of coords the path can hold initially [INPUTS] BlockSize - The number of coords to allocate for each time we run out of space Returns: TRUE if we got all the memory we needed, FALSE if not Errors: Can fail if it runs out of memory Definition at line 284 of file paths.cpp. { // CGS (19/6/2000) A few of camelots programmers seem to be assuming that calling initialise // on an already initialised path will clear out all previous pointers. This is NOT the case // (or at least wasn't). It is not unreasonable for the programmer to expect this to happen // (being viewed as a reinitialise), so I have added code to handle deletion automatically. // This should fix a considerable amount of camelots memory leaks! if (VerbHandle != BAD_MHANDLE) ReleaseBlock(VerbHandle); if (CoordHandle != BAD_MHANDLE) ReleaseBlock(CoordHandle); if (FlagsHandle != BAD_MHANDLE) ReleaseBlock(FlagsHandle); // The memory manager will not allocate blocks of less that 12 bytes and have to be multiples of 4! if (InitialSize<12) { InitialSize = 12; } else { // Make sure it is a multiple of 4, by shifting left 2 and then shifting it back again! InitialSize = (InitialSize+3) >> 2; InitialSize = InitialSize << 2; } if (BlockSize<12) { BlockSize = 12; } else { // Make sure it is a multiple of 4, by shifting left 2 and then shifting it back again! BlockSize = (BlockSize+3) >> 2; BlockSize = BlockSize << 2; } // try and get memory for the verbs VerbHandle = ClaimBlock(sizeof(PathVerb)*InitialSize); if (VerbHandle!=BAD_MHANDLE) { // try and get memory for the coords CoordHandle = ClaimBlock(sizeof(DocCoord)*InitialSize); if (CoordHandle != BAD_MHANDLE) { // try and get memory for the flags FlagsHandle = ClaimBlock(sizeof(PathFlags)*InitialSize); if (FlagsHandle != BAD_MHANDLE) { // everything worked UsedSlots = 0; UnUsedSlots = InitialSize; SlotInitSize = InitialSize; SlotAllocSize = BlockSize; } else { // failed to get the flag block, so release the other blocks and fail ReleaseBlock( CoordHandle ); ReleaseBlock( VerbHandle ); return FALSE; } } else { // failed to get the coords block, so release the block we already have and fail ReleaseBlock( VerbHandle ); return FALSE; } } else { // failed to get any memory, so fail return FALSE; } // a total success, so say so. return TRUE; }

void Path::InitialiseFlags (  PathVerb *  pVerbs, PathFlags *  pFlags, const INT32  Len )

This generates a legal path flags array based on the path verbs in pVerbs within the specified region. It sets all flags in pFlags to default values and then scans all end points setting their end point flag to TRUE. void Path::InitialiseFlags(PathVerb* pVerbs, PathFlags* pFlags, const INT32 Len) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: pVerbs  = ptr to a path verbs array [INPUTS] pFlags = ptr to buffer to place the initialised flags Len = num verbs in pVerbs, and num flags in pFlags pFlags  array contains valid flags for each of the verbs in pVerbs [OUTPUTS] Returns: - See also: - Definition at line 2796 of file paths.cpp. { INT32 n; // Reset all the path flags to default values PathFlags DefaultPathFlags; for (n=0; n < Len; n++) pFlags[n] = DefaultPathFlags; // Scan the verbs, so that the end point flags can be set correctly for (n=0; n < Len; n++) { PathVerb Verb = pVerbs[n] & ~PT_CLOSEFIGURE; switch (Verb) { case PT_LINETO: case PT_MOVETO: pFlags[n].IsEndPoint = TRUE; break; case PT_BEZIERTO: n += 2; ERROR3IF(n>=Len,"Found a PT_BEZIERTO, but third pt is off the end of the array"); pFlags[n].IsEndPoint = TRUE; break; default: ERROR3_PF(("Illegal path verb found : %c",Verb)); break; } } }

void Path::InitialiseFlags (  const INT32  Startindex, const INT32  Len )

This generates a legal path flags array based on the path verbs within the specified region. It sets all flags to default values and then scans all end points setting their end point flag to TRUE. void Path::InitialiseFlags( const UINT32 Startindex, const INT32 Len) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/11/94 Parameters: Startindex  = index of element at which to start [INPUTS] Len = num verbs to set corresponding flags for The  path's flags array contains valid flags for each of its verbs [OUTPUTS] Returns: - See also: - Definition at line 2763 of file paths.cpp. { ERROR3IF(Startindex<0,"startindex off start of path in Path::SetPathFlags()"); ERROR3IF(Startindex+Len>UsedSlots,"(startindex+len) of end of path in Path::SetPathFlags()"); // Get the flags array PathFlags* pFlags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* pVerbs = (PathVerb*) DescribeHandle(VerbHandle); InitialiseFlags(pVerbs+Startindex,pFlags+Startindex,Len); }

void Path::InitialiseFlags (   )

This generates a legal path flags array based on the all path verbs. It sets all flags to default values and then scans all end points setting their end point flag to TRUE. void Path::InitialiseFlags() Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: -  [INPUTS] The  path's flags array contains valid flags for each of its verbs [OUTPUTS] Returns: - See also: - Definition at line 2740 of file paths.cpp. { InitialiseFlags(0,UsedSlots); }

INT32 Path::InitializeContourValues (  UINT32  Width, JoinStyles  JoinS = JOIN_ROUND, BOOL  IsAnOuterContour = TRUE, double  Flatness = 200.0, BOOL  ClosePath = TRUE, BOOL  UseContourMode = TRUE, CapStyles  CapS = CAPS_ROUND, UINT32  MitreLimit = 751941 )

Definition at line 5698 of file paths.cpp. { m_ContourWidth = Width; m_ContourJoinS = JoinS; m_ContourCapS = CapS; m_IsAnOuterContour = IsAnOuterContour; m_DoClosePath = ClosePath; m_UseContourMode = UseContourMode; m_ContourFlatness = Flatness; m_ContourMitreLimit = MitreLimit; return GetNumCoords(); }

BOOL Path::InsertCurveTo (  DocCoord  p1, DocCoord  p2, DocCoord  p3, PathFlags *  NewFlags = NULL )

Inserts a Curve into the path at the Current Path Position. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Parameters: p1  - The first control point [INPUTS] p2 - The second control point p3 - The endpoint NewFlags - The flags to set the new coords to Returns: FALSE if there was an error, TRUE otherwise Errors: Can fail if it can not get enough memory to add the curve See also: Path::InsertLineTo; Path::InsertMoveTo Definition at line 2154 of file paths.cpp. { // We need 3 empty slot to add a CurveTo if (!MakeSpaceInPath(3)) { ERROR( _R(IDS_PATH_MEM_ERROR), FALSE ); } // get all the pointers PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // Prepare the flags PathFlags UseFlags; if (NewFlags!=NULL) UseFlags = *NewFlags; UseFlags.IsEndPoint = FALSE; // There is now a hole in the middle of the path. // We can fill in the appropriate details for the first control point Verbs[CurrentPos] = PT_BEZIERTO; Coords[CurrentPos] = p1; Flags[CurrentPos] = UseFlags; SyncExtraInfo(); CurrentPos++; // and the second control point Verbs[CurrentPos] = PT_BEZIERTO; Coords[CurrentPos] = p2; Flags[CurrentPos] = UseFlags; CurrentPos++; // and the endpoint UseFlags.IsEndPoint = TRUE; Verbs[CurrentPos] = PT_BEZIERTO; Coords[CurrentPos] = p3; Flags[CurrentPos] = UseFlags; CurrentPos++; // Update the memory usage vars UsedSlots += 3; UnUsedSlots -= 3; // The Current Path Position has already been updated and now points to the item // after the curveto (or off the end of the path, if this is the last element in the path return TRUE; }

BOOL Path::InsertLineTo (  DocCoord  p1, PathFlags *  NewFlags = NULL )

Inserts a LineTo into the path at the Current Path Position. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Parameters: p1  - the coord to draw the line to [INPUTS] NewFlags - Flags associtaed with the coord Returns: TRUE if it worked, FALSE if it failed to get more memory Definition at line 2098 of file paths.cpp. { // We need only 1 empty slot to add a LineTo if (!MakeSpaceInPath(1)) { ERROR( _R(IDS_PATH_MEM_ERROR), FALSE ); } // get all the pointers PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // Prepare the flags PathFlags UseFlags; if (NewFlags!=NULL) UseFlags = *NewFlags; UseFlags.IsEndPoint = TRUE; // There is now a hole in the middle of the path. We can fill in the appropriate details // and call it a day Verbs[CurrentPos] = PT_LINETO; Coords[CurrentPos] = p1; Flags[CurrentPos] = UseFlags; // Update the memory usage vars UsedSlots++; UnUsedSlots--; // move the position indicator to point to the thing after our new item SyncExtraInfo(); CurrentPos++; return TRUE; }

BOOL Path::InsertMoveTo (  DocCoord  p1, PathFlags *  NewFlags = NULL )

Inserts a MoveTo element into the middle of the Path and asks for extra memory if we need it. It will return FALSE if we fail to get the memory. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Parameters: p1  - The coordinate to move to [INPUTS] NewFlags - The flags associated with the coord Returns: TRUE if it worked, FALSE otherwise Definition at line 2046 of file paths.cpp. { // We need only 1 empty slot to add a MoveTo if (!MakeSpaceInPath(1)) { ERROR( _R(IDS_PATH_MEM_ERROR), FALSE ); } // get all the pointers PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // Prepare the flags PathFlags UseFlags; if (NewFlags!=NULL) UseFlags = *NewFlags; UseFlags.IsEndPoint = TRUE; // There is now a hole in the middle of the path. We can fill in the appropriate details // and call it a day Verbs[CurrentPos] = PT_MOVETO; Coords[CurrentPos] = p1; Flags[CurrentPos] = UseFlags; // Update the memory usage vars UsedSlots++; UnUsedSlots--; // move the position indicator to point to the thing after our new item SyncExtraInfo(); CurrentPos++; return TRUE; }

BOOL Path::InsertSection (  INT32  StartSlot, INT32  NumSlots )

This routine is the corollary to DeleteSection - it inserts a section into the path at a given position and a given size, but does not put any data into the path. Note that this routine is likely to move the path data around in memory, so after calling it you should re-read any pointers to the path you might have had. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/94 Parameters: StartSlot  is the path slot where we want to insert the section [INPUTS] NumSlots is how many slots we want to insert -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Errors: - See also: Path::DeleteSection Definition at line 4071 of file paths.cpp. { INT32 OldPosition = CurrentPos; CurrentPos = StartSlot; if (!MakeSpaceInPath(NumSlots)) { CurrentPos = OldPosition; return FALSE; } CurrentPos = OldPosition; UsedSlots+=NumSlots; UnUsedSlots -= NumSlots; return TRUE; }

BOOL Path::InsertSectionAtEnd (  const Path *  Other, INT32  StartSlot, INT32  NumSlots )  [private]

Copies a section (usually a sub-path) of a path to the end of another path. This is used extensivly to Join Paths together. If there is not enougth space in this path, then the operation will fail - It will NOT try to make the path bigger. It is up to the caller to ensure that there are sufficent UnUsedSlots in the path before calling. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/94 Parameters: Other  - Pointer to the path to copy data from [INPUTS] StartSlot - The slot in the path to start copying from NumSlots - The number of slots to copy Returns: TRUE if the data was copied OK, FALSE if it failed Definition at line 6679 of file paths.cpp. { // Make sure that there is room in the path to store this extra info if (UnUsedSlots<NumSlots) { TRACE( _T("There was not enough room in this path to copy data into")); return FALSE; } // We need to know about the path arrays DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // and the new path DocCoord* OtherCoords = (DocCoord*) DescribeHandle(Other->CoordHandle); PathFlags* OtherFlags = (PathFlags*) DescribeHandle(Other->FlagsHandle); PathVerb* OtherVerbs = (PathVerb*) DescribeHandle(Other->VerbHandle); // Go though and copy all the element from one path to the other for (INT32 i=StartSlot; i<StartSlot+NumSlots; i++) { ENSURE(UnUsedSlots>0, "Ran out of space in a path that should have enough space in it" ); if (UnUsedSlots<=0) return FALSE; // Copy the coords Coords[UsedSlots] = OtherCoords[i]; Flags[UsedSlots] = OtherFlags[i]; Verbs[UsedSlots] = OtherVerbs[i]; // Move on to the next slots UsedSlots++; UnUsedSlots--; } return TRUE; }

BOOL Path::IsClosed (   )

Tells you whether all subpaths of this path are closed. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 05 April 2000 Returns: TRUE if all subpaths are cloesd, FALSE otherwise. Notes: This code taken from BevelHelpers::IsPathClosed() - seems more appropriate for it to live here. See also: IsSubPathClosed Definition at line 4758 of file paths.cpp. { INT32 StartIndex = 0; INT32 EndIndex = 0; // test each subpath for closure. while (StartIndex < UsedSlots) { EndIndex = StartIndex; FindEndElOfSubPath(&EndIndex); if (!IsSubPathClosed(StartIndex)) return FALSE; StartIndex = EndIndex + 1; } return TRUE; }

BOOL Path::IsComplexPath (   )

Tests to see if the path is a complex path (ie it has multiple sub-paths). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/94 Returns: TRUE if the Path is Complex Definition at line 2654 of file paths.cpp. { // Get the path verbs PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); INT32 SubPaths = 0; for (INT32 i=0; i<UsedSlots; i++) { // Count all the MoveTos in the path if (Verbs[i] == PT_MOVETO) SubPaths++; } // Make sure that there was a moveto in this path. This should not happen ENSURE( SubPaths>0, "Path::IsComplexPath() - Found a Path with no MoveTo in it!" ); // If there was only one SubPath then it is simple, otherwise it is complex if (SubPaths==1) return FALSE; else return TRUE; }

BOOL Path::IsEndPoint (   )

return the IsEndPoint flag for the coordinate Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/02/94 Returns: TRUE if this point is an EndPoint (ie Not a Bezier control point) Definition at line 2488 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "PathPosition is out of Bounds in Path::IsEndPoint" ); // Get the flags array PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // and return the selected flag return Flags[CurrentPos].IsEndPoint; }

BOOL Path::IsInPath (   )

Determine if the path current position is still inside the path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/02/94 Returns: TRUE if the current position is still in the path FALSE if it has gone past the last element in the path Definition at line 1045 of file paths.cpp. { // We are still in the path if the current position has not gone past the last valid // item in the path return ((CurrentPos>=0) && (CurrentPos<UsedSlots)); }

BOOL Path::IsIsometric (  const Path &  OtherPath, Matrix *  pTransform, const double &  Tolerance = 1.0 )  const

Determines whether two paths are isometric. In this context, isometric does not include true isomtric paths with different starting points. This can then be used to provide a transformation of this path, resulting in the given otherPath. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 28/08/96 Parameters: OtherPath,:  The path with which to compare this one [INPUTS] Tolerance: The accuracy to which this path transformed to the otherPath may be considered equal. pTransform,:  A pointer to the resulting transformation matrix if the return [OUTPUTS] value is TRUE Returns: TRUE : this path is Isometric to the otherPath FALSE : if not Isometric or inaccuracy losses Definition at line 10039 of file paths.cpp. { // Check path lengths for equality if (GetNumCoords() != OtherPath.GetNumCoords()) { // If not equal can't possibly be the same return FALSE; } // Determine the transformation matrix from the first three coords DocCoord* ThisCoordArray = GetCoordArray(); DocCoord* OtherCoordArray = OtherPath.GetCoordArray(); double a, b, c, d, e, f = Tolerance; // Matrix components // Find First Non-Colinear points INT32 First = FindNonColinear(ThisCoordArray, GetNumCoords()); if (First == -1) { // this path was a straight line. // If the other one is we might be in with a chance First = FindNonColinear(OtherCoordArray, OtherPath.GetNumCoords()); if (First != -1) { // Unfortunately it had a kink so it can't match return FALSE; } // Shears don't work with the following. But then I doubt they're that common DocCoord ef(- ThisCoordArray[0].x, - ThisCoordArray[0].y); DocCoord v1(ThisCoordArray[1].x - ThisCoordArray[0].x, ThisCoordArray[1].y - ThisCoordArray[0].y); DocCoord v2(OtherCoordArray[1].x - OtherCoordArray[0].x, OtherCoordArray[1].y - OtherCoordArray[0].y); double v1dotv2 = v1.x * v2.x + v1.y * v2.y; double modv1sqrd = v1.x * v1.x + v1.y * v1.y; double v1crossv2 = v1.x * v2.y - v1.y * v2.x; a = v1dotv2 / modv1sqrd; b = v1crossv2 / modv1sqrd; c = -b; d = a; e = a * (double)ef.x - b * (double)ef.y + OtherCoordArray[0].x; f = b * (double)ef.x + a * (double)ef.y + OtherCoordArray[0].y; } else { // We have three non-colinear points: /* In fact, we have: ax00 + cy00 + e = x10 bx00 + dy00 + f = y10 & ax01 + cy01 + e = x11 bx01 + dy01 + f = y11 & ax02 + cy02 + e = x12 bx02 + dy02 + f = y12 Hence need to solve 2 sets of simultaneous equations for (a,c,e) & (b,d,f) */ // Try to find a solution for the a,b,e part CCVector3 x0s(ThisCoordArray[First].x, ThisCoordArray[First + 1].x, ThisCoordArray[First + 2].x); CCVector3 y0s(ThisCoordArray[First].y, ThisCoordArray[First + 1].y, ThisCoordArray[First + 2].y); CCVector3 x1s(OtherCoordArray[First].x, OtherCoordArray[First + 1].x, OtherCoordArray[First + 2].x); if (!Solve3Simultaneous(x0s, x1s, y0s, a, c, e)) { return FALSE; } // Try to find a solution for the (b,d,f) part CCVector3 y1s(OtherCoordArray[First].y, OtherCoordArray[First + 1].y, OtherCoordArray[First + 2].y); if (!Solve3Simultaneous(x0s, y1s, y0s, b, d, f)) { return FALSE; } } // Determine the transformation matrix from the first three coords Matrix Solution(a, b, c, d, INT32(e), INT32(f)); // Check the flags & bits PathVerb* ThisVerbArray = GetVerbArray(); PathVerb* OtherVerbArray = OtherPath.GetVerbArray(); INT32 lTolerance = (INT32)Tolerance; // For each remaining coordinate in this path, check we can transform to the otherPath DocCoord CurrentCoord; for (INT32 i = 0; i < GetNumCoords(); ++i) { // Transform(ThisCoordArray[i], a, b, c, d, e, f, CurrentCoord); // Compare the flags & bits (unlikely to be different if coords same though) if (ThisVerbArray[i] != OtherVerbArray[i]) { return FALSE; } CurrentCoord = ThisCoordArray[i]; Solution.transform(&CurrentCoord); if (!IsNear(CurrentCoord.x, OtherCoordArray[i].x, lTolerance) || !IsNear(CurrentCoord.y, OtherCoordArray[i].y, lTolerance)) { return FALSE; } } *pTransform = Solution; return TRUE; }

BOOL Path::IsNearOpenEnd (  const DocRect &  BlobRect, INT32 *  SlotNum )

Determines if the Coordinate is near any of the path open ends. This function looks through all the open ends in complex paths and returns TRUE if any of them are near the TestCoord. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/94 Parameters: BlobRect  - The rect to see if any of the endpoints are in [INPUTS] Returns: TRUE if the TestCoord is close to one of the endpoints Definition at line 2563 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Dereference a few pointers DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // Start searching all the coords for EndPoints INT32 EndSlot = UsedSlots-1; for (INT32 i=UsedSlots-1; i>=0; i--) { // Are we at the start of a sub-path yet if (Verbs[i] == PT_MOVETO) { // Is this sub path open? if ((Verbs[EndSlot] & PT_CLOSEFIGURE) == 0) { // This is an open sub path, so test if they are close to the TestCoord if (BlobRect.ContainsCoord(Coords[i])) { *SlotNum = i; return TRUE; } if (BlobRect.ContainsCoord(Coords[EndSlot])) { *SlotNum = EndSlot; return TRUE; } } // That sub path did not intersect the rect, so carry on EndSlot = i-1; } } #endif // No luck, so fail return FALSE; }

BOOL Path::IsOpenEnd (  const INT32  index  )

Tests to see if the index provided specifies either the first or last element in an open subpath. ie the index is a true end point. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/2/95 Parameters: index  = index of element to check [INPUTS] Returns: TRUE if this index is set to either end of an open subpath Definition at line 2617 of file paths.cpp. { // Do a quick sanity check if (index<0 || index>=UsedSlots || UsedSlots==0) return FALSE; // 0<=index<=UsedSlots-1 // Dereference the verbs PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // Check its not the end index INT32 end = index; FindEndElOfSubPath(&end); if (Verbs[end] & PT_CLOSEFIGURE) return FALSE; if (end==index) return TRUE; // Check for a start point return (Verbs[index]==PT_MOVETO); }

BOOL Path::IsPointCloseTo (  const DocCoord  ICoord, INT32  range, INT32 *  NearElement, double *  mu )

This routine can be used to determin whether a point is close enough to a path to allow some action to occur. The range input parameter can be used to determin the size of the sensitive area. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/94 Parameters: ICoord  = DocCoord of point of interest (eg MouseCoord) [INPUTS] range = specifes the squared perpendicular distance away from the path forming a region inside which a ICoord is said to be 'in range' NearElement  = path index pointer of closest element to be retured [OUTPUTS] mu = element parameter of closest point to be returned Returns: True if ICoord is in range. Definition at line 7065 of file paths.cpp. { double dist = SqrDistanceToPoint(ICoord, NearElement, mu); // if (IsUserName("Jim")) TRACE( _T("Distance from path = %f\n"),dist); if (dist<0) return FALSE; // return false (not close to path) return (dist<range); }

BOOL Path::IsRotate (   )

returns the Rotate flag for the coordinate Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: TRUE if the point has the rotate flag set, FALSE if not Definition at line 2536 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "PathPosition is out of Bounds in Path::IsRotate" ); // Get the flags array PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // and return the selected flag return Flags[CurrentPos].IsRotate; }

BOOL Path::IsSelected (   )

return the Selected flag for the coordinate Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: TRUE if the point is selected, FALSE if not Definition at line 2465 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "PathPosition is out of Bounds in Path::IsSelected" ); // Get the flags array PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // and return the selected flag return Flags[CurrentPos].IsSelected; }

BOOL Path::IsSmooth (   )

returns the Smooth flag for the Current Path Position Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/94 Returns: TRUE if the point is Smooth, FALSE if not Definition at line 2512 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "PathPosition is out of Bounds in Path::IsSmooth" ); // Get the flags array PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // and return the selected flag return Flags[CurrentPos].IsSmooth; }

BOOL Path::IsSubPathClosed (  INT32  Index  )

Scans to the end of this subpath to see if it has the PT_CLOSEFIGURE flag set. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 6/7/94 Parameters: Index  is the index of a point in the subpath [INPUTS] -  [OUTPUTS] Returns: TRUE if subpath is closed, FALSE otherwise Errors: - See also: - Definition at line 4722 of file paths.cpp. { INT32 i = Index; PathVerb* Verbs = GetVerbArray(); // skip through until we hit the end or a MoveTo do { i++; } while (i<UsedSlots && Verbs[i] != PT_MOVETO); // i points to the firsy element after this subpath (i.e. the top of the subpath) // Check the CloseFigure flag on the previous element to see if the subpath is closed if (Verbs[i-1] & PT_CLOSEFIGURE) return TRUE; return FALSE; }

BOOL Path::IsSubSelection (   )

determine if the path has a subselection Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/4/94 Returns: TRUE if any of the paths coords were selected Definition at line 3684 of file paths.cpp. { // We need to find all the selected control points in the path and de-select them PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // look for a selected coord for (INT32 i=0; i<UsedSlots; i++) { // if we find one then return TRUE if (Flags[i].IsSelected) return TRUE; } // we did not find one, so return FALSE return FALSE; }

BOOL Path::JoinToAnother (  Path *  OtherPath, INT32  MainIndex, INT32  OtherIndex )

This routine is used to join the end of a line to the end of another line. It will cope with the various possiblities: That both subpaths are in the same complex paths, that one or other of the subpaths are in different complex paths, and that one of the paths might need reversing. The other path is left untouched. This path will contain all subpaths from that one. This routine assumes that the two subpaths are different - it will not join the start and end of the same subpath. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 5/10/94 Parameters: OtherPath  is the path which we're joining to this one [INPUTS] MainIndex is the index of the point in this path we're joining OtherIndex is the index of the point in the other path we're joining to -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Errors: Returns FALSE if it failed (lack of memory, for example) See also: - Definition at line 6164 of file paths.cpp. { // First, get some indices pointing at the start and end of these subpaths INT32 MainSubStart; // Start of subpath in main path (this) INT32 MainSubEnd; // End of subpath in this path INT32 OtherSubStart; // Start of subpath in other path INT32 OtherSubEnd; // End of subpath in other path MainSubStart = MainSubEnd = MainIndex; FindStartOfSubPath(&MainSubStart); FindEndElOfSubPath(&MainSubEnd); OtherSubStart = OtherSubEnd = OtherIndex; OtherPath->FindStartOfSubPath(&OtherSubStart); OtherPath->FindEndElOfSubPath(&OtherSubEnd); ERROR2IF(((this == OtherPath) && (MainSubStart == OtherSubStart)), FALSE, "Attempted to join this subpath with itself"); // Because we'll be messing around with the path, it's easier if we make the // two indices relative to the starts of their respective subpaths MainIndex = MainIndex - MainSubStart; OtherIndex = OtherIndex - OtherSubStart; // Now that we know which subpaths we're interested in, let's see if we have to join the two paths if (this != OtherPath) { // OtherPath is not the same, so copy it into this one and adjust the subpath indices OtherSubStart += UsedSlots; OtherSubEnd += UsedSlots; //OtherIndex += UsedSlots; if (!MergeTwoPaths(*OtherPath)) return FALSE; } // Now this path contains both subpaths (and others, maybe) // If the subpaths were originally in the same path, it's possible that the other subpath // is below the main subpath. We don't want that possibility, so swap them if that's the case if (OtherSubStart < MainSubStart) { INT32 temp = OtherSubStart; OtherSubStart = MainSubStart; MainSubStart = temp; temp = OtherSubEnd; OtherSubEnd = MainSubEnd; MainSubEnd = temp; temp = OtherIndex; OtherIndex = MainIndex; MainIndex = temp; } // See if the two subpaths are adjacent now if (OtherSubStart - MainSubEnd >1) { // The two subpaths are not adjacent, so let's shuffle the path around... // It's just possible that the Othersection might be at the top of the path so move the // main section to the top. CurrentPos = UsedSlots; if (!MakeSpaceInPath(MainSubEnd-MainSubStart+1)) return FALSE; if (!InsertSectionAtEnd(this, MainSubStart, MainSubEnd-MainSubStart+1)) return FALSE; DeleteSection( MainSubStart, MainSubEnd-MainSubStart+1); // Recalculate the subpath indices MainSubEnd = MainSubEnd-MainSubStart+1; // Change into length MainSubStart = UsedSlots - MainSubEnd; OtherSubStart -= MainSubEnd; OtherSubEnd -= MainSubEnd; MainSubEnd = UsedSlots-1; // Now, are the subpaths adjacent? Main is now above Other if (MainSubStart - OtherSubEnd > 1) { // Do the same as above, but with Other instead of Main CurrentPos = UsedSlots; if (!MakeSpaceInPath(OtherSubEnd-OtherSubStart+1)) return FALSE; if (!InsertSectionAtEnd(this, OtherSubStart, OtherSubEnd-OtherSubStart+1)) return FALSE; DeleteSection( OtherSubStart, OtherSubEnd-OtherSubStart+1); // Recalculate the subpath indices OtherSubEnd = OtherSubEnd-OtherSubStart+1; // Change into length OtherSubStart = UsedSlots - OtherSubEnd; MainSubStart -= OtherSubEnd; MainSubEnd -= OtherSubEnd; OtherSubEnd = UsedSlots-1; } if (OtherSubStart < MainSubStart) { // Swap Main and Other indices INT32 temp = MainSubStart; MainSubStart = OtherSubStart; OtherSubStart = temp; temp = MainSubEnd; MainSubEnd = OtherSubEnd; OtherSubEnd = temp; temp = OtherIndex; OtherIndex = MainIndex; MainIndex = temp; } } // Now we are guaranteed that the two subpaths are adjacent and that Main is below Other // Let's see if we have to reverse anything MainIndex+=MainSubStart; OtherIndex+=OtherSubStart; if (MainIndex == MainSubStart) { // Because Main is below Other, this means we have to reverse this subpath... ReverseSection(MainSubStart, MainSubEnd-MainSubStart+1); MainIndex = MainSubEnd; } if (OtherIndex == OtherSubEnd) { // We have to reverse the other subpath ReverseSection(OtherSubStart, OtherSubEnd-OtherSubStart+1); OtherIndex = OtherSubStart; } // At INT32 last, it's possible just to join the subpaths - we do this by deleting the // MoveTo between them. DeleteSection(OtherSubStart,1); // And clear selection, then select just the point we want ClearSubSelection(); PathVerb* Verbs = GetVerbArray(); PathFlags* Flags = GetFlagArray(); Flags[MainSubEnd].IsSelected = TRUE; if (Verbs[MainSubEnd] == PT_BEZIERTO) Flags[MainSubEnd-1].IsSelected = TRUE; if (Verbs[MainSubEnd+1] == PT_BEZIERTO) Flags[MainSubEnd+1].IsSelected = TRUE; return TRUE; }

BOOL Path::MakePathFromSection (  const INT32  Start, const INT32  Length, Path *  pDestin )

Copies a specified section from this path to a specific position within another path. A gap is created if necessary to copy the data into. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: Start  = Position within this path to copy data from [INPUTS] Length = Number of items to copy pDestin = pointer to path to put copied section in. Returns: TRUE if the copy was a success, FALSE if it failed (lack of memory) Definition at line 7716 of file paths.cpp. { // Validate the input params ERROR3IF(Start>(UsedSlots-1),"MakePathFromSection given an illegal start index"); if (Start > (UsedSlots-1)) return FALSE; ERROR3IF((Start+Length)>UsedSlots,"MakePathFromSection given an illegal Length"); if ((Start+Length) > UsedSlots) return FALSE; // PathVerb* SourceVerbs = GetVerbArray(); BOOL ok = MergeSectionTo(Start, Length, pDestin, 0); if (ok) { PathVerb* pDestinVerbs = pDestin->GetVerbArray(); pDestinVerbs[0] = PT_MOVETO; } return ok; }

BOOL Path::MakePathFromSubPath (  const INT32  lSubpathIndex, Path *  ppthToFill )

Makes a subpath into a path in its own right. > BOOL Path::MakePathFromSubPath(const INT32 lSubpathIndex, Path* ppthToFill) Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 1/5/97 - Enough is enough Parameters: lSubpathIndex  Index of the subpath to copy - that is, [INPUTS] 0 copies the first subpath 1 copies the second etc ppthToFill Path to copy the subpath into ppthToFill  [OUTPUTS] Returns: TRUE if there were no problems See also: Imagemap::DrawPathToOutputDevice() Definition at line 10230 of file paths.cpp. { //Check our variables ERROR2IF(ppthToFill==NULL,FALSE, "Path::MakePathFromSubPath - null parameter"); ERROR2IF(lSubpathIndex>(GetNumSubpaths()-1),FALSE, "Path::MakePathFromSubPath - null parameter"); //First we must find the start and end of the subpath //This variable will find the start of the subpath INT32 lStart=0; //For each subpath we must skip over for (INT32 l=0; l<lSubpathIndex; l++) { //Move to the end of the current subpath FindEndElOfSubPath(&lStart); //Move on one place to take us into the next subpath lStart++; //And if we haven't overshot the end of the path if (lStart<GetNumCoords()) { //Move to the beginning of that subpath FindStartOfSubPath(&lStart); } } //If we have overshot the end of the path, return FALSE ERROR2IF(lStart>GetNumCoords(),FALSE, "Path::MakePathFromSubPath failed"); //lLookPos is now pointing to the start of the subpath we want to copy //This variable will find the end of that subpath INT32 lEnd=lStart; //And move it to the end of the subpath FindEndElOfSubPath(&lEnd); //Now, copy the subpath into the path MakePathFromSection(lStart, (lEnd-lStart+1), ppthToFill); //And return TRUE return TRUE; }

BOOL Path::MakeSpaceAtEnd (  INT32  NumSlots  )

Will make enough room for NumSlots unused slots at the end of the path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 01/02/94 Parameters: NumSlots  - The number of Unused slots you need free at the end of the path [INPUTS] Returns: TRUE if it was able to find the memory, FALSE if it failed Definition at line 3907 of file paths.cpp. { ERROR2IF(SlotAllocSize <= 0,FALSE,"MakeSpaceAtEnd has ZERO Slot Allocation Size!"); if (UnUsedSlots<NumSlots) { // Find out how many slots to ask for and make sure it is a multiple of 4 INT32 SlotsNeeded = NumSlots-UnUsedSlots; SlotsNeeded = ((INT32)(SlotsNeeded/SlotAllocSize))*SlotAllocSize+SlotAllocSize; SlotsNeeded = ((SlotsNeeded+3) >> 2) << 2; // we are out of spare slots, so try to alloc some extra ones if (!IncreaseBlock(VerbHandle, sizeof(PathVerb)*SlotsNeeded)) return FALSE; if (!IncreaseBlock(CoordHandle, sizeof(DocCoord)*SlotsNeeded)) return FALSE; if (!IncreaseBlock(FlagsHandle, sizeof(PathFlags)*SlotsNeeded)) return FALSE; if (ExtraInfo != NULL) if (!ExtraInfo->IncreaseExtraBlocks(SlotsNeeded)) return FALSE; // Got the memory back that we asked for, so update a few vars UnUsedSlots += SlotsNeeded; } return TRUE; }

BOOL Path::MakeSpaceInPath (  INT32  NumSlots, INT32  Position )

Checks to see if there is already enough memory available to make the insertion and if not will try to allocate some more memory. If this works it will move the path after the position indicated by Position along to make room for the correct number of slots at that point. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 01/02/94 Parameters: NumSlots  - The number of slots you need to put your new thing in [INPUTS] Position - The position at which to put the slots Returns: TRUE if it was able to find the memory, FALSE if it failed Definition at line 3883 of file paths.cpp. { if (!MakeSpaceAtEnd(NumSlots)) return FALSE; return OpenGap(NumSlots,Position); }

BOOL Path::MakeSpaceInPath (  INT32  NumSlots  )

Checks to see if there is already enough memory available to make the insertion and if not will try to allocate some more memory. If this works it will move the path (after the position indicated by the path class variable CurrentPos) along to make room for the correct number of slots at that point. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 01/02/94 Parameters: NumSlots  - The number of slots you need to put your new thing in [INPUTS] Returns: TRUE if it was able to find the memory, FALSE if it failed Definition at line 3857 of file paths.cpp. { if (!MakeSpaceAtEnd(NumSlots)) return FALSE; return OpenGap(NumSlots,CurrentPos); }

void Path::MapWidth (  ChannelIndex  Index  )

Alters the mapping of the Width Information to one of the ExtraInfo channels. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/94 Returns: - Definition at line 8313 of file paths.cpp. { ENSURE(Index <= NUMEXTRACHANNELS, "Index out of range in MapWidth()"); ExtraInfo->MapWidthInfo(Index); }

BOOL Path::MergeSectionFrom (  INT32  DestinPos, const Path &  Source, INT32  SourcePos, INT32  Length )

Copies a specified section from a source path to a specified position in this path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: DestinPos  = Index of where to copy path elements to [INPUTS] All existing items from this index onwards will move up. Source = Object to take elements from SourcePos = Position in source to start copying elements from Length = Number of elements to copy over Returns: TRUE if the merge was a success, FALSE if it failed (lack of memory) Definition at line 6061 of file paths.cpp. { // Make space to copy all the data from the other path into this one CurrentPos = DestinPos; if (!MakeSpaceInPath(Length)) // Failed to get extra memory return FALSE; // We will need all the arrays for both paths DocCoord* DCoords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* DFlags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* DVerbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* SCoords = (DocCoord*) DescribeHandle(Source.CoordHandle); PathFlags* SFlags = (PathFlags*) DescribeHandle(Source.FlagsHandle); PathVerb* SVerbs = (PathVerb*) DescribeHandle(Source.VerbHandle); // Copy all the data memmove((void*)(DCoords+DestinPos), (void*)(SCoords+SourcePos), Length*sizeof(DocCoord)); memmove((void*)(DVerbs+DestinPos), (void*)(SVerbs+SourcePos), Length*sizeof(PathVerb)); memmove((void*)(DFlags+DestinPos), (void*)(SFlags+SourcePos), Length*sizeof(PathFlags)); UsedSlots+=Length; UnUsedSlots-=Length; // and say that it worked return TRUE; }

BOOL Path::MergeSectionTo (  INT32  SourcePos, INT32  Length, Path *  Destin, INT32  DestinPos )

Copies a specified section from this path to a specific position within another path. A gap is created if necessary to copy the data into. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: SourcePos  = Position within this path to copy data from [INPUTS] Length = Number of items to copy Destin = Pointer to path to copy items to DestinPos = Position in destin path top copy data to All existing items from this index and beyond will move up Returns: TRUE if the copy was a success, FALSE if it failed (lack of memory) Definition at line 6110 of file paths.cpp. { // Make space to copy all the data this path to the destination Destin->CurrentPos = DestinPos; if (!Destin->MakeSpaceInPath(Length)) // Failed to get extra memory return FALSE; // We will need all the arrays for both paths DocCoord* SCoords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* SFlags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* SVerbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* DCoords = (DocCoord*) DescribeHandle(Destin->CoordHandle); PathFlags* DFlags = (PathFlags*) DescribeHandle(Destin->FlagsHandle); PathVerb* DVerbs = (PathVerb*) DescribeHandle(Destin->VerbHandle); // Copy all the data memmove((void*)(DCoords+DestinPos), (void*)(SCoords+SourcePos), Length*sizeof(DocCoord)); memmove((void*)(DVerbs+DestinPos), (void*)(SVerbs+SourcePos), Length*sizeof(PathVerb)); memmove((void*)(DFlags+DestinPos), (void*)(SFlags+SourcePos), Length*sizeof(PathFlags)); Destin->UsedSlots+=Length; Destin->UnUsedSlots-=Length; // and say that it worked return TRUE; }

BOOL Path::MergeTwoPaths (  DocCoord *  OtherCoords, PathVerb *  OtherVerbs, PathFlags *  OtherFlags, INT32  Length, BOOL  Filled )

Appends the data in the three given arrays to the arrays in this path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> (Split from Path& varient by Markn 22/11/94) Date: 27/4/94 Parameters: OtherCoords  = ptr to a coords array [INPUTS] OtherVerbs = ptr to a verbs array OtherFlags = ptr to a flags array Length = the number of elements in the three arrays Filled = TRUE if the arrays represent a filled path Returns: TRUE if the merge was a success, FALSE if it failed (lack of memory) Definition at line 5340 of file paths.cpp. { // Do we have enough room? if (UnUsedSlots < Length) return FALSE; // We will need all the arrays for both paths DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // Copy all the data INT32 DestPos = UsedSlots; for (INT32 i=0; i<Length; i++) { // Copy this coord and its associated data Coords[DestPos] = OtherCoords[i]; Flags[DestPos] = OtherFlags[i]; Verbs[DestPos] = OtherVerbs[i]; // move to the next position DestPos++; UsedSlots++; UnUsedSlots--; } // If the other path was closed and marked as filled, then // the new path should also be filled if (Filled) IsFilled = TRUE; // Put current pos to the end of the used slots CurrentPos = UsedSlots; // and say that it worked return TRUE; }

BOOL Path::MergeTwoPaths (  const Path &  Other  )

Combines the two paths into a single complex path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> (Split to arrays varient by Markn 22/11/94) Date: 27/4/94 Parameters: Other  - A reference to another path to merge with this one [INPUTS] Returns: TRUE if the merge was a success, FALSE if it failed (lack of memory) Definition at line 5309 of file paths.cpp. { // Make space to copy all the data from the other path into this one CurrentPos = UsedSlots; if (!MakeSpaceInPath(Other.UsedSlots)) return FALSE; DocCoord* OtherCoords = (DocCoord*) DescribeHandle(Other.CoordHandle); PathVerb* OtherVerbs = (PathVerb*) DescribeHandle(Other.VerbHandle); PathFlags* OtherFlags = (PathFlags*) DescribeHandle(Other.FlagsHandle); return MergeTwoPaths(OtherCoords,OtherVerbs,OtherFlags,Other.UsedSlots,Other.IsFilled); }

void Path::NextExtraInfo (   )  [inline]

Definition at line 525 of file paths.h. { ExtraInfo->Next(); }

INT32 Path::NumSplinters (   )

Returns the number of splinters a selected path will be broken into when calls to BreakPath is called. Splinters include opened subpaths, ie if the algorithm will open a closed subpath, this is classed as a spinter along with breaking a path in two. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> (& Markn) Date: 4/9/94 Parameters: [INPUTS]  -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 9268 of file paths.cpp. { // New implementation by Markn 15/2/95 // This version will return 2 when there's a selected point in the middle of a line. The old code // returned 1 in this case INT32 Index = -1; INT32 EndIndex = -1; INT32 LastEndIndex = -1; INT32 NumSplinters = 0; BOOL SubPathOpen; PathVerb* pVerbs = GetVerbArray(); while (Index++, FindNextSelected(&Index)) { PathVerb Verb = pVerbs[Index] & ~PT_CLOSEFIGURE; // Ignore selected moveto elements if (Verb == PT_MOVETO) continue; EndIndex = Index; FindEndElOfSubPath(&EndIndex); // returns index of last element in this subpath/path SubPathOpen = !(pVerbs[EndIndex] & PT_CLOSEFIGURE); // ignore selected end points when the subpath is open if (Index == EndIndex && SubPathOpen) continue; NumSplinters++; if (EndIndex != LastEndIndex) { LastEndIndex = EndIndex; // if we have found a selected point in the middle of an open subpath // an extra splinter will be produced. if (SubPathOpen) NumSplinters++; } } return NumSplinters; /* // Get array of verbs PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // p,q indexes to selected point and endof(sub)path // vp,vq local verb holders INT32 p = -1; INT32 q = -1; PathVerb vp; PathVerb vq; INT32 splinters = 0; while (p++, FindNextSelected(&p)) { q = p; FindEndElOfSubPath(&q); // returns index of last element in this subpath/path if (p>q) break; // just a quick check on sanity. if (p==q) { if (!(Verbs[p] & PT_CLOSEFIGURE)) continue; // ignore selected points at end of open subpaths } vp = (Verbs[p] & ~PT_CLOSEFIGURE); vq = (Verbs[q]); if (vp==PT_MOVETO) { if (!(vq & PT_CLOSEFIGURE)) // is this sub path already open? { p++; // move forward past moveto continue; // continue do loop } } if ((vp == PT_MOVETO) || (vp == PT_LINETO) || (vp == PT_BEZIERTO)) splinters++; } return splinters; */ }

BOOL Path::OpenGap (  INT32  NumSlots, INT32  Position )

Will open up a gap of NumSlots at the position Position within the path. If Position is set to the end of the path ie the same value as usedslots, no data will be moved. FALSE will ofcourse always be returned if there is not enough free space in the form of unused slots on the end of the path for the gap to open. Use MakeSpaceInPath() if you know there isn't enough room. See Also: MakeSpaceInPath, MakeSpaceAtEnd. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 01/02/94 Parameters: NumSlots  = The size of the gap to open [INPUTS] Position = The index at which to open the gap (0...UsedSlots) Returns: TRUE if it was able to open the gap FALSE if it failed Definition at line 3976 of file paths.cpp. { if (UnUsedSlots<NumSlots) { ERROR3("Path::OpenGap() overflow: Gap request is too large"); return FALSE; } if (Position<0 || Position>UsedSlots) { ERROR3("Path::OpenGap() called with an illegal gap position"); return FALSE; } INT32 SlotsToMove = UsedSlots-Position; if (SlotsToMove>0) { PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); memmove( (void*)(&Verbs[Position+NumSlots]), (void*)(&Verbs[Position]), SlotsToMove*sizeof(PathVerb) ); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); memmove( (void*)&Coords[Position+NumSlots], (void*)&Coords[Position], SlotsToMove*sizeof(DocCoord) ); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); memmove( (void*)&Flags[Position+NumSlots], (void*)&Flags[Position], SlotsToMove*sizeof(PathFlags) ); if (ExtraInfo != NULL) ExtraInfo->ShiftUpExtraInfo(Position, NumSlots, SlotsToMove); } return TRUE; }

BOOL Path::OpenGap (  INT32  NumSlots  )

Will open a gap of NumSlots size in this path. The gap is positioned at CurrentPos (A path class variable). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 01/02/94 Parameters: NumSlots  - The size of the gap to open [INPUTS] Returns: TRUE if it was able to find the memory, FALSE if it failed Definition at line 3951 of file paths.cpp. { return OpenGap(NumSlots, CurrentPos); }

BOOL Path::PointCloseToLine (  DocCoord  pos, INT32 *  position )

This function takes the coordinate pos, and sees if it is close to a line (close enough to drag the line around). It returns TRUE if the point is close enough, and position is an index to the element that it was closest to. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/94 Parameters: pos  - mouse position to be tested [INPUTS] position  - index to the point that was matched [OUTPUTS] unchanged if no match Returns: TRUE if a match was found, FALSE if not Since this routine requires maths beyond that of which I am capable, it returns FALSE at the moment Definition at line 7163 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARLIB) /* double d; INT32 Near; double Param; d = SqrDistanceToPoint(pos, &Near, &Param); TRACE( _T("Index=%d\n"),Near); DocCoord coord; coord = ClosestPointTo(Param, Near); TRACE( _T("x=%d, y=%d\n"),coord.x,coord.y); */ DocRect temp; GetApplication()->GetBlobManager()->GetBlobRect(DocCoord(0,0),&temp); double mu; INT32 width = (temp.Width())/2; return (IsPointCloseTo(pos, width*width, position, &mu)); // return(FALSE); #else return FALSE; #endif }

BOOL Path::Quantise (  const double  threshold, Path *  pOutput )

Quantise a path. All curves within the path will be approximated by straight lines. pOutput may point at 'this' path ie a path can be quantised to itself. If the quantising fails for some reason, the output path will be unaffected EVEN if you're quantising a path to itself. Note, Quantising differs from flattening in that it will approximate straight lines within a path, generating n colinear points for each line it meets. Whereas flattening does nothing with lines. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/94 Parameters: threshold  = How quantised the curves should be (around 64 is good) [INPUTS] pOutput  = will contain the quantised path [OUTPUTS] Returns: BOOL = TRUE if the path was flattened successfully = FALSE then output path will be unaffected Definition at line 7827 of file paths.cpp. { // when flattening, flatten curves but dont quantise lines ProcessFlags QuantFlags(TRUE,TRUE); return CreateFlatPath(QuantFlags, threshold, pOutput); }

void Path::RenderPathBlobs (  RenderRegion *  pRender  )

Draws all the selection blobs for a path. Useful for putting the blobs on or taking them back off again. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> (split from pSpread varient by Markn) Date: 9/11/94 Parameters: pRender  - The render region to draw into [INPUTS] Definition at line 3001 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Dereference the pointers DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); BOOL PrevIsEndPoint; DocCoord StartCoord = Coords[0]; // loop through the path and render each of the blobs INT32 endcount = 0; // Count the number of selected endpoints INT32 EndPtIndex = 0; // Index of only selected endpoint for (INT32 i=0; i<UsedSlots; i++) { if (Flags[i].IsEndPoint) { // Render a blob if (!((Verbs[i] & PT_CLOSEFIGURE) && Coords[i]==StartCoord)) { DrawBlob(pRender, Coords[i], Flags[i].IsSelected); // count the number of selected endpoints if (Flags[i].IsSelected) { EndPtIndex = i; endcount++; } } //GdiFlush(); PrevIsEndPoint = TRUE; if (Verbs[i] == PT_MOVETO) StartCoord = Coords[i]; } } // Now render the control point blobs if there was just one selected endpoint if (endcount == 1) { RenderPathControlBlobs(pRender, EndPtIndex); } #endif }

void Path::RenderPathBlobs (  Spread *  pSpread  )

Draws all the selection blobs for a path. Useful for putting the blobs on or taking them back off again. This goes into its own RenderOnTop loop and calls RenderPathBlobs(RenderRegion* pRender). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 24/02/94 Parameters: pSpread  - spread to render into [INPUTS] Definition at line 2974 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Go into a RenderOnTop loop RenderRegion* pRender = DocView::RenderOnTop(NULL, pSpread, ClippedEOR); while (pRender!=NULL) { RenderPathBlobs(pRender); pRender = DocView::GetNextOnTop(NULL); } #endif }

void Path::RenderPathControlBlobs (  RenderRegion *  pRender, INT32  EndPtIndex )

Draws all the control points selection blobs for a path. Used by RenderPathBlobs and also the Bezier tool. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> (from Rik Code - split from pSpread varient by Markn) Date: 9/11/94 Parameters: pRender  = ptr to render region to render into [INPUTS] EndPtIndex - the index of the endpoint around which the control points are to be rendered. Definition at line 3216 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Dereference the pointers DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); // PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // Render the appropriate control points // We render the two control points adjacent to the only // selected endpoint, but we also render the two control points beyond // those, because their positions might affect the curve. // A special case is when we have a closed path containing // only a moveto and a curveto (it could happen) in which case // we'll have to spot that, and only render two controls instead // of four // find the index of the previous ctrl point of this endpoint INT32 i = FindPrevControlPoint(EndPtIndex); if (i>=0) { DrawControlBlob(pRender, Coords[i]); DrawControlLine(pRender, Coords[i], Coords[EndPtIndex]); DrawControlBlob(pRender, Coords[i-1]); DrawControlLine(pRender, Coords[i-1], Coords[i-2]); } // now do the next control point. Don't render if the next // is still part of the same path INT32 j = FindNextControlPoint(EndPtIndex); if (j>=0 && j!=i-1) { DrawControlBlob(pRender, Coords[j]); DrawControlLine(pRender, Coords[j], Coords[EndPtIndex]); DrawControlBlob(pRender, Coords[j+1]); DrawControlLine(pRender, Coords[j+1], Coords[j+2]); } #endif }

void Path::RenderPathControlBlobs (  Spread *  pSpread, INT32  EndPtIndex )

Draws the control points selection blobs for an endpoint on a path. Used by RenderPathBlobs and also the Bezier tool. This goes into its own RenderOnTop loop. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> (from Rik Code) Date: 19/10/94 Parameters: pSpread  - pointer to the spread containing the path [INPUTS] EndPtIndex - the index of the endpoint around which the control points are to be rendered. Definition at line 3187 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Go into a RenderOnTop loop RenderRegion* pRender = DocView::RenderOnTop(NULL, pSpread, ClippedEOR); while (pRender!=NULL) { RenderPathControlBlobs(pRender,EndPtIndex); pRender = DocView::GetNextOnTop(NULL); } #endif }

void Path::RenderPathPenBlobs (  RenderRegion *  pRegion  )

Draws all the selection blobs and pen blobs for a path. Useful for putting the blobs on or taking them back off again. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> (via Rik) Date: 28/09/94 Parameters: pRegion  - The render region to draw into [INPUTS] Definition at line 3298 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Dereference the pointers DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord StartCoord = Coords[0]; INT32 SelEndPts = 0; // loop through the path and render each of the blobs INT32 EndPtIndex = 0; // Index of only selected endpoint INT32 i; for (i=0; i<UsedSlots; i++) { if (Flags[i].IsEndPoint) { // Render a blob if (!((Verbs[i] & PT_CLOSEFIGURE) && Coords[i]==StartCoord)) { DrawBlob(pRegion, Coords[i], Flags[i].IsSelected); // count the number of selected endpoints if (Flags[i].IsSelected) { EndPtIndex = i; SelEndPts++; } } if (Verbs[i] == PT_MOVETO) StartCoord = Coords[i]; } } // now make sure the correct control handles are drawn if (SelEndPts == 1) { if (Flags[EndPtIndex].IsRotate && IsOpenEnd(EndPtIndex)) { if (Verbs[EndPtIndex] == PT_MOVETO) i = FindNextControlPoint(EndPtIndex); else i = FindPrevControlPoint(EndPtIndex); if (i>=0) { DocCoord GhostPt; GhostPt.x = Coords[EndPtIndex].x - (Coords[i].x - Coords[EndPtIndex].x); GhostPt.y = Coords[EndPtIndex].y - (Coords[i].y - Coords[EndPtIndex].y); pRegion -> SetLineColour(COLOUR_BEZIERLINE); pRegion -> SetFillColour(COLOUR_TRANS); pRegion -> DrawLine(GhostPt, Coords[i]); pRegion -> SetLineColour(COLOUR_TRANS); pRegion -> SetFillColour(COLOUR_UNSELECTEDBLOB); pRegion -> DrawBlob(GhostPt, BT_UNSELECTED); pRegion -> DrawBlob(Coords[i], BT_UNSELECTED); } } } #endif }

void Path::RenderPathPenBlobs (  Spread *  pSpread  )

Draws all the selection blobs and pen blobs for a path. Useful for putting the blobs on or taking them back off again. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 28/09/94 Parameters: pSpread  - The render spread to draw into [INPUTS] Definition at line 3272 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Go into a RenderOnTop loop RenderRegion* pRender = DocView::RenderOnTop(NULL, pSpread, ClippedEOR); while (pRender!=NULL) { RenderPathPenBlobs(pRender); pRender = DocView::GetNextOnTop(NULL); } #endif }

void Path::RenderPathSelectedControlBlobs (  Spread *  pSpread, RenderRegion *  pRender )

Draws all the control points selection blobs for an entire path into a specified render region. Called by the above function. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 28/5/95 Parameters: pSpread  - pointer to the spread containing the path [INPUTS] pRender - pointer to region to render into See also: Path::RenderPathSelectedControlBlobs Definition at line 3097 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR3IF(pSpread == NULL, "pSpread was NULL"); ERROR3IF(pRender == NULL, "pRender was NULL"); if ((pRender == NULL) || (pSpread == NULL)) return ; // loop through the path and count the selected blobs PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); const INT32 NumCoords = GetNumCoords(); INT32 endcount = 0; // Count the number of selected endpoints INT32 EndPtIndex = 0; // Index of only selected endpoint for (INT32 i=0; i<NumCoords; i++) { if (Flags[i].IsEndPoint && Flags[i].IsSelected) { if (!(Verbs[i] & PT_CLOSEFIGURE)) { EndPtIndex = i; endcount++; DrawBlob(pRender, Coords[i], TRUE); DrawBlob(pRender, Coords[i], FALSE); } } } if (endcount == 1) { // Remove the control points and lines RenderPathControlBlobs(pRender, EndPtIndex); } #endif }

void Path::RenderPathSelectedControlBlobs (  Spread *  pSpread, BOOL  Removing = TRUE )

Draws all the control points selection blobs for an entire path. If you are to change the selection flags on a path then call this to remove all selection blobs, do your change, then call this again to draw the new blobs. This goes into its own RenderOnTop loop. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 23/1/95 Parameters: pSpread  - pointer to the spread containing the path [INPUTS] Removing - TRUE if the blobs are being removed (ie rendered off) Definition at line 3061 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // If removing then render on into pending render regions first // if (Removing) // RenderSelectedControlBlobsToPendingRegions(pSpread); // Render the blobs on the path RenderRegion* pRender = DocView::RenderOnTop(NULL, pSpread, ClippedEOR); while (pRender!=NULL) { RenderPathSelectedControlBlobs(pSpread, pRender); pRender = DocView::GetNextOnTop(NULL); } // If putting back on then render back off in pender render regions // if (!Removing) // RenderSelectedControlBlobsToPendingRegions(pSpread); #endif }

void Path::RenderSelectedControlBlobsToPendingRegions (  Spread *  pSpread  )

Draws all the control points selection blobs for an entire path into all the pending render regions. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 28/5/95 Parameters: pSpread  - pointer to the spread containing the path [INPUTS] See also: Path::RenderPathSelectedControlBlobs Definition at line 3147 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (!pRegionList->IsEmpty()) { RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion != NULL) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread) { // Render the blobs into this Render Region. RenderPathSelectedControlBlobs(pSpread, pRegion); } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } #endif }

BOOL Path::RetroReplaceSection (  INT32  StartSlot, INT32  Len, Path *  NewPath, BOOL  KeepStart )

Deletes all the elements in the path from StartSlot to StartSlot+NumSlots and then inserts the whole of NewPath into the hole. If the hole is not big enough, then it is made bigger and if it is too big, then it is shrunk. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/5/94 Parameters: StartSlot  - The slot to start replacing from [INPUTS] NumSlots - The number of slots to replace NewPath - The new path to place in the path to replace the elements from StartSlot to StartSlot+NumSlots KeepStart - TRUE if the initial moveto of the NewPath should be pasted into the path, FALSE if you want to throw away the initial moveto. Returns: TRUE if it worked, FALSE if it failed (Could not alloc memory if NewPath is bigger than the section it was replacing Definition at line 7339 of file paths.cpp. { // Saftey Checks ENSURE( StartSlot<UsedSlots, "PathPosition is off end of path in Path::RetroReplaceSection" ); ENSURE( StartSlot>=0, "PathPosition is off beginning of path in Path::RetroReplaceSection" ); // Make enough space in the path to copy the new path in after the marked section has been removed INT32 SlotsToAdd = NewPath->UsedSlots - Len; if (SlotsToAdd>0) { // We need more space as the new path is bigger than the gap CurrentPos = StartSlot+1; if (!MakeSpaceInPath(SlotsToAdd)) // Failed to get the memory, so fail return FALSE; // Update the usage counters UsedSlots += SlotsToAdd; UnUsedSlots -= SlotsToAdd; } // Dereference the pointers PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // If the section to be replaced is bigger than the new path, then we should move the end of // the path down a bit if (SlotsToAdd<0) { // Find out how much memory to move about INT32 SlotToMoveFrom = StartSlot+Len; INT32 SlotToMoveTo = StartSlot+NewPath->UsedSlots; INT32 SlotsToMove = UsedSlots-SlotToMoveFrom; // Does it need moving if (SlotsToMove>0) { // yep, move it memmove((void*)(&Verbs[SlotToMoveTo]), (void*)(&Verbs[SlotToMoveFrom]), SlotsToMove*sizeof(PathVerb)); memmove((void*)(&Flags[SlotToMoveTo]), (void*)(&Flags[SlotToMoveFrom]), SlotsToMove*sizeof(PathFlags)); memmove((void*)(&Coords[SlotToMoveTo]), (void*)(&Coords[SlotToMoveFrom]), SlotsToMove*sizeof(DocCoord)); } // Change the path flags (SlotsToAdd is negative in here) UsedSlots += SlotsToAdd; UnUsedSlots -= SlotsToAdd; } // Find out about the pointers to the new path PathVerb* NewVerbs = (PathVerb*) DescribeHandle(NewPath->VerbHandle); DocCoord* NewCoords = (DocCoord*) DescribeHandle(NewPath->CoordHandle); PathFlags* NewFlags = (PathFlags*) DescribeHandle(NewPath->FlagsHandle); // Now we have to copy NewPath into the hole INT32 ReadStart, ReadLen, WriteStart; // Work out which section we are copying if (KeepStart) { // Here we are keeping the initial moveto in the replacement path ReadStart = 0; ReadLen = NewPath->UsedSlots; WriteStart = StartSlot; } else { // Here we are throwing away the Moveto in the replacement path ReadStart = 1; ReadLen = NewPath->UsedSlots-1; WriteStart = StartSlot+1; } // Go though the path replacing all the relavent sections for (INT32 i=ReadStart; i<ReadStart+ReadLen; i++) { // Copy the data from the new path into the old path Verbs[WriteStart] = NewVerbs[i]; Flags[WriteStart] = NewFlags[i]; Coords[WriteStart] = NewCoords[i]; // increment the destination slot WriteStart++; } // See if this is a closed shape TryToClose(); // All worked, so return happy return TRUE; }

void Path::Reverse (   )

Reverses this path, so that it is rendered and traversed etc in the other direction. This involves reversing the order of all the coords etc in the path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 7/4/94 Definition at line 5080 of file paths.cpp. { ReverseSection(0, UsedSlots); }

void Path::ReverseSection (  INT32  FirstPos, INT32  SubPathLen )

Reverses the direction of the section of the path specified. This is typically used to reverse subpaths of a complex path. It is also called by Reverse, to reverse the entire path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/94 Parameters: StartSlot  - The slot in the path where the sub path begins [INPUTS] Returns: Errors: ENSUREs if StartSlot is not at the start of a subpath Definition at line 5100 of file paths.cpp. { // We will need to change all the arrays DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // First we will reverse all the Coords and their flags INT32 LastPos = FirstPos+SubPathLen-1; INT32 Start = FirstPos; DocCoord SwapCoord; PathFlags SwapFlag; while (FirstPos<LastPos) { // change the order of the coords in the array SwapCoord = Coords[FirstPos]; Coords[FirstPos] = Coords[LastPos]; Coords[LastPos] = SwapCoord; // Change the order of the flags associated with the coord SwapFlag = Flags[FirstPos]; Flags[FirstPos] = Flags[LastPos]; Flags[LastPos] = SwapFlag; // find the next two coords/flags to swap FirstPos++; LastPos--; } // Now reverse the verbs. // The first verb always stays as a MoveTo and everything else gets sorted around it FirstPos = Start+1; LastPos = Start+SubPathLen-1; PathVerb SwapVerb; while (FirstPos<LastPos) { SwapVerb = Verbs[FirstPos]; Verbs[FirstPos] = Verbs[LastPos]; Verbs[LastPos] = SwapVerb; // Find the next two verbs to swap FirstPos++; LastPos--; } // added by Ed 23/5/95 - fix up screwed up closed paths! // ie first element of subpath has PT_CLOSEFIGURE rather than last! INT32 StartOfSubPath = Start; INT32 EndElOfLastSubPath = Start+SubPathLen-1; #ifdef _DEBUG // check assumption that we are reversing a set of complete subpaths INT32 temp=StartOfSubPath; FindStartOfSubPath(&temp); ERROR3IF(StartOfSubPath!=temp,"Path::ReverseSection() - section does not start at the start of a subpath"); temp=EndElOfLastSubPath-1; FindEndElOfSubPath(&temp); ERROR3IF(EndElOfLastSubPath!=temp,"Path::ReverseSection() - section does not end at the end of a subpath"); #endif // for each subpath, if the second element has an erroneous PT_CLOSEFIGURE, // move it to the end element of the subpath while (StartOfSubPath<=EndElOfLastSubPath) { INT32 EndElOfSubPath=StartOfSubPath; FindEndElOfSubPath(&EndElOfSubPath); if (Verbs[StartOfSubPath+1] & PT_CLOSEFIGURE) { Verbs[StartOfSubPath+1]&=~PT_CLOSEFIGURE; Verbs[EndElOfSubPath] |= PT_CLOSEFIGURE; } StartOfSubPath=EndElOfSubPath+1; } return; }

void Path::RotateElementsLeft (  const INT32  Start, const INT32  End, INT32  Rotate )

Rotates the specified elements in a path by the number of positions indicated. Elements will be rotated from right to left. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 04/09/94 Parameters: Start  = The index of the first element in the component list [INPUTS] End = The index of the last element in the component list Rotate = The number of positions to rotate left by. This may be negative, in which case the path data will be rotated right by the specified amount. -  [OUTPUTS] Returns: - Definition at line 8997 of file paths.cpp. { // just make sure the start and end positions are sensible INT32 Width = End-Start+1; if (Width<2) return; Rotate = Rotate % Width; if (Rotate==0) return; if (Start<0) return; if (End>=UsedSlots) return; // make a rotate right into a rotate left if (Rotate<0) Rotate=Width-Rotate; INT32 Shift = 64; INT32 Step = Rotate/Shift; INT32 Residual = Rotate % Shift; UINT32 Size = sizeof(PathVerb); if (Size<sizeof(PathFlags)) Size=sizeof(PathFlags); if (Size<sizeof(DocCoord)) Size=sizeof(DocCoord); void* TempBuff = (void*)CCMalloc(Shift*Size); // Get arrays of flags,verbs and points. PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); if (TempBuff!=NULL) { void* Destin; void* Source; while (Step>0) { Destin = TempBuff; Source = (void*)&Flags[Start]; memmove(Destin, Source, Shift*sizeof(PathFlags)); Destin = (void*)&Flags[Start]; Source = (void*)&Flags[Start+Shift]; memmove(Destin, Source, (Width-Shift)*sizeof(PathFlags)); Destin = (void*)&Flags[End-Shift+1]; Source = TempBuff; memmove(Destin, Source, Shift*sizeof(PathFlags)); Destin = TempBuff; Source = (void*)&Verbs[Start]; memmove(Destin, Source, Shift*sizeof(PathVerb)); Destin = (void*)&Verbs[Start]; Source = (void*)&Verbs[Start+Shift]; memmove(Destin, Source, (Width-Shift)*sizeof(PathVerb)); Destin = (void*)&Verbs[End-Shift+1]; Source = TempBuff; memmove(Destin, Source, Shift*sizeof(PathVerb)); Destin = TempBuff; Source = (void*)&Coords[Start]; memmove(Destin, Source, Shift*sizeof(DocCoord)); Destin = (void*)&Coords[Start]; Source = (void*)&Coords[Start+Shift]; memmove(Destin, Source, (Width-Shift)*sizeof(DocCoord)); Destin = (void*)&Coords[End-Shift+1]; Source = TempBuff; memmove(Destin, Source, Shift*sizeof(DocCoord)); Step--; } if (Residual>0) { Destin = TempBuff; Source = (void*)&Flags[Start]; memmove(Destin, Source, Residual*sizeof(PathFlags)); Destin = (void*)&Flags[Start]; Source = (void*)&Flags[Start+Residual]; memmove(Destin, Source, (Width-Residual)*sizeof(PathFlags)); Destin = (void*)&Flags[End-Residual+1]; Source = TempBuff; memmove(Destin, Source, Residual*sizeof(PathFlags)); Destin = TempBuff; Source = (void*)&Verbs[Start]; memmove(Destin, Source, Residual*sizeof(PathVerb)); Destin = (void*)&Verbs[Start]; Source = (void*)&Verbs[Start+Residual]; memmove(Destin, Source, (Width-Residual)*sizeof(PathVerb)); Destin = (void*)&Verbs[End-Residual+1]; Source = TempBuff; memmove(Destin, Source, Residual*sizeof(PathVerb)); Destin = TempBuff; Source = (void*)&Coords[Start]; memmove(Destin, Source, Residual*sizeof(DocCoord)); Destin = (void*)&Coords[Start]; Source = (void*)&Coords[Start+Residual]; memmove(Destin, Source, (Width-Residual)*sizeof(DocCoord)); Destin = (void*)&Coords[End-Residual+1]; Source = TempBuff; memmove(Destin, Source, Residual*sizeof(DocCoord)); } CCFree(TempBuff); } else { PathFlags TempFlags; PathVerb TempVerb; DocCoord TempCoord; while (Rotate>0) { TempFlags = Flags[Start]; TempVerb = Verbs[Start]; TempCoord = Coords[Start]; for (INT32 i=Start; i<End; i++) { Flags[i] = Flags[i+1]; Verbs[i] = Verbs[i+1]; Coords[i] = Coords[i+1]; } Flags[End]=TempFlags; Verbs[End]=TempVerb; Coords[End]=TempCoord; Rotate--; } } }

void Path::Scale (  const DocCoord  dcOrigin, const double  dDPI = 96.0 )

This function is called on a path specified in DocCoords, to convert it into pixel coordinates. > void Path::Scale(const DocCoord dcOrigin, const double dDPI=96.0) Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Parameters: dDPI  The DPI by which to scale the path [INPUTS] dcOrigin The origin by which to scale the path This point should be the top left hand corner of the region that is used to create a bitmap. This is used in imagemaps, to convert a path specified in the document to a polygon to specify an imagemap clickable area over a bitmap. This function does the following to all the coordinates in the path a. Subtracts the origin dcOrigin b. Inverts the y-axis c. Multiplies the coordinates to convert them to the number of DPI specified. See also: Imagemap::AddPolygon() Definition at line 10184 of file paths.cpp. { //First find out how many coordinates we have to process INT32 lNumCoords=GetNumCoords(); //And get a pointer to the array DocCoord* pdcArray=GetCoordArray(); //For every coord in the array for (INT32 l=0; l<lNumCoords; l++) { //Get a pointer to the coordinate we are changing DocCoord* pdcThisCoord=&pdcArray[l]; if (pdcThisCoord==NULL) { ERROR2RAW("Path::Scale - coord error"); return; } //And scale it pdcThisCoord->Scale(dcOrigin, (float)dDPI); } }

void Path::SetAllSubSelection (   )

Goes through the path and sets all the IsSelected flags to TRUE, also selecting all control points in the path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 5/1/95 Definition at line 3663 of file paths.cpp. { PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); for (INT32 i=0; i<UsedSlots; i++) Flags[i].IsSelected = TRUE; }

void Path::SetFlags (  const PathFlags &  NewFlags  )

Sets the flags at the current path position to the flags provided. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/02/94 Parameters: NewFlags  - The flags you want to set [INPUTS] Definition at line 2712 of file paths.cpp. { ENSURE( CurrentPos<UsedSlots, "PathPosition is out of Bounds in Path::IsEndPoint" ); // Get the flags array PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); // and set the flags Flags[CurrentPos] = NewFlags; }

void Path::SetPathPosition (  INT32  NewPos  )

Sets the current path position to the value supplied. This represents the Coord number in the path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/02/94 Parameters: NewPos  - the Position you want to go to [INPUTS] Definition at line 1018 of file paths.cpp. { // Set the pos to the position supplied CurrentPos = NewPos; // make sure it was in bounds if (CurrentPos>=UsedSlots) CurrentPos = UsedSlots-1; if (CurrentPos<0) CurrentPos = 0; }

BOOL Path::SimpleJoin (  Path *  Other, INT32 *  OtherStartSlot, BOOL *  IsOtherReversed, BOOL *  ThisReversed = NULL )

Joins two paths to form a new, longer path. Both the paths invloved are simple (ie not complex). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/94 Parameters: Other  - the path to join with this path [INPUTS] OtherStartSlot  - The Slot number in the combined path where the path [OUTPUTS] Other starts. IsOtherReversed - TRUE if the 'Other' path was reversed during the joining process. FALSE if it was not Returns: TRUE if the Join Worked, FALSE if it failed Definition at line 6325 of file paths.cpp. { // We have not reversed the other path yet *IsOtherReversed = FALSE; // Make a note of where the new path will start after the merge INT32 PathStart = UsedSlots; if (ThisReversed != NULL) *ThisReversed = FALSE; // Do we need to reverse any elements of this path INT32 StartSlot, NumSlots; BOOL JoinedAtStart; DocCoord* OtherCoords = (DocCoord*) DescribeHandle(Other->CoordHandle); // Find out if we need to reverse this path to help with the joining if (FindJoinedSubPathInfo(OtherCoords[0], &StartSlot, &NumSlots, &JoinedAtStart)) { // Maybe need to reverse this path if (JoinedAtStart) { Reverse(); if (ThisReversed != NULL) *ThisReversed = TRUE; } } // And check to see if the other end needs checking as well. if (FindJoinedSubPathInfo(OtherCoords[Other->UsedSlots-1], &StartSlot, &NumSlots, &JoinedAtStart)) { // Reverse the joining path always Other->Reverse(); // We have reversed the other path *IsOtherReversed = TRUE; // and maybe reverse this path if (JoinedAtStart) { Reverse(); if (ThisReversed != NULL) *ThisReversed = TRUE; } } // merge the paths if (MergeTwoPaths(*Other)==FALSE) return FALSE; // Make sure that the new path starts with a MoveTo #ifdef _DEBUG PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); ENSURE( Verbs[PathStart]==PT_MOVETO, "Start of SubPath is not a MoveTo in SimpleJoin()" ); #endif // The merge must have worked, so remove the initial MoveTo CurrentPos = PathStart; DeleteElement(); // See if we can make it a closed path TryToClose(); // report that it all worked CurrentPos = UsedSlots; *OtherStartSlot = PathStart-1; return TRUE; }

BOOL Path::Smooth (  const double  error  )

Smooth a path, using the fitcurve function, which may turn out to be NOT the way to do it but I'll give it a try. You should generally call this funcion with a copy of the path you want to smooth. This smooth function will corrupt the path if it fails. Call the function SmoothSection() describing your entire path if you wish to smooth a path without corrupting anything on failure. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/94 Parameters: error  = a double describing the max error to use when smoothing [INPUTS] Operates  on this path. the path will be smoothed meaning that it [OUTPUTS] will change in an unpredictable manner. The number of elements in the path and control point positioning will change, if TRUE is returned. Returns: BOOL = TRUE if the path was smoothed successfully = FALSE then consider 'this' path has been corrupted See also: SmoothSection Definition at line 7768 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARLIB) double QuantOrder = 1024; INT32 orignumcoords = UsedSlots; // create a path and quantise to it Path QuantPath; QuantPath.Initialise(24,12); // quantise original path to QuantPath Quantise(QuantOrder, &QuantPath); // create and fit a smooth curve to the data points. CurveFitObject Smoothed(&QuantPath, error); BOOL ok = Smoothed.Initialise(&QuantPath,QuantPath.GetNumCoords()); if (ok) { Smoothed.FitCurve(); // now that we've smoothed the curve lets check on the number // of coordinates we've generated. If its more, then we should // leave the original path as it was. If its less then replace if (QuantPath.GetNumCoords()<orignumcoords) ok = CloneFrom(QuantPath); } return ok; #else return FALSE; #endif }

DocCoord Path::SmoothControlPoint (  INT32  Index, BOOL  StartAndEndSnapped = FALSE, BOOL  JoinedToAnother = FALSE, BOOL  OtherIsCurve = TRUE, const DocCoord &  OtherCoord = DocCoord(0,0) )

This function will handle the smoothing of a path. It is designed to take account of all the possibilities that might occur (hence the huge list of parameters). The various places where this function might be needed are:Calculates the smoothed position of a control point in a path. The smoothing is calculated based on the endpoint to which the control point is attached, and the endpoints on either side of this point. Since we are guaranteed that one of these segments is a curve (that's where the control point comes from) the other possibilities are: The curve just terminates (at the end of a path); The curve is attached to another curve; It is attached to a line; It is at the end, but the end joins the start of the same path, which could be a line or a curve; and the curve could be at the end, but snapping to a completely separate path segment which might either be a line or curve (this is what the JoinedToAnother, OtherIsCurve and OtherCoord parameters indicate. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: Index  Index into this path of the control point [INPUTS] StartEndSnapped TRUE if the start of the path snaps to the end JoinedToAnother TRUE if this path joins to another one OtherIsCurve TRUE if the other path element is a curve FALSE if other path element is a line OtherCoord Coordinate of element in other path -  [OUTPUTS] Returns: Coordinates of the smoothed point Errors: - See also: Path::SmartSmoothCurve Documentation: Implemnt.doc Definition at line 4347 of file paths.cpp. { #if !defined(EXCLUDE_FROM_RALPH) PathVerb* Verbs = GetVerbArray(); DocCoord* Coords = GetCoordArray(); PathFlags* Flags = GetFlagArray(); // temp vars for calculating smoothness DocCoord p; // Endpoint opposite the control point DocCoord q; // Endpoint directly adjacent to control point DocCoord r; // Endpoint on same side of control point but not adjacent DocCoord ret; // Temp for returning value // We get the parameters for the calculation from different places depending on whether we're // at the first or second control point. We know this by looking at the EndPoint flags if (Flags[Index-1].IsEndPoint) { // This is the first control point of a curve /* These are the possibilities with the control point as the first one in the curve: 1: Curve/Curve ... m/l/c p c a c b c q <- endpoint to which point is attached c c <- Control point we're smoothing c d c r ... 2: Line/Curve ... m/l/c p l q c a <- Control point we're smoothing c b c r ... 3: Curve/Open line m q c a <- control point we're smoothing c b c r ... 4: Curve/snapping to curve at end m q c a <- control point we're snapping c b c r ... l/c p c c c d c q 5: Curve/snapping to line at end m q c a <- control point we're snapping to c b c r ... l/c p l q 6: Curve/snapping to curve in another path 7: Curve/snapping to line in another path m q c a <- control point we're smoothing c b c r ... point p = OtherCoord */ // The position of this point depends on: The previous endpoint (which is the point // to which this control point is 'attached'), the endpoint before that one, and the // endpoint of the bezier segment containing the control point. // point q is the endpoint of the previous element (which always exists where we want it) q = Coords[Index-1]; // point r is the endpoint of this curve element - again, always there r = Coords[Index+2]; // point p, on the other hand, is problematical. It might not exist at all (if the // previous element was a MoveTo and the path is open). It might be a lineto. It // might be a CurveTo element, which is the simplest case. Or, it might be any of // those three elements on a completely different path. Or it might be a curve or // a line at the opposite end of the path (if the CLOSEFIGURE flag is set or the // StartAndEndSnapped flag is TRUE). if (Verbs[Index-1] == PT_BEZIERTO) { // Simple - p = the start of this curve (case 1) p = Coords[Index-4]; CalcPointCurve(p,q,r,&ret); // Bodge inserted by Peter to fix the problem that occurs when you have a closed path // consisting of just two Bezier segments. In this case the returned position is wrong // - it positions the control point over the opposite one - so we will just flip it around /* Commented out by Markn 17/1/95 - replaced by new bodge written by Peter if ((GetNumCoords() == 7) && StartAndEndSnapped) { ret = q - (ret - q); } */ // New version of above bodge also by Peter (put in by Markn - 17/1/95) if ((GetNumCoords() == 7) && ((Verbs[GetNumCoords()-1] & PT_CLOSEFIGURE) || StartAndEndSnapped)) { ret = q - (ret - q); } return ret; } else if (Verbs[Index-1] == PT_LINETO) { // Simple - previous is a lineto, so get its start point and calculate (case 2) p = Coords[Index-2]; CalcPointLine(p,q,r,&ret); return ret; } else { // Scan along to find the end element. This we find by scanning forward until // we find a MoveTo or we go off the end. Either way, the previous element is // the one we want. INT32 i = Index; while (i<UsedSlots && Verbs[i] != PT_MOVETO) i++; // i either points after the end of the path, or at the next MoveTo. Move to the // previous element (could be the endpoint of a curve). i--; if (StartAndEndSnapped || (Verbs[i] & PT_CLOSEFIGURE) ) { // We have to get p from the end of the subpath (cases 4 & 5) if ((Verbs[i] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) { // Case 4 p = Coords[i-3]; CalcPointCurve(p,q,r,&ret); // Bodge inserted by Peter to fix the problem that occurs when you have a path consisting // of just two Bezier segments. In this case the returned position is wrong - it // positions the control point over the opposite one - so we will just flip it around if (GetNumCoords() == 7) { ret = q - (ret - q); } return ret; } else { // Case 5 p = Coords[i-1]; CalcPointLine(p,q,r,&ret); return ret; } } else { // This path hasn't snapped, and isn't closed. Check if it snaps with another if (JoinedToAnother) { // Cases 6 & 7 p = OtherCoord; if (OtherIsCurve) { // Case 6 CalcPointCurve(p,q,r,&ret); } else { // Case 7 CalcPointLine(p,q,r,&ret); } return ret; } else { // There's no snapping at all, so this point has to be calculated as an endpoint CalcPointEnd(q,r,&ret); return ret; } } } } else { // This is the second control point of a curve /* These are the possible situations, with sections of path data 1: Curve/Curve ... m/l/c r c a c b <- Control point pointed to by Index c q <- this is the endpoint to which the control point is connected c c c d c p ... 2: Curve/Line ... m/l/c r c a c b <- Control point pointed to by Index c q <- this is the endpoint to which the control point is connected l p ... 3: Curve/open line ... m/l/c r c a c b <- Control point pointed to by Index c q <- this is the endpoint to which the control point is connected either nothing or a moveto ... 4: Curve/snapping to curve at start m q c c c d c p ... l/c r c a c b <- Control point pointed to by index c q <- Enpoint to which control is connected either nothing or moveto, CLOSEFIGURE or SnapToEnd set ... 5: Curve/snapping to line at start m q l p ... l/c r c a c b <- Control point pointed to by index c q <- Enpoint to which control is connected either nothing or moveto, CLOSEFIGURE or SnapToEnd set ... 6: Curve/snapping to curve in another path 7: Curve/snapping to line in another path ... m/l/c r c a c b <- Control point pointed to by index c q <- Enpoint to which control is connected nothing/moveto point p = OtherCoord */ // Point q is the endpoint of this curve q = Coords[Index+1]; // Point r is the start point of this curve (always guaranteed to be there) r = Coords[Index-2]; // Point p (as before) is difficult. It ight be a curve element. it might be a line // element. It might not exist at all (i.e. this might be the end point of an open subpath). // It also might be the start point of this subpath, either because this path is closed // or because we've been told to snap. Or even, it might be an element at the start or end // of another path. My God, what a choice! // First check for the simple cases of curve/curve or curve/line (1 & 2) if (Index+2<UsedSlots && Verbs[Index+2] != PT_MOVETO) { // The next element is either a curve or a line if (Verbs[Index+2] == PT_BEZIERTO) { // It's a curve, so point p is its endpoint p = Coords[Index+4]; CalcPointCurve(p,q,r,&ret); return ret; } { // It's a line, so point p is the endpoint of that p = Coords[Index+2]; CalcPointLine(p,q,r,&ret); return ret; } } // Now we know there's nothing after this curve, so check snapping and stuff else if (StartAndEndSnapped || (Verbs[Index+1] & PT_CLOSEFIGURE)) { // We're snapping to the start of this path (4 & 5) , so we have to find // the start of this subpath INT32 i = Index; FindStartOfSubPath(&i); // i returned pointing at start element i++; // Point at first element in path if (Verbs[i] == PT_BEZIERTO) { p = Coords[i+2]; CalcPointCurve(p,q,r,&ret); return ret; } else { p = Coords[i]; CalcPointLine(p,q,r,&ret); return ret; } } else if (JoinedToAnother) { // Joined to another path (6 & 7) p = OtherCoord; if (OtherIsCurve) { CalcPointCurve(p,q,r,&ret); } else { CalcPointLine(p,q,r,&ret); } return ret; } else { // The only thing left is a curve at the end of the path (3) CalcPointEnd(q,r,&ret); return ret; } } #else return DocCoord(0,0); #endif }

void Path::SmoothCurve (  BOOL  SetRenderFlags = FALSE, BOOL  SnapEnds = FALSE, INT32  SnapIndex = 0 )

Smooths the path on the areas that have the IsSmooth flag set to TRUE. This can change any or all of the path. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 22/02/94 Parameters: SetRenderFlag  is TRUE if the smoothing should set the NeedToRender flags on points [INPUTS] as it's smoothing. SnapEnds tells the routine to snap two open ends together SnapIndex is an index into the subpath which is to be snapped Definition at line 4130 of file paths.cpp. { // This is a less efficient (slightly) version of this routine (in that there is a // certain amount of moving backward and forward in the path, but only for the start // and end points) but it copes with end snapping DocCoord* Coords = GetCoordArray(); PathVerb* Verbs = GetVerbArray(); PathFlags* Flags = GetFlagArray(); INT32 StartSnapSub = 0; INT32 EndSnapSub = 0; // Start and end of the subpath we're snapping DocCoord tempcoord(0,0); // Find the start and end of the subpath we're snapping if (SnapEnds) { StartSnapSub = EndSnapSub = SnapIndex; FindStartOfSubPath(&StartSnapSub); FindEndElOfSubPath(&EndSnapSub); } if (SetRenderFlags) { // As well as smoothing, we also set the NeedToRender flag on any path that's changed. // Notice that we never clear the NeedToRender flags - if they're rendered once, they're // rendered forever. for (INT32 i = 0; i < UsedSlots; i++) { if (Verbs[i] == PT_BEZIERTO && !(Flags[i].IsEndPoint) && Flags[i].IsSmooth) { tempcoord = SmoothControlPoint(i, (SnapEnds && (i>=StartSnapSub && i<=EndSnapSub))); if (Coords[i] != tempcoord) { if (Flags[i+1].IsEndPoint) Flags[i+1].NeedToRender = TRUE; else Flags[i+2].NeedToRender = TRUE; } Coords[i] = tempcoord; } } } else { for (INT32 i = 0; i < UsedSlots; i++) { if (Verbs[i] == PT_BEZIERTO && !(Flags[i].IsEndPoint) && Flags[i].IsSmooth) Coords[i] = SmoothControlPoint(i, (SnapEnds && (i>=StartSnapSub && i<=EndSnapSub))); } } }

BOOL Path::SmoothRegions (  const double  error, BOOL  smoothall, BOOL  reselect )

Given a path, search for regions of interest and smooth these regions. Regions are defined by sequences of connected selected points ie. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/94 Parameters: error  = a double describing the max error to use when smoothing [INPUTS] smoothall = true then ignore selected points within this path and smooth the whole path. reselect = a boolean indicating whether the path sections should be re selected after smoothing Operates  on this path. the path will be smoothed meaning that it [OUTPUTS] will change in an unpredictable manner. The number of elements in the path and control point positioning will change, if TRUE is returned. Returns: FALSE then unable to smooth the curve TRUE then the path has been smoothed successfully if P is the set of all control points [p0,....,pn] then a region Q is a connected subset of P , [pi....pj] where all members of Q are selected. If smoothall is true the whole path is smoothed. You should call this function with a path which you do not mind being corrupted, ie changed in an unpredictable way. The function may successfully smooth a number of regions within the path, then fail on one particular region. The result will be a path with m out of n regions smoothed. Definition at line 7468 of file paths.cpp. { INT32 index = 0; INT32 start = 0; INT32 end = UsedSlots-1; if (smoothall) { INT32 sel; (reselect) ? sel=4 : sel=0; return (Path::SmoothSection(start,&end,error, sel)); } else { while ((index<UsedSlots) && (FindSelectionLimits(index,&start,&end))) { // increase the region by 1 either way and smooth it. INT32 nstart = start; INT32 nend = end; ExpandRange(&nstart,&nend,1); if (nstart != nend) { INT32 sel = 0; if (reselect) { if (nstart<start) sel |=1 ; if (nend>end) sel |=2 ; if (sel==0) sel=4; } BOOL ok = Path::SmoothSection(nstart, &nend, error, sel); if (!ok) return FALSE; } index = nend+1; } } return TRUE; }

BOOL Path::SmoothSection (  INT32  index1, INT32 *  index2, const double  error, INT32  selection )

Given a path, search for regions of interest and smooth these regions. Regions are defined by (start/end) selected points with any number of none selected points inbetween. If smoothall is true or there are no selected regions within the path, the whole path is smoothed. You should call this function with a path which you do not mind being corrupted, ie changed in an unpredictable way. The function may successfully smooth a number of regions within the path, then fail on one particular region. The result will be a path with m out of n regions smoothed.Smooth a path between the given section delimited by [index1,index2]. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/94 Parameters: index1  = path element index to begin smoothing from. [INPUTS] index2 = path element index to smooth to. -1 then smooth to the end of the path. error = a double describing the max error to use when smoothing selection = 0 then do not reselect the smoothed regions = 1 then reselect all but the first point in the section = 2 then reselect all but the last point in the section a boolean indicating whether the smoothed region should = 3 then reselect all but both end points = 4 reselect all the points in the section index2  = the new index of the end of the smoothed section [OUTPUTS] this = the altered path, smoothed between index1, index2 Returns: BOOL = TRUE if the path was smoothed successfully = FALSE then the path remains unchanged Definition at line 7632 of file paths.cpp. { INT32 last = *index2; if (last==-1) last = UsedSlots-1; // Saftey Checks ERROR3IF( index1>=last, "Section delimiters are invalid in Path::SmoothSection"); ERROR3IF( last>=UsedSlots, "Section end is off end of path in Path::SmoothSection"); ERROR3IF( index1<0, "Section start is negative in Path::SmoothSection"); // Release safety checks if (index1>=last) return FALSE; if (last>=UsedSlots) return FALSE; if (index1<0) return FALSE; INT32 numtosmooth = last-index1+1; // We are smoothing a section of the path so extract a copy from // the specified section. Path PathSection; BOOL ok = PathSection.Initialise(numtosmooth,12); if (ok) { ok = MakePathFromSection(index1, numtosmooth, &PathSection); if (ok) { // smooth the section completely ok = PathSection.Smooth(error); if (ok) { // stick the smoothed path back in as a section and return a new // index2 value ok = RetroReplaceSection(index1, numtosmooth, &PathSection, FALSE); if (ok) { // set up the last coordinate index return param *index2 = index1 + PathSection.GetNumCoords() - 1; // if we need to reselect the points then go to it if (selection) { PathFlags* Flags = (PathFlags*) DescribeHandle(FlagsHandle); INT32 start = index1; INT32 end = *index2; if (!(selection & 4)) { if (selection & 1) FindNextEndPoint(&start); if (selection & 2) FindPrev(&end); } for (INT32 i=start; i<=end; i++) Flags[i].IsSelected = TRUE; } } } } } return ok; }

BOOL Path::SplitAtPoint (  const DocCoord  SplitPt, INT32 *  SplitElement, UINT32 *  NumElements, PathVerb *  Verbs, DocCoord *  Coords )

This function finds the element (line or curve) on which the closest point to SplitPt occurs. A parameter t describes the point on this element and is used to split the element into two distinct pieces. The verbs and coordinates of these pieces are returned to the caller in the output lists. NumElements will describe how many path components have been created and stored in the lists This will be a value of 2 for lines and 6 for curves. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/94 Parameters: SplitPt  = DocCoord to use to split the path as close as possible to [INPUTS] SplitElement  = The element index at which the split occured [OUTPUTS] NumElements = The number of elements generated by the split operation Verbs = a list of NumElements path verbs. Coords = a list of NumElements doc coords generated by the split Returns: TRUE = if the path could be split, FALSE = if SplitPt was closest to an already existing control vertex and hence is unable to split the element. Definition at line 7110 of file paths.cpp. { double mu; double dist = SqrDistanceToPoint(SplitPt, SplitElement, &mu); if (dist < 0.0) return FALSE; PathVerb* InVerbs = GetVerbArray(); DocCoord* InCoords = GetCoordArray(); PathVerb vb = InVerbs[*SplitElement] & ~PT_CLOSEFIGURE; ENSURE((vb == PT_LINETO) || (vb == PT_BEZIERTO), "Unable to find point on path. Index does not specify line or curve"); switch (vb) { case PT_LINETO: return PathUtil::SplitLine(mu, &InCoords[(*SplitElement)-1], NumElements, Verbs, Coords); break; case PT_BEZIERTO: return PathUtil::SplitCurve(mu, &InCoords[(*SplitElement)-1], NumElements, Verbs, Coords); break; } return FALSE; }

BOOL Path::SplitAtPoint (  const DocCoord &  SplitPoint, INT32 *  SplitAt, INT32 *  NewElements )

This function takes a coordinate (typically not on but) close to this path and splits the path at a calculated point on the path which happens to be closest to the input coord. By Split I mean a new coordinate in will appear in the path, but the path will not have changed its shape in anyway. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> (from Riks routine in OpFreeHand) Date: 15/06/95 Parameters: SplitPoint  - The coord that we want the split to happen close to [INPUTS] SplitAt  - The Slot number of the new end point [OUTPUTS] NewElements - The number of new elements inserted into the path Returns: TRUE if it was able to split the path ok, FALSE if it failed Definition at line 9719 of file paths.cpp. { INT32 SplitElement=0; UINT32 NumElements; PathVerb NewVerbs[6]; DocCoord NewCoords[6]; PathFlags NewFlags[6]; // Try and split the path. This returns FALSE if the path did not need splitting if (SplitAtPoint(SplitPoint, &SplitElement, &NumElements, NewVerbs, NewCoords)) { // Make a note of where the new endpoint will be *SplitAt = (SplitElement+(NumElements/2)-1); *NewElements = NumElements; // The path was split, so we know where, and how, so let's party on the path PathVerb* Verbs = GetVerbArray(); PathFlags* Flags = GetFlagArray(); // DocCoord* Coords = GetCoordArray(); // UINT32 NumCoords = GetNumCoords(); INT32 NumToChange; // We're adding something, either a line or curve - check which if ((Verbs[SplitElement] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) { // Adding a curve - number to change = 6 NumToChange = 6; // Initialise the flags appropriately for (INT32 i=0; i<6; i++) { // copy the flags from the old curve (repeat the flag in the first 3 elements) NewFlags[i] = Flags[SplitElement+(i%3)]; NewFlags[i].IsSelected = FALSE; // Want it to be a cusp in the middle if ((i>0) && (i<4)) { NewFlags[i].IsSmooth = FALSE; NewFlags[i].IsRotate = FALSE; } } // If this was happening at the end of a path, // then make sure the close figure flag is set correctly if (Verbs[SplitElement+2] & PT_CLOSEFIGURE) NewVerbs[5] |= PT_CLOSEFIGURE; } else { // The slit happened in a straight line section NumToChange = 2; NewFlags[0] = NewFlags[1] = Flags[SplitElement]; NewFlags[0].IsSmooth = NewFlags[0].IsRotate = FALSE; NewFlags[0].IsSelected = FALSE; // Make sure that the close figure flag is maintained if (Verbs[SplitElement] & PT_CLOSEFIGURE) NewVerbs[1] |= PT_CLOSEFIGURE; } // Move to the place in the path where the split took place SetPathPosition(SplitElement); PathFlags InsertFlags; BOOL InsertWorked; // insert a curve or a line, depending on where the split happened if (NumToChange==6) InsertWorked = InsertCurveTo(NewCoords[0], NewCoords[1], NewCoords[2], &InsertFlags); else InsertWorked = InsertLineTo(NewCoords[0], &InsertFlags); // see if the insertion worked if (!InsertWorked) return FALSE; } else { // else we tried to split at an existing control point (endpoint) // That means that there were no new endpoints *NewElements = 0; *SplitAt = (SplitElement-1); // See if we can find the control point in question DocCoord* Coords = GetCoordArray(); INT32 NumCoords = GetNumCoords(); // see if the split point is over the last point on the curve if (Coords[NumCoords-1]==SplitPoint) *SplitAt = NumCoords; } // all worked return TRUE; }

double Path::SqrDistanceToPoint (  const DocCoord  pt, INT32 *  NearEl, double *  mu )

Finds the distance to the closest point on the path. For efficiency it does not evaluate the closest point. Use this routine in conjunction with ClosestPoint to find the actual closest point. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/94 Parameters: pt  = DocCoord of point of interest (eg MouseCoord) [INPUTS] NearEl  = path index pointer of closest element to be retured [OUTPUTS] mu = element parameter of closest point to be returned Returns: a double, being the closest distance on the path or -1 if there are no points in the path, mu being unaffected Definition at line 6923 of file paths.cpp. { // Get the coordinate list and verb list for this path instance DocCoord* Coords = GetCoordArray(); PathVerb* Verbs = GetVerbArray(); // check for the presence of at least some elements if (UsedSlots==0) { *NearEl = -1; return -1; } // calculate the distance to the first control point double fdist; double ldist; double tmu; INT32 el=-1; fdist = PathUtil::SqrDistance(Coords[0], pt); for (INT32 i=0; i<UsedSlots; i++) { switch (Verbs[i] & ~PT_CLOSEFIGURE) { case PT_LINETO: ldist = PathUtil::SqrDistanceToLine(&Coords[i-1], pt, &tmu); if (ldist<=fdist) { fdist=ldist; el=i; *mu=tmu; } break; case PT_BEZIERTO: ldist = PathUtil::SqrDistanceToCurve(MAXPATHDIFFRATE, &Coords[i-1], pt, &tmu); if (ldist<=fdist) { fdist=ldist; el=i; *mu=tmu; } i+=2; // skip next two bezierto el. break; } } if (el>-1) // have we an element? { *NearEl = el; return fdist; } *NearEl = -1; return -1; }

double Path::SqrLength (   )

Find the length of a path in millipoints. The length is calculated by flattening the path and finding straight line segment lengths and so is a discrete numeric approximation to a line integral. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 1/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The squared length of the path defined in the same coordinate system as the paths points. Definition at line 7912 of file paths.cpp. { double Acc = 64; double Len = 0; ProcessLength LengthObj(Acc); BOOL ok = LengthObj.PathLength(this, &Len); if (ok) return Len; return 0; }

BOOL Path::StrokePathToPath (  MILLIPOINT  LineWidth = 250, LineCapType  LineCap = LineCapButt, JointType  JoinStyle = MitreJoin, DashType *  pDash = NULL, Path *  pDest = NULL, double  Flatness = 200.0, BOOL  Close = FALSE )

Strokes the path, and places result in pDest. If pDest == NULL, the result is placed back in this path. BOOL Path::StrokePathToPath(MILLIPOINT LineWidth = 250, LineCapType LineCap = LineCapButt, JointType JoinStyle = MitreJoin, DashType *pDash = NULL, Path* pDest = NULL, DWORD Flatness = 200, BOOL Close = FALSE) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/1/95 Parameters: LineWidth  = line width in millipoints [INPUTS] LineCap = line cap style JoinStyle = join style (what else!) pDash = ptr to dash pattern (NULL means no dash pattern) pDest = ptr to path to place result in (NULL means put result in 'this' path) Flatness = the value used to flatten the path Close = TRUE means the path is closed, FALSE otherwise -  [OUTPUTS] Returns: TRUE if OK, FALSE if not enough memory, or the resultant path has no elements See also: - Definition at line 5610 of file paths.cpp. { if (pDest == NULL) pDest = this; UINT32 NewFlatness = (UINT32)Flatness; INT32 NumCoords = GetNumCoords(); INT32 OutputSize = (NumCoords*40)+1000; Path OutputPath; if (!OutputPath.Initialise(OutputSize)) return FALSE; DocCoord* IPoints = GetCoordArray(); BYTE* ITypes = (BYTE*) GetVerbArray(); DWORD ILength = (DWORD) NumCoords; DocCoord* OPoints = OutputPath.GetCoordArray(); BYTE* OTypes = (BYTE*) OutputPath.GetVerbArray(); DWORD OLength = (DWORD) OutputSize; // Karim 22/11/2000 // Modified - if line-width is 0, then we don't want dashes. DashType Dash; Dash.Length = 0; if (pDash == NULL || LineWidth == 0) pDash = &Dash; INT32 len = -10; // keep checking to see if we had an overflow! while(len < -2) { len = GRenderRegion::StrokePathToPath(IPoints,ITypes,ILength, OPoints,OTypes,OLength, Close,LineWidth,NewFlatness,LineCap,JoinStyle,pDash); if(len < -2) { OLength -= len; OutputPath.EnsureVolume(OLength); OPoints = OutputPath.GetCoordArray(); OTypes = (BYTE*) OutputPath.GetVerbArray(); } } OutputPath.UsedSlots = len; OutputPath.UnUsedSlots -= len; OutputPath.IsFilled = TRUE; pDest->ClearPath(); if (len > 0) { if (!pDest->MergeTwoPaths(OutputPath)) return FALSE; pDest->InitialiseFlags(); INT32 n = pDest->GetNumCoords(); PathVerb* pVerbs = pDest->GetVerbArray(); pVerbs[n-1] |= PT_CLOSEFIGURE; } return TRUE; }

void Path::SyncExtraInfo (   )

Sets the Extra Info Ptr to the current Path Position. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 08/06/94 Parameters: -  [INPUTS] Returns: - Errors: - Definition at line 8234 of file paths.cpp. { if (ExtraInfo == NULL) return; ExtraInfo->Sync(CurrentPos); }

void Path::Translate (  const DocCoord &  coord  )

Translate all coordinate within 'this' path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Parameters: x  = x coordinate to translate path by [INPUTS] y = y coordinate to translate path by Returns: Definition at line 8133 of file paths.cpp. { INT32 x=coord.x; INT32 y=coord.y; Translate(x,y); }

void Path::Translate (  const INT32  x, const INT32  y )

Translate all coordinate within 'this' path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Parameters: x  = x coordinate to translate path by [INPUTS] y = y coordinate to translate path by Returns: Definition at line 8154 of file paths.cpp. { // if there's any translation then apply it if (x || y) { DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); for (INT32 i=0; i<UsedSlots; i++) { Coords[i].x += x; Coords[i].y += y; } } }

void Path::TryToClose (   )

Tries to close the path. If the start coord and the end coord are the same, it will close the path with a PT_CLOSEFIGURE and set the IsFilled flag. It searches all the sub-paths in the path and if any of them are closed, the whole path is marked as filled. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/94 Definition at line 5267 of file paths.cpp. { // Dereference the pointers to the coords and the verbs DocCoord* Coords = (DocCoord*) DescribeHandle(CoordHandle); PathVerb* Verbs = (PathVerb*) DescribeHandle(VerbHandle); // Need to try all the sub paths, so loop through the whoel path INT32 EndOfSubPath = UsedSlots-1; for (INT32 i=UsedSlots-1; i>=0; i--) { // Have we found the begining of a sub-path if (Verbs[i]==PT_MOVETO) { // yes - is its start and end coords the same if (Coords[i] == Coords[EndOfSubPath]) { // This path has the same start and end coord // so mark it as closed and fill it Verbs[EndOfSubPath] |= PT_CLOSEFIGURE; IsFilled = TRUE; } // Update the EndOfSubPath variable EndOfSubPath = i-1; } } }

---

Member Data Documentation

MHANDLE Path::CoordHandle [private]

Definition at line 578 of file paths.h.

INT32 Path::CurrentPos [private]

Definition at line 591 of file paths.h.

PathExtraInfo* Path::ExtraInfo [private]

Definition at line 582 of file paths.h.

MHANDLE Path::FlagsHandle [private]

Definition at line 579 of file paths.h.

BOOL Path::IsFilled

Definition at line 570 of file paths.h.

BOOL Path::IsStroked

Definition at line 571 of file paths.h.

CapStyles Path::m_ContourCapS [private]

Definition at line 559 of file paths.h.

double Path::m_ContourFlatness [private]

Definition at line 560 of file paths.h.

JoinStyles Path::m_ContourJoinS [private]

Definition at line 558 of file paths.h.

UINT32 Path::m_ContourLength [private]

Definition at line 562 of file paths.h.

UINT32 Path::m_ContourMitreLimit [private]

Definition at line 561 of file paths.h.

INT32 Path::m_ContourWidth [private]

Definition at line 557 of file paths.h.

BOOL Path::m_DoClosePath [private]

Definition at line 564 of file paths.h.

BOOL Path::m_IsAnOuterContour [private]

Definition at line 563 of file paths.h.

BOOL Path::m_UseContourMode [private]

Definition at line 565 of file paths.h.

INT32 Path::SlotAllocSize [private]

Definition at line 587 of file paths.h.

INT32 Path::SlotInitSize [private]

Definition at line 588 of file paths.h.

INT32 Path::UnUsedSlots [private]

Definition at line 585 of file paths.h.

INT32 Path::UsedSlots [private]

Definition at line 586 of file paths.h.

MHANDLE Path::VerbHandle [private]

Definition at line 577 of file paths.h.

---

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

• Kernel/paths.h (r1785/r942)
• Kernel/paths.cpp (r1785/r1492)

---