NodeRenderable Class Reference

This abstract class describes a node which is renderable. See the Node class for an important note about producing derived classes of Node. More...

#include <node.h>

Inheritance diagram for NodeRenderable:

List of all members.

Public Member Functions
	NodeRenderable ()
	This constructor creates a NodeRenderable linked to no other with all status flags false and an uninitialised bounding rectangle.
	NodeRenderable (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.
virtual BOOL	CanTransform ()
	Determine whether a renderable node can be transformed - if it does not, then no undo information needs to be stored for it.
virtual void	Transform (TransformBase &)
	This is the base class verison of the transform function. This is called to move, scale, rotate etc renderable objects. Each class derived from NodeRenderableInk should write a version of this function that manipulates all the control points in the object and updates its bounding box. See NodePath for an example.
virtual void	TransformChildren (TransformBase &)
virtual void	PolyCopyNodeContents (NodeRenderable *NodeCopy)
	Polymorphically copies the contents of this node to another.
virtual SubtreeRenderState	RenderSubtree (RenderRegion *pRender, Node **ppNextNode=NULL, BOOL bClip=TRUE)
	Virtual function - this function will indicate to the caller whether or not we want to render the given node, according to the information passed in. For this class, it always returns TRUE.
virtual BOOL	NeedsToExport (RenderRegion *pRender, BOOL VisibleLayersOnly=FALSE, BOOL CheckSelected=FALSE)
	Indicate that we want to export this class of nodes.
virtual INT32	GetSizeOfExport (Filter *)
	Find out how many nodes will be exported when this node is exported. The node can use the filter to find out how it will be exported, e.g. blends should return a value that reflects whether or not intermediate shapes will be saved out, etc. Bitmaps and other large objects should return an approximation so that the progress display bar gives a smooth update. NB. This is virtual - the default implementation just returns 1 - only override if this is not accurate.
virtual BOOL	IsNodeRenderableClass () const
	Determine if a node is *derived* from the NodeRenderable class. NB. This has nothing to do with the node's renderable flag!
virtual BOOL	ShouldBeRendered () const
	Work out if the node should be rendered - basically all nodes except NodeRenderable nodes should be rendered. However, some NodeRenderable derived classes should not actually be rendered - for example NodeMouldGroup hides the original un-moulded objects, which should definitely *not* be rendered. This is mainly used during printing where due to complications to do with banding and transparency, we cannot use NeedsToRender() to filter out such nodes, so we use this function instead. NB. This has nothing to do with the node's renderable flag!
virtual void	GetDebugDetails (StringBase *Str)
	For obtaining debug information about the Node.
virtual void	RenderFillBlobs (RenderRegion *pRender)
virtual void	RenderAppliedFillBlobs (RenderRegion *pRender)
virtual void	RenderArtisticBlobs (RenderRegion *pRender)
	This function is the base class version of a blob rendering function, so it actually does nothing. Artistic blobs are used to display infomation about things such as pressure and other 'artistic' effects. If a node wants to render artistic blobs it should contain a version of this function.
virtual void	RenderObjectBlobs (RenderRegion *pRender)
	This function is the base class version of a blob rendering function, so it actually does nothing. Object Blobs are the blobs that allow you to edit the shape of the node. For example, a path would display blobs on all its coords and a Rectangle may put a blob at each corner.
virtual void	RenderTinyBlobs (RenderRegion *pRender)
	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	RenderPenBlobs (RenderRegion *pRender)
	This function is the base class version of a blob rendering function, so it actually does nothing. Overide this function in each of the nodes that require Pen Blobs so draw what it needed.
virtual void	RenderToolObjectBlobs (RenderRegion *pRender)
	This function is the base class version of a blob rendering function, so it actually does nothing. ToolObject blobs are displayed and used by a Node for interaction with a specific tool. They are similar to object blobs, but the big difference is that whereas object blobs are displayed regardless of the current tool (even if you can't use it to edit them), ToolObject blobs are not. The Node should always exercise final control over whether the blobs are active, depending on which tool is in use.
virtual void	RenderEffectBlobs (RenderRegion *pRender)
	This function is the base class version of a blob rendering function, so it actually does nothing. The fill blobs are the blobs rendered by fills (eg the graduated fill should draw an arrow to show the start and end positions of the fill). A node that wants to render some fill blobs should write a replacement of this function. This function is the base class version of a blob rendering function, so it actually does nothing. The fill blobs are the blobs rendered by fills (eg the graduated fill should draw an arrow to show the start and end positions of the fill). A node that wants to render some fill blobs should write a replacement of this function.
virtual void	Select (BOOL ReDraw)
	Selects the node.
virtual void	DeSelect (BOOL ReDraw, BOOL bDeselectChildren=FALSE)
	DeSelects the node.
virtual BOOL	CopyComponentData (BaseDocument *SrcDoc, BaseDocument *NodesDoc)
	This virtual function will be called on the node after it has been copied from document SrcDoc. It should copy all neccessary DocComponent data from SrcDoc to the document where the node lives (NodesDoc).
virtual DocRect	GetBlobBoundingRect ()
	Calculates the bounding rectangle of the nodes blobs.This should always be calculated on the fly as the view scale can change without the node knowing, giving an incorrect result.
virtual DocRect	GetUnionBlobBoundingRect (BOOL bIncludeEffects=TRUE)
	This simply returns the result of GetBlobBoundingRect() as the default action for the base class.
virtual BOOL	IsDragged () const
	Returns a flag saying whether the node is currently being dragged or not Scope: public.
virtual void	SetDraggedState (BOOL bNewState, BOOL bAndChildren)
	Allows you to set the dragged state of this node Scope: public.
virtual void	TransformStretchObject (const ExtendParams &ExtParams)
	Perform a stretch on this Node, according to the contents of ExtParams. This function does nothing unless ExtParams uses X_STRETCH or Y_STRETCH. See also: The Extender class.
virtual void	TransformTranslateObject (const ExtendParams &ExtParams)
	Translate this Node, according to the offsets and flags defined in ExtParams, and a reference centre, defined by NodeRenderable::FindExtendCentre(). This function does nothing unless ExtParams uses X_EXTEND or Y_EXTEND. See also: The Extender class; FindExtendCentre().
virtual void	TransformTranslateNoStretchObject (const ExtendParams &ExtParams)
	Translate this node so that its extend-centre matches the position it would be in if the node were stretched. The node maintains its aspect ratio. This function does nothing unless ExtParams uses X_STRETCH or Y_STRETCH. See also: The Extender class; FindExtendCentre().
virtual DocCoord	FindExtendCentre ()
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 (NodeRenderable *NodeCopy)
	This method copies the node's contents to the node pointed to by NodeCopy.
virtual BOOL	IsSeeThrough (BOOL CheckIndirectAttrs)
Protected Attributes
BOOL	Dragged

---

Detailed Description

This abstract class describes a node which is renderable. See the Node class for an important note about producing derived classes of Node.

Author:

Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 19/5/93

See also:

Node

Definition at line 1214 of file node.h.

---

Constructor & Destructor Documentation

NodeRenderable::NodeRenderable (   )

This constructor creates a NodeRenderable linked to no other with all status flags false and an uninitialised bounding rectangle. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: -  [INPUTS] [OUTPUTS]  Returns: - Errors: Definition at line 264 of file noderend.cpp. :Node() { Flags.Renderable = TRUE; Dragged = FALSE; }

NodeRenderable::NodeRenderable (  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: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/93 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] Direction: Specifies the direction in which the 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 313 of file noderend.cpp. : Node(ContextNode, Direction, Locked, Mangled, Marked, Selected, TRUE) { }

---

Member Function Documentation

BOOL NodeRenderable::CanTransform (   )  [virtual]

Determine whether a renderable node can be transformed - if it does not, then no undo information needs to be stored for it. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 14/04/94 Returns: The base class always returns FALSE - i.e. NodeRenderables do not need to be transformed by default. See also: NodeRenderableInk::CanTransform Reimplemented in AttrLinearFill, AttrRadialFill, AttrConicalFill, AttrSquareFill, AttrThreeColFill, AttrFourColFill, AttrBitmapFill, AttrFractalFill, and NodeRenderableInk. Definition at line 520 of file noderend.cpp. { return FALSE; }

BOOL NodeRenderable::CopyComponentData (  BaseDocument *  SrcDoc, BaseDocument *  NodesDoc )  [virtual]

This virtual function will be called on the node after it has been copied from document SrcDoc. It should copy all neccessary DocComponent data from SrcDoc to the document where the node lives (NodesDoc). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 16/8/94 Parameters: SrcDoc,:  The document from where this node was copied [INPUTS] NodesDoc: The document where this node lives -  [OUTPUTS] Returns: FALSE if the copy should be aborted, eg. the component data could not be copied accross because we ran out of memory. Errors: - See also: DocComponent::StartComponentCopy DocComponent::EndComponentCopy DocComponent::AbortComponentCopy Reimplemented in AttrFillGeometry, NodeAttribute, and StyleReferenceAttribute. Definition at line 953 of file noderend.cpp. { // Do nothing in the base class return TRUE; }

void NodeRenderable::CopyNodeContents (  NodeRenderable *  NodeCopy  )

This method copies the node's contents to the node pointed to by NodeCopy. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/93 Parameters: [INPUTS]  A  copy of this node [OUTPUTS] Returns: - Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Definition at line 595 of file noderend.cpp. { ENSURE(NodeCopy != NULL,"Trying to copy a node's contents into a NULL node"); Node::CopyNodeContents(NodeCopy); }

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

DeSelects the node. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/94 Parameters: ReDraw  - TRUE if you want the blobs to be redrawn for you [INPUTS] Reimplemented in NodeCompound, and NodePath. Definition at line 890 of file noderend.cpp. { // Get the blob manager to draw some blobs if needed if (IsSelected()) { if (ReDraw) { // Find the blob manager BlobManager* BlobMgr = GetApplication()->GetBlobManager(); ENSURE( BlobMgr!=NULL, "Blob Manager unexpected not there" ); // Get it to render the blobs of this node BlobMgr->RenderMyBlobsOff(NULL, FindParentSpread(), this); AttrFillGeometry::LastRenderedMesh = NULL; } // Make this node selected SetSelected(FALSE); GetApplication()->UpdateSelection(); } else if (IsParentOfSelected() && bDeselectChildren) { Node* pNode = this->FindFirstDepthFirst(); while (pNode) { if (pNode->IsNodeRenderableClass() && pNode!=this) { ((NodeRenderable*)pNode)->DeSelect(ReDraw); } pNode = pNode->FindNextDepthFirst(this); } GetApplication()->UpdateSelection(); } }

virtual DocCoord NodeRenderable::FindExtendCentre (   )  [inline, virtual]

Reimplemented in AttrFillGeometry, NodeRenderableBounded, and TextStory. Definition at line 1278 of file node.h. { return DocCoord(0, 0); }

DocRect NodeRenderable::GetBlobBoundingRect (   )  [virtual]

Calculates the bounding rectangle of the nodes blobs.This should always be calculated on the fly as the view scale can change without the node knowing, giving an incorrect result. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/01/94 Returns: DocRect - The rectangle that contains all the nodes selection blobs. Reimplemented in AttrFillGeometry, AttrFlatFill, AttrRadialFill, AttrConicalFill, AttrSquareFill, AttrThreeColFill, AttrFourColFill, AttrBitmapFill, NodeGrid, NodeGroup, Layer, AttrStrokeColour, AttrStrokeTransp, NodeContourController, NodeBrushMaker, NodeClipViewController, NodeMouldGroup, NodeBevel, NodeBevelBegin, NodeBlender, NodeBlend, NodeBrush, NodeClipView, NodeContour, NodeEllipse, NodeBitmapEffect, NodeMoulder, NodeMould, NodePath, NodeRegularShape, NodeSimpleShape, AbstractTextChar, CaretNode, EOLNode, TextLine, and TextStory. Definition at line 791 of file noderend.cpp. { DocRect EmptyOne(0,0,0,0); return EmptyOne; }

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

For obtaining debug information about the Node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/93 Parameters: Str,:  String giving debug info about the node [OUTPUTS] Reimplemented in AttrBevelIndent, AttrBevelLightAngle, AttrBevelContrast, AttrBevelType, AttrBevelLightTilt, AttrBrushType, Chapter, AttrFlatColourFill, AttrFlatTranspFill, AttrLinearColourFill, AttrLinearTranspFill, AttrRadialColourFill, AttrRadialTranspFill, AttrConicalColourFill, AttrConicalTranspFill, AttrSquareColourFill, AttrSquareTranspFill, AttrThreeColColourFill, AttrThreeColTranspFill, AttrFourColColourFill, AttrFourColTranspFill, AttrBitmapColourFill, AttrBitmapTranspFill, AttrTextureColourFill, AttrFractalColourFill, AttrNoiseColourFill, AttrTextureTranspFill, NodeGrid, NodeGridRect, NodeGridIso, NodeGuideline, AttrOverprintLine, AttrOverprintFill, AttrPrintOnAllPlates, Layer, AttrLineWidth, AttrStrokeColour, AttrStrokeTransp, AttrStartArrow, AttrEndArrow, AttrStartCap, AttrJoinType, AttrMitreLimit, AttrWindingRule, AttrDashPattern, NodeBrushMaker, NodeClipViewController, NodeRenderableBounded, NodeBevel, NodeBlender, NodeDocument, NodeMoulder, NodeMould, NodePath, NodeRegularShape, NodeSimpleShape, VisibleTextNode, AbstractTextChar, TextChar, KernCode, CaretNode, EOLNode, TextLine, TextStory, NodeRenderablePaper, Page, AttrQuality, Spread, AttrStrokeType, AttrVariableWidth, AttrTxtFontTypeface, AttrTxtBold, AttrTxtItalic, AttrTxtUnderline, AttrTxtAspectRatio, AttrTxtJustification, AttrTxtTracking, AttrTxtFontSize, AttrTxtScript, AttrTxtBaseLine, AttrTxtLeftMargin, AttrTxtRightMargin, AttrTxtFirstIndent, AttrTxtRuler, AttrTxtLineSpace, AttrUser, and AttrWebAddress. Definition at line 615 of file noderend.cpp. { #if DEBUG_TREE Node::GetDebugDetails(Str); #endif }

INT32 NodeRenderable::GetSizeOfExport (  Filter *   )  [virtual]

Find out how many nodes will be exported when this node is exported. The node can use the filter to find out how it will be exported, e.g. blends should return a value that reflects whether or not intermediate shapes will be saved out, etc. Bitmaps and other large objects should return an approximation so that the progress display bar gives a smooth update. NB. This is virtual - the default implementation just returns 1 - only override if this is not accurate. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: pFilter  - the export filter that will be used. [INPUTS] Returns: The number of nodes that will be exported (or an approximation for large objects, e.g. bitmaps). See also: Node::NeedsToExport; Node::ExportRender Reimplemented in NodeBitmap. Definition at line 402 of file noderend.cpp. { // Most nodes are just one node... return 1; }

DocRect NodeRenderable::GetUnionBlobBoundingRect (  BOOL  bIncludeEffects = TRUE  )  [virtual]

This simply returns the result of GetBlobBoundingRect() as the default action for the base class. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 03/02/95 Returns: DocRect - The rectangle that contains all the nodes selection blobs. Reimplemented in NodeRenderableBounded. Definition at line 809 of file noderend.cpp. { return GetBlobBoundingRect(); }

BOOL NodeRenderable::IsDragged (   )  const [virtual]

Returns a flag saying whether the node is currently being dragged or not Scope: public. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/2003 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE - the node is being dragged Reimplemented from Node. Definition at line 2035 of file noderend.cpp. { return Dragged; }

BOOL NodeRenderable::IsNodeRenderableClass (   )  const [virtual]

Determine if a node is *derived* from the NodeRenderable class. NB. This has nothing to do with the node's renderable flag! Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Returns: TRUE => This node is an instance of NodeRenderable or a derived class. FALSE => otherwise. See also: Node::IsRenderable Reimplemented from Node. Definition at line 422 of file noderend.cpp. { // We are a NodeRenderable, thanks. return TRUE; }

virtual BOOL NodeRenderable::IsSeeThrough (  BOOL  CheckIndirectAttrs  )  [inline, virtual]

Reimplemented in AttrFlatColourFill, AttrFlatTranspFill, AttrLinearColourFill, AttrLinearTranspFill, AttrRadialColourFill, AttrRadialTranspFill, AttrConicalColourFill, AttrConicalTranspFill, AttrSquareColourFill, AttrSquareTranspFill, AttrThreeColColourFill, AttrThreeColTranspFill, AttrFourColColourFill, AttrFourColTranspFill, AttrBitmapColourFill, AttrBitmapTranspFill, AttrTextureColourFill, AttrTextureTranspFill, NodeRenderableInk, and NodeAttribute. Definition at line 1293 of file node.h. { return FALSE; }

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

Indicate that we want to export this class of nodes. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 23/03/94 Parameters: pRender  - A pointer to the current export region (NULL if none) [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 => we always want to export NodeRenderable objects. See also: NodeRenderable::NeedsToRender Reimplemented from Node. Reimplemented in NodeGuideline, Layer, NodeMouldGroup, NodeAttribute, NodeMoulder, NodePath, NodeRenderablePaper, and Spread. Definition at line 361 of file noderend.cpp. { #ifdef DO_EXPORT // If we have the check selection flag on then see if this renderable 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 renderable node and always needs to be exported // unless of course some node overrides this. if (CheckSelected) return (IsSelected() || IsChildOfSelected() || IsParentOfSelected()); else return TRUE; #else return FALSE; #endif }

void NodeRenderable::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 in AttrBevelIndent, AttrBevelLightAngle, AttrBevelContrast, AttrBevelType, AttrBevelLightTilt, AttrBrushType, Chapter, AttrClipView, AttrFillGeometry, AttrFillMappingLinear, AttrFillMappingSin, AttrFillEffectFade, AttrFillEffectRainbow, AttrFillEffectAltRainbow, AttrTranspFillMappingLinear, AttrTranspFillMappingSin, AttrMould, AttrFeather, NodeGrid, NodeGridRect, NodeGridIso, NodeGroup, NodeGuideline, AttrImagesetting, Layer, AttrLineWidth, AttrStrokeColour, AttrStrokeTransp, AttrStartArrow, AttrEndArrow, AttrStartCap, AttrJoinType, AttrMitreLimit, AttrWindingRule, AttrDashPattern, NodeContourController, NodeBlendPath, NodeBrushMaker, NodeBrushPath, NodeClipViewController, NodeMouldGroup, NodeMouldBitmap, NodeMouldPath, NodeRenderableBounded, NodeAnimatingBitmap, NodeBevel, NodeBlender, NodeBlend, NodeBitmap, NodeBrush, NodeClipView, NodeContour, NodeDocument, NodeLiveEffect, NodeLockedEffect, NodeFeatherEffect, NodeMoulder, NodeMould, NodePath, NodeEffect, NodeRegularShape, NodeSimpleShape, AbstractTextChar, TextChar, KernCode, HorizontalTab, EOLNode, TextLine, BaseTextClass, TextStory, NodeRenderablePaper, Page, AttrQuality, Spread, AttrStrokeType, AttrVariableWidth, TemplateAttribute, AttrTxtFontTypeface, AttrTxtBold, AttrTxtItalic, AttrTxtUnderline, AttrTxtAspectRatio, AttrTxtJustification, AttrTxtTracking, AttrTxtFontSize, AttrTxtScript, AttrTxtBaseLine, AttrTxtLeftMargin, AttrTxtRightMargin, AttrTxtFirstIndent, AttrTxtRuler, AttrTxtLineSpace, AttrUser, and AttrWebAddress. Definition at line 566 of file noderend.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeRenderable), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeRenderable)) CopyNodeContents(pNodeCopy); }

virtual void NodeRenderable::RenderAppliedFillBlobs (  RenderRegion *  pRender  )  [inline, virtual]

Reimplemented in NodeRenderableInk. Definition at line 1248 of file node.h. {}

void NodeRenderable::RenderArtisticBlobs (  RenderRegion *  pRender  )  [virtual]

This function is the base class version of a blob rendering function, so it actually does nothing. Artistic blobs are used to display infomation about things such as pressure and other 'artistic' effects. If a node wants to render artistic blobs it should contain a version of this function. 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 in NodeRenderableInk. Definition at line 683 of file noderend.cpp. { }

void NodeRenderable::RenderEffectBlobs (  RenderRegion *  pRender  )  [virtual]

This function is the base class version of a blob rendering function, so it actually does nothing. The fill blobs are the blobs rendered by fills (eg the graduated fill should draw an arrow to show the start and end positions of the fill). A node that wants to render some fill blobs should write a replacement of this function. This function is the base class version of a blob rendering function, so it actually does nothing. The fill blobs are the blobs rendered by fills (eg the graduated fill should draw an arrow to show the start and end positions of the fill). A node that wants to render some fill blobs should write a replacement of this function. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/01/2005 Parameters: pRender  - The region to render the blobs into [INPUTS] See also: BlobManager Reimplemented in NodeRenderableInk. Definition at line 662 of file noderend.cpp. { }

virtual void NodeRenderable::RenderFillBlobs (  RenderRegion *  pRender  )  [inline, virtual]

Reimplemented in AttrFillGeometry, AttrLinearFill, AttrLinearColourFill, AttrLinearTranspFill, AttrRadialFill, AttrRadialColourFill, AttrRadialTranspFill, AttrConicalFill, AttrConicalColourFill, AttrConicalTranspFill, AttrSquareFill, AttrSquareColourFill, AttrSquareTranspFill, AttrThreeColFill, AttrThreeColColourFill, AttrThreeColTranspFill, AttrFourColFill, AttrFourColColourFill, AttrFourColTranspFill, AttrBitmapFill, AttrBitmapColourFill, AttrBitmapTranspFill, AttrTextureColourFill, and AttrTextureTranspFill. Definition at line 1247 of file node.h. {}

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

This function is the base class version of a blob rendering function, so it actually does nothing. Object Blobs are the blobs that allow you to edit the shape of the node. For example, a path would display blobs on all its coords and a Rectangle may put a blob at each corner. 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 in NodeGroup, NodeBlendPath, NodeBrushPath, NodeMouldPath, NodeBevelBegin, NodeBlend, NodeBrush, NodeLockedEffect, NodeMould, NodePath, NodeRegularShape, NodeSimpleShape, AbstractTextChar, CaretNode, EOLNode, TextLine, and TextStory. Definition at line 705 of file noderend.cpp. { }

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

This function is the base class version of a blob rendering function, so it actually does nothing. Overide this function in each of the nodes that require Pen Blobs so draw what it needed. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/94 Parameters: pRender  - the render region to draw your blobs into [INPUTS] Reimplemented in NodePath. Definition at line 746 of file noderend.cpp. { }

SubtreeRenderState NodeRenderable::RenderSubtree (  RenderRegion *  pRender, Node **  ppNextNode = NULL, BOOL  bClip = TRUE )  [virtual]

Virtual function - this function will indicate to the caller whether or not we want to render the given node, according to the information passed in. For this class, it always returns TRUE. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 07/02/94 Parameters: pRender  - A pointer to the current render region (NULL if none) [INPUTS] See also: Node::NeedsToRender Reimplemented from Node. Reimplemented in AttrBrushType, AttrClipView, AttrFeather, NodeGrid, NodeGroup, NodeGuideline, Layer, NodeContourController, NodeClipViewController, NodeMouldGroup, NodeRenderableBounded, NodeAttribute, NodeBevelBegin, NodeBrush, NodeClipView, NodeLiveEffect, NodeLockedEffect, NodeEffect, NodeRenderablePaper, and Spread. Definition at line 338 of file noderend.cpp. { return SUBTREE_ROOTANDCHILDREN; // Else we allow the renderer into the subtree }

void NodeRenderable::RenderTinyBlobs (  RenderRegion *  pRender  )  [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 in NodeGroup, NodeContourController, NodeBrushPath, NodeClipViewController, NodeBevel, NodeBevelBegin, NodeBrush, NodeContour, NodeLockedEffect, NodeMould, NodePath, NodeRegularShape, NodeSimpleShape, AbstractTextChar, EOLNode, TextLine, and TextStory. Definition at line 727 of file noderend.cpp. { }

void NodeRenderable::RenderToolObjectBlobs (  RenderRegion *  pRender  )  [virtual]

This function is the base class version of a blob rendering function, so it actually does nothing. ToolObject blobs are displayed and used by a Node for interaction with a specific tool. They are similar to object blobs, but the big difference is that whereas object blobs are displayed regardless of the current tool (even if you can't use it to edit them), ToolObject blobs are not. The Node should always exercise final control over whether the blobs are active, depending on which tool is in use. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 26 March 2000 Parameters: pRender  the region to render the blobs into. [INPUTS] See also: BlobManager Reimplemented in NodeClipViewController. Definition at line 772 of file noderend.cpp. { }

void NodeRenderable::Select (  BOOL  ReDraw  )  [virtual]

Selects the node. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/94 Parameters: Redraw  - TRUE if you want the blobs to be redrawn for you [INPUTS] Reimplemented in NodeCompound. Definition at line 826 of file noderend.cpp. { // Get the blob manager to draw some blobs if needed if (!IsSelected()) { // It's possible that this node is inside a currently selected node // The rules of select inside say that a selected node cannot have // selected parents or children, so we must go deselect them. // Parents... Node* pNode = FindParent(); while (pNode && pNode->IsNodeRenderableClass()) { ((NodeRenderable*)pNode)->DeSelect(ReDraw); pNode = pNode->FindParent(); } // Children... // This node can only have selected children if it's marked as the parent // of selected children. if (IsParentOfSelected()) { pNode = this->FindFirstDepthFirst(); while (pNode) { if (pNode->IsNodeRenderableClass() && pNode!=this) { ((NodeRenderable*)pNode)->DeSelect(ReDraw); } pNode = pNode->FindNextDepthFirst(this); } } SetSelected(TRUE); if (ReDraw) { // Find the blob manager BlobManager* BlobMgr = GetApplication()->GetBlobManager(); ENSURE( BlobMgr!=NULL, "Blob Manager unexpected not there" ); // Get it to render the blobs of this node BlobMgr->RenderMyBlobsOn(NULL, FindParentSpread(), this); AttrFillGeometry::LastRenderedMesh = NULL; } // Make this node selected and throw away the selection cache GetApplication()->UpdateSelection(); } }

void NodeRenderable::SetDraggedState (  BOOL  bNewState, BOOL  bAndChildren )  [virtual]

Allows you to set the dragged state of this node Scope: public. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/2003 Parameters: NewState  - TRUE to become magnetic, FALSE otherwise [INPUTS] bAndChildren - Recursively set all child nodes the same way -  [OUTPUTS] Returns: - Definition at line 2056 of file noderend.cpp. { Dragged = bNewState; if (bAndChildren) { NodeRenderable* pNode = (NodeRenderable*)FindFirstChild(CC_RUNTIME_CLASS(NodeRenderable)); while (pNode) { pNode->SetDraggedState(bNewState, bAndChildren); pNode = (NodeRenderable*)pNode->FindNext(CC_RUNTIME_CLASS(NodeRenderable)); } } }

BOOL NodeRenderable::ShouldBeRendered (   )  const [virtual]

Work out if the node should be rendered - basically all nodes except NodeRenderable nodes should be rendered. However, some NodeRenderable derived classes should not actually be rendered - for example NodeMouldGroup hides the original un-moulded objects, which should definitely *not* be rendered. This is mainly used during printing where due to complications to do with banding and transparency, we cannot use NeedsToRender() to filter out such nodes, so we use this function instead. NB. This has nothing to do with the node's renderable flag! Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 03/07/95 Returns: TRUE => This node should be rendered FALSE => this node should not be rendered. See also: Node::IsNodeRenderable Reimplemented from Node. Reimplemented in NodeMouldGroup. Definition at line 449 of file noderend.cpp. { // By default we render nodes of this class, and derived nodes. return TRUE; }

Node * NodeRenderable::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 Parameters: -  [INPUTS] [OUTPUTS]  Returns: A copy of the node, or NULL if memory has run 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. Reimplemented from Node. Reimplemented in AttrBevelIndent, AttrBevelLightAngle, AttrBevelContrast, AttrBevelType, AttrBevelLightTilt, AttrBrushType, Chapter, AttrClipView, AttrFlatColourFill, AttrFlatTranspFill, AttrLinearColourFill, AttrLinearTranspFill, AttrRadialColourFill, AttrRadialTranspFill, AttrConicalColourFill, AttrConicalTranspFill, AttrSquareColourFill, AttrSquareTranspFill, AttrThreeColColourFill, AttrThreeColTranspFill, AttrFourColColourFill, AttrFourColTranspFill, AttrBitmapColourFill, AttrBitmapTranspFill, AttrTextureColourFill, AttrFractalColourFill, AttrNoiseColourFill, AttrTextureTranspFill, AttrFractalTranspFill, AttrNoiseTranspFill, AttrFillMappingLinear, AttrFillMappingSin, AttrFillEffectFade, AttrFillEffectRainbow, AttrFillEffectAltRainbow, AttrTranspFillMappingLinear, AttrTranspFillMappingSin, AttrMould, AttrFeather, NodeGrid, NodeGridRect, NodeGridIso, NodeGroup, NodeGuideline, NodeRenderableInk, AttrOverprintLine, AttrOverprintFill, AttrPrintOnAllPlates, Layer, AttrLineWidth, AttrStrokeColour, AttrStrokeTransp, AttrStartArrow, AttrEndArrow, AttrStartCap, AttrJoinType, AttrMitreLimit, AttrWindingRule, AttrDashPattern, NodeContourController, NodeBlendPath, NodeBrushMaker, NodeBrushPath, NodeClipViewController, NodeMouldGroup, NodeMouldBitmap, NodeMouldPath, NodeRenderableBounded, NodeAnimatingBitmap, NodeAttribute, NodeBevel, NodeBevelBegin, NodeBlender, NodeBlend, NodeBitmap, NodeBrush, NodeClipView, NodeContour, NodeDocument, NodeEllipse, NodeLiveEffect, NodeLockedEffect, NodeFeatherEffect, NodeMoulder, NodeMould, NodePath, NodeEffect, NodeRect, NodeRegularShape, NodeSimpleShape, VisibleTextNode, AbstractTextChar, TextChar, KernCode, HorizontalTab, CaretNode, EOLNode, TextLine, BaseTextClass, TextStory, NodeRenderablePaper, Page, AttrQuality, Spread, AttrStrokeType, AttrVariableWidth, TemplateAttribute, StyleReferenceAttribute, AttrTxtFontTypeface, AttrTxtBold, AttrTxtItalic, AttrTxtUnderline, AttrTxtAspectRatio, AttrTxtJustification, AttrTxtTracking, AttrTxtFontSize, AttrTxtScript, AttrTxtBaseLine, AttrTxtLeftMargin, AttrTxtRightMargin, AttrTxtFirstIndent, AttrTxtRuler, AttrTxtLineSpace, AttrUser, and AttrWebAddress. Definition at line 544 of file noderend.cpp. { NodeRenderable* NodeCopy; NodeCopy = new NodeRenderable(); ERRORIF(NodeCopy == NULL, _R(IDE_NOMORE_MEMORY), NULL); CopyNodeContents(NodeCopy); return (NodeCopy); }

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

This is the base class verison of the transform function. This is called to move, scale, rotate etc renderable objects. Each class derived from NodeRenderableInk should write a version of this function that manipulates all the control points in the object and updates its bounding box. See NodePath for an example. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/93 Parameters: Trans  - The transform to apply to the objects [INPUTS] Reimplemented in AttrBevelIndent, AttrBevelLightAngle, AttrBevelContrast, AttrBevelType, AttrBevelLightTilt, AttrBrushType, AttrClipView, AttrLinearFill, AttrRadialFill, AttrConicalFill, AttrSquareFill, AttrThreeColFill, AttrFourColFill, AttrBitmapFill, AttrFractalFill, AttrFeather, NodeGroup, NodeGuideline, AttrLineWidth, NodeContourController, NodeBrushMaker, NodeBrushPath, NodeClipViewController, NodeMouldGroup, NodeRenderableBounded, NodeBevel, NodeBlender, NodeBrush, NodeClipView, NodeContour, NodeLiveEffect, NodeLockedEffect, NodeMoulder, NodeMould, NodePath, NodeRegularShape, NodeSimpleShape, TextStory, and AttrUser. Definition at line 472 of file noderend.cpp. { // By default, just transform all the children TransformChildren(Trans); }

void NodeRenderable::TransformChildren (  TransformBase &   )  [virtual]

Reimplemented in NodeRenderableBounded. Definition at line 480 of file noderend.cpp. { // We have to go through all the child nodes of this node and Transform // all the NodeRenderable objects Node* pCurrent = this -> FindFirstChild(); while (pCurrent != NULL) { // Make sure it is a renderable ink object (not an attribute) if (pCurrent->IsKindOf( CC_RUNTIME_CLASS(NodeRenderable) ) ) // Transform the child node ((NodeRenderable*)pCurrent) -> Transform( Trans ); // Show the hourglass if (ShowHourglass()) { ContinueSlowJob(); } // Find the next object in the group pCurrent = pCurrent -> FindNext(); } }

void NodeRenderable::TransformStretchObject (  const ExtendParams &  ExtParams  )  [virtual]

Perform a stretch on this Node, according to the contents of ExtParams. This function does nothing unless ExtParams uses X_STRETCH or Y_STRETCH. See also: The Extender class. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 01/12/1999 Parameters: ExtParams  description of how this object should stretch. [INPUTS] This  node may be stretched, depending on the flags held within ExtParams. [OUTPUTS] Definition at line 974 of file noderend.cpp. { // x-stretch - translate and stretch this Node. if (ExtParams.fExtendFlags & X_STRETCH) { Trans2DMatrix toOrigin(-ExtParams.doccScaleStart.x, 0); Matrix matStretch( FIXED16( ExtParams.xscale ), FIXED16( 1.0 ) ); Trans2DMatrix stretchX( matStretch ); Trans2DMatrix fromOrigin(ExtParams.doccScaleEnd.x, 0); Transform(toOrigin); Transform(stretchX); Transform(fromOrigin); } // y-stretch - translate and stretch this Node. if (ExtParams.fExtendFlags & Y_STRETCH) { Trans2DMatrix toOrigin(0, -ExtParams.doccScaleStart.y); Matrix matStretch( FIXED16(1.0), FIXED16(ExtParams.yscale) ); Trans2DMatrix stretchY( matStretch ); Trans2DMatrix fromOrigin(0, ExtParams.doccScaleEnd.y); Transform(toOrigin); Transform(stretchY); Transform(fromOrigin); } }

void NodeRenderable::TransformTranslateNoStretchObject (  const ExtendParams &  ExtParams  )  [virtual]

Translate this node so that its extend-centre matches the position it would be in if the node were stretched. The node maintains its aspect ratio. This function does nothing unless ExtParams uses X_STRETCH or Y_STRETCH. See also: The Extender class; FindExtendCentre(). Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 01/12/1999 Parameters: ExtParams  description of how this object should translate/stretch. [INPUTS] This  node will be translated so that extend-centre matches up with where it [OUTPUTS] would be if the node were stretched. Definition at line 1084 of file noderend.cpp. { DocCoord doccRef = FindExtendCentre(); // x-stretch - we translate the Node by the same amount as doccRef under stretching. if (ExtParams.fExtendFlags & X_STRETCH) { Trans2DMatrix transX( ExtParams.doccScaleEnd.x - ExtParams.doccScaleStart.x, 0 ); Transform(transX); // extra translation is difference between stretched and unstretched pDoccRef. INT32 deltaX = (INT32)( (ExtParams.xscale - 1.0) * (doccRef.x - ExtParams.doccScaleStart.x) ); Trans2DMatrix trans2X(deltaX, 0); Transform(trans2X); } // y-stretch - we translate the Node by the same amount as doccRef under stretching. if (ExtParams.fExtendFlags & Y_STRETCH) { Trans2DMatrix transY(0, ExtParams.doccScaleEnd.y - ExtParams.doccScaleStart.y); Transform(transY); // extra translation is difference between stretched and unstretched pDoccRef. INT32 deltaY = (INT32)( (ExtParams.yscale - 1.0) * (doccRef.y - ExtParams.doccScaleStart.y) ); Trans2DMatrix trans2Y(0, deltaY); Transform(trans2Y); } }

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

Translate this Node, according to the offsets and flags defined in ExtParams, and a reference centre, defined by NodeRenderable::FindExtendCentre(). This function does nothing unless ExtParams uses X_EXTEND or Y_EXTEND. See also: The Extender class; FindExtendCentre(). Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 01/12/1999 Parameters: ExtParams  description of how this object should translate. [INPUTS] This  node may be translated, depending on the flags held within ExtParams. [OUTPUTS] Reimplemented in AttrFillGeometry, AttrLinearFill, AttrRadialFill, AttrBitmapFill, and NodePath. Definition at line 1017 of file noderend.cpp. { DocCoord doccCentre = FindExtendCentre(); // x-extension - we move the whole Node; behaviour determined by its centre. if (ExtParams.fExtendFlags & X_EXTEND) { doccCentre.x += ExtParams.doccOffset.x; // first, translate the object by the offset from start- to end- centres. Trans2DMatrix baseXoffset(ExtParams.doccOffset.x, 0); Transform(baseXoffset); // slight fudge here - we only move anything if we're outside a buffer-zone around // the centre (necessary as objects can be misaligned by a millipoint or two). if (doccCentre.x > ExtParams.doccEndCentre.x + ExtParams.xincExtendBuffer) { Trans2DMatrix translateX(ExtParams.xinc, 0); Transform(translateX); } else if (doccCentre.x < ExtParams.doccEndCentre.x - ExtParams.xdecExtendBuffer) { Trans2DMatrix translateX(-ExtParams.xdec, 0); Transform(translateX); } } // y-extension - we move the whole Node; behaviour determined by its centre. if (ExtParams.fExtendFlags & Y_EXTEND) { doccCentre.y += ExtParams.doccOffset.y; // first, translate the object by the offset from start- to end- centres. Trans2DMatrix baseYoffset(0, ExtParams.doccOffset.y); Transform(baseYoffset); // only extend if we're outside the centre's buffer-zone. if (doccCentre.y > ExtParams.doccEndCentre.y + ExtParams.yincExtendBuffer) { Trans2DMatrix translateY(0, ExtParams.yinc); Transform(translateY); } else if (doccCentre.y < ExtParams.doccEndCentre.y - ExtParams.ydecExtendBuffer) { Trans2DMatrix translateY(0, -ExtParams.ydec); Transform(translateY); } } }

---

Member Data Documentation

BOOL NodeRenderable::Dragged [protected]

Definition at line 1297 of file node.h.

---

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

• Kernel/node.h (r1785/r1708)
• Kernel/noderend.cpp (r1785/r1328)

---