NodeMould Class Reference

This class defines the structure of a mould node object. This object is the parent of a MouldGroup node and a Moulder node. Objects being moulded are placed inside MouldGroup and all resulting moulded objects are placed inside the Moulder node. More...

#include <nodemold.h>

Inheritance diagram for NodeMould:

List of all members.

Public Member Functions
	NodeMould ()
	NodeMould (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	This method initialises the node and links it to ContextNode in the direction specified by Direction. All necessary tree links are updated.
	~NodeMould ()
	This destructor calls the parent class destructor and then checks whether it is necessary to delete the mould geometry class. If so the shape geometry is deleted.
void	InitialiseVars ()
	Common place to set up the classes private variables.
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" 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" command. Supports ArtWorks EPS and Camelot EPS.
virtual BOOL	PostImport ()
	This function is called after a document is imported. Nodes should override this function to do any post-import processing.
virtual void	RenderObjectBlobs (RenderRegion *pRender)
	This renders all the blobs associated with this mould node This node doesn't do any rendering itself. All it does is ask the shape object to render itself.
virtual void	RenderTinyBlobs (RenderRegion *pRender)
	Draws the paths Tiny blob into the render region supplied.
virtual DocRect	GetBlobBoundingRect ()
	This calculates the bounding box of the mould 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 Note, the mould blob bounds are simply made up of the nodemouldpath bounds and thats yer lot.
virtual void	Transform (TransformBase &Trans)
	Transforms the mould object and all its children.
virtual String	Describe (BOOL Plural, BOOL Verbose)
	To return a description of the Mould object in either the singular or the plural. This method is called by the DescribeRange method.
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.
virtual UINT32	GetNodeSize () const
	For finding the size of the node.
virtual BOOL	IsANodeMould () const
	Virtual function to determine whether this node is a NodeMould.
virtual BOOL	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	Allows the Node to respond to clicks by selecting its blobs or starting drags etc. Here we check for clicks over a moulds shape. If a blob has been clicked on we start a new drag operation to alter the shape of the mould.
BOOL	OnMouseMove (DocCoord, Spread *, ClickModifiers, INT32 *, INT32 *)
	A very unusual function to find in a node. This must exist so that the mould tool can ask the mould object what cursor to show as the mouse moves around. The function is called for each selected mould object when the mould tool is current. The nub of the problem is that a mould object can basically be made up of virtually anything. We actually need to ask the mould shape handler inside the mould object what type of cursor it wants to show and what sort of resouced message it would like to display. This cannot be determined from outside the object.
virtual ChangeCode	OnChildChange (ObjChangeParam *pParam)
	An object has or is currently being edited inside our mould so we need to perform actions related to this change. The parameter block passed to us will define what to do (if we recognise it). Otherwise we will simply perform the default action of remoulding ourselves on receiving a HasChanged reason.
virtual Node *	HasEditableChild (CCRuntimeClass *ChildClass, Node *pPrevEditable)
	This function returns our edit node (the nodemouldpath) which forms part of the mould objects editable surface.
virtual BOOL	OnNodePopUp (Spread *pSpread, DocCoord PointerPos, ContextMenu *pMenu)
	This provides descriptions for the mould records. Allows the Mould object to respond to pop up menu clicks on itself.
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	AllowSelectInside () const
void	GetDebugDetails (StringBase *Str)
	Displays debugging info of the tree For obtaining debug information about the Node.
void	PreExportCAMEPS (RenderRegion *pRegion)
BOOL	PostExportCAMEPS (RenderRegion *pRegion)
void	PreExportAWEPS (RenderRegion *pRegion)
BOOL	PostExportAWEPS (RenderRegion *pRegion)
void	ToggleDetachFlag ()
	Switch the logical value of the detached mould flag inside this mould object.
BOOL	IsDetached () const
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes out a records associated with this node.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
virtual BOOL	IsTypeExtendible () const
virtual DocRect	ValidateExtend (const ExtendParams &ExtParams)
	NodeMould uses Node's base-class implementation, as we don't want to inherit NodeGroup's extend behaviour - see Node::ValidateExtend() for details. See also: Node::ValidateExtend().
virtual void	Extend (const ExtendParams &ExtParams)
	NodeMould uses Node's base-class implementation, as we don't want to inherit NodeGroup's extend behaviour - see Node::Extend() for details. See also: Node::Extend().
virtual DocRect	GetExtendTargetBounds (const ExtendParams &ExtParams)
	NodeMould uses NodeRenderableBounded's base-class implementation, as we don't want to inherit NodeGroup's extend behaviour - see base class for details. See also: NodeRenderableBounded::Extend().
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
MouldSpace	DescribeGeometry ()
	Find out what type of geometry is defined for this mould object.
MouldGeometry *	GetGeometry () const
NodeMouldPath *	GetPathShape ()
	A useful function to find the first node mould shape object within a NodeMould object. As this is used quite a lot its been 'function'alised.
Path *	GetPath ()
	A useful function to find the actual path used for moulding As this is used quite a lot its been 'function' alised.
DocRect	GetRenderBounds ()
	Return the bounding rect of the mould. This rectangle includes only those items in the mould which are visible and hence will be invalidated by the OS. Items such as the NodeMouldGroup (which are of course invisible) do not get involved in the renderbounds.
DocRect	GetChildrensBounds ()
void	DisableBlobs ()
void	EnableBlobs ()
BOOL	CreateGeometry (MouldSpace mSpace)
	Changes the mould space used by this mould to that described by mSpace. Currently the defined spaces are MOULDSPACE_ENVELOPE MOULDSPACE_PERSPECTIVE.
NodeMoulder *	CreateNewMoulder (UndoableOperation *)
	Creates a NodeMoulder object and returns a pointer to it.
NodeMouldPath *	CreateNewMouldShape (Path *pPath, DocRect *const pDestin, UndoableOperation *pOp)
	Creates a node mould path object using the path pointer given and the destination rectangle described. The objects pointer is returned.
NodeMouldGroup *	CreateNewMouldGroup (UndoableOperation *pOp)
	Creates a MouldGroup object and returns a pointer to it.
BOOL	CreateAllMoulderObjects (UndoableOperation *pOp)
	Scan through the children of a mould object, getting all NodeMoulders to regenerate their moulded objects.
NodeMoulder *	AddNewMoulder (Node *, AttachNodeDirection, UndoableOperation *)
	Creates a NodeMoulder object and sticks it in the tree at the specified position.
NodeMouldPath *	AddNewMouldShape (Path *pPath, DocRect *const pDestin, UndoableOperation *pOp)
	Creates a node mould path object using the path pointer given and the destination rectangle described. The object is inserted as the first child of this node mould object and its pointer is returned.
NodeMouldGroup *	AddNewMouldGroup (UndoableOperation *pOp)
	Creates a MouldGroup object inside the MouldParent and moves all the objects specified by NodeList into the group. Only object which can become either a path or a nodebitmap are actually moved.
BOOL	FillMouldGroup (NodeMouldGroup *, List *, UndoableOperation *)
	Moves all the objects specified by NodeList into the mould group. Only objects which can become either a path or a nodebitmap are actually moved.
NodeMoulder *	FindFirstMoulder (BOOL errorcheck=TRUE)
	A useful function to find the first node moulder object within a NodeMould object. As this is used quite a lot its been 'function'alised.
NodeMoulder *	FindNextMoulder (NodeMoulder *pNodeMoulder)
	A useful function to find the next node moulder object within a NodeMould object.
NodeMouldGroup *	FindMouldGroup (BOOL errorcheck=TRUE)
	A useful function to find the mould group node within a NodeMould object. As this is used quite a lot its been 'function'alised.
ChangeCode	RemouldAll (UndoableOperation *pUndoOp)
	Creates a new set of moulded objects, now the mould shape has changed.
ChangeCode	StartSaveContext (UndoableOperation *pUndoOp, INT32)
	Tries to save the current state of the mould shape on the undo. If you want to edit the mould in any way you should use this function to record various parts of the mould before going ahead and changing any data. The corresponding EndSaveContext should be called after you have altered any data.
ChangeCode	EndSaveContext (UndoableOperation *pUndoOp, INT32)
	Tries to save the current state of the mould shape on the undo.
BOOL	CreateAttrSetFromChildren (AttrTypeSet &AttSet)
	Builds a set of AttrTypeSet set of attributes from the children of a node.
BOOL	SetGeometry (MouldGeometry *)
	Not to be used.
INT32	CountMoulders ()
	Count the number of moulder objects which have been created within this mould. This does not include hidden moulder objects of course.
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
Static Public Member Functions
static void	RemovePerspectiveFills (Node *pParentNode, UndoableOperation *pUndoOp)
	This function scans the children of a given parent for perspectivised bitmap fills. It replaces these attributes with standard bitmap fill atts in order to avoid perspective bitmap fills from escaping during a make shapes.
Private Member Functions
	CC_DECLARE_DYNAMIC (NodeMould)
void	RedrawMould ()
	Forces a redraw over the mould object.
void	CopyNodeContents (NodeMould *pCopyOfNode)
	Copies the data from 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.
ChangeCode	HandleMouldShapeChange (ObjChangePathEdit *pParam)
	The user is about to edit, in the action of editing, or has edited, our mould shape. We as a parent need to sort out whether they are allowed to continue. If so we need to perform various actions dependent on what stage the change is in. AboutToEdit: we need to decide whether there is a good reason to prevent the edit from taking place Editing: we need to eor our edit blobs on when necessary HasEdited: we need to perform a remould of all children.
void	IncludeChildrensBoundingRects (DocRect &BoundingRect)
	The childrens Blob bounding rects are added to the BoundingRect.
BOOL	OverMouldEndPoint (DocCoord coord, Spread *pSpread)
	This routine checks for the mouse being over end points of our mould path.
ChangeCode	RecordChangeCodes (UndoableOperation *pOp)
	Record the CRC codes held within the mould object.
ChangeCode	ConvertCode (ActionCode Act)
	Convert a action code to a change code.
Private Attributes
String_32	MouldName
MouldGeometry *	pMouldGeometry
BOOL	DetachedGeometry
INT32	OnCC_CRC
INT32	OnCC_Width
INT32	OnCC_Height
BOOL	RenderBlobs
Friends
class	RecordChangeCodesAction

---

Detailed Description

This class defines the structure of a mould node object. This object is the parent of a MouldGroup node and a Moulder node. Objects being moulded are placed inside MouldGroup and all resulting moulded objects are placed inside the Moulder node.

Author:

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

Date:

1/12/94

Definition at line 161 of file nodemold.h.

---

Constructor & Destructor Documentation

NodeMould::NodeMould (   )

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

This method initialises the node and links it to ContextNode in the direction specified by Direction. All necessary tree links are updated. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 5/12/94 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] Direction: Specifies the direction in which this node is to be attached to the ContextNode. The values this variable can take are as follows: PREV : Attach node as a previous sibling of the context node NEXT : Attach node as a next sibling of the context node FIRSTCHILD: Attach node as the first child of the context node LASTCHILD : Attach node as a last child of the context node The remaining inputs specify the status of the node: Locked: Is node locked ? Mangled: Is node mangled ? Marked: Is node marked ? Selected: Is node selected ? Parameters: -  [OUTPUTS] Returns: - Errors: An assertion error will occur if ContextNode is NULL Definition at line 229 of file nodemold.cpp. :NodeGroup(ContextNode, Direction, Locked, Mangled, Marked, Selected) { NodeMould::InitialiseVars(); }

