XPFRenderCallback Class Reference

This is the custom render callback class for the capabilities conversion. More...

#include <xpfrgn.h>

Inheritance diagram for XPFRenderCallback:

List of all members.

Public Member Functions
	XPFRenderCallback (PluginNativeFilter *pFilter, XPFRenderRegion *pXPFRegion, CapabilityTree *pCapTree, INT32 ConvertPass)
	Constructs an XPFRenderCallback object to control the rendering loop for each phase of the conversion mechanism.
	~XPFRenderCallback ()
	Destructor.
virtual BOOL	BeforeNode (RenderRegion *pRegion, Node *pNode)
virtual BOOL	BeforeSubtree (RenderRegion *pRegion, Node *pNode, Node **ppNextNode, BOOL bClip, SubtreeRenderState *pState)
Spread *	GetNewSpread ()
void	SetAttachContext (Node *pContext, AttachNodeDirection Direction)
BOOL	ConvertNodes ()
	Performs the required conversion on the stored list of nodes.
Protected Member Functions
BOOL	ConvertNodesForPass2 ()
	Performs the "stroked" conversion on the convert list.
BOOL	ConvertNodesForPass3 ()
	Performs the bitmapfill, bitmaptrans and bitmapfilltrans conversions on the convert list.
BOOL	ConvertNodesForPass4 ()
	Performs the bitmap conversion on the convert list.
BOOL	ConvertNodesForPass5 ()
	Performs the bitmapspan conversion on the convert list.
void	RemoveChildAttrs (Node *pNode, CCRuntimeClass *pClass)
	Removes all child attributes of a particular attribute type.
NodeAttribute *	FindChildAttr (Node *pNode, CCRuntimeClass *pClass)
	Finds the last child attr of the specified attribute type.
Node *	RenderNodesToBitmap (Node *pFirstNode, Node *pLastNode, BOOL bNonAlphaTrans)
	Renders a range of nodes into a bitmap. If it uses non-alpha trans then a 24bpp bitmap is generated including all the objects before the span. If it doesn't use non-alpha trans then a 32bpp RGBA bitmap of just the node span is generated.
KernelBitmap *	RenderFillToBitmap (Node *pNode, DocRect &BoundsRect)
	Renders the fill applied to the object into a KernelBitmap so that the fill can be replaced with a simple bitmap fill.
KernelBitmap *	RenderTransToBitmap (Node *pNode, DocRect &BoundsRect, UINT32 *pTransType)
	Renders the transparency applied to the object as a greyscale bitmap so that the transparency can be replaced by a simple bitmap transparency.
KernelBitmap *	RenderFillAndTransToBitmap (Node *pNode, DocRect &BoundsRect)
	Renders the applied fill and transparency to a bitmap so both the fill and trans can be replaced by a simple bitmap fill. If the transparency is non-alpha compatible then we also have to render all the previous objects into it.
TextStory *	ReformatTextStory (TextStory *pStory)
	Creates a copy of a TextStory where the copy is manually kerned and only uses left justification.
Node *	ReformatTextLine (TextLine *pLineNode, FormatRegion *pFormatRegion)
	Creates a left justified and manually kerned copy of a text line by inserting manual kern codes where necessary.
BOOL	CopyAttributesFromNode (Node *pDestNode, Node *pSrcNode)
	Copies all attributes except justification and tracking from one node to another.
BOOL	DoesNodeUseNonAlphaTrans (Node *pRootNode)
	Determines if a node has any attributes that use non-alpha transparency.
BOOL	FindCommonTransTypeToApply (Node *pFirstNode, Node *pLastNode, UINT32 *pCommonType)
Private Attributes
INT32	m_ConvertPass
PluginNativeFilter *	m_pFilter
XPFRenderRegion *	m_pXPFRegion
CapabilityTree *	m_pCapTree
Spread *	m_pNewSpread
Node *	m_pContextNode
AttachNodeDirection	m_Direction
Node *	m_pSpanParent
List	m_ConvertList
List	m_ParentList

---

Detailed Description

This is the custom render callback class for the capabilities conversion.

Author:

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

Date:

26/01/05

Definition at line 250 of file xpfrgn.h.

---

Constructor & Destructor Documentation

XPFRenderCallback::XPFRenderCallback (  PluginNativeFilter *  pFilter, XPFRenderRegion *  pXPFRegion, CapabilityTree *  pCapTree, INT32  ConvertPass )

Constructs an XPFRenderCallback object to control the rendering loop for each phase of the conversion mechanism. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pFilter  - pointer to a PluginNativeFilter [INPUTS] pXPFRegion - pointer to a XPFRenderRegion pCapTree - pointer to a CapabilityTree ConvertPass - conversion pass Definition at line 625 of file xpfrgn.cpp. { m_pFilter = pFilter; m_pXPFRegion = pXPFRegion; m_pCapTree = pCapTree; m_ConvertPass = ConvertPass; m_pNewSpread = NULL; m_pContextNode = NULL; m_Direction = FIRSTCHILD; m_pSpanParent = NULL; }

XPFRenderCallback::~XPFRenderCallback (   )

Destructor. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Definition at line 650 of file xpfrgn.cpp. { m_ConvertList.DeleteAll(); m_ParentList.DeleteAll(); }

---

Member Function Documentation

