NodeContour Class Reference

Contour node. More...

#include <nodecntr.h>

Inheritance diagram for NodeContour:

List of all members.

Public Member Functions
	NodeContour ()
	NodeContour (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	Constructor.
	~NodeContour ()
	Destructor.
virtual Node *	SimpleCopy ()
	This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes.
void	CopyNodeContents (NodeContour *pNewNode)
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
virtual DocRect	GetBoundingRect (BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE)
	Get the bounding rect of this node.
virtual DocRect	GetBlobBoundingRect ()
	Get the blob bounding rect of this node.
virtual void	RenderTinyBlobs (RenderRegion *pRegion)
	This function is the base class version of a blob rendering function, so it actually does nothing. Tiny blobs are displayed by each of the objects that is selected when in bounded region selection mode. Typically a Tiny Blob should be a single small blob.
virtual void	Render (RenderRegion *pRender)
	Renders this node.
virtual BOOL	DoBecomeA (BecomeA *pBecomeA)
	Turns this node into another node of a particular type.
virtual BOOL	CanBecomeA (BecomeA *pBecomeA)
	Can this node turn itself into a node of a particular type ?
virtual BOOL	NeedsParent (Node *pClassNode) const
	Does this node need its parent ?
virtual NodeCompound *	GetParentController () const
virtual String	Describe (BOOL Plural, BOOL Verbose)
	Gets the string descriptor for this object.
virtual BOOL	IsAContour () const
BOOL	GenerateContour (List *pList=NULL, CCAttrMap *pAttrMap=NULL)
void	DeleteCache ()
void	Transform (TransformBase &Trans)
	Base class transform function.
void	RenderEorDrag (RenderRegion *pRender)
	Each class derived from NodeRenderableInk should write a version of this member function. In most cases it will be the same as the Render() member function but some of the nodes (such as groups) need to perform special actions. The function is for drawing the object while it is being dragged about by the selector tool. It should do this with an effective wysiwyg level of 0 so that the drawing is fast.
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes out a record that represents the node.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
virtual BOOL	AllowOp (ObjChangeParam *pParam, BOOL SetOpPermissionState=TRUE, BOOL DoPreTriggerEdit=TRUE)
	This is the way to ask a node if you can do an op to it.
virtual BOOL	IsTypeExtendible () const
virtual DocRect	ValidateExtend (const ExtendParams &ExtParams)
	Tests the reversibility of an Extend operation applied to this node.
virtual void	Extend (const ExtendParams &ExtParams)
	Perform an Extend operation on this Node, and its children if appropriate. Default implementation just calls Extend() on its children.
virtual BOOL	OnNodePopUp (Spread *pSpread, DocCoord PointerPos, ContextMenu *pMenu)
	Allows the Node to respond to popup menu clicks by adding items to the popup menu if required. It also allows the node to prevent the menu appearing at all! 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 blobs.
virtual INT32	EstimateNodeComplexity (OpParam *details)
Static Public Member Functions
static BOOL	SmoothPath (Path *pPath)
static BOOL	GenerateContourPathForNode (Path *pDestPath, Node *pSourceNode, const List *pSourceList, const MILLIPOINT nWidth, const BOOL fOuterContour=TRUE, const JointType jt=RoundJoin, const MILLIPOINT nFlatness=-1, const BOOL fUseLineWidths=TRUE, const BOOL fIncludeShadows=FALSE)
	Generate a contour for the given node or list of paths + attrs.Generates the contour paths in this nodeDeletes all the pathsTransforms me & all my pathsRenders my eor drag stuffWrites the node to a fileWrites the node to a fileWrites the node to a fileSort of backwards copy constructorPolymorphically copies the contents of this node to another Blends all the attributes to this particular position,Does the allow op mechanismRenders the tiny blobs for this objectReturns a type correct pointer to the parent Contour controllerTests the reversibility of an Extend operation applied to this node.Perform an Extend operation on this Node, and its children if appropriate.Allows the shadow to respond to the clickSums all node paths' paths together into one pathThis function estimates a complexity value for the node. The complexity value is based upon the total length of all paths in the node.
Protected Member Functions
BOOL	BlendAttributes (RenderRegion *pRender, CCAttrMap *pAttrMapStart, CCAttrMap *pEndAttrMap, CCAttrMap *pBlendedAttrMap, double BlendRatio)
BOOL	CopyAttributes (NodeRenderableInk *pNode, CCAttrMap *pAttrMap)
	Copies all the attributes in the attribute map onto the given node.
BOOL	SmoothPaths ()
NodeRenderableInk *	FindNodeToContour (NodeRenderableInk *pInk)
	Does a depth first seach to find a node to take the attribute map from when blending.
Protected Attributes
Path	m_SourcePath
Path *	m_pPathList
INT32	m_NumPaths
BOOL	m_FirstRender
Private Member Functions
	CC_DECLARE_DYNCREATE (NodeContour)

---

Detailed Description

Contour node.

Author:

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

Date:

12/8/99

Definition at line 121 of file nodecntr.h.

---

Constructor & Destructor Documentation

NodeContour::NodeContour (   )

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

Constructor. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Definition at line 190 of file nodecntr.cpp. { m_pPathList = NULL; m_NumPaths = 0; m_SourcePath.Initialise(); IsBoundingRectValid = FALSE; m_FirstRender = TRUE; }

NodeContour::~NodeContour (   )

Destructor. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Definition at line 215 of file nodecntr.cpp. { if (m_pPathList) { delete [] m_pPathList; m_pPathList = NULL; } }

---

Member Function Documentation

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

This is the way to ask a node if you can do an op to it. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> 19/01/2000 Date: 3/02/95 Parameters: pParam  = describes the way an op wants to change the node [INPUTS] SetOpPermissionState = if TRUE the Op permission state of this node will be set according to the outcome of the call 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. -  [OUTPUTS] Returns: TRUE means the node and all its parents are happy with this op, FALSE means don't do it The ObjChangeParam class contains flags that describe how it will change the node For example, the op could change the node's appearence (e.g. attr application, editing a path), replace the node with another node (e.g. because it uses hidden nodes to hide the original and put another node in its place, or "make shapes"), delete the node (e.g. the delete and cut ops), etc. This function gives the node a chance to say NO. It also gives the parents a chance to say no too. E.g. a blend node will allow itself to be deleted, but it will NOT allow a child of itself to be deleted). This call should only be made on selected, or parents of selected, nodes. It makes a decision as a straight node if it is selected. It makes a decision as a parent if it has selected children. E.g. NodeBlend::AllowOp(...op delete...) if the node is selected, then it will return TRUE (parents permitting), i.e. I can be deleted if the node is a parent of selected it will return FALSE (i.e. can't delete children of blends). So when the node is selected, you are asking the node if you can do the op to it. When the node is a parent of a selected node, you are asking if you can do the op to one of its children. If the 'SetOpPermissionState' param is TRUE, the following indented lines applies: The node's op permission state is set according to the result of this function. If TRUE is returned, then the node's op permission state will be left unchanged. AND the parent's op permission state will be set to PERMISSION_ALLOWED if FALSE is returned, then the node's op permission state will be PERMISSION_DENIED, AND all it's parents (up to the layer) will be set to PERMISSION_DENIED Also, all parents of this node are called via their AllowOp() func with the same state as this node. This means that after this call, you can guarantee that all of its parents will have either a PERMISSION_DENIED or PERMISSION_ALLOWED state. Note: Even if this node tries to set all it's parents to have a PERMISSION_DENIED state, if any of its parents have previously been set to PERMISSION_ALLOWED they will remain in that state (see SetOpPermission()). Why? Well, it is possible for a parent node to have one child with a PERMISSION_DENIED and another child with a PERMISSION_ALLOWED. It this state the parent MUST be in state PERMISSION_ALLOWED, because at least one of its children will allow the op to happen to it. So, after this call: The op permission state for this node will be either left unchanged (and therefore remain PERMISSION_UNDEFINED), or PERMISSION_DENIED. The parent's op permission state will be either PERMISSION_ALLOWED, or PERMISSION_DENIED. This is so UndoableOperation::UpdateChangedNodes() will only call OnChildChange() on parent nodes, because it only calls that func for nodes that have an op permission state of PERMISSION_ALLOWED. See also: GetOpPermission(),SetOpPermission(); Reimplemented from Node.

BOOL NodeContour::BlendAttributes (  RenderRegion *  pRender, CCAttrMap *  pAttrMapStart, CCAttrMap *  pEndAttrMap, CCAttrMap *  pBlendedAttrMap, double  BlendRatio )  [protected]

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

Can this node turn itself into a node of a particular type ? Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Reimplemented from Node. Definition at line 1071 of file nodecntr.cpp. { if (pBecomeA->BAPath()) { if (pBecomeA->IsCounting()) { NodeContourController * pControl = (NodeContourController *)FindParent(); if (pControl->GetInsetPathFlag()) { pBecomeA->AddCount(1); } else { pBecomeA->AddCount(pControl->GetNumberOfSteps()); } } return TRUE; } return FALSE; }

NodeContour::CC_DECLARE_DYNCREATE (  NodeContour   )  [private]

BOOL NodeContour::CopyAttributes (  NodeRenderableInk *  pNode, CCAttrMap *  pAttrMap )  [protected]

Copies all the attributes in the attribute map onto the given node. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Definition at line 1020 of file nodecntr.cpp. { ERROR2IF(pNode == NULL, FALSE, "Node is null"); ERROR2IF(pAttrMap == NULL, FALSE, "Attribute map is null"); CCAttrMap::iterator end = pAttrMap->GetEndPosition(); CCAttrMap::iterator PosStart = pAttrMap->GetStartPosition(); while( PosStart != end ) { CCRuntimeClass *pTypeStart = NULL; void *pValStart = NULL; pAttrMap->GetNextAssoc( PosStart, pTypeStart, pValStart ); NodeAttribute* pNodeAttr = (NodeAttribute *)pValStart; // copy the attribute onto the node if (pNodeAttr) { if (pNodeAttr->CanBeAppliedToObject()) { if (!pNodeAttr->CopyNode(pNode, FIRSTCHILD)) { ERROR3("Copy node failed"); return FALSE; } } } } return TRUE; }

void NodeContour::CopyNodeContents (  NodeContour *  pNewNode  )

void NodeContour::DeleteCache (   )

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

Gets the string descriptor for this object. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Reimplemented from Node. Definition at line 1126 of file nodecntr.cpp. { String Name; Name.Load(_R(IDS_CONTOUR_NODE_NAME)); if (Plural) { Name += _T("s"); } return Name; }

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

Turns this node into another node of a particular type. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Reimplemented from Node. Definition at line 696 of file nodecntr.cpp. { // Check for a NULL entry param ERROR2IF_PF(pBecomeA == NULL,FALSE,("pBecomeA is NULL")); if (!pBecomeA->BAPath()) { return FALSE; } BOOL ValidReason = (pBecomeA->GetReason() == BECOMEA_REPLACE || pBecomeA->GetReason() == BECOMEA_PASSBACK); ERROR2IF_PF(!ValidReason,FALSE,("Unkown BecomeA reason %d",pBecomeA->GetReason())); UndoableOperation* pOp = pBecomeA->GetUndoOp(); double StepSize = 0; double Ratio = 0; NodeContourController * pController = (NodeContourController *)FindParent(); if (!pController) { ERROR3("No contour controller for become a"); return FALSE; } INT32 Width = pController->GetWidth(); // Node * pContourBegin = NULL; BOOL bPassback = FALSE; if (pBecomeA->GetReason() == BECOMEA_PASSBACK) bPassback = TRUE; // CCAttrMap * pTmpMap = NULL; // turn each path into a node path with the appropriate attributes if (m_pPathList != NULL && m_NumPaths > 0) { // do the blended attributes map CCAttrMap BlendAttrMap(30); // build the attribute maps for the start & end nodes NodeRenderableInk * pEndNode = NULL; if (pController->GetWidth() > 0) { pEndNode = (NodeRenderableInk *)FindPrevious(CC_RUNTIME_CLASS(NodeRenderableInk)); } else { pEndNode = (NodeRenderableInk *)FindNext(CC_RUNTIME_CLASS(NodeRenderableInk)); } if (!pEndNode) { ERROR3("No node present to contour"); return FALSE; } // CGS: need to check whether pEndNode is compound - and if it is, do some extra stuff if (pEndNode->IsCompound()) { pEndNode = FindNodeToContour(pEndNode); } if (pEndNode->IS_KIND_OF(NodeBlend)) { pEndNode = (NodeRenderableInk *)pEndNode->FindFirstChild(CC_RUNTIME_CLASS(NodeRenderableInk)); } // do the blend of the attributes CCAttrMap * pAttrMapStart = CCAttrMap::MakeAppliedAttrMap(this); CCAttrMap * pAttrMapEnd = CCAttrMap::MakeAppliedAttrMap(pEndNode); ERROR3IF (pAttrMapStart == NULL, "pAttrMapStart is NULL!"); ERROR3IF (pAttrMapEnd == NULL, "pAttrMapEnd is NULL!"); StepSize = 1.0 / ((double)(m_NumPaths)); NodePath* pPath = NULL; Node* pInsertContext = this; // For DoBecomeA we must return the paths in the order in which they will be placed // in the tree and rendered // For Outer contours that means: end node, steps, original node // For Inner contours that means: original node, steps, end node // if (Width < 0) { // outer contour ! // // End node first INT32 i = m_NumPaths-1; if (pOp) { ALLOC_WITH_FAIL(pPath, new NodePath, pOp); } else { pPath = new NodePath; ERRORIF(pPath == NULL, _R(IDE_NOMORE_MEMORY), FALSE); } pPath->InkPath.Initialise(); pPath->InkPath.CloneFrom(m_pPathList[i]); pPath->InkPath.IsFilled = TRUE; pPath->InkPath.InitialiseFlags(0, pPath->InkPath.GetNumCoords()); // insert the node if (!bPassback) { pPath->ApplyAttributes(pAttrMapStart, TRUE); if (pOp) pOp->DoInsertNewNode(pPath, pInsertContext, NEXT, TRUE, FALSE, TRUE, TRUE); else { pPath->AttachNode(pInsertContext, NEXT, FALSE, FALSE); pPath->NormaliseAttributes(); } pInsertContext = pPath; pPath->SetSelected(TRUE); pBecomeA->PassBack(pPath, this, pAttrMapStart->Copy()); } else { pBecomeA->PassBack(pPath, this, pAttrMapStart->Copy()); } // Now all the steps for (i = m_NumPaths-2; i>=0; i--) { // blend the attributes at this point Ratio = (StepSize * ((double)i)) + StepSize; // calculate the correct ratio given the profile for attributes CProfileBiasGain Profile = pController->GetAttrProfile(); Profile.SetBias(-Profile.GetBias()); Ratio = (double)Profile.MapZeroToOne((AFp)Ratio); Ratio = 1.0 - Ratio; if (!BlendAttributes(NULL, pAttrMapStart, pAttrMapEnd, &BlendAttrMap, Ratio)) { ERROR3("Blend attributes failed"); return FALSE; } if (pOp) { ALLOC_WITH_FAIL(pPath, new NodePath, pOp); } else { pPath = new NodePath; ERRORIF(pPath == NULL, _R(IDE_NOMORE_MEMORY), FALSE); } pPath->InkPath.Initialise(); pPath->InkPath.CloneFrom(m_pPathList[i]); pPath->InkPath.IsFilled = TRUE; pPath->InkPath.InitialiseFlags(0, pPath->InkPath.GetNumCoords()); // insert the node if (!bPassback) { // copy the blended attributes to the new node // CopyAttributes(pPath, &BlendAttrMap); pPath->ApplyAttributes(&BlendAttrMap, TRUE); if (pOp) pOp->DoInsertNewNode(pPath, pInsertContext, NEXT, TRUE, FALSE, TRUE, TRUE); else { pPath->AttachNode(pInsertContext, NEXT, FALSE, FALSE); pPath->NormaliseAttributes(); } pInsertContext = pPath; pPath->SetSelected(TRUE); pBecomeA->PassBack(pPath, this, BlendAttrMap.Copy()); } else { pBecomeA->PassBack(pPath, this, BlendAttrMap.Copy()); } } } else { // inner contour ! INT32 i = 0; for (i = m_NumPaths-1; i!=0 ; i--) { // Check if the path has any points before outputing it // This stops degenerate paths being added to the document // which will cause errors in the saving code Path* pStepPath = &(m_pPathList[(m_NumPaths - 1) - i]); if (pStepPath && pStepPath->GetNumCoords() > 0) { // calculate the correct ratio given the profile for attributes Ratio = (StepSize * ((double)i)); // calculate the correct ratio given the profile for attributes CProfileBiasGain Profile = pController->GetAttrProfile(); Profile.SetBias(-Profile.GetBias()); Ratio = (double)Profile.MapZeroToOne((AFp)Ratio); if (!BlendAttributes(NULL, pAttrMapStart, pAttrMapEnd, &BlendAttrMap, Ratio)) { ERROR3("Blend attributes failed"); return FALSE; } pPath = new NodePath; pPath->InkPath.Initialise(); pPath->InkPath.CloneFrom(*pStepPath); pPath->InkPath.IsFilled = TRUE; pPath->InkPath.InitialiseFlags(0, pPath->InkPath.GetNumCoords()); if (!bPassback) { pPath->ApplyAttributes(&BlendAttrMap, TRUE); if (pOp) pOp->DoInsertNewNode(pPath, pInsertContext, NEXT, TRUE, FALSE, TRUE, TRUE); else { pPath->AttachNode(pInsertContext, NEXT, FALSE, FALSE); pPath->NormaliseAttributes(); } pInsertContext = pPath; pBecomeA->PassBack(pPath, pPath, BlendAttrMap.Copy()); } else { pBecomeA->PassBack(pPath, pPath, BlendAttrMap.Copy()); } } } // Finally, the end node Path* pStepPath = &(m_pPathList[m_NumPaths - 1]); if (pStepPath && pStepPath->GetNumCoords() > 0) { pPath = new NodePath; pPath->InkPath.Initialise(); pPath->InkPath.CloneFrom(*pStepPath); pPath->InkPath.IsFilled = TRUE; pPath->InkPath.InitialiseFlags(0, pPath->InkPath.GetNumCoords()); // insert the node if (!bPassback) { // CopyAttributes(pPath, pAttrMapStart); pPath->ApplyAttributes(pAttrMapStart, TRUE); if (pOp) pOp->DoInsertNewNode(pPath, pInsertContext, NEXT, TRUE, FALSE, TRUE, TRUE); else { pPath->AttachNode(pInsertContext, NEXT, FALSE, FALSE); pPath->NormaliseAttributes(); } pInsertContext = pPath; pBecomeA->PassBack(pPath, pPath, pAttrMapStart->Copy()); } else { pBecomeA->PassBack(pPath, pPath, pAttrMapStart->Copy()); } } } BlendAttrMap.DeleteAttributes(); delete pAttrMapStart; delete pAttrMapEnd; // hide the contour begin node if (!bPassback) { if (pOp) { NodeHidden * pHidden = NULL; pOp->DoHideNode(this, TRUE, &pHidden, TRUE); } else { CascadeDelete(); delete this; // Scary! } } return TRUE; } return FALSE; }

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

Reimplemented from Node.

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

Perform an Extend operation on this Node, and its children if appropriate. Default implementation just calls Extend() on its children. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 26/11/1999 Parameters: ExtParams  description parameters for the extension. [INPUTS] This  node and some of its children may have their dimensions altered. [OUTPUTS] Returns: Errors: See also: Reimplemented from Node.

NodeRenderableInk * NodeContour::FindNodeToContour (  NodeRenderableInk *  pInk  )  [protected]

Does a depth first seach to find a node to take the attribute map from when blending. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 10/3/2000 Parameters: The  node to start searching from [INPUTS] Definition at line 651 of file nodecntr.cpp. { if (!pInk->IsCompound()) return pInk; Node * pNodeStep = pInk->FindFirstDepthFirst(); AttrFillGeometry * pFill = NULL; while (pNodeStep && pNodeStep != pInk) { if (pNodeStep->IsAnObject()) { if (!pNodeStep->NeedsParent(NULL)) { // does this have a fill attribute ? if (((NodeRenderableInk *)pNodeStep)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry), (NodeAttribute **)(&pFill))) { // let's check this to see if there's a colour on the node or not if (pFill->GetStartColour()) { if (!pFill->GetStartColour()->IsTransparent()) return (NodeRenderableInk *)pNodeStep; } } } } pNodeStep = pNodeStep->FindNextDepthFirst(pInk); } return pInk; }

BOOL NodeContour::GenerateContour (  List *  pList = NULL, CCAttrMap *  pAttrMap = NULL )

BOOL NodeContour::GenerateContourPathForNode (  Path *  pDestPath, Node *  pSourceNode, const List *  pSourceList, const MILLIPOINT  nWidth, const BOOL  fOuterContour = TRUE, const JointType  jt = RoundJoin, const MILLIPOINT  nFlatness = -1, const BOOL  fUseLineWidths = TRUE, const BOOL  fIncludeShadows = FALSE )  [static]

Generate a contour for the given node or list of paths + attrs.Generates the contour paths in this nodeDeletes all the pathsTransforms me & all my pathsRenders my eor drag stuffWrites the node to a fileWrites the node to a fileWrites the node to a fileSort of backwards copy constructorPolymorphically copies the contents of this node to another Blends all the attributes to this particular position,Does the allow op mechanismRenders the tiny blobs for this objectReturns a type correct pointer to the parent Contour controllerTests the reversibility of an Extend operation applied to this node.Perform an Extend operation on this Node, and its children if appropriate.Allows the shadow to respond to the clickSums all node paths' paths together into one pathThis function estimates a complexity value for the node. The complexity value is based upon the total length of all paths in the node. Parameters: pDestPath  ptr to a Path, which will receive the contoured result. [INPUTS] pSourceNode ptr to a node to contour. pSourceList ptr to a list of paths + attrs to contour. nWidth the width of the required contour, in millipoints. fOuterContour TRUE => do an outer contour; FALSE => do an inner contour. jt the required join type. nFlatness the flatness to use, in millipoints. if <= 0, then this routine will use a default value which takes into account the current view's zoom factor. If there is no current view, then a default value of 200 will be used. fUseLineWidths whether or not to include line width attributes. fIncludeShadows whether or not to include the outlines of shadows in our calculations; required by feathering. if  successful, pDestPath is filled with the required contour path. [OUTPUTS] Returns: TRUE if successful, FALSE otherwise. Errors: ERROR2 if pDestPath is NULL or both pSourceNode and pSourceList are NULL. Notes: Karim 18/11/2000 Major rewrite - previously this method used ContourBecomeA. We no longer rely on that procedure, but use PathBecomeA instead, and contour the result. See Camelot2000 SourceSafe db for changes. See also: / return fSuccess; } /*! Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 18/8/99 Parameters: If  we're blending we pass in the path processor's list [INPUTS] < --------------- < ---------------- Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: [INPUTS]  Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: [INPUTS]  Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: [INPUTS]  Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/2004 Parameters: -  [INPUTS] Returns: 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 Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: Render  region to blend the attributes with, and the ratio (i.e. the [INPUTS] position of the blend 0 <= BlendRatio <= 1.0 Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com>; Karim 12/01/2000 Date: 12/8/99 Parameters: pParam  describes the way an op wants to change the node [INPUTS] SetOpPermissionState if TRUE the OpPermission of nodes should be set DoPreTriggerEdit if TRUE then NameGallery::PreTriggerEdit is called. Must* be TRUE if the calling Op may make any nodes change their bounds, eg move, line width, cut. Use TRUE if unsure. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: Render  region to render the tiny blobs to [INPUTS] Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/1999 Returns: Pointer to parent Contour controller (NULL if not found!) Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/1999 Parameters: ExtParams  description parameters for the extension. [INPUTS] [OUTPUTS]  Returns: TRUE if extending this Nodewill be a reversible operation, FALSE otherwise. A NodeContour cannot itself extend, so instead it asks its parent controller to extend for it. Infinite recursion does not occur, as the controller node ignores its child node, this NodeContour. Returns: Errors: In debug builds, ERROR3 if this Node has no NodeContourController, in release, we return TRUE. See also: IsTypeExtendible(), Extend(). Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/1999 Parameters: ExtParams  description parameters for the extension. [INPUTS] Some  of the child nodes of this ContourNode's NodeContourController may have [OUTPUTS] their dimensions altered. Returns: A NodeContour cannot itself extend, so instead it asks its parent controller to extend for it. Infinite recursion does not occur, as the controller node ignores its child node, this NodeContour. Returns: Errors: In debug builds, ERROR3 if this Node has no NodeContourController, in release, we do nothing. See also: Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 7/2/2000 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 Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] 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 () Definition at line 1184 of file nodecntr.cpp.

DocRect NodeContour::GetBlobBoundingRect (   )  [virtual]

Get the blob bounding rect of this node. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Reimplemented from NodeRenderable. Definition at line 379 of file nodecntr.cpp. { DocRect dr = GetBoundingRect(FALSE, FALSE); BlobManager * pMgr = GetApplication()->GetBlobManager(); INT32 Size = 0; if (pMgr) Size = pMgr->GetBlobSize(); dr.lo.x -= Size*2; dr.lo.y -= Size*2; dr.hi.x += Size*2; dr.hi.y += Size*2; IncludeChildrensBoundingRects(&dr); return dr; }

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

Get the bounding rect of this node. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Reimplemented from NodeRenderableBounded. Definition at line 234 of file nodecntr.cpp. { // sum all the bounding rects & then add the width if (!(!IsBoundingRectValid || DontUseAttrs)) { return BoundingRectangle; } DocRect dr; NodeContourController * pController = (NodeContourController *)FindParent(); if (!pController) return DocRect(0,0,0,0); INT32 Width = pController->GetWidth(); Node * pNode = FindParent(); if (!pNode) return BoundingRectangle; pNode = pNode->FindFirstChild(); while (pNode) { if (pNode->IsAnObject() && pNode!=this) { if (!IsBoundingRectValid) { ((NodeRenderableInk *)pNode)->InvalidateBoundingRect(); } dr = dr.Union(((NodeRenderableInk *)pNode)->GetBoundingRect(TRUE, HitTest)); } pNode = pNode->FindNext(); } if (Width < 0) { dr.lo.x += Width; dr.lo.y += Width; dr.hi.x -= Width; dr.hi.y -= Width; } DocRect PathRect; // include all the paths in the bounding rect for (INT32 i = 0 ; i < m_NumPaths && m_pPathList; i++) { PathRect = m_pPathList[i].GetBoundingRect(); if (PathRect.IsValid() && !PathRect.IsEmpty()) { dr = dr.Union(PathRect); } } // take the bounding rect from the paths, if they're present if (Width < 0) { if (m_NumPaths != 0) { dr = (m_pPathList[m_NumPaths-1].GetBoundingRect()); } } else { if (m_NumPaths != 0) { dr = (m_pPathList[0].GetBoundingRect()); } } if (!dr.IsValid() || dr.IsEmpty()) { dr = ((NodeCompound *)FindParent())->GetInsideBoundingRect(); // find the centre point DocCoord Centre = dr.Centre(); dr.lo.x = Centre.x - 5; dr.hi.x = Centre.x + 5; dr.lo.y = Centre.y - 5; dr.hi.y = Centre.y + 5; } // find out the line width and adjust the bounding rectangle appropriately AttrLineWidth * pAttr = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrLineWidth), (NodeAttribute **)(&pAttr)); AttrStrokeTransp * pStrokeAttr = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeTransp), (NodeAttribute **)(&pStrokeAttr)); AttrStrokeColour * pStrokeColour = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), (NodeAttribute **)(&pStrokeColour)); BOOL bTransparent = FALSE; if (pStrokeAttr) { if (pStrokeAttr->Value.Transp == 255) { bTransparent = TRUE; } } if (pStrokeColour) { if (pStrokeColour->Value.Colour == DocColour(COLOUR_NONE)) { bTransparent = TRUE; } } if (pAttr && !bTransparent) { MILLIPOINT LineWidth = pAttr->Value.LineWidth / 2; dr.lo.x -= LineWidth; dr.lo.y -= LineWidth; dr.hi.x += LineWidth; dr.hi.y += LineWidth; } dr.Union(pController->GetInsideBoundingRect()); IsBoundingRectValid = TRUE; BoundingRectangle = dr; return dr; }

virtual NodeCompound* NodeContour::GetParentController (   )  const [virtual]

Reimplemented from Node.

virtual BOOL NodeContour::IsAContour (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 160 of file nodecntr.h. { return TRUE;}

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

Reimplemented from Node. Definition at line 179 of file nodecntr.h. { return TRUE; }

BOOL NodeContour::NeedsParent (  Node *  pClassNode  )  const [virtual]

Does this node need its parent ? Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Reimplemented from Node. Definition at line 1105 of file nodecntr.cpp. { if (!pClassNode) return TRUE; if (pClassNode->IsKindOf(CC_RUNTIME_CLASS(NodeContourController))) return TRUE; return FALSE; }

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

Allows the Node to respond to popup menu clicks by adding items to the popup menu if required. It also allows the node to prevent the menu appearing at all! 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 blobs. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/04/95 Parameters: pSpread  The spread in which the action's occuring [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.

virtual void NodeContour::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.

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

Renders this node. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/99 Parameters: See  base class [INPUTS] Reimplemented from Node. Definition at line 410 of file nodecntr.cpp. { double Ratio = 0; double StepSize = 0; NodeContourController * pControl = (NodeContourController *)FindParent(); // check we have something to render ! if (pControl) { pControl->DisableInsetPathPathProcessor(); if (pControl->GetInsideBoundingRect().IsEmpty()) return; } else return; if(m_FirstRender) { GenerateContour(); m_FirstRender = FALSE; } // get the first path processor ContourNodePathProcessor * pProc = (ContourNodePathProcessor *)pRender->GetFirstPathProcessor(); if (pProc) { if (!((PathProcessor *)pProc)->IS_KIND_OF(ContourNodePathProcessor)) pProc = NULL; } // do we have anything to render ?? if (m_NumPaths == 0) return; pRender->SaveContext(); // find out the line width LineWidthAttribute * pLineWidth = (LineWidthAttribute *)pRender->GetCurrentAttribute(ATTR_LINEWIDTH); TRACEUSER( "DaivdM", _T("Contour node render 1\n")); MILLIPOINT LineWidth = 0; if (pLineWidth) LineWidth = pLineWidth->LineWidth; if (m_pPathList != NULL && m_NumPaths > 0) { // do the blended attributes map CCAttrMap BlendAttrMap(30); // build the attribute maps for the start & end nodes NodeRenderableInk * pEndNode = NULL; if (pControl->GetWidth() > 0) pEndNode = (NodeRenderableInk *)FindPrevious(CC_RUNTIME_CLASS(NodeRenderableInk)); else pEndNode = (NodeRenderableInk *)FindNext(CC_RUNTIME_CLASS(NodeRenderableInk)); if (!pEndNode) return; if (pEndNode->IsCompound()) pEndNode = FindNodeToContour(pEndNode); if (pEndNode->IS_KIND_OF(NodeBlend)) pEndNode = (NodeRenderableInk *)pEndNode->FindFirstChild(CC_RUNTIME_CLASS(NodeRenderableInk)); // do the blend of the attributes CCAttrMap * pAttrMapStart = CCAttrMap::MakeAttrMapFromRenderRegion(pRender); WindingRuleAttribute * pWinding = NULL; if(!pAttrMapStart) { ENSURE(FALSE,"Not enough mem to create start attr map for rendering NodeContour."); return; } CCAttrMap * pAttrMapEnd = CCAttrMap::MakeAppliedAttrMap(pEndNode); StepSize = 1.0 / m_NumPaths; for (INT32 i = m_NumPaths - 1; i >= 0; i--) { TRACEUSER( "Diccon", _T("Rendering contour path %d\n"), i); if (pControl->GetWidth() < 0) { // outer contour TRACEUSER( "DaivdM", _T("Contour node render %d\n"), i); if (i == m_NumPaths - 1) { if (pProc) pProc->SetActive(FALSE); pRender->DrawPath(&(m_pPathList[i])); } else { if (pProc) pProc->SetActive(TRUE); Ratio = (StepSize * i) + StepSize; // calculate the correct ratio given the profile for attributes CProfileBiasGain Profile = pControl->GetAttrProfile(); Profile.SetBias(-Profile.GetBias()); Ratio = (double)Profile.MapZeroToOne((AFp)Ratio); Ratio = 1.0 - Ratio; if (!BlendAttributes(pRender, pAttrMapStart, pAttrMapEnd, &BlendAttrMap, Ratio)) { ERROR3("Blend attributes failed"); // pop the path processor first pRender->PopPathProcessor(); return; } // Ilan 5/5/00 // Call the PostDynCreateInit functions for the attributes which require this // NB attrs which don't succeed in init'ing will mark themselves so that they don't NeedToRender() // ie the AttrMap can safely be rendered - the united attrs simply won't do their job BlendAttrMap.PostBlendInit(&(m_pPathList[i]), GetRuntimeClass()); pRender->SaveContext(); BlendAttrMap.Render(pRender); // Quality Max(Quality::QualityDefault); // QualityAttribute * pAttr = new QualityAttribute(Max); // pRender->SetQuality(pAttr, FALSE); PathProcessor* pPP = pRender->GetFirstPathProcessor(); if (pPP && pPP->IsAPathProcessorStroke()) pPP->SetDisabled(TRUE); pRender->DrawPath(&(m_pPathList[i])); if (pPP) pPP->SetDisabled(FALSE); pRender->RestoreContext(); // Ilan 5/5/00 // Deinitialise the attrs which allocated memory in the PostBlendInit() fn call BlendAttrMap.PostBlendDeinit(); } } else { if (pProc) pProc->SetActive(FALSE); Ratio = StepSize * i; // calculate the correct ratio given the profile for attributes CProfileBiasGain Profile = pControl->GetAttrProfile(); Profile.SetBias(-Profile.GetBias()); Ratio = (double)Profile.MapZeroToOne((AFp)Ratio); if (Ratio > 0 && Ratio < 1.0) { if (!BlendAttributes(pRender, pAttrMapStart, pAttrMapEnd, &BlendAttrMap, Ratio)) { ERROR3("Blend attributes failed"); // pop the path processor first pRender->PopPathProcessor(); return; } pRender->SaveContext(); // Ilan 5/5/00 // Call the PostDynCreateInit functions for the attributes which require this // NB attrs which don't succeed in init'ing will mark themselves so that they don't NeedToRender() // ie the AttrMap can safely be rendered - the united attrs simply won't do their job BlendAttrMap.PostBlendInit(&(m_pPathList[(m_NumPaths-1) - i]), GetRuntimeClass()); BlendAttrMap.Render(pRender); } else if (Ratio == 0) { pRender->SaveContext(); pAttrMapStart->Render(pRender); } else { pRender->SaveContext(); pAttrMapEnd->Render(pRender); } // set the winding rule pWinding = (WindingRuleAttribute *)pRender->GetCurrentAttribute(ATTR_WINDINGRULE); pWinding->WindingRule = NegativeWinding; pRender->DrawPath(&(m_pPathList[(m_NumPaths-1) - i])); pRender->RestoreContext(); if (Ratio > 0 && Ratio < 1.0) { // Ilan 5/5/00 // Deinitialise the attrs which allocated memory in the PostBlendInit() fn call BlendAttrMap.PostBlendDeinit(); } } } pAttrMapStart->DeleteAttributes(); delete pAttrMapStart; delete pAttrMapEnd; BlendAttrMap.DeleteAttributes(); } pRender->RestoreContext(); // pop the path processor if (pProc) pRender->PopPathProcessor(); pControl->EnableInsetPathPathProcessor(); }

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

Each class derived from NodeRenderableInk should write a version of this member function. In most cases it will be the same as the Render() member function but some of the nodes (such as groups) need to perform special actions. The function is for drawing the object while it is being dragged about by the selector tool. It should do this with an effective wysiwyg level of 0 so that the drawing is fast. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/93 Parameters: pRender  - A pointer to a render region to draw in [INPUTS] Reimplemented from NodeRenderableInk.

virtual void NodeContour::RenderTinyBlobs (  RenderRegion *  pRegion  )  [virtual]

This function is the base class version of a blob rendering function, so it actually does nothing. Tiny blobs are displayed by each of the objects that is selected when in bounded region selection mode. Typically a Tiny Blob should be a single small blob. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/94 Parameters: pRender  - The region to render the blobs into [INPUTS] See also: BlobManager Reimplemented from NodeRenderable.

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

This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/93 Returns: A copy of the node, or NULL if memory runs out Errors: If memory runs out when trying to copy, then ERROR is called with an out of memory error and the function returns NULL. Scope: protected Reimplemented from NodeRenderableInk.

static BOOL NodeContour::SmoothPath (  Path *  pPath  )  [static]

BOOL NodeContour::SmoothPaths (   )  [protected]

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

Base class transform function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/94 Parameters: Trans  - The transform [INPUTS] Reimplemented from NodeRenderableBounded.

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

Tests the reversibility of an Extend operation applied to this node. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 26/11/1999 Parameters: ExtParams  description parameters for the extension. [INPUTS] [OUTPUTS]  Returns: TRUE if extending this Node would be a valid operation, ie by passing appropriate inverse extend parameters, the Node could be un-extended back to its original state. FALSE if the operation would be irreversible. Note that where appropriate, this function asks the Node's children if they may validly extend, only returning TRUE if the extension is completely ok with everyone. Also note that if a node is of a non-extending type, it should normally consider itself a 'valid extender', as doing nothing is completely reversible (it should of course still check its children). Returns: Errors: See also: Node::IsTypeExtendible(), Node::Extend(). Reimplemented from Node.

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

Reimplemented from Node.

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

Writes out a record that represents the node. > virtual BOOL Node::WritePreChildrenWeb(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/96 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if the node has written out a record to the filter FALSE otherwise This function is called before any of the node's children are written to the filter. If the node writes out a record successfully to the file, it should return TRUE. If the node chooses not to write itself to the filter (e.g. because it is not appropriate for this filter), then this function should return FALSE. If an error occurs, the function should call pFilter->GotError(), and return FALSE. If the node does not want its child nodes to be written automatically, you should make sure you override CanWriteChildrenWeb() so it returns FALSE. (e.g. this node may choose to save its sub tree itself, so it can choose which of its child nodes should be saved out) See also: CanWriteChildrenWeb(), WritePostChildrenWeb() Reimplemented from Node.

---

Member Data Documentation

BOOL NodeContour::m_FirstRender [protected]

Definition at line 223 of file nodecntr.h.

INT32 NodeContour::m_NumPaths [protected]

Definition at line 221 of file nodecntr.h.

Path* NodeContour::m_pPathList [protected]

Definition at line 220 of file nodecntr.h.

Path NodeContour::m_SourcePath [protected]

Definition at line 217 of file nodecntr.h.

---

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

• Kernel/nodecntr.h (r1785/r1282)
• Kernel/nodecntr.cpp (r1785/r1361)

---