NodeMould::~NodeMould (   )

This destructor calls the parent class destructor and then checks whether it is necessary to delete the mould geometry class. If so the shape geometry is deleted. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 5/12/94 Definition at line 253 of file nodemold.cpp. { if (pMouldGeometry != NULL) { delete pMouldGeometry; pMouldGeometry = NULL; } }

---

Member Function Documentation

NodeMoulder * NodeMould::AddNewMoulder (  Node *  pContextNode, AttachNodeDirection  Direction, UndoableOperation *  pOp )

Creates a NodeMoulder object and sticks it in the tree at the specified position. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pContextNode  = The node to which NewNode is to be attached [INPUTS] Direction = The direction the new node should be attached to the context node. pOp = A pointer to an active operation (can be null) Returns: a pointer to the moulder object (not in the tree). NULL if failed to create this moulder. See also: - Definition at line 1616 of file nodemold.cpp. { BOOL ok; // create a new moulder object NodeMoulder* pMoulder = CreateNewMoulder(pOp); if (pMoulder==NULL) return NULL; if (pOp!=NULL) { // now insert it in the tree in an undoable way CALL_WITH_FAIL(pOp->DoInsertNewNode(pMoulder, pContextNode, Direction, FALSE, FALSE, FALSE, FALSE), pOp, ok); } else { // all right then, insert it in a none undoable way pMoulder->AttachNode(pContextNode, Direction); pMoulder->SetSelected(FALSE); ok = TRUE; } // if failed get rid of what we have if (!ok) { delete pMoulder; return NULL; } return pMoulder; }

NodeMouldGroup * NodeMould::AddNewMouldGroup (  UndoableOperation *  pOp  )

Creates a MouldGroup object inside the MouldParent and moves all the objects specified by NodeList into the group. Only object which can become either a path or a nodebitmap are actually moved. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pOp  = A pointer to an active operation (can be null) [INPUTS] Returns: a pointer to the created mould group (inserted into the tree) NULL if unable to create the node See also: - Definition at line 1836 of file nodemold.cpp. { BOOL ok; // Create a mould group object NodeMouldGroup* pMouldGroup = CreateNewMouldGroup(pOp); if (pMouldGroup==NULL) return NULL; if (pOp!=NULL) { // Now stick the mould group inside the mould parent, but dont alter the selection CALL_WITH_FAIL(pOp->DoInsertNewNode(pMouldGroup, this, LASTCHILD, FALSE, FALSE, FALSE, FALSE), pOp, ok); } else { // all right then, insert it in a none undoable way pMouldGroup->AttachNode(this, LASTCHILD); pMouldGroup->SetSelected(FALSE); ok = TRUE; } // if failed get rid of what we have if (!ok) { delete pMouldGroup; return NULL; } return pMouldGroup; }

NodeMouldPath * NodeMould::AddNewMouldShape (  Path *  pShape, DocRect *const   pDestin, UndoableOperation *  pOp )

Creates a node mould path object using the path pointer given and the destination rectangle described. The object is inserted as the first child of this node mould object and its pointer is returned. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pPath  = pointer to a path to use as a shape [INPUTS] pDestin = a rectangular area to place the shape over. If this is NULL the path is used as is. pOp = A pointer to an active operation (can be null) Returns: a pointer to the created node mould path (inserted into the tree) NULL if unable to create the node See also: - Definition at line 1749 of file nodemold.cpp. { ERROR2IF(pShape==NULL, NULL, "NodeMould::AddNewMouldShape() called with a null path"); NodeMouldPath* pNodeMPath = CreateNewMouldShape(pShape, pDestin, pOp); if (pNodeMPath==NULL) return NULL; NodeMouldGroup* pGroup = FindMouldGroup(FALSE); NodeMoulder* pMoulder = FindFirstMoulder(FALSE); Node* pContext = this; AttachNodeDirection Dir = LASTCHILD; if (pMoulder!=NULL) { pContext = pMoulder; Dir = PREV; } if (pGroup!=NULL) { pContext = pGroup; Dir = PREV; } BOOL ok = TRUE; if (pOp!=NULL) ok = pOp->DoInsertNewNode(pNodeMPath, pContext, Dir, FALSE, FALSE, FALSE, FALSE); else { pNodeMPath->AttachNode(pContext, Dir); pNodeMPath->SetSelected(FALSE); } if (!ok) { delete pNodeMPath; return NULL; } return pNodeMPath; }

virtual BOOL NodeMould::AllowSelectInside (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 211 of file nodemold.h. { return FALSE; }

BOOL NodeMould::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 809 of file nodemold.cpp. { // The NodeMoulder can become a NodePath if (pBecomeA->BAPath()) { if (pBecomeA->IsCounting()) { // We need to count how many paths it will create // We do this by adding the values received by each child NodeMoulder NodeMoulder* pNodeMoulder = FindFirstMoulder(); while (pNodeMoulder != NULL) { pNodeMoulder->CanBecomeA(pBecomeA); // Increments count pNodeMoulder = FindNextMoulder(pNodeMoulder); } } return TRUE; } return FALSE; }

NodeMould::CC_DECLARE_DYNAMIC (  NodeMould   )  [private]

ChangeCode NodeMould::ConvertCode (  ActionCode  Act  )  [private]

Convert a action code to a change code. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/01/95 Parameters: Action  code [INPUTS] Returns: Change code Definition at line 2254 of file nodemold.cpp. { switch (Act) { case AC_FAIL: return CC_FAIL; case AC_NORECORD: return CC_NORECORD; case AC_OK: return CC_OK; } return CC_OK; }

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

Copies the data from 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: 5/12/94 Parameters: pCopyOfNode  - The node to copy data to [INPUTS] -  [OUTPUTS] Returns: - See also: NodeGroup::CopyNodeContents Definition at line 472 of file nodemold.cpp. { ERROR3IF(pCopyOfNode==NULL,"NodeMould::CopyNodeContents() was asked to copy into a NULL pointer"); NodeGroup::CopyNodeContents(pCopyOfNode); // Make sure we copy all our personal data here pCopyOfNode->DetachedGeometry = DetachedGeometry; // Need to copy the shape and adjust our pointer. MouldGeometry* pNewGeom = (MouldGeometry*) pMouldGeometry->MakeCopy(); // if the shape is NULL ie we couldn't build it what do we do? if (pNewGeom) pCopyOfNode->pMouldGeometry = pNewGeom; }

INT32 NodeMould::CountMoulders (   )

Count the number of moulder objects which have been created within this mould. This does not include hidden moulder objects of course. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/03/95 Parameters: [INPUTS]  Returns: The number of moulder objects within this mould Definition at line 1452 of file nodemold.cpp. { INT32 Count=0; Node* pNode = FindFirstChild(); ERROR2IF(pNode == NULL,0, "No children found in MouldObject during NodeMould::CountMoulders()"); while (pNode!=NULL) { // check for the right class if (pNode->GetRuntimeClass() == CC_RUNTIME_CLASS(NodeMoulder)) Count+=1; pNode=pNode->FindNext(); } return Count; }

BOOL NodeMould::CreateAllMoulderObjects (  UndoableOperation *  pOp  )

Scan through the children of a mould object, getting all NodeMoulders to regenerate their moulded objects. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pOp  = pointer to an operation (can be null) [INPUTS] Returns: TRUE if all moulder objects have rebuilt themselves FALSE if one failed. Definition at line 1529 of file nodemold.cpp. { // Scan inside the mould object for the first moulder NodeMoulder* pMoulder = FindFirstMoulder(); if (!pMoulder) // there's no moulder object inside this mould so we still can't do anything. return FALSE; // first find the mould group NodeMouldGroup* pMouldGroup = FindMouldGroup(); if (!pMouldGroup) // there's no mould group inside this mould so we still can't do anything. return FALSE; while (pMoulder) { // create moulds for this moulder if (!pMoulder->CreateMouldedObjects(pMouldGroup, pMouldGeometry, pOp)) return FALSE; // skip to the next moulder object pMoulder = (NodeMoulder*) pMoulder->FindNext(CC_RUNTIME_CLASS(NodeMoulder)); } return TRUE; }

BOOL NodeMould::CreateAttrSetFromChildren (  AttrTypeSet &  AttSet  )

Builds a set of AttrTypeSet set of attributes from the children of a node. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 21/06/95 Parameters: -  [INPUTS] AttSet  = a set of attributes which are children of the compound node [OUTPUTS] Returns: TRUE - if the set was built correctly FALSE - if not Definition at line 1094 of file nodemold.cpp. { Node* qNode = FindFirstChild(); while (qNode && qNode->IsAnAttribute()) { if (!AttSet.AddToSet(((NodeAttribute*)qNode)->GetAttributeType())) return FALSE; qNode=qNode->FindNext(); } return TRUE; }

BOOL NodeMould::CreateGeometry (  MouldSpace  mSpace  )

Changes the mould space used by this mould to that described by mSpace. Currently the defined spaces are MOULDSPACE_ENVELOPE MOULDSPACE_PERSPECTIVE. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 6/12/94 Parameters: mSpace  = the type of mould to create. Currently use Envelope or Perspective [INPUTS] enum values. It can also be NULL if you wish to use the shape as is. Returns: TRUE if the geometry has been created successfully. FALSE then unable to create the geometry object (out of memory) Definition at line 322 of file nodemold.cpp. { // now build the new vector space polymorphically MouldGeometry* pNewGeom=NULL; switch (mSpace) { case MOULDSPACE_ENVELOPE: { MouldEnvelope* mNewSpace = new MouldEnvelope; if (!mNewSpace) return FALSE; if (!mNewSpace->Initialise()) { delete mNewSpace; return FALSE; } pNewGeom = mNewSpace; break; } case MOULDSPACE_ENVELOPE2X2: { MouldEnvelope2x2* mNewSpace = new MouldEnvelope2x2; if (!mNewSpace) return FALSE; if (!mNewSpace->Initialise()) { delete mNewSpace; return FALSE; } pNewGeom = mNewSpace; break; } case MOULDSPACE_PERSPECTIVE: { MouldPerspective* mNewSpace = new MouldPerspective; if (!mNewSpace) return FALSE; pNewGeom = mNewSpace; break; } default: break; } if (!pNewGeom) return FALSE; // Assign the class geometry pointer the new shape // Note, we do not record the mouldspace in our class because // we dont really need to. The shape is an abstract class with // concrete geometries derived from it and hence we can call a shape // function and the run time binder will call the correct class func. pMouldGeometry = pNewGeom; return TRUE; }

NodeMoulder * NodeMould::CreateNewMoulder (  UndoableOperation *  pOp  )

Creates a NodeMoulder object and returns a pointer to it. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pOp  = A pointer to an active operation (can be null) [INPUTS] Returns: a pointer to the moulder object (not in the tree). NULL if failed to create this moulder. See also: - Definition at line 1570 of file nodemold.cpp. { BOOL ok; // first find the mould group NodeMouldGroup* pMouldGroup = FindMouldGroup(); if (!pMouldGroup) return NULL; // Now create a moulder object NodeMoulder* pMoulder; ALLOC_WITH_FAIL( pMoulder, new NodeMoulder, pOp); if (!pMoulder) return NULL; // get the moulder to initialise itself CALL_WITH_FAIL(pMoulder->Initialise(pMouldGroup), pOp, ok); if (!ok) { delete pMoulder; return NULL; } // its built so lets return it return pMoulder; }

NodeMouldGroup * NodeMould::CreateNewMouldGroup (  UndoableOperation *  pOp  )

Creates a MouldGroup object and returns a pointer to it. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pOp  = A pointer to an active operation (can be null) [INPUTS] Returns: a pointer to the created mould group (not in the tree) NULL if unable to create the node See also: - Definition at line 1811 of file nodemold.cpp. { // Create a mould group object NodeMouldGroup* pMouldGroup; ALLOC_WITH_FAIL( pMouldGroup, new NodeMouldGroup, pOp); return pMouldGroup; }

NodeMouldPath * NodeMould::CreateNewMouldShape (  Path *  pShape, DocRect *const   pDestin, UndoableOperation *  pOp )

Creates a node mould path object using the path pointer given and the destination rectangle described. The objects pointer is returned. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: pPath  = pointer to a path to use as a shape [INPUTS] pDestin = a rectangular area to place the shape over. If this is NULL the path is used as is. pOp = A pointer to an active operation (can be null) Returns: a pointer to the created node mould path (not in the tree) NULL if unable to create the node See also: - Definition at line 1673 of file nodemold.cpp. { ERROR2IF(pShape==NULL, NULL, "NodeMould::CreateNewMouldShape() called with a null path"); // Note, we do not record the mouldspace in our class because // we dont really need to. The shape is an abstract class with // concrete geometries derived from it and hence we can call a shape // function and the run time binder will call the correct class func. BOOL ok; // build the new vector space polymorphically NodeMouldPath* pNodeMPath; ALLOC_WITH_FAIL( pNodeMPath, new NodeMouldPath, pOp); if (!pNodeMPath) return NULL; Path* pPath = (&(pNodeMPath->InkPath)); CALL_WITH_FAIL(pPath->Initialise(pShape->GetNumCoords(), 12), pOp, ok); if (!ok) { delete pNodeMPath; return NULL; } CALL_WITH_FAIL(pPath->CopyPathDataFrom(pShape), pOp, ok); if (!ok) { delete pNodeMPath; return NULL; } // make sure our path has no fill bit pPath->IsFilled=FALSE; if (pDestin) { // we have been given a destination rectangle to map the path shape onto, // so first we need the source bbox DocRect Source = pPath->GetBoundingRect(); // Build a transform matrix and apply it to this mould Matrix Mat(Source,*pDestin); Trans2DMatrix Trans(Mat); Trans.Transform( (DocCoord*)pPath->GetCoordArray(), pPath->GetNumCoords() ); } return pNodeMPath; }

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

To return a description of the Mould 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 mould node The description will always begin with a lower case letter. Reimplemented from NodeGroup. Definition at line 418 of file nodemold.cpp. { if (Plural) return(String(_R(IDS_MOULD_DESCRP))); else return(String(_R(IDS_MOULD_DESCRS))); };

MouldSpace NodeMould::DescribeGeometry (   )

Find out what type of geometry is defined for this mould object. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/12/94 Parameters: [INPUTS]  Returns: The current mould space defined for this mould object. ie what type of mould geometry it uses, eg envelope, perspective etc. Definition at line 1303 of file nodemold.cpp. { if (pMouldGeometry) return pMouldGeometry->Describe(); return MOULDSPACE_UNDEFINED; }

void NodeMould::DisableBlobs (   )  [inline]

Definition at line 259 of file nodemold.h. { RenderBlobs=FALSE; }

BOOL NodeMould::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 853 of file nodemold.cpp. { BOOL ok; switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE: { // ERROR2IF(pBecomeA->GetUndoOp() == NULL,FALSE,"Trying to replace a NodeMould, but pUndoOp == NULL"); UndoableOperation* pUndoOp = pBecomeA->GetUndoOp(); // If replacing the mould with shapes, hide the mould, create a group, and move all the children // so they become children of the new group node NodeMoulder* pMoulder = FindFirstMoulder(); if (pMoulder!=NULL) { BOOL IsSelected = this->IsSelected(); SetSelected(FALSE); // Localise only the current children so undo factors out only these AttrTypeSet AttrTypes; if (!CreateAttrSetFromChildren(AttrTypes)) return FALSE; // localise common child attributes before moving objects! if (pUndoOp) { if (!pUndoOp->DoLocaliseCommonAttributes(this, FALSE, FALSE, &AttrTypes)) return FALSE; if (!pUndoOp->DoLocaliseCommonAttributes(pMoulder)) return FALSE; } else { if (!LocaliseCommonAttributes(FALSE, FALSE, &AttrTypes)) return FALSE; if (!pMoulder->LocaliseCommonAttributes()) return FALSE; } // Pass on this message to our child ink nodes first Node* pNode = pMoulder->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 next to the NodeMould if (pUndoOp) { 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; } } else { pNodeGroup->AttachNode(this,NEXT); } // Now move each node in turn. pNode = pMoulder->FindLastChild(); while (pNode != NULL) { // Find the next node to move before we shift up the children Node* pPrevNode = pNode->FindPrevious(); if (pNode->IsAnObject()) { if (pUndoOp) { CALL_WITH_FAIL(pUndoOp->DoMoveNode(pNode, pNodeGroup, FIRSTCHILD), pUndoOp, ok); if (!ok) return FALSE; } else { pNode->MoveNode(pNodeGroup, FIRSTCHILD); } } pNode = pPrevNode; } // Karim 15/05/2000 - this new loop copies non-optimising attrs applied to // the NodeMould object, into the new group. Note that although CopyNode() // is NOT undoable, things should be fine as the insertion of the group *was*. pNode = FindLastChild(); while (pNode != NULL) { Node* pPrevNode = pNode->FindPrevious(); if ( pNode->IsAnAttribute() && !((NodeAttribute*)pNode)->ShouldBeOptimized() ) { CALL_WITH_FAI