BrushRef Class Reference

'wrapper' for the blendref class for use with the brush. Contains the information that the nodebrushmaker needs to draw the brush objects More...

#include <brushref.h>

Inheritance diagram for BrushRef:

List of all members.

Public Types
typedef std::list< BlendPathOffset >	list
typedef list::iterator	iterator
Public Member Functions
	BrushRef ()
	Default constructor.
	~BrushRef ()
	Default destructor.
BOOL	Initialise (NodeRenderableInk *pInitNode)
	This inits the BrushRef object with the given node. Essentially a wrapper for the blendref initialise function. However it also works out the blendpath offsets, if there are any.
BlendPathOffset *	GetFirstOffset (iterator *pHeadPosition)
	as above
BlendPathOffset *	GetNextOffset (iterator *pPosition)
	as above
iterator	GetEndPosition ()
DocRect	GetBoundingRect ()
	as above, unions the bounding boxes
void	DeleteBitmapFills ()
	Searches for bitmap fill attributes and deletes their bitmaps, see previous function for the rationale. Note that this function was designed to be called by the BrushDefinition destructor. I cannot think of a good reason for wanting to use it anywhere else.
void	DeleteAttributesAndPath ()
	Goes through all of the blendpaths and sets a flag which ensures that all the applied attributes of this blendpath are deleted upon destruction. This must not be used under normal circumstances because these attributes will still be in use by other objects. It was designed for when we are blending brush attributes and have to generate our attribute maps from scratch.
void	FreeAttributes ()
	Goes through the blendpaths and asks them to delete their cached attribute map.
void	TranslateTo (DocCoord Target)
	Translates the blendpaths and their applied attributes to Destination.
void	TransformAttributes (TransformBase &Trans)
	When a brush stroke is transformed in the document we do not really need to transform the blendpaths however we do need tot transform the attributes, otherwise bitmap fills become incorrect as do line widths etc. However if we transform all attributes then we also need to transform the blendpaths, because such things as radial fills are translated by the brush code from the position of the blendpaths. It is important however that we do not scale the blendpaths, as the scaling code assumes that they always stay the same size.
BOOL	MakeCopiesForRendering ()
	Asks the blendpaths to make copies of their paths and attributes which we will use to render with.
BOOL	UpdateCopies ()
	Asks the blendpaths to make copies of their paths and attributes which we will use to render with.
void	DeleteRenderCopies ()
	Asks the blendpaths to delete the copies of paths and attributes.
Path *	GetFirstCopyPath ()
	Makes the first blendpath our current blendpath member and returns the copy of its path. Basically you should use the system like this:.
Path *	GetNextCopyPath ()
	Increments our current blendpath member and returns the copy path of the next blendpath.
CCAttrMap *	GetCurrentAttributeCopy ()
Protected Member Functions
BOOL	SetBitmapFillFlags ()
	Because brush definitions exist independently of documents, but bitmap fills do not. Therefore if we make a brush with a bitmap fill and then delete them document we created it in we lose the fill. However the brush still exists, therefore this function searches for a bitmap fill attribute, and sets flags that tell the bitmap not to delete itself. NOTE: This means that we are responsible for deleting the bitmap fills that belong to us.
Protected Attributes
NodeRenderableInk *	m_pNode
List	m_BlendPathList
UINT32	m_NumBlendPaths
CMapPtrToPtr *	m_pBlendPathAttrMap
DocRect	m_CachedRect
list	m_OffsetList
BlendPath *	m_pCurrentBlendPath
Private Member Functions
	CC_DECLARE_MEMDUMP (BrushRef)

---

Detailed Description

'wrapper' for the blendref class for use with the brush. Contains the information that the nodebrushmaker needs to draw the brush objects

Author:

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

Date:

7/12/99

Definition at line 155 of file brushref.h.

---

Member Typedef Documentation

typedef list::iterator BrushRef::iterator

Definition at line 161 of file brushref.h.

typedef std::list<BlendPathOffset> BrushRef::list

Definition at line 160 of file brushref.h.

---

Constructor & Destructor Documentation

BrushRef::BrushRef (   )

Default constructor. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 214 of file brushref.cpp. { m_pNode = NULL; m_NumBlendPaths = 0; m_pBlendPathAttrMap = NULL; m_CachedRect = DocRect(0,0,0,0); m_pCurrentBlendPath = NULL; }