BOOL XPFRenderCallback::BeforeNode (  RenderRegion *  pRegion, Node *  pNode )  [virtual]

Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pRegion  - pointer to a RenderRegion [INPUTS] pNode - pointer to a Node Returns: TRUE if ok, FALSE if bother Reimplemented from RenderCallback. Definition at line 672 of file xpfrgn.cpp. { // TRACEUSER( "Gerry", _T("XPFRC# BeforeNode 0x%08x - %s\n"), pNode, pNode->GetRuntimeClass()->m_lpszClassName); if (pNode->IsNodeHidden() || pNode->IsAnInsertionNode()) return(FALSE); // Move code for each pass into separate functions switch (m_ConvertPass) { case 1: { // All of the children of pNode have been passed to BeforeSubtree and BeforeNode if (m_Direction == FIRSTCHILD) { // TRACEUSER( "Gerry", _T("XPFRC# Was child, attach next node as sibling of %s\n"), m_pContextNode->GetRuntimeClass()->m_lpszClassName); // If the next node will be attached as first child then set it to attach as // as next sibling instead m_Direction = NEXT; } else if (m_Direction == NEXT) { // If already set to next sibling then set the context node to its parent m_pContextNode = m_pContextNode->FindParent(); // TRACEUSER( "Gerry", _T("XPFRC# Was next, attach next node as sibling of %s\n"), m_pContextNode->GetRuntimeClass()->m_lpszClassName); } } break; case 2: { // If the node is a renderable object but not a compound then get the conversion type for pass 2 if (pNode->IsAnObject() && !pNode->IsCompound()) { // Get the convert type of this node XPFConvertType ConvertType = m_pCapTree->GetConvertTypePass2(pNode, m_pXPFRegion); // If it specifies stroked then set a pending stroked conversion for this node if (ConvertType == XPFCONVTYPE_STROKED) { // TRACEUSER( "Gerry", _T("XPFRC# Setting pending stroked conversion for %s\n"), pNode->GetRuntimeClass()->m_lpszClassName); NodeListItem* pItem = new NodeListItem(pNode); m_ConvertList.AddTail(pItem); } } } break; case 3: { // If the node is a renderable object then get the conversion type for pass 2 // This used to also check for non-compund nodes but that breaks group transparency // It may be necessary to modify GetConvertTypePass3 to correctly distinguish // compound objects that can and can't support group transparency if (pNode->IsAnObject()) { // Get the convert type of this node BOOL bFill = FALSE; BOOL bTrans = FALSE; BOOL bFillTrans = FALSE; m_pCapTree->GetConvertTypePass3(pNode, m_pXPFRegion, &bFill, &bTrans, &bFillTrans); // If it specifies bitmapfill then set a pending bitmapfill conversion for this node if (bFill || bTrans || bFillTrans) { // TRACEUSER( "Gerry", _T("XPFRC# Setting pending bitmapfill conversion for %s\n"), pNode->GetRuntimeClass()->m_lpszClassName); NodeThreeBoolListItem* pItem = new NodeThreeBoolListItem(pNode, bFill, bTrans, bFillTrans); m_ConvertList.AddTail(pItem); } } } break; case 4: { // If the node is a renderable object but not a compound then get the conversion type for pass 4 if (pNode->IsAnObject()) { // Get the convert type of this node XPFConvertType ConvertType = m_pCapTree->GetConvertTypePass4(pNode, m_pXPFRegion); // If it specifies bitmap then add the node to the convert list if (ConvertType == XPFCONVTYPE_BITMAP) { // TRACEUSER( "Gerry", _T("XPFRC# Setting pending bitmap conversion for %s\n"), pNode->GetRuntimeClass()->m_lpszClassName); NodeListItem* pItem = new NodeListItem(pNode); m_ConvertList.AddTail(pItem); } } } break; case 5: { // If the node is a renderable object then get the conversion type for pass 5 if (pNode->IsAnObject()) { // Get the parent Node* pParent = pNode->FindParent(); // Get the convert type of this node and // update the span list appropriately XPFConvertType ConvertType = m_pCapTree->GetConvertTypePass5(pNode, m_pXPFRegion); // If this node has children if (pNode->FindFirstChild()) { // If this node should be converted if (ConvertType == XPFCONVTYPE_BITMAPSPAN) { // Remove all items from ConvertList that refer to this as the parent while (TRUE) { SpanListItem* pChildSpanItem = (SpanListItem*)m_ConvertList.GetTail(); if (pChildSpanItem && pChildSpanItem->m_pFirstNode && pChildSpanItem->m_pFirstNode->FindParent() == pNode) { // TRACEUSER( "Gerry", _T("XPFRC# Removing span item for 0x%08x (%s)\n"), pChildSpanItem->m_pFirstNode, pChildSpanItem->m_pFirstNode->GetRuntimeClass()->m_lpszClassName); delete m_ConvertList.RemoveTail(); } else { break; } } } // Get the last item from the parent list NodeThreeBoolListItem* pItem = (NodeThreeBoolListItem*)m_ParentList.RemoveTail(); // TRACEUSER( "Gerry", _T("XPFRC# Removed parent list item for 0x%08x (%s)\n"), pItem->m_pNode, pItem->m_pNode->GetRuntimeClass()->m_lpszClassName); if (pItem) { // Check to make sure it is the correct one if (pItem->m_pNode == pNode) { // If all the children were complex then // we delete the last complex span of the children // and force this node to be treated as complex if (pItem->m_bSecond && !(pItem->m_bFirst)) { SpanListItem* pChildSpanItem = (SpanListItem*)m_ConvertList.GetTail(); if (pChildSpanItem && pChildSpanItem->m_pFirstNode && pChildSpanItem->m_pFirstNode->FindParent() == pNode) { // TRACEUSER( "Gerry", _T("XPFRC# Removing span item for 0x%08x (%s)\n"), pChildSpanItem->m_pFirstNode, pChildSpanItem->m_pFirstNode->GetRuntimeClass()->m_lpszClassName); delete m_ConvertList.RemoveTail(); } // We must reset the parent of the current span here SpanListItem* pCurItem = (SpanListItem*)m_ConvertList.GetTail(); // If the last node in the last span was the previous one if (pCurItem && pCurItem->m_pLastNode == pNode->FindPrevious()) { // Then we are still in the span at the moment m_pSpanParent = pCurItem->m_pLastNode->FindParent(); } else { // Otherwise we aren't in a span at the moment m_pSpanParent = NULL; } // TRACEUSER( "Gerry", _T("XPFRC# Current span parent set to 0x%08x (%s)\n", m_pSpanParent, m_pSpanParent?m_pSpanParent->GetRuntimeClass()->m_lpszClassName:"NULL")); ConvertType = XPFCONVTYPE_BITMAPSPAN; } } delete pItem; } } // If this node should be in a span if (ConvertType == XPFCONVTYPE_BITMAPSPAN) { SpanListItem* pItem = NULL; // If we are currently in a span and the parent is the same if (m_pSpanParent == pParent) { // TRACEUSER( "Gerry", _T("XPFRC# Adding to current span 0x%08x (%s)\n"), pNode, pNode->GetRuntimeClass()->m_lpszClassName); // Make this node the last node in the current span pItem = (SpanListItem*)m_ConvertList.GetTail(); if (pItem) pItem->m_pLastNode = pNode; } else { // TRACEUSER( "Gerry", _T("XPFRC# Starting new span with 0x%08x (%s)\n"), pNode, pNode->GetRuntimeClass()->m_lpszClassName); // Make this node the first node in a new span pItem = new SpanListItem(pNode); m_ConvertList.AddTail(pItem); m_pSpanParent = pParent; } // If this span doesn't have non-alpha transparency yet if (!pItem->m_bNonAlphaTrans) { // Check the current attributes in the render region for // non-alpha transparency types StrokeTranspAttribute* pStroke = (StrokeTranspAttribute*)(pRegion->GetCurrentAttribute(ATTR_STROKETRANSP)); UINT32 Type = pStroke->GetTranspType(); if (Type != TT_NoTranspType && Type != TT_Mix && Type != TT_DARKEN && Type != TT_LIGHTEN && Type != TT_BRIGHTNESS && Type != TT_BEVEL) { // TRACEUSER( "Gerry", _T("XPFRC# Found non-alpha stroke transparency\n")); pItem->m_bNonAlphaTrans = TRUE; } if (!pItem->m_bNonAlphaTrans) { TranspFillAttribute* pFill = (TranspFillAttribute*)(pRegion->GetCurrentAttribute(ATTR_TRANSPFILLGEOMETRY)); UINT32 Type = pFill->GetTranspType(); if (Type != TT_NoTranspType && Type != TT_Mix && Type != TT_DARKEN && Type != TT_LIGHTEN && Type != TT_BRIGHTNESS && Type != TT_BEVEL) { // TRACEUSER( "Gerry", _T("XPFRC# Found non-alpha fill transparency\n")); pItem->m_bNonAlphaTrans = TRUE; } } } } else { // TRACEUSER( "Gerry", _T("XPFRC# Stopping current span\n")); // Stop the current span m_pSpanParent = NULL; } NodeThreeBoolListItem* pParentItem = (NodeThreeBoolListItem*)m_ParentList.GetTail(); if (pParentItem) { if (ConvertType == XPFCONVTYPE_BITMAPSPAN) pParentItem->m_bSecond = TRUE; else pParentItem->m_bFirst = TRUE; } } } break; default: { TRACEUSER( "Gerry", _T("Unimplemented Pass (%d)\n"), m_ConvertPass); } break; } return(TRUE); }

BOOL XPFRenderCallback::BeforeSubtree (  RenderRegion *  pRegion, Node *  pNode, Node **  ppNextNode, BOOL  bClip, SubtreeRenderState *  pState )  [virtual]

Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pRegion  - pointer to a RenderRegion [INPUTS] pNode - pointer to a Node ppNextNode - pointer to a pointer to a Node bClip - pState - pointer to a SubtreeRenderState Returns: TRUE if ok, FALSE if bother Reimplemented from RenderCallback. Definition at line 945 of file xpfrgn.cpp. { // if (pNode->FindFirstChild()) // { // TRACEUSER( "Gerry", _T("XPFRC# BeforeSubtree 0x%08x - %s\n"), pNode, pNode->GetRuntimeClass()->m_lpszClassName); // } if (pNode->IsNodeHidden() || pNode->IsAnInsertionNode()) return(FALSE); BOOL ok; BOOL bSetState = TRUE; SubtreeRenderState RenderState = SUBTREE_ROOTANDCHILDREN; // Move code for each pass into separate functions switch (m_ConvertPass) { case 1: { // If we are doing selection only, this node is an object // and this node is not selected and doesn't have a selected // parent or child then skip it if (m_pCapTree->GetSelection() && pNode->IsAnObject() && !(pNode->IsChildOfSelected() || pNode->HasSelectedChildren())) { RenderState = SUBTREE_NORENDER; bSetState = TRUE; } else { // This pass can handle native, simple, bitmap, reformat and remove conversions // Create a copy of the tree doing the relevant conversions on-the-fly // Get the convert type of this node XPFConvertType ConvertType = m_pCapTree->GetConvertTypePass1(pNode, m_pXPFRegion); if (ConvertType == XPFCONVTYPE_NATIVE) { // If it is native then: // create a shallow copy of the node // attach it at the current context position // update the context to the first child of this node // continue the render into the subtree Node* pNodeToAttach = pNode->PublicCopy(); // TODOG: Check for NULL // If we have a context node then attach to it otherwise set m_pNewSpread if (m_pContextNode) { /* if (m_Direction == FIRSTCHILD) { TRACEUSER( "Gerry", _T("XPFRC# Attaching %s as child of %s\n"), pNodeToAttach->GetRuntimeClass()->m_lpszClassName, m_pContextNode->GetRuntimeClass()->m_lpszClassName); } else if (m_Direction == LASTCHILD) { TRACEUSER( "Gerry", _T("XPFRC# Attaching %s as last child of %s\n"), pNodeToAttach->GetRuntimeClass()->m_lpszClassName, m_pContextNode->GetRuntimeClass()->m_lpszClassName); } else if (m_Direction == NEXT) { TRACEUSER( "Gerry", _T("XPFRC# Attaching %s as sibling of %s\n"), pNodeToAttach->GetRuntimeClass()->m_lpszClassName, m_pContextNode->GetRuntimeClass()->m_lpszClassName); }*/ pNodeToAttach->AttachNode(m_pContextNode, m_Direction); } // Update context node m_pContextNode = pNodeToAttach; m_Direction = FIRSTCHILD; } else if (ConvertType == XPFCONVTYPE_SIMPLE) { // If it is simple then: // create a deep copy of the node // attach it at the current context position // convert it to editable shapes (become a path) // update the context to the next sibling // skip the render of this subtree TRACEUSER( "Gerry", _T("XPFRC# Converting %s to simple\n"), pNode->GetRuntimeClass()->m_lpszClassName); // Create a deep copy of this subtree Node* pNodeToAttach = NULL; ok = pNode->NodeCopy(&pNodeToAttach); if (ok && pNodeToAttach) { // Attach the copy into the output tree /* if (m_Direction == FIRSTCHILD) { TRACEUSER( "Gerry", _T("XPFRC# Attaching %s as child of %s\n"), pNodeToAttach->GetRuntimeClass()->m_lpszClassName, m_pContextNode->GetRuntimeClass()->m_lpszClassName); } else if (m_Direction == LASTCHILD) { TRACEUSER( "Gerry", _T("XPFRC# Attaching %s as last child of %s\n"), pNodeToAttach->GetRuntimeClass()->m_lpszClassName, m_pContextNode->GetRuntimeClass()->m_lpszClassName); } else if (m_Direction == NEXT) { TRACEUSER( "Gerry", _T("XPFRC# Attaching %s as sibling of %s\n"), pNodeToAttach->GetRuntimeClass()->m_lpszClassName, m_pContextNode->GetRuntimeClass()->m_lpszClassName); }*/ pNodeToAttach->AttachNode(m_pContextNode, m_Direction); // We must convert this subtree to simple shapes BecomeA BecomeAPath(BECOMEA_REPLACE, CC_RUNTIME_CLASS(NodePath), NULL); BecomeAPath.SetResultsStayInPlace(TRUE); ok = pNodeToAttach->DoBecomeA(&BecomeAPath); // TRACEUSER( "Gerry", _T("BecomeAPath returned %s\n", ok ? "true" : "false")); if (m_Direction == NEXT) m_pContextNode = m_pContextNode->FindNext(); else m_pContextNode = m_pContextNode->FindFirstChild(); m_Direction = NEXT; // And we must skip this subtree RenderState = SUBTREE_NORENDER; bSetState = TRUE; } } else if (ConvertType == XPFCONVTYPE_BITMAP) { // If it is bitmap then: // render the node into a new bitmap node // attach it at the current context position // update the context to the next sibling // skip the render of this subtree BOOL bNonAlphaTrans = DoesNodeUseNonAlphaTrans(pNode); TRACEUSER("Gerry", _T("XPFRC# Converting %s to bitmap (%s)\n"), pNode->GetRuntimeClass()->m_lpszClassName, bNonAlphaTrans ? _T("NonAlpha") : _T("Alpha")); Node* pNodeToAttach = RenderNodesToBitmap(pNode, pNode, bNonAlphaTrans); if (pNodeToAttach) { // Attach the new node into the output tree /* if (m_Direction == FIRSTCHILD) { TRACEUSER( "Gerry", _T("XPFRC# Attaching %s as child of %s\n"), pNodeToAttach->GetRuntimeClass()->m_lpszClassName, m_pContextNode->GetRuntimeClass()->m_lpszClassName); } else if (m_Direction == LASTCHILD) { TRACEUSER( "Gerry", _T("XPFRC# Attaching %s as last child of %s\n"), pNodeToAttach->GetRuntimeClass()->m_lpszClassName, m_pContextNode->GetRuntimeClass()->m_lpszClassName); } else if (m_Direction == NEXT) { TRACEUSER( "Gerry", _T("XPFRC# Attaching %s as sibling of %s\n"), pNodeToAttach->GetRuntimeClass()->m_lpszClassName, m_pContextNode->GetRuntimeClass()->m_lpszClassName); }*/ pNodeToAttach->AttachNode(m_pContextNode, m_Direction); // The next node must be the NEXT sibling of this one m_pContextNode = pNodeToAttach; m_Direction = NEXT; } RenderState = SUBTREE_NORENDER; bSetState = TRUE; } else if (ConvertType == XPFCONVTYPE_REFORMAT) { // If it is reformat then: // create a reformatted copy of the text story // attach it at the current context position // update the context to the next sibling // skip the render of this subtree TRACEUSER( "Gerry", _T("XPFRC# Reformatting %s\n"), pNode->GetRuntimeClass()->m_lpszClassName); Node* pNodeToAttach = NULL; if (IS_A(pNode, TextStory)) { // Reformat the copy of the story TextStory* pStory = (TextStory*)pNode; pNodeToAttach = ReformatTextStory(pStory); if (pNodeToAttach) { pNodeToAttach->AttachNode(m_pContextNode, m_Direction); // Update context node m_pContextNode = pNodeToAttach; m_Direction = NEXT; } } RenderState = SUBTREE_NORENDER; bSetState = TRUE; } else if (ConvertType == XPFCONVTYPE_REMOVE) { // If it is remove then: // skip the render of this subtree // TRACEUSER( "Gerry", _T("XPFRC# Ignoring %s\n"), pNode->GetRuntimeClass()->m_lpszClassName); RenderState = SUBTREE_NORENDER; bSetState = TRUE; } } } break; case 2: { // Don't do anything in here for now } break; case 3: { // Don't do anything in here for now } break; case 4: { // Get the convert type of this node XPFConvertType ConvertType = m_pCapTree->GetConvertTypePass4(pNode, m_pXPFRegion); // If it specifies bitmap then add the node to the convert list if (ConvertType == XPFCONVTYPE_BITMAP) { TRACEUSER( "Gerry", _T("XPFRC# Setting pending bitmap conversion for %s\n"), pNode->GetRuntimeClass()->m_lpszClassName); NodeListItem* pItem = new NodeListItem(pNode); m_ConvertList.AddTail(pItem); RenderState = SUBTREE_NORENDER; bSetState = TRUE; } } break; case 5: { // If the node is a renderable object and has children if (pNode->IsAnObject() && pNode->FindFirstChild()) { // TRACEUSER( "Gerry", _T("XPFRC# Creating parent list item for 0x%08x (%s)\n"), pNode, pNode->GetRuntimeClass()->m_lpszClassName); // Create a new NodeThreeBoolListItem for this node NodeThreeBoolListItem* pItem = new NodeThreeBoolListItem(pNode); m_ParentList.AddTail(pItem); } } break; default: { TRACEUSER( "Gerry", _T("Unimplemented Pass (%d)\n"), m_ConvertPass); } break; } if (bSetState) *pState = RenderState; return(bSetState); }

BOOL XPFRenderCallback::ConvertNodes (   )

Performs the required conversion on the stored list of nodes. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Returns: TRUE if ok, FALSE if bother Definition at line 1623 of file xpfrgn.cpp. { BOOL ok = TRUE; switch (m_ConvertPass) { case 2: ok = ConvertNodesForPass2(); break; case 3: ok = ConvertNodesForPass3(); break; case 4: ok = ConvertNodesForPass4(); break; case 5: ok = ConvertNodesForPass5(); break; default: break; } // And empty the list m_ConvertList.DeleteAll(); return(ok); }

BOOL XPFRenderCallback::ConvertNodesForPass2 (   )  [protected]

Performs the "stroked" conversion on the convert list. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Returns: TRUE if ok, FALSE if bother Definition at line 1668 of file xpfrgn.cpp. { TRACEUSER( "Gerry", _T("ConvertNodesForPass2 (%d)\n"), m_ConvertList.GetCount()); double dProgress = 0.0; double dInc = 100.0 / (double)m_ConvertList.GetCount(); BOOL ok = TRUE; NodeListItem* pItem = (NodeListItem*)m_ConvertList.GetHead(); while (pItem) { Node* pNode = pItem->pNode; NodeRenderableInk* pInkNode = (NodeRenderableInk*)pNode; TRACEUSER( "Gerry", _T("ConvertStroked 0x%08x (%s) \n"), pNode, pNode->GetRuntimeClass()->m_lpszClassName); // First we need to check if there is any line colour on the object // If there isn't then we don't do anything NodeAttribute* pStrokeCol = NULL; pInkNode->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), &pStrokeCol); if (pStrokeCol && !((AttrStrokeColour*)pStrokeCol)->Value.GetStartColour()->IsTransparent()) { // Now we need to check if there is any fill on this object. // If there is then we need to create a group to represent this node // This will hold this node with the stroke attributes removed and // a copy of this node to represent the stroke which will have the // conversion done on it // Otherwise we can just do the conversion on the original node BOOL bHasFill = TRUE; if (pNode->IsKindOf(CC_RUNTIME_CLASS(NodePath))) { NodePath* pPath = (NodePath*)pNode; if (!pPath->InkPath.IsFilled) bHasFill = FALSE; } if (bHasFill) { NodeAttribute* pAppliedAttr = NULL; pInkNode->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry), &pAppliedAttr); if (pAppliedAttr != NULL && IS_A(pAppliedAttr, AttrFlatColourFill)) { DocColour* pLineColour = ((AttrFlatColourFill*)pAppliedAttr)->GetStartColour(); if (pLineColour != NULL) if (pLineColour->IsTransparent()) bHasFill = FALSE; } } if (bHasFill) { // Create a group node and insert it into the tree as next NodeGroup* pGroup = new NodeGroup(pNode, NEXT); if (pGroup == NULL) { // Set the error return(FALSE); } Node* pFillNode = NULL; // Create a copy of the node and attach it as first child of the group ok = pNode->NodeCopy((Node**)&pFillNode); if (!ok) { // Set the error return(ok); } pFillNode->AttachNode(pGroup, FIRSTCHILD); // Move the node to convert to be next sibling of the copy pNode->MoveNode(pFillNode, NEXT); // Convert the node ok = OpConvertPathToShapes::ConvertPathToShapes(NULL, (NodeRenderableInk*)pNode); TRACEUSER( "Gerry", _T("ConvertPathToShapes returned %s\n"), ok ? _T("true") : _T("false")); if (!ok) { // Report error return(ok); } // Remove the stroke attributes from the fill object pGroup->LocaliseCommonAttributes(FALSE, TRUE, NULL); // Remove all the stroke based attributes RemoveChildAttrs(pFillNode, CC_RUNTIME_CLASS(AttrStrokeColour)); RemoveChildAttrs(pFillNode, CC_RUNTIME_CLASS(AttrStrokeTransp)); RemoveChildAttrs(pFillNode, CC_RUNTIME_CLASS(AttrDashPattern)); RemoveChildAttrs(pFillNode, CC_RUNTIME_CLASS(AttrStartArrow)); RemoveChildAttrs(pFillNode, CC_RUNTIME_CLASS(AttrEndArrow)); RemoveChildAttrs(pFillNode, CC_RUNTIME_CLASS(AttrStartCap)); RemoveChildAttrs(pFillNode, CC_RUNTIME_CLASS(AttrLineWidth)); RemoveChildAttrs(pFillNode, CC_RUNTIME_CLASS(AttrVariableWidth)); RemoveChildAttrs(pFillNode, CC_RUNTIME_CLASS(AttrBrushType)); RemoveChildAttrs(pFillNode, CC_RUNTIME_CLASS(AttrStrokeType)); // Apply a no stroke colour attribute AttrStrokeColour* pTranspAttr = new AttrStrokeColour(pFillNode, FIRSTCHILD); if (pTranspAttr) { StrokeColourAttribute* pTranspVal = (StrokeColourAttribute*)(pTranspAttr->GetAttributeValue()); pTranspVal->Colour = DocColour(COLOUR_NONE); } pGroup->FactorOutCommonChildAttributes(TRUE, (AttrTypeSet*)NULL); } else { ok = OpConvertPathToShapes::ConvertPathToShapes(NULL, (NodeRenderableInk*)pNode); TRACEUSER( "Gerry", _T("ConvertPathToShapes returned %s\n"), ok ? _T("true") : _T("false")); if (!ok) { return(ok); } } } else { TRACEUSER( "Gerry", _T("No line colour\n")); } // Get the next span item pItem = (NodeListItem*)m_ConvertList.GetNext(pItem); dProgress += dInc; if (!m_pFilter->SetProgressBarCount((UINT32)dProgress)) { Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set return(FALSE); } } return(TRUE); }

BOOL XPFRenderCallback::ConvertNodesForPass3 (   )  [protected]

Performs the bitmapfill, bitmaptrans and bitmapfilltrans conversions on the convert list. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Returns: TRUE if ok, FALSE if bother Definition at line 1821 of file xpfrgn.cpp. { TRACEUSER( "Gerry", _T("ConvertNodesForPass3 (%d)\n"), m_ConvertList.GetCount()); double dProgress = 0.0; double dInc = 100.0 / (double)m_ConvertList.GetCount(); NodeCompound* pLastParent = NULL; NodeThreeBoolListItem* pItem = (NodeThreeBoolListItem*)m_ConvertList.GetHead(); while (pItem) { TRACEUSER( "Gerry", _T("ConvertFillAttrs 0x%08x (%s) %s%s\n"), pItem->m_pNode, pItem->m_pNode->GetRuntimeClass()->m_lpszClassName, pItem->m_bFirst ? _T("fill ") : _T(""), pItem->m_bSecond ? _T("trans") : _T("")); Node* pNode = pItem->m_pNode; Node* pParentNode = pNode->FindParent(); ERROR2IF(!pParentNode, FALSE, "Node has no parent in ConvertNodesForPass3"); NodeCompound* pParent = NULL; if (pParentNode->IsCompound()) { pParent = (NodeCompound*)pParentNode; if (pParent != pLastParent) { if (pLastParent) pLastParent->FactorOutCommonChildAttributes(TRUE, (AttrTypeSet*)NULL); pParent->LocaliseCommonAttributes(TRUE, TRUE, NULL); pLastParent = pParent; } } NodeRenderableBounded* pTheNode = (NodeRenderableBounded*)pNode; DocRect BoundsRect = pTheNode->GetBoundingRect(TRUE, FALSE); if (pItem->m_bThird) { // We need to combine the fill and transparency into a bitmap fill // and then create a bitmap fill attribute to replace the existing fill with // All of the fill attributes must be set to sensible values KernelBitmap* pBmp = RenderFillAndTransToBitmap(pNode, BoundsRect); if (!pBmp) return(FALSE); // Remove any existing fill and transparency attributes RemoveChildAttrs(pNode, CC_RUNTIME_CLASS(AttrFillGeometry)); RemoveChildAttrs(pNode, CC_RUNTIME_CLASS(AttrFillMapping)); RemoveChildAttrs(pNode, CC_RUNTIME_CLASS(AttrFillEffect)); RemoveChildAttrs(pNode, CC_RUNTIME_CLASS(AttrTranspFillMapping)); RemoveChildAttrs(pNode, CC_RUNTIME_CLASS(AttrTranspFillGeometry)); // Apply a bitmap fill AttrBitmapColourFill* pBmpFill = new AttrBitmapColourFill(pNode, FIRSTCHILD); if (!pBmpFill) { delete pBmp; return(FALSE); } BitmapFillAttribute* pBmpVal = (BitmapFillAttribute*)(pBmpFill->GetAttributeValue()); pBmpVal->BitmapRef.Attach(pBmp); DocCoord BottomLeft(BoundsRect.lo); DocCoord BottomRight(BoundsRect.hi.x, BoundsRect.lo.y); DocCoord TopLeft(BoundsRect.lo.x, BoundsRect.hi.y); pBmpVal->SetStartPoint(&BottomLeft); pBmpVal->SetEndPoint(&BottomRight); pBmpVal->SetEndPoint2(&TopLeft); // Apply a simple fill mapping AttrFillMappingLinear* pFillMap = new AttrFillMappingLinear(pNode, FIRSTCHILD); if (!pFillMap) { delete pBmpFill; return(FALSE); } FillMappingLinearAttribute* pMapVal = (FillMappingLinearAttribute*)(pFillMap->GetAttributeValue()); pMapVal->Repeat = 1; // Set no repeat } else { if (pItem->m_bFirst) { // We need to render the fill of the object into a bitmap ignoring any transparency // and then create a bitmap fill attribute to replace the existing fill with // All of the fill attributes must be set to sensible values KernelBitmap* pBmp = RenderFillToBitmap(pNode, BoundsRect); if (!pBmp) return(FALSE); // Remove any existing fill attributes RemoveChildAttrs(pNode, CC_RUNTIME_CLASS(AttrFillGeometry)); RemoveChildAttrs(pNode, CC_RUNTIME_CLASS(AttrFillMapping)); RemoveChildAttrs(pNode, CC_RUNTIME_CLASS(AttrFillEffect)); // Apply a bitmap fill AttrBitmapColourFill* pBmpFill = new AttrBitmapColourFill(pNode, FIRSTCHILD); if (!pBmpFill) { delete pBmp; return(FALSE); } BitmapFillAttribute* pBmpVal = (BitmapFillAttribute*)(pBmpFill->GetAttributeValue()); pBmpVal->BitmapRef.Attach(pBmp); DocCoord BottomLeft(BoundsRect.lo); DocCoord BottomRight(BoundsRect.hi.x, BoundsRect.lo.y); DocCoord TopLeft(BoundsRect.lo.x, BoundsRect.hi.y); pBmpVal->SetStartPoint(&BottomLeft); pBmpVal->SetEndPoint(&BottomRight); pBmpVal->SetEndPoint2(&TopLeft); // Apply a simple fill mapping AttrFillMappingLinear* pFillMap = new AttrFillMappingLinear(pNode, FIRSTCHILD); if (!pFillMap) { delete pBmpFill; return(FALSE); } FillMappingLinearAttribute* pMapVal = (FillMappingLinearAttribute*)(pFillMap->GetAttributeValue()); pMapVal->Repeat = 1; // Set no repeat } if (pItem->m_bSecond) { // We need to render the transparency of the object as a greyscale graduated fill // and then create a bitmap transparency attribute to replace the existing one with // All of the transparency attributes must be set to sensible values UINT32 TransType = 0; KernelBitmap* pBmp = RenderTransToBitmap(pNode, BoundsRect, &TransType); if (!pBmp) return(FALSE); // Find the last child AttrTranspFillGeometry // Apply a bitmap transparency as the next node to the one found NodeAttribute* pOldGeometry = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrTranspFillGeometry)); // Apply a bitmap transparency AttrBitmapTranspFill* pBmpTrans = NULL; if (pOldGeometry) pBmpTrans = new AttrBitmapTranspFill(pOldGeometry, NEXT); else pBmpTrans = new AttrBitmapTranspFill(pNode, FIRSTCHILD); if (!pBmpTrans) { delete pBmp; return(FALSE); } BitmapTranspFillAttribute* pBmpVal = (BitmapTranspFillAttribute*)(pBmpTrans->GetAttributeValue()); pBmpVal->BitmapRef.Attach(pBmp); DocCoord BottomLeft(BoundsRect.lo); DocCoord BottomRight(BoundsRect.hi.x, BoundsRect.lo.y); DocCoord TopLeft(BoundsRect.lo.x, BoundsRect.hi.y); pBmpVal->SetStartPoint(&BottomLeft); pBmpVal->SetEndPoint(&BottomRight); pBmpVal->SetEndPoint2(&TopLeft); UINT32 Val = 0; pBmpVal->SetStartTransp(&Val); Val = 255; pBmpVal->SetEndTransp(&Val); pBmpVal->SetTranspType(TransType); // Find the last child AttrTranspFillMappingLinear NodeAttribute* pOldMapping = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrTranspFillMapping)); // If we have found an old geometry attr if (pOldGeometry) { // And we have found an old mapping attr and they don't match Effects if (pOldMapping && pOldMapping->IsEffectAttribute() != pOldGeometry->IsEffectAttribute()) pOldMapping = NULL; // Flag that we haven't found an old mapping } // Apply a simple fill mapping AttrTranspFillMappingLinear* pTransMap = NULL; if (pOldMapping) pTransMap = new AttrTranspFillMappingLinear(pOldMapping, NEXT); else if (pOldGeometry) pTransMap = new AttrTranspFillMappingLinear(pOldGeometry, NEXT); else pTransMap = new AttrTranspFillMappingLinear(pNode, FIRSTCHILD); if (!pTransMap) { delete pBmpTrans; return(FALSE); } TranspFillMappingLinearAttribute* pMapVal = (TranspFillMappingLinearAttribute*)(pTransMap->GetAttributeValue()); pMapVal->Repeat = 1; // Set no repeat // Delete the old attributes if (pOldGeometry) { pOldGeometry->CascadeDelete(); delete pOldGeometry; } if (pOldMapping) { pOldMapping->CascadeDelete(); delete pOldMapping; } } } dProgress += dInc; if (!m_pFilter->SetProgressBarCount((UINT32)dProgress)) { Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set return(FALSE); } pItem = (NodeThreeBoolListItem*)m_ConvertList.GetNext(pItem); } if (pLastParent) pLastParent->FactorOutCommonChildAttributes(TRUE, (AttrTypeSet*)NULL); return(TRUE); }

BOOL XPFRenderCallback::ConvertNodesForPass4 (   )  [protected]

Performs the bitmap conversion on the convert list. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Returns: TRUE if ok, FALSE if bother Definition at line 2056 of file xpfrgn.cpp. { TRACEUSER( "Gerry", _T("ConvertNodesForPass4 (%d)\n"), m_ConvertList.GetCount()); double dProgress = 0.0; double dInc = 100.0 / (double)m_ConvertList.GetCount(); NodeListItem* pItem = (NodeListItem*)m_ConvertList.GetHead(); while (pItem) { Node* pNode = pItem->pNode; if (pNode) { TRACEUSER( "Gerry", _T("NodeListItem 0x%08x (%s)\n"), pNode, pNode->GetRuntimeClass()->m_lpszClassName); // Render the node span to a bitmap BOOL bNonAlphaTrans = DoesNodeUseNonAlphaTrans(pNode); Node* pNewNode = RenderNodesToBitmap(pNode, pNode, bNonAlphaTrans); if (!pNewNode) return(FALSE); // Attach the new node as the previous of the first in the span pNewNode->AttachNode(pNode, PREV); // Delete the node we have just replaced pNode->CascadeDelete(); delete pNode; } dProgress += dInc; if (!m_pFilter->SetProgressBarCount((UINT32)dProgress)) { Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set return(FALSE); } // Get the next item pItem = (NodeListItem*)m_ConvertList.GetNext(pItem); } return(TRUE); }

BOOL XPFRenderCallback::ConvertNodesForPass5 (   )  [protected]

Performs the bitmapspan conversion on the convert list. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Returns: TRUE if ok, FALSE if bother Definition at line 2113 of file xpfrgn.cpp. { TRACEUSER( "Gerry", _T("ConvertNodesForPass5 (%d)\n"), m_ConvertList.GetCount()); double dProgress = 0.0; double dInc = 100.0 / (double)m_ConvertList.GetCount(); SpanListItem* pItem = (SpanListItem*)m_ConvertList.GetHead(); while (pItem) { TRACEUSER( "Gerry", _T("SpanListItem 0x%08x (%s) to 0x%08x (%s)\n"), pItem->m_pFirstNode, pItem->m_pFirstNode->GetRuntimeClass()->m_lpszClassName, pItem->m_pLastNode, pItem->m_pLastNode->GetRuntimeClass()->m_lpszClassName); // Render the node span to a bitmap Node* pNewNode = RenderNodesToBitmap(pItem->m_pFirstNode, pItem->m_pLastNode, pItem->m_bNonAlphaTrans); if (!pNewNode) return(FALSE); // Attach the new node as the previous of the first in the span pNewNode->AttachNode(pItem->m_pFirstNode, PREV); // Delete all the nodes in the span Node* pNode = pItem->m_pFirstNode; while (pNode) { Node* pNextNode = (pNode == pItem->m_pLastNode) ? NULL : pNode->FindNext(); pNode->CascadeDelete(); delete pNode; pNode = pNextNode; } dProgress += dInc; if (!m_pFilter->SetProgressBarCount((UINT32)dProgress)) { Error::SetError(_R(IDN_USER_CANCELLED),0); // Expects error set return(FALSE); } // Get the next span item pItem = (SpanListItem*)m_ConvertList.GetNext(pItem); } return(TRUE); }

BOOL XPFRenderCallback::CopyAttributesFromNode (  Node *  pDestNode, Node *  pSrcNode )  [protected]

Copies all attributes except justification and tracking from one node to another. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pDestNode  - pointer to a Node [INPUTS] pSrcNode - pointer to a Node Returns: TRUE if ok, FALSE if bother Definition at line 1427 of file xpfrgn.cpp. { Node* pChildNode = pSrcNode->FindFirstChild(); Node* pContextNode = pDestNode; AttachNodeDirection Direction = FIRSTCHILD; while (pChildNode) { if (!pChildNode->IsNodeHidden() && !IS_A(pChildNode, AttrTxtJustification) && !IS_A(pChildNode, AttrTxtTracking)) { Node* pNewChild = pChildNode->PublicCopy(); if (pNewChild) { pNewChild->AttachNode(pContextNode, Direction, FALSE, FALSE); pContextNode = pNewChild; Direction = NEXT; } } pChildNode = pChildNode->FindNext(); } return(TRUE); }

BOOL XPFRenderCallback::DoesNodeUseNonAlphaTrans (  Node *  pRootNode  )  [protected]

Determines if a node has any attributes that use non-alpha transparency. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pRootNode  - pointer to a Node [INPUTS] Returns: TRUE if ok, FALSE if bother Definition at line 1535 of file xpfrgn.cpp. { // This function determines if the specified node uses any non-alpha compatible // transparency types (anywhere in its subtree) // If this isn't a renderable ink node then get out // It might be a layer or spread which are paper nodes! // if (!pRootNode->IS_KIND_OF(NodeRenderableInk)) // return(FALSE); if (pRootNode->IsAnObject()) { NodeRenderableInk* pInkNode = (NodeRenderableInk*)pRootNode; // Basically, it just needs to check any transparency attributes // First it needs to check the attributes applied above this node in the tree AttrStrokeTransp* pStrkAttr = (AttrStrokeTransp*)(pInkNode->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeTransp), TRUE)); if (pStrkAttr) { UINT32 Type = pStrkAttr->GetTranspType(); if (Type != TT_NoTranspType && Type != TT_Mix && Type != TT_DARKEN && Type != TT_LIGHTEN && Type != TT_BRIGHTNESS && Type != TT_BEVEL) { return(TRUE); } } AttrFillGeometry* pFillAttr = (AttrFillGeometry*)(pInkNode->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrTranspFillGeometry), TRUE)); if (pFillAttr) { UINT32 Type = pFillAttr->GetTranspType(); if (Type != TT_NoTranspType && Type != TT_Mix && Type != TT_DARKEN && Type != TT_LIGHTEN && Type != TT_BRIGHTNESS && Type != TT_BEVEL) { return(TRUE); } } } // Now we scan through the tree looking for all AttrFillGeometry nodes Node* pNode = pRootNode->FindFirstDepthFirst(); while (pNode) { // Check this node if (pNode->IsAnAttribute() && pNode->IS_KIND_OF(AttrFillGeometry)) { AttrFillGeometry* pAttr = (AttrFillGeometry*)pNode; UINT32 Type = pAttr->GetTranspType(); if (Type != TT_NoTranspType && Type != TT_Mix && Type != TT_DARKEN && Type != TT_LIGHTEN && Type != TT_BRIGHTNESS && Type != TT_BEVEL) { return(TRUE); } } // Move on to the next node pNode = pNode->FindNextDepthFirst(pRootNode); } return(FALSE); }

NodeAttribute * XPFRenderCallback::FindChildAttr (  Node *  pNode, CCRuntimeClass *  pClass )  [protected]

Finds the last child attr of the specified attribute type. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pNode  - pointer to a Node [INPUTS] pClass - pointer to a CCRuntimeClass Returns: NULL in times of grief Definition at line 1501 of file xpfrgn.cpp. { Node* pChild = pNode->FindLastChild(); while (pChild) { if (pChild->IsAnAttribute()) { NodeAttribute* pAttr = (NodeAttribute*)pChild; if (pAttr->GetAttributeType() == pClass) { return(pAttr); } } pChild = pChild->FindPrevious(); } return(NULL); }

BOOL XPFRenderCallback::FindCommonTransTypeToApply (  Node *  pFirstNode, Node *  pLastNode, UINT32 *  pCommonType )  [protected]

Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 15/06/2006 Parameters: pFirstNode  - pointer to a Node [INPUTS] pLastNode - pointer to a Node pCommonType - pointer to a UINT32 Returns: TRUE if ok, FALSE if bother Definition at line 2175 of file xpfrgn.cpp. { // If CommonTrans isn't set then return false if (!m_pCapTree->HasRasteriseCommonTrans()) return(FALSE); // Render the node span using an XPFRenderRegion and XPFSpanRenderCallback // to track the transparency used View *pView = View::GetCurrent(); Spread* pSpread = pFirstNode->FindParentSpread();; CommonTransInfo TransInfo; // Create and set up a new XPFRenderRegion XPFRenderRegion XPFRegion(NULL, NULL, &TransInfo); // Attach a device to the scanning render region // Since this rr does no real rendering, it does not need a Device context XPFRegion.AttachDevice(pView, NULL, pSpread); // Start the render region and return if it fails if (XPFRegion.StartRender()) { TRACEUSER( "Gerry", _T("Rendering nodes from 0x%08x to 0x%08x\n"), pFirstNode, pLastNode); XPFSpanRenderCallback SpanCallback(pFirstNode, pLastNode, FALSE); // Call RenderTree to do the rendering XPFRegion.RenderTree(pSpread, FALSE, FALSE, &SpanCallback); // Thats all the nodes rendered, so stop rendering XPFRegion.StopRender(); // Check the CommonTransInfo if (TransInfo.IsCommonType()) { UINT32 CommonType = TransInfo.GetCommonType(); if (CommonType != TT_Mix) { *pCommonType = CommonType; return(TRUE); } } else { if (TransInfo.UsesNonAlpha()) { if (pFirstNode == pLastNode && IS_A(pFirstNode, Layer)) { Layer* pLayer = (Layer*)pFirstNode; String_256 LayerName = pLayer->GetLayerID(); String_256 WarningMsg; WarningMsg.MakeMsg(_R(IDS_XPF_MIXEDTRANSLAYER), &LayerName); Error::SetError(_R(IDS_XPF_MIXEDTRANSLAYER),WarningMsg,0); InformWarning(); } } } } else { ERROR2(FALSE, "StartRender failed"); } return(FALSE); }

Spread* XPFRenderCallback::GetNewSpread (   )  [inline]

Definition at line 261 of file xpfrgn.h. { return(m_pNewSpread); }

Node * XPFRenderCallback::ReformatTextLine (  TextLine *  pLineNode, FormatRegion *  pFormatRegion )  [protected]

Creates a left justified and manually kerned copy of a text line by inserting manual kern codes where necessary. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pLineNode  - pointer to a TextLine [INPUTS] pFormatRegion- pointer to a FormatRegion Returns: NULL in times of grief Definition at line 1285 of file xpfrgn.cpp. { // TRACE( _T("ReformatTextLine 0x%08x\n"), pLineNode); BOOL ok = TRUE; // Copy the line Node* pNewRoot = pLineNode->PublicCopy(); // Kepp track of where we are attaching copies Node* pContextNode = pNewRoot; AttachNodeDirection Direction = FIRSTCHILD; pFormatRegion->SaveContext(); // Keep track of the current pos on the line MILLIPOINT CurrentPosMP = 0; // scan immediate children rendering any text attrs, and copying any text nodes Node* pNode = pLineNode->FindFirstChild(); while (pNode != NULL) { // TRACE( _T("Node at 0x%08x (%s)\n"), pNode, pNode->GetRuntimeClass()->m_lpszClassName); Node* pNewNode = NULL; if (pNode->IsAnAbstractTextChar()) { VisibleTextNode* pVTN=(VisibleTextNode*)pNode; AbstractTextChar* pATC=(AbstractTextChar*)pNode; // Save the context and render all the child text attributes // into the FormatRegion pFormatRegion->SaveContext(); Node* pChildNode = pNode->FindFirstChild(); while (pChildNode != NULL) { if (pChildNode->IsKindOfTextAttribute()) pChildNode->Render(pFormatRegion); pChildNode = pChildNode->FindNext(); } // Get the metrics of the character // MILLIPOINT EMWidth = 0; CharMetrics CharMet; ok = pFormatRegion->GetCharMetrics(&CharMet, pATC->GetUnicodeValue()); // If this character isn't a space // (have to do this or we get problems at the ends of lines) if (!pVTN->IsASpace()) { // Check the line position and insert a KernCode MILLIPOINT PosMP = pVTN->GetPosInLine(); // TRACE( _T("PosInLine = %d\n"), PosMP); // TRACE( _T("Current = %d\n"), CurrentPosMP); if (PosMP != CurrentPosMP) // If we aren't at the correct position in the line { // Calculate the required kern width in em/1000 INT32 PosEM1000 = MulDiv(PosMP - CurrentPosMP, 1000, CharMet.FontEmWidth); // Convert the em/1000 size back to millipoints INT32 KernSizeMP = MulDiv(PosEM1000, CharMet.FontEmWidth, 1000); // TRACE( _T("Inserting justify kern of %d\n"), PosMP - CurrentPosMP); // TRACE( _T("Real size %d\n"), KernSizeMP); // If the millipoint size is larger than it should be then // subtract 1 from the em/1000 size if (KernSizeMP > (PosMP - CurrentPosMP)) PosEM1000 -= 1; // Create and insert a KernCode with the same attributes as pNode DocCoord TempCoord(PosEM1000, 0); KernCode* pKern = new KernCode(TempCoord); if (pKern) { ok = CopyAttributesFromNode(pKern, pNode); pKern->AttachNode(pContextNode, Direction, FALSE, FALSE); pContextNode = pKern; Direction = NEXT; } CurrentPosMP = PosMP; } } // TRACE( _T("Inserting node width %d\n"), pATC->GetCharWidth()); // Advance the current pos by the character width (note, not the CharAdvance) CurrentPosMP += pATC->GetCharWidth(); // Create a deep copy of this Node pNewNode = pNode->PublicCopy(); if (pNewNode) { ok = CopyAttributesFromNode(pNewNode, pNode); pNewNode->AttachNode(pContextNode, Direction, FALSE, FALSE); pContextNode = pNewNode; Direction = NEXT; pNewNode = NULL; } pFormatRegion->RestoreContext(); } else if(!pNode->IsNodeHidden()) { if (pNode->IsKindOfTextAttribute()) pNode->Render(pFormatRegion); if (!IS_A(pNode, AttrTxtJustification) && !IS_A(pNode, AttrTxtTracking)) pNewNode = pNode->PublicCopy(); if (pNewNode) { ok = CopyAttributesFromNode(pNewNode, pNode); pNewNode->AttachNode(pContextNode, Direction, FALSE, FALSE); pContextNode = pNewNode; Direction = NEXT; } } pNode = pNode->FindNext(); } pFormatRegion->RestoreContext(); return(pNewRoot); }

TextStory * XPFRenderCallback::ReformatTextStory (  TextStory *  pStory  )  [protected]

Creates a copy of a TextStory where the copy is manually kerned and only uses left justification. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pStory  - pointer to a TextStory [INPUTS] Returns: NULL in times of grief Definition at line 1210 of file xpfrgn.cpp. { // Create a FormatRegion to track text attributes FormatRegion FormattingRegion; if (FormattingRegion.Init(pStory) == FALSE) return(NULL); // Create a copy of the TextStory node TextStory* pNewStory = (TextStory*)(pStory->PublicCopy()); if (pNewStory == NULL) return(NULL); // Keep track of where we are attaching new nodes Node* pContextNode = pNewStory; AttachNodeDirection Direction = FIRSTCHILD; // Loop through all the children of the story Node* pNode = pStory->FindFirstChild(); while (pNode != NULL) { Node* pNewNode = NULL; if (IS_A(pNode, TextLine)) // If it is a TextLine { // Then create a reformatted copy pNewNode = ReformatTextLine((TextLine*)pNode, &FormattingRegion); } else if (!pNode->IsNodeHidden()) // Otherwise if it isn't a hidden node { // If it is a text attribute then render it into the FormatRegion if (pNode->IsKindOfTextAttribute()) pNode->Render(&FormattingRegion); // If it isn't a justification or tracking attribute then copy it if (!IS_A(pNode, AttrTxtJustification) && !IS_A(pNode, AttrTxtTracking)) pNewNode = pNode->PublicCopy(); } // If we created a new node then attach it if (pNewNode) { pNewNode->AttachNode(pContextNode, Direction, FALSE, FALSE); // Next node will always be attached as the next sibling of this one pContextNode = pNewNode; Direction = NEXT; } pNode = pNode->FindNext(); } // Make sure the auto-kerning is turned off pNewStory->SetAutoKerning(FALSE); // May have to cause the new story to reformat itself here return(pNewStory); }

void XPFRenderCallback::RemoveChildAttrs (  Node *  pNode, CCRuntimeClass *  pClass )  [protected]

Removes all child attributes of a particular attribute type. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pNode  - pointer to a Node [INPUTS] pClass - pointer to a CCRuntimeClass Definition at line 1466 of file xpfrgn.cpp. { Node* pChild = pNode->FindFirstChild(); while (pChild) { Node* pNextChild = pChild->FindNext(); if (pChild->IsAnAttribute()) { NodeAttribute* pAttr = (NodeAttribute*)pChild; if (pAttr->GetAttributeType() == pClass) { pChild->CascadeDelete(); delete pChild; } } pChild = pNextChild; } }

KernelBitmap * XPFRenderCallback::RenderFillAndTransToBitmap (  Node *  pNode, DocRect &  BoundsRect )  [protected]

Renders the applied fill and transparency to a bitmap so both the fill and trans can be replaced by a simple bitmap fill. If the transparency is non-alpha compatible then we also have to render all the previous objects into it. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pNode  - pointer to a Node [INPUTS] BoundsRect - Returns: NULL in times of grief Definition at line 2775 of file xpfrgn.cpp. { BOOL bBackground = FALSE; NodeAttribute* pTransAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrTranspFillGeometry)); if (pTransAttr) { TranspFillAttribute* pTrans = (TranspFillAttribute*)(pTransAttr->GetAttributeValue()); UINT32 Type = pTrans->GetTranspType(); if (Type != TT_NoTranspType && Type != TT_Mix && Type != TT_DARKEN && Type != TT_LIGHTEN && Type != TT_BRIGHTNESS && Type != TT_BEVEL) { bBackground = TRUE; } } if (!m_pCapTree->GetRasteriseAlpha()) bBackground = TRUE; View* pView = View::GetCurrent(); Spread* pSpread = pNode->FindParentSpread(); Matrix ViewTrans; FIXED16 TempScale(1.0); double Dpi = m_pCapTree->GetRasteriseDPI(); // Make sure that BoundsRect wont end up as a zero-sized rectangle double MPPerPix = 72000.0 / Dpi; if (BoundsRect.Width() < MPPerPix) BoundsRect.hi.x = BoundsRect.lo.x + (INT32)(MPPerPix + 0.5); if (BoundsRect.Height() < MPPerPix) BoundsRect.hi.y = BoundsRect.lo.y + (INT32)(MPPerPix + 0.5); GRenderBitmap BitmapRR(BoundsRect, ViewTrans, TempScale, 32, Dpi); if (!bBackground) BitmapRR.m_DoCompression = TRUE; BitmapRR.AttachDevice(pView, NULL, pSpread); TRACEUSER( "Gerry", _T("Rendering fill and trans as bitmap (%d, %d)\n"), (INT32)((double)BoundsRect.Width() / MPPerPix), (INT32)((double)BoundsRect.Height() / MPPerPix)); // Start rendering into the bitmap if (!BitmapRR.StartRender()) { ERROR2(NULL, "StartRender failed in RenderFillAndTransToBitmap"); } if (bBackground) { // Should draw a big white rectangle here, into the bitmap render region or // transparent objects will not fade to white where you can see the paper under them DocRect DrawRect = BoundsRect; // Inflate the rect by 2 pixels DrawRect.Inflate( (INT32)(2*72000.0/Dpi + 0.5) ); // Draw it into the real bitmap BitmapRR.SaveContext(); BitmapRR.SetFillColour(COLOUR_WHITE); BitmapRR.DrawRect(&DrawRect); BitmapRR.RestoreContext(); } BitmapRR.SaveContext(); // Best quality please QualityAttribute *pQualAttr = new QualityAttribute(); pQualAttr->QualityValue.SetQuality(QUALITY_MAX); BitmapRR.SetQuality(pQualAttr, TRUE); if (bBackground) { // We need to render the background objects first // Reuse existing code by finding the previous object and // asking for it to be rendered with its background Node* pBackNode = pNode->FindPrevious(); Node* pParent = pNode->FindParent(); while (pBackNode == NULL) { if (pParent == NULL) break; pBackNode = pParent->FindPrevious(); pParent = pParent->FindParent(); } if (pBackNode) { XPFSpanRenderCallback SpanCallback(pBackNode, pBackNode, TRUE); BitmapRR.RenderTree(pSpread, FALSE, FALSE, &SpanCallback); } } NodeAttribute* pAttr; pAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrFillGeometry)); if (pAttr) pAttr->Render(&BitmapRR); pAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrFillMapping)); if (pAttr) pAttr->Render(&BitmapRR); pAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrFillEffect)); if (pAttr) pAttr->Render(&BitmapRR); pAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrTranspFillGeometry)); if (pAttr) pAttr->Render(&BitmapRR); pAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrTranspFillMapping)); if (pAttr) pAttr->Render(&BitmapRR); BitmapRR.SetLineColour(COLOUR_NONE); Path RectPath; if (RectPath.Initialise()) { // Start at bottom left corner RectPath.InsertMoveTo(BoundsRect.lo); RectPath.InsertLineTo(DocCoord(BoundsRect.hi.x, BoundsRect.lo.y)); RectPath.InsertLineTo(BoundsRect.hi); RectPath.InsertLineTo(DocCoord(BoundsRect.lo.x, BoundsRect.hi.y)); RectPath.InsertLineTo(BoundsRect.lo); // Close the path properly RectPath.CloseSubPath(); RectPath.IsFilled = TRUE; RectPath.IsStroked = FALSE; BitmapRR.DrawPath(&RectPath); } else { pNode->Render(&BitmapRR); } BitmapRR.RestoreContext(); // Stop rendering BitmapRR.StopRender(); OILBitmap* pFullBitmap = BitmapRR.ExtractBitmap(); String_256 BmpName = m_pFilter->GetNewBitmapName(); pFullBitmap->SetName(BmpName); KernelBitmap* pRealBmp = KernelBitmap::MakeKernelBitmap(pFullBitmap); // Attach the bitmap to this document or a copy will be created when // it is used in the attribute BitmapList* pBmpList = NULL; Document* pCurDoc = Document::GetCurrent(); if (pCurDoc) pBmpList = pCurDoc->GetBitmapList(); // and then attach the bitmap (doesn't matter if BmpList is NULL) pRealBmp->Attach(pBmpList); return(pRealBmp); }

KernelBitmap * XPFRenderCallback::RenderFillToBitmap (  Node *  pNode, DocRect &  BoundsRect )  [protected]

Renders the fill applied to the object into a KernelBitmap so that the fill can be replaced with a simple bitmap fill. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pNode  - pointer to a Node [INPUTS] BoundsRect - Returns: NULL in times of grief Definition at line 2538 of file xpfrgn.cpp. { View* pView = View::GetCurrent(); Spread* pSpread = pNode->FindParentSpread(); Matrix ViewTrans; FIXED16 TempScale(1.0); double Dpi = m_pCapTree->GetRasteriseDPI(); // Make sure that BoundsRect wont end up as a zero-sized rectangle double MPPerPix = 72000.0 / Dpi; if (BoundsRect.Width() < MPPerPix) BoundsRect.hi.x = BoundsRect.lo.x + (INT32)(MPPerPix + 0.5); if (BoundsRect.Height() < MPPerPix) BoundsRect.hi.y = BoundsRect.lo.y + (INT32)(MPPerPix + 0.5); GRenderBitmap BitmapRR(BoundsRect, ViewTrans, TempScale, 32, Dpi); BitmapRR.m_DoCompression = TRUE; BitmapRR.AttachDevice(pView, NULL, pSpread); TRACEUSER( "Gerry", _T("Rendering fill as bitmap (%d, %d)\n"), (INT32)((double)BoundsRect.Width() / MPPerPix), (INT32)((double)BoundsRect.Height() / MPPerPix)); // Start rendering into the bitmap if (!BitmapRR.StartRender()) { ERROR2(NULL, "StartRender failed in RenderFillToBitmap"); } BitmapRR.SaveContext(); // Best quality please QualityAttribute *pQualAttr = new QualityAttribute(); pQualAttr->QualityValue.SetQuality(QUALITY_MAX); BitmapRR.SetQuality(pQualAttr, TRUE); NodeAttribute* pAttr; pAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrFillGeometry)); if (pAttr) pAttr->Render(&BitmapRR); pAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrFillMapping)); if (pAttr) pAttr->Render(&BitmapRR); pAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrFillEffect)); if (pAttr) pAttr->Render(&BitmapRR); BitmapRR.SetLineColour(COLOUR_NONE); Path RectPath; if (RectPath.Initialise()) { // Start at bottom left corner RectPath.InsertMoveTo(BoundsRect.lo); RectPath.InsertLineTo(DocCoord(BoundsRect.hi.x, BoundsRect.lo.y)); RectPath.InsertLineTo(BoundsRect.hi); RectPath.InsertLineTo(DocCoord(BoundsRect.lo.x, BoundsRect.hi.y)); RectPath.InsertLineTo(BoundsRect.lo); // Close the path properly RectPath.CloseSubPath(); RectPath.IsFilled = TRUE; RectPath.IsStroked = FALSE; BitmapRR.DrawPath(&RectPath); } else { pNode->Render(&BitmapRR); } BitmapRR.RestoreContext(); // Stop rendering BitmapRR.StopRender(); OILBitmap* pFullBitmap = BitmapRR.ExtractBitmap(); String_256 BmpName = m_pFilter->GetNewBitmapName(); pFullBitmap->SetName(BmpName); KernelBitmap* pRealBmp = KernelBitmap::MakeKernelBitmap(pFullBitmap); // Attach the bitmap to this document or a copy will be created when // it is used in the attribute BitmapList* pBmpList = NULL; Document* pCurDoc = Document::GetCurrent(); if (pCurDoc) pBmpList = pCurDoc->GetBitmapList(); // and then attach the bitmap (doesn't matter if BmpList is NULL) pRealBmp->Attach(pBmpList); return(pRealBmp); }

Node * XPFRenderCallback::RenderNodesToBitmap (  Node *  pFirstNode, Node *  pLastNode, BOOL  bNonAlphaTrans )  [protected]

Renders a range of nodes into a bitmap. If it uses non-alpha trans then a 24bpp bitmap is generated including all the objects before the span. If it doesn't use non-alpha trans then a 32bpp RGBA bitmap of just the node span is generated. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pFirstNode  - pointer to a Node [INPUTS] pLastNode - pointer to a Node bNonAlphaTrans- if TRUE then node span uses non-alpha trans Returns: NULL in times of grief Definition at line 2259 of file xpfrgn.cpp. { // First we detect the single layer case for various bits of special handling BOOL bOldLayerVisibility = FALSE; Layer* pSingleLayer = NULL; Spread* pSingleSpread = NULL; NodeBitmap* pSingleBitmap = NULL; if (pFirstNode == pLastNode) { if (pFirstNode->IsLayer()) { pSingleLayer = (Layer*)pFirstNode; bOldLayerVisibility = pSingleLayer->GetVisibleFlagState(); pSingleLayer->SetVisible(TRUE); } else if (pFirstNode->IsSpread()) { pSingleSpread = (Spread*)pFirstNode; } else if (pFirstNode->IsABitmap()) { pSingleBitmap = (NodeBitmap*)pFirstNode; } } // Find the bounding rect of the nodes and determine if the background needs // to be rendered DocRect SpanBounds; BOOL bBackground = FALSE; BOOL bForceMix = FALSE; BOOL bAlpha = m_pCapTree->GetRasteriseAlpha(); UINT32 TransToApply = TT_NoTranspType; if (!bAlpha) { bBackground = TRUE; } else { if (FindCommonTransTypeToApply(pFirstNode, pLastNode, &TransToApply)) { bBackground = FALSE; bForceMix = TRUE; } else { bBackground = bNonAlphaTrans; } } Node* pNode = pFirstNode; while (pNode) { if (pNode->IsBounded()) { DocRect ObjectRect = ((NodeRenderableBounded*)pNode)->GetBoundingRect(FALSE, FALSE); SpanBounds = SpanBounds.Union(ObjectRect); } if (pNode == pLastNode) break; pNode = pNode->FindNext(); } View* pView = View::GetCurrent(); Spread* pSpread = pFirstNode->FindParentSpread(); Matrix ViewTrans; FIXED16 TempScale(1.0); double Dpi = m_pCapTree->GetRasteriseDPI(); // Make sure that SpanBounds is an exact multiple of pixels and is at // pixel multiples and is not zero-sized double MPPerPix = 72000.0 / Dpi; INT32 IntVal = (INT32)floor((double)SpanBounds.lo.x / MPPerPix); SpanBounds.lo.x = (INT32)floor((double)IntVal * MPPerPix); IntVal = (INT32)floor((double)SpanBounds.lo.y / MPPerPix); SpanBounds.lo.y = (INT32)floor((double)IntVal * MPPerPix); IntVal = (INT32)ceil((double)SpanBounds.hi.x / MPPerPix); SpanBounds.hi.x = (INT32)ceil((double)IntVal * MPPerPix); IntVal = (INT32)ceil((double)SpanBounds.hi.y / MPPerPix); SpanBounds.hi.y = (INT32)ceil((double)IntVal * MPPerPix); if (SpanBounds.Width() < MPPerPix) SpanBounds.hi.x = (INT32)ceil((double)SpanBounds.lo.x + MPPerPix); if (SpanBounds.Height() < MPPerPix) SpanBounds.hi.y = (INT32)ceil((double)SpanBounds.lo.y + MPPerPix); // Create a full 32bpp RGBA for the mask // This is so that the antialiased pixels are handled correctly in the mask // Rendering into a 1bpp mask only sets half of the edge pixels that an // anti-aliased render does and the mask spreading feature doesn't correctly // account for the difference GRenderBitmap MaskBitmap(SpanBounds, ViewTrans, TempScale, 32, Dpi); if (bBackground && bAlpha) { MaskBitmap.m_DoCompression = TRUE; MaskBitmap.AttachDevice(pView, NULL, pSpread); if (MaskBitmap.StartRender()) { // Save the context here so we can clear everything up later MaskBitmap.SaveContext(); // Best quality please QualityAttribute *pQualAttr = new QualityAttribute(); pQualAttr->QualityValue.SetQuality(QUALITY_MAX); MaskBitmap.SetQuality(pQualAttr, TRUE); XPFSpanRenderCallback MaskCallback(pFirstNode, pLastNode, FALSE); MaskBitmap.RenderTree(pSpread, FALSE, FALSE, &MaskCallback); // Save the context here so we can clear everything up later MaskBitmap.RestoreContext(); // Tell the render region we are done rendering MaskBitmap.StopRender(); } } GRenderBitmap BitmapRR(SpanBounds, ViewTrans, TempScale, 32, Dpi); if (!bBackground) BitmapRR.m_DoCompression = TRUE; BitmapRR.SetForceMixTransparency(bForceMix); BitmapRR.SetUsingSmoothedBitmaps(TRUE); // Make sure we do high quality BitmapRR.AttachDevice(pView, NULL, pSpread); // Start rendering into the bitmap if (BitmapRR.StartRender()) { // Save the context here so we can clear everything up later BitmapRR.SaveContext(); if (bBackground) { // Draw required background DocRect DrawRect = SpanBounds; // Inflate the rect by 2 pixels DrawRect.Inflate( (INT32)(2*72000.0/Dpi + 0.5) ); BitmapRR.SaveContext(); DocColour White(255,255,255); BitmapRR.SetFillColour(White); BitmapRR.DrawRect(&DrawRect); BitmapRR.RestoreContext(); } // Best quality please QualityAttribute *pQualAttr = new QualityAttribute(); pQualAttr->QualityValue.SetQuality(QUALITY_MAX); BitmapRR.SetQuality(pQualAttr, TRUE); // Render the relevant span of the tree TRACEUSER("Gerry", _T("Rendering nodes from 0x%08x to 0x%08x%s\n"), pFirstNode, pLastNode, bBackground ? _T(" with background") : _T("")); XPFSpanRenderCallback SpanCallback(pFirstNode, pLastNode, bBackground); BitmapRR.RenderTree(pSpread, FALSE, FALSE, &SpanCallback); // This should stop any captures BitmapRR.RestoreContext(); // Stop rendering BitmapRR.StopRender(); // Reset the layer visiblity to the correct value if (pSingleLayer) pSingleLayer->SetVisible(bOldLayerVisibility); } else { ERROR2(NULL, "StartRender failed in RenderNodesToBitmap"); } // Get the rendered OILBitmap OILBitmap* pFullBitmap = BitmapRR.ExtractBitmap(); String_256 BmpName(m_pFilter->GetNewBitmapName()); pFullBitmap->SetName(BmpName); if (bBackground && bAlpha) { // Merge in the mask info to knock out the surrounding areas OILBitmap* pMaskBitmap = MaskBitmap.ExtractBitmap(); pFullBitmap->CopyFullyTransparentFrom(pMaskBitmap); // We can't delete an OILBitmap directly so we create a // KernelBitmap and then delete that KernelBitmap* pTempBmp = KernelBitmap::MakeKernelBitmap(pMaskBitmap); delete pTempBmp; } KernelBitmap* pRealBmp = KernelBitmap::MakeKernelBitmap(pFullBitmap); // If we are converting a single NodeBitmap then maintain the lossy flag if (pSingleBitmap && pSingleBitmap->GetBitmap()) { pRealBmp->SetAsLossy(pSingleBitmap->GetBitmap()->IsLossy()); } // Attach the bitmap to this document or a copy will be created when // it is used in the NodeBitmap BitmapList* pBmpList = NULL; Document* pCurDoc = Document::GetCurrent(); if (pCurDoc) pBmpList = pCurDoc->GetBitmapList(); // and then attach the bitmap (doesn't matter if BmpList is NULL) pRealBmp->Attach(pBmpList); // Create a NodeBitmap not in the tree NodeBitmap* pNodeBmp = new NodeBitmap(); ERROR2IF(!pNodeBmp, NULL, "Failed to create NodeBitmap"); pNodeBmp->SetUpPath(); pNodeBmp->CreateShape(SpanBounds); pNodeBmp->BitmapRef.Attach(pRealBmp); // Attach the correct bitmap pNodeBmp->ApplyDefaultBitmapAttrs(NULL); // Apply the correct attrs // If we should be applying a non-mix transparency then do so if (TransToApply != TT_NoTranspType && TransToApply != TT_Mix) { AttrFlatTranspFill* pTrans = new AttrFlatTranspFill(pNodeBmp, FIRSTCHILD); if (pTrans) { pTrans->SetTranspType(TransToApply); UINT32 TransVal = 0; pTrans->SetStartTransp(&TransVal); } } if (pSingleSpread) { // Copy the spread and create a default layer Spread* pNewSpread = (Spread*)(pSingleSpread->PublicCopy()); ERROR2IF(!pNewSpread, NULL, "Failed to create Spread"); Layer* pNewLayer = new Layer(pNewSpread, FIRSTCHILD, String_256("Layer 1")); ERROR2IF(!pNewLayer, NULL, "Failed to create Layer"); // Attach the NodeBitmap as the first child of the new layer pNodeBmp->AttachNode(pNewLayer, FIRSTCHILD); // Return the new spread node return(pNewSpread); } if (pSingleLayer) { // Create a shallow copy of the layer Layer* pNewLayer = (Layer*)(pSingleLayer->PublicCopy()); ERROR2IF(!pNewLayer, NULL, "Failed to create Layer"); // Attach the NodeBitmap as the first child of the new layer pNodeBmp->AttachNode(pNewLayer, FIRSTCHILD); // Return the new layer node return(pNewLayer); } // Just return the NodeBitmap return(pNodeBmp); }

KernelBitmap * XPFRenderCallback::RenderTransToBitmap (  Node *  pNode, DocRect &  BoundsRect, UINT32 *  pTransType )  [protected]

Renders the transparency applied to the object as a greyscale bitmap so that the transparency can be replaced by a simple bitmap transparency. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 31/10/2005 Parameters: pNode  - pointer to a Node [INPUTS] BoundsRect - pTransType - pointer to a UINT32 Returns: NULL in times of grief Definition at line 2649 of file xpfrgn.cpp. { View* pView = View::GetCurrent(); Spread* pSpread = pNode->FindParentSpread(); Matrix ViewTrans; FIXED16 TempScale(1.0); double Dpi = m_pCapTree->GetRasteriseDPI(); // Make sure that BoundsRect wont end up as a zero-sized rectangle double MPPerPix = 72000.0 / Dpi; if (BoundsRect.Width() < MPPerPix) BoundsRect.hi.x = BoundsRect.lo.x + (INT32)(MPPerPix + 0.5); if (BoundsRect.Height() < MPPerPix) BoundsRect.hi.y = BoundsRect.lo.y + (INT32)(MPPerPix + 0.5); GRenderBitmap BitmapRR(BoundsRect, ViewTrans, TempScale, 32, Dpi); BitmapRR.AttachDevice(pView, NULL, pSpread); TRACEUSER( "Gerry", _T("Rendering trans as bitmap (%d, %d)\n"), (INT32)((double)BoundsRect.Width() / MPPerPix), (INT32)((double)BoundsRect.Height() / MPPerPix)); // Start rendering into the bitmap if (!BitmapRR.StartRender()) { ERROR2(NULL, "StartRender failed in RenderTransToBitmap"); } // Should draw a big white rectangle here, into the bitmap render region or // transparent objects will not fade to white where you can see the paper under them DocRect DrawRect = BoundsRect; // Inflate the rect by 2 pixels DrawRect.Inflate( (INT32)(2*72000.0/Dpi + 0.5) ); // Draw it into the real bitmap BitmapRR.SaveContext(); BitmapRR.SetFillColour(COLOUR_WHITE); BitmapRR.DrawRect(&DrawRect); // Best quality please QualityAttribute *pQualAttr = new QualityAttribute(); pQualAttr->QualityValue.SetQuality(QUALITY_MAX); BitmapRR.SetQuality(pQualAttr, TRUE); NodeAttribute* pAttr; pAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrTranspFillGeometry)); if (pAttr) { // It might be safer to create a copy of the attribute so that // the transparency type can be changed without affecting the existing // attribute but the attribute is going to get deleted anyway TranspFillAttribute* pVal = (TranspFillAttribute*)pAttr->GetAttributeValue(); if (pTransType) *pTransType = pVal->GetTranspType(); pVal->SetTranspType(TT_Mix); pAttr->Render(&BitmapRR); } pAttr = FindChildAttr(pNode, CC_RUNTIME_CLASS(AttrTranspFillMapping)); if (pAttr) pAttr->Render(&BitmapRR); BitmapRR.SetFillColour(COLOUR_BLACK); BitmapRR.SetLineColour(COLOUR_NONE); Path RectPath; if (RectPath.Initialise()) { // Start at bottom left corner RectPath.InsertMoveTo(BoundsRect.lo); RectPath.InsertLineTo(DocCoord(BoundsRect.hi.x, BoundsRect.lo.y)); RectPath.InsertLineTo(BoundsRect.hi); RectPath.InsertLineTo(DocCoord(BoundsRect.lo.x, BoundsRect.hi.y)); RectPath.InsertLineTo(BoundsRect.lo); // Close the path properly RectPath.CloseSubPath(); RectPath.IsFilled = TRUE; RectPath.IsStroked = FALSE; BitmapRR.DrawPath(&RectPath); } else { pNode->Render(&BitmapRR); } BitmapRR.RestoreContext(); // Stop rendering BitmapRR.StopRender(); OILBitmap* pFullBitmap = BitmapRR.ExtractBitmap(); String_256 BmpName = m_pFilter->GetNewBitmapName(); pFullBitmap->SetName(BmpName); KernelBitmap* pRealBmp = KernelBitmap::MakeKernelBitmap(pFullBitmap); // Attach the bitmap to this document or a copy will be created when // it is used in the attribute BitmapList* pBmpList = NULL; Document* pCurDoc = Document::GetCurrent(); if (pCurDoc) pBmpList = pCurDoc->GetBitmapList(); // and then attach the bitmap (doesn't matter if BmpList is NULL) pRealBmp->Attach(pBmpList); return(pRealBmp); }

void XPFRenderCallback::SetAttachContext (  Node *  pContext, AttachNodeDirection  Direction )  [inline]

Definition at line 262 of file xpfrgn.h. { m_pContextNode = pContext; m_Direction = Direction; }

---

Member Data Documentation

List XPFRenderCallback::m_ConvertList [private]

Definition at line 300 of file xpfrgn.h.

INT32 XPFRenderCallback::m_ConvertPass [private]

Definition at line 292 of file xpfrgn.h.

AttachNodeDirection XPFRenderCallback::m_Direction [private]

Definition at line 298 of file xpfrgn.h.

List XPFRenderCallback::m_ParentList [private]

Definition at line 301 of file xpfrgn.h.

CapabilityTree* XPFRenderCallback::m_pCapTree [private]

Definition at line 295 of file xpfrgn.h.

Node* XPFRenderCallback::m_pContextNode [private]

Definition at line 297 of file xpfrgn.h.

PluginNativeFilter* XPFRenderCallback::m_pFilter [private]

Definition at line 293 of file xpfrgn.h.

Spread* XPFRenderCallback::m_pNewSpread [private]

Definition at line 296 of file xpfrgn.h.

Node* XPFRenderCallback::m_pSpanParent [private]

Definition at line 299 of file xpfrgn.h.

XPFRenderRegion* XPFRenderCallback::m_pXPFRegion [private]

Definition at line 294 of file xpfrgn.h.

---

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

• Kernel/xpfrgn.h (r1785/r1380)
• Kernel/xpfrgn.cpp (r1785/r1708)

---