CCAttrMap Class Reference

Class that encapsulates lists of attributes in Camelot. More...

#include <attrmap.h>

Inheritance diagram for CCAttrMap:

List of all members.

Public Types
typedef CMapPtrToPtr::iterator	iterator
Public Member Functions
	CCAttrMap (size_t nBlockSize=10)
iterator	GetStartPosition ()
iterator	GetEndPosition ()
void	GetNextAssoc (iterator &iter, CCRuntimeClass *&pClass, void *&pValue) const
bool	Lookup (CCRuntimeClass *pKey, void *&pVal)
bool	RemoveKey (CCRuntimeClass *pKey)
void	SetAt (CCRuntimeClass *pKey, void *pValue)
size_t	GetCount () const
void	RemoveAll ()
void	DeleteAttributes ()
	Deletes all the attributes within this map.
CCAttrMap *	Copy ()
	Copies all the attributes within this map into a new CCAttrMap. A ptr to the new map is returned, or NULL if it fails.
void	Render (RenderRegion *pRegion, BOOL RenderOffscreenAttributes=TRUE)
	Renders the attribute map into the given render region.
void	BuildListOfAttributes (List *pList)
	Builds a list of NodeListItems of all the attributes in this attribute map Notes: Includes all attributes - even those which can't be applied to objects Use CanBeAppliedToObject to test.
void	Transform (TransformBase &Trans)
	Applies the given transform to all the attrs in this map.
NodeAttribute *	FindAttribute (NodeAttribute *pTypeAttr)
	Call to retrieve a ptr to the attribute of the supplied type Notes:.
NodeAttribute *	ReplaceAttribute (NodeAttribute *pNewAttr)
	Directly replaces the attribute in this map with the given one Notes:.
void	RemoveAttribute (CCRuntimeClass *pAttrClass)
	Removes and Deletes the given attribute type Notes:.
void	TransformForBrush (TransformBase &Trans)
	Applies the given transform to all the attrs in this map that need to be rendered at every step of a brush or a blend. This allows us to tile as things such as bitmap fills remain in the same place always.
void	TransformBrushFills (TransformBase &Trans)
	Applies the transform to all the attributes that do not have to render for each brush step.
BOOL	WillScaleLineWidthToZero (TransformBase &Trans)
	As above, this can be useful information as if we pass GDraw a line width of zero it reverts to zero quality.
void	ApplyAttributesToNode (NodeRenderableInk *pNode)
void	PostBlendInit (Path *pPath, CCRuntimeClass *pCreatorClass)
void	PostBlendDeinit ()
void	AttachGeometryLinkedAttrs (Node *pContext)
void	RemoveGeometryLinkedAttrs ()
BOOL	IsSeeThrough ()
	Test each of the attributes in this map for see-through-ness. This is not the same as transparency - what it means is: if I draw something in white, then draw its outline as retrieved from PathBecomeA in black over the top, will I still be able to see white bits? IsSeeThrough() therefore depends partly on the implementation of PathBecomeA.
Static Public Member Functions
static CCAttrMap *	MakeAppliedAttrMap (NodeRenderableInk *pInkNode, BOOL ExcludeIndirectlyAppliedGLAs=TRUE, BOOL bStrictEffectStatus=TRUE)
	This creates a new CCAttrMap and fills it with ptrs to applied attrs of pInkNode.
static CCAttrMap *	MakeAttrMapFromRenderRegion (RenderRegion *pRegion)
	Makes an attribute out of the render region's current attribute state Notes: You MUST call DeleteAttributes afterwards to release memory - delete is not sufficient.
Public Attributes
Node *	attrMapCreator
Private Attributes
CMapPtrToPtr	m_mapAttr

---

Detailed Description

Class that encapsulates lists of attributes in Camelot.

Author:

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

Date:

11/1/95

Definition at line 126 of file attrmap.h.

---

Member Typedef Documentation

typedef CMapPtrToPtr::iterator CCAttrMap::iterator

Definition at line 134 of file attrmap.h.

---

Constructor & Destructor Documentation

CCAttrMap::CCAttrMap (  size_t  nBlockSize = 10  )  [inline]

