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);