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. Reimplemented from Node. Reimplemented in NodePath. Definition at line 2123 of file noderend.cpp. { // First, check with the base class - this checks the classes are the same type if (NodeRenderable::IsDifferent(pOther)) return(TRUE); ERROR3IF(GetRuntimeClass() != pOther->GetRuntimeClass(), "Node::IsDifferent base class method seems to have been broken"); // Now check if the bounds of the nodes are the same if (BoundingRectangle != ((NodeRenderableBounded *)pOther)->BoundingRectangle) return(TRUE); return(FALSE); }

BOOL NodeRenderableBounded::IsIntersectedWith (  DocRect *  pClipRect  )

Determine if this node is intersected with the rectangle supplied. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/9/94 Parameters: pClipRect  [INPUTS] Returns: TRUE if this node is intersected witht he doc rect Definition at line 1572 of file noderend.cpp. { // Go find out about my bounding rectangle DocRect Bounds = GetBoundingRect(); // and return if we intersect return( pClipRect->IsIntersectedWith(Bounds)); }

BOOL NodeRenderableBounded::IsMagnetic (   )  [virtual]

Returns that magnetic state of this node Scope: public. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE - the node is magnetic FALSE - the node is not magnetic Definition at line 1994 of file noderend.cpp. { return Magnetic; }

BOOL NodeRenderableBounded::IsMagneticallyClose (  DocCoord *  pTest, DocCoord *  pOriginal )  [protected]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: pTestCoord  - the coord we are testing the original against [INPUTS] pOriginalCoord - The Coord that we are trying to snap to the test coord pOriginalCoord  - If the 2 coords are close enough together (as defined by [OUTPUTS] the MagneticPointRadius) then pOriginalCoord is changed to match pTestCoord Returns: TRUE if it snapped the original coord to the test coord Definition at line 1956 of file noderend.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Find out if anything is close to this coord if ((abs(pTest->x - pOriginal->x) < CSnap::GetSnapToCoordDist()) && (abs(pTest->y - pOriginal->y) < CSnap::GetSnapToCoordDist())) { // They are close to each other // Snap the original coord to the test coord pOriginal->x = pTest->x; pOriginal->y = pTest->y; // return true to indicate what has happened return TRUE; } #endif // They were not close to each other, so say so return FALSE; }

void NodeRenderableBounded::PolyCopyNodeContents (  NodeRenderable *  pNodeCopy  )  [virtual]

Polymorphically copies the contents of this node to another. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/12/2003 Parameters: -  [OUTPUTS] Returns: Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Reimplemented from NodeRenderable. Reimplemented in Chapter, NodeGrid, NodeGridRect, NodeGridIso, NodeGroup, NodeGuideline, Layer, NodeContourController, NodeBlendPath, NodeBrushMaker, NodeBrushPath, NodeClipViewController, NodeMouldGroup, NodeMouldBitmap, NodeMouldPath, NodeAnimatingBitmap, NodeBevel, NodeBlender, NodeBlend, NodeBitmap, NodeBrush, NodeClipView, NodeContour, NodeDocument, NodeLiveEffect, NodeLockedEffect, NodeFeatherEffect, NodeMoulder, NodeMould, NodePath, NodeEffect, NodeRegularShape, NodeSimpleShape, AbstractTextChar, TextChar, KernCode, HorizontalTab, EOLNode, TextLine, BaseTextClass, TextStory, NodeRenderablePaper, Page, and Spread. Definition at line 1661 of file noderend.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(pNodeCopy->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded)), "PolyCopyNodeContents given wrong dest node type"); if (pNodeCopy->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded))) CopyNodeContents((NodeRenderableBounded*)pNodeCopy); }

