NodePath Class Reference

Puts path objects into the tree. More...

#include <nodepath.h>

Inheritance diagram for NodePath:

List of all members.

Public Member Functions
	NodePath ()
	This constructor creates a NodePath linked to no other with all status flags false and an uninitialized bounding rectangle.
	NodePath (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
BOOL	SetUpPath (INT32 RequiredSize=12, INT32 BlockSize=12)
	To initialise the Nodepath into a state that can be used, by allocating memory, setting up member variables properly and inserting an EndPath element into the path.
virtual Node *	SimpleCopy ()
	Makes a copy of all the data in the node.
virtual DocRect	GetBoundingRect (BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE)
	returns the paths bounding rectangle and recalculates it if it is invalid
virtual DocRect	GetBlobBoundingRect ()
	This calculates the bounding box of the path and adds in the influence of the selection blobs. It does not consider if the blobs are visible or not, it just gives the bounding box that they would occupy if they were visible.
virtual void	Render (RenderRegion *pRender)
	Will render the path contained within the object to the given render region.
virtual void	RenderEorDrag (RenderRegion *)
	Renders a version of the path for EORed dragging of shapes.
virtual void	RenderObjectBlobs (RenderRegion *pRender)
	Draws the paths object blobs into the render region supplied.
virtual void	RenderTinyBlobs (RenderRegion *pRender)
	Draws the paths Tiny blob into the render region supplied.
virtual void	RenderPenBlobs (RenderRegion *pRender)
	Draws the paths pen blobs into the render region supplied.
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes the path record to the filter.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
	Writes the path record to the filter.
virtual BOOL	WriteBeginChildRecordsNative (BaseCamelotFilter *pFilter)
	Begin to write out you child records, in the native format.
virtual BOOL	WriteEndChildRecordsNative (BaseCamelotFilter *pFilter)
	End writing out you child records, in the native format.
virtual UINT32	ChooseTagValue ()
	Writes the path record to the filter.
virtual BOOL	WritePathRecord (BaseCamelotFilter *pFilter)
	Writes the path record to the filter.
virtual BOOL	WritePathRefRecord (BaseCamelotFilter *pFilter, UINT32 SrcPathRecNum, Matrix *pTransform)
	Writes the path reference record to the filter.
virtual INT32	CalcPathRecordSize ()
	This func is the centre point at which the size of the record that will contain the path is calculated.
virtual BOOL	WritePathToRecord (CamelotFileRecord *pRecord)
	Central func writes out the correct path record.
virtual BOOL	CanBecomeA (BecomeA *pBecomeA)
	Interrogation routine to see if a node can be changed into a different node type. Returns TRUE if pClass is a NodePath, FALSE otherwise.
virtual BOOL	DoBecomeA (BecomeA *pBecomeA)
	Actually tries to change the node into a different node type. This responds to BECOMEA_PASSBACK reason by making a duplicate NodePath and passing it to the pfnPassBack func provided in the pBecomeA class.
void	ClearSubSelection (Spread *pSpread)
	Clears the paths sub-selection and re-draws the blobs to show this.
virtual BOOL	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	Allows the Node to respond to clicks by selecting its blobs or starting drags etc. This functions should be overridden in the all the NodeRenderableInk classes so that this verion never gets called. Eg the NodePath class might claim the click if it happened over one of its unselected blobs.
virtual BOOL	OnBlobPopUp (Spread *, DocCoord, ContextMenu *)
	Allows the Node to respond to pop up menu clicks on blobs.
virtual BOOL	OnNodePopUp (Spread *, DocCoord, ContextMenu *)
	Allows the Node to respond to pop up menu clicks on it (rather than its blobs).
virtual void	Transform (TransformBase &)
	Will Transform all the coords in the path with the transform provided.
virtual String	Describe (BOOL Plural, BOOL Verbose)
	To return a description of the NodePath object in either the singular or the plural. This method is called by the DescribeRange method. The description will always begin with a lower case letter.
void	GetDebugDetails (StringBase *Str)
	Displays debugging info of the tree For obtaining debug information about the Node.
virtual UINT32	GetNodeSize () const
	For finding the size of the node.
virtual BOOL	IsNodePath () const
	Override the node virtual function IsNodePath() and return TRUE as we definitely are one.
virtual BOOL	IsPathAllowable ()
	This function following some operations on the path. It allows the path (and objects derived from NodePath) to say wether the operation has left them in an invalid state. For example, following a delete a closed path of one segment is not allowed. Further example, Mould paths can override this function to ensure there is at least four points on the path after a delete.
virtual BOOL	Snap (DocCoord *pDocCoord)
	Snaps to given coord to the nearest point on the path. If it is not appropriate to snap the coord to the path (at the moment this means the coord is too far awawy), then FALSE is returned.
virtual BOOL	Snap (DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Snaps the given rect to the nearest position on the grid, preserving its width and height. The coords of the rect used for the snapping are determined by the PrevCoord and CurCoord coords supplied. This is done to allow the user to control how a selection rectangle is snapped to the grid by the direction of his/her last mouse movement. To force the bottom left hand corner of the rect to be snapped, supply PrevCoord=(0,0) and CurCoord(-1,-1). Scope: public.
virtual BOOL	SnapToCoords (DocCoord *pDocCoord)
	Snaps the point to all the magnetic points in a NodePath. These include all the endpoint in the path (ie MoveTos, LineTos and the last point in CurveTos). If it is close enough to any of these points in the path then the coord ischanged to match the point on the path and TRUE is returned. pDocCoord is not effected if it is not close enough to any of the points in the path.
virtual double	GetRotationAngle ()
	The overridden function for determining the current angle of rotation of this path.
virtual void	DeSelect (BOOL ReDraw, BOOL bDeselectChildren=FALSE)
	When you select a NodePath we can to clear all the selection flags in the path before deselecting the node.
virtual BOOL	NeedsToExport (RenderRegion *pRender, BOOL VisibleLayersOnly=FALSE, BOOL CheckSelected=FALSE)
	Virtual function - this version currently returns false if the path is an immediate child of a text story otherwise its always exportable.
virtual BOOL	AllowOp (ObjChangeParam *pParam, BOOL SetOpPermissionState=TRUE, BOOL DoPreTriggerEdit=TRUE)
	To get node paths inside text objects to reformat themselves correctly when their paths change. Also see: TextStory::AllowOp().
virtual BOOL	IsANodeBlendPath ()
	virtual identifier function,will move to node.h/.cpp when i have time to wait for the rebuild
virtual ChangeCode	OnChildChange (ObjChangeParam *pParam)
	It is now necessary to know when the nodepath has been updated because if it has a brush applied to it the brush needs to clear its cache.
NodePath *	MakeNodePathFromAttributes (double Flatness=750.0, CCAttrMap *pAttrMap=NULL, BOOL bIncludeClosedPaths=FALSE, BOOL IncludeWidth=TRUE)
	See returns.
virtual NodePath *	GetVariableWidthStrokePath ()
	If we have a variable width stroke applied to us then this will get the path generated by that stroke. This base class version returns NULL, overridden versions must supply their own outline path.
virtual NodePath *	GetSmoothVariableWidthStrokePath ()
	If we have a variable width stroke applied to us then this will get the path generated by that stroke. This base class version returns NULL, overridden versions must supply their own outline path.
virtual INT32	EstimateNodeComplexity (OpParam *details)
	This function estimates a complexity value for the node. The complexity value is based upon the total length of all paths in the node.
BOOL	RetroSmoothMe (double Smoothness)
	Use and abuse the retrosmoother to smooth our ink path. The Retrosmoother is normally activated from the gadget in the shape editor tool however we are hijacking it here for our purposes.
virtual BOOL	GetAreaDetails (XLONG *pxlArea, XLONG *pXLPerimeter)
	Work out 2-dimensional properties of this node.
virtual BOOL	IsDifferent (Node *pOther)
	Determine if 2 nodes are considered different.
virtual BOOL	IsTypeExtendible () const
virtual DocRect	ValidateExtend (const ExtendParams &ExtParams)
	Tests to see whether this path's control points are positioned so as to make an extend operation irreversible.
virtual void	Extend (const ExtendParams &ExtParams)
void	TransformTranslateObject (const ExtendParams &ExtParams)
	Do an extend (as opposed to stretch) operation on this path, using ExtParams as the source of the extend data, together with the extend-centre of this path, defined in NodeRenderable::FindExtendCentre().
virtual DocRect	GetExtendTargetBounds (const ExtendParams &ExtParams)
	Return a DocRect which contains the bounds of this node as defined and required by the Extending mechanism.
Path *	GetPathCopy ()
	A quick'n'easy way to get a permanent copy of our path.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
Static Public Member Functions
static BOOL	CreateFromPath (NodePath **ppNewPath, Path *pSrcPath=NULL, Operation *pOp=NULL)
	Create and initialise a new NodePath, using the given path information if provided.
Public Attributes
Path	InkPath
Protected Member Functions
void	CopyNodeContents (NodePath *NodeCopy)
	Copies the data in the node by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected.
Protected Attributes
double	CurrentRotation
Private Member Functions
void	HandleBlobClick (DocCoord *, PathFlags *, INT32, INT32, BOOL, BOOL)
	This will handle the selection and deselection of points on a path. For curve segments all the Bezier control points etc will be drawn in. This routine will also spot closed paths and select endpoints as well Scope: Private.

---

Detailed Description

Puts path objects into the tree.

Author:

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

Date:

26/5/93

See also:

Path

Definition at line 128 of file nodepath.h.

---

Constructor & Destructor Documentation

NodePath::NodePath (   )

This constructor creates a NodePath linked to no other with all status flags false and an uninitialized bounding rectangle. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 04/6/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Note: SetUpPath() must be called before the NodePath is in a state in which it can be used. See also: SetUpPath Definition at line 251 of file nodepath.cpp. : NodeRenderableInk() { CurrentRotation = 0.0; }

NodePath::NodePath (  Node *  ContextNode, AttachNodeDirection  Direction, BOOL  Locked = FALSE, BOOL  Mangled = FALSE, BOOL  Marked = FALSE, BOOL  Selected = FALSE )

---

Member Function Documentation

BOOL NodePath::AllowOp (  ObjChangeParam *  pParam, BOOL  SetOpPermissionState = TRUE, BOOL  DoPreTriggerEdit = TRUE )  [virtual]

To get node paths inside text objects to reformat themselves correctly when their paths change. Also see: TextStory::AllowOp(). Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com>; Karim 19/01/2000 Date: 8/5/95 Parameters: pParam  - pointer to the change parameter object [INPUTS] SetOpPermissionState - TRUE to set the Nodes permission flags DoPreTriggerEdit - if TRUE then calls NameGallery::PreTriggerEdit. Must* be TRUE if the calling Op may make any nodes change their bounds, eg move, line width, cut. Use TRUE if unsure. Returns: TRUE if the operation can proceede, FALSE to stop it Reimplemented from Node. Reimplemented in NodeBlendPath. Definition at line 2322 of file nodepath.cpp. { // call its default AllowOp(); we never want to do a PreTriggerEdit for this. BOOL allowed = NodeRenderableInk::AllowOp(pParam, SetOpPermissionState, FALSE); /* * Karim 15/11/2000 * Commented this out, as I see no point in pretending to be an Op. *Any* parent of ours * will have its AllowOp() called anyway, via our base class. * // if allowed, and our parent is a textstory, call the TextStory's AllowOp() as though called directly by the op Node* pParent=FindParent(); if (allowed && pParent!=NULL && IS_A(pParent,TextStory)) allowed=pParent->AllowOp(pParam,SetOpPermissionState,DoPreTriggerEdit); */ // if we're ok so far and were asked to do a PreTriggerEdit, then // determine whether the Op may change the bounds of some nodes. // If it may, then call NameGallery::PreTriggerEdit. if (allowed && DoPreTriggerEdit) { // if the Op is non-NULL then query its MayChangeNodeBounds() method. UndoableOperation* pChangeOp = pParam->GetOpPointer(); if (pChangeOp != NULL && pChangeOp->MayChangeNodeBounds() && NameGallery::Instance()) { allowed = NameGallery::Instance()->PreTriggerEdit(pChangeOp, pParam, this); } } if (SetOpPermissionState) SetOpPermission(PERMISSION_ALLOWED); return allowed; }

INT32 NodePath::CalcPathRecordSize (   )  [virtual]

This func is the centre point at which the size of the record that will contain the path is calculated. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/96 Parameters: -  [INPUTS] Returns: The size of the record in bytes See also: BaseCamelotFilter::WritePathsInRelativeFormat() Definition at line 2445 of file nodepath.cpp. { INT32 NumCoords = InkPath.GetNumCoords(); if (BaseCamelotFilter::WritePathsInRelativeFormat()) return (sizeof(PathVerb)*NumCoords)+(sizeof(DocCoord)*NumCoords); else return sizeof(INT32)+(sizeof(PathVerb)*NumCoords)+(sizeof(DocCoord)*NumCoords); }

BOOL NodePath::CanBecomeA (  BecomeA *  pBecomeA  )  [virtual]

Interrogation routine to see if a node can be changed into a different node type. Returns TRUE if pClass is a NodePath, FALSE otherwise. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/94 Parameters: pClass  = runtime class to node you wish this node to become [INPUTS] pNumObjects = ptr to place number of objects of type pClass that will be created (Note: can be NULL). pNumObects in undefined on entry -  [OUTPUTS] Returns: TRUE if it can, FALSE if it can't The number you put into pNumObjects (if it's not NULL) should exactly equal the total number of pClass objects you create. It should NOT contain any additional objects you may produce such as group objects for containing the pClass object, or attributes. Also, the entry value of *pNumObjects cannot be assumed to be 0. Returns: Errors: - See also: NodePath::DoBecomeA() Reimplemented from Node. Definition at line 1358 of file nodepath.cpp. { if (pBecomeA->BAPath()) { pBecomeA->AddCount(1); return TRUE; } return FALSE; }

UINT32 NodePath::ChooseTagValue (   )  [virtual]

Writes the path record to the filter. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/8/96 Parameters: -  [INPUTS] Returns: The tag value that should be used for saving this path See also: This function chooses the tag to use based on the filled & stroked flags of the path Definition at line 2372 of file nodepath.cpp. { #ifdef DO_EXPORT UINT32 Tag = TAG_UNDEFINED; if (BaseCamelotFilter::WritePathsInRelativeFormat()) { Tag = TAG_PATH_RELATIVE; if (InkPath.IsFilled && !InkPath.IsStroked) Tag = TAG_PATH_RELATIVE_FILLED; else if (!InkPath.IsFilled && InkPath.IsStroked) Tag = TAG_PATH_RELATIVE_STROKED; else if (InkPath.IsFilled && InkPath.IsStroked) Tag = TAG_PATH_RELATIVE_FILLED_STROKED; } else { Tag = TAG_PATH; if (InkPath.IsFilled && !InkPath.IsStroked) Tag = TAG_PATH_FILLED; else if (!InkPath.IsFilled && InkPath.IsStroked) Tag = TAG_PATH_STROKED; else if (InkPath.IsFilled && InkPath.IsStroked) Tag = TAG_PATH_FILLED_STROKED; } return Tag; #else return TAG_UNDEFINED; #endif }

void NodePath::ClearSubSelection (  Spread *  pSpread  )

Clears the paths sub-selection and re-draws the blobs to show this. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/4/94 Parameters: pSpread  - Pointer to the nodes parent spread [INPUTS] Definition at line 670 of file nodepath.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ENSURE( pSpread!=NULL, "Parent Spread was NULL in NodePath::ClearSubSelection" ); if ((pSpread!=NULL) && (InkPath.IsSubSelection())) { InkPath.RenderPathBlobs(pSpread); InkPath.ClearSubSelection(); InkPath.RenderPathBlobs(pSpread); } #endif }

void NodePath::CopyNodeContents (  NodePath *  NodeCopy  )  [protected]

Copies the data in the node by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Parameters: NodeCopy  - The node to copy [INPUTS] See also: NodeRenderableInk::CopyNodeContents Definition at line 450 of file nodepath.cpp. { NodeRenderableInk::CopyNodeContents( NodeCopy ); //Copy contents specific to derived class here if (NodeCopy->InkPath.Initialise(InkPath.GetNumCoords(),12)) NodeCopy->InkPath.CopyPathDataFrom(&InkPath); }

BOOL NodePath::CreateFromPath (  NodePath **  ppNewPath, Path *  pSrcPath = NULL, Operation *  pOp = NULL )  [static]

Create and initialise a new NodePath, using the given path information if provided. pSrcPath the path which the new NodePath will copy its data from. if NULL, then you just get back a fresh NodePath, ready for use. pOp an Op ptr - if we run out of memory, then we can reclaim memory via this ptr; ok if this is NULL. Parameters: *pNewPath  holds a new NodePath, if successful, NULL otherwise. [OUTPUTS] Returns: TRUE if success, FALSE otherwise. Errors: ERROR2 with FALSE if ppNewPath is NULL. Definition at line 2982 of file nodepath.cpp. { ERROR2IF(ppNewPath == NULL, FALSE, "NodePath::CreateFromPath; called with NULL param!"); NodePath* pNewPath = NULL; ALLOC_WITH_FAIL(pNewPath, new NodePath, pOp); if (pNewPath != NULL) { if (pSrcPath != NULL) { BOOL ok = pNewPath->InkPath.Initialise(pSrcPath->GetNumCoords(), 1); if (ok) CALL_WITH_FAIL(pNewPath->InkPath.CopyPathDataFrom(pSrcPath), pOp, ok); if (!ok) { delete pNewPath; pNewPath = NULL; } } else { pNewPath->SetUpPath(); } } *ppNewPath = pNewPath; return (pNewPath != NULL); }

String NodePath::Describe (  BOOL  Plural, BOOL  Verbose )  [virtual]

To return a description of the NodePath object in either the singular or the plural. This method is called by the DescribeRange method. The description will always begin with a lower case letter. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 25/6/93 Parameters: Plural,:  Flag indicating if the string description should be plural or [INPUTS] singular. Retuns: Description of the object Returns: Errors: A resource exception will be thrown if a problem occurs when loading the string resource. Reimplemented from Node. Definition at line 1130 of file nodepath.cpp. { // if the first subpath is closed, this is a shape rather than a line if (InkPath.IsSubPathClosed(0)) { if (Plural) return(String(_R(IDS_DESCRIBE_SHAPES))); else return(String(_R(IDS_DESCRIBE_SHAPE))); } else { if (Plural) return(String(_R(IDS_PATH_DESCRP))); else return(String(_R(IDS_PATH_DESCRS))); } };

void NodePath::DeSelect (  BOOL  ReDraw, BOOL  bDeselectChildren = FALSE )  [virtual]

When you select a NodePath we can to clear all the selection flags in the path before deselecting the node. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 24/1/95 Parameters: ReDraw  [INPUTS] -  [OUTPUTS] Returns: - See also: NodeRenderable::DeSelect Reimplemented from NodeRenderable. Definition at line 2199 of file nodepath.cpp. { if (ReDraw && GetApplication()->GetBlobManager()->GetCurrentInterest().Object) InkPath.RenderPathSelectedControlBlobs(FindParentSpread()); InkPath.ClearSubSelection(); // Now call the parent class NodeRenderableInk::DeSelect(ReDraw, bDeselectChildren); }

BOOL NodePath::DoBecomeA (  BecomeA *  pBecomeA  )  [virtual]

Actually tries to change the node into a different node type. This responds to BECOMEA_PASSBACK reason by making a duplicate NodePath and passing it to the pfnPassBack func provided in the pBecomeA class. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/94 Parameters: pBecomeA  = ptr to info class containing everything a node needs to be able [INPUTS] to become something else -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Errors: - See also: NodePath::CanBecomeA() Reimplemented from Node. Reimplemented in NodeBlendPath. Definition at line 1388 of file nodepath.cpp. { // Check for a NULL entry param ERROR2IF_PF(pBecomeA == NULL,FALSE,("pBecomeA is NULL")); // This lump checks that the Reason is one that we understand // It also makes sure that we don't have a NULL UndoOp ptr BOOL ValidReason = (pBecomeA->GetReason() == BECOMEA_REPLACE || pBecomeA->GetReason() == BECOMEA_PASSBACK); ERROR2IF_PF(!ValidReason,FALSE,("Unkown BecomeA reason %d",pBecomeA->GetReason())); BOOL Success = TRUE; // Our success flag (Important that this defaults to TRUE) NodePath* pNewNodePath = NULL; // Ptr to a new NodePath, if we get to make one. if (pBecomeA->BAPath()) { switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE: // We do nothing as we are already a NodePath in the tree // except tell the caller where we are in the tree... pBecomeA->PassBack(this, this); break; case BECOMEA_PASSBACK : { // Make a copy of this NodePath CALL_WITH_FAIL(((pNewNodePath = (NodePath*)SimpleCopy()) != NULL), pBecomeA->GetUndoOp(), Success); // If successful, pass it back with my attribute map if (Success) Success = pBecomeA->PassBack(pNewNodePath,this); } break; default: break; } } if (!Success) { if (pNewNodePath != NULL) { // Delete all the NodePath's children (if it has any) and unlink it from the tree (if it's linked) // This is all done by CascadeDelete() pNewNodePath->CascadeDelete(); delete pNewNodePath; pNewNodePath = NULL; } } return Success; }

INT32 NodePath::EstimateNodeComplexity (  OpParam *  details  )  [virtual]

This function estimates a complexity value for the node. The complexity value is based upon the total length of all paths in the node. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 6/09/2000 Parameters: details  any data that should be used for the calculation [INPUTS] -  [OUTPUTS] Returns: an estimate of the nodes complexity See Also: OpBlendNodes::DeterminBlendObjectsProcessorHit () Reimplemented from Node. Definition at line 2426 of file nodepath.cpp. { return (InkPath.GetUsedSlots ()); }

void NodePath::Extend (  const ExtendParams &  ExtParams  )  [virtual]

the path extends separately along each axis. if the path is asked to stretch, it scales along the corresponding axes. if the path is asked to extend, its control points translate, as described by ExtParams. Returns: Errors: See also: class Extender Reimplemented from Node. Definition at line 2850 of file nodepath.cpp. { TransformTranslateObject(ExtParams); TransformStretchObject(ExtParams); // do the base-class implementation to extend our children. Node::Extend(ExtParams); }

BOOL NodePath::GetAreaDetails (  XLONG *  pxlArea, XLONG *  pxlPerimeter )  [virtual]

Work out 2-dimensional properties of this node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 12/03/2005 Parameters: xlArea  [OUTPUTS] xlPerimeter Returns: TRUE if calcs succeeded Reimplemented from NodeRenderableInk. Definition at line 3060 of file nodepath.cpp. { BOOL bOK = TRUE; *pxlArea = InkPath.CalcArea(); double dDistance = 0; bOK = InkPath.DistanceTo(InkPath.GetNumCoords()-1, 1, &dDistance); *pxlPerimeter = (INT32)dDistance; return TRUE; }

DocRect NodePath::GetBlobBoundingRect (   )  [virtual]

This calculates the bounding box of the path and adds in the influence of the selection blobs. It does not consider if the blobs are visible or not, it just gives the bounding box that they would occupy if they were visible. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/02/94 Returns: DocRect - Returns the bounding rect of the path and its blobs Reimplemented from NodeRenderable. Definition at line 1256 of file nodepath.cpp. { // Also, scan through all the points to find the bounds of the blobs PathVerb* Verbs = InkPath.GetVerbArray(); PathFlags* Flags = InkPath.GetFlagArray(); DocCoord* Coords = InkPath.GetCoordArray(); INT32 NumCoords = InkPath.GetNumCoords(); DocRect BlobRect; DocRect Rect; //Go get the blob manager and just return the bounding rect BlobManager* BlobMgr = GetApplication()->GetBlobManager(); if (BlobMgr==NULL) return GetBoundingRect(); // loop through all the coords adding them to the bounding rect for (INT32 i=0; i<NumCoords; i++) { if (i==0) { // Set up initial rect to be just the first point Rect = DocRect(Coords[0].x, Coords[0].y, Coords[0].x + 1L, Coords[0].y + 1L); } else { // Expand the rectangle to include this point Rect.IncludePoint(Coords[i]); } } // Put blobs at the bottom-left and top-right corners, and include these in the rectangle BlobMgr->GetBlobRect(Rect.lo, &BlobRect); Rect = Rect.Union(BlobRect); BlobMgr->GetBlobRect(Rect.hi, &BlobRect); Rect = Rect.Union(BlobRect); // Now make sure we include any extra blobs dependent on the // blob type BlobStyle Blobs = BlobMgr->GetCurrentInterest(TRUE); if (Blobs.Pen) { // ok, if its the pen blobs, we need to do extra things over // and above the standard coord blobs. We need to add an extra // ghost point at the end of the path, if there is a curveto PathVerb LastVerb = Verbs[NumCoords-1]; PathFlags LastFlag = Flags[NumCoords-1]; if ((LastVerb == PT_BEZIERTO) && (LastFlag.IsRotate)) { DocCoord Pt0 = Coords[NumCoords-2]; DocCoord Pt1 = Coords[NumCoords-1]; DocCoord GhostPt; GhostPt.x = Pt1.x - (Pt0.x - Pt1.x); GhostPt.y = Pt1.y - (Pt0.y - Pt1.y); BlobMgr->GetBlobRect(GhostPt,&BlobRect); Rect = Rect.Union(BlobRect); } } // Make sure we include the Bounds of our children IncludeChildrensBoundingRects(&Rect); // return the rectangle with the blobs included return Rect; }

DocRect NodePath::GetBoundingRect (  BOOL  DontUseAttrs = FALSE, BOOL  HitTest = FALSE )  [virtual]

returns the paths bounding rectangle and recalculates it if it is invalid Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/02/94 Parameters: DontUseAttrs  - TRUE if you don't want to use the nodes attrs to calculate [INPUTS] the bounding rect (defaults will be used). Defaults to FALSE. HitTest - TRUE if being called during HitTest Returns: The paths bounding rectangle. See also: NodePath::GetBlobBoundingRect; NodeRenderableBounded::GetBoundingRect Reimplemented from NodeRenderableBounded. Reimplemented in NodeBlendPath, and NodeMouldPath. Definition at line 1167 of file nodepath.cpp. { // go and recalculate the bounding rect if it is not known if (!IsBoundingRectValid || DontUseAttrs) { // a rect to put the new version of the bounding rect into DocRect NewBoundingRect; // Find out what the paths bounding rect is now if (!CalculatePathBoundingRect(InkPath, DontUseAttrs, &NewBoundingRect)) { // GDraw failed to find out how big the bounding rect // we will have to make do with the bounding rect of the coords NewBoundingRect = InkPath.GetBoundingRect(); } // If the line is vertical/horizontal with zero width then we will have a 0 width/height rect // Inflate this so rectangle calculations work. if (NewBoundingRect.Width() == 0) NewBoundingRect.hi.x++; if (NewBoundingRect.Height() == 0) NewBoundingRect.hi.y++; // we have a new bounding rect - decide what to do with it if (DontUseAttrs) { // but it is not the real bounding rect, so just return it return NewBoundingRect; } else { // We need to go though the attributes applied to this path, // and see if any of them effect the bounding rect // (eg. ArrowHeads) CCAttrMap AttribMap(30); if (FindAppliedAttributes(&AttribMap)) { void* pType; void* pVal; // iterating all (key, value) pairs CCAttrMap::iterator end = AttribMap.GetEndPosition(); for( CCAttrMap::iterator Pos = AttribMap.GetStartPosition(); Pos != end; ++Pos ) { // Get attr at position Pos pType = Pos->first; pVal = Pos->second; if (pVal != NULL) { if ( ((NodeAttribute*)pVal)->EffectsParentBounds() ) { // Get the bounds of the attribute and Union it with // the path bounds DocRect AttrBounds = ((NodeAttribute*)pVal)->GetAttrBoundingRect(this, &AttribMap); NewBoundingRect = NewBoundingRect.Union(AttrBounds); } } } } // Update the Nodes bounding rectangle BoundingRectangle = NewBoundingRect; // Mark the rect as valid IsBoundingRectValid = TRUE; } } // return the current bounding rect return BoundingRectangle; }

void NodePath::GetDebugDetails (  StringBase *  Str  )  [virtual]

Displays debugging info of the tree For obtaining debug information about the Node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/93 Parameters: Str,:  String giving debug info about the node [OUTPUTS] Reimplemented from NodeRenderableBounded. Definition at line 336 of file nodepath.cpp. { #ifdef _DEBUG // Call base class NodeRenderableInk::GetDebugDetails( Str ); InkPath.FindStartOfPath(); String_256 TempStr; (*Str) += TEXT( "\r\nPath Data Dump\r\n" ); TempStr._MakeMsg( TEXT( "#1%ld bytes used\r\n"), InkPath.GetPathByteLength() ); (*Str) += TempStr; #if !defined(EXCLUDE_FROM_RALPH) DocRect BlobRect = GetBlobBoundingRect(); TempStr._MakeMsg( TEXT("Blob Bounding Rect :-\r\n\t#1%ld,\t#2%ld\r\n\t#3%ld,\t#4%ld\r\n"), BlobRect.lo.x, BlobRect.lo.y, BlobRect.hi.x, BlobRect.hi.y ); (*Str) += TempStr; #endif TempStr._MakeMsg(TEXT("The Path is #1%sFilled and #2%sStroked\r\n"), InkPath.IsFilled ? "" : "not ", InkPath.IsStroked ? "" : "not "); (*Str) += TempStr; (*Str) += TEXT( "\r\nNum\tType\tX Coord\tY Coord\r\n" ); PathVerb* Verbs = InkPath.GetVerbArray(); DocCoord* Coords = InkPath.GetCoordArray(); PathFlags* Flags = InkPath.GetFlagArray(); INT32 numcoords = InkPath.GetNumCoords(); for (INT32 i=0; i<numcoords; i++) { // Add the info to the string TempStr._MakeMsg( TEXT("#1%d.\t#2%d\t#3%ld,\t#4%ld\t"), i, Verbs[i], Coords[i].x, Coords[i].y ); // Add useful flags to the end of the string 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 }

DocRect NodePath::GetExtendTargetBounds (  const ExtendParams &  ExtParams  )  [virtual]

Return a DocRect which contains the bounds of this node as defined and required by the Extending mechanism. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 02/06/2000 Parameters: ExtParams  const ref to an ExtendParams class describing the extension. [INPUTS] [OUTPUTS]  Returns: The DocRect to treat as the bounding rect of this node when extending. We treat x- and y- directions separately, and we always return our true bounds, unless we're extending in a direction, in which case we return the bounds of our extend control points, which are currently all of our inkpath's control points. Returns: Errors: See also: SliceHelper::BoundingNodeSize(). Reimplemented from NodeRenderableBounded. Definition at line 2936 of file nodepath.cpp. { // think twice about using InkPath::GetTrueBoundingRect() here - using // NodePath::GetBoundingRect takes factors such as attributes into account. DocRect drBounds = GetBoundingRect(); DocRect drPointBounds = InkPath.GetBoundingRect(); if (ExtParams.fExtendFlags & X_EXTEND) { drBounds.lo.x = drPointBounds.lo.x; drBounds.hi.x = drPointBounds.hi.x; } if (ExtParams.fExtendFlags & Y_EXTEND) { drBounds.lo.y = drPointBounds.lo.y; drBounds.hi.y = drPointBounds.hi.y; } return drBounds; }

UINT32 NodePath::GetNodeSize (   )  const [virtual]

For finding the size of the node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The size of the path node in bytes See also: Node::GetSubtreeSize Reimplemented from Node. Definition at line 407 of file nodepath.cpp. { return (sizeof(NodePath)+InkPath.GetPathByteLength()); }

Path * NodePath::GetPathCopy (   )

A quick'n'easy way to get a permanent copy of our path. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/2000 Returns: ptr to a copy of our path if successful, NULL otherwise. Notes: The copy is allocated on the heap, so it's *your* responsibility to dispose of it. Definition at line 3029 of file nodepath.cpp. { Path* pResult = new Path; if (pResult != NULL) { if (!pResult->Initialise(InkPath.GetNumCoords()) || !pResult->CloneFrom(InkPath)) { delete pResult; pResult = NULL; } } return pResult; }

double NodePath::GetRotationAngle (   )  [virtual]

The overridden function for determining the current angle of rotation of this path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 24/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The current angle of rotation of the path See also: NodeRenderableBounded::GetRotationAngle Reimplemented from NodeRenderableBounded. Definition at line 2178 of file nodepath.cpp. { return CurrentRotation; }

NodePath * NodePath::GetSmoothVariableWidthStrokePath (   )  [virtual]

If we have a variable width stroke applied to us then this will get the path generated by that stroke. This base class version returns NULL, overridden versions must supply their own outline path. Author: Priestley (Xara Group Ltd) <camelotdev@xara.com> ripped from Diccon Date: 18-11-2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: a nodepath containing the path that is generated by any variable width strokes that are applied to us, or NULL if there aren't any THIS FUNCTION IS THE SAME AS THAT ABOVE, BUT JUST RETURNS THE SMOOTHED PATH See also: NodePath::GetVariableWidthStrokePath, NodeRegularShape::GetVariableWidthStrokePath Reimplemented from NodeRenderableInk. Definition at line 1504 of file nodepath.cpp. { // first find out if we actually have a variable width applied to us, if not then we don't do anything AttrVariableWidth* pVarWidth = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrVariableWidth), (NodeAttribute**)&pVarWidth); if (pVarWidth && ((VariableWidthAttrValue*)pVarWidth->GetAttributeValue())->GetWidthFunction() == NULL) return NULL; // next find the stroke attribute that actually does the work AttrStrokeType* pStroke = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeType), (NodeAttribute**)&pStroke); NodePath* pRetNode = NULL; if (pStroke && pStroke->HasPathProcessor()) { PathProcessorStroke* pPPS = pStroke->GetPathProcessor(); pRetNode = pPPS->GetSmoothProcessedPath(&InkPath, this); } return pRetNode; }

NodePath * NodePath::GetVariableWidthStrokePath (   )  [virtual]

If we have a variable width stroke applied to us then this will get the path generated by that stroke. This base class version returns NULL, overridden versions must supply their own outline path. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15-5-2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: a nodepath containing the path that is generated by any variable width strokes that are applied to us, or NULL if there aren't any In this version we simply use our inkpath See also: NodePath::GetVariableWidthStrokePath, NodeRegularShape::GetVariableWidthStrokePath Reimplemented from NodeRenderableInk. Definition at line 1460 of file nodepath.cpp. { // first find out if we actually have a variable width applied to us, if not then we don't do anything AttrVariableWidth* pVarWidth = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrVariableWidth), (NodeAttribute**)&pVarWidth); if (pVarWidth && ((VariableWidthAttrValue*)pVarWidth->GetAttributeValue())->GetWidthFunction() == NULL) return NULL; // next find the stroke attribute that actually does the work AttrStrokeType* pStroke = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeType), (NodeAttribute**)&pStroke); NodePath* pRetNode = NULL; if (pStroke && pStroke->HasPathProcessor()) { PathProcessorStroke* pPPS = pStroke->GetPathProcessor(); pRetNode = pPPS->GetProcessedPath(&InkPath, this); } return pRetNode; }

void NodePath::HandleBlobClick (  DocCoord *  Coords, PathFlags *  Flags, INT32  Pos, INT32  NumCoords, BOOL  Adjust, BOOL  Constrain )  [private]

This will handle the selection and deselection of points on a path. For curve segments all the Bezier control points etc will be drawn in. This routine will also spot closed paths and select endpoints as well Scope: Private. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/11/93 Parameters: Coords  - The array of coordinates [INPUTS] Flags - The array of flags Pos - The item click on Adjust - TRUE if this is an Adjust click Constrain - TRIE if this is a Constrain click. The  values in the flags array are modified by this function [OUTPUTS] Definition at line 971 of file nodepath.cpp. { #if !defined(EXCLUDE_FROM_RALPH) PathVerb* Verbs = InkPath.GetVerbArray(); // clear the selection state of all the other selected objects in the tree (but not this one) if (!Adjust && !Constrain) { SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); while (pNode!=NULL) { if ((pNode!=this) && (pNode->IsKindOf(CC_RUNTIME_CLASS(NodePath)))) { // This node needs to get rid of all its selected control points NodePath* pNodePath = (NodePath*) pNode; if (pNodePath->InkPath.IsSubSelection()) { Spread* pSpread = pNodePath->FindParentSpread(); ENSURE(pSpread!=NULL, "Node did not have a parent spread in NodePath::HandleBlobClick"); if (pSpread!=NULL) { pNodePath->InkPath.RenderPathSelectedControlBlobs(pSpread); pNodePath->InkPath.ClearSubSelection(); pNodePath->InkPath.RenderPathSelectedControlBlobs(pSpread); } } } // Get the next selected node pNode = Selected->FindNext(pNode); } } // Find out what the current selection state is, so that we can toggle it // Selection state will hold the value we want to set BOOL NewSelState; BOOL OldSelState = Flags[Pos].IsSelected; if (OldSelState) NewSelState = FALSE; else NewSelState = TRUE; Spread *pSpread = FindParentSpread(); ENSURE(pSpread != NULL, "NodePath does not have a parent spread"); // Remove the current blobs from this path before we try and change selection InkPath.RenderPathSelectedControlBlobs(pSpread); // If we're not adjusting, clear the subselection in this path if (!Adjust && !Constrain) InkPath.ClearSubSelection(); // if we are adjusting and constraining then (de)select all the endpoints on the path if (Adjust && Constrain) { BOOL NewSelState = !Flags[Pos].IsSelected; for (INT32 loop = 0; loop < InkPath.GetNumCoords(); loop++) { Flags[loop].IsSelected = NewSelState; } } else { // Now change the selection of this point Flags[Pos].IsSelected = NewSelState; // If the previous point is a control point then deal with it if ((Pos>0) && (!Flags[Pos-1].IsEndPoint)) { // Change the control point's selection state Flags[Pos-1].IsSelected = NewSelState; } // If the next point is a control point then deal with it if ((Pos+1<NumCoords) && (!Flags[Pos+1].IsEndPoint)) { // Change the control point's selection state Flags[Pos+1].IsSelected = NewSelState; } // Check for this being the first element in a closed subpath // If this element is a moveto, and the end of the path has the // CLOSEFIGURE flag set, we should select the endpoint as well if (Verbs[Pos] == PT_MOVETO) { INT32 j; // This for loop will find either the end of the path, or the next moveto for (j=Pos+1;j<NumCoords && Verbs[j] != PT_MOVETO;j++); // ; is intentional! j--; if (Verbs[j] & PT_CLOSEFIGURE) { //HandleBlobClick(Coords,Flags,j,NumCoords,TRUE); Flags[j].IsSelected = NewSelState; // If the previous point is a control point then deal with it if ((j>0) && (!Flags[j-1].IsEndPoint)) { // Change the control point's selection state Flags[j-1].IsSelected = NewSelState; } } } } InkPath.RenderPathSelectedControlBlobs(pSpread); #endif }

BOOL NodePath::IsANodeBlendPath (   )  [virtual]

virtual identifier function,will move to node.h/.cpp when i have time to wait for the rebuild Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: -  [INPUTS] Returns: FALSE; Reimplemented in NodeBlendPath. Definition at line 2790 of file nodepath.cpp. { return FALSE; }

BOOL NodePath::IsDifferent (  Node *  pOther  )  [virtual]

Determine if 2 nodes are considered different. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 28/2/97 Parameters: pOther  - The node to compare this one to [INPUTS] Returns: TRUE if this is considered different from pOther, FALSE if they are the same Notes: **** IMPORTANT - May not function well enough for your needs! **** This was written to allow the StrokeComponent class to merge stroke definitions which share identical clipart subtrees. Stroke subtrees are special in that they have had Make Shapes applied to them, and so only contain paths. Hence, I have only defined functions in Node, NodeRenderableBounded, and NodePath - most objects in the tree thus use base class functionality (are they of the same class, and do they have identical bounding boxes). This suffices for my needs, but you may need to implement this function for a lot more node types before it's of use to you. NodePath checks that the 2 InkPaths contain the same set of Coords and Verbs - currently IGNOREs everything else Reimplemented from NodeRenderableBounded. Definition at line 2745 of file nodepath.cpp. { // First, check with the base class - this checks the classes are the same type if (NodeRenderableInk::IsDifferent(pOther)) return(TRUE); ERROR3IF(GetRuntimeClass() != pOther->GetRuntimeClass(), "Node::IsDifferent base class method seems to have been broken"); // Now, check the path info if (InkPath.GetNumCoords() != ((NodePath *)pOther)->InkPath.GetNumCoords()) return(TRUE); // Check if all the coords and verbs are the same DocCoord *pCoord1 = InkPath.GetCoordArray(); DocCoord *pCoord2 = ((NodePath *)pOther)->InkPath.GetCoordArray(); PathVerb *pVerb1 = InkPath.GetVerbArray(); PathVerb *pVerb2 = ((NodePath *)pOther)->InkPath.GetVerbArray(); for (INT32 i = 0; i < InkPath.GetNumCoords(); i++) { if (pVerb1[i] != pVerb2[i] || pCoord1[i] != pCoord2[i]) return(TRUE); } return(FALSE); }

BOOL NodePath::IsNodePath (   )  const [virtual]

Override the node virtual function IsNodePath() and return TRUE as we definitely are one. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/03/95 Returns: TRUE => This node is an instance of NodePath. FALSE => otherwise. Reimplemented from Node. Definition at line 271 of file nodepath.cpp. { return TRUE; }

BOOL NodePath::IsPathAllowable (   )  [virtual]

This function following some operations on the path. It allows the path (and objects derived from NodePath) to say wether the operation has left them in an invalid state. For example, following a delete a closed path of one segment is not allowed. Further example, Mould paths can override this function to ensure there is at least four points on the path after a delete. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the path is valid FALSE if is not valid See also: - Definition at line 2231 of file nodepath.cpp. { INT32 NumCoords = InkPath.GetNumCoords(); PathVerb* Verbs = NULL; PathFlags* Flags = NULL; DocCoord* Coords = NULL; InkPath.GetPathArrays(&Verbs, &Coords, &Flags); // It's a moveto/lineto combination if ( (NumCoords == 2) && (Verbs[1] & PT_CLOSEFIGURE) && ((Verbs[1] & ~PT_CLOSEFIGURE) == PT_LINETO) ) { ERROR3IF(Verbs[0] != PT_MOVETO,"Path didn't start with a moveto!"); return FALSE; } // It's a moveto/curveto combination if ( (NumCoords == 4) && (Verbs[3] & PT_CLOSEFIGURE) && ((Verbs[3] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) ) { ERROR3IF(Verbs[0] != PT_MOVETO,"Path didn't start with a moveto!"); ERROR3IF(Verbs[1] != PT_BEZIERTO,"Path didn't continue with a Bezierto!"); return FALSE; } return TRUE; }

virtual BOOL NodePath::IsTypeExtendible (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 245 of file nodepath.h. { return TRUE; }

NodePath * NodePath::MakeNodePathFromAttributes (  double  Flatness = 750.0, CCAttrMap *  pAttrMap = NULL, BOOL  bIncludeClosedPaths = FALSE, BOOL  IncludeWidth = TRUE )

See returns. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 6/12/99 Parameters: Flatness  - The flatness to use in the stroking [INPUTS] pAttrMap - The attribute map to use (if NULL then use the attribute map applied to this object) [OUTPUTS]  Returns: A new node path, stroked + with all line attributes applied to it (i.e. line width, dash patterns, arrowheads etc) Errors: Scope: public Definition at line 1547 of file nodepath.cpp. { // Find the applied attributes AttrLineWidth * pAttrLineWidth = NULL; AttrStartArrow * pAttrStartArrow = NULL; AttrEndArrow * pAttrEndArrow = NULL; AttrJoinType * pAttrJoinType = NULL; AttrStartCap * pAttrStartCap = NULL; AttrDashPattern * pAttrDashPattern = NULL; AttrStrokeColour* pAttrStrokeColour = NULL; AttrStrokeType* pAttrStrokeType = NULL; AttrVariableWidth* pAttrVariableWidth = NULL; if (!pAttrMap) { // get all the attributes out of the node FindAppliedAttribute(CC_RUNTIME_CLASS(AttrLineWidth),(NodeAttribute **)(&pAttrLineWidth)); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStartArrow),(NodeAttribute **)(&pAttrStartArrow)); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrEndArrow),(NodeAttribute **)(&pAttrEndArrow)); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrJoinType),(NodeAttribute **)(&pAttrJoinType)); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStartCap),(NodeAttribute **)(&pAttrStartCap)); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrDashPattern),(NodeAttribute **)(&pAttrDashPattern)); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour),(NodeAttribute **)(&pAttrStrokeColour)); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeType), (NodeAttribute **)(&pAttrStrokeType)); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrVariableWidth), (NodeAttribute **)(&pAttrVariableWidth)); } else { // get all the attributes out of the attribute map pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrLineWidth), (void *&)pAttrLineWidth ); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrStartArrow), (void *&)pAttrStartArrow ); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrEndArrow), (void *&)pAttrEndArrow); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrJoinType), (void *&)pAttrJoinType); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrStartCap), (void *&)pAttrStartCap); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrDashPattern), (void *&)pAttrDashPattern); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrStrokeColour), (void *&)pAttrStrokeColour); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrStrokeType), (void *&)pAttrStrokeType); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrVariableWidth), (void *&)pAttrVariableWidth); if (!pAttrLineWidth) FindAppliedAttribute(CC_RUNTIME_CLASS(AttrLineWidth),(NodeAttribute **)(&pAttrLineWidth)); if (!pAttrStartArrow) FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStartArrow),(NodeAttribute **)(&pAttrStartArrow)); if (!pAttrEndArrow) FindAppliedAttribute(CC_RUNTIME_CLASS(AttrEndArrow), (NodeAttribute **)(&pAttrEndArrow)); if (!pAttrJoinType) FindAppliedAttribute(CC_RUNTIME_CLASS(AttrJoinType),(NodeAttribute **)(&pAttrJoinType)); if (!pAttrStartCap) FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStartCap),(NodeAttribute **)(&pAttrStartCap)); if (!pAttrDashPattern) FindAppliedAttribute(CC_RUNTIME_CLASS(AttrDashPattern),(NodeAttribute **)(&pAttrDashPattern)); if (!pAttrStrokeColour) FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour),(NodeAttribute **)(&pAttrStrokeColour)); if (!pAttrStrokeType) FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeType), (NodeAttribute **)(&pAttrStrokeType)); if(!pAttrVariableWidth) FindAppliedAttribute(CC_RUNTIME_CLASS(AttrVariableWidth), (NodeAttribute **)(&pAttrVariableWidth)); } // ******************************************************************************************** // Matt 20/10/2000 // At this point if stroke shapes are used, we may have a path consisting of a number of points // joined by lines - we can represent this much more efficiently as a path of a fewer number of // points joined by curves: This is achieved by smoothing the path with RetroSmooth // ******************************************************************************************** // Mark Howitt 18/12/00 - I`ve now made it check to see if the Stroke colour is transparent, as // the outline of the last line width is returned which is not correct. // When the outline is made NONE it does not contribute to the objects outline. BOOL IsTransparentStroke = FALSE; if(pAttrStrokeColour) { DocColour* pCol = pAttrStrokeColour->Value.GetStartColour(); IsTransparentStroke = pCol->IsTransparent(); } // If this nodepath belongs to an object with a stroke type attribute, then we should smooth it... if (pAttrStrokeType && !IsTransparentStroke) { // Check to see if the Stroke is the default type by checking the Variable width Attribute // Width function pointer! if(pAttrVariableWidth && ((VariableWidthAttrValue*)pAttrVariableWidth->GetAttributeValue())->GetWidthFunction() != NULL) { // double Smooth = 15.0; #ifdef CONVERTSTROKES // vector stroking in here PathProcessorStroke* pPPS = pAttrStrokeType->GetPathProcessor(); if (pPPS) { BOOL OriginalIsClosed = InkPath.IsClosed(); Path UnStrokedPath; UnStrokedPath.Initialise(); if(OriginalIsClosed) UnStrokedPath.CloneFrom(InkPath); // path processor stroke always wants stroked unfilled path Path ClonePath; ClonePath.Initialise(); ClonePath.CloneFrom(InkPath); ClonePath.IsFilled = FALSE; ClonePath.IsStroked = TRUE; // Path processor makes a nodepath for us NodePath* pNewNodePath = pPPS->GetSmoothProcessedPath(&ClonePath, this); if (pNewNodePath == NULL) { ERROR3("Urk - Cannae get yer stroak path lassie"); } else { double SFlat = pNewNodePath->InkPath.CalculateFlatnessValueFromPath(500.0,2.0,375.0); double CFlat = UnStrokedPath.CalculateFlatnessValueFromPath(500.0,2.0,375.0); DWORD ClipRule = OriginalIsClosed ? 7 : 3; if(UnStrokedPath.ClipPathToPath(pNewNodePath->InkPath,&pNewNodePath->InkPath,ClipRule|CLIPPING_SOURCE_WINDING,20,SFlat,CFlat) < 0) { ERROR3("Urk - Cannae get yer stroak path lassie"); } } return pNewNodePath; } #else if (RetroSmoothMe(Smooth)) { // make a copy to return NodePath * pRetnNode = new NodePath; ERROR2IF(!pRetnNode,NULL,"Failed to create a new Path Node!"); pRetnNode->InkPath.Initialise(); pRetnNode->InkPath.CloneFrom(InkPath); return pRetnNode; } #endif } } // ******************************************************************************************** // End of RetroSmoothing... // ******************************************************************************************** // Make the return node and initialize it! NodePath * pRetnNode = new NodePath; ERROR2IF(!pRetnNode,NULL,"Failed to create a new Path Node!"); pRetnNode->InkPath.Initialise(); Path SrcPath; SrcPath.Initialise(); SrcPath.CloneFrom(InkPath); DashPatternAttribute* pDashPattern = NULL; StartArrowAttribute* pStartArrow = NULL; LineWidthAttribute* pLineWidth = NULL; EndArrowAttribute* pEndArrow = NULL; JoinTypeAttribute* pJoinType = NULL; StartCapAttribute* pStartCap = NULL; // set up the attribute values if (pAttrLineWidth) pLineWidth = &(pAttrLineWidth->Value); if (pAttrStartArrow) pStartArrow = &(pAttrStartArrow->Value); if (pAttrEndArrow) pEndArrow = &(pAttrEndArrow->Value); if (pAttrJoinType) pJoinType = &(pAttrJoinType->Value); if (pAttrStartCap) pStartCap = &(pAttrStartCap->Value); if (pAttrDashPattern) pDashPattern = &(pAttrDashPattern->Value); // go through each path checking for non-closed paths INT32 StartIndex = 0; INT32 EndIndex = 0; Path SubPath; SubPath.Initialise(); Path FlatPath; FlatPath.Initialise(); UINT32 SubPathNum = 0; MILLIPOINT Width = 750; MILLIPOINT EndsWidth = 750; if(pLineWidth != NULL) Width = EndsWidth = pLineWidth->LineWidth; if(pAttrStrokeColour && pAttrStrokeColour->GetStartColour()->IsTransparent()) { Width = 0; pDashPattern = NULL; } JoinStyles JoinS = JOIN_ROUND; if(pJoinType != NULL) JoinS = (pJoinType->JoinType == MitreJoin) ? JOIN_MITER : (pJoinType->JoinType == RoundJoin) ? JOIN_ROUND : JOIN_BEVEL; // Dash pattern - convert to Gavin-ness... DashType* pDashRec = NULL; DashType GavinDash; GavinDash.Length = 0; GavinDash.Offset = 0; GavinDash.Array[0] = 0; // Do do dash patten if there is one and the line width is greater than 0! if (pDashPattern && pDashPattern->DashPattern.Elements > 0 && pDashPattern->DashPattern.LineWidth > 0) { INT32 Length = pDashPattern->DashPattern.Elements; if (Length > 8) Length = 8; BOOL DoScale = pDashPattern->DashPattern.ScaleWithLineWidth; FIXED16 Scale = DoScale ? (double(Width) / double(pDashPattern->DashPattern.LineWidth)) : 1; GavinDash.Length = Length; GavinDash.Offset = LongMulFixed16(pDashPattern->DashPattern.DashStart, Scale); for (INT32 el = 0; el < Length; el++) { GavinDash.Array[el] = LongMulFixed16(pDashPattern->DashPattern.ElementData[el], Scale); } } // Set the dash pointer to the gavin dash structure! pDashRec = &GavinDash; // Make sure that we put the Width to a suitable value if we don`t require line widths in // the calculations if(!IncludeWidth && pAttrStrokeColour && !pAttrStrokeColour->GetStartColour()->IsTransparent()) Width = 50; Path BlankPath; BlankPath.Initialise(); Path StrokedPath; StrokedPath.Initialise(); while (StartIndex < InkPath.GetNumCoords()) { // get the end of the sub-path EndIndex = StartIndex; InkPath.FindEndElOfSubPath(&EndIndex); // only do this if the sub-path isn't closed // if (!InkPath.IsSubPathClosed(StartIndex) || bIncludeClosedPaths) if (!InkPath.IsClosed() || bIncludeClosedPaths) { // we have found the last element of the sub-path // therefore make a new path SubPath.ClearPath(); InkPath.MakePathFromSubPath(SubPathNum, &SubPath); FlatPath.ClearPath(); FlatPath.CloneFrom(SubPath); // first, stroke the path SrcPath.IsFilled = FALSE; SrcPath.IsStroked = FALSE; if (pStartCap && pJoinType) { SubPath.StrokePathToPath(Width, pStartCap->StartCap, pJoinType->JoinType, pDashRec, &StrokedPath, Flatness, FALSE); } else { SubPath.StrokePathToPath(Width, LineCapRound, RoundJoin, pDashRec, &StrokedPath, Flatness, FALSE); } // ensure the validity of the path Path ClipPath; ClipPath.Initialise(); ClipPath.CloneFrom(StrokedPath); StrokedPath.ClearPath(); if(ClipPath.ClipPathToPath(BlankPath, &StrokedPath, 6 | CLIPPING_CLIP_WINDING,30, Flatness, Flatness) < 2) StrokedPath.CloneFrom(ClipPath); // now, do the arrowheads INT32 Index = 0; DocCoord Centre; DocCoord Direction; Trans2DMatrix ArrowMatrix; Path ArrowPath; ArrowPath.Initialise(); Path DestPathStartArrow; DestPathStartArrow.Initialise(); Path DestPathEndArrow; DestPathEndArrow.Initialise(); ClipPath.ClearPath(); // do the start arrow if (pStartArrow) { if (pStartArrow->StartArrow.GetArrowPath()) { Centre = FlatPath.GetCoordArray()[0]; Direction = FlatPath.GetCoordArray()[1]; pStartArrow->StartArrow.GetArrowMatrix(Centre, Direction, EndsWidth, &ArrowMatrix); // build the arrow's path and add it to the existing path ArrowPath.ClearPath(); ArrowPath.CloneFrom(*pStartArrow->StartArrow.GetArrowPath()); ArrowMatrix.Transform(ArrowPath.GetCoordArray(), ArrowPath.GetNumCoords()); DestPathStartArrow.ClearPath(); ClipPath.CloneFrom(StrokedPath); if(ClipPath.ClipPathToPath(ArrowPath,&StrokedPath, 7 | CLIPPING_SOURCE_WINDING,30, Flatness, Flatness) < 2) { TRACEUSER( "MarkH", _T("ClipFailed so copying path! NODEPATH\n")); } pRetnNode->InkPath.MergeTwoPaths(DestPathStartArrow); } } // do the end arrow if (pEndArrow) { if (pEndArrow->EndArrow.GetArrowPath()) { Index = 0; Centre = FlatPath.GetCoordArray()[FlatPath.GetNumCoords() - 1]; Direction.x = FlatPath.GetCoordArray()[FlatPath.GetNumCoords() - 1].x - FlatPath.GetCoordArray()[FlatPath.GetNumCoords() - 2].x; Direction.y = FlatPath.GetCoordArray()[FlatPath.GetNumCoords() - 1].y - FlatPath.GetCoordArray()[FlatPath.GetNumCoords() - 2].y; Direction.x = Centre.x - Direction.x; Direction.y = Centre.y - Direction.y; pEndArrow->EndArrow.GetArrowMatrix(Centre, Direction, EndsWidth, &ArrowMatrix); // build the arrow's path and add it to the existing path ArrowPath.ClearPath(); ArrowPath.CloneFrom(*pEndArrow->EndArrow.GetArrowPath()); ArrowMatrix.Transform(ArrowPath.GetCoordArray(), ArrowPath.GetNumCoords()); DestPathEndArrow.ClearPath(); ClipPath.CloneFrom(StrokedPath); if(ClipPath.ClipPathToPath(ArrowPath,&StrokedPath, 7 | CLIPPING_SOURCE_WINDING,30, Flatness, Flatness) < 2) { ArrowPath.CloneFrom(ClipPath); TRACEUSER( "MarkH", _T("ClipFailed so copying path! NODEPATH\n")); } pRetnNode->InkPath.MergeTwoPaths(DestPathEndArrow); } } if (pRetnNode->InkPath.GetBoundingRect().Union(StrokedPath.GetBoundingRect()).IsEmpty()) { pRetnNode->InkPath.MergeTwoPaths(StrokedPath); } else { ClipPath.CloneFrom(pRetnNode->InkPath); pRetnNode->InkPath.ClearPath(); if(StrokedPath.ClipPathToPath(ClipPath, &(pRetnNode->InkPath), 7 | CLIPPING_SOURCE_WINDING,30, Flatness, Flatness) < 2) { pRetnNode->InkPath.CloneFrom(ClipPath); TRACEUSER( "MarkH", _T("ClipFailed so copying path! NODEPATH\n")); } } } else { SubPath.ClearPath(); // make sure that if we do require line widths to be taken into account then we need to stroke using the line width! if(IncludeWidth) { // First do the clipping to make sure the windings come out correct! SubPath.CloneFrom(InkPath); if(BlankPath.ClipPathToPath(SubPath, &StrokedPath, 3, 10, Flatness, Flatness) < 2) { StrokedPath.CloneFrom(SubPath); TRACEUSER( "MarkH", _T("ClipFailed so copying path! NODEPATH\n")); } // Now get the contour step for the full width! StrokedPath.InitializeContourValues(Width,JoinS,true,Flatness); if(StrokedPath.GetContourForStep(&pRetnNode->InkPath,1.0) < 2) { pRetnNode->InkPath.CloneFrom(StrokedPath); TRACEUSER( "MarkH", _T("ClipFailed so copying path! NODEPATH\n")); } } else { // Just clone the original! InkPath.MakePathFromSubPath(SubPathNum, &SubPath); pRetnNode->InkPath.MergeTwoPaths(SubPath); } } StartIndex = EndIndex+1; SubPathNum++; } if (pRetnNode) { pRetnNode->InkPath.IsFilled = TRUE; pRetnNode->InkPath.IsStroked = FALSE; } return pRetnNode; }

BOOL NodePath::NeedsToExport (  RenderRegion *  pRender, BOOL  VisibleLayersOnly = FALSE, BOOL  CheckSelected = FALSE )  [virtual]

Virtual function - this version currently returns false if the path is an immediate child of a text story otherwise its always exportable. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/03/95 Parameters: pRender  - A pointer to the current export region [INPUTS] VisibleLayersOnly - TRUE => remove nodes which are on invisible layers FALSE => export everything CheckSelected - TRUE => we check if object selected and only export selected bjects FALSE => we don't bother checking for selection or not Returns: TRUE => please export me. Reimplemented from NodeRenderable. Definition at line 2275 of file nodepath.cpp. { #ifdef DO_EXPORT if (pRender->IsKindOf(CC_RUNTIME_CLASS(EPSRenderRegion))) { Node* pParent=FindParent(); if (pParent!=NULL && IS_A(pParent,TextStory)) return FALSE; } // If we have the check selection flag on then see if this node is:- // - selected or not = render it // - a child of the selection e.g. part of selected group where we are an item in the // group and hence are not directly selected but still need to be exported // - a parent of the selected item e.g. selected inside item of group and we are at the // group and hence need to include the group in the range // Otherwise just return True as this is a path node and always needs to be exported // unless of course some node overrides this. if (CheckSelected) return (IsSelected() || IsChildOfSelected() || IsParentOfSelected()); else return TRUE; #else return FALSE; #endif }

BOOL NodePath::OnBlobPopUp (  Spread *  pSpread, DocCoord  PointerPos, ContextMenu *  pMenu )  [virtual]

Allows the Node to respond to pop up menu clicks on blobs. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 10/04/95 Parameters: pSpread  The spread in which things are happening [INPUTS] PointerPos The Location of the mouse pointer at the time of the click pMenu The menu to which items should be added Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented from NodeRenderableInk. Definition at line 873 of file nodepath.cpp. { #if !defined(EXCLUDE_FROM_RALPH) DocRect BlobRect; // DocCoord* Coords = InkPath.GetCoordArray(); // PathFlags* Flags = InkPath.GetFlagArray(); // PathVerb* Verbs = InkPath.GetVerbArray(); // Should always be able to get selected view DocView *pDocView = DocView::GetSelected(); ERROR3IF(pDocView == NULL, "NodePath::OnClick: Could not get selected DocView"); if (pDocView == NULL) return FALSE; // If there are no selected points we won't put up our menu because its // items are entirely to do with points (a useful thing in a Blobs menu!). if (!InkPath.IsSubSelection()) return FALSE; // INT32 NumCoords = InkPath.GetNumCoords(); INT32 i; if (InkPath.FindNearestPoint( PointerPos, POINTFLAG_ENDPOINTS | POINTFLAG_CONTROLPOINTS | POINTFLAG_ENDSFIRST, &i) ) { pMenu->BuildCommand(TOOL_OPTOKEN_BEZTOOL, TRUE); pMenu->BuildCommand(OPTOKEN_MAKELINESOP); pMenu->BuildCommand(OPTOKEN_MAKECURVESOP, TRUE); pMenu->BuildCommand(OPTOKEN_DELETEPOINTSOP); pMenu->BuildCommand(OPTOKEN_BREAKATPOINTS, TRUE); pMenu->BuildCommand(OPTOKEN_SELECTALLPATHPOINTS); pMenu->BuildCommand(OPTOKEN_DESELECTALLPATHPOINTS, TRUE); return TRUE; } #endif // we do not want to claim the click, so return FALSE return FALSE; }

ChangeCode NodePath::OnChildChange (  ObjChangeParam *  pParam  )  [virtual]

It is now necessary to know when the nodepath has been updated because if it has a brush applied to it the brush needs to clear its cache. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 09/01/95 Parameters: pParam  = pointer to a object change parameter class [INPUTS] Returns: CC_OK Reimplemented from Node. Definition at line 640 of file nodepath.cpp. { // look for an applied brush attribute NodeAttribute* pAttr = NULL; AttrBrushType* pAttrBrush = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), &pAttr); if (pAttr!= NULL) { pAttrBrush = (AttrBrushType*)pAttr; // make an undoable action UpdateBrushAction* pAction; UndoableOperation* pOp = pParam->GetOpPointer(); if (pOp != NULL) UpdateBrushAction::Init(pOp, pOp->GetUndoActionList(), this, &pAction); } return CC_OK; }

BOOL NodePath::OnClick (  DocCoord  PointerPos, ClickType  Click, ClickModifiers  ClickMods, Spread *  pSpread )  [virtual]

Allows the Node to respond to clicks by selecting its blobs or starting drags etc. This functions should be overridden in the all the NodeRenderableInk classes so that this verion never gets called. Eg the NodePath class might claim the click if it happened over one of its unselected blobs. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: PointerPos  - The Location of the mouse pointer at the time of the click [INPUTS] Click - The type of click received (single, double, drag etc) ClickMods - The modifiers to the click (eg shift, control etc ) Returns: BOOL - TRUE if the node claims the click as its own and FLASE if it is not interested in the click Reimplemented from NodeRenderableInk. Definition at line 706 of file nodepath.cpp. { #ifndef STANDALONE DocRect BlobRect; DocCoord* Coords = InkPath.GetCoordArray(); PathFlags* Flags = InkPath.GetFlagArray(); // PathVerb* Verbs = InkPath.GetVerbArray(); // Should always be able to get selected view DocView *pDocView = DocView::GetSelected(); ERROR3IF(pDocView == NULL, "NodePath::OnClick: Could not get selected DocView"); if (pDocView == NULL) return FALSE; // we only handle the click if we can confirm that object blobs are being displayed. BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr == NULL) return FALSE; if (!pBlobMgr->GetCurrentInterest().Object) return FALSE; INT32 NumCoords = InkPath.GetNumCoords(); INT32 i; if (InkPath.FindNearestPoint( PointerPos, POINTFLAG_ENDPOINTS | POINTFLAG_CONTROLPOINTS | POINTFLAG_ENDSFIRST, &i) ) { // we had a hit on a blob, so do something with it if ( Click == CLICKTYPE_SINGLE ) { // Clicks on control points have no effect // but clicks on endpoints do have an effect if (Flags[i].IsEndPoint) { if (ClickMods.Adjust && ClickMods.Constrain) { HandleBlobClick(Coords, Flags, i, NumCoords, TRUE, TRUE); } else { if ((!Flags[i].IsSelected) || ((Flags[i].IsSelected) && (ClickMods.Adjust))) { HandleBlobClick(Coords, Flags, i, NumCoords, ClickMods.Adjust, FALSE); } else { // In order to deselect all but the clicked on point and still have dragging of // multiple points we need to start the drag op on the click and handle a click // at the end of the drag if (Flags[i].IsSelected && !ClickMods.Menu) { OpNodePathEditBlob* pOpNodePath = new OpNodePathEditBlob; if (pOpNodePath == NULL) InformError(); else pOpNodePath->DoStartDragEdit(this, Coords[i], pSpread); } } } } else { // Detected single click on Control Point } } if ( Click == CLICKTYPE_DOUBLE) { // A point has been double-clicked. Only if it's selected and an endpoint can we // do anything about it. What we do is the toggle smooth operation if (Flags[i].IsSelected && Flags[i].IsEndPoint) { // Try and create the toggle operation OpToggleSmooth* pOpToggle = new OpToggleSmooth; if (!pOpToggle) { // Inform the user that we are out of memory InformError(); } else { // Call the function that actually does something pOpToggle->DoTogglePoint(this, i, pSpread, FALSE, !ClickMods.Constrain); // invert constrain } } } // Check for drags, but only when the click isn't due to a menu click. if ( Click == CLICKTYPE_DRAG && !ClickMods.Menu ) { //if (Flags[i].IsSelected) { if (Flags[i].IsEndPoint) { // Need to do a drag on the selected points, // so we had better start an operation OpNodePathEditBlob* pOpNodePath = new OpNodePathEditBlob; if (pOpNodePath == NULL) { // Inform the user that we are out of memory InformError(); } else { // Start the drag operation and pass in the Anchor Point to the operation // The anchor point MUST be the true coord of the path point for // snapping to work correctly (Markn 30/9/94) pOpNodePath->DoStartDragEdit(this, Coords[i], pSpread); } } else { // This must be a drag on a control point, so start an operation to // handle that situation OpNodePathEditControlBlob* pOpNodePath = new OpNodePathEditControlBlob; if (pOpNodePath==NULL) { // Failed to get the mem I needed InformError(); } else { // Start the drag operation and pass in the Anchor Point to the operation // The anchor point MUST be the true coord of the path point for // snapping to work correctly (Markn 30/9/94) pOpNodePath->DoStartDragEdit(this, Coords[i], pSpread, i); } } } } return TRUE; } #endif // we do not want to claim the click, so return FALSE return FALSE; }

BOOL NodePath::OnNodePopUp (  Spread *  pSpread, DocCoord  PointerPos, ContextMenu *  pMenu )  [virtual]

Allows the Node to respond to pop up menu clicks on it (rather than its blobs). Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 13/05/95 Parameters: pSpread  The spread in which things are happening [INPUTS] PointerPos The Location of the mouse pointer at the time of the click pMenu The menu to which items should be added Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented from NodeRenderableInk. Definition at line 936 of file nodepath.cpp. { #if !defined(EXCLUDE_FROM_RALPH) BOOL ok = TRUE; ok = ok && pMenu->BuildCommand(TOOL_OPTOKEN_BEZTOOL, TRUE); return ok; #else return FALSE; #endif }

void NodePath::PolyCopyNodeContents (  NodeRenderable *  pNodeCopy  )  [virtual]

Polymorphically copies the contents of this node to another. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/12/2003 Parameters: -  [OUTPUTS] Returns: Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Reimplemented from NodeRenderableBounded. Reimplemented in NodeBlendPath, NodeBrushPath, and NodeMouldPath. Definition at line 474 of file nodepath.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodePath), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodePath)) CopyNodeContents((NodePath*)pNodeCopy); }

void NodePath::Render (  RenderRegion *  pRender  )  [virtual]

Will render the path contained within the object to the given render region. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Parameters: Pointer  to a render region [INPUTS] Reimplemented from Node. Reimplemented in NodeBlendPath, NodeBrushPath, and NodeMouldPath. Definition at line 496 of file nodepath.cpp. { // render the path. TRACEUSER( "Diccon", _T("Rendering nodepath\n")); pRender->DrawPath(&InkPath); }

void NodePath::RenderEorDrag (  RenderRegion *  pRender  )  [virtual]

Renders a version of the path for EORed dragging of shapes. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/93 Parameters: pRender  - A Pointer to the current RenderRegion [INPUTS] See also: NodePath::Render; NodeRenderableInk::RenderEorDrag Reimplemented from NodeRenderableInk. Reimplemented in NodeBlendPath, NodeBrushPath, and NodeMouldPath. Definition at line 517 of file nodepath.cpp. { // Currently this function performs an identical task to the // Render() function // render the path pRender -> DrawPath( &InkPath ); }

void NodePath::RenderObjectBlobs (  RenderRegion *  pRender  )  [virtual]

Draws the paths object blobs into the render region supplied. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/94 Parameters: pRender  - The region to render the blobs into [INPUTS] Reimplemented from NodeRenderable. Reimplemented in NodeBlendPath, NodeBrushPath, and NodeMouldPath. Definition at line 539 of file nodepath.cpp. { // Find the parent spread Spread* pSpread = FindParentSpread(); ENSURE(pSpread != NULL, "NodePath does not have a parent spread"); // Render the blobs on the path if (pSpread!=NULL) InkPath.RenderPathBlobs(pRender); // New Diccon 13/6/2000 If we are a brush and we are selected then we want to // render the path on top NodeAttribute* pAttr = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), &pAttr); if (pAttr!= NULL) { if (((AttrBrushType*)pAttr)->GetBrushHandle() != BrushHandle_NoBrush) { // --- If the quality is set low enough, strokes are just rendered as centrelines // "low enough" is defined as the same point that Blends show their middle parts // BLOCK { View* pRenderView = NULL; pRenderView = pRender->GetRenderView(); if(pRenderView != NULL) { Quality viewQuality = pRenderView->RenderQuality; if (viewQuality.GetBlendQuality() == Quality::FullBlend) { pRender->SetLineColour(COLOUR_BEZIERLINE); pRender->SetFillColour(COLOUR_NONE); pRender->DrawPath(&InkPath); } } } } } }

void NodePath::RenderPenBlobs (  RenderRegion *  pRender  )  [virtual]

Draws the paths pen blobs into the render region supplied. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/94 Parameters: pRender  - The region to render the blobs into [INPUTS] Reimplemented from NodeRenderable. Definition at line 590 of file nodepath.cpp. { // Find the parent spread Spread* pSpread = FindParentSpread(); ENSURE(pSpread != NULL, "NodePath does not have a parent spread"); // Render the blobs on the path if (pSpread!=NULL) InkPath.RenderPathPenBlobs(pSpread); }

void NodePath::RenderTinyBlobs (  RenderRegion *  pRender  )  [virtual]

Draws the paths Tiny blob into the render region supplied. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/94 Parameters: pRender  - The region to render the blobs into [INPUTS] Reimplemented from NodeRenderable. Reimplemented in NodeBrushPath. Definition at line 613 of file nodepath.cpp. { // Set the line colours etc as we need them pRender->SetLineColour(COLOUR_NONE); pRender->SetFillColour(COLOUR_UNSELECTEDBLOB); // Render the blobs on the path DocCoord* Coords = InkPath.GetCoordArray(); pRender->DrawBlob(Coords[0], BT_UNSELECTED); }

BOOL NodePath::RetroSmoothMe (  double  Smoothness  )

Use and abuse the retrosmoother to smooth our ink path. The Retrosmoother is normally activated from the gadget in the shape editor tool however we are hijacking it here for our purposes. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: Smoothness  - the amount to smooth by [INPUTS] [OUTPUTS]  Returns: TRUE if everything went ok, FALSE if not. Errors: Scope: public Definition at line 2019 of file nodepath.cpp. { if (Smoothness <= 0) { ERROR3("Zero smoothing value in NodePath::RetroSmoothMe"); return TRUE; } Spread *pSpread = Document::GetSelectedSpread(); ERROR2IF(pSpread == NULL, FALSE, "No spread in NodePath::RetroSmoothMe"); //Make a retro smoother and tell it not to bother with EOR rendering on top RetroSmooth rSmoother; rSmoother.Initialise(); rSmoother.SetRenderFlag(false); // all path points must be selected InkPath.SetAllSubSelection(); // set the smoother to work rSmoother.Changing(this, pSpread, Smoothness); BOOL ok = rSmoother.FinishedNoUndo(this); InkPath.ClearSubSelection(); return ok; }

BOOL NodePath::SetUpPath (  INT32  RequiredSize = 12, INT32  BlockSize = 12 )

To initialise the Nodepath into a state that can be used, by allocating memory, setting up member variables properly and inserting an EndPath element into the path. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 04/5/93 Parameters: RequiredSize  - The size of the initial block of memory to be allocated to the [INPUTS] path. BlockSize - The size of the block asked for by the path object when it runs out of space. Returns: TRUE if the path was init'ed ok, FALSE otherwise Definition at line 296 of file nodepath.cpp. { CurrentRotation = 0.0; return (InkPath.Initialise(RequiredSize, BlockSize)); }

Node * NodePath::SimpleCopy (  void   )  [virtual]

Makes a copy of all the data in the node. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Returns: Pointer to a Node Reimplemented from NodeRenderableInk. Reimplemented in NodeBlendPath, NodeBrushPath, and NodeMouldPath. Definition at line 425 of file nodepath.cpp. { NodePath* NodeCopy = new NodePath(); if (NodeCopy) CopyNodeContents(NodeCopy); return NodeCopy; }

BOOL NodePath::Snap (  DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )  [virtual]

Snaps the given rect to the nearest position on the grid, preserving its width and height. The coords of the rect used for the snapping are determined by the PrevCoord and CurCoord coords supplied. This is done to allow the user to control how a selection rectangle is snapped to the grid by the direction of his/her last mouse movement. To force the bottom left hand corner of the rect to be snapped, supply PrevCoord=(0,0) and CurCoord(-1,-1). Scope: public. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/94 Parameters: pDocCoord  - the rectangle to snap [INPUTS] StartDrag - Start coord of drag EndDrag - End coord of drag [OUTPUTS]  Returns: TRUE - the DocRect been snapped to the grid. FALSE - the DocRect has not been processed. Reimplemented from NodeRenderableBounded. Definition at line 2107 of file nodepath.cpp. { #if !defined(EXCLUDE_FROM_RALPH) TRACEUSER( "MarkN", _T("NodePath::Snap(DocRect)\n") ); #endif return FALSE; }

BOOL NodePath::Snap (  DocCoord *  pDocCoord  )  [virtual]

Snaps to given coord to the nearest point on the path. If it is not appropriate to snap the coord to the path (at the moment this means the coord is too far awawy), then FALSE is returned. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pDocCoord  = a coord in Spread coords [INPUTS] [OUTPUTS]  Returns: TRUE - the DocCoord has been snapped to the path. FALSE - the DocCoord has not been processed. Errors: Scope: public Reimplemented from NodeRenderableBounded. Definition at line 2071 of file nodepath.cpp. { #if !defined(EXCLUDE_FROM_RALPH) return CSnap::SnapCoordToPath(pDocCoord, &InkPath); #else return FALSE; #endif }

BOOL NodePath::SnapToCoords (  DocCoord *  pDocCoord  )  [virtual]

Snaps the point to all the magnetic points in a NodePath. These include all the endpoint in the path (ie MoveTos, LineTos and the last point in CurveTos). If it is close enough to any of these points in the path then the coord ischanged to match the point on the path and TRUE is returned. pDocCoord is not effected if it is not close enough to any of the points in the path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: pDocCoord  - the point to magnetically snap [INPUTS] pDocCoord  - if the point was able to magnetically snap to a coord then [OUTPUTS] it is changed to that coord Returns: TRUE if it snapped to a coord, FALSE if not See also: MagneticPointRadius; NodeRenderableBounded::SnapToCoords Reimplemented from NodeRenderableBounded. Definition at line 2138 of file nodepath.cpp. { #if !defined(EXCLUDE_FROM_RALPH) DocCoord* Coords = InkPath.GetCoordArray(); PathFlags* Flags = InkPath.GetFlagArray(); INT32 NumCoords = InkPath.GetNumCoords(); // loop through all the coords in the path for (INT32 i=0; i<NumCoords; i++) { // Only test the endpoints if (Flags[i].IsEndPoint) { // Now test the coord to see if it is close if (IsMagneticallyClose(&Coords[i], pDocCoord)) return TRUE; } } #endif // Did not find a match return FALSE; }

void NodePath::Transform (  TransformBase &  Trans  )  [virtual]

Will Transform all the coords in the path with the transform provided. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/93 Parameters: Trans  - The transform to be applied to the path [INPUTS] See also: NodeRenderableInk::Transform() Reimplemented from NodeRenderableBounded. Reimplemented in NodeBrushPath. Definition at line 1097 of file nodepath.cpp. { // Change all the coords Trans.Transform( (DocCoord*)InkPath.GetCoordArray(), InkPath.GetNumCoords() ); // and keep the bounding rectangle up to date. InvalidateBoundingRect(); // Transform all the children... TransformChildren(Trans); // Also update our CurrentRotation variable }

void NodePath::TransformTranslateObject (  const ExtendParams &  ExtParams  )  [virtual]

Do an extend (as opposed to stretch) operation on this path, using ExtParams as the source of the extend data, together with the extend-centre of this path, defined in NodeRenderable::FindExtendCentre(). Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 01/12/1999 Parameters: ExtParams  description of how this path should extend. [INPUTS] This  path's control points may be extended, depending on ExtParams' flags. [OUTPUTS] This function does nothing unless ExtParams uses X_EXTEND or Y_EXTEND. See also: The Extender class; FindExtendCentre(). Reimplemented from NodeRenderable. Definition at line 2875 of file nodepath.cpp. { // get the path's control points. INT32 numPoints = InkPath.GetNumCoords(); DocCoord* doccArray = InkPath.GetCoordArray(); // x-extension behaviour. if (ExtParams.fExtendFlags & X_EXTEND) { // translate the whole path by the offset from start- to end- centres. Trans2DMatrix baseXoffset(ExtParams.doccOffset.x, 0); Transform(baseXoffset); for (INT32 i = 0; i < numPoints; i ++) { if (doccArray[i].x > (ExtParams.doccEndCentre.x + ExtParams.xincExtendBuffer)) doccArray[i].x += ExtParams.xinc; else if (doccArray[i].x < (ExtParams.doccEndCentre.x - ExtParams.xdecExtendBuffer)) doccArray[i].x -= ExtParams.xdec; } } // y-extension behaviour. if (ExtParams.fExtendFlags & Y_EXTEND) { // translate the whole path by the offset from start- to end- centres. Trans2DMatrix baseYoffset(0, ExtParams.doccOffset.y); Transform(baseYoffset); for (INT32 i = 0; i < numPoints; i ++) { if (doccArray[i].y > (ExtParams.doccEndCentre.y + ExtParams.yincExtendBuffer)) doccArray[i].y += ExtParams.yinc; else if (doccArray[i].y < (ExtParams.doccEndCentre.y - ExtParams.ydecExtendBuffer)) doccArray[i].y -= ExtParams.ydec; } } }

DocRect NodePath::ValidateExtend (  const ExtendParams &  ExtParams  )  [virtual]

Tests to see whether this path's control points are positioned so as to make an extend operation irreversible. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 25/11/1999 Parameters: ExtParams  parameters describing the extension. [INPUTS] [OUTPUTS]  Returns: TRUE if this path can validly extend, FALSE otherwise. Errors: See also: Reimplemented from Node. Definition at line 2813 of file nodepath.cpp. { INT32 numPoints = InkPath.GetNumCoords(); DocCoord* doccArray = InkPath.GetCoordArray(); DocRect drMinExtend = Extender::ValidateControlPoints(numPoints, doccArray, ExtParams); // if we didn't invalidate the extension, we must call the base class // implementation, which will validate our children. if (drMinExtend.lo.x == INT32_MAX && drMinExtend.lo.y == INT32_MAX && drMinExtend.hi.x == INT32_MAX && drMinExtend.hi.y == INT32_MAX) drMinExtend = Node::ValidateExtend(ExtParams); return drMinExtend; }

BOOL NodePath::WriteBeginChildRecordsNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Begin to write out you child records, in the native format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/8/96 Parameters: pFilter  [INPUTS] Returns: TRUE if ok, FALSE otherwise This will write out a TAG_DOWN record, followed by a path flags record See also: - Reimplemented from NodeRenderableInk. Definition at line 2639 of file nodepath.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); BOOL ok = pFilter->WriteZeroSizedRecord(TAG_DOWN); if (ok) { INT32 NumCoords = InkPath.GetNumCoords(); INT32 RecordSize = sizeof(BYTE)*NumCoords; CamelotFileRecord Rec(pFilter,TAG_PATH_FLAGS,RecordSize); ok = Rec.Init(); PathFlags* pFlags = InkPath.GetFlagArray(); if (ok && pFlags != NULL) { BYTE Flags; for (INT32 i=0; ok && i < NumCoords;i++) { Flags = 0; if (pFlags[i].IsSmooth) Flags |= TAG_PATH_FLAGS_SMOOTH; if (pFlags[i].IsRotate) Flags |= TAG_PATH_FLAGS_ROTATE; if (pFlags[i].IsEndPoint) Flags |= TAG_PATH_FLAGS_ENDPOINT; ok = Rec.WriteBYTE(Flags); } ok = pFilter->Write(&Rec); } if (ok) { if (pFilter->GetBoundsWriteLevel() >= BWL_ALL) ok = WriteBoundsRecord(pFilter); } } return ok; #else return FALSE; #endif }

BOOL NodePath::WriteEndChildRecordsNative (  BaseCamelotFilter *  pFilter  )  [virtual]

End writing out you child records, in the native format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/8/96 Parameters: pFilter  [INPUTS] Returns: TRUE if ok, FALSE otherwise This will write out a TAG_UP record See also: - Reimplemented from NodeRenderableInk. Definition at line 2701 of file nodepath.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); return pFilter->WriteZeroSizedRecord(TAG_UP); #else return FALSE; #endif }

BOOL NodePath::WritePathRecord (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes the path record to the filter. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/96 Parameters: pFilter  = ptr to the filter [INPUTS] Returns: TRUE if record is written, FALSE if not See also: - Definition at line 2491 of file nodepath.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); INT32 RecordSize = CalcPathRecordSize(); BOOL ok = TRUE; // Which type of path is it to be? UINT32 Tag = ChooseTagValue(); CamelotFileRecord Rec(pFilter,Tag,RecordSize); ok = Rec.Init(); if (ok) ok = WritePathToRecord(&Rec); UINT32 RecordNumber; if (ok) RecordNumber = pFilter->WriteDefinitionRecord(&Rec); if (ok) ok = (RecordNumber != 0); if (ok) pFilter->AddPathRecordRefToList(this,RecordNumber); if (!ok) pFilter->GotError(_R(IDE_FILE_WRITE_ERROR)); return ok; #else return FALSE; #endif }

BOOL NodePath::WritePathRefRecord (  BaseCamelotFilter *  pFilter, UINT32  SrcPathRecNum, Matrix *  pTransform )  [virtual]

Writes the path reference record to the filter. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/9/96 Parameters: pFilter  = ptr to the filter [INPUTS] SrcPathRecNum = the record that contains the path that's similar to this path pTransform = How to transform the path in SrcPathRecNum to get this path bac Returns: TRUE if record is written, FALSE if not See also: - Definition at line 2537 of file nodepath.cpp. { ERROR2IF(pTransform == NULL,FALSE,"NULL transform matrix ptr"); BOOL ok = TRUE; UINT32 Tag = TAG_PATHREF_TRANSFORM; INT32 Size = TAG_PATHREF_TRANSFORM_SIZE; CamelotFileRecord Rec(pFilter,Tag,Size); if (ok) ok = Rec.Init(); if (ok) ok = Rec.WriteReference(SrcPathRecNum); if (ok) ok = Rec.WriteMatrixTrans(*pTransform,0,0); if (ok) ok = (pFilter->Write(&Rec) != 0); return ok; }

BOOL NodePath::WritePathToRecord (  CamelotFileRecord *  pRecord  )  [virtual]

Central func writes out the correct path record. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/96 Parameters: pRecord  = ptr to a record to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise See also: BaseCamelotFilter::WritePathsInRelativeFormat() Definition at line 2468 of file nodepath.cpp. { ERROR2IF(pRecord == NULL,FALSE,"NULL record ptr"); if (BaseCamelotFilter::WritePathsInRelativeFormat()) return pRecord->WritePathRelative(&InkPath); else return pRecord->WritePath(&InkPath); }

BOOL NodePath::WritePreChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes the path record to the filter. > virtual BOOL NodePath::WritePreChildrenNative(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/96 Parameters: pFilter  = ptr to the filter [INPUTS] Returns: TRUE if record is written, FALSE if not See also: - Reimplemented from Node. Reimplemented in NodeBlendPath, NodeBrushPath, and NodeMouldPath. Definition at line 2607 of file nodepath.cpp. { #ifdef DO_EXPORT // If it's the compact native filter (i.e. the non-minimal web format) OR the path // similarity check has been selected to apply to the native format, // do as you would for the web format. if (pFilter->IsCompactNativeFilter() || pFilter->GetNativeCheckSimilarPaths()) return WritePreChildrenWeb(pFilter); else return WritePathRecord(pFilter); #else return FALSE; #endif }

BOOL NodePath::WritePreChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes the path record to the filter. > virtual BOOL NodePath::WritePreChildrenWeb(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/96 Parameters: pFilter  = ptr to the filter [INPUTS] Returns: TRUE if record is written, FALSE if not See also: - Reimplemented from Node. Reimplemented in NodeBlendPath, NodeBrushPath, and NodeMouldPath. Definition at line 2569 of file nodepath.cpp. { #ifdef DO_EXPORT BOOL ok = TRUE; UINT32 SrcPathRecNum; Matrix Transform; INT32 RecordSize = CalcPathRecordSize(); // Only call FindSimilarPath() if the path is bigger than the path reference record. // there's no point in creating a reference if the ref is bigger than the actual path if (RecordSize > TAG_PATHREF_TRANSFORM_SIZE && pFilter->FindSimilarPath(this,&SrcPathRecNum,&Transform)) ok = WritePathRefRecord(pFilter,SrcPathRecNum,&Transform); else ok = WritePathRecord(pFilter); return ok; #else return FALSE; #endif }

---

Member Data Documentation

double NodePath::CurrentRotation [protected]

Definition at line 269 of file nodepath.h.

Path NodePath::InkPath

Definition at line 134 of file nodepath.h.

---

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

• Kernel/nodepath.h (r1785/r1282)
• Kernel/nodepath.cpp (r1785/r1688)

---