NodeBitmapEffect Class Reference

Bitmap effects nodes are type of Post-Processors. They process the bitmap output of their child nodes. More...

#include <nodeliveeffect.h>

Inheritance diagram for NodeBitmapEffect:

List of all members.

Public Member Functions
	NodeBitmapEffect ()
	Note:.
	~NodeBitmapEffect ()
	Destructor Note:.
	NodeBitmapEffect (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	This constructor initialises the nodes flags and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated. Note: SetUpShape() must be called before the NodeRegularShape is in a state in which it can be used.
virtual BOOL	IsBitmapEffect () const
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 NodeRenderableInk *	GetInkNodeFromController () const
	If we had a Controller node inherited class from NodeGroup then this function really belongs there. But we don't, so this function only returns anything if your node also returns TRUE to IsAController(). If so it will return the node that is shadowed, bevelled or contoured.
virtual void	Render (RenderRegion *pRender)
	Will render the liveeffect iff we have it cached - for hit detection reasons.
virtual BOOL	DoBecomeA (BecomeA *pBecomeA)
	Converts me to a path Notes: Note that when this routine creates paths it does NOT call DoBecomeA on its children because the paths and the bitmap fills represetn everything the child objects have rendered.
virtual BOOL	CanBecomeA (BecomeA *pBecomeA)
	Can become a path !
virtual BOOL	HasCachedDirectBitmap ()
virtual BOOL	WriteBoundsRecord (BaseCamelotFilter *pFilter)
	Begin to write out your child records, in the native format.
virtual BOOL	WillWriteBounds (BaseCamelotFilter *pFilter)
	Determines if the down/up pair need to be written.
virtual void	RenderAfterSubtree (RenderRegion *pRender)
	Capture the group as a cached bitmap.
virtual BOOL	GetOriginalBitmap (LPBITMAPINFO *plpInfo, LPBYTE *plpBits, DocRect *pRect)
	To get the required/stored pixel width of this node -.
virtual void	SetOriginalBitmap (LPBITMAPINFO lpInfo, LPBYTE lpBits, DocRect rect)
virtual BOOL	GetProcessedBitmap (BOOL bDirect, LPBITMAPINFO *plpInfo, LPBYTE *plpBits, DocRect *pRect)
virtual DocRect	SetProcessedBitmap (LPBITMAPINFO lpInfo, LPBYTE lpBits, DocRect rect, INT32 width, INT32 height, double xOffset, double yOffset, double dPixelWidth=0, Matrix *pmatTransform=NULL)
virtual IXMLDOMDocumentPtr	GetEditList ()
virtual void	SetEditList (IXMLDOMDocumentPtr pNewEditsDoc)
virtual BOOL	SetDefaultEditList ()
virtual BOOL	IsLockedEffect ()
virtual BOOL	HasChanged () const
virtual BOOL	SetChanged (BOOL bNewFlag=TRUE)
virtual BOOL	CompareState (NodeEffect *pPPNode)
	Notes: Would be more efficient to pass in level xml instead of getting it inside this function
virtual BOOL	ProcessBitmap (RenderRegion *pRender, CBitmapCache *pBitmapCache, LPBITMAPINFO pBMPInfo, LPBYTE pBMPBits, DocRect BMPRect, LPBITMAPINFO &pOutputInfo, LPBYTE &pOutputBits, double *pXOffset, double *pYOffset)
	Processes the bitmap produced by the children of this node. Can be overridden by derived classes to perofrm special processing.
virtual String_64 &	GetDisplayName ()
virtual void	SetDisplayName (String_64 &strDisplayName)
virtual KernelBitmap *	GetKernelBitmap (DocCoord *pCoords, BOOL bRetainCached=FALSE)
virtual double	GetPixelsPerInch ()
	To get the required/stored pixel res of this node.
virtual double	GetPixelsPerInchValue () const
virtual void	SetPixelsPerInch (double dPixelsPerInch)
	To get the required/stored pixel res of this node.
virtual BOOL	CanGenerateBitmap ()
	Test whether node is big enough to bother with.
virtual BOOL	GetChildDirectBitmap (RenderRegion *pRender, LPBITMAPINFO *plpInfo=NULL, LPBYTE *plpBits=NULL, DocRect *pRect=NULL, Matrix *pMat=NULL, double *pdRes=NULL)
virtual BOOL	CanSupplyDirectBitmap ()
virtual BOOL	GetDirectBitmap (RenderRegion *pRender, LPBITMAPINFO *plpInfo, LPBYTE *plpBits, DocRect *pRect, Matrix *pMat, double *pdRes)
	Return details of direct bitmap to caller (caller is usually a NodeBitmapEffect).
virtual BOOL	RenderDirectBitmapState (RenderRegion *pRender)
	Render the current state into the renderregion if we haven't yet done so. Only used in background rendering timeslice screen update.
virtual BOOL	EnableDirectCapture ()
	Determine whether this effect can do a direct capture of its child node(s) or whether it needs to do a normal, rendering capture. At the moment, this depends solely on whether the DirectBitmap supplier can supply a bitmap at the same resolution as this effect requires.
Static Public Member Functions
static BOOL	Init ()
	Initialise the NodeBitmapEffect class.
Static Public Attributes
static UINT32	DefaultLivePixelsPerInch
static UINT32	DefaultLockedPixelsPerInch
static UINT32	GroupPixelsPerInch = 0
static UINT32	ShadowPixelsPerInch = 0
static BOOL	DefaultLocked = FALSE
Protected Member Functions
virtual double	GetPixelWidth ()
virtual DocRect	AdjustPixelOffsets (DocRect inRect, INT32 width, INT32 height, double xOffset, double yOffset, double dPixelWidth=0)
	Notes: Width, height, xoffset, yoffset refer to bitmap in standard Windows fashion - Y coords increase downwards, offsets refer to top-left corner This routine must move from one coord system to the other while it updates the supplied rectangle
virtual BOOL	FindCachedEffect (CBitmapCache *pBitmapCache)
	Find all cached items this node needs to call RenderCachedEffect succesfully.
virtual BOOL	RenderCachedEffect (CBitmapCache *pBitmapCache, RenderRegion *pRenderRegion, BOOL bIgnoreCapture=FALSE)
	Render the cached version of this node.
virtual BOOL	GetQuickRender ()
virtual BOOL	CanGetChildDirectBitmap ()
	FInd out whether our controlled child can give us a DirectBitmap.
Protected Attributes
IXMLDOMDocumentPtr	m_pEditsDoc
StringVar	m_vstrEdits
double	m_dPixelsPerInch
BOOL	m_bHasChangedRecently
String_64	m_strDisplayName
DocRect	m_rectDirectBitmap
Private Member Functions
	CC_DECLARE_DYNCREATE (NodeBitmapEffect)
Friends
class	LiveEffectRecordHandler

---

Detailed Description

Bitmap effects nodes are type of Post-Processors. They process the bitmap output of their child nodes.

Author:

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

Date:

07/09/2004

Definition at line 163 of file nodeliveeffect.h.

---

Constructor & Destructor Documentation

NodeBitmapEffect::NodeBitmapEffect (   )

Note:. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/09/2004 See also: Definition at line 336 of file nodeliveeffect.cpp. : NodeEffect() { m_pEditsDoc = NULL; m_bHasChangedRecently = FALSE; m_strPostProID = String( _T("") ); m_strDisplayName = String( _T("") ); }

NodeBitmapEffect::~NodeBitmapEffect (   )

Destructor Note:. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/09/2004 See also: Definition at line 358 of file nodeliveeffect.cpp. { m_pEditsDoc = NULL; // m_pEditsDoc is a smart pointer so NULLing it Releases the COM interface // and releases any memory // Note that NodeBitmapEffect stores original bitmap data in the cache // but this destructor relies no derived classes clareing cached data when they // are destroyed for efficiency. }

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

This constructor initialises the nodes flags and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated. Note: SetUpShape() must be called before the NodeRegularShape is in a state in which it can be used. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/09/2004 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] MonoOn Direction: MonoOff 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 BoundingRect: Bounding rectangle 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 ? See also: NodeRegularShape::SetUpShape Returns: Errors: An ENSURE will occur if ContextNode is NULL Definition at line 307 of file nodeliveeffect.cpp. : NodeEffect(ContextNode, Direction, Locked, Mangled, Marked, Selected ) { m_pEditsDoc = NULL; m_bHasChangedRecently = FALSE; m_strPostProID = String(_T("")); m_strDisplayName = String(_T("")); m_rectDirectBitmap = DocRect(0,0,0,0); }

---

Member Function Documentation

DocRect NodeBitmapEffect::AdjustPixelOffsets (  DocRect  inRect, INT32  width, INT32  height, double  xOffset, double  yOffset, double  dPixelWidth = 0 )  [protected, virtual]

Notes: Width, height, xoffset, yoffset refer to bitmap in standard Windows fashion - Y coords increase downwards, offsets refer to top-left corner This routine must move from one coord system to the other while it updates the supplied rectangle Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 14/09/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Definition at line 944 of file nodeliveeffect.cpp. { if (dPixelWidth==0) dPixelWidth = GetPixelWidth(); DocRect outRect(inRect.lo.x, inRect.hi.y, inRect.lo.x, inRect.hi.y); // Set new bitmap origin to old bitmap origin outRect.lo.x += INT32( xOffset * dPixelWidth ); // Set new bitmap origin X (-ve offset means "move left") outRect.hi.y -= INT32( yOffset * dPixelWidth ); // Set new bitmap origin Y (-ve yoffset means "move up") if (width==0) outRect.hi.x = outRect.lo.x + inRect.Width(); else outRect.hi.x = outRect.lo.x + INT32( width * dPixelWidth ); // Set width of new bitmap if (height==0) outRect.lo.y = outRect.hi.y - inRect.Height(); else outRect.lo.y = outRect.hi.y - INT32( height * dPixelWidth ); // Set height of new bitmap return outRect; }

BOOL NodeBitmapEffect::CanBecomeA (  BecomeA *  pBecomeA  )  [virtual]

Can become a path ! Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 08/02/2005 Parameters: Ink  class to test [INPUTS] See also: Reimplemented from NodeCompound. Definition at line 1725 of file nodeliveeffect.cpp. { // Don't make a dumb square bitmap if the Op is a blend op because in that case // it's more useful to have the original shape with the effect // Or if this node is in the top surface of those being considered // and the op tells us that the results of dobecomea will be left in place (i.e. under // and effect stack) if (!IsLockedEffect()) { if (pBecomeA->IsBlendBecomeA() || pBecomeA->ResultsStayInPlace()) { return NodeEffect::CanBecomeA(pBecomeA); } } // We only do conversions if we are the top effect in the stack if (!IsLockedEffect() && FindParent() && FindParent()->IsEffect()) return FALSE; if (pBecomeA->BAPath()) { pBecomeA->AddCount(1); return TRUE; } return FALSE; }

BOOL NodeBitmapEffect::CanGenerateBitmap (   )  [virtual]

Test whether node is big enough to bother with. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 01/07/2005 Parameters: -  [INPUTS] Returns: TRUE if this effect node can generate an original bitmap FALSE otherwise See also: Definition at line 1768 of file nodeliveeffect.cpp. { double PixelWidth = GetPixelWidth(); DocRect CaptureRect = GetChildBoundingRect(); return (CaptureRect.Width()>=PixelWidth && CaptureRect.Height()>=PixelWidth); }

BOOL NodeBitmapEffect::CanGetChildDirectBitmap (   )  [protected, virtual]

FInd out whether our controlled child can give us a DirectBitmap. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 26/07/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if we can get a bitmap dircetly from our controlled child node FALSE otherwise Definition at line 823 of file nodeliveeffect.cpp. { NodeRenderableInk* pInkNode = GetInkNodeFromController(); if (pInkNode==NULL) return FALSE; BOOL bOK = EnableDirectCapture() && pInkNode->CanSupplyDirectBitmap(); return bOK; }

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

Reimplemented from NodeRenderableInk. Reimplemented in NodeLockedEffect, and NodeFeatherEffect. Definition at line 254 of file nodeliveeffect.h. {return TRUE;}

NodeBitmapEffect::CC_DECLARE_DYNCREATE (  NodeBitmapEffect   )  [private]

BOOL NodeBitmapEffect::CompareState (  NodeEffect *  pPPNode  )  [virtual]

Notes: Would be more efficient to pass in level xml instead of getting it inside this function Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 12/11/2004 Returns: TRUE if this state matches the state (and type) of the supplied node Reimplemented from NodeEffect. Reimplemented in NodeFeatherEffect. Definition at line 1437 of file nodeliveeffect.cpp. { if (!pPPNode->IsBitmapEffect()) return FALSE; PORTNOTETRACE("other","NodeBitmapEffect::CompareState - do nothing, XML and BSTR"); #ifndef EXCLUDE_FROM_XARALX BSTR temp; HRESULT hr; _bstr_t bstrThisEditDoc; IXMLDOMDocumentPtr pThisEditDoc = GetEditList(); hr = pThisEditDoc->get_xml(&temp); bstrThisEditDoc = temp; _bstr_t bstrTestEditDoc; IXMLDOMDocumentPtr pTestEditDoc = ((NodeBitmapEffect*)pPPNode)->GetEditList(); hr = pTestEditDoc->get_xml(&temp); bstrTestEditDoc = temp; return (bstrTestEditDoc == bstrThisEditDoc); */ #else return false; #endif }

BOOL NodeBitmapEffect::DoBecomeA (  BecomeA *  pBecomeA  )  [virtual]

Converts me to a path Notes: Note that when this routine creates paths it does NOT call DoBecomeA on its children because the paths and the bitmap fills represetn everything the child objects have rendered. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 08/02/2005 Parameters: BecomeA  struct [INPUTS] See also: Reimplemented from NodeCompound. Definition at line 1480 of file nodeliveeffect.cpp. { // Check for a NULL entry param ERROR2IF(pBecomeA == NULL, FALSE, "pBecomeA is NULL"); if (!pBecomeA->BAPath()) return FALSE; // This lump checks that the Reason is one that we understand // It also makes sure that we don't have a NULL UndoOp ptr BOOL ValidReason = (pBecomeA->GetReason() == BECOMEA_REPLACE || pBecomeA->GetReason() == BECOMEA_PASSBACK); ERROR2IF_PF(!ValidReason,FALSE,("Unkown BecomeA reason %d",pBecomeA->GetReason())); BOOL bOK = FALSE; NodePath* pNewNodePath = NULL; NodeAttribute* pAttr = NULL; NodeHidden* pHiddenNode = NULL; // AttrLineWidth* pLineWidth = NULL; UndoableOperation* pOp = pBecomeA->GetUndoOp(); // Don't make a dumb square bitmap if the Op is a blend op because in that case // it's more useful to have the original shape with the effect // Or if this node is in the top surface of those being considered // and the op tells us that the results of dobecomea will be left in place (i.e. under // and effect stack) if (!IsLockedEffect()) { if (pBecomeA->IsBlendBecomeA() || pBecomeA->DoSilhouette() || pBecomeA->OnlyNeedPaths() || pBecomeA->ResultsStayInPlace()) return NodeEffect::DoBecomeA(pBecomeA); } else { if (pBecomeA->OnlyNeedPaths() || (pBecomeA->IsBlendBecomeA() && pBecomeA->GetReason() == BECOMEA_PASSBACK)) return NodeEffect::DoBecomeA(pBecomeA); } // We only do conversions if we are the top effect in the stack if (!IsLockedEffect() && FindParent() && FindParent()->IsEffect()) return TRUE; // Get a permanent kernel bitmap to fill the path DocCoord coords[3]; KernelBitmap* kBitmap = GetKernelBitmap(coords, TRUE); // Retain the cached data because we may be called again (blends with multiple paths) // Note: kBitmap may be NULL // Create a NodePath containing the parallelogram from the cache ALLOC_WITH_FAIL(pNewNodePath, new NodePath, pOp); if (pNewNodePath) { Path InkPath; InkPath.Initialise(); InkPath.AddMoveTo(coords[0]); InkPath.AddLineTo(coords[1]); InkPath.AddLineTo(DocCoord(coords[2].x+coords[1].x-coords[0].x, coords[2].y+coords[1].y-coords[0].y)); InkPath.AddLineTo(coords[2]); InkPath.AddLineTo(coords[0]); InkPath.CloseSubPath(); pNewNodePath->InkPath.Initialise(); pNewNodePath->InkPath.CloneFrom(InkPath); pNewNodePath->InkPath.IsFilled = TRUE; pNewNodePath->InkPath.TryToClose(); pNewNodePath->InkPath.InitialiseFlags(); switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE: { // Note! In many cases we are just being asked to become a path to get // the path data ignoring the attributes. // So if we can't make the attribute, it's better tp just go ahead // and return the path data without them. // // Make a new bitmap fill attribute referring to the newly created Kernel bitmap BitmapFillAttribute* pBitmapAttr = NULL; ALLOC_WITH_FAIL(pBitmapAttr, new BitmapFillAttribute, pOp); if (pBitmapAttr!=NULL && kBitmap) { pBitmapAttr->GetBitmapRef()->SetBitmap(kBitmap); pBitmapAttr->StartPoint = coords[0]; pBitmapAttr->EndPoint = coords[1]; pBitmapAttr->EndPoint2 = coords[2]; // Make sure the Fill attributes point to the new bitmap! pAttr = pBitmapAttr->MakeNode(); pAttr->AttachNode(pNewNodePath, FIRSTCHILD); delete pBitmapAttr; pBitmapAttr = NULL; } AttrStrokeColour* pStrokeColour = NULL; ALLOC_WITH_FAIL(pStrokeColour, new AttrStrokeColour, pOp); if (pStrokeColour!=NULL) { // Also make the line colour NONE DocColour colNone(COLOUR_NONE); pStrokeColour->SetStartColour(&colNone); pStrokeColour->AttachNode(pNewNodePath, FIRSTCHILD); } bOK = TRUE; // Copy any effect attributes over to the new node // where they can become normal attributes now that we have captured // the effect as a bitmap NodeAttribute* pEffectAttr = NodeAttribute::FindFirstAppliedAttr(this); while (bOK && pEffectAttr && pEffectAttr->IsEffectAttribute()) { CALL_WITH_FAIL(pEffectAttr->CopyNode(pNewNodePath, FIRSTCHILD), pOp, bOK); pEffectAttr = NodeAttribute::FindPrevAppliedAttr(pEffectAttr); } // Now insert the new node if (bOK) { if (pOp) { bOK = pOp->DoInsertNewNode(pNewNodePath, this, NEXT, TRUE, FALSE, this->IsSelected() || this->IsParentOfSelected(), TRUE); } else { pNewNodePath->AttachNode(this, NEXT); pNewNodePath->Select(this->IsSelected() || this->IsParentOfSelected()); } } // Handle the passback bits if (bOK) { CCAttrMap ThisMap; CCAttrMap* pThisMap = NULL; if (pNewNodePath->FindAppliedAttributes(&ThisMap)) pThisMap = ThisMap.Copy(); pBecomeA->PassBack(pNewNodePath, this, pThisMap); } // Now hide (or delete) this node if (bOK) { if (pOp) { bOK = pOp->DoHideNode(this, TRUE, &pHiddenNode, FALSE); } else { CascadeDelete(); delete this; // SCARY! } } } break; case BECOMEA_PASSBACK: { // if we're passing back, just do the first path CCAttrMap ThisMap; if (FindAppliedAttributes(&ThisMap)) { // make a copy of this attribute map CCAttrMap* pNewAttrMap = ThisMap.Copy(); AttrStrokeColour* pStrokeColour = NULL; // get the stroke colour attribute out of this map and set it to COLOUR_NONE if( pNewAttrMap->Lookup( CC_RUNTIME_CLASS(AttrStrokeColour), (void*&)(pStrokeColour) ) ) { if (pStrokeColour && pStrokeColour->GetStartColour()) { DocColour colNone(COLOUR_NONE); pStrokeColour->SetStartColour(&colNone); } } // Replace the Fill attribute in the Attr Map copy // with a bitmap fill AttrFillGeometry* pBitmapFill = new AttrBitmapColourFill(); if (pBitmapFill && kBitmap) { // Make a Bitmap Fill that is equivalent to this // node bitmap pBitmapFill->AttachBitmap(kBitmap); // Set any contone colours that we have // pBitmapFill->SetStartColour(ContoneStart); // pBitmapFill->SetEndColour(ContoneEnd); // Set the control points from the NodeBitmap Parallelogram pBitmapFill->SetStartPoint(&coords[0]); pBitmapFill->SetEndPoint(&coords[1]); pBitmapFill->SetEndPoint2(&coords[2]); void* pOldFill; if (pNewAttrMap->Lookup(CC_RUNTIME_CLASS(AttrFillGeometry), pOldFill)) { // We need to Remove and Delete the existing Fill Attr pNewAttrMap->RemoveKey(CC_RUNTIME_CLASS(AttrFillGeometry)); delete (AttrFillGeometry*)pOldFill; } // Add the Bitmap fill into the Attr Map pNewAttrMap->SetAt(CC_RUNTIME_CLASS(AttrFillGeometry),(void*)pBitmapFill); } // ok, now lets set up the attribute maps pBecomeA->PassBack(pNewNodePath, this, pNewAttrMap); bOK = TRUE; } } break; case BECOMEA_TEST: ERROR3("Unhandled BECOMEA type\n"); break; } } if (!bOK) { if (pNewNodePath != NULL) { // Delete all the NodePath's children (if it has any) and unlink it from the tree (if it's linked) // This is all done by CascadeDelete() pNewNodePath->CascadeDelete(); delete pNewNodePath; pNewNodePath = NULL; } } return bOK; }

BOOL NodeBitmapEffect::EnableDirectCapture (   )  [virtual]

Determine whether this effect can do a direct capture of its child node(s) or whether it needs to do a normal, rendering capture. At the moment, this depends solely on whether the DirectBitmap supplier can supply a bitmap at the same resolution as this effect requires. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 04/08/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Reimplemented in NodeFeatherEffect. Definition at line 904 of file nodeliveeffect.cpp. { NodeRenderableInk* pInkNode = GetInkNodeFromController(); if (pInkNode==NULL) return FALSE; PORTNOTE("effects", "EnableDirectCapture returns FALSE until effects work. Forces base objects to render themselves."); #if !defined(EXCLUDE_FROM_XARALX) double dChildPPI = 0; BOOL bDirectResolution = pInkNode->GetDirectBitmap(NULL, NULL, NULL, NULL, NULL, &dChildPPI); if (!bDirectResolution || dChildPPI==0) return FALSE; // Enable Direct Capture if we are "automatic" PPI or we are the same PPI as the child direct bitmap if (m_dPixelsPerInch==0 || dChildPPI==m_dPixelsPerInch) return TRUE; #endif return FALSE; }

BOOL NodeBitmapEffect::FindCachedEffect (  CBitmapCache *  pBitmapCache  )  [protected, virtual]

Find all cached items this node needs to call RenderCachedEffect succesfully. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Reimplemented in NodeFeatherEffect. Definition at line 1245 of file nodeliveeffect.cpp. { // BOOL bRendered = FALSE; CBitmapCacheKey inky(this, GetPixelWidth(), 1); // Get cached BMP for this PROCESSED node at our dpi CCachedBitmap cbmp; BOOL bFoundCached = pBitmapCache->Lookup(inky, cbmp); return bFoundCached; }

DocRect NodeBitmapEffect::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. Definition at line 1375 of file nodeliveeffect.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(); // 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; }

BOOL NodeBitmapEffect::GetChildDirectBitmap (  RenderRegion *  pRender, LPBITMAPINFO *  plpInfo = NULL, LPBYTE *  plpBits = NULL, DocRect *  pRect = NULL, Matrix *  pMat = NULL, double *  pdRes = NULL )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 26/07/2005 Parameters: -  [INPUTS] lpInfo  - reference to LPBITMAPINFO pointer to be written to for bitmap info [OUTPUTS] lpBits - reference to LPBYTE pointer to be written to for bitmap data Definition at line 606 of file nodeliveeffect.cpp. { NodeRenderableInk* pInkNode = GetInkNodeFromController(); if (pInkNode==NULL) return FALSE; // This is the point to choke off all DirectBitmap handling if required // by returning FALSE; // TEMP BODGE! DO NOT RELEASE! //return FALSE; if (!EnableDirectCapture()) return FALSE; return pInkNode->GetDirectBitmap(pRender, plpInfo, plpBits, pRect, pMat, pdRes); }

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

Return details of direct bitmap to caller (caller is usually a NodeBitmapEffect). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 28/07/2005 Parameters: pMat  - pointer to matrix awaiting update [INPUTS] plpInfo  - LPBITMAPINFO pointer describing bitmap [OUTPUTS] plpBits - LPBYTE pointer to bitmap data pRect - rect of Original bitmap data pMat - matrix describing transform from pRect to this instance on the page pdRes - resolution of this bitmap (dpi) Returns: TRUE if this node can supply direct bitmap data to the caller FALSE otherwise Reimplemented from NodeRenderableInk. Definition at line 650 of file nodeliveeffect.cpp. { DocRect rectDirect; Matrix matLocalTransform; double dResolution = 0; // We don't change our child's instance transformation or resolution // So just get them directly from the child BOOL bChildDirect = GetChildDirectBitmap(pRender, NULL, NULL, NULL, &matLocalTransform, &dResolution); if (pMat) *pMat = matLocalTransform; if (pdRes) *pdRes = dResolution; // Initial response is to simply get the cached results of our processing // (See also HasCachedDirectBitmap()) GetProcessedBitmap(bChildDirect && !matLocalTransform.IsIdentity(), plpInfo, plpBits, &rectDirect); // Rect is in DirectBitmap domain if (pRect) *pRect = rectDirect; // We should return our native res if our child didn't supply one // So that callers can check whether they have the same res and optionally make a direct connection // to our bitmap. if (!bChildDirect && pdRes) *pdRes = GetPixelsPerInch(); // If we have effect attrs applied then we must make a subtree bitmap to capture them if (plpInfo && plpBits && HasEffectAttrs()) { AttrFillGeometry* pTranspAttr = NULL; double dPixelWidth = GetPixelWidth(); // Lookup processed bitmap in cache CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache==NULL) return FALSE; CBitmapCacheKey inky2(this, dPixelWidth, 2); // Option 2 is processed/rendered bitmap (see below) CCachedBitmap cbmp2; BOOL bFound = pBitmapCache->Lookup(inky2, cbmp2); if (bFound) { if (plpInfo) *plpInfo = cbmp2.pbmpInfo; if (plpBits) *plpBits = cbmp2.pbmpBits; return TRUE; } // TODO: Implement NodeFeatherEffect::GetDirectBitmap ERROR2IF(IsFeatherEffect(), FALSE, "TODO! Give NodeFeatherEffect its own implementation of GetDirectBitmap!"); // We need to create a new bitmap here that captures the effects of the attributes // // If we don't have a RenderRegion, we can't build it, so return NULLs to indicate // that we need to be called again with a RenderRegion (allows quick test) // (See EnsureLiveEffectOriginalBitmaps) if (pRender == NULL) { if (plpInfo) *plpInfo = NULL; if (plpBits) *plpBits = NULL; return TRUE; } // We must "render" this bitmap to capture the attributes that effect its appearance // By default, we can't do arbitrarily transformed bitmaps - use a bitmap fill. // CBitmapCacheKey inky(this, dPixelWidth, 1); // Option 1 is processed bitmap not including rendering // CCachedBitmap cbmp; // BOOL bFoundCached = pBitmapCache->Lookup(inky, cbmp); // ERROR3IF(!bFoundCached, "Effect:GetDirectBitmap failed to find processed bitmap!"); // LPBITMAPINFO lpInfo = cbmp.pbmpInfo; // LPBYTE lpBits = cbmp.pbmpBits; // In the bitmap domain, we need to upright version of the bitmap, not the // transformed parallelogram and bounds stored with the cbmp, the processed bitmap // DocRect CaptureRect(0, 0, lpInfo->bmiHeader.biWidth*dPixelWidth, lpInfo->bmiHeader.biHeight*dPixelWidth); ERROR3IF(*plpInfo==NULL || *plpBits==NULL, "How come we got here with no processed bitmap?"); DocRect CaptureRect = rectDirect; CaptureFlags caFlags = CaptureFlags(cfLOCKEDTRANSPARENT | cfFULLCOVERAGE); pRender->StartCapture(this, CaptureRect, CAPTUREINFO(ctNESTABLE, caFlags), TRUE, FALSE, dResolution); pRender->SaveContext(); { // ------------------------------------------------------ // Setup coords for rendering in DirectBitmap domain DocCoord coords[3]; coords[0] = CaptureRect.lo; coords[1] = DocCoord(CaptureRect.hi.x, CaptureRect.lo.y); coords[2] = DocCoord(CaptureRect.lo.x, CaptureRect.hi.y); // NOTE! We can only deal with effect transparency at the moment! // Render the transparency geometry using inverse Direct-Screen transform // (This bitmap is being rendered in "Direct space" whereas the transparency attribute // was applied in "Screen space") NodeAttribute* pAttr; if (FindAppliedAttribute(CC_RUNTIME_CLASS(AttrTranspFillGeometry), &pAttr)) { if (pAttr && !pAttr->IsADefaultAttr() && !pAttr->HasEquivalentDefaultValue(TRUE) && pAttr->IsEffectAttribute()) { pTranspAttr = (AttrFillGeometry*) ((AttrFillGeometry*)pAttr)->SimpleCopy(); DocCoord tcoords[4]; DocCoord* pCoord = NULL; pCoord = pTranspAttr->GetStartPoint(); tcoords[0] = pCoord ? *pCoord : DocCoord(0,0); pCoord = pTranspAttr->GetEndPoint(); tcoords[1] = pCoord ? *pCoord : DocCoord(0,0); pCoord = pTranspAttr->GetEndPoint2(); tcoords[2] = pCoord ? *pCoord : DocCoord(0,0); pCoord = pTranspAttr->GetEndPoint3(); tcoords[3] = pCoord ? *pCoord : DocCoord(0,0); Matrix matInverse = matLocalTransform.Inverse(); matInverse.transform(tcoords, 4); pTranspAttr->SetStartPoint(&tcoords[0]); pTranspAttr->SetEndPoint(&tcoords[1]); pTranspAttr->SetEndPoint2(&tcoords[2]); pTranspAttr->SetEndPoint3(&tcoords[3]); pTranspAttr->Render(pRender); } } pRender->RenderBits(*plpInfo, *plpBits, coords, 3, FALSE, NULL); } // ------------------------------------------------------ pRender->RestoreContext(); if (pTranspAttr) { delete pTranspAttr; pTranspAttr = NULL; } LPBITMAPINFO lpInfo = NULL; LPBYTE lpBits = NULL; pRender->StopCapture(this, FALSE, FALSE, &lpInfo, &lpBits, &CaptureRect); // We should now have a bitmap containing an upright version of the NodeBitmap // with transparency and contoning applied as per the attributes in the tree if (lpInfo && lpBits) { *plpInfo = lpInfo; *plpBits = lpBits; // Cache the PROCESSED/RENDERED bitmap as Option 2 cbmp2.pbmpBits = lpBits; cbmp2.pbmpInfo = lpInfo; cbmp2.SetCachedRect(CaptureRect); cbmp2.nPriority = CACHEPRIORITY_TEMPBITMAP_HIGH; if (cbmp2.IsValid()) pBitmapCache->StoreBitmap(inky2, cbmp2); } } return TRUE; }

virtual String_64& NodeBitmapEffect::GetDisplayName (   )  [inline, virtual]

Definition at line 240 of file nodeliveeffect.h. {return m_strDisplayName;}

IXMLDOMDocumentPtr NodeBitmapEffect::GetEditList (   )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 10/09/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Definition at line 982 of file nodeliveeffect.cpp. { return m_pEditsDoc; }

virtual NodeRenderableInk* NodeBitmapEffect::GetInkNodeFromController (   )  const [inline, virtual]

If we had a Controller node inherited class from NodeGroup then this function really belongs there. But we don't, so this function only returns anything if your node also returns TRUE to IsAController(). If so it will return the node that is shadowed, bevelled or contoured. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The ink node that is used by bevels, shadows and contours See also: Reimplemented from NodeCompound. Reimplemented in NodeLockedEffect. Definition at line 198 of file nodeliveeffect.h. {return FindFirstChildInk();}

virtual KernelBitmap* NodeBitmapEffect::GetKernelBitmap (  DocCoord *  pCoords, BOOL  bRetainCached = FALSE )  [inline, virtual]

Reimplemented in NodeLiveEffect, and NodeLockedEffect. Definition at line 242 of file nodeliveeffect.h. {return NULL;}

BOOL NodeBitmapEffect::GetOriginalBitmap (  LPBITMAPINFO *  plpInfo, LPBYTE *  plpBits, DocRect *  pRect )  [virtual]

To get the required/stored pixel width of this node -. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 10/09/2004 Parameters: -  [INPUTS] lpInfo  - reference to LPBITMAPINFO pointer to be written to for bitmap info [OUTPUTS] lpBits - reference to LPBYTE pointer to be written to for bitmap data Definition at line 495 of file nodeliveeffect.cpp. { // --------------------------------------------------------- // New! // Discover whether our child can supply a DirectBitmap for // us to use as the original for processing... // LPBITMAPINFO lpLocalInfo = NULL; LPBYTE lpLocalBits = NULL; DocRect rectLocal; BOOL bFound = GetChildDirectBitmap(NULL, &lpLocalInfo, &lpLocalBits, &rectLocal); if (bFound) { if (plpInfo) *plpInfo = lpLocalInfo; if (plpBits) *plpBits = lpLocalBits; if (pRect) *pRect = rectLocal; return (lpLocalInfo!=NULL && lpLocalBits!=NULL); // Only return TRUE if we got good bitmap data } // --------------------------------------------------------- CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache) { // Look for a cached bitmap at the appropriate pixel size... CBitmapCacheKey inky(this, GetPixelWidth()); // Get cached BMP for this node at our dpi CCachedBitmap cbmp; BOOL bFound = pBitmapCache->Lookup(inky, cbmp); if (bFound) { if (plpInfo) *plpInfo = cbmp.pbmpInfo; if (plpBits) *plpBits = cbmp.pbmpBits; if (pRect) *pRect = cbmp.GetCachedRect(); return TRUE; } } if (plpInfo) *plpInfo = NULL; if (plpBits) *plpBits = NULL; return FALSE; }

double NodeBitmapEffect::GetPixelsPerInch (   )  [virtual]

To get the required/stored pixel res of this node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/09/2004 Parameters: -  [INPUTS] Pixel  resolution for this live effect bitmap in pixels per inch (double) [OUTPUTS] Returns: Description of the group node Errors: - See also: - Definition at line 385 of file nodeliveeffect.cpp. { double dPPI = 0.0; if (m_dPixelsPerInch==0) { // 0 means automatic // Automatic means get resolution in context // Context means either: // * Respond to a direct bitmap below us // * or respond to a fixed resolution above us in the tree // * or get resolution from current view BOOL bDirectResolution = GetChildDirectBitmap(NULL, NULL, NULL, NULL, NULL, &dPPI); if (bDirectResolution && dPPI!=0) return dPPI; Node* pParent = this->FindParent(); // while (pParent && (pParent->IsBitmapEffect() || pParent->IsNodeHidden())) while (pParent && !pParent->IsLayer()) { if (pParent->IsBitmapEffect()) { dPPI = ((NodeBitmapEffect*)pParent)->GetPixelsPerInchValue(); if (dPPI!=0) break; } pParent = pParent->FindParent(); } if (dPPI==0) { // See also OpEffectLock::DoEffectNodeOp View* pView = View::GetCurrent(); if (pView) dPPI = 72000.0 / pView->GetPixelWidth().MakeDouble(); } } if (dPPI==0) dPPI = m_dPixelsPerInch; 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; } return dPPI; };

virtual double NodeBitmapEffect::GetPixelsPerInchValue (   )  const [inline, virtual]

Definition at line 244 of file nodeliveeffect.h. {return m_dPixelsPerInch;}

virtual double NodeBitmapEffect::GetPixelWidth (   )  [inline, protected, virtual]

Definition at line 260 of file nodeliveeffect.h. {return 72000.0 / GetPixelsPerInch();}

virtual BOOL NodeBitmapEffect::GetProcessedBitmap (  BOOL  bDirect, LPBITMAPINFO *  plpInfo, LPBYTE *  plpBits, DocRect *  pRect )  [inline, virtual]

Reimplemented in NodeLiveEffect, and NodeLockedEffect. Definition at line 213 of file nodeliveeffect.h. {return FALSE;}

virtual BOOL NodeBitmapEffect::GetQuickRender (   )  [inline, protected, virtual]

Reimplemented in NodeFeatherEffect. Definition at line 264 of file nodeliveeffect.h. {return Operation::GetQuickRender(this);}

BOOL NodeBitmapEffect::HasCachedDirectBitmap (   )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Reimplemented from NodeRenderableBounded. Definition at line 878 of file nodeliveeffect.cpp. { Matrix matTrans; BOOL bDirect = GetChildDirectBitmap(NULL, NULL, NULL, NULL, &matTrans, NULL); return (bDirect && !matTrans.IsIdentity()); // ??? Non-ident used to indicate that a direct bitmap was found under the effect... }

virtual BOOL NodeBitmapEffect::HasChanged (   )  const [inline, virtual]

Definition at line 228 of file nodeliveeffect.h. {return m_bHasChangedRecently;}

BOOL NodeBitmapEffect::Init (  void   )  [static]

Initialise the NodeBitmapEffect class. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 08/09/2004 Parameters: -  [INPUTS] Reimplemented from NodeRenderableInk. Definition at line 249 of file nodeliveeffect.cpp. { if (Camelot.DeclareSection( _T("Effects"), 10)) { Camelot.DeclarePref(NULL, _T("DefaultLivePixelsPerInch"), (INT32*)&DefaultLivePixelsPerInch, 0, 72000); Camelot.DeclarePref(NULL, _T("DefaultLockedPixelsPerInch"), (INT32*)&DefaultLockedPixelsPerInch, 1, 72000); Camelot.DeclarePref(NULL, _T("DefaultLocked"), (INT32*)&DefaultLocked, FALSE, TRUE); Camelot.DeclarePref(NULL, _T("GroupPixelsPerInch"), (INT32*)&GroupPixelsPerInch, 0, 72000); Camelot.DeclarePref(NULL, _T("ShadowPixelsPerInch"), (INT32*)&ShadowPixelsPerInch, 0, 72000); } return TRUE; }

virtual BOOL NodeBitmapEffect::IsBitmapEffect (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 196 of file nodeliveeffect.h. {return TRUE;}

virtual BOOL NodeBitmapEffect::IsLockedEffect (   )  [inline, virtual]

Reimplemented from NodeEffect. Reimplemented in NodeLiveEffect, and NodeLockedEffect. Definition at line 227 of file nodeliveeffect.h. {return FALSE;}

BOOL NodeBitmapEffect::ProcessBitmap (  RenderRegion *  pRender, CBitmapCache *  pBitmapCache, LPBITMAPINFO  pBMPInfo, LPBYTE  pBMPBits, DocRect  BMPRect, LPBITMAPINFO &  pOutputInfo, LPBYTE &  pOutputBits, double *  pXOffset, double *  pYOffset )  [virtual]

Processes the bitmap produced by the children of this node. Can be overridden by derived classes to perofrm special processing. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/2004 Returns: Reimplemented in NodeFeatherEffect. Definition at line 1324 of file nodeliveeffect.cpp. { BOOL bOK = TRUE; PORTNOTETRACE("other","NodeBitmapEffect::ProcessBitmap - do nothing, CXMLUtils, XPEEditOp"); #ifndef EXCLUDE_FROM_XARALX // Apply the effect to the newly captured bitmap BOOL bValidEditList = TRUE; if (m_pEditsDoc==NULL) { HRESULT hr = E_FAIL; m_pEditsDoc = CXMLUtils::NewDocument(); bValidEditList = FALSE; ERROR3IF(m_pEditsDoc==NULL, "Can't make default edit document"); } if (bValidEditList) { //TRACEUSER( "Phil", _T("NodeLiveEffect calling ProcessBitmap %x %s\n"), this, this->GetRuntimeClass()->m_lpszClassName); INT32 iXOffset = (INT32)*pXOffset; INT32 iYOffset = (INT32)*pYOffset; bOK = XPEEditOp::ProcessBitmap(pBMPInfo, pBMPBits, pOutputInfo, pOutputBits, m_pEditsDoc, &iXOffset, &iYOffset); *pXOffset = iXOffset; *pYOffset = iYOffset; //TRACEUSER( "Phil", _T("NodeLiveEffect back from ProcessBitmap\n")); } #endif return bOK; }

void NodeBitmapEffect::Render (  RenderRegion *  pRender  )  [virtual]

Will render the liveeffect iff we have it cached - for hit detection reasons. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/2004 Parameters: Pointer  to a render region [INPUTS] Reimplemented from Node. Reimplemented in NodeLockedEffect. Definition at line 1221 of file nodeliveeffect.cpp. { CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache!=NULL && pRender->IsHitDetect() && pRender->RRQuality.GetFillQuality() > Quality::Solid) { RenderCachedEffect(pBitmapCache, pRender, TRUE); } }

void NodeBitmapEffect::RenderAfterSubtree (  RenderRegion *  pRender  )  [virtual]

Capture the group as a cached bitmap. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/09/2004 Parameters: pRender  - The region to render into [INPUTS] Reimplemented from NodeEffect. Definition at line 1051 of file nodeliveeffect.cpp. { Matrix matTrans; double dResolution = 0; CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache==NULL) { return; } // -------------------------------------------------------------------------------------- // Note that we use the Capture system to store the state of rendering // in this node in the scope of the rendering system rather than storing // it temporarilly in the document tree (e.g. in this node). This means // the tree is stateless and can be rendered by several different "threads" // with different states at the same time. // In this context a "thread" is a background, rendering RenderRegion but // it could be a real thread one day. // Capture* pCapture = pRender->GetTopCapture(); if (pCapture==NULL) // If nothing was captured return; // Then do nothing // Only stop the capture if we started it // (means we only capture whole subtrees at the mo.) if (pCapture->GetOwner()==this) { // 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; BOOL bCaptureIsDirect = pCapture->IsDirect(); LPBITMAPINFO lpInfo = NULL; LPBYTE lpBits = NULL; DocRect CaptureRect = GetChildBoundingRect(); // Set maximum size we allow CaptureRect.Inflate(CAPTURE_BORDER*(INT32)GetPixelWidth()); pRender->StopCapture(this, FALSE, FALSE, &lpInfo, &lpBits, &CaptureRect, &matTrans, &dResolution); // pCapture is deleted now... // Is this capture direct? if (bCaptureIsDirect) { ERROR3IF(dResolution==0, "Direct Capture returned 0 pixels per inch\n"); // If we are supplied with a direct bitmap, try to process it and cache // the results. // // Note that CaptureRect is in DirectBitmap space, not drawing space // and that matTransform holds the matrix to map from DirectBitmap space // to drawing space... // if (lpInfo && lpBits && CaptureRect.IsValid()) { // Process the bitmap using appropriate virtual functions from derived class LPBITMAPINFO lpProcessedInfo = NULL; LPBYTE lpProcessedBits = NULL; double xOffset = 0; double yOffset = 0; ProcessBitmap(pRender, pBitmapCache, lpInfo, lpBits, CaptureRect, lpProcessedInfo, lpProcessedBits, &xOffset, &yOffset); if (lpProcessedInfo && lpProcessedBits) { // Cache the PROCESSED bitmap, as Option 1 // // Note that SetProcessedBitmap stores the bitmap with coords transformed into Drawing space // So that rendering into drawing space will be quick and simple // The rectangle in DirectBitmap space is stored in a member variable m_rectDirectBitmap SetProcessedBitmap(lpProcessedInfo, lpProcessedBits, CaptureRect, lpProcessedInfo->bmiHeader.biWidth, lpProcessedInfo->bmiHeader.biHeight, xOffset, yOffset, 72000.0/dResolution, &matTrans); // Note RenderCachedEffect only does anything if the current capture // doesn't consume this bitmap directly RenderCachedEffect(pBitmapCache, pRender); } } } else { // If the capture gave us back a bitmap, try to cache it if (lpInfo && lpBits && CaptureRect.IsValid()) { // Cache the ORIGINAL bitmap as Option 0 // See also, SetOriginalBitmap double PixelWidth = GetPixelWidth(); CBitmapCacheKey inky(this, PixelWidth, 0); CCachedBitmap cbmp; cbmp.pbmpBits = lpBits; cbmp.pbmpInfo = lpInfo; cbmp.SetCachedRect(CaptureRect); cbmp.nPriority = CACHEPRIORITY_TEMPBITMAP_HIGH; if (cbmp.IsValid()) { pBitmapCache->StoreBitmap(inky, cbmp); bCached = TRUE; } // Process the bitmap using appropriate virtual processor for derived class LPBITMAPINFO lpProcessedInfo = NULL; LPBYTE lpProcessedBits = NULL; double xOffset = 0; double yOffset = 0; //BOOL bOK = ProcessBitmap(pRender, pBitmapCache, lpInfo, lpBits, CaptureRect, lpProcessedInfo, lpProcessedBits, &xOffset, &yOffset); // ERROR3IF(!bOK, "NodeBitmapEffect::RenderAfterSubtree ProcessBitmap failed\n"); if (lpProcessedInfo && lpProcessedBits) { // Cache the PROCESSED bitmap as well, as Option 1 CaptureRect = SetProcessedBitmap(lpProcessedInfo, lpProcessedBits, CaptureRect, lpProcessedInfo->bmiHeader.biWidth, lpProcessedInfo->bmiHeader.biHeight, xOffset, yOffset); // Render it RenderCachedEffect(pBitmapCache, pRender); // If we are rendering during printing, there may be multiple passes // through the tree to do different aspects of printing. The // PrintingMaskedRenderRegion produces a monochrome mask so we // definitely don't want to cache that! if (pRender->IsKindOf(CC_RUNTIME_CLASS(PrintingMaskedRenderRegion))) { double PixelWidth = GetPixelWidth(); CBitmapCacheKey inky(this, PixelWidth, 0); pBitmapCache->RemoveBitmap(inky); CBitmapCacheKey inky2(this, PixelWidth, 1); pBitmapCache->RemoveBitmap(inky2); bCached = FALSE; } // If we failed to cache the captured bitmap then release it if (lpProcessedInfo!=NULL && lpProcessedBits!=NULL && !bCached) { FreeDIB(lpProcessedInfo, lpProcessedBits, NULL, FALSE); } } else { // If we failed to process the captured bitmap for some reason // Then just plot it back to the screen so the user sees something // ERROR3("NodeBitmapEffect::RenderAfterSubtree ProcessBitmap failed\n"); pRender->RenderBits(lpInfo, lpBits, CaptureRect); } } // If we failed to cache the captured bitmap then release it if (lpInfo!=NULL && lpBits!=NULL && !bCached) { FreeDIB(lpInfo, lpBits, NULL, FALSE); } } } }

BOOL NodeBitmapEffect::RenderCachedEffect (  CBitmapCache *  pBitmapCache, RenderRegion *  pRender, BOOL  bIgnoreCapture = FALSE )  [protected, virtual]

Render the cached version of this node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the cached effect was rendered or passed on to a consumer capture FALSE if the cached effect was not present or could not be consumed or rendered Reimplemented in NodeLockedEffect, and NodeFeatherEffect. Definition at line 1273 of file nodeliveeffect.cpp. { BOOL bRendered = FALSE; CBitmapCacheKey inky(this, GetPixelWidth(), 1); // Get cached BMP for this PROCESSED node at our dpi CCachedBitmap cbmp; BOOL bFoundCached = pBitmapCache->Lookup(inky, cbmp); if (bFoundCached) { // No need to render if we are going to supply to a capture Capture* pCapture = pRender->GetTopCapture(); if (!bIgnoreCapture && pCapture && pCapture->ConsumeDirectBitmap(this)) { // Tell the caller that the effect has been "rendered" bRendered = TRUE; } else { // Allow RenderBits to render any effect attributes that are attached to us // before rendering the bitmap so that they affect its appearance // by passing it a pointer to this node to search for effect attributes bRendered = pRender->RenderBits(cbmp.pbmpInfo, cbmp.pbmpBits, &cbmp.coord0, 3, TRUE, this); } } return bRendered; }

BOOL NodeBitmapEffect::RenderDirectBitmapState (  RenderRegion *  pRender  )  [virtual]

Render the current state into the renderregion if we haven't yet done so. Only used in background rendering timeslice screen update. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/07/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Reimplemented from NodeRenderableInk. Definition at line 851 of file nodeliveeffect.cpp. { CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache!=NULL && pRender->RRQuality.GetFillQuality() > Quality::Solid) { RenderCachedEffect(pBitmapCache, pRender, TRUE); } return TRUE; }

virtual BOOL NodeBitmapEffect::SetChanged (  BOOL  bNewFlag = TRUE  )  [inline, virtual]

Definition at line 229 of file nodeliveeffect.h. {m_bHasChangedRecently = bNewFlag; return TRUE;}

BOOL NodeBitmapEffect::SetDefaultEditList (   )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 27/07/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Definition at line 1022 of file nodeliveeffect.cpp. { PORTNOTETRACE("other","NodeBitmapEffect::SetDefaultEditList - do nothing"); #ifndef EXCLUDE_FROM_XARALX // Ensure that we have an edit list if (m_pEditsDoc==NULL) { m_pEditsDoc = CXMLUtils::NewDocument(); ERROR3IF(m_pEditsDoc==NULL, "Can't make default edit document"); return (m_pEditsDoc!=NULL); } #endif return TRUE; }

virtual void NodeBitmapEffect::SetDisplayName (  String_64 &  strDisplayName  )  [inline, virtual]

Definition at line 241 of file nodeliveeffect.h. {m_strDisplayName = strDisplayName;}

void NodeBitmapEffect::SetEditList (  IXMLDOMDocumentPtr  pNewEditsDoc  )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 14/09/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Definition at line 1002 of file nodeliveeffect.cpp. { m_pEditsDoc = pNewEditsDoc; }

void NodeBitmapEffect::SetOriginalBitmap (  LPBITMAPINFO  lpInfo, LPBYTE  lpBits, DocRect  rect )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 13/09/2004 Parameters: -  [INPUTS] lpInfo  - reference to LPBITMAPINFO pointer for bitmap info [OUTPUTS] lpBits - reference to LPBYTE pointer for bitmap data Definition at line 553 of file nodeliveeffect.cpp. { CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache==NULL) return; if (rect.IsEmpty()) { rect = GetChildBoundingRect(); rect.Inflate(CAPTURE_BORDER*(INT32)GetPixelWidth()); } CBitmapCacheKey inky(this, GetPixelWidth()); // Get cached BMP for this node at our dpi // Deallocate any cached DIB here CCachedBitmap cbmp; BOOL bFound = pBitmapCache->Lookup(inky, cbmp); if (bFound) { pBitmapCache->RemoveBitmap(inky); cbmp.Release(); } if (lpInfo && lpBits) { cbmp.pbmpInfo = lpInfo; cbmp.pbmpBits = lpBits; cbmp.SetCachedRect(rect); cbmp.nPriority = CACHEPRIORITY_TEMPBITMAP_HIGH; pBitmapCache->StoreBitmap(inky, cbmp); } }

void NodeBitmapEffect::SetPixelsPerInch (  double  dPixelsPerInch  )  [virtual]

To get the required/stored pixel res of this node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/09/2004 Parameters: -  [INPUTS] Pixel  resolution for this live effect bitmap in pixels per inch (double) [OUTPUTS] Retuns: Description of the group node Returns: Errors: - See also: - Definition at line 454 of file nodeliveeffect.cpp. { m_dPixelsPerInch = dPixelsPerInch; };

virtual DocRect NodeBitmapEffect::SetProcessedBitmap (  LPBITMAPINFO  lpInfo, LPBYTE  lpBits, DocRect  rect, INT32  width, INT32  height, double  xOffset, double  yOffset, double  dPixelWidth = 0, Matrix *  pmatTransform = NULL )  [inline, virtual]

Reimplemented in NodeLiveEffect, and NodeLockedEffect. Definition at line 214 of file nodeliveeffect.h. {return DocRect(0,0,0,0);}

virtual BOOL NodeBitmapEffect::WillWriteBounds (  BaseCamelotFilter *  pFilter  )  [inline, 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 206 of file nodeliveeffect.h. { return(TRUE); }

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

Begin to write out your child records, in the native format. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/09/2005 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise The base class will write out a TAG_DOWN record, but only if it has a child ptr See also: WritePostChildrenWeb(), WritePreChildrenWeb() Reimplemented from NodeRenderableInk. Definition at line 1794 of file nodeliveeffect.cpp. { BOOL ok = TRUE; // Add a description of the TAG_COMPOUNDRENDER record, for older importers that don't understand this record pFilter->AddTagDescription(TAG_COMPOUNDRENDER, _R(IDS_TAG_COMPOUNDRENDER)); // Write out the record DocRect Rect = GetChildBoundingRect(); 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); return ok; }

---

Friends And Related Function Documentation

friend class LiveEffectRecordHandler [friend]

Reimplemented in NodeLiveEffect, NodeLockedEffect, and NodeFeatherEffect. Definition at line 168 of file nodeliveeffect.h.

---

Member Data Documentation

UINT32 NodeBitmapEffect::DefaultLivePixelsPerInch [static]

Definition at line 176 of file nodeliveeffect.h.

BOOL NodeBitmapEffect::DefaultLocked = FALSE [static]

Preference: DefaultLocked Section: Effects Range: FALSE-TRUE Definition at line 180 of file nodeliveeffect.h.

UINT32 NodeBitmapEffect::DefaultLockedPixelsPerInch [static]

Definition at line 177 of file nodeliveeffect.h.

UINT32 NodeBitmapEffect::GroupPixelsPerInch = 0 [static]

Preference: GroupPixelsPerInch Section: Effects Range: 0-72000 Definition at line 178 of file nodeliveeffect.h.

BOOL NodeBitmapEffect::m_bHasChangedRecently [protected]

Definition at line 271 of file nodeliveeffect.h.

double NodeBitmapEffect::m_dPixelsPerInch [protected]

Definition at line 270 of file nodeliveeffect.h.

IXMLDOMDocumentPtr NodeBitmapEffect::m_pEditsDoc [protected]

Definition at line 268 of file nodeliveeffect.h.

DocRect NodeBitmapEffect::m_rectDirectBitmap [protected]

Definition at line 273 of file nodeliveeffect.h.

String_64 NodeBitmapEffect::m_strDisplayName [protected]

Definition at line 272 of file nodeliveeffect.h.

StringVar NodeBitmapEffect::m_vstrEdits [protected]

Definition at line 269 of file nodeliveeffect.h.

UINT32 NodeBitmapEffect::ShadowPixelsPerInch = 0 [static]

Preference: ShadowPixelsPerInch Section: Effects Range: 0-72000 Definition at line 179 of file nodeliveeffect.h.

---

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

• Kernel/nodeliveeffect.h (r1785/r1688)
• Kernel/nodeliveeffect.cpp (r1785/r1688)

---