NodeGroup Class Reference

Group Node. More...

#include <group.h>

Inheritance diagram for NodeGroup:

List of all members.

Public Member Functions
	NodeGroup ()
	This constructor creates a NodeGroup linked to no other, with all status flags false and an uninitialised bounding rectangle.
	NodeGroup (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	This method initialises the node and links it to ContextNode in the direction specified by Direction. All necessary tree links are updated.
virtual BOOL	IsAGroup () const
virtual DocRect	GetBoundingRect (BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE)
	If the groups bounding rect is known then it is returned. If not, it is re-calculated.
virtual DocRect	GetBlobBoundingRect ()
	Finds the bounding rect of the group along with its blobs. Its main use is to determine which areas of the document to invalidate.
virtual DocRect	GetEorDragBoundingRect ()
	Gets the eor drag bounding rect for all my children.
virtual void	Transform (TransformBase &)
	Transforms the group object and all its children.
virtual void	PreExportRender (RenderRegion *pRender)
	Perform any rendering required when exporting to a file, and this node is being 'passed by' during the tree searching. For example, a group node being exported to EPS would output a "start group" token, and then its ExportRender function would output a "end group" token. By default, it does nothing. Nodes wishing to do special export processing should override this function (and ExportRender).
virtual BOOL	ExportRender (RenderRegion *pRender)
	Custom export code for nodes derived from NodeRenderableInk. So far there is only code for the VectorFileRenderRegion (which is a superclass for the EPS, CMX, and Flash render regions) to allow for the export of stroked shapes.
virtual SubtreeRenderState	RenderSubtree (RenderRegion *pRender, Node **ppNextNode=NULL, BOOL bClip=TRUE)
	Do clever stuff on the way into a subtree, possibly modifying rendering behaviour.
virtual void	RenderAfterSubtree (RenderRegion *pRender)
	For determining quickly if the node is a compound object Capture the group as a cached bitmap.
virtual void	RenderObjectBlobs (RenderRegion *pRender)
	Will render the group iff we have it cached - for hit detection reasonsRenders the object blobs.
virtual void	RenderTinyBlobs (RenderRegion *pRender)
	Renders the tiny blobs for a group (A Single blob on the topmost child object in the group).
virtual String	Describe (BOOL Plural, BOOL Verbose)
	To return a description of the Group object in either the singular or the plural. This method is called by the DescribeRange method.
virtual Node *	SimpleCopy ()
	This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes.
void	CopyNodeContents (NodeGroup *NodeCopy)
	Copies the data from this node to pCopyOfNode by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
virtual UINT32	GetNodeSize () const
	This method outputs a 'deep' copy of the node. It is the same as CopyNode except that the copy is not linked into the tree. Override if your class can interpret the lightweight flagFor finding the size of the node.
virtual ChangeCode	OnChildChange (ObjChangeParam *pParam)
	This function should be overridden in derived object classes. Composite objects can use this function to respond to one of their children undergoing a change. They should return CC_FAIL whenever they are unable to cope with the change.
virtual BOOL	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	Determines if the user has started a drag on one of the groups blobs. If they have then it starts the groups resize operation.
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes the group record to the filter.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
virtual BOOL	WriteBoundsRecord (BaseCamelotFilter *pFilter)
	Write out a record containing the bounds of this object.
virtual BOOL	WillWriteBounds (BaseCamelotFilter *pFilter)
	Determines if the down/up pair need to be written.
virtual BOOL	AreYouSafeToRender ()
	Begin to write out your child records, in the native formatBegin to write out you child records, in the native formatGroup nodes are always safe to render, but derived group nodes (such as blends and text, etc) are not safe until their post import functions have been called.
virtual BOOL	RenderTight (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	CaptureTight (RenderRegion *pRender)
	Protected Helper function Use the CaptureManager to capture the results of rendering, cache them and associate them with this Ink node.
virtual double	GetTightGroupPixelsPerInch (RenderRegion *pRender=NULL) const
	Get width of pixels for use in capturing this group as a tight group bitmap.
virtual double	GetTightGroupPixelWidth (RenderRegion *pRender=NULL) const
virtual void	TransformTight (TransformBase &Trans, double dTestPixelWidth)
	Transform all the cached bitmaps associated with this node.
virtual BOOL	IsValidEffectAttr (NodeAttribute *pAttr) const
	Get width of pixels for use in capturing this group as a tight group bitmapDetermine whether this type of attribute can be an effect attribute On this node at this time.Determine whether this attribute instance can be an effect attribute On this node at this time.
virtual BOOL	GroupCanTransformCached (TransformBase &Trans) const

---

Detailed Description

Group Node.

Author:

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

Date:

28/9/93

Definition at line 122 of file group.h.

---

Constructor & Destructor Documentation

NodeGroup::NodeGroup (   )

This constructor creates a NodeGroup linked to no other, with all status flags false and an uninitialised bounding rectangle. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: -  [INPUTS] [OUTPUTS]  Returns: - Errors: Definition at line 164 of file group.cpp. : NodeCompound() { blenderNode = NULL; }

NodeGroup::NodeGroup (  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: 19/10/93 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] Direction: Specifies the direction in which this node is to be attached to the ContextNode. The values this variable can take are as follows: PREV : Attach node as a previous sibling of the context node NEXT : Attach node as a next sibling of the context node FIRSTCHILD: Attach node as the first child of the context node LASTCHILD : Attach node as a last child of the context node The remaining inputs specify the status of the node: Locked: Is node locked ? Mangled: Is node mangled ? Marked: Is node marked ? Selected: Is node selected ? Parameters: -  [OUTPUTS] Returns: - Errors: An assertion error will occur if ContextNode is NULL Definition at line 214 of file group.cpp. :NodeCompound(ContextNode, Direction, Locked, Mangled, Marked, Selected) { blenderNode = NULL; }

---

Member Function Documentation

BOOL NodeGroup::AreYouSafeToRender (   )  [virtual]

Begin to write out your child records, in the native formatBegin to write out you child records, in the native formatGroup nodes are always safe to render, but derived group nodes (such as blends and text, etc) are not safe until their post import functions have been called. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 18/9/96 Parameters: -  [INPUTS] Returns: TRUE if safe to render, FALSE otherwise See also: - Reimplemented from NodeRenderableInk. Definition at line 1842 of file group.cpp. { if (IS_A(this,NodeGroup)) return TRUE; else return NodeRenderableInk::AreYouSafeToRender(); }

BOOL NodeGroup::CaptureTight (  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: 11/01/2005 Returns: TRUE if captured data was cached See also: NodeRenderableBounded::RenderCached Definition at line 525 of file group.cpp. { // If the caller wants his bitmap to respond to Effect Attributes // Then we have to behave quite differently than a normal cache/capture sequence // We must grab the bitmap regardless of the cache-enabling flag // We must grab at a controlled resolution // We must grab the whole thing // We must grab at 32BPP RGBT Capture* pCapture = pRender->GetTopCapture(); if (pCapture==NULL) // If nothing was captured return FALSE; // Then do nothing CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache==NULL) { return FALSE; } // ERROR3IF(IsDragged() || m_bCachedBitmapShared, "CaptureTight asked to capture when its dragged"); // ERROR3IF(IsDragged(), "CaptureTight asked to capture when its dragged"); // Only stop the capture if we started it // (means we only capture whole subtrees at the mo.) BOOL bCached = FALSE; if (pCapture->GetOwner()==this) { // End this capture: // Blit capture to screen // Retain bitmap because we will release it ourselves onyl if we fail to cache it LPBITMAPINFO lpInfo = NULL; LPBYTE lpBits = NULL; DocRect CaptureRect = GetBoundingRect(); // Set maximum size we allow BOOL bFullCoverage = pCapture->HasFullCoverage(); pRender->StopCapture(this, FALSE, FALSE, &lpInfo, &lpBits, &CaptureRect); // If the capture gave us back a bitmap, try to cache it if (lpInfo && lpBits && CaptureRect.IsValid()) { //TRACEUSER("Phil", _T("Ending TightGroup Capture SUCCEEDED %x, %f\n"), this, GetTightGroupPixelWidth(pRender)); // Cache the ORIGINAL bitmap as Option 0 // See also, SetOriginalBitmap double PixelWidth = GetTightGroupPixelWidth(pRender); CBitmapCacheKey inky(this, PixelWidth, 0); CCachedBitmap cbmp; cbmp.pbmpBits = lpBits; cbmp.pbmpInfo = lpInfo; cbmp.SetCachedRect(CaptureRect); cbmp.nPriority = CACHEPRIORITY_TEMPBITMAP_HIGH; cbmp.bFullCoverage = bFullCoverage; if ( cbmp.IsValid() && !pRender->IsKindOf(CC_RUNTIME_CLASS(PrintingMaskedRenderRegion)) ) { pBitmapCache->StoreBitmap(inky, cbmp); MayBeCached = TRUE; bCached = TRUE; } // Render the bitmap taking effect attrs into account... if (lpInfo && lpBits) pRender->RenderBits(lpInfo, lpBits, CaptureRect, TRUE, this); } // If we failed to cache the captured bitmap then release it if (lpInfo!=NULL && lpBits!=NULL && !bCached) { //TRACEUSER("Phil", _T("Ending TightGroup Capture FAILED %x, %f\n"), this, GetTightGroupPixelWidth(pRender)); FreeDIB(lpInfo, lpBits, NULL, FALSE); } } return bCached; }

void NodeGroup::CopyNodeContents (  NodeGroup *  pCopyOfNode  )

Copies the data from this node to pCopyOfNode by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/2004 Parameters: pCopyOfNode  - The node to copy data to [INPUTS] -  [OUTPUTS] Returns: - See also: NodeGroup::CopyNodeContents Definition at line 1368 of file group.cpp. { NodeRenderableInk::CopyNodeContents(pCopyOfNode); pCopyOfNode->m_bBlendStartNode = m_bBlendStartNode; // NodeController? pCopyOfNode->m_bBlendEndNode = m_bBlendEndNode; // NodeController? pCopyOfNode->m_pBlendCreatedByNode = m_pBlendCreatedByNode; // NodeController? CopyCached(pCopyOfNode); // Copy cached bitmaps }

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

To return a description of the Group object in either the singular or the plural. This method is called by the DescribeRange method. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 18/6/93 Parameters: Plural,:  Flag indicating if the string description should be plural or [INPUTS] singular. -  [OUTPUTS] Retuns: Description of the group node The description will always begin with a lower case letter. Returns: Errors: (Need to do this) See also: - Reimplemented from Node. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBlend, NodeBrush, NodeMoulder, and NodeMould. Definition at line 1316 of file group.cpp. { if (Plural) return(String(_R(IDS_GROUP_DESCRP))); else return(String(_R(IDS_GROUP_DESCRS))); };

BOOL NodeGroup::ExportRender (  RenderRegion *  pRegion  )  [virtual]

Custom export code for nodes derived from NodeRenderableInk. So far there is only code for the VectorFileRenderRegion (which is a superclass for the EPS, CMX, and Flash render regions) to allow for the export of stroked shapes. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/00 Parameters: pRender  - A pointer to the render region being used for the export. [INPUTS] Returns: TRUE - The node was exported using this function. FALSE - There is no custom export code for this node type. Reimplemented from NodeRenderableInk. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBlend, NodeMoulder, and NodeMould. Definition at line 251 of file group.cpp. { #ifdef DO_EXPORT if (pRegion->IsKindOf(CC_RUNTIME_CLASS(EPSRenderRegion))) { // Output "end group" token EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); pDC->OutputToken(_T("U")); pDC->OutputNewLine(); // Tell caller we rendered ourselves ok return TRUE; } PORTNOTE("cmx", "Removed use of CMXRenderRegion") #ifndef EXCLUDE_FROM_XARALX else if(pRegion->IsKindOf(CC_RUNTIME_CLASS(CMXRenderRegion))) { // mark start of a group... CMXExportDC *pDC = (CMXExportDC *) pRegion->GetRenderDC(); pDC->EndGroup(); return TRUE; } #endif #endif // Render thid node in the normal way return FALSE; }

DocRect NodeGroup::GetBlobBoundingRect (   )  [virtual]

Finds the bounding rect of the group along with its blobs. Its main use is to determine which areas of the document to invalidate. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> (re-written) Date: 29/6/95 Returns: DocRect - The bounding rect of the group and its blobs Reimplemented from NodeRenderable. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBlend, NodeBrush, NodeMoulder, and NodeMould. Definition at line 1248 of file group.cpp. { DocRect NewRect = DocRect(0,0,0,0); #if !defined(EXCLUDE_FROM_RALPH) // Find the Blob manager BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr!= NULL) { BlobStyle VisibleBlobs = pBlobMgr->GetCurrentInterest(TRUE); if (VisibleBlobs.Object) { DocRect BoundingRect = GetBoundingRect(); // Object blobs are visible, so include blob in each // corner of the group bounds DocRect BlobSize; // Find out where the blobs will be drawn DocCoord Low = BoundingRect.LowCorner(); DocCoord High = BoundingRect.HighCorner(); // Include the object blob in each corner pBlobMgr->GetBlobRect(Low, &BlobSize); NewRect = NewRect.Union(BlobSize); pBlobMgr->GetBlobRect(High, &BlobSize); NewRect = NewRect.Union(BlobSize); pBlobMgr->GetBlobRect(DocCoord(Low.x, High.y), &BlobSize); NewRect = NewRect.Union(BlobSize); pBlobMgr->GetBlobRect(DocCoord(High.x, Low.y), &BlobSize); NewRect = NewRect.Union(BlobSize); } } Node* pNode=FindFirstChild(); while (pNode!=NULL) { if (pNode->IsBounded()) NewRect = NewRect.Union(((NodeRenderableBounded*)pNode)->GetBlobBoundingRect()); pNode = pNode->FindNext(); } IncludeChildrensBoundingRects(&NewRect); #endif return NewRect; }

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

If the groups bounding rect is known then it is returned. If not, it is re-calculated. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/6/94 Parameters: DontUseAttrs  - TRUE if the attrs associated with the node should be [INPUTS] ignored. defaults to FALSE HitTest - TRUE if being called during HitTest Returns: The Groups bounding rect Reimplemented from NodeRenderableBounded. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBlend, NodeBrush, and NodeMoulder. Definition at line 1162 of file group.cpp. { if (!IsBoundingRectValid || DontUseAttrs) { // Optimisation: // If we're holding cached data that is a full representation of our children // And we're being dragged // And the bounding box should include attrs (the cached data includes attrs) // // Then we can avoid calling our children recursively to get their bounding // rectangles because the info is all contained in our cached data's bounding // rectangle. // if (MayBeCached && IsDragged() && !DontUseAttrs) { CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); CCachedBitmap cbmp; BOOL bFound = FALSE; if (HasEffectAttrs()) { CBitmapCacheKey inky(this, GetTightGroupPixelWidth()); bFound = pBitmapCache->Lookup(inky, cbmp); bFound = bFound && cbmp.bFullCoverage; } else { View* pCurrentView = View::GetCurrent(); if (pCurrentView) { // Note! View::GetScaledPixelWidth returns an unrounded fractional value where // RenderRegion::GetScaledPixelWidth return a rounded integer!!! CBitmapCacheKey inky(this, (MILLIPOINT)(pCurrentView->GetScaledPixelWidth().MakeDouble()+0.5)); bFound = pBitmapCache->Lookup(inky, cbmp); bFound = bFound && cbmp.bFullCoverage; } } if (bFound) { BoundingRectangle = cbmp.GetCachedRect(); IsBoundingRectValid = TRUE; return BoundingRectangle; } } // Find the groups first child DocRect NewRect(0,0,0,0); Node* pNode = FindFirstChild(); while (pNode!=NULL) { // if this node is bounded, union its bounds with the others if (pNode->IsBounded()) NewRect = NewRect.Union(((NodeRenderableBounded*)pNode)->GetBoundingRect(DontUseAttrs)); // Get the next node in the list pNode = pNode->FindNext(); } if (DontUseAttrs) { // just return this rectangle as it is not the nodes true bounding rect return NewRect; } // copy the new docrect into the node bounding rect BoundingRectangle = NewRect; // Mark the bounding rect as valid IsBoundingRectValid = TRUE; } // Return the resulting bounding rect return BoundingRectangle; }

DocRect NodeGroup::GetEorDragBoundingRect (   )  [virtual]

Gets the eor drag bounding rect for all my children. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/2000 Parameters: None  [INPUTS] Returns: The eor drag bounding rect for all of my children See also: - Reimplemented from NodeRenderableBounded. Reimplemented in NodeClipViewController, and NodeMouldGroup. Definition at line 1128 of file group.cpp. { Node * pChild = FindFirstChild(); DocRect dr(0,0,0,0); while (pChild) { if (pChild->IsBounded()) { dr = dr.Union(((NodeRenderableBounded *)pChild)->GetEorDragBoundingRect()); } pChild = pChild->FindNext(); } return dr; }

UINT32 NodeGroup::GetNodeSize (   )  const [virtual]

This method outputs a 'deep' copy of the node. It is the same as CopyNode except that the copy is not linked into the tree. Override if your class can interpret the lightweight flagFor finding the size of the node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The size of the node in bytes See also: Node::GetSubtreeSize Reimplemented from Node. Reimplemented in NodeClipViewController, NodeMouldGroup, NodeBlend, NodeMoulder, and NodeMould. Definition at line 1470 of file group.cpp. { return (sizeof(NodeGroup)); }

double NodeGroup::GetTightGroupPixelsPerInch (  RenderRegion *  pRender = NULL  )  const [virtual]

Get width of pixels for use in capturing this group as a tight group bitmap. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 20/01/2005 Parameters: -  [INPUTS] Returns: pixel width for capturing Definition at line 614 of file group.cpp. { double dPPI = 0.0; if (NodeBitmapEffect::GroupPixelsPerInch==0) { // 0 means automatic // Automatic means get resolution in context // Context means either respond to a fixed resolution above us in the tree // or get resolution from current view double dViewPPI = 96.0; double dViewScaledPPI = 96.0; if (pRender==NULL) { View* pView = View::GetCurrent(); if (pView) dViewPPI = 72000.0 / pView->GetPixelWidth().MakeDouble(); dViewScaledPPI = 72000.0 / pView->GetScaledPixelWidth().MakeDouble(); } else { dViewPPI = pRender->GetPixelsPerInch(); dViewScaledPPI = 72000.0 / pRender->GetScaledPixelWidth(); } Node* pParent = this->FindParent(); while (pParent && !pParent->IsLayer()) { if (pParent->IsBitmapEffect()) { dPPI = ((NodeBitmapEffect*)pParent)->GetPixelsPerInchValue(); if (dPPI!=0) break; // If we found an effect at all then ensure we use default effect PPI dPPI = dViewPPI; } pParent = pParent->FindParent(); } // If we found no effects above us then try to operate at zoomed view res // for best results on screen. if (dPPI==0) { // See also OpEffectLock::DoEffectNodeOp // We should capture at at least 200dpi for printing // We should capture at a size that's at least as good as the current zoomed pixel size // (We rely on the capture being clipped to keep bitmap sizes under control at high zoom factors) // (We should reduce the resolution if the bitmap will be huge...) dPPI = dViewScaledPPI; } } // Try to limit bitmap size if dpi is getting large inside a wrapped // RenderRegion. // Without this restriction, tight groups inside shadows become a problem // because this function does not pick up the reduced resolution of the // offscreen render region used by the shadow to create its silhouette. if (pRender && pRender->IsWrappedRender() && dPPI>480) { dPPI = 480; } if (dPPI==0) dPPI = NodeBitmapEffect::GroupPixelsPerInch; if (dPPI==0) { // Shouldn't ever reach this clause but just in case... ERROR3("GetPixelsPerInch can't get sensible PPI so defaulting to 96"); dPPI = 96.0; } TRACEUSER("Phil", _T("GTGPPI %f\n"), dPPI); return dPPI; }

virtual double NodeGroup::GetTightGroupPixelWidth (  RenderRegion *  pRender = NULL  )  const [inline, virtual]

Definition at line 184 of file group.h. {return 72000.0/GetTightGroupPixelsPerInch(pRender);}

virtual BOOL NodeGroup::GroupCanTransformCached (  TransformBase &  Trans  )  const [inline, virtual]

Reimplemented in NodeContourController, NodeClipViewController, NodeBrush, NodeMoulder, and NodeMould. Definition at line 189 of file group.h. {return TRUE;}

virtual BOOL NodeGroup::IsAGroup (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 139 of file group.h. { return TRUE; }

BOOL NodeGroup::IsValidEffectAttr (  NodeAttribute *  pAttr  )  const [virtual]

Get width of pixels for use in capturing this group as a tight group bitmapDetermine whether this type of attribute can be an effect attribute On this node at this time.Determine whether this attribute instance can be an effect attribute On this node at this time. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/01/2005 Parameters: Attribute  [INPUTS] Returns: TRUE if the attr is a valid effect attr Reimplemented from NodeRenderableInk. Reimplemented in NodeMouldGroup, NodeBrush, NodeMoulder, and NodeMould. Definition at line 769 of file group.cpp. { // return (AttrFillGeometry::s_bGroupTransparency && // If pref allows group transparency // (pAttr->IsATranspFill() || // And the attribute is a transparency type // pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrTranspChange)) || // Return TRUE to apply the attr as an effect // pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrStrokeTranspChange)) // ) // ); CCRuntimeClass* pAttrType = pAttr->GetAttributeType(); return (AttrFillGeometry::s_bGroupTransparency && // If pref allows group transparency (pAttr->IsATranspFill() || pAttrType == CC_RUNTIME_CLASS(AttrTranspFillGeometry) || //->IsKindOf(CC_RUNTIME_CLASS(AttrTranspChange)) || pAttrType == CC_RUNTIME_CLASS(AttrStrokeTransp) || //pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrStrokeTranspChange)) || pAttrType == CC_RUNTIME_CLASS(AttrTranspFillMapping) ) ); }

ChangeCode NodeGroup::OnChildChange (  ObjChangeParam *  pParam  )  [virtual]

This function should be overridden in derived object classes. Composite objects can use this function to respond to one of their children undergoing a change. They should return CC_FAIL whenever they are unable to cope with the change. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 07/02/95 Parameters: pParam  = pointer to a object change parameter class [INPUTS] Returns: CC_OK if we have successfully processed the change. CC_FAIL if we cannot handle this particular change and must prevent the child from continuing Groups will hide themselves if the op has left it in a state where it has no bounds, i.e. all it's node renderable bounded children are gone. See also: WarnParentOfChange(),AllowOp(); Reimplemented from NodeCompound. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBlend, NodeBrush, NodeMoulder, and NodeMould. Definition at line 1624 of file group.cpp. { ERROR2IF(pParam == NULL,CC_FAIL,"pParam == NULL"); ObjChangeType cType = pParam->GetChangeType(); if (cType == OBJCHANGE_FINISHED) { InvalidateBoundingRect(); // The groups DocRect Rect = GetBoundingRect(); if (Rect.IsEmpty()) { UndoableOperation* pOp = pParam->GetOpPointer(); if (pOp != NULL) { Node* pParent = FindParent(); if (!pOp->DoHideNode(this,TRUE)) { return CC_FAIL; } // This bit is a bit scary, but should work ! // After a deletion we factor out all attributes on the parent of this group if (pParent && pParent->IsCompound()) { if (!pOp->DoFactorOutCommonChildAttributes(((NodeRenderableInk*)pParent),TRUE)) { return CC_FAIL; } } } } } return NodeCompound::OnChildChange(pParam); }

BOOL NodeGroup::OnClick (  DocCoord  PointerPos, ClickType  Click, ClickModifiers  ClickMods, Spread *  pSpread )  [virtual]

Determines if the user has started a drag on one of the groups blobs. If they have then it starts the groups resize operation. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 27/09/94 Parameters: PointerPos  - The Location of the mouse pointer at the time of the click [INPUTS] Click - The type of click received (single, double, drag etc) ClickMods - The modifiers to the click (eg shift, control etc ) Returns: TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented from NodeRenderableInk. Reimplemented in NodeClipViewController, NodeMouldGroup, NodeBlend, NodeMoulder, and NodeMould. Definition at line 1493 of file group.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Find a view and if we failed to find a view, then just don't claim the click DocView *pDocView = DocView::GetSelected(); if (pDocView==NULL) return FALSE; // we only handle the click if we can confirm that object blobs are being displayed. BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr == NULL) return FALSE; if (!pBlobMgr->GetCurrentInterest().Object) return FALSE; // Find the DocRect of blob size around the point that was clicked on DocRect MouseBlob; OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), PointerPos, BT_SELECTEDLARGEST, &MouseBlob); INT32 StartBlob = 0; // If the user has clicked on a blob we will need to set the centre of rotation to the // oposite corner DocCoord OpCorner; // Has the user clicked on one of the group's blobs ? if (MouseBlob.ContainsCoord(BoundingRectangle.lo)) // Bottom left { StartBlob = 6; OpCorner = BoundingRectangle.hi; } else if (MouseBlob.ContainsCoord(BoundingRectangle.hi)) // Top right { StartBlob = 3; OpCorner = BoundingRectangle.lo; } else if (MouseBlob.ContainsCoord(DocCoord(BoundingRectangle.lo.x,BoundingRectangle.hi.y))) // Top left { StartBlob = 1; OpCorner = DocCoord(BoundingRectangle.hi.x,BoundingRectangle.lo.y); } else if (MouseBlob.ContainsCoord(DocCoord(BoundingRectangle.hi.x,BoundingRectangle.lo.y))) // Bottom right { StartBlob = 8; OpCorner = DocCoord(BoundingRectangle.lo.x,BoundingRectangle.hi.y); } if (StartBlob != 0) { // User has clicked on a blob if (Click==CLICKTYPE_DRAG) { // Try to create the operation to scale the group OpScaleTrans* pOp = new OpScaleTrans(); if (pOp == NULL) { InformError(); return TRUE; // Claim the click though } // Create a range containing only this object // RangeControl RngCtl = { TRUE, FALSE, FALSE }; static TransformData TransData; // Setup the transform info TransData.CentreOfTrans = OpCorner; TransData.StartBlob = StartBlob; TransData.LockAspect = FALSE; TransData.LeaveCopy = FALSE; TransData.ScaleLines = TRUE; TransData.TransFills = TRUE; TransData.pRange = 0; TransformBoundingData BoundingData; BoundingData.x = BoundingRectangle.lo.x; BoundingData.y = BoundingRectangle.lo.y; BoundingData.Width = BoundingRectangle.Width(); BoundingData.Height = BoundingRectangle.Height(); BoundingData.XScale = (FIXED16) 1; BoundingData.YScale = (FIXED16) 1; BoundingData.Rotation = (ANGLE) 0; BoundingData.Shear = (ANGLE) 0; // Start the drag pOp->DragStarted(&TransData, NULL, // Don't report to any tool &BoundingData, // Must give bounds data or call fails PointerPos, pSpread, ClickMods, DocCoord(0,0), this ); } // we have used that click up return TRUE; } #endif // we did not use the click, so let someone else try return FALSE; }

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

Polymorphically copies the contents of this node to another. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/2004 Parameters: -  [OUTPUTS] Returns: Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Reimplemented from NodeRenderableBounded. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBlend, NodeBrush, NodeMoulder, and NodeMould. Definition at line 1390 of file group.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeGroup), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeGroup)) CopyNodeContents((NodeGroup*)pNodeCopy); }

void NodeGroup::PreExportRender (  RenderRegion *  pRegion  )  [virtual]

Perform any rendering required when exporting to a file, and this node is being 'passed by' during the tree searching. For example, a group node being exported to EPS would output a "start group" token, and then its ExportRender function would output a "end group" token. By default, it does nothing. Nodes wishing to do special export processing should override this function (and ExportRender). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 25/03/94 Parameters: pRender  - the render region we are exporting to. [INPUTS] See also: Node::ExportRender; Node::NeedsToExport Reimplemented from Node. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBlend, NodeMoulder, and NodeMould. Definition at line 228 of file group.cpp. { #ifdef DO_EXPORT if (pRegion->IsKindOf(CC_RUNTIME_CLASS(EPSRenderRegion))) { // Output "start group" token EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); pDC->OutputToken(_T("u")); pDC->OutputNewLine(); } PORTNOTE("cmx", "Removed use of CMXRenderRegion") #ifndef EXCLUDE_FROM_XARALX else if(pRegion->IsKindOf(CC_RUNTIME_CLASS(CMXRenderRegion))) { // mark start of a group... CMXExportDC *pDC = (CMXExportDC *) pRegion->GetRenderDC(); DocRect BBox = GetBoundingRect(); pDC->StartGroup(&BBox); } #endif #endif }

void NodeGroup::RenderAfterSubtree (  RenderRegion *  pRegion  )  [virtual]

For determining quickly if the node is a compound object Capture the group as a cached bitmap. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 17/06/2004 Parameters: pRender  - The region to render into [INPUTS] Reimplemented from Node. Definition at line 313 of file group.cpp. { // Deal with group transparency capture // Call Helper function to run all my cacheing functionality for me... // If we have Effect attrs applied then the user wants "tight group transparency" if (HasEffectAttrs()) CaptureTight(pRegion); else CaptureCached(pRegion); }

void NodeGroup::RenderObjectBlobs (  RenderRegion *  pRegion  )  [virtual]

Will render the group iff we have it cached - for hit detection reasonsRenders the object blobs. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/6/94 Parameters: pRender  - The region to draw the blobs in [INPUTS] Reimplemented from NodeRenderable. Reimplemented in NodeBlend, NodeBrush, and NodeMould. Definition at line 842 of file group.cpp. { NodeCompound::RenderObjectBlobs(pRegion); #if !defined(EXCLUDE_FROM_RALPH) // Find out about the groups bounding rect DocRect BoundingRect = GetBoundingRect(); // Find out where to draw the blobs DocCoord Low = BoundingRect.LowCorner(); DocCoord High = BoundingRect.HighCorner(); // Set the colours of the blobs pRegion->SetFillColour(COLOUR_UNSELECTEDBLOB); pRegion->SetLineColour(COLOUR_NONE); // Draw all the blobs pRegion->DrawBlob(Low, BT_UNSELECTED); pRegion->DrawBlob(High, BT_UNSELECTED); pRegion->DrawBlob(DocCoord(Low.x, High.y), BT_UNSELECTED); pRegion->DrawBlob(DocCoord(High.x, Low.y), BT_UNSELECTED); #endif }

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

Do clever stuff on the way into a subtree, possibly modifying rendering behaviour. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 29/06/2004 Parameters: pRender  - The region render into (or use as context for decisions about subtree) [INPUTS] ppNextNode - Address of node pointer for next node to render or run to after this bClip - flag indicating whether to clip or not Reimplemented from NodeRenderableBounded. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, and NodeBrush. Definition at line 340 of file group.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 BoundingRect = GetBoundingRect(); DocRect ClipRect = pRender->GetClipRect(); if (bClip && !ClipRect.IsIntersectedWith(BoundingRect)) // If not within the clipping rect then return SUBTREE_NORENDER; // Don't render us or our children // Ask Helper function to set up cacheing for me... // If we have Effect attrs applied then the user wants "tight group transparency" if (HasEffectAttrs()) { if (RenderTight(pRender)) return SUBTREE_NORENDER; } else { if (RenderCached(pRender)) // If we can find a cached bitmap for this node and render it { //TRACEUSER("Phil", _T("Skipping cached group %x %s\n"), this, GetRuntimeClass()->m_lpszClassName); return SUBTREE_NORENDER; // Then tell the renderer to move on without doing any more... } //TRACEUSER("Phil", _T("Re-rendering cached group %x %s\n"), this, GetRuntimeClass()->m_lpszClassName); } return SUBTREE_ROOTANDCHILDREN; // Else we must render ourselves and our children }

BOOL NodeGroup::RenderTight (  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: 11/01/2005 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 397 of file group.cpp. { // If the caller wants his bitmap to respond to Effect Attributes // Then we have to behave quite differently than a normal cache/capture sequence // We must grab the bitmap regardless of the cache-enabling flag // We must grab at a controlled resolution // We must grab the whole thing // We must grab at 32BPP RGBT // // 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()) return FALSE; // Tight groups need to be rendered in the complex bitmap stages of printing if (pRender->IsKindOf(CC_RUNTIME_CLASS(ScanningRenderRegion))) { ScanningRenderRegion* pScanner = (ScanningRenderRegion*)pRender; pScanner->ComplexShapeFoundWrapper(); return TRUE; // Return TRUE so that rendering will NOT continue into the group normally } 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; CBitmapCacheKey inky(this, GetTightGroupPixelWidth(pRender)); // No need to check BackmostChanged node here because we never capture // our background in a 24BPP bitmap we always capture at 32BPP using cfLOCKEDTRANSPARENT // 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("Rendering cached bitmap for %x %s\n"), this, GetRuntimeClass()->GetClassName() ); bRendered = pRender->RenderBits(cbmp.pbmpInfo, cbmp.pbmpBits, &cbmp.coord0, 3, TRUE, this); } } if (bRendered) return bRendered; // If we couldn't find or render a cached bitmap then try to cache a new one // double ScaledPixelWidth = pRender->GetScaledPixelWidth(); // Work out how much of the object we propose to capture DocRect viewrect = cliprect; DocRect CaptureRect = bounds; if (!pRender->IsPrinting()) { 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 our capture rect is invalid (no intersection) then don't do any rendering if (!CaptureRect.IsValid()) return(TRUE); if (!pRender->IsPrinting()) { // 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)GetTightGroupPixelWidth(pRender)); BOOL bFullCoverage = CaptureRect.ContainsRect(bounds); // Finally start the Capture @ 32BPP CaptureFlags caFlags = CaptureFlags(cfLOCKEDTRANSPARENT | cfUNCLIP | (bFullCoverage ? cfFULLCOVERAGE : cfNONE)); //TRACEUSER("Phil", _T("Starting TightGroup Capture %x, %f\n"), this, GetTightGroupPixelsPerInch(pRender)); pRender->StartCapture(this, CaptureRect, CAPTUREINFO(ctNESTABLE, caFlags), TRUE, FALSE, GetTightGroupPixelsPerInch(pRender)); return bRendered; }

void NodeGroup::RenderTinyBlobs (  RenderRegion *  pRegion  )  [virtual]

Renders the tiny blobs for a group (A Single blob on the topmost child object in the group). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/6/94 Parameters: pRender  - The region to draw the blobs in [INPUTS] Reimplemented from NodeRenderable. Reimplemented in NodeContourController, NodeClipViewController, NodeBrush, and NodeMould. Definition at line 881 of file group.cpp. { #if !defined(EXCLUDE_FROM_RALPH) if (NodeRenderableBounded::bShowCacheBlobs) { // To help see what the cacheing system is doing // If this node has a cached bitmap associated with it // Render a special blob to show that... CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache && MayBeCached && !HasEffectAttrs()) { CBitmapCacheKey inky(this, pRegion->GetScaledPixelWidth()); //GetScaledPixelWidthDouble? CCachedBitmap cbmp; BOOL bFound = pBitmapCache->Lookup(inky, cbmp); if (bFound) { // Find out about the groups bounding rect DocRect BoundingRect = GetBoundingRect(); // Draw a blob if (cbmp.IsTransparent()) pRegion->DrawBitmapBlob(DocCoord(BoundingRect.hi.x - pRegion->GetScaledPixelWidth(), BoundingRect.lo.y - pRegion->GetScaledPixelWidth()), _R(IDB_CACHE_MARK_32)); else pRegion->DrawBitmapBlob(DocCoord(BoundingRect.hi.x - pRegion->GetScaledPixelWidth(), BoundingRect.lo.y - pRegion->GetScaledPixelWidth()), _R(IDB_CACHE_MARK_24)); } } } // get the topmost object in this group and tell it to render its tiny blobs. Node* pNode = FindLastChild(); while (pNode != NULL && !pNode->IsAnObject()) pNode = pNode->FindPrevious(); // empty groups are not allowed! if (pNode == NULL) { ERROR3("NodeGroup::RenderTinyBlobs; This group is empty! Shouldn't be!"); return; } else { ((NodeRenderableInk*)pNode)->RenderTinyBlobs(pRegion); } #endif }

Node * NodeGroup::SimpleCopy (  void   )  [virtual]

This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/93 Parameters: -  [INPUTS] [OUTPUTS]  Returns: A copy of the node, or NULL if memory has run out Errors: If memory runs out when trying to copy, then ERROR is called with an out of memory error and the function returns NULL. Reimplemented from NodeRenderableInk. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBlend, NodeBrush, NodeMoulder, and NodeMould. Definition at line 1342 of file group.cpp. { NodeGroup* NodeCopy; NodeCopy = new NodeGroup(); ERRORIF(NodeCopy == NULL, _R(IDE_NOMORE_MEMORY), NULL); CopyNodeContents(NodeCopy); return (NodeCopy); }

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

Transforms the group object and all its children. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/6/94 Parameters: Trans  - A transformation object [INPUTS] Reimplemented from NodeRenderableBounded. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBrush, NodeMoulder, and NodeMould. Definition at line 940 of file group.cpp. { View* pView = View::GetCurrent(); if (GroupCanTransformCached(Trans) && pView) // if (GroupCanTransformCached() && pView) { // Note! View::GetScaledPixelWidth returns an unrounded fractional value where // RenderRegion::GetScaledPixelWidth return a rounded integer!!! // // Note! It would be better not to call HasEffectAttrs() here because it can be slow in large groups if (HasEffectAttrs()) TransformTight(Trans, GetTightGroupPixelsPerInch()); else TransformCached(Trans, (MILLIPOINT)(pView->GetScaledPixelWidth().MakeDouble()+0.5)); } else { // Our cached data can't be transformed so we must remove it because // it will now be out of date // We must do it directly because ReleaseCached does conditional // stuff based on IsDragged //TRACEUSER("Phil", _T("NodeGroup::Transform releasing cache\n")); CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache!=NULL) { CBitmapCacheKey inky(this, 42); pBitmapCache->RemoveAllOwnedBitmaps(inky); MayBeCached = FALSE; Trans.bHaveTransformedCached = FALSE; Trans.bTransformYourChildren = TRUE; } } // Optimisation: // If we have transformed our cached data // And we're dragging // And we were holding cached data (sanity check) // (And /assuming/ that the cached data fully represents the child objects!!!) // // Then we can avoid transforming our children to save time // // This is safe because we know that the dragged objects will not remain permanently in the // document so it doesn't matter if they're not up to date... // BOOL bTransCache = Trans.bHaveTransformedCached; if (Trans.bTransformYourChildren) { // Transform all the children NodeRenderableInk::TransformChildren(Trans); } else { // We can get away with just transforming our effect attrs TransformEffectAttrs(Trans); Trans.bHaveTransformedChildren = FALSE; } Trans.bHaveTransformedCached = bTransCache; // If we have successfully transformed the cached data for this // contour then we can simply transform the bounds to suit... // (Some derived classes might not be able to compute bounds // if their children have not been transformed.) // (Bounds have to be correct for RenderCached to allow the cached // bitmap to be used during dragging.) // // We can only do this for translations at the moment // if (Trans.bHaveTransformedCached && Trans.IsTranslation()) { Trans.Transform(&BoundingRectangle.lo, 1); Trans.Transform(&BoundingRectangle.hi, 1); /* The following code doesn't work because it keeps on transforming the results of previous transformed bounding rects, iteratively getting bigger and bigger. It needs to be able to work on the original bounding rect all the time DocCoord temp[4]; temp[0] = BoundingRectangle.lo; temp[1] = BoundingRectangle.hi; temp[2] = DocCoord(BoundingRectangle.lox, BoundingRectangle.hiy); temp[3] = DocCoord(BoundingRectangle.hix, BoundingRectangle.loy); Trans.Transform(temp, 4); BoundingRectangle.lo = temp[0]; BoundingRectangle.hi = temp[0]; BoundingRectangle.IncludePoint(temp[1]); BoundingRectangle.IncludePoint(temp[2]); BoundingRectangle.IncludePoint(temp[3]); */ } else { // The groups bounding rect is no longer valid // ERROR3IF(!IS_A(this, NodeGroup) && !Trans.bHaveTransformedChildren, "Compound children not transformed but compound bounding rect depends on them\n"); InvalidateBoundingRect(); } // -------------------------------------------------------------------- // CGS: We need to check for a blend on a path here .... if (IS_A (this, NodeBlend)) { NodeBlend* ptrBlend = (NodeBlend*) this; NodeBlender* ptrBlender = (NodeBlender*) ptrBlend->FindFirstBlender (); if (ptrBlender) { ptrBlender->UpdateBlendStartAngles ((Trans2DMatrix&) Trans); BOOL done = FALSE; while (!done) { ptrBlender = ptrBlend->FindNextBlender (ptrBlender); if (!ptrBlender) { done = TRUE; } else { ptrBlender->UpdateBlendStartAngles ((Trans2DMatrix&) Trans); } } } } }

void NodeGroup::TransformTight (  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 1084 of file group.cpp. { 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; } }

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

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

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

Write out a record containing the bounds of this object. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/05 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise Reimplemented from NodeRenderableInk. Definition at line 1719 of file group.cpp. { BOOL ok = TRUE; // Write out the record DocRect Rect = GetBoundingRect(); if (HasEffectAttrs()) { CamelotFileRecord Rec(pFilter, TAG_COMPOUNDRENDER, TAG_COMPOUNDRENDER_SIZE); ok = Rec.Init(); if (ok) ok = Rec.WriteUINT32(0); // Reserved if (ok) ok = Rec.WriteCoord(Rect.lo); if (ok) ok = Rec.WriteCoord(Rect.hi); if (ok) ok = pFilter->Write(&Rec); } else { CamelotFileRecord Rec(pFilter, TAG_OBJECTBOUNDS, TAG_OBJECTBOUNDS_SIZE); ok = Rec.Init(); if (ok) ok = Rec.WriteCoord(Rect.lo); if (ok) ok = Rec.WriteCoord(Rect.hi); if (ok) ok = pFilter->Write(&Rec); } return(ok); }

BOOL NodeGroup::WritePreChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Reimplemented from Node. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBlend, NodeBrush, NodeMoulder, and NodeMould. Definition at line 1697 of file group.cpp. { #ifdef DO_EXPORT return WritePreChildrenWeb(pFilter); #else return FALSE; #endif }

BOOL NodeGroup::WritePreChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes the group record to the filter. > virtual BOOL NodeGroup::WritePreChildrenWeb(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/96 Parameters: pFilter  = ptr to the filter [INPUTS] Returns: TRUE if record is written, FALSE if not See also: - Reimplemented from Node. Reimplemented in NodeContourController, NodeClipViewController, NodeMouldGroup, NodeBlend, NodeBrush, NodeMoulder, and NodeMould. Definition at line 1679 of file group.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); CXaraFileRecord Rec(TAG_GROUP,0); BOOL ok = pFilter->Write(&Rec); return ok; #else return FALSE; #endif }

---

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

• Kernel/group.h (r1785/r751)
• Kernel/group.cpp (r1785/r1688)

---