NodeMoulder Class Reference

defines the structure of a moulder object. The moulder exists only as a child of a mould object, controlling the production and manipulation of moulded versions of associated siblings. ie for each child (C) of a mould object, we create a moulder object (M). M controls the actual production and rendering of paths and bitmaps generated by C. More...

#include <nodemldr.h>

Inheritance diagram for NodeMoulder:

List of all members.

Public Member Functions
	NodeMoulder ()
	This constructor creates a NodeMoulder linked to no other with all status flags false and an uninitialized bounding rectangle. Note: Initialise() must be called before the NodeMoulder is in a state in which it can be used.
	~NodeMoulder ()
	Default destructor.
	NodeMoulder (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
BOOL	Initialise (NodeRenderableInk *ContextNode)
	Initialise a moulder object with information necessary for it to perform a mould.
virtual Node *	SimpleCopy ()
	Makes a copy of all the data in the node.
virtual UINT32	GetNodeSize () const
	For finding the size of the node.
virtual DocRect	GetBoundingRect (BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE)
	if the bounding rect is valid it is returned, if not, it is recalculated and then returned.
virtual DocRect	GetBlobBoundingRect ()
	Scan through the Mouldered paths finding bounding boxes of Mouldered objects.
DocRect	GetChildBBox (BOOL DontUseAttrs)
	Calculates the bounding rectangle of the children of a moulder object. It does this by scanning the child objects and merging each bounded child bbox together.
virtual void	PreExportRender (RenderRegion *pRender)
	Called before this node or any of its children have been rendered to the export region. This outputs the "start mould destin objects" command. Supports ArtWorks EPS and Camelot EPS.
virtual BOOL	ExportRender (RenderRegion *pRender)
	Called after this node and all of its children have been rendered to the export region. This outputs the "end mould destin objs" command. Supports ArtWorks EPS and Camelot EPS.
void	Render (RenderRegion *pRender)
	Will render the steps of this Moulder node.
virtual BOOL	NeedsToExport (RenderRegion *pRender, BOOL VisibleLayersOnly=FALSE, BOOL CheckSelected=FALSE)
	Snaps to given coord to the nearest point on the Moulder node. Just returns FALSE currently Virtual function - this version will return FALSE for exporting to native EPS documents. We dont need the moulded objects in these docs.
virtual BOOL	CanBecomeA (BecomeA *pBecomeA)
	This function is used by the convert to shapes operation. It determines if the node or any of its children can convert themselves into an InkClass object.
virtual BOOL	DoBecomeA (BecomeA *pBecomeA)
	Transforms the object into another type of object. This converts all its children, and replaces itself in the tree with a NodeGroup.
virtual BOOL	AllowOp (ObjChangeParam *pParam, BOOL SetOpPermissionState=TRUE, BOOL DoPreTriggerEdit=TRUE)
	Generic AllowOp() for all moulder nodes.
virtual BOOL	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	Allows the Node to respond to clicks by selecting its blobs or starting drags etc.
virtual String	Describe (BOOL Plural, BOOL Verbose)
	To return a description of the Moulder object in either the singular or the plural. This method is called by the DescribeRange method.
virtual void	Transform (TransformBase &)
	Transforms all the paths attached to this Moulder node.
void	GetDebugDetails (StringBase *Str)
	Displays debugging info of the tree For obtaining debug information about the Node.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
virtual ChangeCode	OnChildChange (ObjChangeParam *pParam)
	This function should be overridden in derived object classes. Composite objects can use this function to respond to one of their children undergoing a change. They should return CC_FAIL whenever they are unable to cope with the change.
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes out a records associated with this node.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
virtual BOOL	CanWriteChildrenWeb (BaseCamelotFilter *pFilter)
	This allows a node to stop the filter from writing out the child nodes automatically.
virtual BOOL	CanWriteChildrenNative (BaseCamelotFilter *pFilter)
virtual BOOL	IsValidEffectAttr (NodeAttribute *pAttr) const
	Get width of pixels for use in capturing this group as a tight group bitmapDetermine whether this type of attribute can be an effect attribute On this node at this time.Determine whether this attribute instance can be an effect attribute On this node at this time.
virtual BOOL	GroupCanTransformCached (TransformBase &Trans) const
NodeRenderableInk *	GetProvider ()
NodePath *	CreateMouldPath (NodePath *, MouldGeometry *, UndoableOperation *)
	Creates a new Node path object containing a moulded version of the path held within the source node path and returns a pointer to it. This can then be inserted somewhere in the tree.
NodeMouldBitmap *	CreateMouldBitmap (NodeBitmap *, MouldGeometry *, UndoableOperation *)
	Creates a NodeMouldBitmap object which is used during rendering to render normal bitmaps through the mould.
BOOL	CreateMouldedObjects (NodeMouldGroup *pGroup, MouldGeometry *, UndoableOperation *)
	Given a pointer to a moulder object, create all the moulded children using the source objects under the nodemouldgroup object.
BOOL	MouldAllChildren (Node *pNode, MouldGeometry *pGeometry, TransformBase &Trans, UndoableOperation *pOp)
	Given a pointer to a node, begin moulding it, all its children and all its forward siblings and their children.
BOOL	MouldPath (NodePath *, MouldGeometry *, UndoableOperation *)
	This function moulds the path contained within a NodPath to itself. It will use a temp path as a mould destination and copy this back over the source when successful.
BOOL	DestroyMouldedObjects ()
Private Member Functions
void	PreExportCAMEPS (RenderRegion *pRegion)
	Export delimiter tokens for this particular object. The format is defined as csmp path description cemp.
BOOL	PostExportCAMEPS (RenderRegion *pRegion)
void	PreExportAWEPS (RenderRegion *pRegion)
BOOL	PostExportAWEPS (RenderRegion *pRegion)
BOOL	CreateMouldObjsWithUndo (NodeMouldGroup *pGroup, MouldGeometry *, UndoableOperation *)
	Given a pointer to a moulder object, create all the moulded children using the source objects under the nodemouldgroup object.
BOOL	CreateMouldObjsWithoutUndo (NodeMouldGroup *pGroup, MouldGeometry *pGeometry)
	Given a pointer to a moulder object, create all the moulded children using the source objects under the nodemouldgroup object.
void	CopyNodeContents (NodeMoulder *pCopyOfNode)
	Copies the data in this node to pCopyOfNode by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected.
Private Attributes
NodeRenderableInk *	pProviderNode

---

Detailed Description

defines the structure of a moulder object. The moulder exists only as a child of a mould object, controlling the production and manipulation of moulded versions of associated siblings. ie for each child (C) of a mould object, we create a moulder object (M). M controls the actual production and rendering of paths and bitmaps generated by C.

Author:

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

Date:

1/12/94

See also:

Mould (the parent object)

Definition at line 134 of file nodemldr.h.

---

Constructor & Destructor Documentation

NodeMoulder::NodeMoulder (   )

This constructor creates a NodeMoulder linked to no other with all status flags false and an uninitialized bounding rectangle. Note: Initialise() must be called before the NodeMoulder is in a state in which it can be used. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 See also: Initialise() Definition at line 205 of file nodemldr.cpp. : NodeGroup() { pProviderNode = NULL; }

NodeMoulder::~NodeMoulder (   )

Default destructor. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Definition at line 221 of file nodemldr.cpp. { }

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

---

Member Function Documentation

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

Generic AllowOp() for all moulder nodes. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>; Karim 20/01/2000 Date: 30/6/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. Definition at line 1502 of file nodemldr.cpp. { ERROR2IF(pParam==NULL,FALSE,"Node::AllowOp() - pParam==NULL"); // if not called by a child AllowOp(), ensure AllowOp() called for all nodes in compound nodes, if (pParam->GetDirection()!=OBJCHANGE_CALLEDBYCHILD) { BOOL AnyAllowed=AllowOp_AccountForCompound( pParam, SetOpPermissionState, DoPreTriggerEdit ); // if called by a parent, just pass this result back if (pParam->GetDirection()==OBJCHANGE_CALLEDBYPARENT) return AnyAllowed; } else { // clean out the calling-child ptr, so it doesn't get passed around unintentionally. pParam->SetCallingChild(NULL); } // at this point we must have been called directly by the op or via a child AllowOp() // decide if we allow it, we dont allow very much at the moment, the only thing you can // actually do to children of a moulder is to copy them BOOL allowed=TRUE; ObjChangeFlags Flags=pParam->GetChangeFlags(); if ((pParam->GetDirection()==OBJCHANGE_CALLEDBYCHILD) || (pParam->GetDirection()==OBJCHANGE_CALLEDBYOP)) // if (Flags.DeleteNode || Flags.ReplaceNode || Flags.MoveNode || Flags.Attribute || Flags.MultiReplaceNode || Flags.TransformNode) { pParam->SetReasonForDenial(_R(IDS_MOULD_CANT_OP_ON_CHILDREN)); allowed=FALSE; } // if we allowed it, see if our parents do ... if (allowed && Parent!=NULL) { ObjChangeDirection OldDirection=pParam->GetDirection(); pParam->SetCallingChild(this); pParam->SetDirection(OBJCHANGE_CALLEDBYCHILD); allowed=Parent->AllowOp(pParam,SetOpPermissionState,DoPreTriggerEdit); pParam->SetDirection(OldDirection); } // if setting permisions ... if (SetOpPermissionState) { // if allowed, mark parent accordingly, else mark child as denied and update parents if (allowed) Parent->SetOpPermission(PERMISSION_ALLOWED); else SetOpPermission(PERMISSION_DENIED,TRUE); } // 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()) { if (NameGallery::Instance()) allowed = NameGallery::Instance()->PreTriggerEdit(pChangeOp, pParam, this); } } // return result (directly, or indirectly via a child AllowOp()) to op return allowed; }

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

This function is used by the convert to shapes operation. It determines if the node or any of its children can convert themselves into an InkClass object. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: InkClass,:  The class of object [INPUTS] pNumObjects = ptr to place number of objects of type pClass that will be created (Note: can be NULL). pNumObects in undefined on entry Returns: TRUE if the node, or any of its children can transmogrify themselves to become an InkClass object 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. Reimplemented from NodeCompound. Definition at line 1116 of file nodemldr.cpp. { // The NodeMoulder can become a NodePath if (pBecomeA->BAPath()) { if (pBecomeA->IsCounting()) { // Count the number of NodePaths that are children of this NodeMoulder Node* pNode = FindFirstChild(); while (pNode != NULL) { pNode->CanBecomeA(pBecomeA); // Increments count pNode = pNode->FindNext(); } } return TRUE; } return FALSE; }

BOOL NodeMoulder::CanWriteChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Reimplemented from Node. Definition at line 1647 of file nodemldr.cpp. { return CanWriteChildrenWeb(pFilter); }

BOOL NodeMoulder::CanWriteChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

This allows a node to stop the filter from writing out the child nodes automatically. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 18/7/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] Returns: TRUE if children can be written automatically, FALSE otherwise NodeMoulders do NOT save anything out in the current version of Camelot. Therefore, none of it's children can be saved out either. Reimplemented from Node. Definition at line 1640 of file nodemldr.cpp. { return FALSE; }

void NodeMoulder::CopyNodeContents (  NodeMoulder *  pCopyOfNode  )  [private]

Copies the data in this node to pCopyOfNode by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pCopyOfNode  - The node to copy data to [INPUTS] See also: NodeRenderableInk::CopyNodeContents Definition at line 827 of file nodemldr.cpp. { NodeRenderableInk::CopyNodeContents(pCopyOfNode); // Copy contents specific to derived class here }

NodeMouldBitmap * NodeMoulder::CreateMouldBitmap (  NodeBitmap *  pSourceNodeBlit, MouldGeometry *  pGeometry, UndoableOperation *  pOp )

Creates a NodeMouldBitmap object which is used during rendering to render normal bitmaps through the mould. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pSourceNodeBlit  = pointer to a node bitmap [INPUTS] pGeometry = pointer to a mould shape to use for moulding pOp = pointer to an active operation or NULL if none See also: - Notes: We've found a source bitmap so we need to do something about moulding it. We either mould to a destination bitmap or create a NodeMouldBitmap node, which uses the bitmap and renders through the current mould. Eek Algorithm (1) Create NodeMouldBitmap node (2) Add the source node type to it (3) Add the source node object pointer to it (4) return ok; The idea here is hopefully simple. Currently bitmaps get rendered in Camelot as fill attributes. That means what really gets rendered is a rectangular path, with a fill attribute set to the bitmap. We should attempt to simulate this but use one of our manifold paths instead. So when asked to render a NodeMouldBitmap object that we create here, the render function will simply take the original rectangle, mould it and render the result with a bitmap fill. I hope. Hmm, actually this may not be the best way. We need a MouldInk object but we cannot use a pointer to NodeBitmap due to the fact that we are in trouble if we copy the whole structure to another document. Definition at line 416 of file nodemldr.cpp. { ERROR2IF(pSourceNodeBlit==NULL, NULL, "CreateMouldBitmap() called with a null source pointer"); ERROR2IF(pGeometry==NULL, NULL, "CreateMouldBitmap() called with a null geometry pointer"); // ok we have the source node, so lets create a mould render object NodeMouldBitmap* pNodeMouldBitmap; ALLOC_WITH_FAIL( pNodeMouldBitmap, new NodeMouldBitmap, pOp); if (!pNodeMouldBitmap) return NULL; return pNodeMouldBitmap; }

BOOL NodeMoulder::CreateMouldedObjects (  NodeMouldGroup *  pGroup, MouldGeometry *  pGeometry, UndoableOperation *  pOp )

Given a pointer to a moulder object, create all the moulded children using the source objects under the nodemouldgroup object. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pGroup  = pointer to a node mould group object [INPUTS] pGeometry = pointer to a node path shape to use for moulding pOp = pointer to an active operation or NULL if none [OUTPUTS]  Returns: TRUE if all moulded objects have been created FALSE if unable to create some moulded objects Definition at line 479 of file nodemldr.cpp. { BOOL Success; if (pOp!=NULL) Success=CreateMouldObjsWithUndo(pGroup, pGeometry, pOp); else Success=CreateMouldObjsWithoutUndo(pGroup, pGeometry); return Success; }

BOOL NodeMoulder::CreateMouldObjsWithoutUndo (  NodeMouldGroup *  pGroup, MouldGeometry *  pGeometry )  [private]

Given a pointer to a moulder object, create all the moulded children using the source objects under the nodemouldgroup object. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pGroup  = pointer to a node mould group object [INPUTS] pGeometry = pointer to a node path shape to use for moulding [OUTPUTS]  Returns: TRUE if all moulded objects have been created FALSE if unable to create some moulded objects Definition at line 617 of file nodemldr.cpp. { ERROR2IF(pGroup==NULL, FALSE, "CreateMouldedObjects() called with a null group pointer"); ERROR2IF(pGeometry==NULL, FALSE, "CreateMouldedObjects() called with a null geometry pointer"); Node *pNode; // Stage1 // Copy the tree as shapes if (!pGroup->CopyChildrenAsShapes(this)) return FALSE; // Stage2 // Process all objects, moulding each object as we go pNode = FindFirstChild(); MouldTransform Transformer(pGeometry); if (!MouldAllChildren(pNode, pGeometry, Transformer, NULL)) return FALSE; // Stage 3 // Factor out those attributes! if (!FactorOutCommonChildAttributes(FALSE,NULL)) return FALSE; // Stage3 // Deselect all the naughty selected objects inside ourselves pNode = FindFirstChild(); while (pNode) { pNode->SetSelected(FALSE); pNode=pNode->FindNext(); } // Stage4, make sure we know our bounds will be updated. InvalidateBoundingRect(); return TRUE; }

BOOL NodeMoulder::CreateMouldObjsWithUndo (  NodeMouldGroup *  pGroup, MouldGeometry *  pGeometry, UndoableOperation *  pOp )  [private]

Given a pointer to a moulder object, create all the moulded children using the source objects under the nodemouldgroup object. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pGroup  = pointer to a node mould group object [INPUTS] pGeometry = pointer to a node path shape to use for moulding pOp = pointer to an active operation [OUTPUTS]  Returns: TRUE if all moulded objects have been created FALSE if unable to create some moulded objects Definition at line 511 of file nodemldr.cpp. { ERROR2IF(pGroup==NULL, FALSE, "CreateMouldedObjects() called with a null group pointer"); ERROR2IF(pGeometry==NULL, FALSE, "CreateMouldedObjects() called with a null geometry pointer"); Node *pNode, *qNode; // Stage 1 // Copy all objects from the mould group to this new moulder object pNode = pGroup->FindFirstChild(); while (pNode) { if (!IS_A(pNode,NodeHidden)) { if (!pNode->CopyNode(this,LASTCHILD)) { CascadeDelete(); return FALSE; } } pNode=pNode->FindNext(); } // Localise the current attributes. I do this because, although // most DoBecomeA() functions do their own localisation, bitmaps // see to apply AttrStrokeColour attributes to Pathified bitmaps // without localisation. This causes things like ConvertToShapes // produce MakeAttributeComplete found duplicate attr errors. if (!pOp->DoLocaliseCommonAttributes(this)) return FALSE; // Stage 2 // Get all objects to become paths or nodemouldbitmaps // Set up a BecomeA derived object, so that we can get everyone to become paths BecomeA ParamBecomeA(BECOMEA_REPLACE, CC_RUNTIME_CLASS(NodePath), pOp, FALSE); AttrStrokeType* pStroke = NULL; pNode = FindFirstChild(); while (pNode) { qNode = pNode->FindNext(); // bodge to deal with variable width strokes if (pNode->IsAnObject()) { ((NodeRenderableInk*)pNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeType), (NodeAttribute**)&pStroke); if (pStroke && pStroke->HasPathProcessor()) { if (!pStroke->DoBecomeA(&ParamBecomeA, (NodeRenderableInk*)pNode)) return FALSE; } else if (!pNode->DoBecomeA(&ParamBecomeA)) return FALSE; } pStroke = NULL; pNode=qNode; } // As we've localised lets factor up. Make sure we do the factoring NONE globally. // We don't want to confuse any attributes. if (!pOp->DoFactorOutCommonChildAttributes(this)) return FALSE; // Stage3 // Process all objects, moulding each object as we go pNode = FindFirstChild(); MouldTransform Transformer(pGeometry); if (!MouldAllChildren(pNode, pGeometry, Transformer, pOp)) return FALSE; // Stage4 // Deselect all the naughty selected objects inside ourselves pNode = FindFirstChild(); while (pNode) { pNode->SetSelected(FALSE); pNode=pNode->FindNext(); } // Stage5, make sure we know our bounds will be updated. InvalidateBoundingRect(); return TRUE; }

NodePath * NodeMoulder::CreateMouldPath (  NodePath *  pSourceNodePath, MouldGeometry *  pGeometry, UndoableOperation *  pOp )

Creates a new Node path object containing a moulded version of the path held within the source node path and returns a pointer to it. This can then be inserted somewhere in the tree. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Inputs pSourceNodePath = pointer to a source node path object pGeometry = pointer to a mould shape pOp = pointer to an active operation or NULL if none Parameters: [OUTPUTS]  Returns: a pointer to a node path if successfull. NULL if failed to create the object Definition at line 294 of file nodemldr.cpp. { ERROR2IF(pSourceNodePath==NULL, NULL, "CreateMouldPath called with a null source pointer"); ERROR2IF(pGeometry==NULL, NULL, "CreateMouldPath called with a null geometry pointer"); BOOL ok; // ok we have the source node, so find the original path and mould it Path* pSourcePath = &(pSourceNodePath->InkPath); // create a node path receptor. NodePath* pDestinNodePath; ALLOC_WITH_FAIL( pDestinNodePath, new NodePath, pOp); if (!pDestinNodePath) return NULL; // allocate the node path some space CALL_WITH_FAIL((pDestinNodePath->SetUpPath(12,12)),pOp,ok); if (!ok) { delete pDestinNodePath; return NULL; } // create a destination path receptor for the mould Path* pDestinPath = &(pDestinNodePath->InkPath); CALL_WITH_FAIL((pGeometry->MouldPathToPath(pSourcePath, pDestinPath)),pOp,ok); if (!ok) { delete pDestinNodePath; return NULL; } // Set up the fill where necessary pDestinPath->IsFilled = pSourcePath->IsFilled; return pDestinNodePath; }

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

To return a description of the Moulder object in either the singular or the plural. This method is called by the DescribeRange method. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 5/12/94 Parameters: Plural,:  Flag indicating if the string description should be plural or [INPUTS] singular. -  [OUTPUTS] Retuns: Description of the moulder node The description will always begin with a lower case letter. Reimplemented from NodeGroup. Definition at line 265 of file nodemldr.cpp. { if (Plural) return(String(_R(IDS_MOULDER_DESCRP))); else return(String(_R(IDS_MOULDER_DESCRS))); };

BOOL NodeMoulder::DestroyMouldedObjects (   )

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the moulder children were all destroyed successfully FALSE, if failed. Definition at line 447 of file nodemldr.cpp. { // first need to add a record to the undo to rebuild the // moulded objects on a fail! Node* pChild = FindFirstChild(); if (pChild!=NULL) DeleteChildren(pChild); return TRUE; }

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

Transforms the object into another type of object. This converts all its children, and replaces itself in the tree with a NodeGroup. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 5/12/94 Parameters: pBecomeA  = ptr to a class that contains all the info needed to become a new [INPUTS] type of node. -  [OUTPUTS] Returns: TRUE if the object has been transformed, FALSE if we run out of memory Errors: - See also: Node::CanBecomeA Reimplemented from NodeCompound. Definition at line 1158 of file nodemldr.cpp. { // Check for a NULL entry param ERROR2IF_PF(pBecomeA == NULL,FALSE,("NodeMoulder::DoBecomeA() called with a NULL ptr")); switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE: { // If replacing the moulder with shapes, hide the moulder, create a group, and move all the children // so they become children of the new group node ERROR2IF(pBecomeA->GetUndoOp() == NULL,FALSE,"Trying to replace a NodeMoulder, but pUndoOp == NULL"); UndoableOperation* pUndoOp = pBecomeA->GetUndoOp(); BOOL ok; // If being repaced in the tree, deselect the node BOOL IsSelected=this->IsSelected(); SetSelected(FALSE); // Pass on this message to our child ink nodes first Node* pNode = FindFirstChild(); while (pNode != NULL) { Node* pThisNode = pNode; pNode = pNode->FindNext(); pThisNode->DoBecomeA(pBecomeA); } // Allocate a new NodeGroup node NodeGroup* pNodeGroup; ALLOC_WITH_FAIL(pNodeGroup, (new NodeGroup), pUndoOp); if (pNodeGroup == NULL) return FALSE; // Insert the NodeGroup where the NodeMoulder used to be if (!pUndoOp->DoInsertNewNode(pNodeGroup,this,NEXT,FALSE,FALSE,FALSE,FALSE)) return FALSE; // if we were selected the lets select our group if (IsSelected) { // Select the group if (!pUndoOp->DoSelectNode(pNodeGroup,FALSE)) return FALSE; } // localise common child attributes before moving objects! if (!pUndoOp->DoLocaliseCommonAttributes(this)) return FALSE; // Now move each node in turn. pNode = FindLastChild(); while (pNode != NULL) { // Find the next node to move before we shift up the children Node* pPrevNode = pNode->FindPrevious(); if (pNode->IsAnObject()) { CALL_WITH_FAIL(pUndoOp->DoMoveNode(pNode, pNodeGroup, FIRSTCHILD), pUndoOp, ok); if (!ok) return FALSE; } pNode = pPrevNode; } // factor up on the group. if (!pUndoOp->DoFactorOutCommonChildAttributes(pNodeGroup)) return FALSE; // Hide the moulder node NodeHidden* pNodeHidden; if (!pUndoOp->DoHideNode(this, FALSE, &pNodeHidden, FALSE)) return FALSE; // and finally remove any nasty perspective fills from the result NodeMould::RemovePerspectiveFills(pNodeGroup, pUndoOp); } break; case BECOMEA_PASSBACK: { // We have been called to becomea passback on the moulder. // We cannot allow paths to be put in the tree with perspective fills // in them so we must hide the fills and replace them with standard ones // We should not do this on the clipboard however as undo/redo fails and // pasting clipboard contents wont work after! Document* pOwner = (Document*)FindOwnerDoc(); if (pOwner == NULL || pOwner->IsNotAClipboard()) NodeMould::RemovePerspectiveFills(this, pBecomeA->GetUndoOp()); // Sequentially ask the children of the moulder to DoBecomeA // This is all that's required because the child objects are only passing back // the new node type, and NOT replacing themselves in the tree // This also ensures the receipient gets the list of paths in render order Node* pNode = FindFirstChild(); while (pNode != NULL) { if (!pNode->DoBecomeA(pBecomeA)) return FALSE; pNode = pNode->FindNext(); } } break; default: ERROR3_PF(("Unknown BecomeA reason %d",pBecomeA->GetReason())); break; } // If this is a Perspective Mould, then we need to ensure // that any perspective fills are removed, as it is // dangerous to allow the user to edit a shape containing // a perspectivised fill. return TRUE; }

BOOL NodeMoulder::ExportRender (  RenderRegion *  pRegion  )  [virtual]

Called after this node and all of its children have been rendered to the export region. This outputs the "end mould destin objs" command. Supports ArtWorks EPS and Camelot EPS. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 14/03/95 Parameters: pRegion  = ptr to the export render region to export to [INPUTS] [OUTPUTS]  Returns: TRUE if ok, FALSE if something went wrong Errors: Reimplemented from NodeGroup. Definition at line 1404 of file nodemldr.cpp. { #ifdef DO_EXPORT if (pRegion->IS_KIND_OF(CamelotEPSRenderRegion)) return PostExportCAMEPS(pRegion); if (pRegion->IS_KIND_OF(ArtWorksEPSRenderRegion)) return PostExportAWEPS(pRegion); #endif return FALSE; }

DocRect NodeMoulder::GetBlobBoundingRect (   )  [virtual]

Scan through the Mouldered paths finding bounding boxes of Mouldered objects. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Returns: DocRect - Returns the bounding rect of the Moulder node and its blobs Reimplemented from NodeGroup. Definition at line 1042 of file nodemldr.cpp. { return (GetBoundingRect()); }

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

if the bounding rect is valid it is returned, if not, it is recalculated and then returned. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: DontUseAttrs  - TRUE if we should ignore the nodes attributes. [INPUTS] Defaults to FALSE HitTest - TRUE if being called during HitTest Returns: The nodes bounding rect See also: NodeMoulder::GetBlobBoundingRect Reimplemented from NodeGroup. Definition at line 977 of file nodemldr.cpp. { if (!IsBoundingRectValid || DontUseAttrs) { DocRect NewRect = GetChildBBox(DontUseAttrs); // just return this rectangle as it is not the nodes true bounding rect if (DontUseAttrs) return NewRect; // copy the new docrect into the node bounding rect BoundingRectangle = NewRect; IsBoundingRectValid = TRUE; } // Return the resulting bounding rect return BoundingRectangle; }

DocRect NodeMoulder::GetChildBBox (  BOOL  DontUseAttrs  )

Calculates the bounding rectangle of the children of a moulder object. It does this by scanning the child objects and merging each bounded child bbox together. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 6/12/94 Parameters: DontUseAttrs  - TRUE if we should ignore the nodes attributes. [INPUTS] Defaults to FALSE Returns: The bounding rectangle of all the moulder children Definition at line 1013 of file nodemldr.cpp. { // Find the moulders mangled object bounds DocRect Rect(0,0,0,0); Node* pNode = FindFirstChild(); while (pNode!=NULL) { // if this node is bounded, union its bounds with the others if (pNode->IsBounded()) Rect = Rect.Union(((NodeRenderableBounded*)pNode)->GetBoundingRect(DontUseAttrs)); pNode = pNode->FindNext(); } return Rect; }

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

Displays debugging info of the tree For obtaining debug information about the Node. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: Str,:  String giving debug info about the node [OUTPUTS] Reimplemented from NodeRenderableBounded. Definition at line 891 of file nodemldr.cpp. { #ifdef _DEBUG // Call base class NodeRenderableInk::GetDebugDetails( Str ); String_256 TempStr; (*Str) += TEXT( "\r\nMoulder Data Dump\r\n" ); /* TempStr._MakeMsg( "Mould steps = #1%ld\n" "Index start = #2%ld\n" "Index end = #3%ld\n\n" "", IndexStart, IndexEnd); *Str += TempStr; */ 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 }

UINT32 NodeMoulder::GetNodeSize (   )  const [virtual]

For finding the size of the node. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Returns: The size of the node in bytes See also: Node::GetSubtreeSize Reimplemented from NodeGroup. Definition at line 1062 of file nodemldr.cpp. { return (sizeof(NodeMoulder)); }

NodeRenderableInk* NodeMoulder::GetProvider (   )  [inline]

Definition at line 205 of file nodemldr.h. { return pProviderNode; };

virtual BOOL NodeMoulder::GroupCanTransformCached (  TransformBase &  Trans  )  const [inline, virtual]

Reimplemented from NodeGroup. Definition at line 201 of file nodemldr.h. {return FALSE;}

BOOL NodeMoulder::Initialise (  NodeRenderableInk *  pContextNode  )

Initialise a moulder object with information necessary for it to perform a mould. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pContextNode  = pointer to node which will be moulded [INPUTS] Returns: TRUE if able to initialise the moulder object FALSE if not Definition at line 240 of file nodemldr.cpp. { ERROR2IF(pContextNode == NULL,FALSE,"pContext == NULL in NodeMoulder::Init"); pProviderNode = pContextNode; return (TRUE); }

virtual BOOL NodeMoulder::IsValidEffectAttr (  NodeAttribute *  pAttr  )  const [inline, virtual]

Get width of pixels for use in capturing this group as a tight group bitmapDetermine whether this type of attribute can be an effect attribute On this node at this time.Determine whether this attribute instance can be an effect attribute On this node at this time. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/01/2005 Parameters: Attribute  [INPUTS] Returns: TRUE if the attr is a valid effect attr Reimplemented from NodeGroup. Definition at line 200 of file nodemldr.h. {return FALSE;}

BOOL NodeMoulder::MouldAllChildren (  Node *  pNode, MouldGeometry *  pGeometry, TransformBase &  Trans, UndoableOperation *  pOp )

Given a pointer to a node, begin moulding it, all its children and all its forward siblings and their children. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 22/01/95 Parameters: pNode  = pointer to a node to start moulding from [INPUTS] pGeometry = pointer to a node path shape to use for moulding Trans = reference to a mould transform object pOp = pointer to an active operation or NULL if none [OUTPUTS]  Returns: TRUE if all objects have been moulded FALSE if unable to mould some objects Definition at line 678 of file nodemldr.cpp. { Node* qNode; while (pNode) { if (pNode->IsKindOf(CC_RUNTIME_CLASS(NodePath))) { // Ok, alter the path NodePath* pNodePath = (NodePath*)pNode; if (!MouldPath(pNodePath,pGeometry,pOp)) return FALSE; } else { if (pNode->IsAnAttribute()) { NodeAttribute* pAttr = (NodeAttribute*)pNode; if ( pAttr->IsAFillAttr() && IS_A(pGeometry,MouldPerspective) ) { // Tell the fill attr to render perspectivised ((AttrFillGeometry*)pAttr)->MakePerspective(); } pAttr->Transform(Trans); } } qNode=pNode->FindFirstChild(); pNode=pNode->FindNext(); if (qNode) { if (!MouldAllChildren(qNode, pGeometry, Trans, pOp)) return FALSE; } } return TRUE; }

BOOL NodeMoulder::MouldPath (  NodePath *  pNodePath, MouldGeometry *  pGeometry, UndoableOperation *  pOp )

This function moulds the path contained within a NodPath to itself. It will use a temp path as a mould destination and copy this back over the source when successful. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Inputs pNodePath = pointer to a source node path object pGeometry = pointer to a mould shape pOp = pointer to an active operation or NULL if none Parameters: [OUTPUTS]  Returns: TRUE if the path has been moulded correctly FALSE, then unable to mould the path, the originial is intact Definition at line 357 of file nodemldr.cpp. { ERROR2IF(pNodePath==NULL, FALSE, "MouldPath called with a null source pointer"); ERROR2IF(pGeometry==NULL, FALSE, "MouldPath called with a null geometry pointer"); // ok we have the source node, so find the original path and mould it Path* pSourcePath = &(pNodePath->InkPath); // convert the source path into a destination path if (!pGeometry->MouldPathToPath(pSourcePath, pSourcePath)) return FALSE; pNodePath->InvalidateBoundingRect(); return TRUE; }

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

Snaps to given coord to the nearest point on the Moulder node. Just returns FALSE currently Virtual function - this version will return FALSE for exporting to native EPS documents. We dont need the moulded objects in these docs. 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 1326 of file nodemldr.cpp. { #ifdef DO_EXPORT if (pRender==NULL) return TRUE; // dont export to native documents if (pRender->IS_KIND_OF(NativeRenderRegion)) return FALSE; // If we have the check selection flag on then see if this moulder 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 moulder node and always needs to be exported // unless of course some node overrides this or the test above fails. if (CheckSelected) return (IsSelected() || IsChildOfSelected() || IsParentOfSelected()); else return TRUE; #else return FALSE; #endif }

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

This function should be overridden in derived object classes. Composite objects can use this function to respond to one of their children undergoing a change. They should return CC_FAIL whenever they are unable to cope with the change. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 09/01/95 Parameters: pParam  = pointer to a object change parameter class [INPUTS] Returns: CC_OK if we have successfully processed the change. CC_FAIL if we cannot handle this particular change and must prevent the child from continuing See also: WarnParentOfChange(); Reimplemented from NodeGroup. Definition at line 1594 of file nodemldr.cpp. { return CC_OK; }

BOOL NodeMoulder::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. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 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 FALSE if it is not interested in the click Reimplemented from NodeGroup. Definition at line 1086 of file nodemldr.cpp. { // we did not use the click, so let someone else try return FALSE; }

void NodeMoulder::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 NodeGroup. Definition at line 846 of file nodemldr.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeMoulder), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeMoulder)) CopyNodeContents((NodeMoulder*)pNodeCopy); }

BOOL NodeMoulder::PostExportAWEPS (  RenderRegion *  pRegion  )  [private]

Definition at line 1475 of file nodemldr.cpp. { return FALSE; }

BOOL NodeMoulder::PostExportCAMEPS (  RenderRegion *  pRegion  )  [private]

Definition at line 1445 of file nodemldr.cpp. { #ifdef DO_EXPORT // Make sure this token goes out only in Native documents if (pRegion->IS_KIND_OF(NativeRenderRegion)) { EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); pDC->OutputToken(_T("cedo")); // Camelot "end mould destin" token pDC->OutputNewLine(); return TRUE; } #endif // Otherwise render as paths (e.g. in EPS) return FALSE; }

void NodeMoulder::PreExportAWEPS (  RenderRegion *  pRegion  )  [private]

void NodeMoulder::Pre/Post ExportAWEPS(RenderRegion* pRegion) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 14/03/95 Definition at line 1471 of file nodemldr.cpp. { }

void NodeMoulder::PreExportCAMEPS (  RenderRegion *  pRegion  )  [private]

Export delimiter tokens for this particular object. The format is defined as csmp path description cemp. BOOL NodeMoulder::Pre/Post ExportCAMEPS(RenderRegion* pRegion) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 14/03/95 Definition at line 1431 of file nodemldr.cpp. { #ifdef DO_EXPORT // Make sure this token goes out only in Native documents if (pRegion->IS_KIND_OF(NativeRenderRegion)) { EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); pDC->OutputToken(_T("csdo")); // Camelot "start mould destin" token pDC->OutputNewLine(); } #endif }

void NodeMoulder::PreExportRender (  RenderRegion *  pRegion  )  [virtual]

Called before this node or any of its children have been rendered to the export region. This outputs the "start mould destin objects" command. Supports ArtWorks EPS and Camelot EPS. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 14/03/95 Parameters: pRegion  = ptr to the export render region to export to [INPUTS] [OUTPUTS]  Returns: Errors: Reimplemented from NodeGroup. Definition at line 1371 of file nodemldr.cpp. { #ifdef DO_EXPORT if (pRegion->IS_KIND_OF(CamelotEPSRenderRegion)) { PreExportCAMEPS(pRegion); return; } if (pRegion->IS_KIND_OF(ArtWorksEPSRenderRegion)) { PreExportAWEPS(pRegion); return; } #endif }

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

Will render the steps of this Moulder node. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: Pointer  to a render region [INPUTS] Reimplemented from Node. Definition at line 953 of file nodemldr.cpp. { // pRender->SaveContext(); // RenderMoulderedObjs(pRender); // Only supply a render region, because we're only rendering // pRender->RestoreContext(); }

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

Makes a copy of all the data in the node. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Returns: Pointer to a Node Reimplemented from NodeGroup. Definition at line 802 of file nodemldr.cpp. { // Make a new NodeMoulder and then copy things into it NodeMoulder* pCopyOfNode = new NodeMoulder(); if (pCopyOfNode) CopyNodeContents(pCopyOfNode); return pCopyOfNode; }

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

Transforms all the paths attached to this Moulder node. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: Trans  - The transform Object [INPUTS] See also: NodeRenderableInk::Transform() Reimplemented from NodeGroup. Definition at line 931 of file nodemldr.cpp. { // the moulder node bbox is now invalid InvalidateBoundingRect(); // Transform all the children // See GroupCanTransformCached() NodeGroup::Transform(Trans); }

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

Reimplemented from NodeGroup. Definition at line 1620 of file nodemldr.cpp. { return WritePreChildrenWeb(pFilter); }

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

Writes out a records associated with this node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 18/7/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] Returns: TRUE is a record has been written, FALSE otherwise NodeMoulders do NOT save anything out in the current version of Camelot. Reimplemented from NodeGroup. Definition at line 1613 of file nodemldr.cpp. { return FALSE; }

---

Member Data Documentation

NodeRenderableInk* NodeMoulder::pProviderNode [private]

Definition at line 226 of file nodemldr.h.

---

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

• Kernel/nodemldr.h (r1785/r1282)
• Kernel/nodemldr.cpp (r1785/r1315)

---