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 != NULL && !pParent->IsLayer()) { if (pParent->IsSelected()) { Retval = TRUE; break; } pParent = pParent->FindParent(); } return Retval; }

BOOL AttrBrushType::IsTimeStamping (   )

interface to the BrushAttrValue Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: TRUE if we are timestamping, or FALSE if not See also: - Definition at line 4371 of file brshattr.cpp. { return m_Value.IsTimeStamping(); }

BOOL AttrBrushType::NeedsTransparency (   )  const [virtual]

Strokes like the airbrush require transparency to be turned on to work. Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 7/2/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if this Attribute requires transparency mode to render properly. Errors: - Reimplemented from Node. Definition at line 3207 of file brshattr.cpp. { BOOL SoWeDoReallyNeedTransparencyThenDoWe = FALSE; PathProcessorBrush *pPathProc = m_Value.GetPathProcessor(); if(pPathProc != NULL) { SoWeDoReallyNeedTransparencyThenDoWe = pPathProc->NeedsTransparency(); } return SoWeDoReallyNeedTransparencyThenDoWe; }

void AttrBrushType::NodePathUpdated (  Path *  pPath  )

interface to the BrushAttrValue, called when a nodepath is updated, either flushes the cache or recalculates the timestamping points distances Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: InkPath  of the nodepath [INPUTS] Returns: - See also: - Definition at line 4185 of file brshattr.cpp. { // so far as coordinates go, if we are not timestamping then we just flush our cache if (!IsTimeStamping()) m_Value.FlushCache(); else m_Value.RecalculateTimeStampList(pPath); // clear our cached bounding rect m_Value.SetCachedRect(DocRect(0,0,0,0)); }

BOOL AttrBrushType::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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pOther  - the attribute we are about to replace [INPUTS] Returns: TRUE if successful, FALSE otherwise See also: - Definition at line 4147 of file brshattr.cpp. { ERROR2IF(pOther == NULL, FALSE, "Null input pointer to AttrBrushType::OnReplaceAttribute"); PathProcessorBrush* pOldPPB = pOther->GetPathProcessor(); PathProcessorBrush* pNewPPB = GetPathProcessor(); if (pOldPPB != NULL && pNewPPB != NULL) { pNewPPB->SetUseLocalFillColour(pOldPPB->GetUseLocalFillColour()); pNewPPB->SetUseNamedColours(pOldPPB->GetUseNamedColours()); } // if we have a pressure cache then we want to copy that, also use local colour flags CDistanceSampler* pPressure = pOther->GetPressureCache(); if (pPressure) { CDistanceSampler* pCopyPressure = pPressure->MakeCopy(); if (pCopyPressure) SetPressureCache(pCopyPressure); } return TRUE; }

INT32 AttrBrushType::operator== (  const NodeAttribute &  NodeAttrib  )  [virtual]

Comparison operator - determines if the AttributeValues of both objects are ==. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: NodeAttrib  - The node to compare this node to [INPUTS] Returns: TRUE if the nodes are considered equal Reimplemented from NodeAttribute. Definition at line 3125 of file brshattr.cpp. { // First check they are of the same type if (((NodeAttribute*)&NodeAttrib)->GetAttributeType() != GetAttributeType()) return FALSE; // Make a more sensible pointer AttrBrushType *Attr = (AttrBrushType *) &NodeAttrib; // Now let the AttributeValues compare themselves return( *((BrushAttrValue *) Attr->GetAttributeValue()) == *((BrushAttrValue *) GetAttributeValue()) ); }

void AttrBrushType::PolyCopyNodeContents (  NodeRenderable *  pNodeCopy  )  [virtual]

Polymorphically copies the contents of this node to another. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/12/2003 Parameters: -  [OUTPUTS] Returns: Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Reimplemented from NodeRenderable. Definition at line 3100 of file brshattr.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, AttrBrushType), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, AttrBrushType)) CopyNodeContents((AttrBrushType*)pNodeCopy); }

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

