NodeRenderableInk Class Reference

This abstract class describes a renderable ink node. A property of Ink nodes is that they should be rendered after their children have been rendered. More...

#include <ink.h>

Inheritance diagram for NodeRenderableInk:

List of all members.

Public Types
enum	SelStateAction { CLEAR, SET, TOGGLE }
Public Member Functions
	NodeRenderableInk ()
	This constructor creates a NodeRenderableInk linked to no other, with all status flags false, and an uninitialised bounding rectangle.
	NodeRenderableInk (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	IsAnObject () const
	For determining quickly if the node is an object.
virtual BOOL	IsSetCandidate () const
	Indicates that NodeRenderableInks are candidates for membership of Attribute gallery set.
virtual BOOL	IsRenderedAsInk () const
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 BOOL	ExportRender (RenderRegion *pRender)
	Custom export code for nodes derived from NodeRenderableInk. So far there is only code for the VectorFileRenderRegion (which is a superclass for the EPS, CMX, and Flash render regions) to allow for the export of stroked shapes.
virtual void	RenderAppliedFillBlobs (RenderRegion *pRender)
	Draws the Fill blobs of an ink object. It does this by calling all the attributes that are its immediate children and asking them to render their Fill Blobs. If any of them happen to be items such as Graduated fills, then blobs will appear.
virtual void	RenderArtisticBlobs (RenderRegion *pRender)
	Draws the Artistic blobs of an ink object. It does this by calling all the attributes that are its immediate children and asking them to render their Artistic Blobs. If any of them happen to be items such as Pressure attributes or some other artistic effect then blobs will appear.
virtual void	RenderEorDrag (RenderRegion *)
	Each class derived from NodeRenderableInk should write a version of this member function. In most cases it will be the same as the Render() member function but some of the nodes (such as groups) need to perform special actions. The function is for drawing the object while it is being dragged about by the selector tool. It should do this with an effective wysiwyg level of 0 so that the drawing is fast.
virtual void	RenderEffectBlobs (RenderRegion *pRender)
	Draws the Effect blobs of an ink object. It does this by calling all the attributes that are its immediate children and asking them to render their Fill Blobs. If any of them happen to be items such as Graduated fills, then blobs will appear.
virtual void	RenderEorDragChildren (RenderRegion *pRender)
	Recursively calls RenderEorDrag for all children of this node, ignoring nodes which have ChildrenAreEorDragRenderedByMe() returning TRUE.
virtual BOOL	ChildrenAreEorDragRenderedByMe ()
virtual void	ClearSubSelection (BOOL ReDraw)
	Goes through the object and clears the selection state of all its blobs. eg a selected path has blobs and each of these blobs can be selected. This clears the blobs selection BUT not the objects selection!
virtual BOOL	CanSelectAsCompoundParent ()
	Ask a node whether or not it's prepared to become selected when one of it's children is clicked on. This function is called in the FindSimple/Compound routines when they are following parent links up the tree from a node which has been "hit". This virtual function should be overridden in derived classes to alter its behaviour.
virtual BOOL	CanSelectAsSimple ()
	Ask a node whether or not it's prepared to become selected when one of it's clicked on. This function is called in the FindSimple routines when they have just detected a "hit" on a node. This virtual function should be overridden in derived classes to alter its behaviour.
virtual BOOL	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	Allows the Node to respond to clicks by selecting its blobs or starting drags etc.
virtual BOOL	OnMouseMove (const DocCoord &, Spread *, ClickModifiers)
	Called by the selector tool for the selected object(s) when the mouse is moved.
virtual BOOL	GetStatusInfo (String_256 **ppStatusText, Cursor **ppStatusCursor)
	Called by the selector tool if either a previous OnMouseMove or OnClick member function call returns TRUE, indicating that the node has some feedback to display when the mous is at the previously passed point.
virtual BOOL	OnBlobPopUp (Spread *, DocCoord, ContextMenu *)
	Allows the Node to respond to popup menu clicks by adding items to the popup menu if required. It also allows the node to prevent the menu appearing at all! This functions should be overridden in the all the NodeRenderableInk classes so that this verion never gets called. Eg the NodePath class might claim the click if it happened over one of its blobs.
virtual BOOL	OnNodePopUp (Spread *, DocCoord, ContextMenu *)
	Allows the Node to respond to popup menu clicks by adding items to the popup menu if required. It also allows the node to prevent the menu appearing at all! This functions should be overridden in the all the NodeRenderableInk classes so that this verion never gets called. Eg the NodePath class might claim the click if it happened over one of its blobs.
virtual void	SelectInRect (const DocRect &Rect, SelStateAction st)
	Helper method for the static fn SelectAllInRect() used by marquee select. This method changes the selection state of this node according to the given bounding rectangle and sel-state action. Most nodes will want to use the default behaviour, which is to select themselves if their bounds lie within the given bounding rectangle. If you want to do something special with the marquee select, then override this method.
void	RedrawObject ()
	Invalidates the Bounding rectangle of the node, causing it to be redrawn.
void	ApplyAttributeToObject (NodeAttribute *Attribute, BOOL Redraw)
	Applys Attribute to the selected node and then if Redraw is TRUE it redraws the node.
BOOL	ApplyAttributes (CCAttrMap *pAttribMap, BOOL RequiredAttrsOnly=FALSE)
	This generates copies of all the attributes in the map, and applies them to this node.
virtual BOOL	RequiresAttrib (CCRuntimeClass *AttribClass, BOOL Search=FALSE)
	To determine if the node requires attribute AttribType to render itself.
virtual BOOL	RequiresAttrib (NodeAttribute *pAttrib, BOOL Search=FALSE)
	To determine if the node requires the pAttr to render itself.
virtual BOOL	CanAttrBeAppliedToMe (CCRuntimeClass *AttrType)
	This fn is not to be confused with RequiresAttrib, it determines if an attribute of type AttrType can be directly applied to this object. The object is assumed to Require the attribute.
virtual NodeRenderableInk *	GetObjectToApplyTo (CCRuntimeClass *AttrType)
	Before applying an attribute to an object this function should be called to return the actual object the attribute should be applied to.
virtual CCRuntimeClass *	GetCurrentAttribGroup ()
	Every Ink object has an associated current attribute group, If an attribute is applied to the object, and it needs to become current then the attribute group specified will get updated.
NodeAttribute *	GetChildAttrOfType (CCRuntimeClass *ReqdAttrib)
	Scans the child attribute block of the node for an attribute with type ReqdAttrib.
BOOL	HasAttrTypesOn (NodeRenderableInk *Object)
	This function returns TRUE if the set of Object's child attribute types are a subset of this objects child attribute types.
BOOL	CopyChildrenAsShapes (Node *pDestin)
	This function scans through all children of this object and asks them to convert themselves to shapes. The shapes are placed as children of the destination node. If the routine fails, all children of the destination will automatically be removed.
virtual BOOL	ReadPostChildrenWeb (BaseCamelotFilter *pFilter)
	This function is called during the importing of the file.
virtual BOOL	ReadPostChildrenNative (BaseCamelotFilter *pFilter)
virtual BOOL	WriteBeginChildRecordsWeb (BaseCamelotFilter *pFilter)
	Begin to write out you child records, in the web format.
virtual BOOL	WriteBeginChildRecordsNative (BaseCamelotFilter *pFilter)
	Begin to write out you child records, in the native format.
virtual BOOL	WriteEndChildRecordsWeb (BaseCamelotFilter *pFilter)
	Finished writing out you child records, in the web format.
virtual BOOL	WriteEndChildRecordsNative (BaseCamelotFilter *pFilter)
	Finished writing out you child records, in the native format.
virtual BOOL	WriteBoundsRecord (BaseCamelotFilter *pFilter)
	Write out a record containing the bounds of this object.
virtual BOOL	WillWriteBounds (BaseCamelotFilter *pFilter)
	Determines if the down/up pair need to be written.
virtual BOOL	AreYouSafeToRender ()
	This function is used by the progressive rendering system & the new file format to determine whether the node is renderable or not.
AttrBrushType *	GetAppliedBrushAttribute ()
	as above
AttrStrokeType *	GetActiveStroke ()
	We may have a stroke attribute applied to us that does not do anything under certain circumstances (zero line width, no accompanying variable width attribute).
virtual NodePath *	GetVariableWidthStrokePath ()
	If we have a variable width stroke applied to us then this will get the path generated by that stroke. This base class version returns NULL, overridden versions must supply their own outline path.
virtual NodePath *	GetSmoothVariableWidthStrokePath ()
virtual BOOL	GetAreaDetails (XLONG *pxlArea, XLONG *pXLPerimeter)
virtual BOOL	CanSupplyDirectBitmap ()
virtual BOOL	GetDirectBitmap (RenderRegion *pRender, LPBITMAPINFO *plpInfo, LPBYTE *plpBits, DocRect *pRect, Matrix *pMat, double *pdRes)
virtual BOOL	RenderDirectBitmapState (RenderRegion *pRender)
BOOL	FindAppliedAttributes (CCAttrMap *pAttribMap, INT32 nMax=5000, INT32 *nFound=NULL, BOOL ExcludeIndirectlyAppliedGLAs=FALSE, BOOL bStrictEffectStatus=TRUE) const
	Searches for all the attributes which apply to "this" ink-node. This routine does NOT render them! Use RenderAppliedAttributes if you want that functionality.
BOOL	FindAppliedAttribute (CCRuntimeClass *AttribType, NodeAttribute **pAttrFound, BOOL bStrict=TRUE)
	Finds the attribute of type 'AttribType' applied to this node.
NodeAttribute *	FindAppliedAttribute (CCRuntimeClass *AttribType, BOOL bExcludeChildAttrs=FALSE, BOOL bStrict=TRUE)
virtual BOOL	IsValidEffectAttr (NodeAttribute *pAttr) const
void	DeleteAppliedAttributes ()
	This function deletes all child attributes from the node which have the same type and value as the attributes applied above the child level. It is useful for Attribute optimisation work.
BOOL	AddChildAttrTypesToSet (AttrTypeSet *pAttrTypeSet)
	A function to return a set of the attribute types of all attribute children of.
virtual NodeRenderableInk *	FindNodeAtPointHelper (const Spread *pSpread, const DocCoord dcPoint)
BOOL	MakeAttributeComplete (Node *Root=NULL, BOOL CheckForDuplicates=TRUE, AttrTypeSet *pAffectedAttrTypes=NULL, BOOL IncludeDefaults=FALSE, BOOL bIncludeEffectAttrs=FALSE)
	This function should be called on a subtree prior to it being moved, either to a new position in the document, or to another document. It is also used to localise attributes; during an ungroup for example.
void	NormaliseAttributes ()
	This function should be called whenever an attribute-complete node is inserted into the tree (whether it's a new node, or a node which has been moved from elsewhere).
BOOL	FactorOutCommonChildAttributes (BOOL Global=FALSE, AttrTypeSet *pAffectedAttrTypes=NULL)
	Scope: public.
BOOL	LocaliseCommonAttributes (BOOL CheckForDuplicates=FALSE, BOOL Global=FALSE, AttrTypeSet *pAffectedAttrTypes=NULL, BOOL RecursiveDownwards=FALSE)
	This function is the opposite of the FactorOutCommonChildAttributes function it copies all attributes common to the compound to each child object within the compound which requires each attribute. The groups common attributes are deleted.
virtual BOOL	BeginBlendStep (BlendNodeParam *pParam)
virtual BOOL	EndBlendStep (BlendNodeParam *pParam)
virtual BOOL	SetParentLayerAsEdited ()
	Mark parent layer as edited. If an ink object as something done to it which changes its appearance then we need to mark the parent layer as edited. In this class we actually do the work as these are visible objects in the tree.
virtual BOOL	IsSeeThrough (BOOL CheckIndirectAttrs)
	Determines whether this node is see through or not. See through in this case does not necessarily mean transparent - eg we could be a no-colour-fill rectangle. This test is useful if you're going to render into a bitmap, which will then be post-processed and plonked on the document (eg Feathering). This way, you can hopefully avoid any performance hit from unnecessary rendering into an alpha-channel bitmap.
Static Public Member Functions
static BOOL	Init ()
	Reads preferences for NodeRenderableInk.
static void	DeselectAll (BOOL RenderBlobs=TRUE, BOOL InformImmediate=TRUE)
	Deselects all the selected objects in the tree, leaving camelot with nothing selected. It also removes the EORed blobs of the objects that were selected at the time of the call.
static void	DeselectAllOnLayer (Layer *Layer)
	Same as DeselectAll except that it only deselects objects on Layer.
static void	SelectAllInRect (DocRect, Spread *, SelStateAction st=SET)
	Selects all the objects that are wholly inside the supplied rectangle. It will draw in all the EORed blobs of the objects that it selects/deselects. rewritten by Simon so that objects on locked layers do not get selected also more optimal. (st parameter etc added by JCF 1.11.94).
static NodeRenderableInk *	FindSimpleAtPoint (Spread *pSpread, DocCoord dcPoint, Node *pHighNode=NULL, Node **ppInterruptNode=NULL)
	Searches the ink-able objects within the given spread for one that lies at or near the given point. The method used to render each candidate object into a small monochrome bitmap, in the reverse order to normal (so that the object normally rendered last is the first to be rendered into the bitmap). The bitmap is examined to see if the object affected the centre or surrounding pixels.
static NodeRenderableInk *	FindSimpleAtPointForColourPicker (Spread *pSpread, DocCoord dcPoint, Pixel32bpp &Pix, Node *pHighNode=NULL, Node **ppInterruptNode=NULL)
	Firstly, this function serves to find the 'ID' of the item that our colour picker is over - which is used to update our mouse cursor. Secondly, it obtains the TRUE 32-BIT RGB index for the pixel that our mouse cursor is over - enabling us to do colour manager/dialog type things. The first part of this routine simply calls FindSimpleAtPointFor - and the second part actually does colour specific work.
static NodeRenderableInk *	FindColourForNodeRenderableAtPoint (Spread *pSpread, DocCoord dcPoint, Pixel32bpp &Pix, Node *pThisNode, AttrFillGeometry *pThisFill)
	The function obtains the TRUE 32-BIT RGB index for the pixel that our mouse cursor is over for the supplied node.
static NodeRenderableInk *	FindCompoundAtPoint (Spread *pSpread, DocCoord dcPoint, Node *pHighNode=NULL)
	This function is similar to NodeRenderableInk::FindSimpleAtPoint, except that.
static NodeRenderableInk *	FindCompoundFromSimple (NodeRenderableInk *pSimpleNode, Node *pSiblingNode=NULL)
	This function will search up the parent links from the given "simple" node looking for a node whose parent is a layer. This guarantees that the returned node will be a genuinely selectable object, for example the routine will return the group node if the given point is within a grouped object.
static NodeRenderableInk *	FindInnerCompound (Node *pLowNode, Node *pHighNode)
static void	ClearAttribMap ()
	Clears out all entries in the attribute map that is being accumulated as click-detection occurs. This has to be done when going down a child-link because then you are entering a deeper scope where the attributes in the map may not apply. It is called from Node::FindNextHitTest.
Protected Member Functions
BOOL	CalculatePathBoundingRect (Path &BoundPath, BOOL DontUseAttrs, DocRect *pRect)
	Calculates the bounding rectangle of a path using GDraw. It will optionally go and find all the attributes that are applied to the path and tell GDraw about these as well (this is the normal way of using it) It can make up sone default attributes if needed as well. This will assume that the path is to be stroked as thin as possible.
virtual Node *	SimpleCopy (void)
	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.
Private Member Functions
void	RenderAppliedAttributes (RenderRegion *pRegion) const
	Searches for all the attributes which apply to "this" ink-node, rendering them into the given render-region. Private helper function for NodeRenderableInk::FindSimpleAtPoint.
void	RenderAppliedClipAttributes (RenderRegion *pRender) const
	Helper method for RenderAppliedAttributes().
BOOL	FactorOutCommonChildAttrHelper (BOOL Global, AttrTypeSet *pAffectedAttrTypes)
	This is a helper function for FactorOutCommonChildAttributes. It finds all attributes which are common to all children of this compound object and adds the common attributes to this node. If Global is TRUE then it recursivly tries to factor out the attributes on all parent compounds. This function does not delete the attributes which are factored out, This is left to the calling function.
BOOL	LocaliseCommonAttrHelper (BOOL CheckForDuplicates, BOOL Global, AttrTypeSet *pAffectedAttrTypes, BOOL RecursiveDownwards=FALSE)
	This function copies all attributes common to the compound to each child object within the compound which requires each attribute.
void	DeleteLocalisedAttributes (BOOL Global=FALSE, AttrTypeSet *pAffectedAttrTypes=NULL)
void	DeleteFactoredOutAttribs (BOOL Global=FALSE, AttrTypeSet *pAffectedAttrTypes=NULL)
	Deletes all child attributes of objects within the compound, which are defined in the groups child attribute block. The attributes of objects which discard their child attributes (like the caret) are only deleted if they have the same value Scope: private.
BOOL	FindReqdAttribs (List *ReqdAttribList)
void	RemoveSuperfluousAttribs ()
BOOL	FindCommonAttributesToFactorOut (CommonAttrSet *CommonAttributeSet)
	This fn does not exist.Finds all attributes common to the compound node.
Static Private Member Functions
static Node *	FindFirstHitTest (Spread *pStartSpread, const DocRect &drClickRect, CCAttrMap *pAttribMap, BOOL bExcludeLayers, Node *pHighNode=NULL)
	Walks the node tree in the reverse order to rendering, which is the order that nodes should be considered for hit-testing.
static Node *	FindNextHitTest (Node *pNode, const DocRect &drClickRect, CCAttrMap *pAttribMap, BOOL bExcludeLayers, BOOL bSkipChildren=FALSE)
	Walks the node tree in the reverse order to rendering, which is the order that nodes should be considered for hit-testing.
static BOOL	HitTestChildren (Node *pNode, const DocRect &drClickRect, BOOL bExcludeLayers)
	Private helper function for Node::FindNextHitTest. This function decides whether FindNextHitTest should go down a child link, which it should if (i) there is a child link; AND (ii) this node isn't a locked or invisible layer if such things should be excluded; (iii) if this node has a bounding rectangle it intersects the click rectangle.
Private Attributes
BOOL	SafeToRender
Static Private Attributes
static BOOL	bUseSmartClicks = TRUE
	If TRUE then click detection is done with rendering, else if FALSE it is done with rectangle intersection. Will be made obsolete once rendering methods are reliable. Defaults to TRUE.
static BOOL	AverageHitColour = FALSE
	If TRUE then click detection is done with rendering, else if FALSE it is done with rectangle intersection. Will be made obsolete once rendering methods are reliable. Defaults to TRUE.
static CCAttrMap *	pAttribMap
static INT32	nFoundAttributes
static INT32	nMaxAttributes

---

Detailed Description

This abstract class describes a renderable ink node. A property of Ink nodes is that they should be rendered after their children have been rendered.

Author:

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

Date:

19/5/93 Base Classes: NodeRenderable, Node, CCObject

See the Node class for an important note about producing derived classes of Node.

See also:

NodeRenderable

Returns:

Errors: -

Definition at line 139 of file ink.h.

---

Member Enumeration Documentation

enum NodeRenderableInk::SelStateAction

Enumerator: CLEAR  SET  TOGGLE  Definition at line 195 of file ink.h. { CLEAR, SET, TOGGLE };

---

Constructor & Destructor Documentation

NodeRenderableInk::NodeRenderableInk (   )

This constructor creates a NodeRenderableInk 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 2228 of file noderend.cpp. : NodeRenderableBounded() { SafeToRender = FALSE; // Not safe to progressively render during importing yet (see ReadPostChildren...) MayBeCached = FALSE; // Definitely not cached }

NodeRenderableInk::NodeRenderableInk (  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 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 2277 of file noderend.cpp. : NodeRenderableBounded(ContextNode, Direction, Locked, Mangled, Marked,Selected) { SafeToRender = FALSE; // Not safe to progressively render during importing yet (see ReadPostChildren...) MayBeCached = FALSE; // Definitely not cached }

---

Member Function Documentation

BOOL NodeRenderableInk::AddChildAttrTypesToSet (  AttrTypeSet *  pAttrTypeSet  )

A function to return a set of the attribute types of all attribute children of. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 1/6/95 Parameters: -  [INPUTS] pAttrTypeSet,:  The attribute types of all this nodes attributes are added to [OUTPUTS] this set. Returns: FALSE if we run out of memory If you are adding an object, which has localised attributes, to a compound node then this function is useful. The attrTypeSet will contain those attributes that need to be localised on the compound before the object is added, and those that need to be factored out after. Returns: Errors: - See also: - Definition at line 4430 of file noderend.cpp. { Node* pChild; // Create a set of the caret's attribute types for (pChild = FindFirstChild(); pChild; pChild = pChild->FindNext()) { if (pChild->IsAnAttribute()) { // Add the attribute's type to the CaretsAttrTypes set if (!(pAttrTypeSet->AddToSet(((NodeAttribute*)pChild)->GetAttributeType()))) return FALSE; // out of mem } } return TRUE; }

BOOL NodeRenderableInk::ApplyAttributes (  CCAttrMap *  pAttribMap, BOOL  RequiredAttrsOnly = FALSE )

This generates copies of all the attributes in the map, and applies them to this node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: pAttribMap  = ptr to the attributes to apply to this node [INPUTS] RequiredAttrsOnly = TRUE is attrs should only be applied if object requires them as determined by the func RequiresAttrib() -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise If RequiredAttrsOnly is TRUE, then only the attrs in the map that are required by the node are applied. RequiresAttrib() works this out for us. Definition at line 3927 of file noderend.cpp. { if (pAttribMap == NULL) return FALSE; BOOL ApplyAttr = TRUE; // iterating all (key, value) pairs for (CMapPtrToPtr::iterator Pos = pAttribMap->GetStartPosition(); Pos!=pAttribMap->GetEndPosition();) { CCRuntimeClass* pType; void* pVal; pAttribMap->GetNextAssoc(Pos,pType,pVal); NodeAttribute* pNodeAttr = (NodeAttribute *)pVal; if (pNodeAttr->CanBeAppliedToObject()) { if (RequiredAttrsOnly) ApplyAttr = RequiresAttrib(pNodeAttr); if (ApplyAttr) { Node* pNode = pNodeAttr->SimpleCopy(); if (pNode != NULL) { pNode->AttachNode(this,FIRSTCHILD); // Ilan // Supply nodes geometry to attributes which require it ((NodeAttribute*)pNode)->LinkToGeometry(this); } } } } // This will remove all the redundant attributes that have been attached to the node NormaliseAttributes(); return TRUE; }

void NodeRenderableInk::ApplyAttributeToObject (  NodeAttribute *  Attribute, BOOL  Redraw )

Applys Attribute to the selected node and then if Redraw is TRUE it redraws the node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 11/11/93 Parameters: Attribute,:  The Attribute to apply to the object [INPUTS] Redraw: Flag indicating if the object should be redrawn after the attribute is added. -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 3901 of file noderend.cpp. { Attribute->AttachNode(this, FIRSTCHILD); if (Redraw) RedrawObject(); // Redraw the node }

BOOL NodeRenderableInk::AreYouSafeToRender (   )  [virtual]

This function is used by the progressive rendering system & the new file format to determine whether the node is renderable or not. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/9/96 Parameters: -  [INPUTS] Returns: TRUE means yes, FALSE means no The base class assumes that the node IS safe to render, as these are the most common See also: CanWriteChildrenWeb(), WritePreChildrenWeb() Reimplemented from Node. Reimplemented in NodeGroup. Definition at line 4570 of file noderend.cpp. { return SafeToRender; }

virtual BOOL NodeRenderableInk::BeginBlendStep (  BlendNodeParam *  pParam  )  [inline, virtual]

Definition at line 392 of file ink.h. { return TRUE; }

BOOL NodeRenderableInk::CalculatePathBoundingRect (  Path &  BoundPath, BOOL  DontUseAttrs, DocRect *  pRect )  [protected]

Calculates the bounding rectangle of a path using GDraw. It will optionally go and find all the attributes that are applied to the path and tell GDraw about these as well (this is the normal way of using it) It can make up sone default attributes if needed as well. This will assume that the path is to be stroked as thin as possible. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/94 Parameters: BoundPath  - The path to calculate the bounding rectangle of [INPUTS] DontUseAtrrs - TRUE if we do not want to apply the attributes to the path when calculating its bounds pRect  - Will hold the paths bounding rect if everything worked [OUTPUTS] Returns: TRUE if it worked, FALSE if it failed Errors: GDraw can fail when calculating bounding rects, so beware See also: NodeRenderableBounded::GetBoundingRect Definition at line 3431 of file noderend.cpp. { // Check and initialise output. ERROR3IF(pRect == 0, "NodeRenderableInk::CalculatePathBoundingRect: null output"); pRect->MakeEmpty(); // Something to put the new bounding rect into DocRect NewBoundingRect; BOOL GDrawResult = TRUE; GDrawContext *GD = GRenderRegion::GetStaticDrawContext(); if (GD == NULL) return(FALSE); // do we need to use the attrs if (DontUseAttrs) { // here we are not interested in the attributes // Find out what the paths bounding rect is now RECT rectTmp; GDrawResult = GD->CalcStrokeBBox((POINT*)BoundPath.GetCoordArray(), BoundPath.GetVerbArray(), BoundPath.GetNumCoords(), &rectTmp, BoundPath.IsFilled, 0, CAPS_ROUND, JOIN_ROUND, NULL); if ( rectTmp.left>rectTmp.right || rectTmp.top>rectTmp.bottom ) return false; NewBoundingRect = DocRect( rectTmp.left, rectTmp.top, rectTmp.right, rectTmp.bottom ); } else { // First find all attributes applied to this node... // 30 is a default value - this will grow if it needs more space CCAttrMap AttribMap(30); if (FindAppliedAttributes(&AttribMap)) { void* pLineColour = NULL; AttribMap.Lookup( CC_RUNTIME_CLASS(AttrStrokeColour),pLineColour); if (pLineColour && (*((AttrStrokeColour*)pLineColour)->GetStartColour() == COLOUR_NONE) || !BoundPath.IsStroked) { // This path is not stroked, so we won't bother with any of the attributes // applied to it RECT rectTmp; GDrawResult = GD->CalcStrokeBBox((POINT*)BoundPath.GetCoordArray(), BoundPath.GetVerbArray(), BoundPath.GetNumCoords(), &rectTmp, BoundPath.IsFilled, 0, CAPS_ROUND, JOIN_ROUND, NULL); if ( rectTmp.left>rectTmp.right || rectTmp.top>rectTmp.bottom ) return false; NewBoundingRect = DocRect( rectTmp.left, rectTmp.top, rectTmp.right, rectTmp.bottom ); } else { // Extract the info we need from the applied attributes void* pLineWidth = NULL; AttribMap.Lookup( CC_RUNTIME_CLASS(AttrLineWidth),pLineWidth); ENSURE(pLineWidth,"NodePath::GetBoundingRect can't find LineWidth"); // if we did not get a line width, fail if (!pLineWidth) return FALSE; // The Start cap void* pStartCap = NULL; AttribMap.Lookup( CC_RUNTIME_CLASS(AttrStartCap),pStartCap); #ifdef _DEBUG if (pStartCap == 0) TRACE( _T("NodeRenderableInk::CalculatePathBoundingRect: can't find StartCap\n")); #endif // The join style void* pJoinType = NULL; AttribMap.Lookup( CC_RUNTIME_CLASS(AttrJoinType),pJoinType); #ifdef _DEBUG if (pJoinType == 0) TRACE( _T("NodeRenderableInk::CalculatePathBoundingRect: can't find JoinType\n")); #endif if(pStartCap != NULL && pJoinType != NULL && pLineWidth != NULL) { // Now pass those values to Gavin along with the path for a bounds calculation RECT rectTmp; GDrawResult = GD->CalcStrokeBBox((POINT*)BoundPath.GetCoordArray(), BoundPath.GetVerbArray(), BoundPath.GetNumCoords(), &rectTmp, BoundPath.IsFilled, ((AttrLineWidth*)pLineWidth)->Value.LineWidth, (CapStyles)((AttrStartCap*)pStartCap)->Value.StartCap, (JoinStyles)((AttrJoinType*)pJoinType)->Value.JoinType, NULL //Pointer to dash pattern attribute ); if ( rectTmp.left>rectTmp.right || rectTmp.top>rectTmp.bottom ) return false; NewBoundingRect = DocRect( rectTmp.left, rectTmp.top, rectTmp.right, rectTmp.bottom ); } } } } // Make sure Gavin did not screw up. if (!NewBoundingRect.IsValid()) // Set it to TRUE, as this means it went wrong in Gavin Talk. GDrawResult = TRUE; // see if GDraw worked (It returns FALSE when it works!) if (GDrawResult == FALSE) { // update the rectangle *pRect = NewBoundingRect; return TRUE; } // to get here, something must have failed return FALSE; }

BOOL NodeRenderableInk::CanAttrBeAppliedToMe (  CCRuntimeClass *  AttrType  )  [virtual]

This fn is not to be confused with RequiresAttrib, it determines if an attribute of type AttrType can be directly applied to this object. The object is assumed to Require the attribute. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/95 Parameters: AttrType,:  The type of the attribute. It is a type, rather than an [INPUTS] instance because this function needs to be called from the Localise/Factor out routines which operate on attribute types. Returns: TRUE if an attribute of AttrType can be applied to this object, FALSE otherwise. The base class fn returns TRUE. Certain attributes cannot be directly applied to specific nodes (even though they require the attribute to render). eg. LineSpacing attributes cannot be applied to text character objects. This function is called by the GetObjectToApplyTo virtual function. Returns: Errors: - See also: NodeRenderableInk::GetObjectToApplyTo Reimplemented in NodeBevel, NodeClipView, and VisibleTextNode. Definition at line 4064 of file noderend.cpp. { return TRUE; }

BOOL NodeRenderableInk::CanSelectAsCompoundParent (   )  [virtual]

Ask a node whether or not it's prepared to become selected when one of it's children is clicked on. This function is called in the FindSimple/Compound routines when they are following parent links up the tree from a node which has been "hit". This virtual function should be overridden in derived classes to alter its behaviour. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the node will allow itself to be selected when one of it's children has been "hit" FALSE otherwise Errors: - See also: NodeRenderableInk::FindSimpleAtPoint; NodeRenderableInk::FindCompoundAtPoint Reimplemented in NodeLiveEffect, and NodeLockedEffect. Definition at line 978 of file hittest.cpp. { // Virtual base-class function returns TRUE always. // Override this function in your class. return TRUE; }

BOOL NodeRenderableInk::CanSelectAsSimple (   )  [virtual]

Ask a node whether or not it's prepared to become selected when one of it's clicked on. This function is called in the FindSimple routines when they have just detected a "hit" on a node. This virtual function should be overridden in derived classes to alter its behaviour. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the node will allow itself to be selected when it has been "hit" FALSE otherwise Errors: - See also: NodeRenderableInk::FindSimpleAtPoint; NodeRenderableInk::FindCompoundAtPoint Reimplemented in NodeBlender. Definition at line 1007 of file hittest.cpp. { // Virtual base-class function returns TRUE always. // Override this function in your class. return TRUE; }

virtual BOOL NodeRenderableInk::CanSupplyDirectBitmap (   )  [inline, virtual]

Reimplemented in NodeBitmap, NodeBitmapEffect, NodeLockedEffect, and NodeFeatherEffect. Definition at line 260 of file ink.h. {return FALSE;}

BOOL NodeRenderableInk::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: This class's implementation always returns TRUE - i.e. NodeRenderableInks should be transformed by default. See also: NodeRenderable::CanTransform Reimplemented from NodeRenderable. Definition at line 2343 of file noderend.cpp. { return TRUE; }

virtual BOOL NodeRenderableInk::ChildrenAreEorDragRenderedByMe (   )  [inline, virtual]

Reimplemented in NodeContourController, NodeClipViewController, and NodeMouldGroup. Definition at line 179 of file ink.h. { return FALSE; }

void NodeRenderableInk::ClearAttribMap (   )  [static]

Clears out all entries in the attribute map that is being accumulated as click-detection occurs. This has to be done when going down a child-link because then you are entering a deeper scope where the attributes in the map may not apply. It is called from Node::FindNextHitTest. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 31/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: Node::FindNextHitTest Definition at line 1293 of file hittest.cpp. { pAttribMap->RemoveAll(); nFoundAttributes = 0; }

void NodeRenderableInk::ClearSubSelection (  BOOL  ReDraw  )  [virtual]

Goes through the object and clears the selection state of all its blobs. eg a selected path has blobs and each of these blobs can be selected. This clears the blobs selection BUT not the objects selection! Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 4/11/93 Parameters: ReDraw  - TRUE if the selection should be redrawn [INPUTS] Definition at line 3117 of file noderend.cpp. { // Base class does nothing }

BOOL NodeRenderableInk::CopyChildrenAsShapes (  Node *  pDestin  )

This function scans through all children of this object and asks them to convert themselves to shapes. The shapes are placed as children of the destination node. If the routine fails, all children of the destination will automatically be removed. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: pDestin  = a pointer to a tree node to place the shapes. [INPUTS] -  [OUTPUTS] Returns: TRUE if a copy of the children of this parent has been taken FALSE if failed. Definition at line 4465 of file noderend.cpp. { ERROR2IF(pDestin==NULL,FALSE,"pDestin==NULL in CopyChildrenAsShapes"); // ok lets get the subtree to become a bunch of nodepaths CopyBecomeA ParamBecomeA(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL); // Set the context node ParamBecomeA.SetContextNode(pDestin); // now scan the children and get them to do their stuff Node* pNode = FindFirstChild(); while (pNode!=NULL) { if (pNode->CanBecomeA(&ParamBecomeA)) { if (!pNode->DoBecomeA(&ParamBecomeA)) { pDestin->CascadeDelete(); return FALSE; } } pNode=pNode->FindNext(); } return TRUE; }

void NodeRenderableInk::DeleteAppliedAttributes (   )

This function deletes all child attributes from the node which have the same type and value as the attributes applied above the child level. It is useful for Attribute optimisation work. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 4365 of file noderend.cpp. { Node* pChild = FindFirstChild(); Node* pFirstChild = pChild; // Temporarily unlink the children so that we can easily find applied attributes which // exclude the child attribs Child = NULL; NodeAttribute* pAppliedAttr; NodeAttribute* pChildAttr; while (pChild != NULL) { if (pChild->IsAnAttribute()) { pChildAttr = (NodeAttribute*)pChild; if (FindAppliedAttribute((pChildAttr->GetAttributeType()), &pAppliedAttr)) { if (pAppliedAttr) { // Test to see if the attributes have the same value if ((IS_SAME_CLASS(pAppliedAttr, pChildAttr ))) { if ((*pAppliedAttr)==(*pChildAttr)) { pChildAttr->CascadeDelete(); // Delete the attribute delete pChildAttr; } } } } } pChild = pChild->FindNext(); } // Restore the children pChild = pFirstChild; }

void NodeRenderableInk::DeleteFactoredOutAttribs (  BOOL  Global = FALSE, AttrTypeSet *  pAffectedAttrTypes = NULL )  [private]

Deletes all child attributes of objects within the compound, which are defined in the groups child attribute block. The attributes of objects which discard their child attributes (like the caret) are only deleted if they have the same value Scope: private. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/95 Parameters: Global,:  TRUE indicates that we should delete the attributes on all [INPUTS] parent compound nodes as well as this node's attributes pAffectedAttrTypes: An optional set of attribute types. If this is specified then we only consider deleting those attributes which have a type which is in this set. Definition at line 1053 of file ndoptmz.cpp. { Node* pGroupNode = FindFirstChild(); while(pGroupNode!=NULL) { // Karim 30/08/2000 // Non-optimisable attributes, like feathers and names, // must not be automatically deleted - only automatically delete optimisable ones. if (pGroupNode->IsAnAttribute() && ((NodeAttribute*)pGroupNode)->ShouldBeOptimized()) { NodeAttribute* pGroupAttr = (NodeAttribute*)pGroupNode; CCRuntimeClass* GrouptAttrType = pGroupAttr->GetAttributeType(); if (pAffectedAttrTypes==NULL || pAffectedAttrTypes->InSet(GrouptAttrType)) { // delete this group attr type from all child objects of this group // BUT if obj discards child attrs only delete attr if it also has same value for (Node* pNode=FindFirstChild(); pNode!=NULL; pNode=pNode->FindNext()) { if (pNode->IsAnObject()) { NodeRenderableInk* pObject = (NodeRenderableInk*)pNode; NodeAttribute* pDeadAttr = pObject->GetChildAttrOfType(GrouptAttrType); if (pDeadAttr!=NULL) { // This code used to only test the attribute for equality if pObject // returned TRUE from DiscardsAttributeChildren, otherwise it would // just assume that they are identical and delete it. // The DiscardAttributeChildren checks are now done elsewhere so // this code now just assumes it can delete any attributes that have // got this far. // This optimisation relies on the tree being in a "legal" state // at the start (i.e. correctly optimised) and also helps to correct // problems where attributes may have been incorrectly left on children // (though such "corrections" may change the appearance of the document). pDeadAttr->CascadeDelete(); delete pDeadAttr; } } } } } pGroupNode = pGroupNode->FindNext(); } // Do we need to delete any parent compound's attributes if (Global) { Node* pParent = FindParent(); if (pParent && (pParent->IsCompound())) { // We need to delete the parent's attributes first (Recursive bit) ((NodeRenderableInk*)pParent)->DeleteFactoredOutAttribs(Global, pAffectedAttrTypes); } } }

void NodeRenderableInk::DeleteLocalisedAttributes (  BOOL  Global = FALSE, AttrTypeSet *  pAffectedAttrTypes = NULL )  [private]

Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/95 Parameters: Global,:  TRUE indicates that we should delete the attributes on all [INPUTS] parent compound nodes as well as this node's attributes pAffectedAttrTypes: An optional set of attribute types. If this is specified then we only consider deleting those attributes which have a type which is in this set. Scope: private See also: NodeRenderableInk::LocaliseCommonAttributes Definition at line 978 of file ndoptmz.cpp. { // Do we need to delete any parent compound's attributes if (Global) { Node* pParent = FindParent(); if (pParent && pParent->IsCompound()) { // We need to localise the parent's attributes first (Recursive bit) ((NodeRenderableInk*)pParent)->DeleteLocalisedAttributes(Global, pAffectedAttrTypes); } } // Delete all moved attributes Node* Next; Node* Current = FindFirstChild(); while (Current != NULL && !Current->IsAnObject()) { Next = Current->FindNext(); if (Current->IsAnAttribute()) { BOOL DeleteAttr = TRUE; if (pAffectedAttrTypes) { // Only delete the attribute if it has been localised if (!(pAffectedAttrTypes->InSet(((NodeAttribute*)Current)->GetAttributeType()))) DeleteAttr = FALSE; } if (DeleteAttr) { // Die // Ilan 19/04/00 // More generally speaking, all attributes which returned FALSE in their ShouldBeOptimized() // calls, will not have been localised to the child nodes during DoLocaliseCommonAttributes(). // Hence don't want to delete these attributes, they must remain attached to the group node // which we are ungrouping so that they are present on an UNDO of a OpUngroup // Attributes in this category include Feather attibutes and TemplateAttributes at present // if (!Current->IsKindOf(CC_RUNTIME_CLASS(TemplateAttribute))) if( ((NodeAttribute*)Current)->ShouldBeOptimized()) { Current->CascadeDelete(); delete Current; } } } Current = Next; } }

void NodeRenderableInk::DeselectAll (  BOOL  RenderBlobs = TRUE, BOOL  InformImmediate = TRUE )  [static]

Deselects all the selected objects in the tree, leaving camelot with nothing selected. It also removes the EORed blobs of the objects that were selected at the time of the call. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/93 Parameters: RenderBlobs,:  Should blobs be rendered [INPUTS] InformImmediate - TRUE if the SelChanged message should be broadcast immediatly FALSE if it should be saved until the end of the operation Definition at line 3570 of file noderend.cpp. { // Find the selected objects in the tree; SelRange* Selected = GetApplication()->FindSelection(); ENSURE( Selected!=NULL, "Selection object is null in DeselectAll()"); // Find first selected node Node* pFirstSelectedNode = Selected->FindFirst(); // If there is a selection, EOR blobs off, deselect nodes, and inform everybody if (pFirstSelectedNode != NULL) { // Go though and render all the EOR blobs off the screen if (RenderBlobs) { // Find the Blob Manager BlobManager* BlobMgr = GetApplication()->GetBlobManager(); ENSURE( BlobMgr!=NULL, "Blob Manager unexpectedly not there."); // Render all the blobs BlobMgr->RenderOff(NULL, pFirstSelectedNode->FindParentSpread()); } // and clear the object selection Node* pNode = pFirstSelectedNode; while(pNode) { // Deselect the object //ENSURE( pNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderable)), "Selected Node not renderable"); //((NodeRenderable*)pNode)->DeSelect(FALSE); if (pNode->IsNodePath()) ((NodePath*)pNode)->InkPath.ClearSubSelection(); /* // DMc // Deselect all nodes under node Node * pSubNode = pNode->FindFirstDepthFirst(); while (pSubNode) { pSubNode->SetSelected(FALSE); if (pSubNode->IsNodePath()) { ((NodePath*)pSubNode)->InkPath.ClearSubSelection(); } pSubNode = pSubNode->FindNextDepthFirst(pNode); } */ // Deselect the node itself pNode->SetSelected(FALSE); // Find the next node pNode = Selected->FindNext(pNode); } // Selection cache is no longer valid, so update and tell everyone that it has changed Selected->Update(InformImmediate); } }

void NodeRenderableInk::DeselectAllOnLayer (  Layer *  Layer  )  [static]

Same as DeselectAll except that it only deselects objects on Layer. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/1/94 Parameters: Layer,:  The layer on which to deselect objects [INPUTS] See also: NodeRenderableInk::DeselectAll Definition at line 3645 of file noderend.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR3IF(Layer == NULL,"Layer == NULL"); if (Layer == NULL) return; ERROR3IF(Layer->FindParent() == NULL,"Layer has no parent"); if (Layer->FindParent() == NULL) return; ERROR3IF(!IS_A(Layer->FindParent(),Spread),"The parent of a layer was not a spread"); if (!IS_A(Layer->FindParent(),Spread)) return; // if the layer has no children, return immediately (otherwise the range screws things up by // giving nodes from other layers to deselect) - MarkN 11/1/95 if (Layer->FindFirstChild() == NULL) return; // Find the layer's spread Spread *pSpread = (Spread*)Layer->FindParent(); // Set up a range of the selected object in this layer // RangeControl rc = { TRUE, FALSE }; Range SelectedRange(Layer->FindFirstChild(),NULL,RangeControl(TRUE,FALSE)); Node* CurrentNode = SelectedRange.FindFirst(); // See if there was anything selected in the first place if (CurrentNode != NULL) { // Go and find the Blob Manager BlobManager* BlobMgr = GetApplication()->GetBlobManager(); ENSURE( BlobMgr!=NULL, "There is no blob manager - Impossible!"); if (BlobMgr==NULL) return; // Go through all the regions and rub out all the blobs RenderRegion* pRegion = DocView::RenderOnTop( NULL, pSpread, ClippedEOR ); while (pRegion) { // Find out the rect for this render region DocRect Rect = pRegion->GetRegionRect(); if ( (Rect.IsValid()) && (!Rect.IsEmpty()) ) { // Find the first node in the selection range CurrentNode = SelectedRange.FindFirst(); // Find all the selected nodes in the tree while (CurrentNode != NULL) { // Rub the blobs off the screen for this node in this region ENSURE( CurrentNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderable)), "Node was not renderbale"); BlobMgr->RenderMyBlobs(&Rect, pSpread, (NodeRenderable*)CurrentNode); // Find the next selected object on the layer CurrentNode = SelectedRange.FindNext(CurrentNode); } } // Thats all the bits deselected for that render region, give me the next one please pRegion = DocView::GetNextOnTop( NULL ); } // Now go though the selected nodes on the layer and deselect them CurrentNode = SelectedRange.FindFirst(); while (CurrentNode != NULL) { // Make it unselected //((NodeRenderable*)CurrentNode)->DeSelect( FALSE ); CurrentNode->SetSelected(FALSE); // and find the next one CurrentNode = SelectedRange.FindNext(CurrentNode); } // Selection cache is no longer valid GetApplication()->Selection->Update(TRUE); } #endif }

virtual BOOL NodeRenderableInk::EndBlendStep (  BlendNodeParam *  pParam  )  [inline, virtual]

Reimplemented in NodeContourController. Definition at line 395 of file ink.h. { return TRUE; }

BOOL NodeRenderableInk::ExportRender (  RenderRegion *  pRender  )  [virtual]

Custom export code for nodes derived from NodeRenderableInk. So far there is only code for the VectorFileRenderRegion (which is a superclass for the EPS, CMX, and Flash render regions) to allow for the export of stroked shapes. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/00 Parameters: pRender  - A pointer to the render region being used for the export. [INPUTS] Returns: TRUE - The node was exported using this function. FALSE - There is no custom export code for this node type. Reimplemented from Node. Reimplemented in NodeGroup, NodeGuideline, NodeContourController, NodeBlendPath, NodeClipViewController, NodeMouldGroup, NodeMouldPath, NodeBevel, NodeBlender, NodeBlend, NodeBitmap, NodeMoulder, NodeMould, NodeRegularShape, TextChar, KernCode, HorizontalTab, CaretNode, EOLNode, and TextStory. Definition at line 4738 of file noderend.cpp. { // The return value. BOOL Result = FALSE; // Is this a FlashRenderRegion? if ( pRender->IsKindOf ( CC_RUNTIME_CLASS ( FlashRenderRegion ) ) ) { // Cast the render region pointer to be a pointer to a vector file render region. FlashRenderRegion *pFlash = static_cast<FlashRenderRegion*> ( pRender ); // Call the appropriate method in the vector file render region class. Result = pFlash->ExportRenderableNode ( this ); } return Result; }

BOOL NodeRenderableInk::FactorOutCommonChildAttrHelper (  BOOL  Global, AttrTypeSet *  pAffectedAttrTypes )  [private]

This is a helper function for FactorOutCommonChildAttributes. It finds all attributes which are common to all children of this compound object and adds the common attributes to this node. If Global is TRUE then it recursivly tries to factor out the attributes on all parent compounds. This function does not delete the attributes which are factored out, This is left to the calling function. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/95 Parameters: Global,:  When TRUE we recursively factor out attributes in all parent compounds [INPUTS] of the CompoundObject (Bottom up) pAffectedAttrTypes: An optional set of attribute types. If this is specified then we only consider factoring out those attributes which have a type which is in this set. Parameters: -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 753 of file ndoptmz.cpp. { // This function should only ever get called on a compound object ENSURE(IsCompound(), "FactorOutCommonChildAttributes called on a non compound object"); CommonAttrSet CommonAttributeSet; // A list of CommonAttributeItems if (!FindCommonAttributesToFactorOut(&CommonAttributeSet)) // Ignores attr discard nodes { return FALSE; } NodeAttribute* pFactoredOutAttr; // Ok let's add the common attributes to the first child of the group CommonAttributeItem* pCommonAttr; for (pCommonAttr = (CommonAttributeItem*)CommonAttributeSet.GetHead(); pCommonAttr != NULL; pCommonAttr = (CommonAttributeItem*)CommonAttributeSet.GetNext(pCommonAttr)) { // Is the common attribute an attribute which should be factored out ? if (!pAffectedAttrTypes || (pAffectedAttrTypes->InSet(pCommonAttr->pAttr->GetAttributeType())) ) { //pCommonAttr->pAttr->MoveNode(this, FIRSTCHILD); // Take a copy of the node and insert it as a first child pFactoredOutAttr = (NodeAttribute*)(pCommonAttr->pAttr->SimpleCopy()); if (!pFactoredOutAttr) return FALSE; pFactoredOutAttr->AttachNode(this, FIRSTCHILD, TRUE, FALSE); } } // The CommonAttributeSet is no longer required CommonAttributeSet.DeleteAll(); // Do we need to factor out the parents attributes ? if (Global) { Node* pParent = FindParent(); if (pParent && (pParent->IsCompound())) { // We need to localise the parent's attributes first (Recursive bit) if (!(((NodeRenderableInk*)pParent)->FactorOutCommonChildAttrHelper(TRUE, pAffectedAttrTypes))) { return FALSE; // Failed } } } return TRUE; // Success }

BOOL NodeRenderableInk::FactorOutCommonChildAttributes (  BOOL  Global = FALSE, AttrTypeSet *  pAffectedAttrTypes = NULL )

Scope: public. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 2/8/94 Parameters: Global,:  When TRUE we recursively factor out attributes in all parent compounds [INPUTS] of the CompoundObject (Bottom up) pAffectedAttrTypes: An optional set of attribute types. If this is specified then we only consider factoring out those attributes which have a type which is in this set. Parameters: TRUE  if successful, FALSE otherwise (out of memory) [OUTPUTS] Returns: This function finds all attributes which are common to all children of this compound object, adds the common attributes to this node and deletes them from its children. If the compound contains a node which can discard its attributes (like the caret) then its attributes are not considered when factoring out. Returns: Errors: - Document: atroptmz.doc See also: - Definition at line 703 of file ndoptmz.cpp. { // This function should only ever get called on a compound object ENSURE(IsCompound(), "FactorOutCommonChildAttributes called on a non compound object"); // Try to factor out the neccessary attributes if (!FactorOutCommonChildAttrHelper(Global, pAffectedAttrTypes)) { // Tidyup then return FAIL DeleteLocalisedAttributes(Global, pAffectedAttrTypes); // tidyup return FALSE; // Failed } else { // The only thing that remains now is to delete all remaining factored out attributes DeleteFactoredOutAttribs(Global, pAffectedAttrTypes); } return TRUE; // Success }

NodeAttribute * NodeRenderableInk::FindAppliedAttribute (  CCRuntimeClass *  AttribType, BOOL  bExcludeChildAttrs = FALSE, BOOL  bStrict = TRUE )

Definition at line 4294 of file noderend.cpp. { // Made more efficient by Simon 09/06/95 // *pAttrFound = ScanForNearestAttrib(AttribType, TRUE); // if (*pAttrFound) // return TRUE; // else // return FALSE; // Restored 06/01/2005 by Phil // FindFirst/PrevAppliedAttr have been made more efficient // And let's try to only have ONE way of scanning for applied attributes so we only // have to deal with ONE set of bugs... // // // Repeat the following loop for all attributes we encounter in the tree. NodeAttribute* pAttrib = NULL; if (bExcludeChildAttrs) pAttrib = NodeAttribute::FindPrevAppliedAttr(this); else pAttrib = NodeAttribute::FindFirstAppliedAttr(this); while (pAttrib) { if (pAttrib->GetAttributeType() == AttribType) { // If the attr is an effect attr // and it is in my child list // and I don't allow this type of attr to be an effect // Then continue looking // Else return it // if (!(pAttrib->FindParent()==this && pAttrib->IsEffectAttribute() && !this->IsValidEffectAttr(pAttrib))) // return pAttrib; if (pAttrib->FindParent()!=this) return pAttrib; if (bStrict) { if (pAttrib->IsEffectAttribute() == this->IsValidEffectAttr(pAttrib)) return pAttrib; } else if (!(pAttrib->IsEffectAttribute() && !this->IsValidEffectAttr(pAttrib))) return pAttrib; } pAttrib = NodeAttribute::FindPrevAppliedAttr(pAttrib); } return NULL; }

BOOL NodeRenderableInk::FindAppliedAttribute (  CCRuntimeClass *  AttribType, NodeAttribute **  ppAttr, BOOL  bStrict = TRUE )

Finds the attribute of type 'AttribType' applied to this node. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The attribute of type 'AttribType' applied to this node. Errors: - See also: NodeRenderableInk::FindAppliedAttributes Definition at line 4287 of file noderend.cpp. { NodeAttribute* pAttr = FindAppliedAttribute(AttribType, FALSE, bStrict); if (ppAttr) *ppAttr = pAttr; return (pAttr!=NULL); }

BOOL NodeRenderableInk::FindAppliedAttributes (  CCAttrMap *  pAttribMap, INT32  nMax = 5000, INT32 *  pnFound = NULL, BOOL  ExcludeIndirectlyAppliedGLAs = FALSE, BOOL  bStrictEffectStatus = TRUE )  const

Searches for all the attributes which apply to "this" ink-node. This routine does NOT render them! Use RenderAppliedAttributes if you want that functionality. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: pAttribMap  Map table to fill in with attribute details. This table stores [INPUTS] Key,Value tuples of the form (CCRuntimeClass*, NodeAttribute*). You can use the normal CMap Lookup function to extract the pointer to an attribute from the map, eg. Lookup(CC_RUNTIME_CLASS(NodeAttrFill),pAttrib); nMax The maximum number of attribute types that can be found pnFound Pointer to the number already in the Map. This param can be used in conjunction with nMax to make the scan stop as soon as the required number of attributes have been found. (Defaults cause whole tree scan.) ExcludeIndirectlyAppliedGLAs - ensures that this map won't include a pointer to a geometry linked attribute which is not directly linked to this nodes geometry (ie exclude parent GLA's) bStrictEffectStatus - TRUE when non-effect attrs are ignored in compound that allow effect attrs FALSE when non-effect attrs are allowed throughout -  [OUTPUTS] Returns: TRUE if attributes were successfully found FALSE otherwise (if no attributes were found) Errors: - See also: NodeRenderableInk::RenderAppliedAttributes NodeAttribute::FindFirstAppliedAtt NodeAttribute::FindPrevAppliedAtt Definition at line 1504 of file hittest.cpp. { // Precondition checks ERROR2IF(pAttribMap == 0, FALSE, "FindAppliedAttributes passed null map"); // Find the closest attribute applied to "this" node... NodeAttribute* pAttrib = NodeAttribute::FindFirstAppliedAttr((Node*)this); if (pAttrib == 0) return FALSE; // Get variables ready for the loop, OUTSIDE the loop!!! CCRuntimeClass* pTypeInfo; void* pDummy; INT32 nFound; if (pnFound) nFound = *pnFound; else nFound = 0; // BOOL FoundClipAttr = FALSE; // If we are finding a completely new set of attrs then we should not overwrite any entries // into the map that have been made within this routine // (So that normal attrs don't overwrite effect attrs) BOOL bOverwriteExisting = (nFound!=0); // Repeat the following loop for all attributes we encounter in the tree. while (pAttrib) { // Get the run-time type of the attribute, which serves as a hash "key". pTypeInfo = pAttrib->GetAttributeType(); // Check if this type is already in the hash table. If it isn't then insert // its address with its run-time type as the key, and check if we need to look // for any more. BOOL bEffectStatusOK = FALSE; if (bStrictEffectStatus) bEffectStatusOK = (pAttrib->IsEffectAttribute() == this->IsValidEffectAttr(pAttrib)); else bEffectStatusOK = !pAttrib->IsEffectAttribute(); if (!pAttrib->IsAClipViewAttr() && (pAttrib->FindParent() != (Node*)this || bEffectStatusOK)) { if (!pAttribMap->Lookup(pTypeInfo, pDummy)) { // This is a new attribute for the map BOOL AddAttr = TRUE; // NB keep default attrs in map so we don't have incomplete maps if (ExcludeIndirectlyAppliedGLAs && !pAttrib->IsADefaultAttr() && pAttrib->IsLinkedToNodeGeometry()) { if(!pAttrib->IsLinkedToThisNode((Node*)this)) { AddAttr = FALSE; } } if(AddAttr) { pAttribMap->SetAt(pTypeInfo, pAttrib); nFound++; ERROR3IF(nFound>nMax,"Found more attribute types than are registered!"); } } else if (bOverwriteExisting) { // An attribute of that type is already in the map // But if this attribute is a child of the scanned node // we should force it into the map because it's // still in scope! if (pAttrib->FindParent() == (Node*)this) { pAttribMap->SetAt(pTypeInfo,pAttrib); // (Attrib type was already in map so no need to increment counter.) } } } // After dealing with that attribute can we stop the scan? // We want to stop as soon as we can, namely when we have all the attribute // types in the map and when we're no longer scanning children of "this". if ( nFound >= nMax && (pAttrib->FindParent()!=(Node*)this) ) break; // Go on to find the next attribute. pAttrib = NodeAttribute::FindPrevAppliedAttr(pAttrib); } #ifdef _DEBUG PORTNOTE("other","Removed some IsUserName protected debug") #if 0 if (IsUserName("Phil") && nMax<5000 && nFound<nMax) { TRACE( _T("Not found all reqd atts: (found %d attributes, should be %d)\n"), nFoundAttributes, nMaxAttributes); for (POSITION pos = pAttribMap->GetStartPosition(); pos != 0; ) { void* pKey; void* pValue; pAttribMap->GetNextAssoc(pos, pKey, pValue); TRACE( _T("\tFound a %s at 0x%lX\n"), ((CCRuntimeClass*) pKey)->m_lpszClassName, (UINT32) pValue); } List* pTypeList = ObjectRegistry::GetRequiredAttribs(GetRuntimeClass()); for (ListItem* pItem = pTypeList->GetHead(); pItem != 0; pItem = pTypeList->GetNext(pItem)) { CCRuntimeClass* pClass = ((NodeAttributeClassItem*) pItem)->AttributeClass; void* pDummy; if (!pAttribMap->Lookup(pClass, pDummy)) { TRACE( _T("\t\tCouldn't find a %s\n"), pClass->m_lpszClassName); } } } #endif #endif ERROR2IF(nMax<5000 && nFound<nMax,FALSE,"Failed to find all required attributes."); if (pnFound) *pnFound = nFound; return TRUE; }

NodeRenderableInk * NodeRenderableInk::FindColourForNodeRenderableAtPoint (  Spread *  pSpread, DocCoord  dcPoint, Pixel32bpp &  Pix, Node *  pThisNode, AttrFillGeometry *  pThisFill )  [static]

The function obtains the TRUE 32-BIT RGB index for the pixel that our mouse cursor is over for the supplied node. Parameters: -  [OUTPUTS] Returns: 0 (at present) Errors: - See also: NodeRenderableInk::FindSimpleAtPointForColourPicker Definition at line 730 of file hittest.cpp. { PORTNOTETRACE("other","NodeRenderableInk::FindColourForNodeRenderableAtPoint - do nothing"); #ifndef EXCLUDE_FROM_XARALX // Find the currently active DocView. DocView* pDocView = DocView::GetSelected(); ENSURE(pDocView != 0, "Null current DocView in NodeRenderableInk::FindFirstAtPoint"); // Build a rectangle around the given point, based on the size of a blob. DocRect drClickRect; OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), dcPoint, BT_CLICKME, &drClickRect); // Get the extent of the current view and convert to spread coordinates. DocRect drViewRect = pDocView->GetDocViewRect(pSpread); pSpread->DocCoordToSpreadCoord(&drViewRect); // Create a colour render region to draw into, if possible. RenderRegion* pRegion = pDocView->RenderOnTop(&drClickRect, pSpread, COLOURBITMAP); if (pRegion==0) { delete pAttribMap; ERROR2(0,"FindSimpleAtPoint: couldn't create a RenderRegion!"); } // Start with a (very) clean sheet. pRegion->SetClean(TRUE, TRUE); pRegion->StopRender (); while (pRegion != 0) { // we want to render everything using the quality the document is using .... if (pRegion->RRQuality.GetQuality() != Quality::QualityGuideLayer) { QualityAttribute* pQualAttr = new QualityAttribute(pDocView->RenderQuality); pRegion->SetQuality(pQualAttr, TRUE); } pRegion->SetFillGeometry ((ColourFillAttribute*) (pThisFill->GetAttributeValue ()), FALSE); pThisNode->Render (pRegion); // uncommenting the following line allows us to see what is going on // OSRenderBitmap::DebugMe(pRegion,8); // need explicit cast to enable us to call ReadCentrePixel32bpp if (pRegion->IsKindOf(CC_RUNTIME_CLASS(GRenderClickColour))) { GRenderClickColour* actualRegion = (GRenderClickColour*) pRegion; Pix = actualRegion->GetCentrePixel32BPP(); } pRegion->StartRender (); pRegion = pDocView->GetNextOnTop(&drClickRect); } #endif return 0; // I suppose I should return something else here? //pThisNode); }

BOOL NodeRenderableInk::FindCommonAttributesToFactorOut (  CommonAttrSet *  CommonAttributeSet  )  [private]

This fn does not exist.Finds all attributes common to the compound node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 3/8/94 Parameters: -  [INPUTS] All  items in the CommonAttributeSet are attributes common to all objects [OUTPUTS] within the group. The attributes applied to objects which can discard their attributes (like the caret) are ignored Returns: TRUE if successful, FALSE otherwise (out of memory) Errors: - Scope: private See also: - Definition at line 559 of file ndoptmz.cpp. { CommonAttributeItem* CommonAttrItem; CommonAttributeItem* NextCommonAttrItem; // Place all attributes in the CommonAttributeSet if (!CommonAttributeSet->AddAllTypesToSet()) { return FALSE; // ERROR already called } // Scan all grouped objects for (Node* CurrentObject = FindFirstChild(); CurrentObject != NULL; CurrentObject = CurrentObject->FindNext()) { if (CurrentObject->IsAnObject()) { // Scan all attributes in the CommonAttributeSet in turn CommonAttrItem = (CommonAttributeItem*)CommonAttributeSet->GetHead(); while(CommonAttrItem != NULL) { // Hand over hand cos we may well delete the CommonAttrItem NextCommonAttrItem = (CommonAttributeItem*)(CommonAttributeSet->GetNext(CommonAttrItem)); // Does CurrentObject require the attribute to render if ( (((NodeRenderableInk*)CurrentObject)->RequiresAttrib(CommonAttrItem->AttrType)) || CurrentObject->IsCompound()) { BOOL DeleteCommonAttr = FALSE; // Until we know better // Ok the current object requires the attribute // Does the CurrentObject have a child attribute of this type ? NodeAttribute* pAttrNode = ((NodeRenderableInk*)CurrentObject)->GetChildAttrOfType(CommonAttrItem->AttrType); if (pAttrNode != NULL && pAttrNode->ShouldBeOptimized()) { // Ok it has an attribute of this type if (CommonAttrItem->pAttr == NULL) { // The attribute becomes a common attribute CommonAttrItem->pAttr = pAttrNode; CommonAttrItem->Status = Range::ATTR_COMMON; } else if(CommonAttrItem->pAttr->GetRuntimeClass() == pAttrNode->GetRuntimeClass()) { // Ok they are the same runtime class but are they equal if (!((*pAttrNode)==(*(CommonAttrItem->pAttr)))) { // They are not equal so remove CommonAttrItem from the // common attribute set. DeleteCommonAttr = TRUE; } // DY 12/5/2000 AttrBrushTypes cannot be factored because they // may contain caches of pressure or timestamp data which apply // to a specific node only. // They no longer contain this data so factor them like normal! //if (pAttrNode->IsKindOf(CC_RUNTIME_CLASS(AttrBrushType))) // DeleteCommonAttr = TRUE; } else { // They cannot be the same value cos they are different runtime types DeleteCommonAttr = TRUE; } } else { // The CurrentObject does not have an attribute of this type so it // cannot be common DeleteCommonAttr = TRUE; } if (DeleteCommonAttr) { delete(CommonAttributeSet->RemoveItem(CommonAttrItem)); } } CommonAttrItem = NextCommonAttrItem; } } // Removed because there are circumstances where certain attributes have // already been factored out eg. Corel filter //else //{ // ENSURE(CurrentObject->GetRuntimeClass() == CC_RUNTIME_CLASS(NodeHidden), // "It's not an object, it's not a hidden node, so what is it ??"); //} } // Delete all NULL items in the CommonAttributeSet CommonAttrItem = (CommonAttributeItem*)CommonAttributeSet->GetHead(); while (CommonAttrItem != NULL) { CommonAttributeItem* Next = (CommonAttributeItem*)CommonAttributeSet->GetNext(CommonAttrItem); if (CommonAttrItem->pAttr == NULL) { // Item is a non required attribute so zap it delete (CommonAttributeSet->RemoveItem(CommonAttrItem)); } CommonAttrItem = Next; } return TRUE; // Job done }

NodeRenderableInk * NodeRenderableInk::FindCompoundAtPoint (  Spread *  pSpread, DocCoord  dcPoint, Node *  pHighNode = NULL )  [static]

This function is similar to NodeRenderableInk::FindSimpleAtPoint, except that. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: pSpread  --- pointer to the spread containing the given point [INPUTS] dcPoint --- the point the object to be searched for occupies pHighNode Node below which search should be carried out. -  [OUTPUTS] Returns: A pointer to a node at the given point, which may be a "compound" object, eg. a group. Errors: - See also: NodeRenderableInk::FindSimpleAtPoint Definition at line 950 of file hittest.cpp. { return FindCompoundFromSimple(FindSimpleAtPoint(pSpread, dcPoint, pHighNode)); }

NodeRenderableInk * NodeRenderableInk::FindCompoundFromSimple (  NodeRenderableInk *  pSimpleNode, Node *  pSiblingNode = NULL )  [static]

This function will search up the parent links from the given "simple" node looking for a node whose parent is a layer. This guarantees that the returned node will be a genuinely selectable object, for example the routine will return the group node if the given point is within a grouped object. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/94 Parameters: pSimpleNode  a simple node, eg. a renderable node such as a path, [INPUTS] possibly returned by a previous call to FindSimpleAtPoint. -  [OUTPUTS] Returns: A pointer to the "compound" node, eg. a group, that contains the given simple node, or (pSimpleNode) if there isn't one. Errors: - See also: NodeRenderableInk::FindSimpleAtPoint; NodeRenderableInk::FindCompoundAtPoint Definition at line 815 of file hittest.cpp. { // If necessary, search for a selectable parent node. if (pSimpleNode != 0) { for (;;) { // Find the node's parent, and if it is a layer then we have a node that can // be selected. Node* pParentNode = pSimpleNode->FindParent(); Node* pSaveParentNode = 0; // DMc - new test to see which parent node wishes to be selected while (pParentNode != 0) { if (pParentNode->IsRenderable() && !pParentNode->IsNodeDocument() && !pParentNode->IsLayer() && !pParentNode->IsPaper() && !pParentNode->IsSpread() && !pParentNode->IsChapter()) { if (pParentNode->PromoteHitTestOnChildrenToMe() || pParentNode->IsSelected()) pSaveParentNode = pParentNode; } pParentNode = pParentNode->FindParent(); } pParentNode = pSaveParentNode; if (pParentNode == 0 || pParentNode->IsLayer()) break; // If the caller has specified that the node should be in the same level // as the specified sibling then check to see if the node we've got to // exists in that sibling list or not... if (pSiblingNode != 0) { // Check all siblings. Start from first sibling in this list. Node* pSibling = pSimpleNode->FindParent(); if (pSibling != 0) pSibling = pSibling->FindFirstChild(); // Loop around comparing members of the sibling list with the specified sibling... while (pSibling != 0 && pSibling != pSiblingNode) pSibling = pSibling->FindNext(); // If we found the specified sibling then stop the CompoundFromSimple search. if (pSibling == pSiblingNode) break; } // If the parent doesn't want to be selected due to one of it's children being // clicked on then stop NOW! if (pParentNode->IsAnObject()) { if (((NodeRenderableInk*) pParentNode)->CanSelectAsCompoundParent()) pSimpleNode = (NodeRenderableInk*) pParentNode; // Parent allowed to be selected else break; // Parent not allowed to be selected // So return pSimpleNode now! } else { // Hit a non-ink node so we must have emerged above the selection surface // This shouldn't happen, so raise an error! ERROR2(0, "Couldn't find a selectable compound node in FindCompoundFromSimple"); } } } // Return the node found, or 0 if we couldn't find any. return pSimpleNode; }

Node * NodeRenderableInk::FindFirstHitTest (  Spread *  pStartSpread, const DocRect &  drClickRect, CCAttrMap *  pAttribMap, BOOL  bExcludeLayers, Node *  pHighNode = NULL )  [static, private]

Walks the node tree in the reverse order to rendering, which is the order that nodes should be considered for hit-testing. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: pStartSpread  --- the spread node to begin the hit-testing search [INPUTS] from. Only nodes contained within this spread will be returned. drClickRect --- the rectangle centred on the mouse click position pAttribMap --- Pointer to the map of attributes current at this point bExcludeLayers --- TRUE if the routine should not return objects contained within locked or invisible layers. pHighNode Node below which search should be carried out. -  [OUTPUTS] Returns: A pointer to the next NodeRenderableInk to consider for hit-testing. The returned node intersects the given click rectangle. Errors: ENSURE failure if the routine runs out of nodes to consider - this should never happen - if it does then there is something wrong with the node tree, for example it contains no spread nodes. See also: Node::FindNextHitTest; NodeRenderableInk::FindSimpleAtPoint Definition at line 1052 of file hittest.cpp. { // Make sure that the node we start at is really a spread, as all NodeRenderableInks // are children of spread nodes. ENSURE(pStartSpread != NULL, "Node::FindFirstHitTest: pStartSpread parameter is NULL!"); ENSURE(pStartSpread->IsSpread(), "Node::FindFirstHitTest: pStartSpread parameter is not a spread!"); // Get the bounding box of the objects within the specified spread, converted to // spread coordinates. DocRect drSpreadBounds = pStartSpread->GetBoundingRect(); pStartSpread->DocCoordToSpreadCoord(&drSpreadBounds); // If the bounding box doesn't intersect the click rectangle then the given spread // cannot hold any object that was clicked on. if (!drSpreadBounds.IsIntersectedWith(drClickRect)) return NULL; // As the spread does contain the click rectangle, begin the traversal... // Call FindNextHitTest directly on the Spread so that the last item of the // Spread's child list can be considered correctly. Node* pFirstNode = FindNextHitTest((Node*)pStartSpread, drClickRect, pAttribMap, bExcludeLayers); if (pFirstNode == NULL) return NULL; // If there is an upper limit node then go through the tree until we get down to that // without returning the results for hit-testing. // (Or until there are no more nodes to consider!) if (pHighNode != NULL) { while (pFirstNode != NULL && pFirstNode != pHighNode) { pFirstNode = FindNextHitTest(pFirstNode, drClickRect, pAttribMap, bExcludeLayers); } // If we have stopped at the high node then return the next node below that in HitTest order // as the "first" node... Note that we do not want to examine child nodes of the high node. if (pFirstNode != NULL) { pFirstNode = FindNextHitTest(pFirstNode, drClickRect, pAttribMap, bExcludeLayers, TRUE); } } return pFirstNode; }

NodeRenderableInk * NodeRenderableInk::FindInnerCompound (  Node *  pLowNode, Node *  pHighNode )  [static]

Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pLowNode  the node to start the search from (deep in the tree) [INPUTS] pHighNode the node to finish searching at -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 905 of file hittest.cpp. { if (pLowNode==pHighNode) return 0; if (!pHighNode->AllowSelectInside()) return 0; Node* pLastCompoundNode = pLowNode; if (pLowNode != 0) { for (;;) { pLowNode = pLowNode->FindParent(); if (pLowNode == 0 || pLowNode == pHighNode || IS_A(pLowNode, Layer)) break; if (pLowNode->IsCompound()) pLastCompoundNode = pLowNode; // if (IsUserName("JustinF")) TRACE( _T("\t\tLooking at a %s\n"), pLowNode->Name()); } } return (NodeRenderableInk*) pLastCompoundNode; }

Node * NodeRenderableInk::FindNextHitTest (  Node *  pNode, const DocRect &  drClickRect, CCAttrMap *  pAttribMap, BOOL  bExcludeLayers, BOOL  bSkipChildren = FALSE )  [static, private]

Walks the node tree in the reverse order to rendering, which is the order that nodes should be considered for hit-testing. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: pNode  --- Pointer to previous node in reverse rendering order [INPUTS] (usually a result of calling FindFirstHitText or a previous call to FindNextHitTest) drClickRect --- the rectangle centred on the mouse click position pAttribMap --- Pointer to the map of attributes current at this point bExcludeLayers --- TRUE if the routine should not return objects contained within locked or invisible layers. bSkipChildren --- if TRUE then the routine will not examine the children of this Node. By default this flag is FALSE. -  [OUTPUTS] Returns: A pointer to the next node to consider for hit-testing. Errors: ENSURE failure if the routine runs out of nodes to consider - this should never happen - if it does then there is something wrong with the node tree, for example it contains no spread nodes. See also: Node::FindFirstHitTest; NodeRenderableInk::FindSimpleAtPoint; Node::IsUnhittableLayer Definition at line 1134 of file hittest.cpp. { if (pNode == NULL) return NULL; // Storage for pointer to attribute types... CCRuntimeClass* pTypeInfo; void* pDummy; // Check if we should go down the child link of this node. // (If node is a spread then allow it's children to be scanned because it's bounds // are in a different coordinate system. This is OK because we know that the // only time this routine is called on a Spread is the first call made in FindFirstHitTest // which has already done a bounds test.) if (!bSkipChildren && (HitTestChildren(pNode, drClickRect, bExcludeLayers) || pNode->IsSpread())) { // Find its right-most sibling and continue walking from there. pNode = pNode->FindFirstChild(); while (pNode->FindNext() != NULL) { // If this node is an attribute then it's more local than anything that might // be in the Attribute map (because we've just gone DOWN in the tree). // So, we'll bung it directly into the attribute map! if (pNode->IsAnAttribute() && !pNode->IsAClipViewAttr()) { pTypeInfo = ((NodeAttribute*)pNode)->GetAttributeType(); // Check if this type is already in the hash table. If it isn't then increment // the number of attribute types found if (!pAttribMap->Lookup(pTypeInfo, pDummy)) nFoundAttributes++; // Insert this local attribute into the map pAttribMap->SetAt(pTypeInfo, pNode); } pNode = pNode->FindNext(); } } else if (pNode->FindPrevious() != NULL) { // Otherwise, just backtrack to the immediately-previous sibling, if possible. pNode = pNode->FindPrevious(); } else { // We have hit a node with no previous sibling or children. Search up through // its parents until we find a parent with a previous sibling. This previous // sibling is our next node. However, if while searching up the parent links // we hit a spread then we know we have passed all NodeRenderableInks, and the // search can be terminated. do { if (pNode->IsSpread()) // Don't allow hit-testing to cross spreads return NULL; pNode = pNode->FindParent(); } while (pNode != NULL && pNode->FindPrevious() == NULL); if (pNode->IsSpread()) // Don't allow hit-testing to cross spreads return NULL; // If we broke out of the above loop because we found a parent with a previous // sibling then advance to that sibling. if (pNode != NULL && pNode->FindPrevious() != NULL) pNode = pNode->FindPrevious(); if (pNode->IsSpread()) // Don't allow hit-testing to cross spreads return NULL; } // If the found node is an attribute then remove it from the attribute map because it // has just gone out of scope! if (pNode->IsAnAttribute() && !pNode->IsAClipViewAttr()) { // The node is an attribute. Make sure that it no longer occurs in the // attribute hash table, so that the next time RenderAppliedAttributes is // called it will look for this kind. if (nFoundAttributes > 0 && pAttribMap->RemoveKey(((NodeAttribute*) pNode)->GetAttributeType())) nFoundAttributes--; } // Return the node we've found. return pNode; }

virtual NodeRenderableInk* NodeRenderableInk::FindNodeAtPointHelper (  const Spread *  pSpread, const DocCoord  dcPoint )  [inline, virtual]

Reimplemented in NodeLiveEffect. Definition at line 335 of file ink.h. {return this;}

BOOL NodeRenderableInk::FindReqdAttribs (  List *  ReqdAttribList  )  [private]

NodeRenderableInk * NodeRenderableInk::FindSimpleAtPoint (  Spread *  pSpread, DocCoord  dcPoint, Node *  pHighNode = NULL, Node **  ppInterruptNode = NULL )  [static]

Searches the ink-able objects within the given spread for one that lies at or near the given point. The method used to render each candidate object into a small monochrome bitmap, in the reverse order to normal (so that the object normally rendered last is the first to be rendered into the bitmap). The bitmap is examined to see if the object affected the centre or surrounding pixels. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/94 Parameters: pSpread  --- pointer to the spread containing the given point [INPUTS] dcPoint --- the point the object to be searched for occupies pHighNode Node below which search should be carried out. ppInterruptNode 0 if hit-detection shouldn't be interrupted Non-null otherwsie, then contains pointer to node at which hit-detection was interrupted on exit. -  [OUTPUTS] Returns: A pointer to an ink-able object that lies at or is closest to the given point, or 0 if there is none. This object will be "simple", ie. it will be a single "atomic" object such as a path, rectangle etc. and not a "compound" object like a group. One of the biggest time users in this routine is the scanning of the tree to find the attributes applied to an object. Attempts are made to cut down this scanning. A hash table of pointers to attributes is maintained. Assume that the hash table is full of attributes used to render an object. Then, as we scan backwards along a sibling list we simply remove attributes from the hash table as we encounter them because they have moved out of scope. When we go down a child link we scan along the sibling child list adding all those attributes encountered to the hash table because they have just moved into scope. Thus, at any time the hash table contains pointers to all the attributes that apply to the node we are about to render WITH ONE EXCEPTION! The reverse render-order tree-scan means that objects are encountered before their child attributes. The FindAppliedAttribute routine overcomes this by forcibly adding all child attributes to the map when it scans for applied attributes. Returns: Errors: - See also: NodeRenderableInk::FindCompoundAtPoint; NodeRenderableInk::OldFindFirstAtPoint; Node::FindFirstHitTest; Node::FindNextHitTest Definition at line 297 of file hittest.cpp. { // TRACE(_T("FindSimpleAtPoint(%d, %d)\n"), dcPoint.x, dcPoint.y); // Find the currently active DocView. DocView* pDocView = DocView::GetSelected(); ENSURE(pDocView != 0, "Null current DocView in NodeRenderableInk::FindFirstAtPoint"); // Initialise the count and limit on the number of attributes encountered. List* pTypeList = ObjectRegistry::GetRequiredAttribs(0); // <--- ENSURE(pTypeList != 0 && !pTypeList->IsEmpty(), "Object Registry returned a dodgy list in NodeRenderableInk::FindSimpleAtPoint"); nFoundAttributes = 0; nMaxAttributes = pTypeList->GetCount(); // Clear interrupt node pointer if (ppInterruptNode) *ppInterruptNode = 0; // Initialise the hash-table used to look-up attributes encountered. // Make the hash table twice as big as the number of att types for efficient look-up. pAttribMap = new CCAttrMap(nMaxAttributes*2); ERROR2IF(pAttribMap==0,0,"FindSimpleAtPoint: couldn't create a CCAttrMap!"); // Build a rectangle around the given point, based on the size of a blob. DocRect drClickRect; OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), dcPoint, BT_CLICKME, &drClickRect); // Get the extent of the current view and convert to spread coordinates. DocRect drViewRect = pDocView->GetDocViewRect(pSpread); pSpread->DocCoordToSpreadCoord(&drViewRect); // Create a special hit-detection render region to draw into, if possible. RenderRegion* pRegion = pDocView->RenderOnTop(&drClickRect, pSpread, CLICKBITMAP); if (pRegion==NULL) { delete pAttribMap; ERROR2(NULL,"FindSimpleAtPoint: couldn't create a RenderRegion!"); } // Start with a (very) clean sheet. pRegion->SetClean(TRUE, TRUE); // These point to ink-nodes in the tree that have been rendered into our hit-test // render-region. NodeRenderableInk* pHitNode = NULL; // node that occupies dcPoint NodeRenderableInk* pNearNode = NULL; // node that came closest to dcPoint NodeRenderableInk* pCompoundHitNode = NULL; // compound node that was hit before trying children NodeRenderableInk* pCompoundNearNode = NULL; // compound node that was near before trying children MonotonicTime Slice; // Sample time now BOOL bSkipChildren = FALSE; // Perform hit-testing for each render-region provided by the DocView. while (pRegion != NULL) { // Render the first and subsequent ink-nodes into the render-region, checking if any // draw into it. for (Node* pNode = FindFirstHitTest(pSpread, drClickRect, pAttribMap, TRUE, pHighNode); pNode != NULL; pNode = FindNextHitTest(pNode, drClickRect, pAttribMap, TRUE, bSkipChildren)) { bSkipChildren = FALSE; if (pNode) { if (pNode->IsAnObject()) { // Does this renderable node intersect the click rectangle? If not, then // ignore it. DocRect drBounds = ((NodeRenderableInk*) pNode)->GetBoundingRect(FALSE, TRUE); if (!drBounds.IsIntersectedWith(drClickRect)) continue; // This node can be rendered. Find all the outstanding attributes in the // tree that affect the rendering of this node, and render them. // // Jason 15/1/97 - Save the current RR context so that we can restore the render // stack to a sensible state after rendering this object. This is safe because we // always render all relevant attributes for every object we hit test. // We restore immediately after rendering (the 3 RestoreContext() calls, below) pRegion->SaveContext(); ((NodeRenderableInk*) pNode)->RenderAppliedAttributes(pRegion); // This ensures that the object is rendered according to the view Quality setting. // When Quality attributes appear in the tree this may not be a good thing!!! // It should really be called before RenderAppliedAttributes but at the moment that seems // to always set Quality to Normal for some reason!!! // Extract Quality from DocView object and set it up in the renderregion/monobitmap // Markn 26/9/95: Added the following 'if' statement to prevent the setting of the view // quality overriding the quality set by the AttrQuality attribute in the guides layer. if (pRegion->RRQuality.GetQuality() != Quality::QualityGuideLayer) { QualityAttribute *pQualAttr = new QualityAttribute(pDocView->RenderQuality); pRegion->SetQuality(pQualAttr, TRUE); } // Phil 18/03/2004 // Must render clip region attribute AFTER Quality attribute has been set how // the region will be rendered otherwise GDraw will fail in FillPath! // // Karim 13/4/2000 (lucky for some...) // ok, BODGE CITY here. we're going to do a RenderAppliedClipAttributes(), which // renders all the ClipRegionAttributes which would normally apply to this node. // see the method header for more info. ((NodeRenderableInk*) pNode)->RenderAppliedClipAttributes(pRegion); do { // This 'do' loop will render the same node until the sub render state is 0 // This allows heavy-duty nodes (e.g. blends) to get the hit test bmp to be checked // at any point during the rendering of the node. // Now the attributes are done, render the object itself. pRegion->SetClean(FALSE, FALSE); // Reset just the clean flag so we can tell whether // compound nodes render anything // ------------------------------ pNode->Render(pRegion); // ------------------------------ #ifdef DEBUG_CLICK_DETECT_BITMAP OSRenderBitmap::DebugMe(pRegion, 8); #endif // Check if any of the pixels in the render-region were affected by the // last rendering. BitmapContents bcDrawCode = OSRenderBitmap::GetContents(pRegion, FALSE); if (pNode->IsCompoundClass() && !pRegion->IsClean()) { #ifdef DEBUG_CLICK_DETECT_BITMAP OSRenderBitmap::DebugMe(pRegion, 108); #endif // Compound has rendered something... // // Clean out the bitmap since we know we are going to use it some more pRegion->SetClean(FALSE, TRUE); // Compound nodes may render themselves if they have effect // attributes applied (so that effect transparency is // properly taken into account during hit testing) // If the compound node rendered the centre pixel then we must // allow the children of the node to render themselves to get // a true indication of the clicked on node // If not, then we should not allow our children to render // themselves at all if (bcDrawCode != BITMAPCONTENTS_CENTRE && bcDrawCode != BITMAPCONTENTS_ANY) { // Skip out of this node's subtree... bSkipChildren = TRUE; } else // else just keep going (treat this as a "near" node) { // if (pNearNode == NULL) pNearNode = (NodeRenderableInk*) pNode; if (bcDrawCode == BITMAPCONTENTS_CENTRE) { if (pCompoundHitNode == NULL) pCompoundHitNode = (NodeRenderableInk*)pNode; } else { if (pCompoundNearNode == NULL) pCompoundNearNode = (NodeRenderableInk*)pNode; } } } else { if (bcDrawCode == BITMAPCONTENTS_CENTRE) { // The centre pixel was affected. Remember this node and prepare to // return result to caller. pHitNode = (NodeRenderableInk*) pNode; // And exit both loops. We have to restore the previous RR state first, though pRegion->RestoreContext(); goto AfterSearch; } else if (bcDrawCode == BITMAPCONTENTS_ANY) { // Some outer pixels were affected. If we don't already have a // "closest" node then remember this one. If we do already have a // "closest" node then the previous "closest" is "closer", because // it is on-top! if (pNearNode == NULL) pNearNode = (NodeRenderableInk*) pNode; // Don't break because although this stage (typically a stage of a Blend) has returned // "Near" the next one might be a direct hit! //break; // break out of the do-while sub render state loop } } // If the caller has allowed us to inetrrupt the hit-testing process // then we will do so if the mouse has moved... // Only do these tests every twentieth of a second because they could take some time if (ppInterruptNode && Slice.Elapsed(50)) { Slice.Sample(); // Reset the slice timer DocView* pDocView = DocView::GetCurrent(); if (pDocView->IsMouseMoved()) // Has the mouse moved? { TRACEUSER( "Phil", _T("FindSimpleAtPoint Interrupt! %lx\n"), pNode); if (*ppInterruptNode == NULL) // If so set the interrupt *ppInterruptNode = pNode; // node pointer pNode = 0; // Clear pointer to "hit" node // And exit both loops. We have to restore the previous RR state first, though pRegion->RestoreContext(); goto AfterSearch; // and stop the search } } // Render the same node until the sub render state is NULL } while (pRegion->GetSubRenderState() != NULL); // Restore the RenderRegion attr state to how it was before we rendered this node pRegion->RestoreContext(); } } } // Advance onto the next render-region. pRegion = pDocView->GetNextOnTop(&drClickRect); } AfterSearch: // Discard remaining render regions (although there shouldn't be any). while (pRegion != NULL) pRegion = pDocView->GetNextOnTop(&drClickRect); // Deallocate the hash table. delete pAttribMap; // If we found a "hit" then return that node, otherwise return the closest // "near miss" (which will be null if no node was close). if (pHitNode == NULL) { if (pNearNode != NULL) { if (!pNearNode->IsKindOf(CC_RUNTIME_CLASS(NodeShadow)) && !pNearNode->IsKindOf(CC_RUNTIME_CLASS(NodeShadowController))) pHitNode = pNearNode; } else if (pCompoundHitNode) pHitNode = pCompoundHitNode; else if (pCompoundNearNode) pHitNode = pCompoundNearNode; } else { // We might have set pNearNode from a compound render // but then allowed processing to continue // So if pNearNode is set but is not the parent of the hit node then // we should use pNearNode instead // // NOTE! We could avoid extra work by making FinNextHitTest stop as soon // as it leaves the subtree whose root is pNearNode. if (pCompoundHitNode && !pCompoundHitNode->IsNodeInSubtree(pHitNode)) pHitNode = pCompoundHitNode; } // Check if this node wishes to be selected // and if not, find it's parent instead... while (pHitNode != NULL && !pHitNode->CanSelectAsSimple()) // While we have a node but it doesn't { // want to be selected... Node* ptemp = pHitNode->FindParent(); // Find parent of current node if (ptemp != NULL && ptemp->IsAnObject()) // If parent is ink { pHitNode = (NodeRenderableInk*) ptemp; // Then reset current pointer if (!pHitNode->CanSelectAsCompoundParent()) // See if it is prepared to be selected pHitNode = NULL; // If not then can't select anything! } else // Else (parent is NOT ink) pHitNode = NULL; // Then can't select anything! } // Give the node a chance to alter it's "hit" status if (pHitNode) pHitNode = pHitNode->FindNodeAtPointHelper(pSpread, dcPoint); return pHitNode; }

NodeRenderableInk * NodeRenderableInk::FindSimpleAtPointForColourPicker (  Spread *  pSpread, DocCoord  dcPoint, Pixel32bpp &  Pix, Node *  pHighNode = NULL, Node **  ppInterruptNode = NULL )  [static]

Firstly, this function serves to find the 'ID' of the item that our colour picker is over - which is used to update our mouse cursor. Secondly, it obtains the TRUE 32-BIT RGB index for the pixel that our mouse cursor is over - enabling us to do colour manager/dialog type things. The first part of this routine simply calls FindSimpleAtPointFor - and the second part actually does colour specific work. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 28/10/99 Parameters: pSpread  --- pointer to the spread containing the given point [INPUTS] dcPoint --- the point the object to be searched for occupies Pix --- reference to the structure that will receive pixel data (created internally by custom colour picker control) pHighNode Node below which search should be carried out. ppInterruptNode 0 if hit-detection shouldn't be interrupted Non-null otherwsie, then contains pointer to node at which hit-detection was interrupted on exit. NOTE: uses same inputs as NodeRenderableInk::FindSimpleAtPoint so that we may call NodeRenderableInk::FindSimpleAtPoint internally. Parameters: -  [OUTPUTS] Returns: A pointer to an ink-able object that lies at or is closest to the given point, or 0 if there is none. This object will be "simple", ie. it will be a single "atomic" object such as a path, rectangle etc. and not a "compound" object like a group. Also returns (by reference) details concerning the pixel that the colour picker control is over. Errors: - See also: NodeRenderableInk::FindSimpleAtPoint Definition at line 630 of file hittest.cpp. { // Find the currently active DocView. DocView* pDocView = DocView::GetSelected(); ENSURE(pDocView != 0, "Null current DocView in NodeRenderableInk::FindFirstAtPoint"); // Build a rectangle around the given point, based on the size of a blob. DocRect drClickRect; OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), dcPoint, BT_CLICKME, &drClickRect); // Get the extent of the current view and convert to spread coordinates. DocRect drViewRect = pDocView->GetDocViewRect(pSpread); pSpread->DocCoordToSpreadCoord(&drViewRect); // find 'ID' of item that mouse cursor is over (or not) NodeRenderableInk* pHitNode = FindSimpleAtPoint (pSpread, dcPoint, pHighNode, ppInterruptNode); BOOL bOldForce = pDocView->SetForceDefaultColourContexts(); // Create a colour render region to draw into, if possible. RenderRegion* pRegion = pDocView->RenderOnTop(&drClickRect, pSpread, COLOURBITMAP); if (pRegion == 0) { pDocView->SetForceDefaultColourContexts(bOldForce); delete pAttribMap; ERROR2(0,"FindSimpleAtPoint: couldn't create a RenderRegion!"); } // Start with a (very) clean sheet. pRegion->SetClean(TRUE, TRUE); pRegion->StopRender(); while (pRegion != 0) { // we want to render everything using the quality the document is using .... if (pRegion->RRQuality.GetQuality() != Quality::QualityGuideLayer) { QualityAttribute *pQualAttr = new QualityAttribute(pDocView->RenderQuality); pRegion->SetQuality(pQualAttr, TRUE); } // render everything over pSpread into our renderregion .... pDocView->ContinueRenderView(pRegion, pSpread, TRUE, FALSE); // uncommenting the following line allows us to see what is going on // OSRenderBitmap::DebugMe(pRegion,8); // need explicit cast to enable us to call ReadCentrePixel32bpp if (pRegion->IsKindOf(CC_RUNTIME_CLASS(GRenderClickColour))) { GRenderClickColour* actualRegion = (GRenderClickColour*) pRegion; if (NodeRenderableInk::AverageHitColour) Pix = actualRegion->GetAveragePixel32BPP(); else Pix = actualRegion->GetCentrePixel32BPP(); } pRegion->StartRender(); pRegion = pDocView->GetNextOnTop(&drClickRect); } pDocView->SetForceDefaultColourContexts(bOldForce); return pHitNode; }

AttrStrokeType * NodeRenderableInk::GetActiveStroke (   )

We may have a stroke attribute applied to us that does not do anything under certain circumstances (zero line width, no accompanying variable width attribute). Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15-5-2000 Parameters: [INPUTS]  -  [OUTPUTS] Returns: pointer to the stroke attribute applied to us, so long as it is active Definition at line 1685 of file hittest.cpp. { // first up, if we have no stroke colour then any strokes we have aren't really active AttrStrokeColour* pStrokeColour = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), (NodeAttribute**)&pStrokeColour); if (pStrokeColour != NULL) { // get the stroke colour StrokeColourAttribute* pVal = (StrokeColourAttribute*)pStrokeColour->GetAttributeValue(); if (pVal != NULL) if (pVal->Colour.IsTransparent()) return NULL; } else return NULL; // now find out if we have both a stroke and variable width attribute AttrStrokeType* pStroke = NULL; AttrVariableWidth* pVarWidth = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeType), (NodeAttribute**)&pStroke); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrVariableWidth), (NodeAttribute**)&pVarWidth); if (pVarWidth != NULL && ((VariableWidthAttrValue*)pVarWidth->GetAttributeValue())->GetWidthFunction() != NULL) { if (pStroke != NULL && pStroke->HasPathProcessor()) return pStroke; } return NULL; }

AttrBrushType * NodeRenderableInk::GetAppliedBrushAttribute (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15-5-2000 Parameters: [INPUTS]  -  [OUTPUTS] Returns: the attrbrushtype that applies to this inknode Definition at line 1649 of file hittest.cpp. { AttrBrushType* pAttr = 0; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), (NodeAttribute**)&pAttr); if (pAttr == NULL) return NULL; BrushHandle Handle = pAttr->GetBrushHandle(); if (Handle == BrushHandle_NoBrush) return NULL; // double check to make sure it isn't referring to a deleted brush BrushDefinition* pDef = BrushComponent::FindBrushDefinition(Handle); if (pDef == NULL) return NULL; return pAttr; }

virtual BOOL NodeRenderableInk::GetAreaDetails (  XLONG *  pxlArea, XLONG *  pXLPerimeter )  [inline, virtual]

Reimplemented in NodePath. Definition at line 258 of file ink.h. {return FALSE;}

NodeAttribute * NodeRenderableInk::GetChildAttrOfType (  CCRuntimeClass *  ReqdAttrib  )

Scans the child attribute block of the node for an attribute with type ReqdAttrib. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 3/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: If the node has an attribute with TYPE ReqdType then a pointer to the attribute, else NULL. Errors: - See also: NodeAttribute::GetAttributeType Definition at line 4192 of file noderend.cpp. { /* Node* Current = FindFirstChild(); while (Current != NULL) { if (Current->IsAnAttribute()) { if (((NodeAttribute*)Current)->GetAttributeType() == ReqdAttrib) { return ((NodeAttribute*)Current); } } else { if (Current->IsAnObject()) // Check for end of attribute block { return NULL; } } Current = Current->FindNext(); } return NULL; // Not found */ // It's important to do this scan in reverse render order so that closer scoped // attributes are found first. This helps report effect attributes correctly Node* Current = FindLastChild(); while (Current != NULL) { if (Current->IsAnAttribute()) { if (((NodeAttribute*)Current)->GetAttributeType() == ReqdAttrib) { NodeAttribute* pAttr = (NodeAttribute*)Current; if (pAttr->IsEffectAttribute() == IsValidEffectAttr(pAttr)) return pAttr; } } Current = Current->FindPrevious(); } return NULL; // Not found }

CCRuntimeClass * NodeRenderableInk::GetCurrentAttribGroup (   )  [virtual]

Every Ink object has an associated current attribute group, If an attribute is applied to the object, and it needs to become current then the attribute group specified will get updated. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Returns: The default attribute group (NodeRenderableInk) Reimplemented in BaseTextClass. Definition at line 4168 of file noderend.cpp. { return (CC_RUNTIME_CLASS(NodeRenderableInk)); }

virtual BOOL NodeRenderableInk::GetDirectBitmap (  RenderRegion *  pRender, LPBITMAPINFO *  plpInfo, LPBYTE *  plpBits, DocRect *  pRect, Matrix *  pMat, double *  pdRes )  [inline, virtual]

Reimplemented in NodeBitmap, and NodeBitmapEffect. Definition at line 261 of file ink.h. {return FALSE;}

NodeRenderableInk * NodeRenderableInk::GetObjectToApplyTo (  CCRuntimeClass *  AttrType  )  [virtual]

Before applying an attribute to an object this function should be called to return the actual object the attribute should be applied to. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 7/6/95 Parameters: AttrType,:  The type of the attribute. It is a type, rather than an [INPUTS] instance because this function needs to be called from the Localise/Factor out routines which operate on attribute types. Returns: A pointer to an object that the attribute should be applied to. It returns NULL if there is no such object. This base class function calls CanBeAppliedToMe, and if the object says No then it tries it's parent etc. This system works for Line based text attributes which should never be applied to text characters. However if in future we meet a situation where things need to be done differently then this function can be overloaded. Returns: Errors: - See also: NodeRenderableInk::CanAttrBeAppliedToMe Definition at line 4099 of file noderend.cpp. { Node* pParent; NodeRenderableInk* pCurrentObject = this; do { if (pCurrentObject->CanAttrBeAppliedToMe(AttrType)) { // if applying line level attr, force it to be the first line of the paragraph if (IS_A(pCurrentObject,TextLine) && TextLine::IsAttrTypeLineLevel(AttrType)) pCurrentObject = ((TextLine*)pCurrentObject)->FindFirstLineOfParagraph(); break; } // ok try the parent then pParent = pCurrentObject->FindParent(); if (pParent && (pParent->IsAnObject())) { pCurrentObject = (NodeRenderableInk*)pParent; } else { pCurrentObject = NULL; // No more to try } } while (pCurrentObject); return pCurrentObject; }

NodePath * NodeRenderableInk::GetSmoothVariableWidthStrokePath (   )  [virtual]

Reimplemented in NodePath, and NodeRegularShape. Definition at line 1743 of file hittest.cpp. { return NULL; }

BOOL NodeRenderableInk::GetStatusInfo (  String_256 **  ppStatusText, Cursor **  ppStatusCursor )  [virtual]

Called by the selector tool if either a previous OnMouseMove or OnClick member function call returns TRUE, indicating that the node has some feedback to display when the mous is at the previously passed point. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Parameters: -  [INPUTS] ppStatusText  pointer to a string pointer to set to an approrpiate [OUTPUTS] status bar text message, or 0 if not relevant ppStatusCursor pointer to a cursor pointer to set to an apppropriate Cursor object, or 0 if not relevant Returns: TRUE if the routine used any of the output parameters and thus has some text/cursor to show, FALSE if it doesn't. Errors: - See also: NodeRenderableInk::OnClick; NodeRenderableInk::OnMouseMove Definition at line 233 of file hittest.cpp. { #ifdef _DEBUG // if (IsUserName("JustinF")) // { // TRACE( _T("Call to base class NodeRenderableInk::GetStatusInfo for a %s\n"), (LPCTSTR) Name()); // } #endif return FALSE; }

NodePath * NodeRenderableInk::GetVariableWidthStrokePath (   )  [virtual]

If we have a variable width stroke applied to us then this will get the path generated by that stroke. This base class version returns NULL, overridden versions must supply their own outline path. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15-5-2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: a nodepath containing the path that is generated by any variable width strokes that are applied to us, or NULL if there aren't any See also: NodePath::GetVariableWidthStrokePath, NodeRegularShape::GetVariableWidthStrokePath Reimplemented in NodePath, and NodeRegularShape. Definition at line 1736 of file hittest.cpp. { return NULL; }

BOOL NodeRenderableInk::HasAttrTypesOn (  NodeRenderableInk *  Object  )

This function returns TRUE if the set of Object's child attribute types are a subset of this objects child attribute types. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/95 Definition at line 4246 of file noderend.cpp. { AttrTypeSet OurAttrs; AttrTypeSet ObjectsAttrs; if (!AddChildAttrTypesToSet(&OurAttrs)) return FALSE; if (!(Object->AddChildAttrTypesToSet(&ObjectsAttrs))) return FALSE; AttrTypeItem* pObjectsAttr = (AttrTypeItem*)ObjectsAttrs.GetHead(); CCRuntimeClass* AttrType; while (pObjectsAttr) { AttrType = pObjectsAttr->AttributeType; if (!(OurAttrs.InSet(AttrType))) return FALSE; // sets are different pObjectsAttr = (AttrTypeItem*) ObjectsAttrs.GetNext(pObjectsAttr); } return TRUE; }

BOOL NodeRenderableInk::HitTestChildren (  Node *  pNode, const DocRect &  drClickRect, BOOL  bExcludeLayers )  [static, private]

Private helper function for Node::FindNextHitTest. This function decides whether FindNextHitTest should go down a child link, which it should if (i) there is a child link; AND (ii) this node isn't a locked or invisible layer if such things should be excluded; (iii) if this node has a bounding rectangle it intersects the click rectangle. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 20/6/94 Parameters: pNode  --- Pointer to node to test child link of [INPUTS] drClickRect --- the rectangle enclosing a mouse-click, in spread coordinates. bExcludeLayers --- whether locked or invisible layers should be excluded from hit-testing. -  [OUTPUTS] Returns: TRUE if the caller should go down the child link of "this" node. Errors: - See also: Node::FindNextHitTest Definition at line 1249 of file hittest.cpp. { // If there's no child link to follow the decision is easy . . . if (pNode->FindFirstChild() == 0) return FALSE; // If the node is a locked or invisible layer and the caller wants such things // ignored then don't follow link down . . . if (bExcludeLayers && pNode->IsLayer()) { Layer* pLayer = (Layer*) pNode; if (pLayer->IsLocked() || !pLayer->IsVisible()) return FALSE; } // If this node has a bounding rectangle then don't go down the link if the given // mouse-click rectangle doesn't intersect with the bounds . . . if (pNode->IsBounded()) { DocRect drBounds = ((NodeRenderableBounded*) pNode)->GetBoundingRect(); if (!drBounds.IsIntersectedWith(drClickRect)) return FALSE; } // If we pass all the above tests then by all means go down the child link. return TRUE; }

BOOL NodeRenderableInk::Init (  void   )  [static]

Reads preferences for NodeRenderableInk. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/93 Parameters: -  [INPUTS] [OUTPUTS]  Returns: TRUE if worked (in fact cannot fail). Errors: None Reimplemented from NodeRenderableBounded. Reimplemented in NodeBitmapEffect, VisibleTextNode, AbstractTextChar, TextLine, BaseTextClass, and TextStory. Definition at line 2195 of file noderend.cpp. { #if !defined(EXCLUDE_FROM_RALPH) BOOL bOK = TRUE; bOK = bOK && Camelot.DeclareSection(TEXT("DebugFlags"), 10) && Camelot.DeclarePref(TEXT("DebugFlags"), TEXT("SmartClicks"), &bUseSmartClicks, FALSE, TRUE) && Camelot.DeclareSection(TEXT("Rendering"), 10) && Camelot.DeclarePref(TEXT("Rendering"), TEXT("EyeDropperAverage"), &AverageHitColour, FALSE, TRUE); return bOK; #else return TRUE; #endif }

BOOL NodeRenderableInk::IsAnObject (   )  const [virtual]

For determining quickly if the node is an object. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the node is an object i.e. a NodeRenderableInk Errors: Reimplemented from Node. Definition at line 2305 of file noderend.cpp. { return TRUE; // Cos it is }

virtual BOOL NodeRenderableInk::IsRenderedAsInk (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 158 of file ink.h. {return TRUE;}

BOOL NodeRenderableInk::IsSeeThrough (  BOOL  CheckIndirectAttrs  )  [virtual]

Determines whether this node is see through or not. See through in this case does not necessarily mean transparent - eg we could be a no-colour-fill rectangle. This test is useful if you're going to render into a bitmap, which will then be post-processed and plonked on the document (eg Feathering). This way, you can hopefully avoid any performance hit from unnecessary rendering into an alpha-channel bitmap. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 13 September 2000 Parameters: CheckIndirectAttrs  whether or not to test those attributes applied [INPUTS] to us living somewhere above us in the tree. Returns: TRUE if you can still see some of the background after rendering the tree rooted at this node. Notes: You should only need to set CheckIndirectAttrs when calling this fn on a sub-tree root-node. The recursive calls made by this fn pass FALSE, as we only need to check indirectly applied attrs once for a sub-tree. Reimplemented from NodeRenderable. Definition at line 4634 of file noderend.cpp. { // we do the searches in this order: // // 1. any attrs applied to us (not recursive). // 2. ask any non-attribute children if they are see-through (recursive). // // we finish the search as soon as we get a positive result. BOOL bIsSeeThrough = FALSE; // 1. Check our indirectly-applied attributes. if (CheckIndirectAttrs) { CCAttrMap* pAttrMap = CCAttrMap::MakeAppliedAttrMap(this); if (pAttrMap != NULL) { bIsSeeThrough = pAttrMap->IsSeeThrough(); delete pAttrMap; } } // 2. Check all our NodeRenderable children. // Note that if we've checked indirect attrs, // then we needn't bother re-testing any attributes. for (Node* pKid = FindFirstChild(); pKid != NULL && !bIsSeeThrough; pKid = pKid->FindNext() ) { if (pKid->IsNodeRenderableClass()) { if (CheckIndirectAttrs && pKid->IsAnAttribute()) { // do nothing. } else { bIsSeeThrough = ((NodeRenderable*)pKid)->IsSeeThrough(FALSE); } } } return bIsSeeThrough; }

BOOL NodeRenderableInk::IsSetCandidate (   )  const [virtual]

Indicates that NodeRenderableInks are candidates for membership of Attribute gallery set. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 2/10/99 Returns: TRUE. Reimplemented from Node. Reimplemented in TextChar, TextLine, BaseTextClass, and TextStory. Definition at line 2322 of file noderend.cpp. { return TRUE; }

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

Reimplemented in NodeGroup, NodeMouldGroup, NodeBrush, NodeMoulder, NodeMould, and NodeEffect. Definition at line 319 of file ink.h. {return FALSE;}

BOOL NodeRenderableInk::LocaliseCommonAttrHelper (  BOOL  CheckForDuplicates, BOOL  Global, AttrTypeSet *  pAffectedAttrTypes, BOOL  RecursiveForChildren = FALSE )  [private]

This function copies all attributes common to the compound to each child object within the compound which requires each attribute. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/95 Parameters: CheckForDuplicates,:  This should be TRUE if the children of this compound [INPUTS] node could have child attributes with the same type as the compound's attributes. This should never be the case. Global: TRUE indicates that we should localise the attributes on all parent compound nodes (top down), before localising the attributes for this compound. pAffectedAttrTypes: An optional set of attribute types. If this is specified then we only consider localising those attributes which have a type which is in this set. RecursiveDownwards: Passed on to the attribute helper, means that if we have a child who is also compound then we will also localise their attributes. Defaults to FALSE. Parameters: -  [OUTPUTS] Returns: TRUE if successful FALSE if we run out of memory, the localised attributes are not deleted in this function. The routine does not localise attributes on objects which can discard their child attributes (like the caret) Scope: private See also: NodeRenderableInk::LocaliseCommonAttributes Definition at line 918 of file ndoptmz.cpp. { // Do we need to globally optimise ? if (Global) { Node* pParent = FindParent(); if (pParent && (pParent->IsCompound())) { // We need to localise the parent's attributes first (Recursive bit) if (!(((NodeRenderableInk*)pParent)->LocaliseCommonAttrHelper(CheckForDuplicates, TRUE, pAffectedAttrTypes))) { return FALSE; // Failed } } } // add all necessary attrs to each child object in the group for (Node* Current=FindFirstChild(); Current!=NULL; Current=Current->FindNext()) { if (RecursiveForChildren && Current->IsCompound()) ((NodeRenderableInk*)Current)->LocaliseCommonAttributes(FALSE, FALSE, NULL, TRUE); if (Current->IsAnObject()) { NodeRenderableInk* pObject = (NodeRenderableInk*)Current; BOOL ChkForDups = CheckForDuplicates; Node* pRoot = RecursiveForChildren ? NULL : this; if(!pObject->MakeAttributeComplete(pRoot,ChkForDups,pAffectedAttrTypes)) return FALSE; // out of memory } } return TRUE; }

BOOL NodeRenderableInk::LocaliseCommonAttributes (  BOOL  CheckForDuplicates = FALSE, BOOL  Global = FALSE, AttrTypeSet *  pAffectedAttrTypes = NULL, BOOL  RecursiveForChildren = FALSE )

This function is the opposite of the FactorOutCommonChildAttributes function it copies all attributes common to the compound to each child object within the compound which requires each attribute. The groups common attributes are deleted. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/94 Parameters: CheckForDuplicates,:  This should be TRUE if the children of this compound [INPUTS] node could have child attributes with the same type as the compound's attributes. This should never be the case. Global: TRUE indicates that we should localise the attributes on all parent compound nodes (top down), before localising the attributes for this compound. pAffectedAttrTypes: An optional set of attribute types. If this is specified then we only consider localising those attributes which have a type which is in this set. RecursiveForChildren: Passed onto the helper function, means that if we have children who are compound then they will have LocaliseCommonAttrs called on them also Parameters: -  [OUTPUTS] Returns: TRUE if successful FALSE if we run out of memory, in this situation the NodeRenderableInk is left unchanged The routine does not localise attributes on objects which can discard their child attributes (like the caret) Returns: Errors: - See also: NodeRenderableInk::FactorOutCommonChildAttributes Definition at line 847 of file ndoptmz.cpp. { // This function should only ever get called on a compound object ENSURE(IsCompound(), "LocaliseCommonAttributes called on a non compound object"); // First of all let's try and localise the attributes. This is the bit that can fail if (!LocaliseCommonAttrHelper(CheckForDuplicates, Global, pAffectedAttrTypes, RecursiveForChildren)) { // We ran out of memory so we must, delete all attributes which were localised DeleteFactoredOutAttribs(Global, pAffectedAttrTypes); return FALSE; } else { // We managed to localise all the attributes so it is now safe to delete // them from the compounds. DeleteLocalisedAttributes(Global, pAffectedAttrTypes); return TRUE; } }

BOOL NodeRenderableInk::MakeAttributeComplete (  Node *  Root = NULL, BOOL  CheckForDuplicates = TRUE, AttrTypeSet *  pAffectedAttrTypes = NULL, BOOL  IncludeDefaults = FALSE, BOOL  bIncludeEffectAttrs = FALSE )

This function should be called on a subtree prior to it being moved, either to a new position in the document, or to another document. It is also used to localise attributes; during an ungroup for example. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 7/2/94 Parameters: Root,:  The search for attributes will stop at this node. The [INPUTS] NULL default value means 'don't stop until we reach the top'. CheckForDuplicates: When TRUE a check is made to ensure that duplicate attribiutes are not added to the subtree (this is the default). When localising a groups attributes this check will be unneccessary. pAffectedAttrTypes: An optional set of attribute types. If this is specified then we only add attributes which have a type in this set. IncludeDefaults: When TRUE default attributes will be added. bIncludeEffectAttrs Only used when forcing effect attrs to become normal attrs (see Ungroup) TRUE to force attr scanning to find effect attrs as well as normal ones... -  [OUTPUTS] Returns: TRUE if successful FALSE if we run out of memory, the children of the node will remain unchanged It finds ALL attributes which are required by the subtree and adds them as first children. After the subtree has been moved to its new position, the function NodeRenderableInk::NormaliseAttributes should be called. See also: NodeRenderableInk::NormaliseAttributes Range::MakeAttributeComplete Definition at line 183 of file ndoptmz.cpp. { Node* Current = NULL; // Pointer to the current node in the tree NodeAttribute* CurAttr; CCRuntimeClass* AttrType; BOOL Exists; Node* PreFirstChild = FindFirstChild(); // Remember the FirstChild of the node before we add // any new attributes, this will come in handy if we // need to abort. // Loop until all attributes are copied, we are not interested in the defaults cos these are the // same for all docs !. if (bIncludeEffectAttrs) Current = NodeAttribute::FindFirstAppliedAttr(this, Root); else Current = NodeAttribute::FindPrevAppliedAttr(this, Root); while (Current && (IncludeDefaults || (!(IS_A(Current->FindParent(), NodeDocument)))) ) { // Find the next node, snaking up the tree if (Current->IsAnAttribute()) { CurAttr = (NodeAttribute*)Current; if (CurAttr->CanBeAppliedToObject() && CurAttr->ShouldBeOptimized()) { AttrType = CurAttr->GetAttributeType(); BOOL Required = RequiresAttrib(AttrType) || this->IsCompound(); // Is the attribute required ? if (Required && (!pAffectedAttrTypes || pAffectedAttrTypes->InSet(AttrType))) { Exists = FALSE; if (CheckForDuplicates) { // triggers can have duplicates if(!CurAttr->CanBeMultiplyApplied()) { // Does the node already have this child attribute Exists = (GetChildAttrOfType(AttrType) != NULL); } } #ifdef _DEBUG if (!CheckForDuplicates) { // If we feel there is no need to check for duplicates then there shouldn't be any ! if (!CurAttr->CanBeMultiplyApplied()) { NodeAttribute* pChildAttr = GetChildAttrOfType(AttrType); if ((pChildAttr != NULL)) { #if DEBUG_TREE DebugTreeDlg::DumpSubTree(this, 4); #endif TRACE(_T("Duplicate Attr found at %x %s\n"), pChildAttr, pChildAttr->GetRuntimeClass()->m_lpszClassName); } // ERROR3IF((pChildAttr != NULL), "MakeAttributeComplete: Duplicate attr found !"); } } #endif if (!Exists) { // Make a copy of the attribute NodeAttribute* NewAttr = (NodeAttribute*)CurAttr->SimpleCopy(); if (NewAttr == NULL) { goto OutOfMemory; } // Now add the attribute to this node NewAttr->AttachNode(this, FIRSTCHILD, TRUE, FALSE); } } } } Current = NodeAttribute::FindPrevAppliedAttr(Current, Root); // in order to copy brush ink nodes we need to break if the parent is NULL, else is violates if (Current!=NULL && Current->FindParent() == NULL) break; } return TRUE; OutOfMemory: // Delete any new attributes added to the node Current = FindFirstChild(); Node* Next; while (Current != PreFirstChild) { ENSURE(Current != NULL, "PreFirstChild could not be found"); ENSURE(Current->IsAnAttribute(), "Should be a NodeAttribute"); Next = Current->FindNext(); // Delete the attribute Current->CascadeDelete(); delete Current; Current = Next; } return FALSE; }

void NodeRenderableInk::NormaliseAttributes (   )

This function should be called whenever an attribute-complete node is inserted into the tree (whether it's a new node, or a node which has been moved from elsewhere). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 9/2/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - It removes all child attributes of the node which are the same type and value as attributes defined further up the tree eg. the defaults Returns: Errors: - See also: NodeRenderableInk::MakeAttributeComplete Definition at line 318 of file ndoptmz.cpp. { NodeAttribute* ChildAttribute; NodeAttribute* GlobalAttribute; Node* LocalScan; Node* NextLocal; // Scan the child attribute block LocalScan = FindFirstChild(); // Stop if we hit an object or if there are no more children // NOTE: Stopping scanning when we find the first RendereblInk node prevents // Effect attributes being Normalised. THIS IS DELIBERATE! while((LocalScan != NULL) && (!LocalScan->IsAnObject())) { // Hand over hand (LocalScan may get deleted) NextLocal = LocalScan->FindNext(); if(LocalScan->IsAnAttribute() && ((NodeAttribute*)LocalScan)->ShouldBeOptimized()) // cos it could be a NodeHidden { ChildAttribute = (NodeAttribute*)LocalScan; // We now need to search up the tree to see if ChildAttribute is redundant // Node* GlobalScan = FindPreviousEffectiveNode(); Node* GlobalScan = NodeAttribute::FindPrevAppliedAttr(this); // Search until we can go no higher while (GlobalScan != NULL) { if (GlobalScan->IsAnAttribute()) { GlobalAttribute = (NodeAttribute*)GlobalScan; // An attribute has been found, is it the same class as ChildAttribute ? if(GlobalAttribute->GetRuntimeClass() == ChildAttribute->GetRuntimeClass()) { // Yes it is, so let's check if they are equal if ((*GlobalAttribute)==(*ChildAttribute)) { // They are equal so we can nuke the child object because it's // redundant ChildAttribute->CascadeDelete(); delete ChildAttribute; } break; // don't search any further } } // GlobalScan = GlobalScan->FindPreviousEffectiveNode(); // climb higher GlobalScan = NodeAttribute::FindPrevAppliedAttr(GlobalScan); } } LocalScan = NextLocal; // Get the next child } }

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

Allows the Node to respond to popup menu clicks by adding items to the popup menu if required. It also allows the node to prevent the menu appearing at all! This functions should be overridden in the all the NodeRenderableInk classes so that this verion never gets called. Eg the NodePath class might claim the click if it happened over one of its blobs. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/04/95 Parameters: pSpread  The spread in which the action's occuring [INPUTS] PointerPos The Location of the mouse pointer at the time of the click pMenu The menu to which items should be added Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented in NodePath. Definition at line 3362 of file noderend.cpp. { // we do not want to claim the click, so return FALSE return FALSE; }

BOOL NodeRenderableInk::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: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/93 Parameters: PointerPos  - The Location of the mouse pointer at the time of the click [INPUTS] Click - The type of click received (single, double, drag etc) ClickMods - The modifiers to the click (eg shift, control etc ) Returns: BOOL - TRUE if the node claims the click as its own and FLASE if it is not interested in the click This function should be overridden in the all the NodeRenderableInk classes so that this verion never gets called. Eg the NodePath class might claim the click if it happened over one of its unselected blobs. Karim 07/04/2000 With the advent of ToolObject blobs, this method can now be called when Object blobs are not showing. What this means is that when this method is called, you should *check* that conditions are right for you to respond. eg if BlobManager's current interest does not include Object blobs, you may not want to do anything. Reimplemented in NodeGroup, NodeGuideline, NodeClipViewController, NodeMouldGroup, NodeBlender, NodeBlend, NodeBitmap, NodeMoulder, NodeMould, NodePath, NodeRegularShape, and NodeSimpleShape. Definition at line 3329 of file noderend.cpp. { // we do not want to claim the click, so return FALSE return FALSE; }

BOOL NodeRenderableInk::OnMouseMove (  const DocCoord &  dcPos, Spread *  pSpread, ClickModifiers  mods )  [virtual]

Called by the selector tool for the selected object(s) when the mouse is moved. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Parameters: dcPos  the current mouse position, in spread coordinates [INPUTS] pSpread the spread containing the mouse position mods which keys/buttons are down, eg. Adjust (shift/right button) -  [OUTPUTS] Returns: TRUE if the node did something with this call, FALSE if it didn't/won't Errors: - See also: NodeRenderableInk::OnClick; NodeRenderableInk::GetStatusInfo Definition at line 200 of file hittest.cpp. { #ifdef _DEBUG // if (IsUserName("JustinF")) // { // TRACE( _T("Call to base class NodeRenderableInk::OnMouseMove for a %s\n"), (LPCTSTR) Name()); // } #endif return FALSE; }

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

Allows the Node to respond to popup menu clicks by adding items to the popup menu if required. It also allows the node to prevent the menu appearing at all! This functions should be overridden in the all the NodeRenderableInk classes so that this verion never gets called. Eg the NodePath class might claim the click if it happened over one of its blobs. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/04/95 Parameters: pSpread  The spread in which the action's occuring [INPUTS] PointerPos The Location of the mouse pointer at the time of the click pMenu The menu to which items should be added Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented in NodeGuideline, NodeBevel, NodeBlend, NodeBitmap, NodeContour, NodeMould, NodePath, NodeRegularShape, VisibleTextNode, and TextStory. Definition at line 3397 of file noderend.cpp. { // we do not want to claim the click, so return FALSE return FALSE; }

BOOL NodeRenderableInk::ReadPostChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Reimplemented from Node. Definition at line 4565 of file noderend.cpp. { return ReadPostChildrenWeb(pFilter); }

BOOL NodeRenderableInk::ReadPostChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

This function is called during the importing of the file. > virtual BOOL Node::ReadPostChildrenWeb(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/96 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise A node gets called via this function after all its children have been imported. This allows complex nodes (such as moulds) to do some post-import work, which can only be done after all its children have been read in and created. See also: CanWriteChildrenWeb(), WritePreChildrenWeb() Reimplemented from Node. Definition at line 4559 of file noderend.cpp. { SafeToRender = NodeRenderableBounded::ReadPostChildrenWeb(pFilter); return SafeToRender; }

void NodeRenderableInk::RedrawObject (   )

Invalidates the Bounding rectangle of the node, causing it to be redrawn. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 11/11/93 Definition at line 3860 of file noderend.cpp. { // Find this nodes parent spread Spread* pSpread = FindParentSpread(); // Find the owner document (could do it on this node, but leaping to spread // directly is slighlt quicker). BaseDocument *pDoc = pSpread->FindOwnerDoc(); if ((pSpread != NULL) && (pDoc != NULL)) { // Invalidate region (if we're in a real document) if (IS_A(pDoc, Document)) ((Document *) pDoc)->ForceRedraw(pSpread, GetBoundingRect(), FALSE, this); else // Not in a real document - ought to complain. // (If this ERROR3 proves to be a problem then could be removed - Tim) ERROR3("Trying to redraw an object that is in a BaseDocument!"); } }

void NodeRenderableInk::RemoveSuperfluousAttribs (   )  [private]

void NodeRenderableInk::RenderAppliedAttributes (  RenderRegion *  pRegion  )  const [private]

Searches for all the attributes which apply to "this" ink-node, rendering them into the given render-region. Private helper function for NodeRenderableInk::FindSimpleAtPoint. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 16/6/94 Parameters: pRegion  --- pointer to the render-reigion the function should [INPUTS] render attributes into. -  [OUTPUTS] Returns: - Errors: - See also: NodeRenderableInk::FindSimpleAtPoint Definition at line 1317 of file hittest.cpp. { // If we are missing some attributes then search until we find all of them. FindAppliedAttributes(pAttribMap, nMaxAttributes, &nFoundAttributes); // Make sure our dummy flat fill, that will be used in the // place of any 'fancy' fills, is set up. *(DummyFill.GetStartColour()) = DocColour(COLOUR_BLACK); // OK, we have found the full quota of attributes. Now render them all. CCAttrMap::iterator pos = pAttribMap->GetStartPosition(); while( pos != pAttribMap->GetEndPosition() ) { CCRuntimeClass* pKey; void* pVal; pAttribMap->GetNextAssoc(pos, pKey, pVal); // Get the 'Family' of Attributes the fill belongs to CCRuntimeClass* AttrFamily = ((NodeAttribute*) pVal)->GetAttributeType(); // Get the actual fill type CCRuntimeClass* AttrClass = ((NodeAttribute*) pVal)->GetRuntimeClass(); // Check for a Transparency fill. // We can ignore them, as they do not effect hit testing. if ( AttrFamily != CC_RUNTIME_CLASS(AttrTranspFillGeometry) ) { // Is this a fancy fill type ? if ( AttrFamily == CC_RUNTIME_CLASS(AttrFillGeometry) && AttrClass != CC_RUNTIME_CLASS(AttrFlatColourFill) ) { if (AttrClass == CC_RUNTIME_CLASS(AttrBitmapColourFill) && ((NodeAttribute*) pVal)->NeedsTransparency()) { // It must be a masked bitmap, so we'll need to render it. // The render code will check the 'VeryMono' flag, and render // the bitmap non-masked pixels as black ((NodeAttribute*) pVal)->Render(pRegion); } else { // Yes, so just render a black flat fill DummyFill.Render(pRegion); } } else { // It's only a flat fill, so we might as well render it. // This will allow 'no colour' fills to work too. ((NodeAttribute*) pVal)->Render(pRegion); } } } }

void NodeRenderableInk::RenderAppliedClipAttributes (  RenderRegion *  pRender  )  const [private]

Helper method for RenderAppliedAttributes(). Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 13/04/2000 Parameters: pRender  the render region to render into. [INPUTS] The  given render region will have its clipping region reduced to the clip [OUTPUTS] region which would apply to this node in the normal course of rendering. Render all ClipRegionAttributes which would be applied to this node in the normal render-loop. This actually gets a little complicated, as these attrs are rendered by NodeClipView nodes, so we need to go up the tree looking for NodeClipViewController nodes, then getting their NodeClipView nodes to render the clip-attribute.Things are complicated more by the fact that a ClipView clips all nodes below a NCVC *except* the keyhole node of that NCVC, which is *not* clipped. Notes: This is a bit of a BODGE, but is required because ClipRegionAttributes are not stored in the tree inside a NodeAttribute, and are therefore not picked up on by the normal RenderAppliedAttributes() process. See also: RenderAppliedAttributes(). Definition at line 1400 of file hittest.cpp. { // 1. pRefNode starts on this node. We look for a NCVC which clips pRefNode, add it to // our list, and then that NCVC becomes the new pRefNode to work from. // // 2. To find a NCVC which clips us, we go straight up the tree. If we find a NCVC, // then we check whether its child which we came from is also one of its keyhole // nodes. If so, we ignore it and continue. If not, then it must clip us, and // therefore the NCVC becomes the new pRefNode. // // 3. We repeat the process until we hit a layer node, which marks the top of this // branch of the tree. // Node* pRefNode = (Node*) this; std::list<NodeClipViewController*> lNCVC; BOOL bFinished = FALSE; while (!bFinished) { // go up the tree until we reach the top or we reach a NCVC // for which we are not a keyhole node. Node* pChild = pRefNode; Node* pParent = pRefNode->FindParent(); BOOL bFoundApplicableNCVC = pParent->IsANodeClipViewController() && !((NodeClipViewController*)pParent)->OwnsAsKeyholeNode(pChild); while (pParent != NULL && !pParent->IsLayer() && !bFoundApplicableNCVC) { pChild = pParent; pParent = pParent->FindParent(); bFoundApplicableNCVC = pParent->IsANodeClipViewController() && !((NodeClipViewController*)pParent)->OwnsAsKeyholeNode(pChild); } if (bFoundApplicableNCVC) { lNCVC.push_front((NodeClipViewController*) pParent); pRefNode = pParent; } else { bFinished = TRUE; } } // ok, now go through the list in reverse order, telling the NCV belonging to each NCVC // to render is ClipRegionAttribute. NodeClipView* pClipView = 0; NodeClipViewController* pNCVC = 0; while (!lNCVC.empty()) { pNCVC = lNCVC.back(); lNCVC.pop_back(); pClipView = pNCVC->GetClipView(); if (pClipView != 0) { // DEBUG: // TRACEUSER( "Karim", _T("NRInk::RenderAppliedClipAttrs; NCVC: 0x%x\n"), (DWORD)pNCVC); pClipView->RenderClipAttr(pRender); } } // DEBUG: // TRACEUSER( "Karim", _T("NRInk::RenderAppliedClipAttrs; this: 0x%x; %s\n"), // (DWORD)this, this->Name()); }

void NodeRenderableInk::RenderAppliedFillBlobs (  RenderRegion *  pRender  )  [virtual]

Draws the Fill blobs of an ink object. It does this by calling all the attributes that are its immediate children and asking them to render their Fill Blobs. If any of them happen to be items such as Graduated fills, then blobs will appear. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 24/6/94 Parameters: pRender  - The region to render the blobs into [INPUTS] Reimplemented from NodeRenderable. Definition at line 3141 of file noderend.cpp. { #if !defined(EXCLUDE_FROM_RALPH) CCAttrMap* pAttribMap = new CCAttrMap(30); if (pAttribMap == NULL) return; // Find the topmost effect applied to this node // So that we can test whether it has preferential effect attributes Node* pEffectNode = FindParent(); NodeEffect* pTopEffectNode = NULL; while (pEffectNode && pEffectNode->IsEffect()) { // BODGE! we happen to know that shadow controllers can't have effect attrs applied to them // Would be better of there were some nice way to ask effect nodes about this. if (!pEffectNode->IsAShadowController()) pTopEffectNode = (NodeEffect*)pEffectNode; pEffectNode = pEffectNode->FindParent(); } // Now find any attributes that are applied to this node. BOOL FoundAttrs = FindAppliedAttributes(pAttribMap, 5000, NULL, FALSE); if (FoundAttrs) { // iterating all (key, value) pairs for (CCAttrMap::iterator Pos = pAttribMap->GetStartPosition(); Pos != pAttribMap->GetEndPosition();) { CCRuntimeClass *pType; void *pVal; pAttribMap->GetNextAssoc(Pos,pType,pVal); NodeAttribute* pAttr = (NodeAttribute*)pVal; // Only render fill blobs for the applied attribute if it can't // be overridden by a preferential effect attribute above... if (pTopEffectNode==NULL || (pTopEffectNode!=NULL && !pTopEffectNode->IsValidEffectAttr(pAttr))) pAttr->RenderFillBlobs(pRender); } } delete pAttribMap; #endif }

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

Draws the Artistic blobs of an ink object. It does this by calling all the attributes that are its immediate children and asking them to render their Artistic Blobs. If any of them happen to be items such as Pressure attributes or some other artistic effect then blobs will appear. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 24/6/94 Parameters: pRender  - The region to render the blobs into [INPUTS] Reimplemented from NodeRenderable. Definition at line 3247 of file noderend.cpp. { #if !defined(EXCLUDE_FROM_RALPH) CCAttrMap* pAttribMap = new CCAttrMap(30); if (pAttribMap == NULL) return; // Now find any attributes that are applied to this node. BOOL FoundAttrs = FindAppliedAttributes(pAttribMap); if (FoundAttrs) { // iterating all (key, value) pairs for (CCAttrMap::iterator Pos = pAttribMap->GetStartPosition(); Pos != pAttribMap->GetEndPosition();) { CCRuntimeClass *pType; void *pVal; pAttribMap->GetNextAssoc(Pos,pType,pVal); NodeAttribute* pAttr = (NodeAttribute*)pVal; pAttr->RenderArtisticBlobs(pRender); } } delete pAttribMap; #endif }

virtual BOOL NodeRenderableInk::RenderDirectBitmapState (  RenderRegion *  pRender  )  [inline, virtual]

Reimplemented in NodeBitmapEffect. Definition at line 262 of file ink.h. {return FALSE;}

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

Draws the Effect blobs of an ink object. It does this by calling all the attributes that are its immediate children and asking them to render their Fill Blobs. If any of them happen to be items such as Graduated fills, then blobs will appear. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/01/2005 Parameters: pRender  - The region to render the blobs into [INPUTS] Reimplemented from NodeRenderable. Definition at line 3200 of file noderend.cpp. { #if !defined(EXCLUDE_FROM_RALPH) Node* pEffectNode = FindParent(); Node* pTopEffectNode = NULL; while (pEffectNode && pEffectNode->IsEffect()) { // BODGE! we happen to know that shadow controllers can't have effect attrs applied to them // Would be better of there were some nice way to ask effect nodes about this. if (!pEffectNode->IsAShadowController()) pTopEffectNode = pEffectNode; pEffectNode = pEffectNode->FindParent(); } if (pTopEffectNode && pTopEffectNode->IsBounded()) { if (pTopEffectNode!=this) ((NodeRenderableBounded*)pTopEffectNode)->RenderEffectBlobs(pRender); // Allow any effect attributes to render their blobs... NodeAttribute* pAttr = (NodeAttribute*)pTopEffectNode->FindLastChild(CC_RUNTIME_CLASS(NodeAttribute)); while (pAttr && pAttr->IsEffectAttribute()) { pAttr->RenderFillBlobs(pRender); pAttr = (NodeAttribute*)pAttr->FindPrevious(CC_RUNTIME_CLASS(NodeAttribute)); } } #endif }

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

Each class derived from NodeRenderableInk should write a version of this member function. In most cases it will be the same as the Render() member function but some of the nodes (such as groups) need to perform special actions. The function is for drawing the object while it is being dragged about by the selector tool. It should do this with an effective wysiwyg level of 0 so that the drawing is fast. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/93 Parameters: pRender  - A pointer to a render region to draw in [INPUTS] Reimplemented in NodeContourController, NodeBlendPath, NodeBrushMaker, NodeBrushPath, NodeClipViewController, NodeMouldGroup, NodeMouldPath, NodeBevel, NodeBlender, NodeClipView, NodeContour, NodePath, NodeRegularShape, NodeSimpleShape, and TextChar. Definition at line 3052 of file noderend.cpp. { // This function does nothing. It is a virtual function and should be replaced by // derived class versions of it }

void NodeRenderableInk::RenderEorDragChildren (  RenderRegion *  pRender  )  [virtual]

Recursively calls RenderEorDrag for all children of this node, ignoring nodes which have ChildrenAreEorDragRenderedByMe() returning TRUE. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 19/1/2000 Parameters: pRender  - Render region to use [INPUTS] See also: NodeRenderableInk::RenderEorDrag, NodeRenderableInk::ChildrenAreEorDragRenderedByMe Reimplemented in NodeMouldGroup. Definition at line 3073 of file noderend.cpp. { Node * pNode = FindFirstChild(); while (pNode) { if (pNode->IsAnObject()) { if (pNode->IsCompound()) { if (((NodeRenderableInk *)pNode)->ChildrenAreEorDragRenderedByMe()) { // just render this node ((NodeRenderableInk *)pNode)->RenderEorDrag(pRender); } else { ((NodeRenderableInk *)pNode)->RenderEorDragChildren(pRender); ((NodeRenderableInk *)pNode)->RenderEorDrag(pRender); } } else { ((NodeRenderableInk *)pNode)->RenderEorDrag(pRender); } } pNode = pNode->FindNext(); } }

BOOL NodeRenderableInk::RequiresAttrib (  NodeAttribute *  pAttr, BOOL  Search = FALSE )  [virtual]

To determine if the node requires the pAttr to render itself. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/7/94 Parameters: pAttr,:  An attribute [INPUTS] Search: This flag only applies to compound objects. It specifies if we should search the compound to find out if any child requires the attribute. By default time is considered more important than truth, and TRUE is returned on compound objects. Returns: The answer to this question Reimplemented in NodeBevel, NodeBitmap, and NodeClipView. Definition at line 4147 of file noderend.cpp. { CCRuntimeClass* AttribType = pAttr->GetAttributeType(); // Call fn which takes type return RequiresAttrib(AttribType, Search); }

BOOL NodeRenderableInk::RequiresAttrib (  CCRuntimeClass *  AttribType, BOOL  Search = FALSE )  [virtual]

To determine if the node requires attribute AttribType to render itself. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/7/94 Parameters: AttribType,:  The type of the attribute [INPUTS] Search: This flag only applies to compound objects. It specifies if we should search the compound to find out if any child requires the attribute. By default time is considered more important than truth and TRUE is returned on compound objects. Returns: The answer to this question Reimplemented in NodeBevel, and NodeClipView. Definition at line 3988 of file noderend.cpp. { List* ReqdAttribList; if (!IsCompound()) { // Obtain the list of required attributes for this node ReqdAttribList = ObjectRegistry::GetRequiredAttribs(GetRuntimeClass()); //Is AttribClass in the list ? NodeAttributeClassItem* AttrClassItem = (NodeAttributeClassItem*)(ReqdAttribList->GetHead()); while (AttrClassItem != NULL) { if (AttrClassItem->AttributeClass == AttribType) { return TRUE; } AttrClassItem = (NodeAttributeClassItem*)(ReqdAttribList->GetNext(AttrClassItem)); } } else { if (Search) { // Ask the kids if they require the attribute (they will ask their kids etc.) Node* pChild = FindFirstChild(); NodeRenderableInk* pChildObject; while (pChild) { if (pChild->IsAnObject()) { pChildObject = (NodeRenderableInk*)pChild; if (pChildObject->RequiresAttrib(AttribType, Search)) return TRUE; } pChild = pChild->FindNext(); } } else return TRUE; // Assume the compound requires the attribute } return FALSE; // Not found (!IsCompound || IsCompound && Search cases ) }

void NodeRenderableInk::SelectAllInRect (  DocRect  Rect, Spread *  pSpread, NodeRenderableInk::SelStateAction  st = SET )  [static]

Selects all the objects that are wholly inside the supplied rectangle. It will draw in all the EORed blobs of the objects that it selects/deselects. rewritten by Simon so that objects on locked layers do not get selected also more optimal. (st parameter etc added by JCF 1.11.94). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> / JustinF Date: 15/9/93 Parameters: Rect  - The Rectangle to act as a bounding box for the selection [INPUTS] Spread - The spread on which to select the objects st - either CLEAR, SET, or TOGGLE, which is what should be done to the selection state of each object within the rectangle. See also: NodeRenderableInk::DeselectAll Definition at line 3742 of file noderend.cpp. { // Make sure we are not being told garbage ERROR3IF(pSpread == NULL, "No spread in NodeRenderableInk::SelectAllInRect"); ERROR3IF(pSpread->FindFirstLayer() == NULL, "No layer in NodeRenderableInk::SelectAllInRect"); // Make all objects on modifiable layers within the given bounding box selected or // whatever. for (Layer* pLayer = pSpread->FindFirstLayer(); pLayer != NULL; pLayer = pLayer->FindNextLayer()) { if (!pLayer->IsLocked() && pLayer->IsVisible() && pLayer->GetBoundingRect().IsIntersectedWith(Rect)) { // The current layer is not locked so select all objects which intersect // with rect /* Range rng(pLayer->FindFirstChild(), NULL, RangeControl(TRUE, TRUE)); for (Node* pNode = rng.FindFirst(); pNode != NULL; pNode = rng.FindNext(pNode)) { // make sure it is a Renderable Ink Node if (pNode->IsAnObject()) { ((NodeRenderableInk*)pNode)->SelectInRect(Rect, st); } } */ Node* pNode = pLayer->FindFirstChild(); while (pNode) { // make sure it is a Renderable Ink Node if (pNode->IsAnObject()) { ((NodeRenderableInk*)pNode)->SelectInRect(Rect, st); } pNode = pNode->FindNext(); } } } // Update the selection cache GetApplication()->UpdateSelection(); }

void NodeRenderableInk::SelectInRect (  const DocRect &  Rect, SelStateAction  st )  [virtual]

Helper method for the static fn SelectAllInRect() used by marquee select. This method changes the selection state of this node according to the given bounding rectangle and sel-state action. Most nodes will want to use the default behaviour, which is to select themselves if their bounds lie within the given bounding rectangle. If you want to do something special with the marquee select, then override this method. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 14 April 2000 Parameters: Rect  const reference to the bounding rect to use. [INPUTS] st the selection state, ie SET/TOGGLE/CLEAR. This  node may have its selection status changed, depending on the inputs. [OUTPUTS] Notes: This method is meant to be called solely from SelectAllInRect() - if you wish to call it from elsewhere, it *may* work as you expect, but it is a good idea that you check your assumptions on what preconditions are necessary. Returns: Errors: ERROR3 in DEBUG if st holds an invalid state. See also: SelectAllInRect(). Definition at line 3819 of file noderend.cpp. { // ok, check whether we lie within the given rect. if (Rect.ContainsRect(GetBoundingRect())) { switch (st) { case CLEAR: DeSelect(TRUE); break; case SET: Select(TRUE); break; case TOGGLE: if (IsSelected()) DeSelect(TRUE); else Select(TRUE); break; default: ERROR3("NodeRenderableInk::SelectInRect; Unknown SelStateAction!\n"); break; } } }

BOOL NodeRenderableInk::SetParentLayerAsEdited (   )  [virtual]

Mark parent layer as edited. If an ink object as something done to it which changes its appearance then we need to mark the parent layer as edited. In this class we actually do the work as these are visible objects in the tree. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 31/7/97 Returns: True if worked ok, False otherwise Reimplemented from Node. Definition at line 4589 of file noderend.cpp. { // New 31/7/97 Neville // Mark the parent layer as edited as something has changed on it Layer * pLayer = (Layer*) FindParent(CC_RUNTIME_CLASS(Layer)); if (pLayer) { // Note that this layer has been edited pLayer->SetEdited(TRUE); #ifdef _DEBUG // Tell the frame gallery to update its display of the frame BROADCAST_TO_ALL(LayerMsg(pLayer, LayerMsg::REDRAW_LAYER)); #endif } return TRUE; }

Node * NodeRenderableInk::SimpleCopy (  void   )  [protected, virtual]

This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/93 Returns: A copy of the node, or NULL if memory runs out Errors: If memory runs out when trying to copy, then ERROR is called with an out of memory error and the function returns NULL. Scope: protected Reimplemented from NodeRenderableBounded. Reimplemented in NodeGroup, NodeGuideline, NodeContourController, NodeBlendPath, NodeBrushMaker, NodeBrushPath, NodeClipViewController, NodeMouldGroup, NodeMouldBitmap, NodeMouldPath, NodeAnimatingBitmap, NodeBevel, NodeBlender, NodeBlend, NodeBitmap, NodeBrush, NodeClipView, NodeContour, NodeEllipse, NodeLiveEffect, NodeLockedEffect, NodeFeatherEffect, NodeMoulder, NodeMould, NodePath, NodeEffect, NodeRect, NodeRegularShape, NodeSimpleShape, VisibleTextNode, AbstractTextChar, TextChar, KernCode, HorizontalTab, CaretNode, EOLNode, TextLine, BaseTextClass, and TextStory. Definition at line 3291 of file noderend.cpp. { NodeRenderableInk* NodeCopy; NodeCopy = new NodeRenderableInk(); if (NodeCopy) NodeRenderableBounded::CopyNodeContents(NodeCopy); return (NodeCopy); }

BOOL NodeRenderableInk::WillWriteBounds (  BaseCamelotFilter *  pFilter  )  [virtual]

Determines if the down/up pair need to be written. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/05 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if this node will write out a bounds record Reimplemented in NodeGroup, and NodeBitmapEffect. Definition at line 2453 of file noderend.cpp. { return(pFilter->GetBoundsWriteLevel() >= BWL_ALL); }

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

Begin to write out you child records, in the native format. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/05 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise The base class will write out a TAG_DOWN record, but only if it has a child ptr See also: WritePostChildrenWeb(), WritePreChildrenWeb() Reimplemented from Node. Reimplemented in NodeBlender, NodePath, TextLine, and TextStory. Definition at line 2386 of file noderend.cpp. { BOOL bNeedDown = FALSE; BOOL ok = TRUE; Node* pChild = FindFirstChild(); if (pChild != NULL) { // The node is considered to have children ONLY if at least one child is not a hidden node. if (!pChild->IsNodeHidden() || (pChild->FindNextNonHidden() != NULL)) { bNeedDown = TRUE; } } BOOL bBounds = WillWriteBounds(pFilter); if (bNeedDown || bBounds) { ok = pFilter->WriteZeroSizedRecord(TAG_DOWN); if (ok && bBounds) ok = WriteBoundsRecord(pFilter); } return(ok); }

BOOL NodeRenderableInk::WriteBeginChildRecordsWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Begin to write out you child records, in the web format. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/05 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise The base class will write out a TAG_DOWN record, but only if it has a child ptr See also: WritePostChildrenWeb(), WritePreChildrenWeb() Reimplemented from Node. Reimplemented in NodeBlender, TextLine, and TextStory. Definition at line 2365 of file noderend.cpp. { return(WriteBeginChildRecordsNative(pFilter)); }

BOOL NodeRenderableInk::WriteBoundsRecord (  BaseCamelotFilter *  pFilter  )  [virtual]

Write out a record containing the bounds of this object. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/05 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise Reimplemented in NodeGroup, NodeBlender, and NodeBitmapEffect. Definition at line 2425 of file noderend.cpp. { BOOL ok = TRUE; // Write out the record DocRect Rect = GetBoundingRect(); CamelotFileRecord Rec(pFilter, TAG_OBJECTBOUNDS, TAG_OBJECTBOUNDS_SIZE); ok = Rec.Init(); if (ok) ok = Rec.WriteCoord(Rect.lo); if (ok) ok = Rec.WriteCoord(Rect.hi); if (ok) ok = pFilter->Write(&Rec); return(ok); }

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

Finished writing out you child records, in the native format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/8/96 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise The base class will write out a TAG_UP record, but only if it has a child ptr See also: WritePostChildrenWeb(), WritePreChildrenWeb() Reimplemented from Node. Reimplemented in NodeBlender, NodePath, TextLine, and TextStory. Definition at line 2496 of file noderend.cpp. { BOOL bNeedUp = WillWriteBounds(pFilter); Node* pChild = FindFirstChild(); if (pChild != NULL) { // The node is considered to have children ONLY if at least one child is not a hidden node. if (!pChild->IsNodeHidden() || (pChild->FindNextNonHidden() != NULL)) bNeedUp = TRUE; } if (bNeedUp) return pFilter->WriteZeroSizedRecord(TAG_UP); return TRUE; }

BOOL NodeRenderableInk::WriteEndChildRecordsWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Finished writing out you child records, in the web format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/8/96 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise The base class will write out a TAG_UP record, but only if it has a child ptr See also: WritePostChildrenWeb(), WritePreChildrenWeb() Reimplemented from Node. Reimplemented in NodeBlender, TextLine, and TextStory. Definition at line 2475 of file noderend.cpp. { return WriteEndChildRecordsNative(pFilter); }

---

Member Data Documentation

BOOL NodeRenderableInk::AverageHitColour = FALSE [static, private]

If TRUE then click detection is done with rendering, else if FALSE it is done with rectangle intersection. Will be made obsolete once rendering methods are reliable. Defaults to TRUE. Preference: AverageHitColour Section: ? Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Range: TRUE or FALSE Definition at line 341 of file ink.h.

BOOL NodeRenderableInk::bUseSmartClicks = TRUE [static, private]

If TRUE then click detection is done with rendering, else if FALSE it is done with rectangle intersection. Will be made obsolete once rendering methods are reliable. Defaults to TRUE. Preference: SmartClicks Section: DebugFlags Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Range: TRUE or FALSE Definition at line 340 of file ink.h.

INT32 NodeRenderableInk::nFoundAttributes [static, private]

Definition at line 344 of file ink.h.

INT32 NodeRenderableInk::nMaxAttributes [static, private]

Definition at line 345 of file ink.h.

CCAttrMap * NodeRenderableInk::pAttribMap [static, private]

Definition at line 343 of file ink.h.

BOOL NodeRenderableInk::SafeToRender [private]

Definition at line 265 of file ink.h.

---

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

• Kernel/ink.h (r1785/r751)
• Kernel/hittest.cpp (r1785/r1282)
• Kernel/ndoptmz.cpp (r1785/r1282)
• Kernel/noderend.cpp (r1785/r1328)

---