Definition at line 131 of file attrmap.h. { attrMapCreator = NULL; }

---

Member Function Documentation

void CCAttrMap::ApplyAttributesToNode (  NodeRenderableInk *  pNode  )

Definition at line 643 of file attrmap.cpp. { iterator pos = GetStartPosition(); while( pos != GetEndPosition() ) { CCRuntimeClass *pKey; void *pVal; GetNextAssoc(pos, pKey, pVal); NodeAttribute * pAttr = (NodeAttribute *)pVal; // copy the attribute if( pAttr->CanBeAppliedToObject() ) { NodeAttribute * pAttrCopy = NULL; pAttr->NodeCopy((Node **)(&pAttrCopy)); pAttrCopy->AttachNode(pInk, LASTCHILD); // nb now that GLAs have an independent flag to indicate when // they are copied from the default, it is safe to fix linkages // this ensures that GLA defaults get copied when BlendRefs are // made from complex nodes, and that they are found when MakeAppliedAttributes // calls FindAppliedAttributes on the unattached subtree // TODO?? // What about just copying compound node's Parent pointers to // pseudo attach the tree, rather than copying applied attrs to unattached tree // Just need to watch when deleting that it doesn't do anything to the // parents pointers - which it shouldn't surely? pAttrCopy->LinkToGeometry(pInk); } } }

void CCAttrMap::AttachGeometryLinkedAttrs (  Node *  pContext  )

Definition at line 745 of file attrmap.cpp. { INT32 curr = 0; do { CCRuntimeClass *pType = (CCRuntimeClass *)GeometryLinkedAttributeClasses[curr]; void *pVal; if (Lookup(pType,pVal)) { if (pVal != NULL) { ((NodeAttribute*)pVal)->LinkToGeometry(pContext); } } curr++; } while(curr<NumGLAs); }

void CCAttrMap::BuildListOfAttributes (  List *  pList  )

Builds a list of NodeListItems of all the attributes in this attribute map Notes: Includes all attributes - even those which can't be applied to objects Use CanBeAppliedToObject to test. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/99 Parameters: The  list to use [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 474 of file attrmap.cpp. { iterator pos = GetStartPosition(); NodeListItem *pItem = NULL; while( pos != GetEndPosition() ) { CCRuntimeClass *pKey; void *pVal; GetNextAssoc( pos, pKey, pVal ); pItem = new NodeListItem((NodeAttribute *)pVal); pList->AddTail(pItem); } }

CCAttrMap * CCAttrMap::Copy (   )

Copies all the attributes within this map into a new CCAttrMap. A ptr to the new map is returned, or NULL if it fails. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/96 Parameters: [INPUTS]  -  [OUTPUTS] Returns: Ptr to a new CCAttrMap, or NULL if it fails The new map contains a list of attrs that are not attached in the tree. If the attrs are not needed or used (e.g. not inserted into the tree) make sure you delete the attrs via DeleteAttributes() before deleting the CCAttrMap, otherwise memory leaks will occur. See also: CCAttrMap::DeleteAttributes() Definition at line 178 of file attrmap.cpp. { CCAttrMap *pNewAttrMap = new CCAttrMap( GetCount() ); if( pNewAttrMap != NULL ) { // iterating all (key, value) pairs for( iterator Pos = GetStartPosition(); Pos != GetEndPosition(); ) { CCRuntimeClass *pType; void *pVal; GetNextAssoc( Pos, pType, pVal ); // Get the attribute value of this attribute NodeAttribute* pAttr = (NodeAttribute*)pVal; // Copy the attribute NodeAttribute* pNewAttr = (NodeAttribute*) (pAttr->SimpleCopy()); // Stick the new attr into the new attr map if (pNewAttr != NULL) pNewAttrMap->SetAt(pNewAttr->GetAttributeType(),pNewAttr); } } pNewAttrMap->attrMapCreator = attrMapCreator; return pNewAttrMap; }

void CCAttrMap::DeleteAttributes (   )

Deletes all the attributes within this map. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/96 Parameters: [INPUTS]  -  [OUTPUTS] Returns: - NOTE: THIS CAN BE DANGEROUS. Only delete the attributes within this map if you know for sure that they are not being used. This usually means only delete if the attrs in this map are not in the tree. The blend system generates attrs out of the tree, so they can be deleted. NodeRenderableInk::FindAppliedAttributes() finds a list of attrs in the tree and therefore should not be deleted via this call. See also: CCAttrMap::Copy() Definition at line 137 of file attrmap.cpp. { CCRuntimeClass *pType; void *pVal; // iterating all (key, value) pairs for( iterator Pos = GetStartPosition(); Pos != GetEndPosition(); ) { // Get attr at position Pos GetNextAssoc( Pos, pType, pVal ); if (pVal != NULL) { RemoveKey(pType); // Must cast to NodeAttribute before deleting, otherwise wrong destructor gets called delete (NodeAttribute*)pVal; } } }

NodeAttribute * CCAttrMap::FindAttribute (  NodeAttribute *  pTypeAttr  )

Call to retrieve a ptr to the attribute of the supplied type Notes:. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 15/6/2000 Parameters: The  attribute type that we are to find. [INPUTS] The  attribute that matches this attribute type [OUTPUTS] Returns: - See also: - Definition at line 507 of file attrmap.cpp. { void* ptrToAttr = NULL; if( Lookup( pTypeAttr->GetAttributeType(), ptrToAttr ) ) { return (NodeAttribute *)ptrToAttr; } return (NULL); }

size_t CCAttrMap::GetCount (   )  const [inline]

Definition at line 176 of file attrmap.h. { return m_mapAttr.size(); }

iterator CCAttrMap::GetEndPosition (   )  [inline]

Definition at line 139 of file attrmap.h. { return m_mapAttr.end(); }

void CCAttrMap::GetNextAssoc (  iterator &  iter, CCRuntimeClass *&  pClass, void *&  pValue )  const [inline]

Definition at line 144 of file attrmap.h. { pClass = (CCRuntimeClass *)iter->first; pValue = iter->second; ++iter; }

iterator CCAttrMap::GetStartPosition (   )  [inline]

Definition at line 135 of file attrmap.h. { return m_mapAttr.begin(); }

BOOL CCAttrMap::IsSeeThrough (   )

Test each of the attributes in this map for see-through-ness. This is not the same as transparency - what it means is: if I draw something in white, then draw its outline as retrieved from PathBecomeA in black over the top, will I still be able to see white bits? IsSeeThrough() therefore depends partly on the implementation of PathBecomeA. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 19/02/2001 Returns: TRUE if at least one of our attrs IsSeeThrough(), FALSE otherwise. Examples: Transparency is always see-through unless it is a zero transparency. Line width is not see through - PathBecomeA can cope with this attr. Fill colour is not see-through unless it is COLOUR_NONE. Brush attrs are normally see-through, as PathBecomeA ignores them. See Also: NodeRenderableInk::IsSeeThrough() Definition at line 817 of file attrmap.cpp. { CCRuntimeClass *pKey; void *pVal; BOOL bIsSeeThrough = FALSE; for ( iterator pos = GetStartPosition(); pos != GetEndPosition() && !bIsSeeThrough; ) { GetNextAssoc(pos, pKey, pVal); NodeAttribute* pAttr = (NodeAttribute*)pVal; bIsSeeThrough = pAttr->IsSeeThrough(FALSE); } return bIsSeeThrough; }

bool CCAttrMap::Lookup (  CCRuntimeClass *  pKey, void *&  pVal )  [inline]

Definition at line 151 of file attrmap.h. { iterator iter = m_mapAttr.find( pKey ); if( m_mapAttr.end() == iter ) return false; pVal = iter->second; return true; }

CCAttrMap * CCAttrMap::MakeAppliedAttrMap (  NodeRenderableInk *  pInkNode, BOOL  ExcludeIndirectlyAppliedGLAs = TRUE, BOOL  bStrictEffectStatus = TRUE )  [static]

This creates a new CCAttrMap and fills it with ptrs to applied attrs of pInkNode. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 15/1/96 Parameters: pInkNode  = ptr to an ink node [INPUTS] ExcludeIndirectlyAppliedGLAs - whether they should be excluded from this attrmap -  [OUTPUTS] Returns: Ptr to a new CCAttrMap, or NULL if it fails pInkNode must be a node that is inserted in the tree, and is not hidden. It is the caller's responsibility to delete the returned CCAttrMap. Note: As the map contains ptrs to attrs in the tree. Do not call DeleteAttributes() on the returned CCAttrMap See also: CCAttrMap::Copy() Definition at line 231 of file attrmap.cpp. { ERROR2IF(pInkNode == NULL,NULL,"pInkNode is NULL"); // ERROR2IF(pInkNode->FindParent() == NULL,NULL,"pInkNode has no parent"); CCAttrMap* pAttrMap = new CCAttrMap(30); if (pAttrMap != NULL) { if (!pInkNode->FindAppliedAttributes(pAttrMap, 5000, NULL, ExcludeIndirectlyAppliedGLAs, bStrictEffectStatus)) { delete pAttrMap; pAttrMap = NULL; } else { pAttrMap->attrMapCreator = (Node*) pInkNode; } } return pAttrMap; }

CCAttrMap * CCAttrMap::MakeAttrMapFromRenderRegion (  RenderRegion *  pRegion  )  [static]

Makes an attribute out of the render region's current attribute state Notes: You MUST call DeleteAttributes afterwards to release memory - delete is not sufficient. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 24/2/2000 Parameters: The  render region to get the attribute map from [INPUTS] An  attribute map (copied) from the render region [OUTPUTS] Returns: - See also: - Definition at line 598 of file attrmap.cpp. { CCAttrMap * pMap = new CCAttrMap; ENSURE(pMap,"No mem for attrmap"); if(!pMap) return NULL; // let's get every attribute in the render region AttributeValue * pAttrVal = NULL; NodeAttribute * pNewAttr = NULL; for (UINT32 i = 0; i < ATTR_FIRST_FREE_ID; i++) { pAttrVal = pRegion->GetCurrentAttribute(i); // make a new node out of this attribute value pNewAttr = pAttrVal->MakeNode(); // Karim 12/04/2000 // AttributeValues _do_not_have_to_have_ a corresponding NodeAttribute, // so can we please *check* that MakeNode didn't just return NULL! if (pNewAttr != NULL) { if(!pNewAttr->IsLinkedToNodeGeometry()) pMap->SetAt(pNewAttr->GetAttributeType(),pNewAttr); else { delete pNewAttr; pNewAttr = AttributeManager::GetDefaultAttribute((AttrIndex) i); if(pNewAttr) { ENSURE(pNewAttr->IsLinkedToNodeGeometry(),"Incorrect NodeAttribute returned by GetDefaultAttribute"); pMap->SetAt(pNewAttr->GetAttributeType(), pNewAttr); } else return NULL; } } } pMap->attrMapCreator = NULL; return pMap; }

void CCAttrMap::PostBlendDeinit (   )

Definition at line 720 of file attrmap.cpp. { INT32 curr = 0; do { CCRuntimeClass *pType = (CCRuntimeClass *)GeometryLinkedAttributeClasses[curr]; void *pVal; if( Lookup( pType, pVal ) ) { if (pVal != NULL) { NodeAttribute * pAttr = (NodeAttribute *)pVal; pAttr->PostDynCreateDeInit(); } } curr++; } while(curr<NumGLAs); }

void CCAttrMap::PostBlendInit (  Path *  pPath, CCRuntimeClass *  pCreatorClass )

Definition at line 682 of file attrmap.cpp. { INT32 curr = 0; // NB this function is called on a Blended attr map // The Blend() function should return false if it doesn't want to be in the blended attr map // ie default GLAs shouldn't be in here! do { CCRuntimeClass *pType = (CCRuntimeClass *)GeometryLinkedAttributeClasses[curr]; void *pVal; if( Lookup( pType, pVal ) ) { if (pVal != NULL) { NodeAttribute * pAttr = (NodeAttribute *)pVal; // call the attributes routine to initialise itself if(!pAttr->PostDynCreateInit(this, pPath, pCreatorClass)) { // make sure the node is not going to try and render itself TRACEUSER( "Ilan", wxT("Dynamically created attribute failed to post init itself. Removing attribute from map.\n") ); // NB map must contain copied attrs RemoveKey( pType ); // Must cast to NodeAttribute before deleting, otherwise wrong destructor gets called delete (NodeAttribute*)pVal; } } } curr++; } while(curr<NumGLAs); }

void CCAttrMap::RemoveAll (   )  [inline]

Definition at line 181 of file attrmap.h. { return m_mapAttr.clear(); }

void CCAttrMap::RemoveAttribute (  CCRuntimeClass *  pAttrClass  )

Removes and Deletes the given attribute type Notes:. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 04/11/2005 Parameters: The  attribute class to remove [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 567 of file attrmap.cpp. { NodeAttribute* pOldAttr = NULL; if( Lookup( pAttrClass, (void*&)pOldAttr ) ) { if (pOldAttr) delete pOldAttr; // We need to Remove and Delete the existing Stroke Colour Attr RemoveKey( pAttrClass ); } }

void CCAttrMap::RemoveGeometryLinkedAttrs (   )

Definition at line 767 of file attrmap.cpp. { INT32 curr = 0; do { CCRuntimeClass *pType = (CCRuntimeClass *)GeometryLinkedAttributeClasses[curr]; void *pVal; if( Lookup( pType, pVal ) ) { if (pVal != NULL) { RemoveKey( pType ); delete (NodeAttribute*)pVal; } } curr++; } while(curr<NumGLAs); }

bool CCAttrMap::RemoveKey (  CCRuntimeClass *  pKey  )  [inline]

Definition at line 161 of file attrmap.h. { iterator iter = m_mapAttr.find( pKey ); if( m_mapAttr.end() == iter ) return false; m_mapAttr.erase( iter ); return true; }

void CCAttrMap::Render (  RenderRegion *  pRegion, BOOL  RenderOffscreenAttributes = TRUE )

Renders the attribute map into the given render region. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/99 Parameters: pRegion  render-region to render into. [INPUTS] RenderOffscreenAttributes whether or not to render offscreen attributes, eg feathers. -  [OUTPUTS] Returns: - Notes: Karim 15/11/2000 Modified so that I can render an attribute map *without* rendering any offscreen attributes contained therein. See also: - Definition at line 436 of file attrmap.cpp. { // OK, we have found the full quota of attributes. Now render them all. iterator pos = GetStartPosition(); while( pos != GetEndPosition() ) { CCRuntimeClass *pKey; void *pVal; GetNextAssoc( pos, pKey, pVal ); NodeAttribute* pAttr = (NodeAttribute*)pVal; if ( pAttr->CanBeAppliedToObject() && pAttr->RenderSubtree(pRegion)==SUBTREE_ROOTONLY ) { // render all attributes, unless we've been specifically asked // not to render offscreen attributes. if (RenderOffscreenAttributes || !pAttr->IsAnOffscreenAttribute()) pAttr->Render(pRegion); } } }

NodeAttribute * CCAttrMap::ReplaceAttribute (  NodeAttribute *  pNewAttr  )

Directly replaces the attribute in this map with the given one Notes:. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 10/12/99 Parameters: The  attribute to replace [INPUTS] The  old attribute - in case it needs deleting [OUTPUTS] Returns: - See also: - Definition at line 534 of file attrmap.cpp. { void* pOldAttr = NULL; if( Lookup( pNewAttr->GetAttributeType(), pOldAttr ) ) { // We need to Remove and Delete the existing Stroke Colour Attr RemoveKey( pNewAttr->GetAttributeType() ); } // Add the new attr into the attr map SetAt( pNewAttr->GetAttributeType(), (void*)pNewAttr ); return (NodeAttribute *)pOldAttr; }

void CCAttrMap::SetAt (  CCRuntimeClass *  pKey, void *  pValue )  [inline]

Definition at line 171 of file attrmap.h. { m_mapAttr[pKey] = pValue; }

void CCAttrMap::Transform (  TransformBase &  Trans  )

Applies the given transform to all the attrs in this map. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/99 Parameters: Trans  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 273 of file attrmap.cpp. { CCRuntimeClass *pType; void *pVal; for( iterator Pos = GetStartPosition(); Pos != GetEndPosition(); ) { GetNextAssoc(Pos,pType,pVal); if (pVal != NULL) { NodeAttribute* pNodeAttr = (NodeAttribute *)pVal; pNodeAttr->Transform(Trans); } } }

void CCAttrMap::TransformBrushFills (  TransformBase &  Trans  )

Applies the transform to all the attributes that do not have to render for each brush step. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/99 Parameters: Trans  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 348 of file attrmap.cpp. { CCRuntimeClass *pType; void *pVal; for( iterator Pos = GetStartPosition(); Pos != GetEndPosition(); ) { GetNextAssoc(Pos,pType,pVal); if (pVal != NULL) { NodeAttribute* pNodeAttr = (NodeAttribute *)pVal; // check that we are not about to set line width to zero if( pNodeAttr->IsALineWidthAttr() && Trans.TransLines != FALSE ) { INT32 Test = labs( INT32(Trans.GetScalar().MakeDouble() * ((AttrLineWidth*)pNodeAttr)->Value.LineWidth) ); if (Test <= 10) Trans.TransLines = FALSE; } if (!pNodeAttr->NeedsToRenderAtEachBrushStroke()) pNodeAttr->Transform(Trans); } } }

void CCAttrMap::TransformForBrush (  TransformBase &  Trans  )

Applies the given transform to all the attrs in this map that need to be rendered at every step of a brush or a blend. This allows us to tile as things such as bitmap fills remain in the same place always. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/99 Parameters: Trans  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 304 of file attrmap.cpp. { CCRuntimeClass *pType; void *pVal; for( iterator Pos = GetStartPosition(); Pos != GetEndPosition(); ) { GetNextAssoc(Pos,pType,pVal); if (pVal != NULL) { NodeAttribute* pNodeAttr = (NodeAttribute *)pVal; // check that we are not about to set line width to zero if( pNodeAttr->IsALineWidthAttr() && Trans.TransLines != FALSE ) { double Test = Trans.GetScalar().MakeDouble() * (double)((AttrLineWidth*)pNodeAttr)->Value.LineWidth; // TRACEUSER( "Diccon", _T("Scale line width by %f\n"), Test); if (Test <= 1.0) { // TRACEUSER( "Diccon", _T("Setting line width scaling OFF\n")); Trans.TransLines = FALSE; } } if (pNodeAttr->NeedsToRenderAtEachBrushStroke()) pNodeAttr->Transform(Trans); } } }

BOOL CCAttrMap::WillScaleLineWidthToZero (  TransformBase &  Trans  )

As above, this can be useful information as if we pass GDraw a line width of zero it reverts to zero quality. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/99 Parameters: Trans  - the transformation we wish to test [INPUTS] -  [OUTPUTS] Returns: TRUE if this transformation will scale the line width in this map to zero or not See also: - Definition at line 391 of file attrmap.cpp. { // first look up the line width AttrLineWidth* pLineWidth = NULL; Lookup( CC_RUNTIME_CLASS(AttrLineWidth), (void*&)pLineWidth ); // if we don't have a line width then we're obviously not going to scale it to zero if (pLineWidth == NULL) return FALSE; // also look up the stroke colour, if it is fully transparent then the line // is invisible anyway AttrStrokeColour* pStrokeCol = NULL; Lookup( CC_RUNTIME_CLASS(AttrStrokeColour), (void*&)pStrokeCol ); if (pStrokeCol && pStrokeCol->Value.Colour.IsTransparent()) return FALSE; double ScaleFactor = Trans.GetScalar().MakeDouble(); INT32 ScaleVal = (INT32)(ScaleFactor * (double)pLineWidth->Value.LineWidth); if (ScaleVal < 1) return TRUE; return FALSE; }

---

Member Data Documentation

Node* CCAttrMap::attrMapCreator

Definition at line 233 of file attrmap.h.

CMapPtrToPtr CCAttrMap::m_mapAttr [private]

Definition at line 236 of file attrmap.h.

---

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

• Kernel/attrmap.h (r1785/r751)
• Kernel/attrmap.cpp (r1785/r1282)

---