Renders this attribute (by simply calling the Render function of its contained AttributeValue). Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Reimplemented from NodeAttribute. Definition at line 2927 of file brshattr.cpp. { // what it says FindNearestStrokeTransp(); // tell the processor who it belongs to PathProcessorBrush* pPPB = m_Value.GetPathProcessor(); if (pPPB != NULL) pPPB->SetParentAttribute(this); if (m_pFreeTool != NULL) { String_32 ProgressString = _T("Processing Brush"); Progress Hourglass(&ProgressString, -1, FALSE); TRACEUSER("Diccon", _T("About to do first render\n") ); GetAttributeValue()->Render(pRender); // if we have pressure then we must invalidate our parent nodepath Node* pParent = FindParent(); if (pParent != NULL && pParent->IsNodePath() && ContainsPressureCache()) { ((NodeRenderableInk*)pParent)->InvalidateBoundingRect(); } m_pFreeTool = NULL; } else { #ifdef NEWFASTBRUSHES BrushAttrValue* pAttr = (BrushAttrValue*) GetAttributeValue(); pAttr->SetBoundsParent (FindParent ()); #endif GetAttributeValue()->Render(pRender); } }

SubtreeRenderState AttrBrushType::RenderSubtree (  RenderRegion *  pRender, Node **  ppNextNode = NULL, BOOL  bClip = TRUE )  [virtual]

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. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 07/02/94 Parameters: pRender  - A pointer to the current render region [INPUTS] Returns: TRUE => This node should be rendered, FALSE => This node does not need to be rendered. See also: Node::NeedsToRender Reimplemented from NodeAttribute. Definition at line 2981 of file brshattr.cpp. { // BOOL Retval = TRUE; PathProcessorBrush* pPPB = GetPathProcessor(); if (pPPB != NULL) { // pRender can legally be null, but we don't want to proliferate passing null pointers around if (pRender != NULL && pPPB->IsThisPathProcessorOnTheStack(pRender)) return SUBTREE_NORENDER; } return SUBTREE_ROOTONLY; }

BOOL AttrBrushType::ReversePressureCache (   )

Asks the attribute value to reverse its pressure list See Also: BrushAttrValue::ReversePressureList. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if all went well, otherwise false Definition at line 4334 of file brshattr.cpp. { CDistanceSampler* pCache = GetPressureCache(); return pCache->ReverseData(); }

BOOL AttrBrushType::RotateBounds (  double  Angle, DocRect *  pBounds )  [static]

The bounds are updated to contain the rotated version. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 8/2/2000 Parameters: Bounds  = the bounds to rotate [INPUTS] Angle = the angle in degrees by which to rotate it by Bounds  is updated [OUTPUTS] Returns: TRUE, unless you try to pass in a dud rect See also: - Definition at line 4416 of file brshattr.cpp. { ERROR2IF(pBounds == NULL, FALSE, "DocRect is NULL"); if (Angle != 0.0) { DocCoord BBCentre = pBounds->Centre(); DocCoord Coords[4]; Coords[0].x = pBounds->lo.x; Coords[0].y = pBounds->lo.y; Coords[1].x = pBounds->hi.x; Coords[1].y = pBounds->lo.y; Coords[2].x = pBounds->hi.x; Coords[2].y = pBounds->hi.y; Coords[3].x = pBounds->lo.x; Coords[3].y = pBounds->hi.y; Trans2DMatrix Rotate(BBCentre,Angle); Rotate.Transform(Coords,4); pBounds->lo.x = min(min(Coords[0].x,Coords[1].x), min(Coords[2].x,Coords[3].x)); pBounds->hi.x = max(max(Coords[0].x,Coords[1].x), max(Coords[2].x,Coords[3].x)); pBounds->lo.y = min(min(Coords[0].y,Coords[1].y), min(Coords[2].y,Coords[3].y)); pBounds->hi.y = max(max(Coords[0].y,Coords[1].y), max(Coords[2].y,Coords[3].y)); } return TRUE; }

void AttrBrushType::SetBlendedStrokeColour (  DocColour *  pCol  )

Tells the attribute that pCol is the stroke colour for the current blend step. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pointer  to stroke colour in the blend [INPUTS] Returns: - Definition at line 3535 of file brshattr.cpp. { m_pBlendedStrokeColour = pCol; }

void AttrBrushType::SetBrushData (  BrushData  Data  )

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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Data  object to set [INPUTS] Returns: - See also: - Definition at line 3906 of file brshattr.cpp. { m_BrushData = Data; }

void AttrBrushType::SetCache (  PointsMap *  pMap  )

interface to the BrushAttrValue, sets the cache Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: - See also: - Definition at line 4242 of file brshattr.cpp. { m_Value.SetCache(pMap); }

void AttrBrushType::SetFreeHandTool (  FreeHandTool *  pTool  )

Definition at line 4396 of file brshattr.cpp. { m_pFreeTool = pTool; }

BOOL AttrBrushType::SetPathOffsetType (  PathOffset  NewOffsetType  )

to set the offset type for this brush Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Inputs Offset - the offset type to set Returns: - Definition at line 3726 of file brshattr.cpp. { PathProcessorBrush* pPathProc = m_Value.GetPathProcessor(); if (pPathProc == NULL) return FALSE; pPathProc->SetPathOffsetType(NewOffsetType); return TRUE; }

BOOL AttrBrushType::SetPathOffsetValue (  MILLIPOINT  NewValue  )

to set the offset distance for this brush Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Inputs Value - the offset value to set Returns: - Definition at line 3746 of file brshattr.cpp. { PathProcessorBrush* pPathProc = m_Value.GetPathProcessor(); if (pPathProc == NULL) return FALSE; pPathProc->SetPathOffsetValue(NewValue); return TRUE; }

void AttrBrushType::SetPressureCache (  CDistanceSampler *  pCache  )

interface to the BrushAttrValue, sets the cache Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: array  holding pressure values [INPUTS] Returns: - See also: - Definition at line 4316 of file brshattr.cpp. { m_Value.SetPresssureCache(pCache); }

BOOL AttrBrushType::SetRotateAngle (  double  NewAngle  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  angle of rotation to set [INPUTS] Returns: TRUE if the angle is within the stated bounds See also: - Definition at line 3796 of file brshattr.cpp. { PathProcessorBrush* pPathProc = m_Value.GetPathProcessor(); if (pPathProc == NULL) return FALSE; return pPathProc->SetRotationAngle(NewAngle); }

BOOL AttrBrushType::SetRotated (  BOOL  Rotated  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: whether  or not the brush rotates [INPUTS] Returns: - See also: - Definition at line 3818 of file brshattr.cpp. { PathProcessorBrush* pPathProc = m_Value.GetPathProcessor(); if (pPathProc == NULL) return FALSE; pPathProc->SetRotated(Rotated); return TRUE; }

BOOL AttrBrushType::SetScaling (  double  NewScale  )

To set the brush scaling. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  scaling value to set [INPUTS] Returns: TRUE if successful, FALSE if not See also: - Definition at line 3707 of file brshattr.cpp. { PathProcessorBrush* pPPB = m_Value.GetPathProcessor(); if (pPPB == NULL) return FALSE; return pPPB->SetBrushScaling(NewScale); }

BOOL AttrBrushType::SetSpacing (  MILLIPOINT  NewSpacing  )

To set the spacing between brush objects. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  spacing value to set [INPUTS] Returns: TRUE if successful, FALSE if not See also: - Definition at line 3660 of file brshattr.cpp. { PathProcessorBrush* pPathProc = m_Value.GetPathProcessor(); if (pPathProc == NULL) return FALSE; return pPathProc->SetSpacing(NewSpacing); }

BOOL AttrBrushType::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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: whether  or not the brush tiles [INPUTS] Returns: TRUE if successful, FALSE otherwise See also: - Definition at line 3773 of file brshattr.cpp. { PathProcessorBrush* pPathProc = m_Value.GetPathProcessor(); if (pPathProc == NULL) return FALSE; pPathProc->SetTiling(Tiled); return TRUE; }

void AttrBrushType::SetUseLocalTransp (  BOOL  UseTransp  )

interface to the PPB, sets a member Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: whether  or not to use local transparency [INPUTS] Returns: - See also: PathProcessorBrush::RenderAttributes Definition at line 4059 of file brshattr.cpp. { PathProcessorBrush* pPPB = m_Value.GetPathProcessor(); if (pPPB) pPPB->SetUseLocalTransp(UseTransp); }

void AttrBrushType::SetValueToScaleTo (  MILLIPOINT  Value  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: linewidth  to scale to [INPUTS] Returns: - See also: - Definition at line 4040 of file brshattr.cpp. { m_Value.ScaleToLineWidth(Value); }

virtual BOOL AttrBrushType::ShouldBeOptimized (   )  [inline, virtual]

Reimplemented from NodeAttribute. Definition at line 362 of file brshattr.h. { return TRUE;}

Node * AttrBrushType::SimpleCopy (  void   )  [virtual]

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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: A copy of the node, or NULL if memory runs out Reimplemented from NodeAttribute. Definition at line 3155 of file brshattr.cpp. { AttrBrushType* NodeCopy = new AttrBrushType; if (NodeCopy == NULL) return(NULL); // Call the base class NodeAttribute::CopyNodeContents(NodeCopy); // And call our AttributeValue to copy itself too NodeCopy->GetAttributeValue()->SimpleCopy(GetAttributeValue()); // tell the new path processor who is boss PathProcessorBrush* pPPB = NodeCopy->GetPathProcessor(); if (pPPB != NULL) pPPB->SetParentAttribute(NodeCopy); return(NodeCopy); }

void AttrBrushType::Transform (  TransformBase &  Trans  )  [virtual]

Currently this simply flushes the cached points map. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  transformation to perform [INPUTS] Returns: - See also: - Reimplemented from NodeRenderable. Definition at line 4079 of file brshattr.cpp. { #ifdef NEWFASTBRUSHES if (m_Value.GetCachedBitmap ()) { m_Value.GetCachedBitmap ()->Transform (Trans); } // else // { #endif if (!Trans.bSolidDrag) { // CGS: my new TransformCache function is three // times faster than doing it this way! m_Value.TransformCache(Trans); m_Value.TransformTimeStampList(Trans); m_Value.TransformCachedRect(Trans); } else { // Phil, 10/03/2004 // It may be faster but it doesn't do the job properly during solid dragging. // The following version works better for solid dragging and ought to be // reasonably fast because it still uses the cached bounding rect FlushCache(); m_Value.TransformCachedRect(Trans); } //#ifdef NEWFASTBRUSHES //} //#endif }

BOOL AttrBrushType::WritePreChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Reimplemented from Node. Definition at line 4480 of file brshattr.cpp. { //return TRUE; ERROR2IF(pFilter == NULL, FALSE, "Illegal NULL param"); BOOL ok = TRUE; PathProcessorBrush *pProcessor = m_Value.GetPathProcessor(); if (pProcessor != NULL) { // first try and get the definition stored in the brush component BrushHandle Handle = pProcessor->GetBrushDefinitionHandle(); // also check that the definition exists, as we do not want to save out deactivated brushes BrushDefinition* pDef = BrushComponent::FindBrushDefinition(Handle); if (Handle != BrushHandle_NoBrush && pDef != NULL) { // now get the brush component from the document (bit longwinded this but it // ensures that each brush only gets written once) Document* pDoc = Document::GetCurrent(); ERROR2IF(pDoc == NULL, FALSE, "Er, wheres the document gone?"); BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent)); ERROR2IF(pBrushComp == NULL, FALSE, "Couldn't find brush component"); // finally lets write the definition ok = pBrushComp->ExportLine(pFilter, Handle); if (ok) ok = pProcessor->WriteNative(pFilter); // now write our timestamping and pressure data if (IsTimeStamping()) if (ok) ok = m_Value.WriteTimeStampList(pFilter); if (ContainsPressureCache()) if (ok) ok = m_Value.WritePressureData(pFilter); } } else { //ERROR3("Trying to write empty attribute"); // return FALSE; } return ok; }

BOOL AttrBrushType::WritePreChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes out a record that represents the node, to either Native or Web file format. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pFilter  - filter to write to [INPUTS] Returns: TRUE if the Node has written out a record to the filter This function is called before any of the AttrBrushType's children are written to the filter. If the AttrBrushType writes out a record successfully to the file, it will return TRUE. If the AttrBrushType chooses not to write itself to the filter (e.g. because it is not appropriate for this filter), then this function will return FALSE. Notes: Simple Brushs (not using fancy bitmap/vector brushes) just write out a 4-byte (UINT32) record containing the stroke type. Defined stroke types at this time are: 0 - Simple variable width stroke See also: Node::WritePreChildrenNative; Node::WritePreChildrenWeb; StrokeAttrRecordHandler::HandleRecord Reimplemented from Node. Definition at line 4475 of file brshattr.cpp. { return(WritePreChildrenNative(pFilter)); }

---

Member Data Documentation

BrushData AttrBrushType::m_BrushData [protected]

Definition at line 437 of file brshattr.h.

UINT32 AttrBrushType::m_LocalTranspType [protected]

Definition at line 442 of file brshattr.h.

UINT32 AttrBrushType::m_LocalTranspValue [protected]

Definition at line 441 of file brshattr.h.

DocColour* AttrBrushType::m_pBlendedStrokeColour [protected]

Definition at line 436 of file brshattr.h.

FreeHandTool* AttrBrushType::m_pFreeTool [protected]

Definition at line 439 of file brshattr.h.

DocColour* AttrBrushType::m_pLocalStrokeColour [protected]

Definition at line 435 of file brshattr.h.

BrushAttrValue AttrBrushType::m_Value [protected]

Definition at line 433 of file brshattr.h.

---

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

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

---