BOOL NodeRenderableBounded::ReleaseCached (  BOOL  bAndParents = TRUE, BOOL  bAndChildren = TRUE, BOOL  bSelf = TRUE, BOOL  bAndDerived = TRUE )  [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: NodeRenderableInk::RenderCached, CaptureCached Reimplemented in NodeBitmap, and NodeLiveEffect. Definition at line 2838 of file noderend.cpp. { if (MayBeCached) { BOOL bRemoveOpaqueBitmapsOnly = IsDragged(); // If we're being dragged, only remove opaque bmps BOOL bDidRemoveSome = FALSE; CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache!=NULL && bSelf) { CBitmapCacheKey inky(this, 42); bDidRemoveSome = pBitmapCache->RemoveAllOwnedBitmaps(inky, bRemoveOpaqueBitmapsOnly); } if (bDidRemoveSome && !bRemoveOpaqueBitmapsOnly) // If we know we removed all cached bitmaps MayBeCached = FALSE; // Then we can clear our maybe flag to optimise rendering } // If we should release our children's caches as well... if (bAndChildren) { Node* pChild = FindFirstChild(); while (pChild) { if (pChild->IsBounded()) ((NodeRenderableBounded*)pChild)->ReleaseCached(FALSE, TRUE, TRUE, TRUE); pChild = pChild->FindNext(); } } // If I can't be cached, neither can my parent... if (bAndParents && FindParent() && FindParent()->IsBounded()) ((NodeRenderableBounded*)FindParent())->ReleaseCached(TRUE, FALSE, TRUE, TRUE); return TRUE; }

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

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). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 17/06/2004 Returns: TRUE if the node managed to render a cached version of itself then pNextNode contains the pointer to the node to continue rendering from FALSE if the node did not render a cached version of itself and thus normal rendering is required For this implementation we assume that our cached info will represent just this subtree. Also start to capture the rendered info into a cached bitmap if possible See also: NodeRenderableBounded::CaptureCached Definition at line 2540 of file noderend.cpp. { // Standard implementation of RenderCached takes note of RenderRegion.BackmostChangedNode // and uses the global CBitmapCache object... // // First, try to find quick ways to do nothing... // If cacheing is disabled bale out now! if (!NodeRenderableBounded::bEnableCacheing) return FALSE; //TRACEUSER("Phil", _T("NRB::RenderCached for %x %s\n"), this, GetRuntimeClass()->m_lpszClassName); // If the rendering quality is outline - no point showing cached bitmaps... if (pRender->RRQuality.GetFillQuality() <= Quality::Solid) return FALSE; // If the rendering system is doing black and white only then we can't sensibly // produce a monochrome version of the cached bitmap... if (pRender->IsVeryMono() || pRender->IsHitDetect() || pRender->IsPrinting() || pRender->IsWrappedRender()) return FALSE; CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache==NULL) return FALSE; // If this node is definitely not cached, skip the cache rendering stuff... DocRect cliprect = pRender->GetClipRect(); DocRect bounds = GetBoundingRect(); // Assure new bounds are recalced if they were invalid BOOL bRendered = FALSE; if (MayBeCached) { // If render region tells us to, then we must remove all 24BPP cached bitmaps // (Opaque bitmaps could capture parts of the tree underneath them and they could have changed. // That's what the ReleaseCache() function is telling us.) CBitmapCacheKey inky(this, pRender->GetScaledPixelWidth()); //GetScaledPixelWidthDouble? Node* pBackmostChanged = pRender->GetBackmostChangedNode(); if (pBackmostChanged) { // Only delete cached opaque bitmaps if they are above the lowest // changed node in this render (keep ones that are below because they are still valid) // // (Remember that the bounds of this object should already have been checked against // the clipping rectangle before this function is called, so we will only be chucking // out cached items that intersect the clipping rect.) // if (pBackmostChanged->IsUnder(this)) { // Then we must remove all opaque bitmaps in the cache // associated with this node //TRACEUSER("Phil", _T("NRB:RenderCached release transp bitmaps %x %s\n"), this, this->GetRuntimeClass()->m_lpszClassName); BOOL bRemoved = pBitmapCache->RemoveAllOwnedBitmaps(inky, TRUE); // Only remove opaque bitmaps if (bRemoved) MayBeCached = FALSE; // assume that is some were opaque, all were (and thus all have been removed)... } } // Look for a cached bitmap at the appropriate pixel size... CCachedBitmap cbmp; BOOL bFound = pBitmapCache->Lookup(inky, cbmp); if (bFound) { // If cached bitmap covers the current clipped object rect, we can use it... DocRect clippedboundrect = cliprect.Intersection(bounds); if (cbmp.GetCachedRect().ContainsRect(clippedboundrect)) { //TRACEUSER("Phil", _T("NRB::RenderCached Rendering cached bitmap for %x %s %d\n"), this, GetRuntimeClass()->m_lpszClassName, cbmp.pbmpInfo->bmiHeader.biBitCount); bRendered = pRender->RenderBits(cbmp.pbmpInfo, cbmp.pbmpBits, &cbmp.coord0, 3); } } } if (bRendered) return TRUE; // -------------------------------------------------------------------- // Now we must decide whether we can afford to cache this node... // // If this is being (solid) dragged don't waste time trying to cache it // if (IsDragged()) // return FALSE; // Any sort of drag prevents new cacheing (to keep drags running smoothly) if (Operation::GetCurrentDragOp()) return FALSE; //TRACEUSER("Phil", _T("NRB:RenderCached prep capture %x %s\n"), this, this->GetRuntimeClass()->m_lpszClassName); // Do the following optimisation only on unselected nodes... if (!IsSelected()) { // This is a performance optimisation to reduce cacheing overhead... // If there are more than 2 nested captures already running, don't try another one... if (pRender->GetCaptureDepth() > 2) return FALSE; // We can use cache throttling to prevent this node being cached // // If we've run out of time to do cacheing then stop now. // if (time spent cacheing thus far is >5% of total rendering time) then don't do any more // Node* pParent = FindParent(); if (NodeRenderableBounded::bThrottleCacheing && pRender->GetStoredCount()*((INT64)20) > pRender->GetTotalCount() //&& // !IsSelected() && // Selected nodes can't be throttled // pParent && // Nodes without parents can't be trottled // pParent->IsLayer() // Nodes whose parents are layers can't be throttled ) { //TRACEUSER("Phil", _T("NRB:RenderCached throttling prevents capture %x %s %I64d %I64d\n"), this, this->GetRuntimeClass()->m_lpszClassName, pRender->GetStoredCount()*(INT64)20, pRender->GetTotalCount()); return FALSE; } //TRACEUSER("Phil", _T("NRB:RenderCached throttling allows capture %x %s %I64d %I64d\n"), this, this->GetRuntimeClass()->m_lpszClassName, pRender->GetStoredCount()*(INT64)20, pRender->GetTotalCount()); } #if defined(_WIN32) // If we couldn't find or render a cached bitmap then try to cache a new one // Start timing of this cacheing overhead code LARGE_INTEGER countStart; LARGE_INTEGER countEnd; QueryPerformanceCounter(&countStart); #endif double ScaledPixelWidth = pRender->GetScaledPixelWidth(); // Work out how much of the object we propose to capture // (This may change during the Capture if we have to fall back to 24BPP opaque capture) DocRect viewrect = cliprect; DocRect CaptureRect = bounds; // Only do stuff if the cliprect is at least half the size of the object if (cliprect.Width()>(bounds.Width()/2) && cliprect.Height()>(bounds.Height()/2)) { View* pView = pRender->GetRenderView(); Spread* pSpread = pRender->GetRenderSpread(); if (pView && pSpread) { viewrect = pView->GetDocViewRect(pSpread); pSpread->DocCoordToSpreadCoord(&viewrect); if (!viewrect.IsValid() || !viewrect.ContainsRect(cliprect)) viewrect = cliprect; } CaptureRect = CaptureRect.Intersection(viewrect); // Proposed capture area is obj x viewport if (CaptureRect.IsValid()) { // If we're nearly going to capture the whole object // (Compare area of bounding rect with area of view rect so that bitmap sizes don't get out of control) XLONG areaBounds = (XLONG)bounds.Width()*(XLONG)bounds.Height(); XLONG area2View = (XLONG)2*(XLONG)viewrect.Width()*(XLONG)viewrect.Height(); if (areaBounds < area2View) { // Then grab the whole thing // (Bounding Rect is small enough for us to capture the whole object ignoring clipping rect) CaptureRect = bounds; } // Inflate by one pixel all round to allow for anti-aliasing effects at the edges CaptureRect.Inflate((INT32)ScaledPixelWidth); UINT32 flagCoverage = 0; if (CaptureRect.ContainsRect(bounds)) flagCoverage = cfFULLCOVERAGE; // Only cache if it's worth it! if (CaptureRect.Width()>=ScaledPixelWidth*4 || CaptureRect.Height()>=ScaledPixelWidth*4) { // It's quicker to scan ahead looking for non-mix transparency than to find it // half way through rendering a bitmap... //TRACEUSER("Phil", _T("NRB:RenderCached start capture %x %s\n"), this, this->GetRuntimeClass()->m_lpszClassName); CaptureFlags caFlags(flagCoverage | cfPIXWIDTHSCALE | (this->ContainsNonMixTransparency(pRender) ? cfGRABRENDERED : cfCOLLAPSETOMASTER | cfUNCLIP) ); pRender->StartCapture(this, CaptureRect, CAPTUREINFO(ctNESTABLE, caFlags), TRUE, FALSE); } } } #if defined(_WIN32) // Add up time spent doing cacheing work and store it in the render region INT64 countCacheing = pRender->GetStoredCount(); QueryPerformanceCounter(&countEnd); countCacheing += countEnd.QuadPart-countStart.QuadPart; pRender->SetStoredCount(countCacheing); #endif return FALSE; }

void NodeRenderableBounded::RenderEffectAttributes (  RenderRegion *  pRegion  )  [virtual]

Render any effect attributes attached to this node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/2005 Returns: - See also: - Definition at line 3019 of file noderend.cpp. { Node* pNode = FindLastChild(CC_RUNTIME_CLASS(NodeRenderableBounded)); while (pNode) { pNode = pNode->FindNext(); if (pNode && pNode->IsAnAttribute()) { pNode->Render(pRegion); } } }

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

Virtual function - this function will indicate to the caller whether or not we want to render the given node, according to the information passed in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 07/02/94 Parameters: pRender  - A pointer to the current render region (NULL if none) [INPUTS] Returns: TRUE => This node should be rendered, FALSE => This node does not need to be rendered. See also: Node::NeedsToRender Reimplemented from NodeRenderable. Reimplemented in NodeGrid, NodeGroup, NodeGuideline, Layer, NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBevelBegin, NodeBrush, NodeClipView, NodeLiveEffect, NodeLockedEffect, NodeEffect, NodeRenderablePaper, and Spread. Definition at line 1540 of file noderend.cpp. { if (pRender == NULL) // If no render region supplied, assume we need to be rendered return SUBTREE_ROOTANDCHILDREN; // Go find out about my bounding rectangle DocRect Bounds = GetBoundingRect(); DocRect ClipRect = pRender->GetClipRect(); if (bClip && !ClipRect.IsIntersectedWith(Bounds)) // If not within the clipping rect then return SUBTREE_NORENDER; // Don't render us or our children // if (RenderCached(pRender, ppNextNode)) // If we can find a cached bitmap for this node and render it // return SUBTREE_NORENDER; // Then tell the renderer to move on without doing any more... return SUBTREE_ROOTANDCHILDREN; // Else we must render ourselves and our children }

void NodeRenderableBounded::SetMagneticState (  BOOL  state  )  [virtual]

Allows you to set the magnetic state of this node Scope: public. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/9/94 Parameters: State  - TRUE to become magnetic, FALSE otherwise [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2014 of file noderend.cpp. { Magnetic = state; }

Node * NodeRenderableBounded::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 has run out Errors: If memory runs out when trying to copy, then ERROR is called with an out of memory error and the function returns NULL. Reimplemented from NodeRenderable. Reimplemented in Chapter, NodeGrid, NodeGridRect, NodeGridIso, NodeGroup, NodeGuideline, NodeRenderableInk, Layer, NodeContourController, NodeBlendPath, NodeBrushMaker, NodeBrushPath, NodeClipViewController, NodeMouldGroup, NodeMouldBitmap, NodeMouldPath, NodeAnimatingBitmap, NodeBevel, NodeBevelBegin, NodeBlender, NodeBlend, NodeBitmap, NodeBrush, NodeClipView, NodeContour, NodeDocument, NodeEllipse, NodeLiveEffect, NodeLockedEffect, NodeFeatherEffect, NodeMoulder, NodeMould, NodePath, NodeEffect, NodeRect, NodeRegularShape, NodeSimpleShape, VisibleTextNode, AbstractTextChar, TextChar, KernCode, HorizontalTab, CaretNode, EOLNode, TextLine, BaseTextClass, TextStory, NodeRenderablePaper, Page, and Spread. Definition at line 1638 of file noderend.cpp. { NodeRenderableBounded* NodeCopy; NodeCopy = new NodeRenderableBounded(); ERRORIF(NodeCopy == NULL, _R(IDE_NOMORE_MEMORY), NULL); CopyNodeContents(NodeCopy); return (NodeCopy); }

BOOL NodeRenderableBounded::Snap (  DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )  [virtual]

ALWAYS RETURNS FALSE! This is just a virtual base function intended to be overridden. Scope: public. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/94 Parameters: pDocCoord  - the rectangle to snap [INPUTS] StartDrag - Start coord of drag EndDrag - End coord of drag [OUTPUTS]  Returns: TRUE - the DocRect been snapped to the grid. FALSE - the DocRect has not been processed. Reimplemented in NodeGrid, NodeGridRect, NodeGridIso, NodeGuideline, NodeBlender, NodePath, NodeRegularShape, NodeSimpleShape, and Page. Definition at line 1835 of file noderend.cpp. { return (FALSE); }

BOOL NodeRenderableBounded::Snap (  DocCoord *  pDocCoord  )  [virtual]

ALWAYS RETURNS FALSE! This is just a virtual base function intended to be overridden. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pDocCoord  = a coord in Spread coords [INPUTS] [OUTPUTS]  Returns: TRUE - the DocCoord has been snapped to the path. FALSE - the DocCoord has not been processed. Errors: Scope: public Reimplemented in NodeGrid, NodeGridRect, NodeGridIso, NodeGuideline, NodeBlender, NodePath, NodeRegularShape, NodeSimpleShape, TextChar, and Page. Definition at line 1811 of file noderend.cpp. { return (FALSE); }

BOOL NodeRenderableBounded::SnapToCoords (  DocCoord *  pDocCoord  )  [virtual]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: pDocCoord  - The DocCoord that needs snapping [INPUTS] If  the function returns TRUE then pDocCoord will have been modified to [OUTPUTS] snap to a significant point on the node. Returns: TRUE if the Coord was snapped. FALSE if the coord was not effected by this node See also: MagneticPointRadius; MagneticLineRadius; NodePath::SnapToCoords Reimplemented in NodePath, NodeRect, NodeRegularShape, and NodeSimpleShape. Definition at line 1866 of file noderend.cpp. { return FALSE; }

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

Base class transform function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/94 Parameters: Trans  - The transform [INPUTS] Reimplemented from NodeRenderable. Reimplemented in NodeGroup, NodeGuideline, NodeContourController, NodeBrushMaker, NodeBrushPath, NodeClipViewController, NodeMouldGroup, NodeBevel, NodeBlender, NodeBrush, NodeClipView, NodeContour, NodeLiveEffect, NodeLockedEffect, NodeMoulder, NodeMould, NodePath, NodeRegularShape, NodeSimpleShape, and TextStory. Definition at line 1224 of file noderend.cpp. { // Just transform the children and invalidate the nodes bounding rect InvalidateBoundingRect(); TransformChildren(Trans); }

void NodeRenderableBounded::TransformCached (  TransformBase &  Trans, double  dTestPixelWidth )  [virtual]

Transform all the cached bitmaps associated with this node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/2004 Parameters: Trans  - Transformation [INPUTS] dPixelWidth - PixelWidth to be tested specifically to control Trans.bHaveTransformedCached Returns: - See also: NodeRenderableInk::RenderCached, CaptureCached Definition at line 2966 of file noderend.cpp. { // If cacheing is disabled bale out now! if (!NodeRenderableBounded::bEnableCacheing) { MayBeCached = FALSE; Trans.bHaveTransformedCached = FALSE; Trans.bTransformYourChildren = TRUE; return; } CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); CBitmapCacheKey inky(this, 42); CCacheKeyMap::iterator pos = pBitmapCache->GetStartPosition(); CCachedBitmap abitmap = pBitmapCache->FindNextOwnedBitmap(pos, inky); MayBeCached = abitmap.IsValid(); // Update MayBeCached here because we can BOOL bTransformedTested = FALSE; while (abitmap.IsValid()) { abitmap.Transform(Trans); pBitmapCache->StoreBitmap(inky, abitmap); if (inky.GetPixelWidth() == dTestPixelWidth && abitmap.IsTransparent()) bTransformedTested = TRUE; abitmap = pBitmapCache->FindNextOwnedBitmap(pos, inky); } // We can only continue to transform cached things if all our bitmaps are transparent (32BPP) // And if we actually had some cached data to transform if (!bTransformedTested) { Trans.bHaveTransformedCached = FALSE; Trans.bTransformYourChildren = TRUE; } }

void NodeRenderableBounded::TransformChildren (  TransformBase &  Trans  )  [virtual]

Transforms the Child nodes of this node. This allows fills etc to move with the objects. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/9/94 Parameters: Trans  - The transform that should be applied to all the children [INPUTS] Reimplemented from NodeRenderable. Definition at line 1245 of file noderend.cpp. { // We have to go through all the child nodes of this node and Transform // all the NodeRenderable objects Node* pCurrent = this -> FindFirstChild(); while (pCurrent != NULL) { // Make sure it is a renderable ink object (not a hidden node) if (pCurrent->IS_KIND_OF(NodeRenderable)) { // Transform the child node ((NodeRenderable*)pCurrent)->Transform( Trans ); // If this node has a bounding box then invalidate it if (pCurrent->IsBounded()) { ((NodeRenderableBounded*)pCurrent)->InvalidateBoundingRect(); } // Show the hourglass if (ShowHourglass()) { ContinueSlowJob(); } } // Find the next object in the group pCurrent = pCurrent -> FindNext(); } }

void NodeRenderableBounded::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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 13/9/94 Definition at line 1388 of file noderend.cpp. { IsBoundingRectValid = TRUE; }

---

Member Data Documentation

BOOL NodeRenderableBounded::bEnableCacheing = TRUE [static]

Enable or disable bitmap cacheing of parts of the tree during GRenderRegion rendering. Preference: EnableCacheing Section: Rendering Range: 0 or 1 See also: - Definition at line 1448 of file node.h.

DocRect NodeRenderableBounded::BoundingRectangle [protected]

Definition at line 1435 of file node.h.

BOOL NodeRenderableBounded::bShowCacheBlobs = FALSE [static]

TRUE - Show special markers when cached groups are selected. Preference: ShowCacheBlobs Section: Rendering Range: 0 or 1 See also: - Definition at line 1450 of file node.h.

BOOL NodeRenderableBounded::bThrottleCacheing = TRUE [static]

TRUE - Throttle cacheing to be 5% of total rendering time or less. Preference: ThrottleCacheing Section: Rendering Range: 0 or 1 See also: - Definition at line 1449 of file node.h.

BOOL NodeRenderableBounded::IsBoundingRectValid [protected]

Definition at line 1432 of file node.h.

BOOL NodeRenderableBounded::Magnetic [protected]

Definition at line 1438 of file node.h.

INT32 NodeRenderableBounded::MagneticLineRadius = 750*4 [static]

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. Preference: Line Radius Section: Magnetic Options Range: 0 - lots See also: Point Radius Definition at line 1446 of file node.h.

INT32 NodeRenderableBounded::MagneticPointRadius = 750*6 [static]

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. Preference: Point Radius Section: Magnetic Options Range: 0 - lots See also: Line Radius Definition at line 1445 of file node.h.

BOOL NodeRenderableBounded::MayBeCached [protected]

Definition at line 1440 of file node.h.

---

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

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

---