BrushDefinition Class Reference

Stores a vector Brush definition A static list of these items is held in the BrushComponent. More...

#include <brshcomp.h>

Inheritance diagram for BrushDefinition:

List of all members.

Public Member Functions
	BrushDefinition ()
	Default constructor for the purposes of inherited classes, if you just want a normal brushdef you should really use the constructor above.
	BrushDefinition (Node *pBrushTree)
	Constructor.
	~BrushDefinition ()
	Destructor.
BOOL	GenerateBrush ()
	goes through the input spread and calls AddNewObject() for each ink object found We try to make some intelligent guesses about what to set the starting spacing and offset values depending on the nature of the nodes. The following rules apply: if there are multiple ink objects then the spacing is 1.1 * the largest dimension of the largest bounding box if there is only one object and it contains a positive line width spacing is as above if there is only one object with no line width then spacing is 10000 millipoint defaulf offset is always the largest dimension of the largest BBOX.
BOOL	RegenerateBrush ()
	This function deletes the existing brushrefs and recreates them from scratch from m_pTree.
BOOL	IsActivated ()
	To see if this definition was initialised ok or if it was subsequently deactivated for some reason.
void	SetActivated (BOOL Value)
	To set this definition activated or not.
BOOL	StartRender ()
	Basically due to imprecision in the arithmetic system we ended up corrupting the brush data if we used it too much. So to get around this we never transform the original brush data, instead we make copies of it each time we want to render a version of this brush. This function generates the data copies that we need to render this brush, make sure you call StopRender() to get rid of them.
void	StopRender ()
	Call this when you have finished rendering a node with this brush, it deletes the copied data that we used for rendering.
BOOL	IsDifferent (LineDefinition *pOther)
	Determine if 2 BrushDefinitions are considered different. Used when adding Brushes to the global list, so that like Brushes can be merged.
BOOL	AreBrushParametersIdentical (BrushDefinition *pOther)
	Compares the member variables of the two brushes.
BrushDefinition *	Copy ()
	Makes a copy of this definition, inknodes and all.
BOOL	CopyInkTreeToClipboard ()
	copies the ink objects of this brush definition to the clipboard so they can be used elsewhere
BOOL	UsesPressure ()
	as above
MILLIPOINT	GetSpacing ()
	As above.
BOOL	SetSpacing (MILLIPOINT Spacing)
	To set the spacing between brush objects.
BOOL	SetSpacingIncrProp (double Incr)
	To set the proportional spacing increment between brush objects.
double	GetSpacingIncrProp ()
	As above.
BOOL	SetSpacingIncrConst (MILLIPOINT Incr)
	To set the proportional spacing increment between brush objects.
MILLIPOINT	GetSpacingIncrConst ()
	As above.
UINT32	GetSpacingMaxRand ()
	As above.
BOOL	SetSpacingMaxRand (UINT32 Value)
	As above.
UINT32	GetSpacingRandSeed ()
	As above.
void	SetSpacingRandSeed (UINT32 Seed)
	As above.
PathOffset	GetPathOffsetType ()
	as above
MILLIPOINT	GetPathOffsetValue ()
	as above
void	SetPathOffsetType (PathOffset Offset)
	to set the offset type for this brush
void	SetPathOffsetValue (MILLIPOINT Value)
	to set the offset distance for this brush
BOOL	SetPathOffsetIncrProp (double Incr)
	to set the offset distance for this brush
double	GetPathOffsetIncrProp ()
	as above
BOOL	SetPathOffsetIncrConst (MILLIPOINT Incr)
	to set the offset distance for this brush
MILLIPOINT	GetPathOffsetIncrConst ()
	as above
UINT32	GetOffsetTypeRandSeed ()
	As above.
void	SetOffsetTypeRandSeed (UINT32 Seed)
	As above.
UINT32	GetOffsetValueMaxRand ()
	As above.
BOOL	SetOffsetValueMaxRand (UINT32 Seed)
	As above.
UINT32	GetOffsetValueRandSeed ()
	As above.
void	SetOffsetValueRandSeed (UINT32 Seed)
	As above.
void	SetTiling (BOOL Value)
	as above
BOOL	IsTiled ()
	as above
BOOL	SetRotationAngle (double Angle)
	as above
double	GetRotationAngle ()
	as above
double	GetRotationIncrConst ()
	as above
BOOL	SetRotationIncrConst (double Value)
	as above
double	GetRotationIncrProp ()
	as above
BOOL	SetRotationIncrProp (double Value)
	as above
void	SetRotated (BOOL Value)
	as above
BOOL	IsRotated ()
	as above
UINT32	GetRotationMaxRand ()
	as above
BOOL	SetRotationMaxRand (UINT32 Value)
	as above
UINT32	GetRotationRandSeed ()
	as above
void	SetRotationRandSeed (UINT32 Seed)
	as above
UINT32	GetRotationMaxPressure ()
	as above
BOOL	SetRotationMaxPressure (UINT32 Pressure)
	as above
double	GetBrushScaling ()
	as above
BOOL	SetBrushScaling (double Scale)
	to set the member that determine to what scale of the original object each brush object is drawn
double	GetBrushScalingIncr ()
	as above
BOOL	SetBrushScalingIncr (double Incr)
	to set the member that determine the increment to scaling applied to each brush object
double	GetBrushScalingIncrConst ()
	as above
BOOL	SetBrushScalingIncrConst (double Incr)
	to set the member that determine the increment to scaling applied to each brush object
UINT32	GetScalingMaxRand ()
	As above.
BOOL	SetScalingMaxRand (UINT32 Value)
	As above.
UINT32	GetScalingRandSeed ()
	As above.
void	SetScalingRandSeed (UINT32 Seed)
	As above.
UINT32	GetScalingMaxPressure ()
	As above.
BOOL	SetScalingMaxPressure (UINT32 Pressure)
	As above.
double	GetHueIncrement ()
	as above
BOOL	SetHueIncrement (double Incr)
	as above
UINT32	GetHueMaxRand ()
	as above
BOOL	SetHueMaxRand (UINT32 Max)
	as above
UINT32	GetHueRandSeed ()
	as above
BOOL	SetHueRandSeed (UINT32 Seed)
	as above
double	GetSatIncrement ()
	as above
BOOL	SetSatIncrement (double Incr)
	as above
UINT32	GetSatMaxRand ()
	as above
BOOL	SetSatMaxRand (UINT32 Max)
	as above
UINT32	GetSatRandSeed ()
	as above
BOOL	SetSatRandSeed (UINT32 Seed)
	as above
SequenceType	GetSequenceType ()
	as above
void	SetSequenceType (SequenceType Type)
	as above
UINT32	GetSequenceSeed ()
	as above
void	SetSequenceSeed (UINT32 Seed)
	as above
double	GetTimeStampingPeriod ()
	as above
BOOL	SetTimeStampingPeriod (double Period)
	as above
INT32	GetBrushTransparency ()
	as above
BOOL	SetBrushTransparency (INT32 Value)
	as above
UINT32	GetTransparencyPressure ()
	Sets the extent to which pressure affects transparency.
BOOL	SetTransparencyPressure (UINT32 Value)
	Sets the extent to which pressure affects transparency.
UINT32	GetNumBrushObjects () const
	as above
DocRect	GetLargestBoundingBox ()
	as above
DocRect	GetLargestPossibleRect (BOOL AdjustForLineWidth=FALSE)
	To find out the largest possible bounding box that this brush can achieve, this we get the largest ink rect and then perform the maximum scaling, rotation etc. Note that ScalingIncrConst will be will be excluded from this test as we will never be able to know what affect it will have in advance of drawing the path.
MILLIPOINT	GetDefaultLineWidth (BOOL IgnorePressure=FALSE)
	as above
BrushRef *	GetFirstBrushRef ()
	as above
BrushRef *	GetNextBrushRef ()
	as above
BrushRef *	GetBrushRef (UINT32 Index)
	as above
void	CalculateMaxScaling ()
	Calculates the maximum scaling value possible by dividing the maximum size value by the longest side of the bounding rect of the largest object.
double	GetMaxScaling ()
	as above
void	CopyDataToProcessor (PathProcessorBrush *pPathProc)
	To copy all of the numeric data about this brush to a path processor.
BOOL	BrushContainsGroup ()
	as above
UINT32	GetBrushFileID ()
	as above
void	SetBrushFileID (UINT32 ID)
	as above, this should only be called as part of the start-up process.
BOOL	ExportBrush (BaseCamelotFilter *pFilter, const BrushHandle Handle)
	To export a Brush definition.
void	InitialiseBrushData (BrushData *pData)
	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. Note that you are responsible for deleting this object.
void	SetMembersFromData (BrushData Data)
	gets the latest data from our path processor, copies it into our BrushData object which is then returned. Note that you are responsible for deleting this object.
Static Public Member Functions
static BOOL	ObjectCanCreateBrush (NodeRenderableInk *pObject)
	To determine if this ink node can be made into a brush, currently returns TRUE for except for bevels, shadows, and contours, which are too damn awkward.
Protected Member Functions
BOOL	PreExportSubTree ()
	To perform various functions just prior to saving the subtree of the brush definition. The function loops through the BrushRefs, finding the blendpaths of each and transforming their attribute maps back to the position that they were in when the brush was created.
BOOL	PostExportSubTree ()
	To perform various functions just prior to saving the subtree of the brush definition. The function loops through the BrushRefs, finding the blendpaths of each and undoes the transformation performed by PreExportSubTree. This is required because to continue using the brush in our current document we want to use its current position.
BOOL	AddNewObject (NodeRenderableInk *pNode)
	creates a brushref object from the inknode and its attributes, then adds the brushref to the member array
BOOL	ReplaceBrushWithGroup (NodeRenderableInk *pInk, NodeGroup **ppGroup)
	We are no longer allowed to make brushes from brushes, because of problems when saving and loading. Instead if we have a brush then we will convert it to shapes and use those instead.
void	ResetMembers ()
	Initialises the member variables.
void	InitialiseBrushArray (UINT32 NumObjects)
	Clears out the m_BrushRefPtrArray if it is not empty, and sets the size.
UINT32	GetFirstRandomNumber (UINT32 Seed=0)
	Seeds srand with either the seed supplied or by using time (i.e. a random seed).
UINT32	GetNextRandomNumber ()
	as above, note that you MUST have already called GetFirstRandomNumber()
Protected Attributes
MILLIPOINT	m_BrushSpacing
double	m_BrushSpacingIncrProp
MILLIPOINT	m_BrushSpacingIncrConst
UINT32	m_BrushSpacingMaxRand
UINT32	m_BrushSpacingRandSeed
UINT32	m_SpacingMaxPressure
BOOL	m_bTile
BOOL	m_bRotate
double	m_RotateAngle
double	m_RotAngleIncrProp
double	m_RotAngleIncrConst
UINT32	m_RotationMaxRand
UINT32	m_RotationRandSeed
UINT32	m_RotationMaxPressure
PathOffset	m_PathOffsetType
MILLIPOINT	m_PathOffsetValue
double	m_PathOffsetIncrProp
MILLIPOINT	m_PathOffsetIncrConst
UINT32	m_OffsetTypeRandSeed
UINT32	m_OffsetValueMaxRand
UINT32	m_OffsetValueRandSeed
UINT32	m_OffsetMaxPressure
double	m_BrushScaling
double	m_BrushScalingIncr
double	m_BrushScalingIncrConst
UINT32	m_BrushScalingMaxRand
UINT32	m_BrushScalingRandSeed
UINT32	m_ScalingMaxPressure
double	m_BrushHueIncrement
UINT32	m_BrushHueMaxRand
UINT32	m_BrushHueRandSeed
UINT32	m_HueMaxPressure
double	m_BrushSatIncrement
UINT32	m_BrushSatMaxRand
UINT32	m_BrushSatRandSeed
UINT32	m_SatMaxPressure
INT32	m_BrushTransparency
UINT32	m_TranspMaxPressure
SequenceType	m_SequenceType
UINT32	m_SequenceRandSeed
double	m_TimeStampPeriod
UINT32	m_TimeStampMaxPressure
std::vector< BrushRef * >	m_BrushRefPtrArray
UINT32	m_NumBrushObjects
UINT32	m_LastBrushRefRetrieved
DocRect	m_LargestBoundingBox
BOOL	m_bInitOk
double	m_MaxScaling
UINT32	m_DefaultFileID
BOOL	m_bActivated