BrushRef::~BrushRef (   )

Default destructor. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 236 of file brushref.cpp. { FreeAttributes(); m_BlendPathList.DeleteAll(); m_OffsetList.clear(); }

---

Member Function Documentation

BrushRef::CC_DECLARE_MEMDUMP (  BrushRef   )  [private]

void BrushRef::DeleteAttributesAndPath (   )

Goes through all of the blendpaths and sets a flag which ensures that all the applied attributes of this blendpath are deleted upon destruction. This must not be used under normal circumstances because these attributes will still be in use by other objects. It was designed for when we are blending brush attributes and have to generate our attribute maps from scratch. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: [INPUTS]  [OUTPUTS]  Returns: - Definition at line 754 of file brushref.cpp. { // BlendPath* pLastPath = NULL; BlendPath* pBlendPath = GetFirstBlendPath(); while (pBlendPath != NULL) { // ensures that all the applied attributes will be deleted when the object is deleted pBlendPath->DeleteAttributesAndPath(); pBlendPath = GetNextBlendPath(pBlendPath); } }

void BrushRef::DeleteBitmapFills (   )

Searches for bitmap fill attributes and deletes their bitmaps, see previous function for the rationale. Note that this function was designed to be called by the BrushDefinition destructor. I cannot think of a good reason for wanting to use it anywhere else. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: [INPUTS]  [OUTPUTS]  Returns: - Definition at line 706 of file brushref.cpp. { // loop through each blendpath BlendPath* pBlendPath = GetFirstBlendPath(); while (pBlendPath != NULL) { // retrieve the attribute node AttrBitmapFill* pBMPFill = pBlendPath->GetAppliedBitmapColourFill(); if (pBMPFill != NULL) { // get the attribute value BitmapFillAttribute* pVal = (BitmapFillAttribute*)pBMPFill->GetAttributeValue(); if (pVal != NULL) { // get the bitmap KernelBitmap* pBitmap = pVal->GetBitmap(); // if it has been flagged by us then zap it if (pBitmap != NULL && pBitmap->IsUsedByBrush()) { pBitmap->SetUsedByBrush(FALSE); pBitmap->Detach(); delete pBitmap; } } } pBlendPath = GetNextBlendPath(pBlendPath); } }

void BrushRef::DeleteRenderCopies (   )

Asks the blendpaths to delete the copies of paths and attributes. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 394 of file brushref.cpp. { // BlendPath* pLastPath = NULL; BlendPath* pBlendPath = GetFirstBlendPath(); while (pBlendPath != NULL) { pBlendPath->DeleteCopyPathAndAttributes(); pBlendPath = GetNextBlendPath(pBlendPath); } }

void BrushRef::FreeAttributes (   )

Goes through the blendpaths and asks them to delete their cached attribute map. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: [INPUTS]  [OUTPUTS]  Returns: - Definition at line 780 of file brushref.cpp. { // BlendPath* pLastPath = NULL; BlendPath* pBlendPath = GetFirstBlendPath(); while (pBlendPath != NULL) { pBlendPath->SetFreeAttributeFlag(TRUE); pBlendPath = GetNextBlendPath(pBlendPath); } //DeleteBitmapFills(); // disabled until I get it working properly }

DocRect BrushRef::GetBoundingRect (   )

as above, unions the bounding boxes Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: [INPUTS]  [OUTPUTS]  Returns: the bounding rect of this brushref Reimplemented from BlendRef. Definition at line 571 of file brushref.cpp. { DocRect Rect; BlendPath *pBlendPath = GetFirstBlendPath(); BlendPathOffset Offset; iterator ListPos = m_OffsetList.begin(); CCAttrMap *pAttrMap = NULL; while (pBlendPath != NULL) { DocRect PathRect; pAttrMap = pBlendPath->FindAppliedAttributes(); pBlendPath->m_pPath->GetTrueBoundingRect(&PathRect, 0, pAttrMap); if (ListPos != m_OffsetList.end() ) { Offset = *ListPos++; /* PathRect.hix += Offset.m_XOffset; PathRect.lox += Offset.m_XOffset; PathRect.hiy += Offset.m_YOffset; PathRect.loy += Offset.m_YOffset; */ } Rect = Rect.Union(PathRect); pAttrMap = NULL; pBlendPath = GetNextBlendPath(pBlendPath); } return Rect; }

CCAttrMap * BrushRef::GetCurrentAttributeCopy (   )

Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the attribute map that we should render with our current copy path Definition at line 498 of file brushref.cpp. { if (m_pCurrentBlendPath == NULL) { ERROR3("Current blendpath is NULL in BrushRef::GetCurrentAttributeCopy"); return NULL; } return m_pCurrentBlendPath->GetCopyAttributes(); }

iterator BrushRef::GetEndPosition (   )  [inline]

Definition at line 170 of file brushref.h. { return m_OffsetList.end(); }

Path * BrushRef::GetFirstCopyPath (   )

Makes the first blendpath our current blendpath member and returns the copy of its path. Basically you should use the system like this:. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the copy of the path made by the first blendpath that we should use for rendering Path* pPath = pBrushRef->GetFirstCopyPath(); CCAttrMap* pMap = NULL; while (pPath) { pMap = pBrushRef->GetCurrentAttributeCopy(); pMap->Render(or whatever) pPath->Render (or whatever) pPath = pBrushRef->GetNextCopyPath(); } Definition at line 438 of file brushref.cpp. { m_pCurrentBlendPath = GetFirstBlendPath(); if (m_pCurrentBlendPath == NULL) { ERROR3("First blendpath is NULL in BrushRef::GetFirstCopyPath"); return NULL; } return m_pCurrentBlendPath->GetCopyPath(); }

BlendPathOffset * BrushRef::GetFirstOffset (  iterator *  pHeadPosition  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: pListPosition  - uninitialised POSITION variable [INPUTS] pListPosition  - the position of the head of the list - use it to pass into GetNextOffset [OUTPUTS] Returns: the value of the first offset in the m_offset list. If the list is empty it returns -1. Definition at line 523 of file brushref.cpp. { if (m_OffsetList.empty()) return NULL; else { *pHeadPosition = m_OffsetList.begin(); return &( *(*pHeadPosition)++ ); } }

Path * BrushRef::GetNextCopyPath (   )

Increments our current blendpath member and returns the copy path of the next blendpath. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the next path to be rendered Definition at line 465 of file brushref.cpp. { // If our current blendpath isn't set yet then its an error if (m_pCurrentBlendPath == NULL) { ERROR3("Current blendpath is NULL in BrushRef::GetNextCopyPath"); return NULL; } m_pCurrentBlendPath = GetNextBlendPath(m_pCurrentBlendPath); if (m_pCurrentBlendPath != NULL) return m_pCurrentBlendPath->GetCopyPath(); // we've hit the end of the line return NULL; }

BlendPathOffset * BrushRef::GetNextOffset (  iterator *  pHeadPosition  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: pPosition  - the position to get in the list [INPUTS] pPosition  - the next position in the list (or NULL) [OUTPUTS] Returns: the value of the next offset in the m_offset list. If the list is empty it returns NULL. Definition at line 549 of file brushref.cpp. { if( m_OffsetList.empty() ) return NULL; else return &( *(*pHeadPosition)++ ); }

BOOL BrushRef::Initialise (  NodeRenderableInk *  pInitNode  )

This inits the BrushRef object with the given node. Essentially a wrapper for the blendref initialise function. However it also works out the blendpath offsets, if there are any. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: pInitNode  = ptr to the node this BrushRef refers to. [INPUTS] -  [OUTPUTS] Returns: TRUE if successfully initialises, FALSE otherwise Definition at line 259 of file brushref.cpp. { ERROR2IF(pInitNode == NULL, FALSE, "Ink node is NULL in BrushRef::Initialise"); // Note that BrushDefinition::GenerateBrush now prevents objects with brush attributes being // used to generate brushes, instead it converts them to groups of nodepaths as per Convert Line to Shapes pInitNode->MakeAttributeComplete(); // just in case we're missing any BOOL ok = BlendRef::InitialiseForBrush(pInitNode); if (ok) { // if we have made a brushref from a group then the different // blendpaths will be offset from the centre of. work out these // offsets and store them in a list m_OffsetList.clear(); DocRect BRect = GetBoundingRect(); DocCoord Centre = BRect.Centre(); BlendPath* pBlendPath = GetFirstBlendPath(); while (pBlendPath != NULL) { Path* pPath = pBlendPath->GetPath(); if (pPath) { DocRect BlendPathRect = pPath->GetBoundingRect(); DocCoord BlendPathCentre = BlendPathRect.Centre(); BlendPathOffset ThisOffset; ThisOffset.m_XOffset = BlendPathCentre.x - Centre.x ; ThisOffset.m_YOffset = BlendPathCentre.y - Centre.y; ThisOffset.CalculateAngleAndMagnitude(); m_OffsetList.push_back(ThisOffset); pBlendPath->FindAppliedAttributes(); pBlendPath = GetNextBlendPath(pBlendPath); } else { ERROR3("BlendPath has no path"); return FALSE; } } // if we have a bitmap fill we need to do some special things.. SetBitmapFillFlags(); PreBlend(); if (pInitNode->IsABlend()) ((NodeBlend*)pInitNode)->Deinit(); return TRUE; } return FALSE; }

BOOL BrushRef::MakeCopiesForRendering (   )

Asks the blendpaths to make copies of their paths and attributes which we will use to render with. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise (e.g. out of memory) Definition at line 332 of file brushref.cpp. { // BlendPath* pLastPath = NULL; BlendPath* pBlendPath = GetFirstBlendPath(); BOOL ok = TRUE; while (pBlendPath != NULL) { if (ok) ok = pBlendPath->MakeCopyPathAndAttributes(); pBlendPath = GetNextBlendPath(pBlendPath); } return ok; }

BOOL BrushRef::SetBitmapFillFlags (   )  [protected]

Because brush definitions exist independently of documents, but bitmap fills do not. Therefore if we make a brush with a bitmap fill and then delete them document we created it in we lose the fill. However the brush still exists, therefore this function searches for a bitmap fill attribute, and sets flags that tell the bitmap not to delete itself. NOTE: This means that we are responsible for deleting the bitmap fills that belong to us. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if we don't have a bitmap fill, or if we do and successfully made a copy Definition at line 619 of file brushref.cpp. { // for each blendpath we wish to find out if they have an applied bitmap fill attribute. // if so then we want to copy it, and replace it in the attribute map BlendPath* pBlendPath = GetFirstBlendPath(); while (pBlendPath != NULL) { // there may be both a colour fill and transparency attribute, so get both AttrBitmapFill* pBMPFill = pBlendPath->GetAppliedBitmapColourFill(); if (pBMPFill != NULL) { // Get the attribute value BitmapFillAttribute* pVal = (BitmapFillAttribute*)pBMPFill->GetAttributeValue(); if (pVal == NULL) { ERROR3("Couldn't retrieve attribute value"); return FALSE; } KernelBitmap* pKBitmap = pVal->GetBitmap(); if (pKBitmap != NULL) { OILBitmap* pOBitmap = pKBitmap->GetActualBitmap(); // tell the bitmaps that they are being used by us so that if the // document closes they don't get deleted if (pOBitmap != NULL) { pOBitmap->SetUsedByBrush(TRUE); pKBitmap->SetUsedByBrush(TRUE); } } } AttrBitmapFill* pTranspFill = pBlendPath->GetAppliedBitmapTranspFill(); if (pTranspFill != NULL) { // Get the attribute value BitmapFillAttribute* pVal = (BitmapFillAttribute*)pTranspFill->GetAttributeValue(); if (pVal == NULL) { ERROR3("Couldn't retrieve attribute value"); return FALSE; } KernelBitmap* pKBitmap = pVal->GetBitmap(); if (pKBitmap != NULL) { OILBitmap* pOBitmap = pKBitmap->GetActualBitmap(); // tell the bitmaps that they are being used by us so that if the // document closes they don't get deleted if (pOBitmap != NULL) { pOBitmap->SetUsedByBrush(TRUE); pKBitmap->SetUsedByBrush(TRUE); } } } pBlendPath = GetNextBlendPath(pBlendPath); } return TRUE; }

void BrushRef::TransformAttributes (  TransformBase &  Trans  )

When a brush stroke is transformed in the document we do not really need to transform the blendpaths however we do need tot transform the attributes, otherwise bitmap fills become incorrect as do line widths etc. However if we transform all attributes then we also need to transform the blendpaths, because such things as radial fills are translated by the brush code from the position of the blendpaths. It is important however that we do not scale the blendpaths, as the scaling code assumes that they always stay the same size. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: Trans  - the transformation to perform [INPUTS] -  [OUTPUTS] Returns: - Definition at line 861 of file brushref.cpp. { BlendPath *pBlendPath = GetFirstBlendPath(); CCAttrMap *pAttrMap = NULL; CCRuntimeClass *pType; void *pVal; NodeAttribute *pNodeAttr; while (pBlendPath != NULL) { // we want to transform attributes too pAttrMap = pBlendPath->FindAppliedAttributes(); if (pAttrMap == NULL) { ERROR3("No applied attributes"); } else { // monster bodge - currently we only actually want to transform line widths and bitmap fills for( CCAttrMap::iterator Pos = pAttrMap->GetStartPosition(); Pos != pAttrMap->GetEndPosition(); ) { // Get attr at position Pos pAttrMap->GetNextAssoc( Pos, pType, pVal ); // pVal is actually an attribute, so get a ptr to it and render it pNodeAttr = (NodeAttribute *)pVal; if (pNodeAttr->IsABitmapFill()) pNodeAttr->Transform(Trans); if( pNodeAttr->IsALineWidthAttr() && FALSE != Trans.TransLines ) { INT32 Test = labs( INT32(Trans.GetScalar().MakeDouble() * ((AttrLineWidth*)pNodeAttr)->Value.LineWidth) ); if (Test >= 10) pNodeAttr->Transform(Trans); } } pAttrMap = NULL; } pBlendPath = GetNextBlendPath(pBlendPath); } return; }

void BrushRef::TranslateTo (  DocCoord  Destination  )

Translates the blendpaths and their applied attributes to Destination. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/12/99 Parameters: Destination  - the coord to translateto [INPUTS] -  [OUTPUTS] Returns: - Definition at line 806 of file brushref.cpp. { BlendPath* pBlendPath = GetFirstBlendPath(); CCAttrMap* pAttrMap = NULL; DocRect BRect; DocCoord CurrentCentre; Trans2DMatrix Trans; while (pBlendPath != NULL) { // find out where we are BRect = pBlendPath->m_pPath->GetBoundingRect(); CurrentCentre = BRect.Centre(); // set the translation in the matrix Trans.SetTransform(Destination.x - CurrentCentre.x, Destination.y - CurrentCentre.y); // we want to transform attributes too pAttrMap = pBlendPath->FindAppliedAttributes(); if (pAttrMap == NULL) { ERROR3("No applied attributes"); } else { pAttrMap->Transform(Trans); pAttrMap = NULL; } pBlendPath->Transform(Trans); pBlendPath = GetNextBlendPath(pBlendPath); } }

BOOL BrushRef::UpdateCopies (   )

Asks the blendpaths to make copies of their paths and attributes which we will use to render with. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 14/01/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise (e.g. out of memory) Definition at line 364 of file brushref.cpp. { // BlendPath* pLastPath = NULL; BlendPath* pBlendPath = GetFirstBlendPath(); BOOL ok = TRUE; while (pBlendPath != NULL && ok) { pBlendPath->UpdateCopyPathAndAttributes(); pBlendPath = GetNextBlendPath(pBlendPath); } return ok; }

---

Member Data Documentation

List BrushRef::m_BlendPathList [protected]

Reimplemented from BlendRef. Definition at line 197 of file brushref.h.

DocRect BrushRef::m_CachedRect [protected]

Definition at line 200 of file brushref.h.

UINT32 BrushRef::m_NumBlendPaths [protected]

Reimplemented from BlendRef. Definition at line 198 of file brushref.h.

list BrushRef::m_OffsetList [protected]

Definition at line 203 of file brushref.h.

CMapPtrToPtr* BrushRef::m_pBlendPathAttrMap [protected]

Reimplemented from BlendRef. Definition at line 199 of file brushref.h.

BlendPath* BrushRef::m_pCurrentBlendPath [protected]

Definition at line 206 of file brushref.h.

NodeRenderableInk* BrushRef::m_pNode [protected]

Reimplemented from BlendRef. Definition at line 196 of file brushref.h.

---

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

• Kernel/brushref.h (r1785/r1282)
• Kernel/brushref.cpp (r1785/r1282)

---