NodeRenderableBounded Class Reference

As NodeRenderable, but with a bounding box describing the area this object occupies. This class also includes functions for use with attribute optimisation. More...

#include <node.h>

Inheritance diagram for NodeRenderableBounded:

List of all members.

Public Member Functions
	NodeRenderableBounded ()
	Default constructor.
	NodeRenderableBounded (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.
	~NodeRenderableBounded ()
	Since this node is dieing make sure that any cached data associated with it is also removed...
virtual void	GetDebugDetails (StringBase *Str)
	For obtaining debug information about the Node.
virtual SubtreeRenderState	RenderSubtree (RenderRegion *pRender, Node **ppNextNode=NULL, BOOL bClip=TRUE)
	Virtual function - this function will indicate to the caller whether or not we want to render the given node, according to the information passed in.
virtual void	Transform (TransformBase &)
	Base class transform function.
virtual void	TransformChildren (TransformBase &)
	Transforms the Child nodes of this node. This allows fills etc to move with the objects.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
virtual BOOL	CanTakeAttributeType (CCRuntimeClass *)
	This function will return TRUE when called on NodeRenderableBounded nodes and those derived from it. Determine whether or not a bounded node can take a particular kind of attribute. This is used for various objects, e.g. bitmap objects use it to accept transparent fill geometries but not normal ones, because they are always filled with the bitmap. Base class version always returns TRUE so by default an object supports all attribute types.
void	ValidateBoundingRect ()
	Marks this nodes bounding rect as valid again. You should not generally speaking be using this function. It was created so that new nodes could be sure of invalidating their parents bounding rects. DoInsertNewNode() is the only real case in which it can be used without express written permission from the UN.
virtual void	InvalidateBoundingRect (BOOL InvalidateChildBounds=FALSE)
	Marks the bounding rect of this node as invalid, as well as marking this nodes parents as invalid as well. Next time a nodes GetBoundingRect() function is called the bounding rect will be recalculated if needed.
virtual DocRect	GetBoundingRect (BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE)
	returns the nodes bounding rectangle. If the rectangle is valid the rectangle is simply returned, but is IsBoundingRectValid is FALSE (cos someone called InvaldateBoundingRect() on this node, or one of its children) then the bounding rect is first calculated and the flag reset, before it is returned. This is the base class version of this function and will build a bounding box out of the union of the nodes childrens bounding boxes. Your node MUST replace this function if this is not what you want it to do....
virtual DocRect	GetUnionBlobBoundingRect (BOOL bIncludeEffects=TRUE)
	This simply returns the result of GetBlobBoundingRect() as the default action for the base class.
virtual DocRect	GetEorDragBoundingRect ()
virtual DocRect	GetImagemapClickableRectangle ()
virtual DocRect	GetEffectStackBounds (BOOL *pbFoundEffects=NULL)
	Find the bounds of any effects which might be affected by changes to this node.
virtual void	IncludeChildrensBoundingRects (DocRect *)
	The child attribute Blob bounding rects are included in the BoundingRect. Note: re-written by Ed 25/4/95 Now only includes bounds of child attrs (rather than all NodeRenderableBounded) The assumption is that no child can be selected if it's parent is, so attr blobs of child nodes cannot be visible at the same time as their parents!
BOOL	IsIntersectedWith (DocRect *pClipRect)
	Determine if this node is intersected with the rectangle supplied.
virtual BOOL	IsBounded () const
virtual BOOL	Snap (DocCoord *pDocCoord)
	ALWAYS RETURNS FALSE! This is just a virtual base function intended to be overridden.
virtual BOOL	Snap (DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	ALWAYS RETURNS FALSE! This is just a virtual base function intended to be overridden. Scope: public.
virtual BOOL	SnapToCoords (DocCoord *pDocCoord)
	This is a form of Magnetic snapping. It Snaps the Coordinates to the Significant points around a shape. eg. It would snap to the EndPoints along a path, the centre and corners of a rectangle etc. This snapping is more powerful than the normal magnetic snapping, so that these significant points can be snapped to more easily. This is the base class version of the function and does no snapping at all. It always returns FALSE. If you want your node to make use of this sort of snapping, override this function and use the MagneticPointRadius to decide if the DocCoord is close enough to be snapped.
virtual BOOL	IsMagnetic ()
	Returns that magnetic state of this node Scope: public.
virtual void	SetMagneticState (BOOL state)
	Allows you to set the magnetic state of this node Scope: public.
virtual double	GetRotationAngle ()
	Call this function to obtain the current angle of rotation of the node. By default this is zero. Nodes derived from NodeRenderableBounded should override this function and return the angle of rotation using their own particular method Scope: public.
virtual BOOL	RenderCached (RenderRegion *pRender)
	Protected Helper function Allow this node to render itself using cached data if it has it and for that cached data to represent an arbitrary section of the document (usually a subtree but can be more).
virtual BOOL	CaptureCached (RenderRegion *pRender)
	Protected Helper function Use the CaptureManager to capture the results of rendering, cache them and associate them with this Ink node.
virtual BOOL	ReleaseCached (BOOL bAndParents=TRUE, BOOL bAndChildren=TRUE, BOOL bSelf=TRUE, BOOL bAndDerived=TRUE)
	Protected Helper function Use the CaptureManager to capture the results of rendering, cache them and associate them with this Ink node.
virtual void	CopyCached (NodeRenderableBounded *pCopyOfNode, double dRes, INT32 maxOption=0)
	Copy fixed res cached bitmaps associated with this node to be associated with the specified new node.
virtual void	CopyCached (NodeRenderableBounded *pCopyOfNode)
	Copy all cached bitmaps associated with this node to be associated with the specified new node.
virtual void	TransformCached (TransformBase &Trans, double dTestPixelWidth)
	Transform all the cached bitmaps associated with this node.
virtual BOOL	HasCachedDirectBitmap ()
BOOL	ContainsNonMixTransparency (RenderRegion *pRegion)
	Find out whether this node's subtree contains non-mix transparency. Useful for optimising cacheing because while you want things to be cached as 32BPP RGBT bitmaps most of the time, non-mix transparencies can't be captured that way and so some work ahs to be done to transform down to a 24BPP RGB bitmap - better to avoid that by calling this function.
virtual void	RenderEffectAttributes (RenderRegion *pRegion)
	Render any effect attributes attached to this node.
virtual BOOL	IsDifferent (Node *pOther)
	Determine if 2 nodes are considered different.
virtual DocCoord	FindExtendCentre ()
virtual DocRect	GetExtendTargetBounds (const ExtendParams &ExtParams)
	Return a DocRect which contains the bounds of this node as defined and required by the Extending mechanism.
Static Public Member Functions
static BOOL	Init ()
	Declare the preferences for the magnetic options. Now also declares the layers section rather than having a new explicit init in the layers section.
Static Public Attributes
static INT32	MagneticPointRadius = 750*6
	This is the radius around a control point (such as the corner of a rectangle, or the end point in the middle of a path) that will allow other points to be magnetically attracted to it. This is measured in millipoints.
static INT32	MagneticLineRadius = 750*4
	This is the radius around a path (such as the edges of a rectangle, or the whole of a path) that will allow other points to be magnetically attracted to it. This is measured in millipoints.
static BOOL	bEnableCacheing = TRUE
	Enable or disable bitmap cacheing of parts of the tree during GRenderRegion rendering.
static BOOL	bThrottleCacheing = TRUE
	TRUE - Throttle cacheing to be 5% of total rendering time or less.
static BOOL	bShowCacheBlobs = FALSE
	TRUE - Show special markers when cached groups are selected.
Protected Member Functions
BOOL	IsMagneticallyClose (DocCoord *, DocCoord *)
	Tests to see if the 2 coordinates are close enough together to qualify as Magnetically close to each other. If they are, then pOriginalCoord is Modified to match pTestCoord and TRUE id returned. If not, then all the coords are left alone and FALSE is returned.
virtual Node *	SimpleCopy ()
	This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes.
void	CopyNodeContents (NodeRenderableBounded *NodeCopy)
	This method copies the node's contents to the node pointed to by NodeCopy.
Protected Attributes
BOOL	IsBoundingRectValid
DocRect	BoundingRectangle
BOOL	Magnetic
BOOL	MayBeCached
Private Member Functions
void	InvalidateBoundingRectHelper ()
	Marks the bounding rect of this node as invalid, as well as marking this nodes parents as invalid as well. Next time a nodes GetBoundingRect() function is called the bounding rect will be recalculated if needed.

---

Detailed Description

As NodeRenderable, but with a bounding box describing the area this object occupies. This class also includes functions for use with attribute optimisation.

Author:

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

Date:

14/04/94

See also:

NodeRendereable

Definition at line 1317 of file node.h.

---

Constructor & Destructor Documentation

NodeRenderableBounded::NodeRenderableBounded (   )

Default constructor. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 14/04/94 Definition at line 1134 of file noderend.cpp. :NodeRenderable() { IsBoundingRectValid = FALSE; Magnetic = FALSE; MayBeCached = FALSE; // Definitely not cached }

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

This method initialises the node and links it to ContextNode in the direction specified by Direction. All necessary tree links are updated. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/93 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] Direction: Specifies the direction in which the node is to be attached to the ContextNode. The values this variable can take are as follows: PREV : Attach node as a previous sibling of the context node NEXT : Attach node as a next sibling of the context node FIRSTCHILD: Attach node as the first child of the context node LASTCHILD : Attach node as a last child of the context node The remaining inputs specify the status of the node: Locked: Is node locked ? Mangled: Is node mangled ? Marked: Is node marked ? Selected: Is node selected ? Returns: Errors: An assertion error will occur if ContextNode is NULL Definition at line 1169 of file noderend.cpp. : NodeRenderable(ContextNode, Direction, Locked, Mangled, Marked, Selected) { IsBoundingRectValid = FALSE; Magnetic = FALSE; Dragged = FALSE; MayBeCached = FALSE; // Definitely not cached }

NodeRenderableBounded::~NodeRenderableBounded (   )

Since this node is dieing make sure that any cached data associated with it is also removed... Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 25/06/2004 Parameters: -  [INPUTS] [OUTPUTS]  Returns: - Errors: Definition at line 1197 of file noderend.cpp. { if (MayBeCached) { // There could be some cached bitmaps associated with this node CBitmapCacheKey mykey(this, 42); CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache) { // Get rid of EVERYTHING - we are dying! pBitmapCache->RemoveAllOwnedBitmaps(mykey, FALSE, CACHEPRIORITY_PERMANENT); } } }

---

Member Function Documentation

BOOL NodeRenderableBounded::CanTakeAttributeType (  CCRuntimeClass *   )  [virtual]

This function will return TRUE when called on NodeRenderableBounded nodes and those derived from it. Determine whether or not a bounded node can take a particular kind of attribute. This is used for various objects, e.g. bitmap objects use it to accept transparent fill geometries but not normal ones, because they are always filled with the bitmap. Base class version always returns TRUE so by default an object supports all attribute types. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 31/08/94 Parameters: pAttrClass  - specifies the type of attribute being enquired about. [INPUTS] Returns: TRUE => object supports this kind of attribute. FALSE => object does not support this kind of attribute, and so it should not be applied. Definition at line 1620 of file noderend.cpp. { return TRUE; }

BOOL NodeRenderableBounded::CaptureCached (  RenderRegion *  pRender  )  [virtual]

Protected Helper function Use the CaptureManager to capture the results of rendering, cache them and associate them with this Ink node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/2004 Returns: TRUE if captured data was cached See also: NodeRenderableBounded::RenderCached Definition at line 2742 of file noderend.cpp. { // If cacheing is disabled bale out now! if (!NodeRenderableBounded::bEnableCacheing) return FALSE; Capture* pCapture = pRender->GetTopCapture(); if (pCapture==NULL) // If nothing was captured return FALSE; // Then do nothing // Only stop the capture if we started it // (means we only capture whole subtrees at the mo.) if (pCapture->GetOwner()==this) { #if defined(_WIN32) LARGE_INTEGER countStart; LARGE_INTEGER countEnd; QueryPerformanceCounter(&countStart); #endif // End this capture: // Blit capture to screen // Retain bitmap because we will release it ourselves only if we fail to cache it BOOL bCached = FALSE; LPBITMAPINFO lpInfo = NULL; LPBYTE lpBits = NULL; DocRect CaptureRect = GetBoundingRect(); // Set maximum size we allow BOOL bFullCoverage = pCapture->HasFullCoverage(); pRender->StopCapture(this, TRUE, FALSE, &lpInfo, &lpBits, &CaptureRect); // If the capture gave us back a bitmap, try to cache it if (lpInfo && lpBits && CaptureRect.IsValid()) { // If we can't find the cache then all is lost! CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache) { double ScaledPixelWidth = pRender->GetScaledPixelWidth(); CBitmapCacheKey inky(this, ScaledPixelWidth); //GetScaledPixelWidthDouble? CCachedBitmap cbmp; cbmp.pbmpBits = lpBits; cbmp.pbmpInfo = lpInfo; cbmp.SetCachedRect(CaptureRect); cbmp.nPriority = CACHEPRIORITY_TEMPBITMAP_LOW; cbmp.bFullCoverage = bFullCoverage; if (cbmp.IsValid()) { //TRACEUSER("Phil", _T("NRB:CaptureCached %x %s\n"), this, this->GetRuntimeClass()->m_lpszClassName); pBitmapCache->StoreBitmap(inky, cbmp); MayBeCached = TRUE; bCached = TRUE; } } } // If we failed to cache the captured bitmap then release it if (lpInfo!=NULL && lpBits!=NULL && !bCached) { FreeDIB(lpInfo, lpBits, NULL, FALSE); } INT64 countCacheing = pRender->GetStoredCount(); #if defined(_WIN32) QueryPerformanceCounter(&countEnd); countCacheing += countEnd.QuadPart-countStart.QuadPart; #endif pRender->SetStoredCount(countCacheing); } return TRUE; }

BOOL NodeRenderableBounded::ContainsNonMixTransparency (  RenderRegion *  pRegion  )

Find out whether this node's subtree contains non-mix transparency. Useful for optimising cacheing because while you want things to be cached as 32BPP RGBT bitmaps most of the time, non-mix transparencies can't be captured that way and so some work ahs to be done to transform down to a 24BPP RGB bitmap - better to avoid that by calling this function. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/08/2004 Parameters: -  [INPUTS] Returns: TRUE - The node contains non-mix transparency attributes FALSE - It doesn't Definition at line 4699 of file noderend.cpp. { for (Node* pKid = FindFirstDepthFirst(); pKid != NULL; pKid = pKid->FindNextDepthFirst(this) ) { if (pKid->IsAnAttribute() && ((NodeAttribute*)pKid)->IsATranspFill()) { AttrFillGeometry* pTransAttr = (AttrFillGeometry*) pKid; UINT32 ttype = pTransAttr->GetTranspType(); ERROR3IF(ttype<TT_NoTranspType || ttype>TT_MAX, "Someone's trying to set an unknown transp type!"); // if (!(ttype==TT_NoTranspType || ttype==TT_Mix)) if (!pRegion->TranspTypeIsRGBTCompatible(ttype)) return TRUE; } } return FALSE; }

void NodeRenderableBounded::CopyCached (  NodeRenderableBounded *  pCopyOfNode  )  [virtual]

Copy all cached bitmaps associated with this node to be associated with the specified new node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/2004 Returns: - See also: NodeRenderableInk::RenderCached, CaptureCached Definition at line 2928 of file noderend.cpp. { CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); CBitmapCacheKey inky(this, 42); CCacheKeyMap::iterator pos = pBitmapCache->GetStartPosition(); CCachedBitmap abitmap = pBitmapCache->FindNextOwnedBitmap(pos, inky); pCopyOfNode->MayBeCached = FALSE; while (abitmap.IsValid()) { CCachedBitmap copybitmap = abitmap.Copy(); CBitmapCacheKey copyinky(inky); copyinky.SetOwner(pCopyOfNode); pBitmapCache->StoreBitmap(copyinky, copybitmap); pCopyOfNode->MayBeCached = TRUE; abitmap = pBitmapCache->FindNextOwnedBitmap(pos, inky); } }

void NodeRenderableBounded::CopyCached (  NodeRenderableBounded *  pCopyOfNode, double  dRes, INT32  maxOption = 0 )  [virtual]

Copy fixed res cached bitmaps associated with this node to be associated with the specified new node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/2004 Returns: - See also: NodeRenderableInk::RenderCached, CaptureCached Definition at line 2891 of file noderend.cpp. { CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); INT32 i = 0; for (i = 0; i<=maxOption; i++) { // Copy the cached bitmap CCachedBitmap cbmp; CBitmapCacheKey inky(this, dRes, i); CBitmapCacheKey inkycopy(pCopyOfNode, dRes, i); BOOL bFound = pBitmapCache->Lookup(inky, cbmp); if (bFound) { cbmp = cbmp.Copy(); pBitmapCache->StoreBitmap(inkycopy, cbmp); } } pCopyOfNode->MayBeCached = TRUE; }

void NodeRenderableBounded::CopyNodeContents (  NodeRenderableBounded *  NodeCopy  )  [protected]

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

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

Reimplemented from NodeRenderable. Reimplemented in TextStory. Definition at line 1425 of file node.h. { return GetBoundingRect().Centre(); }

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

returns the nodes bounding rectangle. If the rectangle is valid the rectangle is simply returned, but is IsBoundingRectValid is FALSE (cos someone called InvaldateBoundingRect() on this node, or one of its children) then the bounding rect is first calculated and the flag reset, before it is returned. This is the base class version of this function and will build a bounding box out of the union of the nodes childrens bounding boxes. Your node MUST replace this function if this is not what you want it to do.... Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/9/94 Parameters: DontUseAttrs  - TRUE if you want to ignore all the nodes attributes [INPUTS] FALSE by default. HitTest - TRUE if being called during HitTest Returns: The nodes bounding rectangle Reimplemented in NodeGroup, NodeGuideline, NodeContourController, NodeBlendPath, NodeBrushMaker, NodeClipViewController, NodeMouldGroup, NodeMouldPath, NodeBevel, NodeBevelBegin, NodeBlender, NodeBlend, NodeBrush, NodeClipView, NodeContour, NodeLiveEffect, NodeLockedEffect, NodeMoulder, NodePath, NodeRegularShape, NodeSimpleShape, AbstractTextChar, CaretNode, EOLNode, and Spread. Definition at line 1303 of file noderend.cpp. { // if the bounding rect of this node is not valid then fill in something if (!IsBoundingRectValid || DontUseAttrs) { // just set it to be an empty rectangle DocRect BoundRect(0,0,0,0); Node* pNode = FindFirstChild(); while (pNode!=NULL) { // Add in the bounding rect of this node with all the others if (pNode->IsBounded()) BoundRect = BoundRect.Union(((NodeRenderableBounded*)pNode)->GetBoundingRect(DontUseAttrs)); // And find the next node pNode = pNode->FindNext(); } if (DontUseAttrs) { // We do not want to update the cached bounding rect here return BoundRect; } // Copy the unions into the nodes bounding rect param BoundingRectangle = BoundRect; // mark the bounding rect as valid IsBoundingRectValid = TRUE; } // and return the bounding rect return BoundingRectangle; }

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

For obtaining debug information about the Node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/93 Parameters: Str,:  String giving debug info about the node [OUTPUTS] Reimplemented from NodeRenderable. Reimplemented in Chapter, NodeGrid, NodeGridRect, NodeGridIso, NodeGuideline, Layer, NodeBrushMaker, NodeClipViewController, NodeBevel, NodeBlender, NodeDocument, NodeMoulder, NodeMould, NodePath, NodeRegularShape, NodeSimpleShape, VisibleTextNode, AbstractTextChar, TextChar, KernCode, CaretNode, EOLNode, TextLine, TextStory, NodeRenderablePaper, Page, and Spread. Definition at line 1709 of file noderend.cpp. { #ifdef _DEBUG NodeRenderable::GetDebugDetails(Str); String_256 TempStr; // Find out about the node up to date bounding rect DocRect Bounds = GetBoundingRect(); if (!Bounds.IsValid()) { TempStr = TEXT("\r\nBounding Rectangle = *INVALID*\r\n"); } else TempStr._MakeMsg(TEXT("\r\nBounding Rectangle\r\n Low(#1%ld, #2%ld)\r\n High(#3%ld, #4%ld)\r\n"), Bounds.LowCorner().x, Bounds.LowCorner().y, Bounds.HighCorner().x, Bounds.HighCorner().y); (*Str)+=TempStr; #endif }

DocRect NodeRenderableBounded::GetEffectStackBounds (  BOOL *  pbFoundEffects = NULL  )  [virtual]

Find the bounds of any effects which might be affected by changes to this node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 11/07/2005 Parameters: -  [INPUTS] Returns: rectangle containing bounds of topmost effect above this node Definition at line 1499 of file noderend.cpp. { DocRect drBounds = GetBoundingRect(); if (pbFoundEffects) *pbFoundEffects = FALSE; Node* pParent = FindParent(); while (pParent && !pParent->IsLayer()) { if (pParent->IsEffect()) { drBounds = ((NodeEffect*)pParent)->GetBoundingRect(); if (pbFoundEffects) *pbFoundEffects = TRUE; } pParent = pParent->FindParent(); } return drBounds; }

virtual DocRect NodeRenderableBounded::GetEorDragBoundingRect (   )  [inline, virtual]

Reimplemented in NodeGroup, NodeClipViewController, and NodeMouldGroup. Definition at line 1355 of file node.h. { return GetBoundingRect(TRUE, FALSE); }

DocRect NodeRenderableBounded::GetExtendTargetBounds (  const ExtendParams &  ExtParams  )  [virtual]

Return a DocRect which contains the bounds of this node as defined and required by the Extending mechanism. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 02/06/2000 Parameters: ExtParams  const ref to an ExtendParams class describing the extension. [INPUTS] [OUTPUTS]  Returns: The DocRect to treat as the bounding rect of this node when extending. We treat x- and y- directions separately, and we always return our true bounds, unless we're extending in a direction, in which case we return the bounds of our extend control points. Default behaviour for this is to use the 'bounds' of our FindExtendCentre() coord. Returns: Errors: See also: SliceHelper::BoundingNodeSize(). Reimplemented in NodeCompound, NodeMould, and NodePath. Definition at line 2161 of file noderend.cpp. { DocRect drBounds = GetBoundingRect(); DocCoord doccCentre = FindExtendCentre(); if (ExtParams.fExtendFlags & X_EXTEND) drBounds.lo.x = drBounds.hi.x = doccCentre.x; if (ExtParams.fExtendFlags & Y_EXTEND) drBounds.lo.y = drBounds.hi.y = doccCentre.y; return drBounds; }

virtual DocRect NodeRenderableBounded::GetImagemapClickableRectangle (   )  [inline, virtual]

Reimplemented in AbstractTextChar. Definition at line 1357 of file node.h. { return GetBoundingRect(FALSE, TRUE); }

double NodeRenderableBounded::GetRotationAngle (   )  [virtual]

Call this function to obtain the current angle of rotation of the node. By default this is zero. Nodes derived from NodeRenderableBounded should override this function and return the angle of rotation using their own particular method Scope: public. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 24/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The angle of rotation of the object. This ranges from PI to -PI. Zero is on the positive x-axis. (i.e. what atan2 returns) Reimplemented in NodePath, NodeRegularShape, and NodeSimpleShape. Definition at line 2088 of file noderend.cpp. { return 0.0; }

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

This simply returns the result of GetBlobBoundingRect() as the default action for the base class. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 03/02/95 Returns: DocRect - The rectangle that is the union of all the nodes selection blobs and the node's bounding rectangle Reimplemented from NodeRenderable. Definition at line 1352 of file noderend.cpp. { DocRect drBounds = GetBoundingRect().Union(GetBlobBoundingRect()); if (!bIncludeEffects) return drBounds; // Search up the effects stack // NodeRenderableBounded* pEffect = this; Node* pParent = FindParent(); while (pParent && !pParent->IsLayer()) { if (pParent->IsEffect()) drBounds = ((NodeEffect*)pParent)->GetBoundingRect().Union(((NodeEffect*)pParent)->GetBlobBoundingRect()); pParent = pParent->FindParent(); } return drBounds; }

virtual BOOL NodeRenderableBounded::HasCachedDirectBitmap (   )  [inline, virtual]

Reimplemented in NodeBitmapEffect. Definition at line 1397 of file node.h. {return FALSE;}

void NodeRenderableBounded::IncludeChildrensBoundingRects (  DocRect *  pBounds  )  [virtual]

The child attribute Blob bounding rects are included in the BoundingRect. Note: re-written by Ed 25/4/95 Now only includes bounds of child attrs (rather than all NodeRenderableBounded) The assumption is that no child can be selected if it's parent is, so attr blobs of child nodes cannot be visible at the same time as their parents! Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 28/7/94 Parameters: DocRect  is updated to include Childrens Bounding Rects. [OUTPUTS] re-written by Will 5/5/95 Now uses 'FindAppliedAttributes' so it works for select inside. Definition at line 1749 of file noderend.cpp. { // Ok, so this function should be defined in NodeRenderableInk, but that is // one heck of a change, so we'll just make sure we warn people if they try // something silly. ERROR3IF(!this->IS_KIND_OF(NodeRenderableInk), "IncludeChildrensBoundingRect called for non-ink node"); #if !defined(EXCLUDE_FROM_RALPH) // Find the blob Manager BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr==NULL) return; // Since the only blobs that attributes have are Fill Blobs, // don't bother if the fill blobs are not visible BlobStyle VisibleBlobs = pBlobMgr->GetCurrentInterest(TRUE); if (VisibleBlobs.Fill) { CCAttrMap* pAttribMap = new CCAttrMap(30); if (pAttribMap == NULL) return; // Now find any attributes that are applied to this node. BOOL FoundAttrs = ((NodeRenderableInk*)this)->FindAppliedAttributes(pAttribMap, 5000, NULL, FALSE); if (FoundAttrs) { // iterating all (key, value) pairs for (CCAttrMap::iterator Pos = pAttribMap->GetStartPosition(); Pos != pAttribMap->GetEndPosition();) { void *pVal; CCRuntimeClass *pType; pAttribMap->GetNextAssoc(Pos,pType,pVal); NodeAttribute* pAttr = (NodeAttribute*)pVal; *pBounds=pBounds->Union( pAttr->GetBlobBoundingRect() ); } } delete pAttribMap; } #endif }

BOOL NodeRenderableBounded::Init (  void   )  [static]

Declare the preferences for the magnetic options. Now also declares the layers section rather than having a new explicit init in the layers section. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/11/94 Returns: TRUE if it worked, FALSE if not Reimplemented from SimpleCCObject. Reimplemented in NodeRenderableInk, Layer, NodeBitmapEffect, VisibleTextNode, AbstractTextChar, TextLine, BaseTextClass, and TextStory. Definition at line 1885 of file noderend.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Declare the section that the magnetic options will live in BOOL Worked = Camelot.DeclareSection(TEXT("Magnetic Options"), 2); // declare the 2 prefs that there are if (Worked) Worked = Camelot.DeclarePref(TEXT("Magnetic Options"), TEXT("Point Radius"), &MagneticPointRadius, 0); if (Worked) Worked = Camelot.DeclarePref(TEXT("Magnetic Options"), TEXT("Line Radius"), &MagneticLineRadius, 0); // Declare the section that the preferences for layers will live in if (Worked) Worked = Camelot.DeclareSection(TEXT("Layers"), 2); // declare the 2 prefs that there are if (Worked) Worked = Camelot.DeclarePref(TEXT("Layers"), TEXT("ActiveLayerVisibleAndEditable"), &Layer::ActiveLayerVisibleAndEditable, 0, 1); if (Worked) Worked = Camelot.DeclarePref(TEXT("Layers"), TEXT("EnableLayerCacheing"), &Layer::EnableLayerCacheing, 0, 2); // Declare the section that the preferences for layers will live in if (Worked) Worked = Camelot.DeclareSection(TEXT("Rendering"), 4); if (Worked) Worked = Camelot.DeclarePref(TEXT("Rendering"), TEXT("Cacheing"), &bEnableCacheing, 0); if (Worked) Worked = Camelot.DeclarePref(TEXT("Rendering"), TEXT("ThrottleCacheing"), &bThrottleCacheing, 0); if (Worked) Worked = Camelot.DeclarePref(TEXT("Rendering"), TEXT("ShowCacheBlobs"), &bShowCacheBlobs, 0); // Return if it worked or not return Worked; #else return TRUE; #endif }

void NodeRenderableBounded::InvalidateBoundingRect (  BOOL  InvalidateChildBounds = FALSE  )  [virtual]

Marks the bounding rect of this node as invalid, as well as marking this nodes parents as invalid as well. Next time a nodes GetBoundingRect() function is called the bounding rect will be recalculated if needed. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> / Recursion moved to new function by Simon Date: 11/9/94 Parameters: InvalidateChildBounds  - When TRUE all children of the node have their [INPUTS] bounds invalidated as well (eg. applying a line attribute to a group) Definition at line 1450 of file noderend.cpp. { // Invalid this nodes bounding rect if we need to if (IsBoundingRectValid) { InvalidateBoundingRectHelper(); // Removed by Simon (31/03/95) I Can't see a reason to update the selection here ! // Inform the range that it's invalid //SelRange* Selected = GetApplication()->FindSelection(); //ERROR3IF(Selected == NULL, "Where's the selection gone ?"); //Selected->UpdateBounds(); if (InvalidateChildBounds) { // Invalidate the bounds of all children of the node Node* Current = FindFirstDepthFirst(); while (Current != this) { ERROR3IF (Current == NULL, "invalid NULL Current"); if (Current->IsBounded()) { if (((NodeRenderableBounded*)Current)->IsBoundingRectValid) { ((NodeRenderableBounded*)Current)->IsBoundingRectValid = FALSE; } } Current = Current->FindNextDepthFirst(this); } } } }

void NodeRenderableBounded::InvalidateBoundingRectHelper (   )  [private]

Marks the bounding rect of this node as invalid, as well as marking this nodes parents as invalid as well. Next time a nodes GetBoundingRect() function is called the bounding rect will be recalculated if needed. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/9/94 Scope: private This is the recursive helper function for NodeRenderableBounded::InvalidateBoundingRect SeeAlso NodeRenderableBounded::InvalidateBoundingRect Definition at line 1413 of file noderend.cpp. { // Invalid this nodes bounding rect if we need to BoundingRectangle = DocRect(0,0,0,0); if (IsBoundingRectValid) { IsBoundingRectValid = FALSE; // and invalid this nodes parents bounding rect Node* pParent = FindParent(); if (pParent!=NULL) { // Check that the tree is as expected ENSURE(pParent->IS_KIND_OF(NodeRenderableBounded), "Parent of a bounded node was not bounded"); // sort of recurse up the tree invalidating the bounding rects as we go if (pParent->IsBounded()) ((NodeRenderableBounded*)pParent)->InvalidateBoundingRectHelper(); } } }

virtual BOOL NodeRenderableBounded::IsBounded (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 1367 of file node.h. {return TRUE;}

BOOL NodeRenderableBounded::IsDifferent (  Node *  pOther  )  [virtual]

Determine if 2 nodes are considered different. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 28/2/97 Parameters: pOther  - The node to compare this one to [INPUTS] Returns: TRUE if this is considered different from pOther, FALSE if they are the same Notes: **** IMPORTANT - May not function well enough for your needs! **** This was written to allow the StrokeComponent class to merge stroke definitions which share identical clipart subtrees. Stroke subtrees are special in that they have had Make Shapes applied to them, and so only contain paths. Hence, I have only defined functions in Node, NodeRenderableBounded, and NodePath - most objects in the tree thus use base class functionality (are they of the same class, and do they have identical bounding boxes). This suffices for my needs, but you may need to implement this function for a lot more node types before it's of use to you.