AttrBrushType Class Reference

BrushType attribute BrushType attributes are very simple, and merely contain a BrushTypeAttrValue, which is the entity which holds all the info and does all the work. More...

#include <brshattr.h>

Inheritance diagram for AttrBrushType:

List of all members.

Public Member Functions
	AttrBrushType ()
	Default constructor for AttrBrushType.
	AttrBrushType (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	Constructs an AttrBrushType Attribute.
	~AttrBrushType ()
	destructor
virtual void	Render (RenderRegion *pRender)
	Renders this attribute (by simply calling the Render function of its contained AttributeValue).
virtual void	CopyNodeContents (AttrBrushType *NodeCopy)
	Copies the node's contents to the node pointed to by NodeCopy.
virtual INT32	operator== (const NodeAttribute &NodeAttrib)
	Comparison operator - determines if the AttributeValues of both objects are ==.
virtual Node *	SimpleCopy ()
	This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes.
virtual UINT32	GetAttrNameID (void)
	Retrieves a string resource ID describing this attribute.
virtual void	GetDebugDetails (StringBase *Str)
	Produces debug details about this node.
virtual UINT32	GetNodeSize () const
	For finding the size of the node, in bytes.
virtual void	Transform (TransformBase &)
	Currently this simply flushes the cached points map.
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes out a record that represents the node, to either Native or Web file format.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
virtual AttributeValue *	GetAttributeValue ()
virtual BOOL	NeedsTransparency () const
	Strokes like the airbrush require transparency to be turned on to work.
virtual BOOL	Blend (BlendAttrParam *pBlendParam)
	Blends between two brush attributes. In fact at the moment it just blends between the parameters in the two path processors. At some point it should also blend between the ink objects and attributes.
virtual SubtreeRenderState	RenderSubtree (RenderRegion *pRender, Node **ppNextNode=NULL, BOOL bClip=TRUE)
	Basically we want to avoid the situation of recursive path processing for brushes. Therefore if there is already a path processor of the same type as this one on the stack then we should not render.
BOOL	DoBecomeA (BecomeA *pBecomeA, Node *pParent)
	Its a little unusual for attributes to have their own dobecomea function but the brush requires one because the node that it is applied to will not know anything about it. It is designed to be called by the node that has this brush applied to it. Note that all the real work goes on in the attribute value and path processor.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
virtual BOOL	EffectsParentBounds ()
	Virtual function for determining if the node will effect it's parent bounds. eg. ArrowHeads.
virtual DocRect	GetAttrBoundingRect (NodeRenderableInk *pParent=NULL, CCAttrMap *pAttribMap=NULL)
	Virtual function for determining the bounding rect of an attribute. Simply calls the brush value which does the calculation.
virtual BOOL	IsABrush () const
	For identifying this as a brush attribute.
virtual BOOL	ShouldBeOptimized ()
void	NodePathUpdated (Path *pPath)
	interface to the BrushAttrValue, called when a nodepath is updated, either flushes the cache or recalculates the timestamping points distances
BOOL	OnReplaceAttribute (AttrBrushType *pOther)
	If we are applying this attribute to a node that already has a brush attribute then we wish to retain certain information,so copy it over before we do the replacing.
String_32	GetBrushName ()
	For finding the size of the node, in bytes.
BOOL	SetSpacing (MILLIPOINT NewSpacing)
	To set the spacing between brush objects.
BOOL	SetScaling (double NewScale)
	To set the brush scaling.
BOOL	SetPathOffsetType (PathOffset NewOffsetType)
	to set the offset type for this brush
BOOL	SetPathOffsetValue (MILLIPOINT NewOffsetValue)
	to set the offset distance for this brush
BOOL	SetTiled (BOOL Tiled)
	When a brush tiles it means that the attribute types: 3 colour fill 4 colour fill bitmap fill are only rendered once per brush, rather than for every brush step.
BOOL	SetRotated (BOOL Rotated)
	as above
BOOL	SetRotateAngle (double NewAngle)
	as above
PathProcessorBrush *	GetPathProcessor ()
	as above
BrushDefinition *	GetBrushDefinition ()
	interface to the BrushAttrValue
BrushHandle	GetBrushHandle (void)
	interface to the BrushAttrValue
MILLIPOINT	GetSpacing ()
MILLIPOINT	GetDefaultLineWidth (BOOL IgnorePressure=FALSE)
	convenient interface to the attribute value
void	SetUseLocalTransp (BOOL UseTransp)
	interface to the PPB, sets a member
void	FlushCache ()
	interface to the BrushAttrValue, tells it to flush the cache of its path processor
void	SetCache (PointsMap *pMap)
	interface to the BrushAttrValue, sets the cache
PointsMap *	GetCache ()
	interface to the BrushAttrValue, gets the cache
TimeStampList *	GetTimeStampList ()
	interface to the BrushAttrValue, gets the cache
BOOL	IsTimeStamping ()
	interface to the BrushAttrValue
void	SetPressureCache (CDistanceSampler *pSamp)
	interface to the BrushAttrValue, sets the cache
CDistanceSampler *	GetPressureCache ()
	interface to the BrushAttrValue, gets the pressure cache
BOOL	ContainsPressureCache ()
	interface to the BrushAttrValue, gets the pressure cache
BOOL	ReversePressureCache ()
	Asks the attribute value to reverse its pressure list See Also: BrushAttrValue::ReversePressureList.
BOOL	CanUsePointsCache ()
	We are not allowed to use the points cache if this attribute is applied to multiple ink nodes as a part of a group. The reason for this is that the paths of the ink nodes are passed in to the path processor one by one, this means that the points along the first path are cached, and because the cache exists these points are re-used for all subsequent ink objects, meaning that only the first object gets drawn. Further conditions may be added to this at a later date. See also: PathProcessorBrush::GetPointAtDistance.
MILLIPOINT	GetAppliedLineWidth ()
	as above
void	SetValueToScaleTo (MILLIPOINT LineWidth)
	as above
DocColour	GetLocalStrokeColour ()
	Returns either the blended or local stroke colour. Given that the blended colour is null unless we are in a blend it takes priority when it does exist.
void	SetBlendedStrokeColour (DocColour *pCol)
	Tells the attribute that pCol is the stroke colour for the current blend step.
UINT32	GetLocalTranspValue ()
UINT32	GetLocalTranspType ()
void	ClearCachedRect ()
	interface to the BrushAttrValue, wipes the cached bounding rect
void	SetFreeHandTool (FreeHandTool *pTool)
void	InitialiseBrushData ()
	retrieves data from the path processor and puts it into our brushdata object
BrushData	GetBrushData ()
	gets the latest data from our path processor, copies it into our BrushData object which is then returned;
void	SetBrushData (BrushData NewData)
	Not quite sure why you would use this, as there is no link from the brush data object to the path processor at the moment. hmm.
void	GetMaxScalingFromDefinition ()
	Obtains the max scaling value from the brush definition and sets it to the path processor. This is not needed upon brush creation however it is required if you are importing a brush.
BOOL	IsParentSelected ()
	To find out if this brush belongs to an ink node that is selected. We simpy scan up the tree until we find a selected node or hit the layer.
Static Public Member Functions
static BOOL	RotateBounds (double Angle, DocRect *pBounds)
	The bounds are updated to contain the rotated version.
Protected Member Functions
void	FindNearestStrokeColour ()
	Locates the nearest stroke colour attribute, takes the colour and stores it in our member variable. Note that it also converts the colour if it is an IndexedColour.
void	FindNearestStrokeTransp ()
	Finds the local stroke transparency and caches the transparency value and type.
Protected Attributes
BrushAttrValue	m_Value
DocColour *	m_pLocalStrokeColour
DocColour *	m_pBlendedStrokeColour
BrushData	m_BrushData
FreeHandTool *	m_pFreeTool
UINT32	m_LocalTranspValue
UINT32	m_LocalTranspType

---

Detailed Description

BrushType attribute BrushType attributes are very simple, and merely contain a BrushTypeAttrValue, which is the entity which holds all the info and does all the work.

Author:

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

Date:

7/1/97

Definition at line 320 of file brshattr.h.

---

Constructor & Destructor Documentation

AttrBrushType::AttrBrushType (   )

Default constructor for AttrBrushType. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Definition at line 2852 of file brshattr.cpp. { m_pFreeTool = NULL; m_pLocalStrokeColour = NULL; m_pBlendedStrokeColour = NULL; m_LocalTranspType = 0; m_LocalTranspValue = 0; }

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

Constructs an AttrBrushType Attribute. Definition at line 2878 of file brshattr.cpp. : NodeAttribute(ContextNode, Direction, Locked, Mangled, Marked, Selected) { m_pFreeTool = NULL; m_pLocalStrokeColour = NULL; m_pBlendedStrokeColour = NULL; m_LocalTranspType = 0; m_LocalTranspValue = 0; }

AttrBrushType::~AttrBrushType (   )

destructor Definition at line 2904 of file brshattr.cpp. { // if we are a blended attribute then our processor must destroy its blended brushdefinition /*PathProcessorBrush* pPPB =*/ m_Value.GetPathProcessor(); // ask our attrval to delete its path processor m_Value.SetPathProcessor(NULL); }

---

Member Function Documentation

BOOL AttrBrushType::Blend (  BlendAttrParam *  pBlendParam  )  [virtual]

Blends between two brush attributes. In fact at the moment it just blends between the parameters in the two path processors. At some point it should also blend between the ink objects and attributes. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/3/2000 Parameters: pBlendParam  - contains the blend info, [INPUTS] pBlendParama  - containing the blended attributes [OUTPUTS] Returns: TRUE - Blend went ok, the blended attr val is valid; FALSE if not. Errors: Out of memory. Reimplemented from NodeAttribute. Definition at line 3276 of file brshattr.cpp. { // Check entry param isn't NULL ERROR3IF(pBlendParam == NULL,"NULL entry param"); if (pBlendParam == NULL) return FALSE; // Get the Value member to blend to the Value member of the other NodeAttribute. // If it succeeds, ask the blended Value to make a NodeAttribute out of itself. if (GetAttributeValue()->Blend(pBlendParam)) { // Get the blended attr val. After this call, the ptr is our reponsibility // so we have to delete it if it's no longer needed AttributeValue* pBlendedAttrVal = pBlendParam->GetBlendedAttrVal(); if (pBlendedAttrVal != NULL) { // We have a blended attr val, so ask it to make a NodeAttribute out of itself // and set the pBlendParam's blended NodeAttribute ptr to it NodeAttribute* pBlendedAttr = pBlendedAttrVal->MakeNode(); pBlendParam->SetBlendedAttr(pBlendedAttr); if (pBlendedAttr != NULL) { // We were able to make a blended NodeAttribute // so delete the blended attr val, and return TRUE ((BrushAttrValue*)pBlendedAttrVal)->SetPathProcessor(NULL); delete pBlendedAttrVal; return TRUE; } else { // Couldn't make a blended NodeAttribute, so give the blended attr val back // and return FALSE pBlendParam->SetBlendedAttrVal(pBlendedAttrVal); return FALSE; } } } return FALSE; }

BOOL AttrBrushType::CanUsePointsCache (   )

We are not allowed to use the points cache if this attribute is applied to multiple ink nodes as a part of a group. The reason for this is that the paths of the ink nodes are passed in to the path processor one by one, this means that the points along the first path are cached, and because the cache exists these points are re-used for all subsequent ink objects, meaning that only the first object gets drawn. Further conditions may be added to this at a later date. See also: PathProcessorBrush::GetPointAtDistance. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: TRUE if the we are allowed to use the points cache in the brushattrvalue, FALSE if not. Definition at line 3960 of file brshattr.cpp. { Node* pParent = FindParent(); if (pParent != NULL) { if (pParent->IsCompound() || pParent->IsABaseTextClass() || pParent->IsAContour() ) return FALSE; } return TRUE; }

void AttrBrushType::ClearCachedRect (   )

interface to the BrushAttrValue, wipes the cached bounding rect Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: - See also: - Definition at line 4390 of file brshattr.cpp. { m_Value.SetCachedRect(DocRect(0,0,0,0)); }

BOOL AttrBrushType::ContainsPressureCache (   )

interface to the BrushAttrValue, gets the pressure cache Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: pointer to the points map of the brushattrvalue See also: - Definition at line 4279 of file brshattr.cpp. { return (m_Value.GetPressureCache() != NULL); }

void AttrBrushType::CopyNodeContents (  AttrBrushType *  NodeCopy  )  [virtual]

Copies the node's contents to the node pointed to by NodeCopy. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: NodeCopy  - returned containing a copy of this node [OUTPUTS] Definition at line 3077 of file brshattr.cpp. { // Let the base class do its bit NodeAttribute::CopyNodeContents(NodeCopy); // And then copy our Value *(NodeCopy->GetAttributeValue()) = *(GetAttributeValue()); }

BOOL AttrBrushType::DoBecomeA (  BecomeA *  pBecomeA, Node *  pParent )

Its a little unusual for attributes to have their own dobecomea function but the brush requires one because the node that it is applied to will not know anything about it. It is designed to be called by the node that has this brush applied to it. Note that all the real work goes on in the attribute value and path processor. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/3/2000 Parameters: pBecomeA  - the becomeA object that tells us what to do [INPUTS] pParent - the node that this attribute is applied to [OUTPUTS]  Returns: TRUE if everything went ok, Definition at line 3339 of file brshattr.cpp. { ERROR2IF(pBecomeA == NULL, FALSE, "BecomeA pointer is NULL in AttrBrushType::DoBecomeA"); ERROR2IF(pParent == NULL, FALSE, "Parent node is NULL in AttrBrushType::DoBecomeA"); PathProcessorBrush* pPPB = m_Value.GetPathProcessor(); if (pPPB) pPPB->SetParentAttribute(this); return m_Value.DoBecomeA(pBecomeA, pParent); }

BOOL AttrBrushType::EffectsParentBounds (   )  [virtual]

Virtual function for determining if the node will effect it's parent bounds. eg. ArrowHeads. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/12/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the node will effect the bounds of it's parent. See also: NodeAttribute::GetAttrBoundingRect Reimplemented from NodeAttribute. Definition at line 3011 of file brshattr.cpp. { return TRUE; }

void AttrBrushType::FindNearestStrokeColour (   )  [protected]

Locates the nearest stroke colour attribute, takes the colour and stores it in our member variable. Note that it also converts the colour if it is an IndexedColour. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: - Definition at line 3411 of file brshattr.cpp. { NodeRenderableInk* pParent = (NodeRenderableInk*)FindParent(); if (pParent == NULL) { // ERROR3("Wheres my parent?!"); Might be a default, so don't error return; } // if its a controller we want its ink node if (pParent->IsCompoundClass()) { NodeRenderableInk* pInk = ((NodeCompound*)pParent)->GetInkNodeFromController(); if (pInk) pParent = pInk; } NodeAttribute* pStrokeColour = NULL; // get the attribute pParent->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), &pStrokeColour); if (pStrokeColour == NULL) return; // get the stroke colour StrokeColourAttribute* pVal = (StrokeColourAttribute*)pStrokeColour->GetAttributeValue(); if (pVal != NULL) { // we're only interested in the actual colour m_pLocalStrokeColour = &(pVal->Colour); } else TRACEUSER("Diccon", _T("Unable to find local stroke colour\n") ); }

void AttrBrushType::FindNearestStrokeTransp (   )  [protected]

Finds the local stroke transparency and caches the transparency value and type. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: - Definition at line 3459 of file brshattr.cpp. { m_LocalTranspValue = 0; m_LocalTranspType = 0; NodeRenderableInk* pParent = (NodeRenderableInk*)FindParent(); if (pParent == NULL || !pParent->IsAnObject()) { // ERROR3("Wheres my parent?!"); Might be a default, so don't error return; } // if its a controller we want its ink node if (pParent->IsCompoundClass()) { NodeRenderableInk* pInk = ((NodeCompound*)pParent)->GetInkNodeFromController(); if (pInk) pParent = pInk; } NodeAttribute* pStrokeTransp = NULL; // get the attribute pParent->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeTransp), &pStrokeTransp, FALSE); if (pStrokeTransp == NULL) return; // get the stroke transparency StrokeTranspAttribute* pVal = (StrokeTranspAttribute*)pStrokeTransp->GetAttributeValue(); if (pVal != NULL) { // we're only interested in the actual colour m_LocalTranspValue = *pVal->GetStartTransp(); m_LocalTranspType = pVal->GetTranspType(); } }

void AttrBrushType::FlushCache (   )

interface to the BrushAttrValue, tells it to flush the cache of its path processor Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: - See also: - Definition at line 4127 of file brshattr.cpp. { m_Value.FlushCache(); }

MILLIPOINT AttrBrushType::GetAppliedLineWidth (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the width of the nearest linewidth attribute, or -1 if there isn't one (unlikely) See also: - Definition at line 3988 of file brshattr.cpp. { MILLIPOINT ReturnVal = 0; //first get the parent NodeRenderableInk* pInk = (NodeRenderableInk*)FindParent(); // if we're under a nodeshadow controller then we need to ask it for the right ink node if (pInk != NULL && pInk->IsCompoundClass()) { NodeRenderableInk* pInkNode = ((NodeCompound*)pInk)->GetInkNodeFromController(); if (pInkNode) pInk = pInkNode; } if (pInk != NULL) { // find the applied AttrLineWidth NodeAttribute* pAttr = NULL; BOOL Found = pInk->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrLineWidth), &pAttr); if (Found && (pAttr != NULL)) { LineWidthAttribute* pVal = (LineWidthAttribute*)((AttrLineWidth*)pAttr)->GetAttributeValue(); if (pVal != NULL) ReturnVal = pVal->LineWidth; } // double check that we don't have a transparent stroke colour AttrStrokeColour* pStrokeCol = NULL; pInk->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), (NodeAttribute**)&pStrokeCol, FALSE); if (pStrokeCol) { if (pStrokeCol->Value.Colour.IsTransparent()) ReturnVal = 0; } } return ReturnVal; }

DocRect AttrBrushType::GetAttrBoundingRect (  NodeRenderableInk *  pParent = NULL, CCAttrMap *  pAttribMap = NULL )  [virtual]

Virtual function for determining the bounding rect of an attribute. Simply calls the brush value which does the calculation. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/12/99 Parameters: pParent,the  parent Ink node that this attribute will effect. [INPUTS] pAttribMap - not used -  [OUTPUTS] Returns: The Bounding rect of the attribute (NULL rectangle is it doesn't have any). See also: NodeAttribute::EffectsParentBounds Reimplemented from NodeAttribute. Definition at line 3033 of file brshattr.cpp. { ERROR2IF(pParent == NULL, DocRect(0,0,0,0) , "Parent node is NULL in AttrBrushType::GetAttrBoundingRect"); BrushAttrValue* pVal = (BrushAttrValue*)GetAttributeValue(); if (pVal == NULL) return DocRect(0, 0, 0, 0); else { // bit of a hack - the PPB needs to know that we are its parents, and if we have not yet rendered then // it may not know that yet PathProcessorBrush* pPPB = pVal->GetPathProcessor(); if (pPPB != NULL) { pPPB->SetParentAttribute(this); // set the line width MILLIPOINT Width = GetAppliedLineWidth(); if (Width > 500) { SetValueToScaleTo(Width); } else return DocRect(0, 0, 0, 0); // if its too small then just return as we'll generate infinite objects } } return pVal->GetAttrBoundingRect(pParent); }

virtual AttributeValue* AttrBrushType::GetAttributeValue (   )  [inline, virtual]

Reimplemented from NodeAttribute. Definition at line 346 of file brshattr.h. { return(&m_Value); };

UINT32 AttrBrushType::GetAttrNameID (  void   )  [virtual]

Retrieves a string resource ID describing this attribute. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: Attribute description string-resource ID Reimplemented from NodeAttribute. Definition at line 3190 of file brshattr.cpp. { return(_R(IDS_ATTRBRUSH)); }

BrushData AttrBrushType::GetBrushData (   )

gets the latest data from our path processor, copies it into our BrushData object which is then returned; Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: our brush data object See also: - Definition at line 3884 of file brshattr.cpp. { InitialiseBrushData(); return m_BrushData; }

BrushDefinition * AttrBrushType::GetBrushDefinition (  void   )

interface to the BrushAttrValue Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the brush definition used by this brush (can be NULL) See also: - Definition at line 3587 of file brshattr.cpp. { return m_Value.GetBrushDefinition(); }

BrushHandle AttrBrushType::GetBrushHandle (  void   )

interface to the BrushAttrValue Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: handle of the brush definition used by this brush (can be NULL) See also: - Definition at line 3606 of file brshattr.cpp. { return m_Value.GetBrushHandle(); }

String_32 AttrBrushType::GetBrushName (   )

For finding the size of the node, in bytes. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: The size of this node, in bytes Definition at line 3382 of file brshattr.cpp. { String_32 Name = TEXT(" "); BrushDefinition* pDef = GetBrushDefinition(); if (pDef != NULL) { String_32* pName = pDef->GetLineName(); if (pName != NULL) Name = *pName; } return Name; }

PointsMap * AttrBrushType::GetCache (   )

interface to the BrushAttrValue, gets the cache Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: pointer to the points map of the brushattrvalue See also: - Definition at line 4260 of file brshattr.cpp. { return m_Value.GetCache(); }

void AttrBrushType::GetDebugDetails (  StringBase *  Str  )  [virtual]

Produces debug details about this node. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: On  return, Str is filled in with details on this node [OUTPUTS] Reimplemented from NodeRenderable. Definition at line 3234 of file brshattr.cpp. { #ifdef _DEBUG NodeAttribute::GetDebugDetails(Str); String_256 TempStr; TempStr._MakeMsg( _T("\r\nBrush #1%s\r\n"), (m_Value.GetPathProcessor() == NULL) ? _T("old-style line") : _T("new stroke:") ); *Str += TempStr; if (m_Value.GetPathProcessor() != NULL) { TempStr._MakeMsg( _T(" #1%s\r\n"), m_Value.GetPathProcessor()->GetRuntimeClass()->GetClassName() ); *Str += TempStr; } //TempStr._MakeMsg("\r\nNeedsTransparency=#1%s\r\n", NeedsTransparency() ? "TRUE" : "FALSE"); //*Str += TempStr; TempStr._MakeMsg( _T("\r\nDefinition Handle=#1%d\r\n"), GetBrushHandle() ); *Str += TempStr; #endif }

MILLIPOINT AttrBrushType::GetDefaultLineWidth (  BOOL  IgnorePressure = FALSE  )

convenient interface to the attribute value Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the height of the largest object in this brush See also: - Definition at line 3642 of file brshattr.cpp. { return m_Value.GetDefaultLineWidth(IgnorePressure); }

DocColour AttrBrushType::GetLocalStrokeColour (   )

Returns either the blended or local stroke colour. Given that the blended colour is null unless we are in a blend it takes priority when it does exist. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: the colour of the stroke that this attribute is applied to, or a default 'blank' colour if we don't have a stroke Definition at line 3512 of file brshattr.cpp. { DocColour Col; if (m_pBlendedStrokeColour != NULL) Col = * m_pBlendedStrokeColour; else if (m_pLocalStrokeColour != NULL) Col = *m_pLocalStrokeColour; return Col; }

UINT32 AttrBrushType::GetLocalTranspType (   )

Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: the type of the local stroke transparency that we cached Definition at line 3569 of file brshattr.cpp. { return m_LocalTranspType; }

UINT32 AttrBrushType::GetLocalTranspValue (   )

Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: the value of the local stroke transparency that we cached Definition at line 3552 of file brshattr.cpp. { return m_LocalTranspValue; }

void AttrBrushType::GetMaxScalingFromDefinition (   )

Obtains the max scaling value from the brush definition and sets it to the path processor. This is not needed upon brush creation however it is required if you are importing a brush. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: - See also: - Definition at line 3927 of file brshattr.cpp. { BrushDefinition* pBrushDef = GetBrushDefinition(); if (pBrushDef != NULL) { double Max = pBrushDef->GetMaxScaling(); PathProcessorBrush* pPPB = GetPathProcessor(); if (pPPB != NULL) pPPB->SetMaxScaling(Max); } }

UINT32 AttrBrushType::GetNodeSize (   )  const [virtual]

For finding the size of the node, in bytes. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: The size of this node, in bytes Reimplemented from Node. Definition at line 3363 of file brshattr.cpp. { return(sizeof(AttrBrushType)); }

PathProcessorBrush * AttrBrushType::GetPathProcessor (  void   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the path processor belonging to the attribute value See also: - Definition at line 3841 of file brshattr.cpp. { return m_Value.GetPathProcessor(); }

CDistanceSampler * AttrBrushType::GetPressureCache (   )

interface to the BrushAttrValue, gets the pressure cache Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: pointer to the points map of the brushattrvalue See also: - Definition at line 4297 of file brshattr.cpp. { return m_Value.GetPressureCache(); }

MILLIPOINT AttrBrushType::GetSpacing (   )

Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the current brush spacing value See also: - Definition at line 3684 of file brshattr.cpp. { PathProcessorBrush* pPathProc = m_Value.GetPathProcessor(); if (pPathProc == NULL) return -1; return (MILLIPOINT)pPathProc->GetSpacing(); }

TimeStampList * AttrBrushType::GetTimeStampList (   )

interface to the BrushAttrValue, gets the cache Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: pointer to the timestamp points list of the brushattrvalue See also: - Definition at line 4353 of file brshattr.cpp. { return m_Value.GetTimeStampList(); }

void AttrBrushType::InitialiseBrushData (   )

retrieves data from the path processor and puts it into our brushdata object Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: - See also: - Definition at line 3861 of file brshattr.cpp. { PathProcessorBrush* pPPB = GetPathProcessor(); if (pPPB != NULL) pPPB->CopyBrushData(&m_BrushData); }

BOOL AttrBrushType::IsABrush (   )  const [virtual]

For identifying this as a brush attribute. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: TRUE Reimplemented from Node. Definition at line 3623 of file brshattr.cpp. { return TRUE; }

BOOL AttrBrushType::IsParentSelected (   )

To find out if this brush belongs to an ink node that is selected. We simpy scan up the tree until we find a selected node or hit the layer. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: TRUE if any ancestor of the brush attribute is selected, FALSE otherwise See also: - Definition at line 4213 of file brshattr.cpp. { BOOL Retval = FALSE; Node* pParent = FindParent(); while (pParent !=