---

Detailed Description

Stores a vector Brush definition A static list of these items is held in the BrushComponent.

Author:

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

Date:

13/12/99

See also:

BrushComponent

Definition at line 205 of file brshcomp.h.

---

Constructor & Destructor Documentation

BrushDefinition::BrushDefinition (   )

Default constructor for the purposes of inherited classes, if you just want a normal brushdef you should really use the constructor above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 27/2/97 5/12/2000 Actually I've just read that it is a poor idea to initialise inside constructors, so I think that a reorganisation should occur whereby the construcotr should simply assign the brush tree and we should GenerateBrush after the constructor returns. Definition at line 210 of file brshcomp.cpp. { ResetMembers(); }

BrushDefinition::BrushDefinition (  Node *  pBrushTree  )

Constructor. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 27/2/97 Parameters: pBrushTree  - A pointer to a Spread node which is the root of a clipart [INPUTS] subtree which should be used for this Brush definition. It must obey these rules: It must be a Spread It must not be linked into any other parent tree structure It should contain at least one ink node (or else the Brush will appear "blank"). It should be attribute complete, or close thereto See also: BrushComponent::AddNewBrush Definition at line 179 of file brshcomp.cpp. : LineDefinition(pBrushTree) { ResetMembers(); InitialiseBrushArray(MAX_BRUSH_OBJECTS); if (!GenerateBrush()) { // hmm, not sure what to do here, but you can detect if we failed to initialise // by calling IsActivated, if that fails you should delete me. } }

BrushDefinition::~BrushDefinition (   )

Destructor. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 27/2/97 Definition at line 227 of file brshcomp.cpp. { for( size_t i = 0; i < m_BrushRefPtrArray.size(); i++ ) { // ask the brushref to delete the attribute maps it generated if (m_BrushRefPtrArray[i] != NULL) { // m_BrushRefPtrArray[i]->DeleteAttributeMapsAndAttributes(); delete m_BrushRefPtrArray[i]; } } m_BrushRefPtrArray.clear(); }

---

Member Function Documentation

BOOL BrushDefinition::AddNewObject (  NodeRenderableInk *  pInkNode  )  [protected]

creates a brushref object from the inknode and its attributes, then adds the brushref to the member array Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pInkNode  - node to add [INPUTS] Returns TRUE if successful, FALSE otherwise Definition at line 608 of file brshcomp.cpp. { if (pInkNode == NULL) { ERROR3("Ink node is NULL"); return FALSE; } if (m_NumBrushObjects >= MAX_BRUSH_OBJECTS) { ERROR3("Cannot exceed MAX_BRUSH_OBJECTS"); return FALSE; } BrushRef *pNewBrushRef = new BrushRef; if (pNewBrushRef == NULL) { ERROR3("Failed to allocate brushref"); return FALSE; } if (!pNewBrushRef->Initialise(pInkNode)) { ERROR3("Failed to initialise brushref"); return FALSE; } m_BrushRefPtrArray[m_NumBrushObjects++] = pNewBrushRef; return TRUE; }

BOOL BrushDefinition::AreBrushParametersIdentical (  BrushDefinition *  pOther  )

Compares the member variables of the two brushes. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pOther  - the Brush to compare this Brush to [INPUTS] Returns: TRUE if they're different FALSE if they are identical Definition at line 823 of file brshcomp.cpp. { if (m_BrushSpacing != pOther->m_BrushSpacing || m_BrushSpacingIncrProp != pOther->m_BrushSpacingIncrProp || m_BrushSpacingIncrConst != pOther->m_BrushSpacingIncrConst || m_BrushSpacingMaxRand != pOther->m_BrushSpacingMaxRand || m_BrushSpacingRandSeed != pOther->m_BrushSpacingRandSeed || m_SpacingMaxPressure != pOther->m_SpacingMaxPressure || m_bTile != pOther->m_bTile || m_bRotate != pOther->m_bRotate || m_RotateAngle != pOther->m_RotateAngle || m_RotAngleIncrProp != pOther->m_RotAngleIncrProp || m_RotAngleIncrConst != pOther->m_RotAngleIncrConst || m_RotationMaxRand != pOther->m_RotationMaxRand || m_RotationRandSeed != pOther->m_RotationRandSeed || m_RotationMaxPressure != pOther->m_RotationMaxPressure || m_PathOffsetType != pOther->m_PathOffsetType || m_PathOffsetValue != pOther->m_PathOffsetValue || m_PathOffsetIncrProp != pOther->m_PathOffsetIncrProp || m_PathOffsetIncrConst != pOther->m_PathOffsetIncrConst || m_OffsetTypeRandSeed != pOther->m_OffsetTypeRandSeed || m_OffsetValueMaxRand != pOther->m_OffsetValueMaxRand || m_OffsetValueRandSeed != pOther->m_OffsetValueRandSeed || m_BrushScaling != pOther->m_BrushScaling || m_BrushScalingIncr != pOther->m_BrushScalingIncr || m_BrushScalingIncrConst != pOther->m_BrushScalingIncrConst || m_BrushScalingMaxRand != pOther->m_BrushScalingMaxRand || m_BrushScalingRandSeed != pOther->m_BrushScalingRandSeed || m_ScalingMaxPressure != pOther->m_ScalingMaxPressure || m_BrushHueIncrement != pOther->m_BrushHueIncrement || m_BrushHueMaxRand != pOther->m_BrushHueMaxRand || m_BrushHueRandSeed != pOther->m_BrushHueRandSeed || m_HueMaxPressure != pOther->m_HueMaxPressure || m_BrushSatIncrement != pOther->m_BrushSatIncrement || m_BrushSatMaxRand != pOther->m_BrushSatMaxRand || m_BrushSatRandSeed != pOther->m_BrushSatRandSeed || m_SatMaxPressure != pOther->m_SatMaxPressure || m_SequenceType != pOther->m_SequenceType || m_SequenceRandSeed != pOther->m_SequenceRandSeed || m_TimeStampPeriod != pOther->m_TimeStampPeriod) return FALSE; else return TRUE; }

BOOL BrushDefinition::BrushContainsGroup (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: TRUE, if the brush is made from one or more groups, FALSE if not See also: - Definition at line 2747 of file brshcomp.cpp. { for (UINT32 i = 0; i < m_NumBrushObjects; i++) { if (m_BrushRefPtrArray[i]->GetNumBlendPaths() > 1) return TRUE; } return FALSE; }

void BrushDefinition::CalculateMaxScaling (   )

Calculates the maximum scaling value possible by dividing the maximum size value by the longest side of the bounding rect of the largest object. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns - Definition at line 1121 of file brshcomp.cpp. { DocRect BRect = GetLargestBoundingBox(); if (BRect.IsEmpty()) { //ERROR3("Bounding rect is empty in BrushDefinition::CalculateMaxScaling"); return; } MILLIPOINT LongestSide = BRect.Height() > BRect.Width() ? BRect.Height() : BRect.Width(); m_MaxScaling = MAX_BRUSH_SIZE / LongestSide; }

BrushDefinition * BrushDefinition::Copy (   )

Makes a copy of this definition, inknodes and all. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/2000 Parameters: -  [INPUTS] Returns: Pointer to new brush definition if succesful, NULL if it fails Definition at line 891 of file brshcomp.cpp. { // we need to make a range in order to copy the nodes to the new brush definition // so we need the start and end nodes of the range Node* pStart = NULL; Node* pNext = NULL; Node* pLast = NULL; // don't forget we start on a spread Node* pTree = GetLineTree(); if (pTree != NULL) pTree = pTree->FindFirstChild(); // get the layer if (pTree != NULL) pTree = pTree->FindFirstChild(); // get the first ink object if (pTree == NULL) { ERROR3("Tree node is NULL in BrushDefinition::Copy()"); return NULL; } pNext = pStart = pTree; while (pNext != NULL) { pNext->SetSelected(FALSE); // we need to do this so that Range::FindFirst doesn't return NULL pLast = pNext; pNext = pLast->FindNext(); } // make a range out of our subtree as thats the easiest way to copy all the nodes RangeControl rc; rc.Unselected = TRUE; rc.Selected = FALSE; Range BrushRange(pStart, pLast, rc); // make a new spread to attach our copy tree to Spread* pSpread = new Spread; if (pSpread == NULL) { ERROR3("Failed to allocate spread in BrushDefinition::Copy"); return NULL; } Layer *pLayer = new Layer( pSpread, FIRSTCHILD, String_256( TEXT("Diccon did this") ) ); if (pLayer == NULL) { ERROR3("Failed to allocate layer in BrushDefinition::Copy"); delete pSpread; return NULL; } // we need to reset our attributes in the same way that we need to with exporting. // If we don't do this then attributes with control points end up vanishing PreExportSubTree(); if (!pLayer->CopyComplexRange(BrushRange)) { ERROR3("Failed to copy range in BrushDefinition::Copy"); delete pSpread; delete pLayer; return NULL; } PostExportSubTree(); // lets allocate ourselves a new empty definition BrushDefinition* pNewBrushDef = new BrushDefinition(pSpread); if (pNewBrushDef == NULL) { ERROR3("Failed to allocate brush definition in BrushDefinition* BrushDefinition::Copy"); delete pSpread; delete pLayer; return NULL; } if (!pNewBrushDef->IsActivated()) { ERROR3("Brush definition failed to initialise"); delete pNewBrushDef; delete pSpread; delete pLayer; return NULL; } return pNewBrushDef; }

void BrushDefinition::CopyDataToProcessor (  PathProcessorBrush *  pPathProc  )

To copy all of the numeric data about this brush to a path processor. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pPathProc  - path processor to receive the data [INPUTS] Returns: - See also: - Definition at line 4368 of file brshcomp.cpp. { if (pPathProc == NULL) { ERROR3("Path processor is NULL"); return; } // spacing members pPathProc->SetSpacing(m_BrushSpacing); pPathProc->SetSpacingIncrProp(m_BrushSpacingIncrProp); pPathProc->SetSpacingIncrConst(m_BrushSpacingIncrConst); pPathProc->SetSpacingMaxRand(m_BrushSpacingMaxRand); pPathProc->SetSpacingRandSeed(m_BrushSpacingRandSeed); // offset members pPathProc->SetPathOffsetType(m_PathOffsetType); pPathProc->SetPathOffsetValue(m_PathOffsetValue); pPathProc->SetPathOffsetIncrConst(m_PathOffsetIncrConst); pPathProc->SetPathOffsetIncrProp(m_PathOffsetIncrProp); pPathProc->SetOffsetTypeRandSeed(m_OffsetTypeRandSeed); pPathProc->SetOffsetValueMaxRand(m_OffsetValueMaxRand); pPathProc->SetOffsetValueRandSeed(m_OffsetValueRandSeed); // scaling members pPathProc->SetBrushScaling(m_BrushScaling); pPathProc->SetScalingMaxRand(m_BrushScalingMaxRand); pPathProc->SetScalingRandSeed(m_BrushScalingRandSeed); pPathProc->SetScalingMaxPressure(m_ScalingMaxPressure); pPathProc->SetMaxScaling(m_MaxScaling); pPathProc->SetBrushScalingIncr(m_BrushScalingIncr); pPathProc->SetBrushScalingIncrConst(m_BrushScalingIncrConst); // rotation pPathProc->SetRotationMaxRand(m_RotationMaxRand); pPathProc->SetRotationRandSeed(m_RotationRandSeed); pPathProc->SetRotationIncrConst(m_RotAngleIncrConst); pPathProc->SetRotationIncrProp(m_RotAngleIncrProp); pPathProc->SetRotationMaxPressure(m_RotationMaxPressure); pPathProc->SetRotationAngle(m_RotateAngle); // sequence pPathProc->SetSequenceType(m_SequenceType); pPathProc->SetSequenceSeed(m_SequenceRandSeed); // Hue/Saturation pPathProc->SetHueIncrement(m_BrushHueIncrement); pPathProc->SetHueMaxRand(m_BrushHueMaxRand); pPathProc->SetHueRandSeed(m_BrushHueRandSeed); pPathProc->SetSatIncrement(m_BrushSatIncrement); pPathProc->SetSatMaxRand(m_BrushSatMaxRand); pPathProc->SetSatRandSeed(m_BrushSatRandSeed); // Transparency pPathProc->SetBrushTransparency(m_BrushTransparency); pPathProc->SetTransparencyPressure(m_TranspMaxPressure); // Other pPathProc->SetRotated(m_bRotate); pPathProc->SetTiling(m_bTile); }

BOOL BrushDefinition::CopyInkTreeToClipboard (   )

copies the ink objects of this brush definition to the clipboard so they can be used elsewhere Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: TRUE if successful, FALSE otherwise See also: - Definition at line 3245 of file brshcomp.cpp. { // first see if we can get the clipboard InternalClipboard *Clipboard = InternalClipboard::Instance(); if (Clipboard == NULL || !Clipboard->PrepareForCopy()) { ERROR3("Error copying to clipboard"); return FALSE; } if (m_pTree == NULL) { ERROR3("No ink objects"); return FALSE; } // remember that we store the ink nodes in a spread, so the first child // will be the layer, which we do not want to copy Node* pFirstNode = m_pTree->FindFirstChild(); if (pFirstNode == NULL) { ERROR3("No layer underneath spread"); return FALSE; } pFirstNode = pFirstNode->FindFirstChild(); // Just be sure its an ink node if (pFirstNode == NULL || !pFirstNode->IsAnObject()) { ERROR3("No ink object to copy"); return FALSE; } // we want to set up a range to copy to the clipboard, so find the rightmost sibling // of our node // We need to set them unselected so that range::findfirst doesn't return NULL Node* pLastNode = pFirstNode; Node* pNextNode = pLastNode->FindNext(); while (pNextNode != NULL) { pNextNode->SetSelected(FALSE); pLastNode = pNextNode; pNextNode = pLastNode->FindNext(); } pFirstNode->SetSelected(FALSE); DocCoord Centre; if (pFirstNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk))) { DocRect BRect = ((NodeRenderableInk*)pFirstNode)->GetBoundingRect(); Centre = BRect.Centre(); TRACEUSER( "Diccon", _T("Ink node centre = %d, %d\n"), Centre.x, Centre.y); } Node* pChild = pFirstNode->FindFirstChild(CC_RUNTIME_CLASS(AttrRadialTranspFill)); if (pChild != NULL) { DocCoord *pStartPoint = ((AttrRadialTranspFill*)pChild)->GetStartPoint(); if (pStartPoint != NULL) TRACEUSER( "Diccon", _T("StartPoint pre-export = %d, %d\n"), pStartPoint->x, pStartPoint->y); } // that should give us our range, now set up the range control, just use the default RangeControl rc; rc.Unselected = TRUE; rc.Selected = FALSE; Range BrushRange(pFirstNode, pLastNode, rc); PreExportSubTree(); BOOL ok = Clipboard->CopyObjects(BrushRange); BOOL StillOk = Clipboard->CopyCompleted(); PostExportSubTree(); return (ok && StillOk); }

BOOL BrushDefinition::ExportBrush (  BaseCamelotFilter *  pFilter, const BrushHandle  Handle )

To export a Brush definition. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 22/12/99 Parameters: pFilter  - the BaseCamelotFilter filter that is being used to export a file. [INPUTS] Handle - the handle assigned to the brush Returns: TRUE if export was successful FALSE if export was aborted - no error is set, as in this case, it usually means that the Brush has been deleted, and is being treated as an old-style line. In this case, the caller should simply not bother exporting the attribute using the Brush definition. Notes: Do not call this function directly, it is better to call it via BrushComponent::ExportBrush as this ensures that each brush is only saved once Definition at line 3347 of file brshcomp.cpp. { ERROR2IF(pFilter == NULL, FALSE, "Filter is null"); ERROR2IF(Handle == BrushHandle_NoBrush, FALSE, "Trying to export null brush"); BOOL ok = TRUE; PreExportSubTree(); CXaraFileRecord Record(TAG_BRUSHDEFINITION, TAG_BRUSHDEFINITION_SIZE); if (ok) ok = Record.Init(); // first write the handle if (ok) ok = Record.WriteUINT32(Handle); if (ok) pFilter->Write(&Record); // then write the subtree - note that this may be moved to the superclass if (ok) { Node* pExportNode = NULL; if (m_pTree == NULL) ok = FALSE; else { pExportNode = m_pTree->FindFirstChild(); // Find the Layer if (pExportNode != NULL) pExportNode = pExportNode->FindFirstChild(); // Find the inknode } // Write out the clipart subtree. We have to encapsulate it in DOWN and UP // records ourselves CXaraFileRecord DownRec(TAG_DOWN, 0); if (ok) pFilter->Write(&DownRec); if (ok) ok = pFilter->WriteNodes(pExportNode); CXaraFileRecord UpRec(TAG_UP, 0); if (ok) pFilter->Write(&UpRec); } PostExportSubTree(); // now write the data, note that the handle is written here also as they // are retrieved separately and will need to be reconciled CXaraFileRecord DataRecord((INT32)TAG_BRUSHDATA, (INT32)TAG_BRUSHDATA_SIZE); if (ok) ok = DataRecord.Init(); BYTE Flags = 0; if (m_bTile) Flags |= TAG_BRUSHTILE_FLAG; if (m_bRotate) Flags |= TAG_BRUSHROTATE_FLAG; INT32 Offset = (INT32)m_PathOffsetType; if(ok) ok = DataRecord.WriteUINT32((UINT32)Handle); if (ok) ok = DataRecord.WriteINT32(m_BrushSpacing); if (ok) ok = DataRecord.WriteBYTE(Flags); if (ok) ok = DataRecord.WriteDOUBLE(m_RotateAngle); if (ok) ok = DataRecord.WriteINT32(Offset); if (ok) ok = DataRecord.WriteINT32(m_PathOffsetValue); if (ok) ok = DataRecord.WriteUnicode((TCHAR *)*(GetLineName())); if (ok) ok = DataRecord.WriteDOUBLE(m_BrushScaling); if (ok) pFilter->Write(&DataRecord); // write the additional data CXaraFileRecord NextRec(TAG_MOREBRUSHDATA, TAG_MOREBRUSHDATA_SIZE); if (ok) ok = NextRec.Init(); if (ok) ok = NextRec.WriteDOUBLE(m_BrushSpacingIncrProp); if (ok) ok = NextRec.WriteINT32(m_BrushSpacingIncrConst); if (ok) ok = NextRec.WriteINT32((INT32)m_BrushSpacingMaxRand); if (ok) ok = NextRec.WriteINT32((INT32)m_BrushSpacingRandSeed); if (ok) ok = NextRec.WriteDOUBLE(m_BrushScalingIncr); if (ok) ok = NextRec.WriteINT32((INT32)m_BrushScalingMaxRand); if (ok) ok = NextRec.WriteINT32((INT32)m_BrushScalingRandSeed); if (ok) ok = NextRec.WriteINT32((INT32)m_SequenceType); if (ok) ok = NextRec.WriteINT32((INT32)m_SequenceRandSeed); if (ok) ok = NextRec.WriteDOUBLE(m_PathOffsetIncrProp); if (ok) ok = NextRec.WriteINT32(m_PathOffsetIncrConst); if (ok) ok = NextRec.WriteINT32((INT32)m_OffsetTypeRandSeed); if (ok) ok = NextRec.WriteINT32((INT32)m_OffsetValueMaxRand); if (ok) ok = NextRec.WriteINT32((INT32)m_OffsetValueRandSeed); if (ok) ok = pFilter->Write(&NextRec); CXaraFileRecord AnotherRec(TAG_EVENMOREBRUSHDATA, TAG_EVENMOREBRUSHDATA_SIZE); if (ok) ok = AnotherRec.Init(); if (ok) ok = AnotherRec.WriteINT32((INT32)m_RotationMaxRand); if (ok) ok = AnotherRec.WriteINT32((INT32)m_RotationRandSeed); if (ok) ok = pFilter->Write(&AnotherRec); CXaraFileRecord PressureRec(TAG_BRUSHPRESSUREINFO, TAG_BRUSHPRESSUREINFO_SIZE); if (ok) ok = PressureRec.Init(); if (ok) ok = PressureRec.WriteINT32((INT32)m_ScalingMaxPressure); if (ok) ok = PressureRec.WriteINT32((INT32)m_SpacingMaxPressure); if (ok) ok = PressureRec.WriteINT32((INT32)m_OffsetMaxPressure); if (ok) ok = PressureRec.WriteINT32((INT32)m_RotationMaxPressure); if (ok) ok = PressureRec.WriteINT32((INT32)m_HueMaxPressure); if (ok) ok = PressureRec.WriteINT32((INT32)m_SatMaxPressure); if (ok) ok = PressureRec.WriteINT32((INT32)m_TimeStampMaxPressure); if (ok) ok = pFilter->Write(&PressureRec); // now write our transparency info CXaraFileRecord TranspRec(TAG_BRUSHTRANSPINFO, TAG_BRUSHTRANSPINFO_SIZE); if (ok) ok = TranspRec.Init(); if (ok) ok = TranspRec.WriteINT32(INT32(m_BrushTransparency)); if (ok) ok = TranspRec.WriteINT32(INT32(m_TranspMaxPressure)); if (ok) ok = TranspRec.WriteDOUBLE(m_RotAngleIncrConst); if (ok) ok = TranspRec.WriteDOUBLE(m_BrushScalingIncrConst); if (ok) ok = TranspRec.WriteINT32(INT32(m_BrushHueMaxRand)); if (ok) ok = TranspRec.WriteINT32(INT32(m_BrushHueRandSeed)); if (ok) ok = TranspRec.WriteINT32(INT32(m_BrushSatMaxRand)); if (ok) ok = TranspRec.WriteINT32(INT32(m_BrushSatRandSeed)); if (ok) ok = pFilter->Write(&TranspRec); // Finally, mark this stroke as having been written out so we don't do it again if (ok) SetIOStore(TRUE); return ok; }

BOOL BrushDefinition::GenerateBrush (   )

goes through the input spread and calls AddNewObject() for each ink object found We try to make some intelligent guesses about what to set the starting spacing and offset values depending on the nature of the nodes. The following rules apply: if there are multiple ink objects then the spacing is 1.1 * the largest dimension of the largest bounding box if there is only one object and it contains a positive line width spacing is as above if there is only one object with no line width then spacing is 10000 millipoint defaulf offset is always the largest dimension of the largest BBOX. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns TRUE if successful, FALSE otherwise Definition at line 340 of file brshcomp.cpp. { if (m_pTree == NULL) return FALSE; // get a node that points at the first child of the layer Node* pNode = m_pTree->FindFirstChild(); pNode = pNode->FindFirstChild(); AttrLineWidth* pLineWidth = NULL; while (pNode != NULL) { if (pNode->IsAnObject()) { // it has been drawn to my attention that it is possible to end up with a brush object // that has no line width attribute, which leads to all kinds of problems. So here we will // search for one and if we don't find one we will add one. ((NodeRenderableInk*)pNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrLineWidth), (NodeAttribute**)&pLineWidth); if (!pLineWidth) { pLineWidth = new AttrLineWidth(pNode, LASTCHILD); if (pLineWidth) { pLineWidth->Value.LineWidth = 501; pLineWidth = NULL; } } // we don't want to make brushes from brushes, instead we want to convert them // to shapes first, so use the routine to do that. NodeGroup* pGroup = NULL; ReplaceBrushWithGroup((NodeRenderableInk*)pNode, &pGroup); if (pGroup != NULL) { // we got a group, so we have to delete the original node pGroup->AttachNode(pNode, NEXT); pGroup->FactorOutCommonChildAttributes(); // unhook from the tree pNode->CascadeDelete(); // swap the pointers Node* pDelete = pNode; pNode = pGroup; delete pDelete; } if (!AddNewObject((NodeRenderableInk*)pNode)) return FALSE; } pNode = pNode->FindNext(); } CalculateMaxScaling(); m_bActivated = TRUE; return TRUE; }

BrushData * BrushDefinition::GetBrushData (   )

gets the latest data from our path processor, copies it into our BrushData object which is then returned. Note that you are responsible for deleting this object. 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 3108 of file brshcomp.cpp. { BrushData* pNewData = new BrushData; if (pNewData != NULL) InitialiseBrushData(pNewData); return pNewData; }

UINT32 BrushDefinition::GetBrushFileID (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the ID of the default file that this brush was created from (if there is one) See also: - Definition at line 2629 of file brshcomp.cpp. { return m_DefaultFileID; }

BrushRef * BrushDefinition::GetBrushRef (  UINT32  Index  )

as above 0 Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Index  - the array element to get [INPUTS] Returns: the brushref at position Index in the array, or NULL if the index is invalid See also: - Definition at line 2719 of file brshcomp.cpp. { // check that the index is ok if( Index > m_NumBrushObjects || Index > (UINT32)( m_BrushRefPtrArray.size() - 1 ) ) { ERROR3("Invalid index"); return NULL; } // update our member m_LastBrushRefRetrieved = Index; return m_BrushRefPtrArray[Index]; }

double BrushDefinition::GetBrushScaling (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the scaling factor to use when drawing the objects See also: - Definition at line 1991 of file brshcomp.cpp. { return m_BrushScaling; }

double BrushDefinition::GetBrushScalingIncr (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the scaling factor increment to use when drawing the objects See also: - Definition at line 2010 of file brshcomp.cpp. { return m_BrushScalingIncr; }

double BrushDefinition::GetBrushScalingIncrConst (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the scaling factor increment to use when drawing the objects See also: - Definition at line 2058 of file brshcomp.cpp. { return m_BrushScalingIncrConst; }

INT32 BrushDefinition::GetBrushTransparency (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Value  - the value to set [INPUTS] Returns: our transparency value See also: - Definition at line 2455 of file brshcomp.cpp. { return m_BrushTransparency; }

MILLIPOINT BrushDefinition::GetDefaultLineWidth (  BOOL  IgnorePressure = FALSE  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the height of the largest bounding box, to be used as a default line width See also: - Definition at line 2940 of file brshcomp.cpp. { DocRect BRect = GetLargestBoundingBox(); MILLIPOINT Height = BRect.Height(); MILLIPOINT Width = BRect.Width(); // double dHeight = (double)Height; // double dWidth = (double)Width; double ScaleFactor = 1.0; // firstly, if we are rotated, or have random rotation, then use the longest side // if (m_RotationMaxRand > 0 || m_RotateAngle != 0.0 || !m_bRotate) { if (Width > Height) Height = Width; } // next increase by our maximum possible random scaling if (m_BrushScalingMaxRand > 0) { // find out the random range UINT32 Lower = 0; UINT32 Upper = 0; PathProcessorBrush::GetRandomLimits(100, m_BrushScalingMaxRand, &Lower, &Upper); //Use the upper limit ScaleFactor *= ((double)Upper * 0.01); } // and our maximum possible pressure effect /* if (m_ScalingMaxPressure > 0 && !IgnorePressure) { ScaleFactor *= ((double)m_ScalingMaxPressure * 0.01 + 1); } */ MILLIPOINT NewHeight = (MILLIPOINT)((double)Height * ScaleFactor); // if we have random offset then there will be some effect, this is separate from the offset amount if (m_OffsetValueMaxRand > 0) { // rand value is a percentage of object size double RandMultiplier = (double)m_OffsetValueMaxRand * 0.01; double OffsetAmount = (double)Height * RandMultiplier; // remember that it goes both sides MILLIPOINT mpAmount = (MILLIPOINT)(2*OffsetAmount); NewHeight += mpAmount; } // if we are offset then add that amount switch (m_PathOffsetType) { case OFFSET_NONE: break; case OFFSET_LEFT: case OFFSET_RIGHT: case OFFSET_ALTERNATE: { MILLIPOINT OffsetIncr = 2 * m_PathOffsetValue; NewHeight += OffsetIncr; } break; case OFFSET_RANDOM: break; default: ERROR3("Invalid offset type"); } return NewHeight; }

BrushRef * BrushDefinition::GetFirstBrushRef (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the first in the brushref array See also: - Definition at line 2663 of file brshcomp.cpp. { if( m_BrushRefPtrArray.empty() ) { ERROR3("The array is empty!"); return NULL; } m_LastBrushRefRetrieved = 0; return m_BrushRefPtrArray[0]; }

UINT32 BrushDefinition::GetFirstRandomNumber (  UINT32  Seed = 0  )  [protected]

Seeds srand with either the seed supplied or by using time (i.e. a random seed). Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: a  seed to use to generate the random number sequence [INPUTS] Returns: the first number in a random number sequence See also: Definition at line 3200 of file brshcomp.cpp. { // seed the random number generator if (Seed == 0) srand( (unsigned)time( NULL ) ); else srand((unsigned)Seed); return (UINT32)rand(); }

double BrushDefinition::GetHueIncrement (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the hue increment for this brush See also: - Definition at line 2216 of file brshcomp.cpp. { return m_BrushHueIncrement; }

UINT32 BrushDefinition::GetHueMaxRand (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the hue increment random amount for this brush See also: - Definition at line 2255 of file brshcomp.cpp. { return m_BrushHueMaxRand; }

UINT32 BrushDefinition::GetHueRandSeed (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the hue increment random amount for this brush See also: - Definition at line 2295 of file brshcomp.cpp. { return m_BrushHueRandSeed; }

DocRect BrushDefinition::GetLargestBoundingBox (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the largest bounding box of all the objects in this definition See also: - Definition at line 2770 of file brshcomp.cpp. { // if the member is not empty then we have done this search so return it now if (!m_LargestBoundingBox.IsEmpty()) return m_LargestBoundingBox; // otherwise search through the brushrefs BrushRef* pBrushRef = GetFirstBrushRef(); DocRect BRect; DocRect BiggestRect; XLONG BiggestArea = 0; while (pBrushRef != NULL) { BRect = pBrushRef->GetBoundingRect(); XLONG RectHeight = BRect.Height(); XLONG RectWidth = BRect.Width(); XLONG ThisRectArea = RectHeight * RectWidth; if (ThisRectArea > BiggestArea) { BiggestRect = BRect; BiggestArea = ThisRectArea; } pBrushRef = GetNextBrushRef(); } m_LargestBoundingBox = BiggestRect; return BiggestRect; }

DocRect BrushDefinition::GetLargestPossibleRect (  BOOL  AdjustForLineWidth = FALSE  )

To find out the largest possible bounding box that this brush can achieve, this we get the largest ink rect and then perform the maximum scaling, rotation etc. Note that ScalingIncrConst will be will be excluded from this test as we will never be able to know what affect it will have in advance of drawing the path. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: AdjustForLineWidth  - do we include scaling to the current line width in our [INPUTS] calculations? Returns: the largest bounding box of all the objects in this definition, plus adjustments for variations in scale Note: Only use this function to determine the size of the bounding box, the location information should not be used. See also: - Definition at line 2825 of file brshcomp.cpp. { DocRect BRect = GetLargestBoundingBox(); if (BRect.IsEmpty()) // just quit now return BRect; double Scale = 1.0; MILLIPOINT LineWidth = GetDefaultLineWidth(TRUE); // if we are including the scale to linewidth then work that out here if (AdjustForLineWidth) { MILLIPOINT CurrentLineWidth = OpDrawBrush::GetCurrentLineWidthIfNotDefault(); if (CurrentLineWidth != -1 && CurrentLineWidth > 501) // -1 indicates the default linewidth, hence no scaling { Scale = (double)CurrentLineWidth / (double)LineWidth; // otherwise use the current line width LineWidth = CurrentLineWidth; } } // increase the size if we have randomness or pressure UINT32 MaxRand = GetScalingMaxRand(); double dRand = ((double)MaxRand * 0.01) + 1.0; UINT32 MaxPressure = GetScalingMaxPressure(); double dPressure = ((double)MaxPressure * 0.01) + 1.0; Scale *= dRand; Scale *= dPressure; if (Scale != 1.0) { double Height = (double)BRect.Height() * Scale; double Width = (double)BRect.Width() * Scale; BRect.lo.x = 0; BRect.hi.x = (MILLIPOINT)Height; BRect.lo.y = 0; BRect.hi.y = (MILLIPOINT)Width; } // DocRect BRect(0, 0, LineWidth* 1.1, LineWidth* 1.1); // as the shape might get rotated we make sure the bitmap is big enough to cope // so make a temporary rect, rotate it and expand it, and union it with the original if (m_bRotate || m_RotateAngle || m_RotAngleIncrConst || m_RotationMaxRand) { DocRect TempRect = BRect; BrushAttrValue::RotateBounds(90, &TempRect); BRect = BRect.Union(TempRect); TempRect = BRect; BrushAttrValue::RotateBounds(45, &TempRect); BRect = BRect.Union(TempRect); } return BRect; }

double BrushDefinition::GetMaxScaling (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns the maximum scaling value Definition at line 1146 of file brshcomp.cpp. { return m_MaxScaling; }

BrushRef * BrushDefinition::GetNextBrushRef (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the next element in the brushref array, as kept track of by m_LastBrushRefRetrieved See also: - Definition at line 2690 of file brshcomp.cpp. { // have we hit the end? if( m_LastBrushRefRetrieved >= m_NumBrushObjects - 1 ) return NULL; // quick check so we don't violate if( m_LastBrushRefRetrieved >= (UINT32)m_BrushRefPtrArray.size() - 1 ) { ERROR3("Overran the array"); return NULL; } return m_BrushRefPtrArray[++m_LastBrushRefRetrieved]; }

UINT32 BrushDefinition::GetNextRandomNumber (   )  [protected]

as above, note that you MUST have already called GetFirstRandomNumber() Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the next number in an already seeded random number sequence See also: Definition at line 3225 of file brshcomp.cpp. { return (UINT32)rand(); }

UINT32 BrushDefinition::GetNumBrushObjects (   )  const

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the number of brush objects used by this brush See also: - Definition at line 2610 of file brshcomp.cpp. { return m_NumBrushObjects; }

UINT32 BrushDefinition::GetOffsetTypeRandSeed (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the seed used to determine the sequence of random numbers for offset value Definition at line 1610 of file brshcomp.cpp. { return m_OffsetTypeRandSeed; }

UINT32 BrushDefinition::GetOffsetValueMaxRand (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the maximum percentage randomness to be applied to Offset Definition at line 1535 of file brshcomp.cpp. { return m_OffsetValueMaxRand; }

UINT32 BrushDefinition::GetOffsetValueRandSeed (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the seed used to determine the sequence of random numbers for offset value Definition at line 1574 of file brshcomp.cpp. { return m_OffsetValueRandSeed; }

MILLIPOINT BrushDefinition::GetPathOffsetIncrConst (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: The value of the constant path offset increment used by this brush See also: - Definition at line 1451 of file brshcomp.cpp. { return m_PathOffsetIncrConst; }

double BrushDefinition::GetPathOffsetIncrProp (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: The value of the proportional path offset increment used by this brush See also: - Definition at line 1492 of file brshcomp.cpp. { return m_PathOffsetIncrProp; }

PathOffset BrushDefinition::GetPathOffsetType (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: The type of pathoffset this brush is using See also: - Definition at line 1379 of file brshcomp.cpp. { return m_PathOffsetType; }

MILLIPOINT BrushDefinition::GetPathOffsetValue (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: The value of the path offset used by this brush See also: - Definition at line 1415 of file brshcomp.cpp. { return m_PathOffsetValue; }

double BrushDefinition::GetRotationAngle (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the angle of rotation that has been set See also: - Definition at line 1713 of file brshcomp.cpp. { return m_RotateAngle; }

double BrushDefinition::GetRotationIncrConst (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the increment to the angle of rotation See also: - Definition at line 1752 of file brshcomp.cpp. { return m_RotAngleIncrConst; }

double BrushDefinition::GetRotationIncrProp (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the increment to the angle of rotation See also: - Definition at line 1791 of file brshcomp.cpp. { return m_RotAngleIncrProp; }

UINT32 BrushDefinition::GetRotationMaxPressure (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the seed to use to generate the rotation RNG See also: - Definition at line 1886 of file brshcomp.cpp. { return m_RotationMaxPressure; }

UINT32 BrushDefinition::GetRotationMaxRand (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the maximum amount of randomness to be applied to the rotation angle See also: - Definition at line 1809 of file brshcomp.cpp. { return m_RotationMaxRand; }

UINT32 BrushDefinition::GetRotationRandSeed (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the seed to use to generate the rotation RNG See also: - Definition at line 1848 of file brshcomp.cpp. { return m_RotationRandSeed; }

double BrushDefinition::GetSatIncrement (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the Saturation increment for this brush See also: - Definition at line 2335 of file brshcomp.cpp. { return m_BrushSatIncrement; }

UINT32 BrushDefinition::GetSatMaxRand (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the Saturation increment random amount for this brush See also: - Definition at line 2374 of file brshcomp.cpp. { return m_BrushSatMaxRand; }

UINT32 BrushDefinition::GetSatRandSeed (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the Saturation increment random amount for this brush See also: - Definition at line 2414 of file brshcomp.cpp. { return m_BrushSatRandSeed; }

UINT32 BrushDefinition::GetScalingMaxPressure (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the maximum percentage effect that pressure will have on Scaling Definition at line 2175 of file brshcomp.cpp. { return m_ScalingMaxPressure; }

UINT32 BrushDefinition::GetScalingMaxRand (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the maximum percentage randomness to be applied to Scaling Definition at line 2101 of file brshcomp.cpp. { return m_BrushScalingMaxRand; }

UINT32 BrushDefinition::GetScalingRandSeed (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the seed used to determine the sequence of random numbers for Scaling Definition at line 2140 of file brshcomp.cpp. { return m_BrushScalingRandSeed; }

UINT32 BrushDefinition::GetSequenceSeed (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the seed we are using to generate random sequences See also: - Definition at line 2592 of file brshcomp.cpp. { return m_SequenceRandSeed; }

SequenceType BrushDefinition::GetSequenceType (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the type of sequence we are using for mutliple ink objects See also: - Definition at line 2535 of file brshcomp.cpp. { return m_SequenceType; }

MILLIPOINT BrushDefinition::GetSpacing (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the spacing between the brush objects Definition at line 1188 of file brshcomp.cpp. { return m_BrushSpacing; }

MILLIPOINT BrushDefinition::GetSpacingIncrConst (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the constant spacing increment between the brush objects Definition at line 1286 of file brshcomp.cpp. { return m_BrushSpacingIncrConst; }

double BrushDefinition::GetSpacingIncrProp (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the proportional spacing increment between the brush objects Definition at line 1240 of file brshcomp.cpp. { return m_BrushSpacingIncrProp; }

UINT32 BrushDefinition::GetSpacingMaxRand (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the maximum percentage randomness to be applied to spacing Definition at line 1304 of file brshcomp.cpp. { return m_BrushSpacingMaxRand; }

UINT32 BrushDefinition::GetSpacingRandSeed (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: the seed used to determine the sequence of random numbers for spacing Definition at line 1343 of file brshcomp.cpp. { return m_BrushSpacingRandSeed; }

double BrushDefinition::GetTimeStampingPeriod (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the time stamping period for this brush, if zero then timestamping is disabled See also: - Definition at line 2898 of file brshcomp.cpp. { return m_TimeStampPeriod; }

UINT32 BrushDefinition::GetTransparencyPressure (   )

Sets the extent to which pressure affects transparency. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Value  - the value to set [INPUTS] Returns: See also: - Definition at line 2516 of file brshcomp.cpp. { return m_TranspMaxPressure; }

void BrushDefinition::InitialiseBrushArray (  UINT32  NumObjects  )  [protected]

Clears out the m_BrushRefPtrArray if it is not empty, and sets the size. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Number  of objects to size the array at [INPUTS] Returns: - Definition at line 658 of file brshcomp.cpp. { size_t i = 0; while( i < m_BrushRefPtrArray.size() ) { delete m_BrushRefPtrArray[i++]; } m_BrushRefPtrArray.clear(); m_BrushRefPtrArray.resize( NumObjects ); // fill the array with NULL objects so that we can check later // to see if our allocations have worked i = 0; while( i < m_BrushRefPtrArray.size() ) { m_BrushRefPtrArray[i++] = NULL; } }

void BrushDefinition::InitialiseBrushData (  BrushData *  pData  )

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 3029 of file brshcomp.cpp. { pData->m_BrushHandle = 100; pData->m_BrushScaling = m_BrushScaling; pData->m_BrushScalingIncr = m_BrushScalingIncr; pData->m_BrushScalingMaxRand = m_BrushScalingMaxRand; pData->m_BrushScalingRandSeed = m_BrushScalingRandSeed; pData->m_ScalingMaxPressure = m_ScalingMaxPressure; pData->m_bRotate = m_bRotate; pData->m_RotateAngle = m_RotateAngle; pData->m_RotAngleIncrConst = m_RotAngleIncrConst; pData->m_RotAngleIncrProp = m_RotAngleIncrProp; pData->m_RotationMaxRand = m_RotationMaxRand; pData->m_RotationRandSeed = m_RotationRandSeed; pData->m_BrushSpacing = m_BrushSpacing; pData->m_BrushSpacingIncrConst = m_BrushSpacingIncrConst; pData->m_BrushSpacingIncrProp = m_BrushSpacingIncrProp; pData->m_BrushSpacingMaxRand = m_BrushSpacingMaxRand; pData->m_BrushSpacingRandSeed = m_BrushSpacingRandSeed; pData->m_PathOffsetType = m_PathOffsetType; pData->m_PathOffsetValue = m_PathOffsetValue; pData->m_PathOffsetIncrConst = m_PathOffsetIncrConst; pData->m_PathOffsetIncrProp = m_PathOffsetIncrProp; pData->m_OffsetValueMaxRand = m_OffsetValueMaxRand; pData->m_OffsetValueRandSeed = m_OffsetValueRandSeed; pData->m_OffsetTypeRandSeed = m_OffsetTypeRandSeed; pData->m_bTile = m_bTile; pData->m_SequenceType = m_SequenceType; pData->m_SequenceRandSeed = m_SequenceRandSeed; pData->m_bUseLocalFillColour = FALSE; pData->m_BrushHueIncrement = m_BrushHueIncrement; pData->m_BrushHueMaxRand = m_BrushHueMaxRand; pData->m_BrushHueRandSeed = m_BrushHueRandSeed; pData->m_BrushSatIncrement = m_BrushSatIncrement; pData->m_BrushSatMaxRand = m_BrushSatMaxRand; pData->m_BrushSatRandSeed = m_BrushSatRandSeed; pData->m_BrushTransparency = m_BrushTransparency; pData->m_TranspMaxPressure = m_TranspMaxPressure; if (m_TimeStampPeriod <=0) { pData->m_bTimeStampBrushes = FALSE; pData->m_TimeStampPeriod = UINT32(-1); } else { pData->m_bTimeStampBrushes = TRUE; pData->m_TimeStampPeriod = (UINT32)m_TimeStampPeriod; } pData->m_Name = *GetLineName(); }

BOOL BrushDefinition::IsActivated (   )

To see if this definition was initialised ok or if it was subsequently deactivated for some reason. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns the member indicating whether this definition is active Definition at line 572 of file brshcomp.cpp. { return m_bActivated; }

BOOL BrushDefinition::IsDifferent (  LineDefinition *  pOther  )  [virtual]

Determine if 2 BrushDefinitions are considered different. Used when adding Brushes to the global list, so that like Brushes can be merged. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pOther  - the Brush to compare this Brush to [INPUTS] Returns: TRUE if they're different in any way, FALSE if they are identical definitions Implements LineDefinition. Definition at line 698 of file brshcomp.cpp. { ERROR3IF(pOther == NULL, "Illegal NULL param"); // String_32* pName = pOther->GetLineName(); if (!m_Name.IsIdentical(*pOther->GetLineName())) return(TRUE); if (pOther->GetLineTree() == NULL || m_pTree == NULL) { ERROR3("BrushDefinition has not been properly initialised"); return(TRUE); } /* // --- Check to see if the brush bounds are equal DocRect OtherBounds = ((Spread *)(pOther->GetLineTree()))->GetBoundingRect(); DocRect Bounds = ((Spread *)m_pTree)->GetBoundingRect(); if (Bounds != OtherBounds) return(TRUE); */ // --- Check the subtrees node-for-node to see if they are the same Node *pCurNode1 = m_pTree->FindFirstDepthFirst(); Node *pCurNode2 = pOther->GetLineTree()->FindFirstDepthFirst(); while (pCurNode1 != NULL && pCurNode2 != NULL) { // if they are fill attributes then we want to translate both attributes to the origin. // This prevents us getting duplication of brushes when we have the // same thing in a different place, note that occasionally this fails due to rounding errors. if (pCurNode1->IsAFillAttr() && pCurNode2->IsAFillAttr() && !((AttrFillGeometry*)pCurNode1)->IsAStrokeColour() && !((AttrFillGeometry*)pCurNode1)->IsAStrokeTransp()) { AttrFillGeometry* pFill1 = (AttrFillGeometry*)pCurNode1; AttrFillGeometry* pFill2 = (AttrFillGeometry*)pCurNode2; DocCoord* pStartPoint1 = pFill1->GetStartPoint(); DocCoord* pStartPoint2 = pFill2->GetStartPoint(); // translate them both to 0,0 if (pStartPoint1 && pStartPoint2) { Trans2DMatrix Trans1(-pStartPoint1->x, -pStartPoint1->y); Trans2DMatrix Trans2(-pStartPoint2->x, -pStartPoint2->y); pFill1->Transform(Trans1); pFill2->Transform(Trans2); BOOL Different = FALSE; if (pCurNode1->IsDifferent(pCurNode2)) Different = TRUE; Trans1.Invert(); Trans2.Invert(); pFill1->Transform(Trans1); pFill2->Transform(Trans2); if (Different == TRUE) return TRUE; } } else // likewise if they are an object then translate from the centre of the bounding // rect to the origin if (pCurNode1->IsAnObject() && pCurNode2->IsAnObject()) { NodeRenderableInk* pInk1 = (NodeRenderableInk*)pCurNode1; NodeRenderableInk* pInk2 = (NodeRenderableInk*)pCurNode2; DocRect BRect1 = ((NodeRenderableInk*)pCurNode1)->GetBoundingRect(); DocRect BRect2 = ((NodeRenderableInk*)pCurNode2)->GetBoundingRect(); DocCoord Coord1 = BRect1.Centre(); DocCoord Coord2 = BRect2.Centre(); Trans2DMatrix Trans1(-Coord1.x, -Coord1.y); Trans2DMatrix Trans2(-Coord2.x, -Coord2.y); pInk1->Transform(Trans1); pInk2->Transform(Trans2); BOOL Different = FALSE; if (pCurNode1->IsDifferent(pCurNode2)) Different = TRUE; Trans1.Invert(); Trans2.Invert(); pInk1->Transform(Trans1); pInk2->Transform(Trans2); if (Different ==TRUE) return TRUE; } else { // otherwise just use the regular == operator if (pCurNode1->IsDifferent(pCurNode2)) return(TRUE); } // And go to the next node in both brushes pCurNode1 = pCurNode1->FindNextDepthFirst(m_pTree); pCurNode2 = pCurNode2->FindNextDepthFirst(pOther->GetLineTree()); } if (!AreBrushParametersIdentical((BrushDefinition*)pOther)) return TRUE; // If we did the entire search and both pointers ended up NULL simultaneously, then // we have an exact match if (pCurNode1 == NULL && pCurNode2 == NULL) return(FALSE); return(TRUE); }

BOOL BrushDefinition::IsRotated (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: [INPUTS]  Returns: whether or not the brush objects are rotated See also: - Definition at line 1928 of file brshcomp.cpp. { return m_bRotate; }

BOOL BrushDefinition::IsTiled (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: [INPUTS]  Returns: whether or not the brush tiles See also: - Definition at line 1668 of file brshcomp.cpp. { return m_bTile; }

BOOL BrushDefinition::ObjectCanCreateBrush (  NodeRenderableInk *  pObject  )  [static]

To determine if this ink node can be made into a brush, currently returns TRUE for except for bevels, shadows, and contours, which are too damn awkward. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 16/6/2000 Parameters: pObject  - the object to test [INPUTS] Returns TRUE if we are allowed to make a brush out of this object, FALSE otherwise Definition at line 1014 of file brshcomp.cpp. { ERROR2IF(pObject == NULL, FALSE, "Object is NULL in BrushDefinition::ObjectCanCreateBrush"); // only way to do it is some ugly IKO's if (pObject->IS_KIND_OF(NodeShadow)) return FALSE; if (pObject->IS_KIND_OF(NodeContour)) return FALSE; if (pObject->IS_KIND_OF(NodeBevel)) return FALSE; // if its compound then check all the children if (pObject->IsCompound()) { Node* pChild = pObject->FindFirstChild(); while (pChild) { if (pChild->IsAnObject()) { if (!ObjectCanCreateBrush((NodeRenderableInk*)pChild)) return FALSE; } pChild = pChild->FindNext(); } } return TRUE; }

BOOL BrushDefinition::PostExportSubTree (   )  [protected]

To perform various functions just prior to saving the subtree of the brush definition. The function loops through the BrushRefs, finding the blendpaths of each and undoes the transformation performed by PreExportSubTree. This is required because to continue using the brush in our current document we want to use its current position. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: TRUE if successful, FALSE if something went wrong See also: - Notes: This function is required because if the attribute map is not saved out at the exact position it was created it will become 'out of sync' with the blendpath it applies to. Recall that upon reimporting the brush the blendpaths are generated from scratch whereas the attributes are not. Definition at line 3537 of file brshcomp.cpp. { BrushRef* pBrushRef = GetFirstBrushRef(); while (pBrushRef != NULL) { BlendPath * pBlendPath = pBrushRef->GetFirstBlendPath(); while (pBlendPath != NULL) { if (!pBlendPath->TransformBrushAttributesAfterSave()) ERROR3("Somethings gone wrong"); pBlendPath = pBrushRef->GetNextBlendPath(pBlendPath); } pBrushRef = GetNextBrushRef(); } return TRUE; }

BOOL BrushDefinition::PreExportSubTree (   )  [protected]

To perform various functions just prior to saving the subtree of the brush definition. The function loops through the BrushRefs, finding the blendpaths of each and transforming their attribute maps back to the position that they were in when the brush was created. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: TRUE if successful, FALSE if something went wrong See also: - Notes: This function is required because if the attribute map is not saved out at the exact position it was created it will become 'out of sync' with the blendpath it applies to. Recall that upon reimporting the brush the blendpaths are generated from scratch whereas the attributes are not. Definition at line 3495 of file brshcomp.cpp. { BrushRef* pBrushRef = GetFirstBrushRef(); ERROR2IF(pBrushRef== NULL, FALSE, "No brushref"); while (pBrushRef != NULL) { BlendPath * pBlendPath = pBrushRef->GetFirstBlendPath(); while (pBlendPath != NULL) { if (!pBlendPath->TransformBrushAttributesBeforeSave()) ERROR2(FALSE, "Somethings gone wrong"); pBlendPath = pBrushRef->GetNextBlendPath(pBlendPath); } pBrushRef = GetNextBrushRef(); } return TRUE; }

BOOL BrushDefinition::RegenerateBrush (   )

This function deletes the existing brushrefs and recreates them from scratch from m_pTree. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns TRUE if successful, FALSE otherwise Notes: This function is necessary because of the inaccuracies in our matrix transformation system which make it impossible to repeatedly scale without either growing our objects. Therefore it is recommended that after every render where an object is scaled this function should be called to regenerate the brush. Obviously the potential for disaster is very high for instance we run out of memory in the middle of the operation. Definition at line 501 of file brshcomp.cpp. { /* As we now always take copies of the brush objects, this is scheduled for demolition... // first we need to transform all the attributes back to where they began PreExportSubTree(); // make a temporary array to hold the existing elements, as we do not wish // to delete them until we are sure regeneration went ok CTypedPtrArray <CPtrArray, BrushRef*> TempArray; TempArray.SetSize(MAX_BRUSH_OBJECTS, -1); // fill the array with our existing objects BrushRef* pRef = NULL; INT32 i = 0; for (i = 0; i < TempArray.GetSize(); i++) { pRef = m_BrushRefPtrArray[i]; TempArray.SetAt(i, pRef); m_BrushRefPtrArray.SetAt(i, NULL); // set existing pointer to null } m_NumBrushObjects = 0; // now remake ourselves if (GenerateBrush() == TRUE) { // delete the existing brushrefs for (i = 0; i < TempArray.GetSize(); i++) { if (TempArray[i] != NULL) { delete TempArray[i]; } } TempArray.RemoveAll(); return TRUE; } // ok so something went wrong, not much we can do except for restore the original objects // and hope for the best ERROR3("Uh oh - Regenerate Brush failed"); pRef = NULL; i= 0; for (i = 0; i < TempArray.GetSize(); i++) { pRef = TempArray[i]; m_BrushRefPtrArray.SetAt(i, pRef); // set existing pointer to null TempArray[i] = NULL; } */ return TRUE; }

BOOL BrushDefinition::ReplaceBrushWithGroup (  NodeRenderableInk *  pInk, NodeGroup **  ppGroup )  [protected]

We are no longer allowed to make brushes from brushes, because of problems when saving and loading. Instead if we have a brush then we will convert it to shapes and use those instead. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pInk  - the inknode that we are going to generate a brush from [INPUTS] if  pInk has a brush attribute applied to it then we will generate a new group [OUTPUTS] from that brush Returns TRUE if successful, FALSE otherwise Note: So you actually have to delete pInk yourself if this function outputs a group. I had to do that to get the recursion to work. Still I'm sure you can handle it. Definition at line 419 of file brshcomp.cpp. { ERROR2IF(pInk == NULL, FALSE, "Invalid inputs to BrushDefinition::ReplaceBrushWithGroups"); BOOL ok = TRUE; // if we're compound then search through all our children first if (pInk->IsCompound()) { NodeGroup* pNodeGroup = NULL; Node* pChild = pInk->FindFirstChild(); Node* pDelete = NULL; while (pChild) { if (pChild->IsAnObject()) { if (ok) ok = ReplaceBrushWithGroup((NodeRenderableInk*)pChild, &pNodeGroup); if (pNodeGroup) { // attach the new group next to the child pNodeGroup->AttachNode(pChild, NEXT); pNodeGroup->FactorOutCommonChildAttributes(); // unhook the child pChild->CascadeDelete(); // we're ready to delete the original child pDelete = pChild; // swap the pointer pChild = pNodeGroup; delete pDelete; } } pChild = pChild->FindNext(); pNodeGroup = NULL; } } AttrBrushType* pAttrBrush = NULL; pInk->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), (NodeAttribute**)&pAttrBrush); if (pAttrBrush && pAttrBrush->GetBrushHandle() != BrushHandle_NoBrush && ok) { //Turn the brush into a group with lots of nodepaths BrushBecomeAGroup BecomeA(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL); ok = pAttrBrush->DoBecomeA(&BecomeA, pInk); // the brush will create a group out of itself and we want to retrieve that NodeGroup* pBrushGroup = BecomeA.GetNodeGroup(); pBrushGroup->FactorOutCommonChildAttributes(); pBrushGroup->NormaliseAttributes(); if (pBrushGroup != NULL && ok) { *ppGroup = pBrushGroup; } } return ok; }

void BrushDefinition::ResetMembers (   )  [protected]

Initialises the member variables. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns - Definition at line 258 of file brshcomp.cpp. { m_BrushSpacing = 10000; m_BrushSpacingIncrProp = 1.0; m_BrushSpacingIncrConst = 0; m_BrushSpacingMaxRand = 0; m_BrushSpacingRandSeed = 0; m_PathOffsetType = OFFSET_NONE; m_PathOffsetValue = 0; m_PathOffsetIncrProp = 1.0; m_PathOffsetIncrConst = 0; m_OffsetTypeRandSeed = 0; m_OffsetValueMaxRand = 0; m_OffsetValueRandSeed = 0; m_bRotate = TRUE; m_RotateAngle = 0; m_RotationMaxRand = 0; m_RotationRandSeed = 0; m_RotAngleIncrConst = 0; m_RotAngleIncrProp = 1.0; m_RotationMaxPressure = 0; m_bTile = TRUE; m_BrushScaling = 1.0; m_BrushScalingIncr = 1.0; m_BrushScalingIncrConst = 0.0; m_BrushScalingMaxRand = 0; m_BrushScalingRandSeed = 0; m_ScalingMaxPressure = 35; m_BrushHueIncrement = 0.0; m_BrushHueMaxRand = 0; m_BrushHueRandSeed = 1234; m_BrushSatIncrement = 0.0; m_BrushSatMaxRand = 0; m_BrushSatRandSeed = 5432; m_SequenceType = SEQ_FORWARD; m_SequenceRandSeed = 0; m_NumBrushObjects = 0; m_bInitOk = FALSE; m_LargestBoundingBox.MakeEmpty(); m_Name = TEXT("Custom Brush"); m_TimeStampPeriod = 0; m_BrushTransparency = 100; m_TranspMaxPressure = 0; m_DefaultFileID = BRUSHFILE_NONE; m_bActivated = FALSE; }

void BrushDefinition::SetActivated (  BOOL  Value  )

To set this definition activated or not. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: Value  - the value to set [INPUTS] Returns - Definition at line 590 of file brshcomp.cpp. { m_bActivated = Value; }

void BrushDefinition::SetBrushFileID (  UINT32  ID  )

as above, this should only be called as part of the start-up process. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: ID  - the ID of the default file that this file is being created from [INPUTS] Returns: - Definition at line 2645 of file brshcomp.cpp. { m_DefaultFileID = ID; }

BOOL BrushDefinition::SetBrushScaling (  double  Scale  )

to set the member that determine to what scale of the original object each brush object is drawn Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  scale factor to set [INPUTS] Returns: TRUE if Scale is within the permitted bounds See also: - Definition at line 1968 of file brshcomp.cpp. { if (Scale <= MIN_BRUSH_SCALE || Scale >= MAX_BRUSH_SCALE) return FALSE; m_BrushScaling = Scale; return TRUE; }

BOOL BrushDefinition::SetBrushScalingIncr (  double  Incr  )

to set the member that determine the increment to scaling applied to each brush object Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  scale factor increment to set [INPUTS] Returns: TRUE unless incr is negative See also: - Definition at line 2032 of file brshcomp.cpp. { if (Incr <= 0) { ERROR3("Negative scaling increment"); return FALSE; } m_BrushScalingIncr = Incr; return TRUE; }

BOOL BrushDefinition::SetBrushScalingIncrConst (  double  Incr  )

to set the member that determine the increment to scaling applied to each brush object Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  scale factor increment to set [INPUTS] Returns: TRUE unless Incr >= 100 See also: - Definition at line 2080 of file brshcomp.cpp. { if (abs((INT32)Incr) >= 100) { return FALSE; } m_BrushScalingIncrConst = Incr; return TRUE; }

BOOL BrushDefinition::SetBrushTransparency (  INT32  Value  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Value  - the value to set [INPUTS] Returns: our transparency value (-1 indicates unused) See also: - Definition at line 2473 of file brshcomp.cpp. { if (Value > MAX_TRANSP_VALUE) return FALSE; m_BrushTransparency = Value; return TRUE; }

BOOL BrushDefinition::SetHueIncrement (  double  Incr  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  hue increment for this brush [INPUTS] Returns: - See also: - Definition at line 2235 of file brshcomp.cpp. { m_BrushHueIncrement = Incr; return TRUE; }

BOOL BrushDefinition::SetHueMaxRand (  UINT32  Rand  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  hue increment random amount for this brush [INPUTS] Returns: - See also: - Definition at line 2275 of file brshcomp.cpp. { m_BrushHueMaxRand = Rand; return TRUE; }

BOOL BrushDefinition::SetHueRandSeed (  UINT32  Rand  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  hue increment random amount for this brush [INPUTS] Returns: - See also: - Definition at line 2315 of file brshcomp.cpp. { m_BrushHueRandSeed = Rand; return TRUE; }

void BrushDefinition::SetMembersFromData (  BrushData  Data  )

gets the latest data from our path processor, copies it into our BrushData object which is then returned. Note that you are responsible for deleting this object. 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 3130 of file brshcomp.cpp. { m_BrushSpacing = Data.m_BrushSpacing; m_BrushSpacingIncrProp = Data.m_BrushSpacingIncrProp; m_BrushSpacingIncrConst = Data.m_BrushSpacingIncrConst; m_BrushSpacingMaxRand = Data.m_BrushSpacingMaxRand; m_BrushSpacingRandSeed = Data.m_BrushSpacingRandSeed; m_PathOffsetType = Data.m_PathOffsetType; m_PathOffsetValue = Data.m_PathOffsetValue; m_PathOffsetIncrProp = Data.m_PathOffsetIncrProp; m_PathOffsetIncrConst = Data.m_PathOffsetIncrConst; m_OffsetTypeRandSeed = Data.m_OffsetTypeRandSeed; m_OffsetValueMaxRand = Data.m_OffsetValueMaxRand; m_OffsetValueRandSeed = Data.m_OffsetValueRandSeed; m_bRotate = Data.m_bRotate; m_RotateAngle = Data.m_RotateAngle; m_RotationMaxRand = Data.m_RotationMaxRand; m_RotationRandSeed = Data.m_RotationRandSeed; m_RotAngleIncrConst = Data.m_RotAngleIncrConst; m_RotAngleIncrProp = Data.m_RotAngleIncrProp; m_RotationMaxPressure = Data.m_RotationMaxPressure; m_bTile = Data.m_bTile; m_BrushScaling = Data.m_BrushScaling; m_BrushScalingIncr = Data.m_BrushScalingIncr; m_BrushScalingIncrConst = Data.m_BrushScalingIncrConst; m_BrushScalingMaxRand = Data.m_BrushScalingMaxRand; m_BrushScalingRandSeed = Data.m_BrushScalingRandSeed; m_ScalingMaxPressure = Data.m_ScalingMaxPressure; m_BrushHueIncrement = Data.m_BrushHueIncrement; m_BrushHueMaxRand = Data.m_BrushHueMaxRand; m_BrushHueRandSeed = Data.m_BrushHueRandSeed; m_BrushSatIncrement = Data.m_BrushSatIncrement; m_BrushSatMaxRand = Data.m_BrushSatMaxRand; m_BrushSatRandSeed = Data.m_BrushSatRandSeed; m_BrushTransparency = Data.m_BrushTransparency; m_TranspMaxPressure = Data.m_TranspMaxPressure; m_SequenceType = Data.m_SequenceType; m_SequenceRandSeed = Data.m_SequenceRandSeed; m_LargestBoundingBox.MakeEmpty(); m_Name = TEXT("Custom Brush"); m_TimeStampPeriod = Data.m_TimeStampPeriod; }

void BrushDefinition::SetOffsetTypeRandSeed (  UINT32  Value  )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/9 Inputs : the seed used to determine the sequence of random numbers for offset value Returns: TRUE if Value is valid, which it always is at the moment Definition at line 1628 of file brshcomp.cpp. { m_OffsetValueRandSeed = Value; }

BOOL BrushDefinition::SetOffsetValueMaxRand (  UINT32  Value  )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: :  the maximum percentage randomness to be applied to Offset [INPUTS] Returns: TRUE if Value is within the legal limits, otherwise FALSE Definition at line 1553 of file brshcomp.cpp. { if (Value < MIN_BRUSH_RAND || Value > MAX_BRUSH_RAND) return FALSE; m_OffsetValueMaxRand = Value; return TRUE; }

void BrushDefinition::SetOffsetValueRandSeed (  UINT32  Value  )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/9 Inputs : the seed used to determine the sequence of random numbers for offset value Returns: TRUE if Value is valid, which it always is at the moment Definition at line 1592 of file brshcomp.cpp. { m_OffsetValueRandSeed = Value; }

BOOL BrushDefinition::SetPathOffsetIncrConst (  MILLIPOINT  Value  )

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 increment value to set Returns: - Definition at line 1469 of file brshcomp.cpp. { if (Value < 0 || Value > MAX_BRUSH_SPACING) return FALSE; m_PathOffsetIncrConst = Value; return TRUE; }

BOOL BrushDefinition::SetPathOffsetIncrProp (  double  Incr  )

to set the offset distance for this brush Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Inputs incr - the proportional offset increment value to set Returns: - Definition at line 1510 of file brshcomp.cpp. { if (Incr < 0 ) return FALSE; // test to see if 10 objects takes us to the limit double TenIncr = pow(Incr, 10.0); if ((m_PathOffsetValue * TenIncr) >= MAX_BRUSH_SPACING) return FALSE; m_PathOffsetIncrProp = Incr; return TRUE; }

void BrushDefinition::SetPathOffsetType (  PathOffset  Offset  )

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 1396 of file brshcomp.cpp. { m_PathOffsetType = Offset; }

void BrushDefinition::SetPathOffsetValue (  MILLIPOINT  Value  )

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 1432 of file brshcomp.cpp. { m_PathOffsetValue = Value; }

void BrushDefinition::SetRotated (  BOOL  Value  )

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 1947 of file brshcomp.cpp. { m_bRotate = Value; }

BOOL BrushDefinition::SetRotationAngle (  double  Angle  )

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 1688 of file brshcomp.cpp. { /* if ((Angle <= MIN_ANGLE) || (Angle >= MAX_ANGLE)) { ERROR3("Invalid angle"); return FALSE; }*/ m_RotateAngle = Angle; return TRUE; }

BOOL BrushDefinition::SetRotationIncrConst (  double  Angle  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  incremental angle of rotation to set [INPUTS] Returns: TRUE if the angle is within the stated bounds See also: - Definition at line 1732 of file brshcomp.cpp. { m_RotAngleIncrConst = Angle; return TRUE; }

BOOL BrushDefinition::SetRotationIncrProp (  double  Value  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  incremental angle of rotation to set [INPUTS] Returns: TRUE if the angle is within the stated bounds See also: - Definition at line 1771 of file brshcomp.cpp. { m_RotAngleIncrProp = Value; return TRUE; }

BOOL BrushDefinition::SetRotationMaxPressure (  UINT32  Value  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  seed to use [INPUTS] Returns: - See also: - Definition at line 1906 of file brshcomp.cpp. { if (Value < MIN_PRESSURE_EFFECT || Value > MAX_PRESSURE_EFFECT) return FALSE; m_RotationMaxPressure = Value; return TRUE; }

BOOL BrushDefinition::SetRotationMaxRand (  UINT32  Value  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  maximum amount of randomness (as a %) to be applied to rotation [INPUTS] Returns: - See also: - Definition at line 1828 of file brshcomp.cpp. { m_RotationMaxRand = Value; return TRUE; }

void BrushDefinition::SetRotationRandSeed (  UINT32  Seed  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  seed to use [INPUTS] Returns: - See also: - Definition at line 1868 of file brshcomp.cpp. { m_RotationRandSeed = Seed; }

BOOL BrushDefinition::SetSatIncrement (  double  Incr  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  Saturation increment for this brush [INPUTS] Returns: - See also: - Definition at line 2354 of file brshcomp.cpp. { m_BrushSatIncrement = Incr; return TRUE; }

BOOL BrushDefinition::SetSatMaxRand (  UINT32  Rand  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  Saturation increment random amount for this brush [INPUTS] Returns: - See also: - Definition at line 2394 of file brshcomp.cpp. { m_BrushSatMaxRand = Rand; return TRUE; }

BOOL BrushDefinition::SetSatRandSeed (  UINT32  Rand  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  Saturation increment random amount for this brush [INPUTS] Returns: - See also: - Definition at line 2434 of file brshcomp.cpp. { m_BrushSatRandSeed = Rand; return TRUE; }

BOOL BrushDefinition::SetScalingMaxPressure (  UINT32  Max  )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  maximum percentage effect that pressure will have on Scaling [INPUTS] Returns: - Definition at line 2193 of file brshcomp.cpp. { if (Max < MIN_PRESSURE_EFFECT || Max > MAX_PRESSURE_EFFECT) return FALSE; m_ScalingMaxPressure = Max; return TRUE; }

BOOL BrushDefinition::SetScalingMaxRand (  UINT32  Value  )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: :  the maximum percentage randomness to be applied to Scaling [INPUTS] Returns: TRUE if Value is within the legal limits, otherwise FALSE Definition at line 2119 of file brshcomp.cpp. { if (Value < MIN_BRUSH_RAND || Value > MAX_BRUSH_RAND) return FALSE; m_BrushScalingMaxRand = Value; return TRUE; }

void BrushDefinition::SetScalingRandSeed (  UINT32  Seed  )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  seed to use for our scaling RNG [INPUTS] Returns: - Definition at line 2158 of file brshcomp.cpp. { m_BrushScalingRandSeed = Seed; }

void BrushDefinition::SetSequenceSeed (  UINT32  Seed  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  random seed to use for sequences [INPUTS] Returns: - See also: - Definition at line 2573 of file brshcomp.cpp. { m_SequenceRandSeed = Seed; }

void BrushDefinition::SetSequenceType (  SequenceType  Type  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  type of sequence to use [INPUTS] Returns: - See also: - Definition at line 2554 of file brshcomp.cpp. { m_SequenceType = Type; }

BOOL BrushDefinition::SetSpacing (  MILLIPOINT  Spacing  )

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 the spacing is invalid See also: - Definition at line 1164 of file brshcomp.cpp. { if (Spacing < MIN_BRUSH_SPACING || Spacing > MAX_BRUSH_SPACING) return FALSE; m_BrushSpacing = Spacing; return TRUE; }

BOOL BrushDefinition::SetSpacingIncrConst (  MILLIPOINT  Incr  )

To set the proportional spacing increment between brush objects. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  constant spacing increment value to set [INPUTS] Returns: TRUE if we can draw 10 objects, FALSE if the spacing is invalid See also: - Definition at line 1259 of file brshcomp.cpp. { if (Incr <= 0) return TRUE; MILLIPOINT TenthSpacing = 10 * Incr; if (TenthSpacing >= MAX_BRUSH_SPACING || TenthSpacing < MIN_BRUSH_SPACING) { ERROR3("Illegal increment value"); return FALSE; } m_BrushSpacingIncrConst = Incr; return TRUE; }

BOOL BrushDefinition::SetSpacingIncrProp (  double  Incr  )

To set the proportional spacing increment between brush objects. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  spacing increment value to set [INPUTS] Returns: TRUE if we can draw 10 objects, FALSE if the spacing is invalid See also: - Definition at line 1208 of file brshcomp.cpp. { if (Incr <= 0) return FALSE; if (Incr != 1.0) { double TenIncr = pow(Incr, 10.0); double TenthSpacing = m_BrushSpacing * TenIncr; if (TenthSpacing >= MAX_BRUSH_SPACING || TenthSpacing < MIN_BRUSH_SPACING) { ERROR3("Illegal increment value"); return FALSE; } } m_BrushSpacingIncrProp = Incr; return TRUE; }

BOOL BrushDefinition::SetSpacingMaxRand (  UINT32  Value  )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: :  the maximum percentage randomness to be applied to spacing [INPUTS] Returns: TRUE if Value is within the legal limits, otherwise FALSE Definition at line 1322 of file brshcomp.cpp. { if (Value < MIN_BRUSH_RAND || Value > MAX_BRUSH_RAND) return FALSE; m_BrushSpacingMaxRand = Value; return TRUE; }

void BrushDefinition::SetSpacingRandSeed (  UINT32  Seed  )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  seed to use for our spacing RNG [INPUTS] Returns: - Definition at line 1361 of file brshcomp.cpp. { m_BrushSpacingRandSeed=Seed; // "=Seed" added by AMB 2006-01-06 }

void BrushDefinition::SetTiling (  BOOL  Value  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: whether  or not the brush tiles [INPUTS] Returns: - See also: - Definition at line 1648 of file brshcomp.cpp. { m_bTile = Value; }

BOOL BrushDefinition::SetTimeStampingPeriod (  double  Period  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: time  period to set [INPUTS] Returns: TRUE if period is valid, else FALSE See also: - Definition at line 2918 of file brshcomp.cpp. { if (Period < MIN_TIMESTAMP || Period > MAX_TIMESTAMP) return FALSE; m_TimeStampPeriod = Period; return TRUE; }

BOOL BrushDefinition::SetTransparencyPressure (  UINT32  Value  )

Sets the extent to which pressure affects transparency. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Value  - the value to set [INPUTS] Returns: See also: - Definition at line 2496 of file brshcomp.cpp. { m_TranspMaxPressure = Value; return TRUE; }

BOOL BrushDefinition::StartRender (  void   )

Basically due to imprecision in the arithmetic system we ended up corrupting the brush data if we used it too much. So to get around this we never transform the original brush data, instead we make copies of it each time we want to render a version of this brush. This function generates the data copies that we need to render this brush, make sure you call StopRender() to get rid of them. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 4/9/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE if not. If we return FALSE then don't even think about rendering with this brush. Definition at line 1065 of file brshcomp.cpp. { BrushRef* pBrushRef = GetFirstBrushRef(); BOOL ok = TRUE; while (pBrushRef != NULL) { if (ok) ok = pBrushRef->MakeCopiesForRendering(); pBrushRef = GetNextBrushRef(); } return ok; }

void BrushDefinition::StopRender (  void   )

Call this when you have finished rendering a node with this brush, it deletes the copied data that we used for rendering. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 4/9/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1096 of file brshcomp.cpp. { BrushRef* pBrushRef = GetFirstBrushRef(); while (pBrushRef != NULL) { pBrushRef->DeleteRenderCopies(); pBrushRef = GetNextBrushRef(); } return; }

BOOL BrushDefinition::UsesPressure (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 16/6/2000 Parameters: -  [INPUTS] Returns TRUE if this brush has one of its pressure variables set Definition at line 991 of file brshcomp.cpp. { if (m_ScalingMaxPressure != 0 || m_RotationMaxPressure != 0 || m_TranspMaxPressure != 0) return TRUE; return FALSE; }

---

Member Data Documentation

BOOL BrushDefinition::m_bActivated [protected]

Definition at line 453 of file brshcomp.h.

BOOL BrushDefinition::m_bInitOk [protected]

Definition at line 446 of file brshcomp.h.

BOOL BrushDefinition::m_bRotate [protected]

Definition at line 394 of file brshcomp.h.

double BrushDefinition::m_BrushHueIncrement [protected]

Definition at line 419 of file brshcomp.h.

UINT32 BrushDefinition::m_BrushHueMaxRand [protected]

Definition at line 420 of file brshcomp.h.

UINT32 BrushDefinition::m_BrushHueRandSeed [protected]

Definition at line 421 of file brshcomp.h.

std::vector< BrushRef * > BrushDefinition::m_BrushRefPtrArray [protected]

Definition at line 440 of file brshcomp.h.

double BrushDefinition::m_BrushSatIncrement [protected]

Definition at line 424 of file brshcomp.h.

UINT32 BrushDefinition::m_BrushSatMaxRand [protected]

Definition at line 425 of file brshcomp.h.

UINT32 BrushDefinition::m_BrushSatRandSeed [protected]

Definition at line 426 of file brshcomp.h.

double BrushDefinition::m_BrushScaling [protected]

Definition at line 411 of file brshcomp.h.

double BrushDefinition::m_BrushScalingIncr [protected]

Definition at line 412 of file brshcomp.h.

double BrushDefinition::m_BrushScalingIncrConst [protected]

Definition at line 413 of file brshcomp.h.

UINT32 BrushDefinition::m_BrushScalingMaxRand [protected]

Definition at line 414 of file brshcomp.h.

UINT32 BrushDefinition::m_BrushScalingRandSeed [protected]

Definition at line 415 of file brshcomp.h.

MILLIPOINT BrushDefinition::m_BrushSpacing [protected]

Definition at line 386 of file brshcomp.h.

MILLIPOINT BrushDefinition::m_BrushSpacingIncrConst [protected]

Definition at line 388 of file brshcomp.h.

double BrushDefinition::m_BrushSpacingIncrProp [protected]

Definition at line 387 of file brshcomp.h.

UINT32 BrushDefinition::m_BrushSpacingMaxRand [protected]

Definition at line 389 of file brshcomp.h.

UINT32 BrushDefinition::m_BrushSpacingRandSeed [protected]

Definition at line 390 of file brshcomp.h.

INT32 BrushDefinition::m_BrushTransparency [protected]

Definition at line 429 of file brshcomp.h.

BOOL BrushDefinition::m_bTile [protected]

Definition at line 393 of file brshcomp.h.

UINT32 BrushDefinition::m_DefaultFileID [protected]

Definition at line 450 of file brshcomp.h.

UINT32 BrushDefinition::m_HueMaxPressure [protected]

Definition at line 422 of file brshcomp.h.

DocRect BrushDefinition::m_LargestBoundingBox [protected]

Definition at line 445 of file brshcomp.h.

UINT32 BrushDefinition::m_LastBrushRefRetrieved [protected]

Definition at line 443 of file brshcomp.h.

double BrushDefinition::m_MaxScaling [protected]

Definition at line 448 of file brshcomp.h.

UINT32 BrushDefinition::m_NumBrushObjects [protected]

Definition at line 441 of file brshcomp.h.

UINT32 BrushDefinition::m_OffsetMaxPressure [protected]

Definition at line 409 of file brshcomp.h.

UINT32 BrushDefinition::m_OffsetTypeRandSeed [protected]

Definition at line 406 of file brshcomp.h.

UINT32 BrushDefinition::m_OffsetValueMaxRand [protected]

Definition at line 407 of file brshcomp.h.

UINT32 BrushDefinition::m_OffsetValueRandSeed [protected]

Definition at line 408 of file brshcomp.h.

MILLIPOINT BrushDefinition::m_PathOffsetIncrConst [protected]

Definition at line 405 of file brshcomp.h.

double BrushDefinition::m_PathOffsetIncrProp [protected]

Definition at line 404 of file brshcomp.h.

PathOffset BrushDefinition::m_PathOffsetType [protected]

Definition at line 402 of file brshcomp.h.

MILLIPOINT BrushDefinition::m_PathOffsetValue [protected]

Definition at line 403 of file brshcomp.h.

double BrushDefinition::m_RotAngleIncrConst [protected]

Definition at line 397 of file brshcomp.h.

double BrushDefinition::m_RotAngleIncrProp [protected]

Definition at line 396 of file brshcomp.h.

double BrushDefinition::m_RotateAngle [protected]

Definition at line 395 of file brshcomp.h.

UINT32 BrushDefinition::m_RotationMaxPressure [protected]

Definition at line 400 of file brshcomp.h.

UINT32 BrushDefinition::m_RotationMaxRand [protected]

Definition at line 398 of file brshcomp.h.

UINT32 BrushDefinition::m_RotationRandSeed [protected]

Definition at line 399 of file brshcomp.h.

UINT32 BrushDefinition::m_SatMaxPressure [protected]

Definition at line 427 of file brshcomp.h.

UINT32 BrushDefinition::m_ScalingMaxPressure [protected]

Definition at line 416 of file brshcomp.h.

UINT32 BrushDefinition::m_SequenceRandSeed [protected]

Definition at line 433 of file brshcomp.h.

SequenceType BrushDefinition::m_SequenceType [protected]

Definition at line 432 of file brshcomp.h.

UINT32 BrushDefinition::m_SpacingMaxPressure [protected]

Definition at line 391 of file brshcomp.h.

UINT32 BrushDefinition::m_TimeStampMaxPressure [protected]

Definition at line 436 of file brshcomp.h.

double BrushDefinition::m_TimeStampPeriod [protected]

Definition at line 435 of file brshcomp.h.

UINT32 BrushDefinition::m_TranspMaxPressure [protected]

Definition at line 430 of file brshcomp.h.

---

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

• Kernel/brshcomp.h (r1785/r1282)
• Kernel/brshcomp.cpp (r1785/r1732)

---