BrushAttrValue Class Reference

Brush attribute value. More...

#include <brshattr.h>

Inheritance diagram for BrushAttrValue:

List of all members.

Public Member Functions
	BrushAttrValue ()
	Default Constuctor for BrushAttrValue.
	BrushAttrValue (PathProcessorBrush *pPathProcessor)
	Default Constuctor for BrushAttrValue.
	~BrushAttrValue ()
	Destructor Deletes any attached PathProcessor (see the constructor).
virtual void	Render (RenderRegion *pRegion, BOOL Temp=FALSE)
	Sets the BrushAttrValue attribute for the given render region.
virtual void	Restore (RenderRegion *pRegion, BOOL Temp)
	Restores the BrushAttrValue attribute for the given render region.
virtual void	GoingOutOfScope (RenderRegion *pRegion)
	A sister function to Render().
virtual void	SimpleCopy (AttributeValue *pValue)
	See AttributeValue::SimpleCopy.
virtual NodeAttribute *	MakeNode ()
	Make a new attribute node for this type of attr value - see base class.
virtual BOOL	IsDifferent (AttributeValue *pAttr)
	Determines if this AttrValue is different from the given one.
virtual BrushAttrValue &	operator= (BrushAttrValue &Attrib)
	Assignment operator.
virtual INT32	operator== (const BrushAttrValue &Attrib)
	Comparison operator.
virtual BOOL	Blend (BlendAttrParam *pBlendParam)
	Blends between two brush attributes. In fact at the moment it just blends between the parameters in the two path processors. At some point it should also blend between the ink objects and attributes.
BOOL	DoBecomeA (BecomeA *pBecomeA, Node *pParent)
	To convert our brush into its individual paths and attributes, works in a very similar way to the bounding box, by finding the paths of our parent node and asking our path processor to do the calculations.
BOOL	EffectsParentBounds ()
DocRect	GetAttrBoundingRect (NodeRenderableInk *pParent=NULL, CCAttrMap *pAttribMap=NULL)
	Virtual function for determining the bounding rect of an attribute. It achieves this by giving a path to the path processor which tells it the bounding rect.
void	SetCachedRect (DocRect Rect)
	This is designed to be called by the path processor, which calculates the bounding rect of this attribute, arbitrarily setting bounding rects by other objects is not recommended.
void	TransformCachedRect (TransformBase &Trans)
	Because it takes such a long time to calculate the bounding rect of a brushed object we prefer to calculate it once and then simply transform it.
void	SetPathProcessor (PathProcessorBrush *pNewProcessor)
	To set the path processor used by this object. The processor is now "owned" by this attribute, and will be auto-deleted upon destruction.
PathProcessorBrush *	GetPathProcessor (void) const
void	FlushCache ()
	clears out the cached points
void	TransformCache (TransformBase &Trans)
	transforms the cached path. Attempts to optimise straight transform case.
void	SetCache (PointsMap *pMap)
	sets the cache member variable
PointsMap *	GetCache ()
TimeStampList *	GetTimeStampList ()
void	SetTimeStampList (TimeStampList *pList)
	sets the timestamp cache member variable
BOOL	IsTimeStamping ()
	as above
void	SetTimeStampUpdateType (ListUpdateType Update)
	These flags determine what will happen in the NodePathUpdate function which is called after the freehand/brush or bezier tool is used to edit a brushed nodepath.
ListUpdateType	GetTimeStampUpdateType ()
	As above.
void	CalculateProportionalDistances (MILLIPOINT PathLength)
	Only use when we are utilising the path stamping cache. This fn. proceeds through the list and works out the proportional distance along the path for each object. See Also: TimeStampBrushPoint.
void	TransformTimeStampList (TransformBase &Trans)
	transforms all the points in the timestamping cache
BOOL	DeleteTimeStampPoints (MILLIPOINT StartDistance, MILLIPOINT EndDistance, TimeStampList *pRemovedPoints=NULL)
	removes points from the timestamping list between the provided distances
BOOL	DeleteTimeStampPoints (MILLIPOINT StartDistance, UINT32 NumPoints, TimeStampList *pRemovedPoints=NULL)
	removes points from the timestamping list between the provided distances
BOOL	AddTimeStampPoints (TimeStampList *pNewPoints, MILLIPOINT StartDistance)
	inserts the list of points after the distance given
BOOL	RecalculateTimeStampList (Path *pPath)
	If time stamped lists are edited they can get out of shape, call this function to make sure the list is all in order. Note that it can be a bit slow Extra note, depending on exactly how the path was edited our update method differs. RepositionPointsByProportion is used when the path was edited by no points were added or removed from the timestamping list. If points were added then the other method should be used.
BOOL	RepositionPointsByProportion (Path *pPath)
	This function moves all the points in the timestamping list to their proportional TimeStampList::iterator along pPath.
BOOL	RepositionPointsByPosition (Path *pPath)
	This function assumes that all the points in the timestamping list are in the path but that their distance and proportion information is incorrect. Therefore it runs through the list and finds the correct distance and proportion. This is useful for those times when the path editing functions conveniently decide to go and reverse the paths because they feel like it.
TimeStampList *	CopyTimeStampList ()
	Copy our timestamping list.
BOOL	WriteTimeStampList (BaseCamelotFilter *pFilter)
	If this brush uses timestamping then this function writes the timestamped list to the filter provided.
void	SetPresssureCache (CDistanceSampler *pPress)
	sets the pressure array memeber variable
CDistanceSampler *	GetPressureCache ()
	as above
UINT32	GetPressureValue (UINT32 Index)
	as above
BOOL	SetPressureValue (UINT32 Index, PressureItem Value)
	as above
void	CalculatePressureArrayProportions (MILLIPOINT PathLength)
	Only use when we are utilising the path stamping cache. This fn. proceeds through the list and works out the proportional distance along the path for each object. See Also: TimeStampBrushPoint.
void	PressureSpacingChange (MILLIPOINT OldSpacing, MILLIPOINT NewSpacing)
void	FlushPressureCache ()
	clears out and deletes the cache of pressure values
INT32	GetPressureListIndexAtDistance (MILLIPOINT Distance)
	Finds the pressure list index corresponding to the brush object that would appear at Distance along the brushed path. Or rather asks the processor to do it.
BOOL	DeletePressurePoints (MILLIPOINT StartDistance, MILLIPOINT EndDistance, SampleArray *pRemovedPoints=NULL)
	removes points from the Pressure Sampler list between the provided distances
BOOL	DeletePressurePoints (UINT32 StartIndex, size_t NumPoints, SampleArray *pRemovedPoints=NULL)
	removes points from the Pressure Sampler between the provided distances
BOOL	AddPressurePoints (CSampleData *pNewPoints, MILLIPOINT StartDistance)
	inserts the list of points after the distance given
BOOL	AddPressurePoints (CSampleData *pNewPoints, UINT32 StartIndex)
	inserts the list of points after the index given
void	SetPressureUpdateType (ListUpdateType Update)
	These flags determine what will happen in the NodePathUpdate function which is called after the freehand/brush or bezier tool is used to edit a brushed nodepath.
ListUpdateType	GetPressureUpdateType ()
	As above.
CDistanceSampler *	CopyPressureCache ()
	To make a carbon copy of our pressure cache and all the items in it. To be used as part of the operator= sequence.
BOOL	WritePressureData (BaseCamelotFilter *pFilter)
	If this attribute contains pressure data then it will write out that data to the filter provided.
void	ScaleToLineWidth (MILLIPOINT Width)
	asks the processor to scale to this line width. Note that the relevant flag must also be set
MILLIPOINT	GetDefaultLineWidth (BOOL IgnorePressure=FALSE)
	as above
BrushDefinition *	GetBrushDefinition (void)
	as above
BrushHandle	GetBrushHandle (void)
	interface to the pathprocessor
Static Public Member Functions
static BOOL	Init (void)
	Registers a default attribute of this type with the attribute manager.
static BOOL	RotateBounds (double Angle, DocRect *pBounds, DocCoord *pCentre=NULL)
	The bounds are updated to contain the rotated version.
Protected Member Functions
BOOL	RepositionPressureDataByPosition (Path *pPath)
void	InitialisePointsCache ()
	allocates the map to store cached points
void	FlushTimeStampCache ()
	deletes the timestamp cache if we have one
BOOL	RecalculateDistances (Path *pPath)
	for a timestamped brush, this fn. goes along the path and recalculates the distances of the coordinates along the line.
BOOL	RecalculateTangents (Path *pPath)
	for a timestamped brush, this fn. goes along the path and recalculates the tangents of the coordinates along the line.
BOOL	SortTimeStampingList ()
	The TimeStamping points lists can become rather disorderly if you edit them a lot. This function sorts them by order of distance using quicksort. Make sure you call RecalculateDistances() first.
BOOL	GetRidOfCrapFromList (Path *pPath)
	The TimeStamping points lists can become rather disorderly if you edit them a lot. My woefully inadequate undo/redo actions for editing them can still leave some rogue points hanging around. This function proceeds through the list removing any points that are not on the path.
Static Protected Member Functions
static void	ShuffleArrayUp (PressureArray *pPressure, UINT32 StartIndex)
	shuffles each element in the array up by one, assumes that there is already a spare element at the top of the array.
static void	ShuffleArrayDown (PressureArray *pPressure, UINT32 StartIndex)
static UINT32	BlendUINT32 (UINT32 First, UINT32 Second, double BlendRatio)
	to blend between two numbers and return the result
static INT32	BlendINT32 (INT32 First, INT32 Second, double BlendRatio)
	to blend between two numbers and return the result
static double	BlendDouble (double First, double Second, double BlendRatio)
	to blend between two numbers and return the result
Private Attributes
PathProcessorBrush *	m_pProcessor
PointsMap *	m_pCachedPoints
TimeStampList *	m_pTimeStampList
PressureArray *	m_pPressureVals
CDistanceSampler *	m_pPressureSampler
DocRect	m_CachedBRect
ListUpdateType	m_TimeStampUpdateType
ListUpdateType	m_PressureUpdateType

---

Detailed Description

Brush attribute value.

Author:

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

Date:

7/1/97

Notes: This AttrValue just contains a pointer to a path processor which will apply brush path objects and attributes to the attributee, so to speak.

Definition at line 136 of file brshattr.h.

---

Constructor & Destructor Documentation

BrushAttrValue::BrushAttrValue (   )

Default Constuctor for BrushAttrValue. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Definition at line 166 of file brshattr.cpp. { #ifdef NEWFASTBRUSHES pCachedBitmap = NULL; #endif m_pProcessor = NULL; #ifdef BRUSHPOINTSCACHE m_pCachedPoints = NULL; #endif m_pTimeStampList = NULL; m_pPressureVals = NULL; m_CachedBRect = DocRect(0,0,0,0); m_pPressureSampler = NULL; }

BrushAttrValue::BrushAttrValue (  PathProcessorBrush *  pPathProcessor  )

Default Constuctor for BrushAttrValue. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pPathProcessor  - the stroke path-processor which will do the stroking [INPUTS] effect "applied" by this attribute. NULL indicates that this attribute does no stroking (i.e. that the path should have an old-style "line") NOTE that this object is NOW OWNED by this BrushAttrValue, and will be deleted when the attribute value is deleted. Definition at line 203 of file brshattr.cpp. { #ifdef NEWFASTBRUSHES pCachedBitmap = NULL; #endif // Remember our processor, and let it know that we "own" it m_pProcessor = pPathProcessor; // if (m_pProcessor != NULL) // m_pProcessor->SetParentAttribute(this); #ifdef BRUSHPOINTSCACHE m_pCachedPoints = NULL; #endif m_pTimeStampList = NULL; m_pPressureVals = NULL; m_CachedBRect = DocRect(0,0,0,0); m_pPressureSampler = NULL; }

BrushAttrValue::~BrushAttrValue (   )

Destructor Deletes any attached PathProcessor (see the constructor). Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Definition at line 237 of file brshattr.cpp. { #ifdef NEWFASTBRUSHES if (pCachedBitmap != NULL) { delete (pCachedBitmap->GetBitmap ()); delete (pCachedBitmap); pCachedBitmap = NULL; } #endif if (m_pProcessor != NULL) { delete m_pProcessor; m_pProcessor = NULL; } FlushCache(); FlushTimeStampCache(); FlushPressureCache(); }

---

Member Function Documentation

BOOL BrushAttrValue::AddPressurePoints (  CSampleData *  pNewPoints, UINT32  StartIndex )

inserts the list of points after the index given Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pNewPoints  - the points to add [INPUTS] StartIndex - the TimeStampList::iterator in the list where we want to insert the new points Returns: TRUE if successful, FALSE if not See also: - Definition at line 1200 of file brshattr.cpp. { if (pNewPoints == NULL) { ERROR3("Invalid inputs to BrushAttrValue::AddPressurePoints"); return FALSE; } if (m_pPressureSampler == NULL) return FALSE; if (StartIndex > m_pPressureSampler->GetNumItems()) { ERROR3("Attempting to insert over the end of the array in BrushAttrValue::AddPressurePoints"); return FALSE; } return m_pPressureSampler->InsertNewData(StartIndex, pNewPoints); }

BOOL BrushAttrValue::AddPressurePoints (  CSampleData *  pNewPoints, MILLIPOINT  StartDistance )

inserts the list of points after the distance given Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pNewPoints  - the points to add [INPUTS] Start - distance from which to add the points, note that if this is negative then all the new points will be added to the very start Returns: TRUE if successful, FALSE if not See also: - Definition at line 1160 of file brshattr.cpp. { // couple of checks if (pNewPoints == NULL) { ERROR3("Invalid inputs to BrushAttrValue::AddPressurePoints"); return FALSE; } if (m_pPressureSampler == NULL) return FALSE; // find out where we're inserting INT32 StartIndex = m_pPressureSampler->GetInternalIndexFromDistance(StartDistance); if (StartIndex == -1) { ERROR3("Attempting to insert over the end of the array in BrushAttrValue::AddPressurePoints"); return FALSE; } // ask the sampler to insert for us return m_pPressureSampler->InsertNewData((UINT32)StartIndex, pNewPoints); }

BOOL BrushAttrValue::AddTimeStampPoints (  TimeStampList *  pNewPoints, MILLIPOINT  StartDistance )

inserts the list of points after the distance given Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pNewPoints  - the points to add [INPUTS] Start - distance from which to add the points, note that if this is negative then all the new points will be added to the very start Returns: TRUE if successful, FALSE if not See also: - Definition at line 1606 of file brshattr.cpp. { if (pNewPoints == NULL) { ERROR3("Invalid inputs to BrushAttrValue::DeleteTimeStampingPoints"); return FALSE; } if (m_pTimeStampList == NULL) return FALSE; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); TimeStampList::iterator LastPos = ListPos; TimeStampBrushPoint TSBP; TimeStampBrushPoint NewPoint; MILLIPOINT Distance; TRACEUSER("Diccon", _T("Num points pre-add = %d\n"), m_pTimeStampList->size()); // first find the TimeStampList::iterator at which we want to insert the new points if (StartDistance > 0) { while( ListPos != m_pTimeStampList->end() ) { LastPos = ListPos; TSBP = *ListPos; ++ListPos; Distance = TSBP.m_Distance; if (Distance > StartDistance) break; } } else LastPos = m_pTimeStampList->begin(); TimeStampList::iterator NewListPos = pNewPoints->begin(); while( NewListPos != m_pTimeStampList->end() ) { // get the point from the new list NewPoint = *NewListPos; ++NewListPos; // insert it into the old list, recall that LastPos stores the element just before // StartDistance was exceeded if (StartDistance > 0) { m_pTimeStampList->insert( LastPos, NewPoint ); // increment our list position ++LastPos; } else m_pTimeStampList->push_front( NewPoint ); } TRACEUSER("Diccon", _T("Ended with %d points\n"), m_pTimeStampList->size()); return TRUE; }

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

Blends between two brush attributes. In fact at the moment it just blends between the parameters in the two path processors. At some point it should also blend between the ink objects and attributes. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/3/2000 Parameters: pBlendParam  - contains the blend info, [INPUTS] pBlendParama  - containing the blended attributes [OUTPUTS] Returns: TRUE - Blend went ok, the blended attr val is valid; FALSE if not. Errors: Out of memory. Reimplemented from AttributeValue. Definition at line 450 of file brshattr.cpp. { ERROR2IF(pBlendParam == NULL, FALSE, "BlendAttrParam is NULL in BrushAttrValue::Blend"); // First get the fill that we are blending to BrushAttrValue* pOtherBrush = (BrushAttrValue*)pBlendParam->GetOtherAttrVal(); if (pOtherBrush == NULL) return FALSE; // it is ok if we have null path processors as that merely indicates a default line PathProcessorBrush* pOtherPPB = pOtherBrush->GetPathProcessor(); PathProcessorBrush* pThisPPB = GetPathProcessor(); // Now make a new object of the same type as this one //CCRuntimeClass* ObjectType = GetRuntimeClass(); BrushAttrValue* pNewAttr = new BrushAttrValue; //(BrushAttrValue*)ObjectType->CreateObject(); if (pNewAttr == NULL) { // Fail if we couldn't create the new fill pBlendParam->SetBlendedAttrVal(NULL); return FALSE; } // Make the new fill an exact copy of this one pNewAttr->SimpleCopy(this); // make a new path processor PathProcessorBrush* pBlendedPPB = new PathProcessorBrush; if (pBlendedPPB == NULL) { delete pNewAttr; return FALSE; } pBlendedPPB->SetBrushDefinition(BrushHandle_NoBrush); // find out what point along the blend we are at double BlendRatio = pBlendParam->GetBlendRatio(); // we need to ask the brush component to make a blended brush definition for us Document* pDoc = Document::GetCurrent(); ERROR2IF(pDoc == NULL, FALSE, "Wheres the document?"); BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent)); ERROR2IF(pBrushComp == NULL, FALSE, "No brush component"); // don't want to blend the variables any more, lets just copy them BrushDefinition* pThisDef = GetBrushDefinition(); BrushDefinition* pOtherDef = pOtherBrush->GetBrushDefinition(); BrushHandle ThisHandle = BrushHandle_NoBrush; BrushHandle OtherHandle = BrushHandle_NoBrush; if (pThisPPB != NULL) ThisHandle = pThisPPB->GetBrushDefinitionHandle(); if (pOtherPPB != NULL) OtherHandle = pOtherPPB->GetBrushDefinitionHandle(); if (BlendRatio <= 0.5) { { if (pThisDef != NULL) { // if we have a ppb then copy the data across if (pThisPPB != NULL) { BrushData ThisData; pThisPPB->CopyBrushData(&ThisData); pBlendedPPB->CopyDataFromObject(&ThisData); } else // otherwise go with the definition pThisDef->CopyDataToProcessor(pBlendedPPB); pBlendedPPB->SetBrushDefinition(GetBrushHandle()); pBlendedPPB->SetMaxScaling(pThisDef->GetMaxScaling()); } else { // turns out we're not really a brush so delete our processor delete pBlendedPPB; pBlendedPPB = NULL; } } } else { /* if (ThisHandle == OtherHandle) { if (pOtherPPB != NULL) { delete pBlendedPPB; pBlendedPPB = pOtherPPB->Clone(); } //pBlendedPPB->SetBrushDefinition(BrushHandle_NoBrush); } else */ { if (pOtherDef != NULL) { if (pOtherPPB != NULL) { BrushData OtherData; pOtherPPB->CopyBrushData(&OtherData); pBlendedPPB->CopyDataFromObject(&OtherData); // little hack that we need to ensure the scaling is correct AttrBrushType* pAttrBrush = pOtherPPB->GetParentAttribute(); if (pAttrBrush != NULL) { MILLIPOINT LineWidth = pAttrBrush->GetAppliedLineWidth(); pOtherPPB->ScaleToValue(LineWidth); } } else pOtherDef->CopyDataToProcessor(pBlendedPPB); pBlendedPPB->SetMaxScaling(pOtherDef->GetMaxScaling()); } else { // special case to deal with blend between a brushed and non=brushed object delete pBlendedPPB; pBlendedPPB = NULL; pNewAttr->SetPathProcessor(NULL); pBlendParam->SetBlendedAttrVal(pNewAttr); return TRUE; } pBlendedPPB->SetBrushDefinition(pOtherBrush->GetBrushHandle()); } } // trudge through all the variables and blend them /* // blend scaling variables double BlendedScaling = BlendDouble(m_pProcessor->GetBrushScaling(), pOtherPPB->GetBrushScaling(), BlendRatio); pBlendedPPB->SetBrushScaling(BlendedScaling); double BlendedScalingIncr = BlendDouble(m_pProcessor->GetBrushScalingIncr(), pOtherPPB->GetBrushScalingIncr(), BlendRatio); pBlendedPPB->SetBrushScalingIncr(BlendedScalingIncr); // blend spacing variables MILLIPOINT BlendedSpacing = BlendINT32(m_pProcessor->GetSpacing(), pOtherPPB->GetSpacing(), BlendRatio); pBlendedPPB->SetSpacing(BlendedSpacing); MILLIPOINT BlendedSpacingIncrConst = BlendINT32(m_pProcessor->GetSpacingIncrConst(), pOtherPPB->GetSpacingIncrConst(), BlendRatio); pBlendedPPB->SetSpacingIncrConst(BlendedSpacingIncrConst); double BlendedSpacingIncrProp = BlendDouble(m_pProcessor->GetSpacingIncrProp(), pOtherPPB->GetSpacingIncrProp(), BlendRatio); pBlendedPPB->SetSpacingIncrProp(BlendedSpacingIncrProp); UINT32 BlendedSpacingMaxRand = BlendUINT32(m_pProcessor->GetSpacingMaxRand(), pOtherPPB->GetSpacingMaxRand(), BlendRatio); pBlendedPPB->SetSpacingMaxRand(BlendedSpacingMaxRand); // for the random seed don't blend, just use one or the other if (BlendRatio <= 0.5) pBlendedPPB->SetSpacingRandSeed(m_pProcessor->GetSpacingRandSeed()); else pBlendedPPB->SetSpacingRandSeed(pOtherPPB->GetSpacingRandSeed()); // Offset variables MILLIPOINT BlendedOffsetValue = BlendINT32(m_pProcessor->GetPathOffsetValue(), pOtherPPB->GetPathOffsetValue(), BlendRatio); pBlendedPPB->SetPathOffsetValue(BlendedOffsetValue); MILLIPOINT BlendedOffsetIncrConst = BlendINT32(m_pProcessor->GetPathOffsetIncrConst(), pOtherPPB->GetPathOffsetIncrConst(), BlendRatio); pBlendedPPB->SetPathOffsetIncrConst(BlendedOffsetIncrConst); double BlendedOffsetIncrProp = BlendDouble(m_pProcessor->GetPathOffsetIncrProp(), pOtherPPB->GetPathOffsetIncrProp(), BlendRatio); pBlendedPPB->SetPathOffsetIncrProp(BlendedOffsetIncrProp); UINT32 BlendedOffsetMaxRand = BlendUINT32(m_pProcessor->GetOffsetValueMaxRand(), pOtherPPB->GetOffsetValueMaxRand(), BlendRatio); pBlendedPPB->SetOffsetValueMaxRand(BlendedOffsetMaxRand); // don't blend offset type, just use one or the other, likewise random seed if (BlendRatio <= 0.5) { pBlendedPPB->SetPathOffsetType(m_pProcessor->GetPathOffsetType()); pBlendedPPB->SetOffsetTypeRandSeed(m_pProcessor->GetOffsetTypeRandSeed()); pBlendedPPB->SetOffsetValueRandSeed(m_pProcessor->GetOffsetValueRandSeed()); } else { pBlendedPPB->SetPathOffsetType(pOtherPPB->GetPathOffsetType()); pBlendedPPB->SetOffsetTypeRandSeed(pOtherPPB->GetOffsetTypeRandSeed()); pBlendedPPB->SetOffsetValueRandSeed(pOtherPPB->GetOffsetValueRandSeed()); } // rotation double BlendedRotateAngle = BlendDouble(m_pProcessor->GetRotationAngle(), pOtherPPB->GetRotationAngle(), BlendRatio); pBlendedPPB->SetRotationAngle(BlendedRotateAngle); // do all the flags at once if (BlendRatio <= 0.5) { pBlendedPPB->SetRotated(m_pProcessor->IsRotated()); pBlendedPPB->SetTiling(m_pProcessor->IsTiled()); pBlendedPPB->SetUseLocalFillColour(m_pProcessor->GetUseLocalFillColour()); pBlendedPPB->SetScaleToLineWidth(m_pProcessor->IsScalingToLineWidth()); pBlendedPPB->SetBrushDefinition(m_pProcessor->GetBrushDefinitionHandle()); } else { pBlendedPPB->SetRotated(pOtherPPB->IsRotated()); pBlendedPPB->SetTiling(pOtherPPB->IsTiled()); pBlendedPPB->SetUseLocalFillColour(pOtherPPB->GetUseLocalFillColour()); pBlendedPPB->SetScaleToLineWidth(pOtherPPB->IsScalingToLineWidth()); pBlendedPPB->SetBrushDefinition(pOtherPPB->GetBrushDefinitionHandle()); } */ // whew, think thats the lot, now attach the processor to the new attribute pNewAttr->SetPathProcessor(pBlendedPPB); // and attach the attribute to the blend param pBlendParam->SetBlendedAttrVal(pNewAttr); return TRUE; }

double BrushAttrValue::BlendDouble (  double  First, double  Second, double  BlendRatio )  [static, protected]

to blend between two numbers and return the result Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: First  - the first number to blend [INPUTS] Second - the second number to blend BlendRatio - the proportion of first to second number Returns: the blended result Definition at line 786 of file brshattr.cpp. { double InvRatio = 1 - BlendRatio; double BlendedVal = ((double)First * InvRatio) + ((double)Second*BlendRatio); return BlendedVal; }

INT32 BrushAttrValue::BlendINT32 (  INT32  First, INT32  Second, double  BlendRatio )  [static, protected]

to blend between two numbers and return the result Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: First  - the first number to blend [INPUTS] Second - the second number to blend BlendRatio - the proportion of first to second number Returns: the blended result Definition at line 761 of file brshattr.cpp. { double InvRatio = 1 - BlendRatio; double BlendedVal = ((double)First * InvRatio) + ((double)Second*BlendRatio); return (INT32)BlendedVal; }

UINT32 BrushAttrValue::BlendUINT32 (  UINT32  First, UINT32  Second, double  BlendRatio )  [static, protected]

to blend between two numbers and return the result Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: First  - the first number to blend [INPUTS] Second - the second number to blend BlendRatio - the proportion of first to second number Returns: the blended result Definition at line 737 of file brshattr.cpp. { double InvRatio = 1 - BlendRatio; double BlendedVal = ((double)First * InvRatio) + ((double)Second*BlendRatio); return (UINT32)BlendedVal; }

void BrushAttrValue::CalculatePressureArrayProportions (  MILLIPOINT  PathLength  )

Only use when we are utilising the path stamping cache. This fn. proceeds through the list and works out the proportional distance along the path for each object. See Also: TimeStampBrushPoint. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: The  length of the path to which this attribute applies [INPUTS] Returns: - Definition at line 1028 of file brshattr.cpp. { if (m_pPressureVals == NULL || PathLength <= 0) { ERROR3("Error in calculating proportional distance"); return; } PressureItem Item; for (size_t i = 0; i < m_pPressureVals->size(); i++) { Item = (*m_pPressureVals)[i]; if (Item.m_Distance > PathLength) ERROR3("Item distance is greater than path length in BrushAttrValue::CalculatePressureArrayProportions"); Item.m_Proportion = Item.m_Distance / (double) PathLength; (*m_pPressureVals)[i] = Item; } }

void BrushAttrValue::CalculateProportionalDistances (  MILLIPOINT  PathLength  )

Only use when we are utilising the path stamping cache. This fn. proceeds through the list and works out the proportional distance along the path for each object. See Also: TimeStampBrushPoint. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: The  length of the path to which this attribute applies [INPUTS] Returns: - Definition at line 1383 of file brshattr.cpp. { if (m_pTimeStampList == NULL || PathLength <= 0) { ERROR3("Error in calculating proportional distance"); return; } TimeStampList::iterator ListPos = m_pTimeStampList->begin(); TimeStampList::iterator LastPos = ListPos; TimeStampBrushPoint TSBP; while( ListPos != m_pTimeStampList->end() ) { LastPos = ListPos; TSBP = *ListPos; ++ListPos; TSBP.WorkOutProportion( PathLength ); *LastPos = TSBP; } }

CDistanceSampler * BrushAttrValue::CopyPressureCache (   )

To make a carbon copy of our pressure cache and all the items in it. To be used as part of the operator= sequence. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/2000 Parameters: -  [INPUTS] Returns: pointer to a newly allocated pressure cache, or NULL if it fails See also: BrushAttrValue::operator= Definition at line 1283 of file brshattr.cpp. { if (m_pPressureSampler == NULL) return NULL; return m_pPressureSampler->MakeCopy(); }

TimeStampList * BrushAttrValue::CopyTimeStampList (   )

Copy our timestamping list. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/2000 Returns: Pointer to the new list, or null if it fails See also: operator= Definition at line 2081 of file brshattr.cpp. { if (m_pTimeStampList == NULL) return NULL; // allocate a new list of our own TimeStampList* pCopyList = new TimeStampList; if (pCopyList != NULL) { TimeStampBrushPoint TBSP; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); // copy the points while( ListPos != m_pTimeStampList->end() ) { TBSP = *ListPos; ++ListPos; pCopyList->push_back(TBSP); } } return pCopyList; }

BOOL BrushAttrValue::DeletePressurePoints (  UINT32  StartIndex, size_t  NumPoints, SampleArray *  pRemovedPoints = NULL )

removes points from the Pressure Sampler between the provided distances Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: StartIndex  - the index where we want to start deleting [INPUTS] NumPoints - the number to delete pRemovedPoints - an array to put the deleted points in (defaults to null) Returns: TRUE if successful, FALSE if not See also: - Definition at line 1110 of file brshattr.cpp. { if (NumPoints < 1) { TRACEUSER( "Diccon", _T("Num points = %d in DeletePressurePoints\n"), NumPoints); return FALSE; } if (m_pPressureSampler == NULL) return FALSE; UINT32 EndIndex = StartIndex + NumPoints; // check that this doesn't overrun the array if (EndIndex > m_pPressureSampler->GetNumItems()) { ERROR3("Attempting to remove over the end of the array"); return FALSE; } // set the size of the sample array if (pRemovedPoints != NULL) pRemovedPoints->resize( NumPoints ); // set the retrieval rate m_pPressureSampler->SetRetrievalSampleRate(1.0); // ask the sampler to do its thing return m_pPressureSampler->RemoveData(StartIndex, EndIndex, pRemovedPoints); }

BOOL BrushAttrValue::DeletePressurePoints (  MILLIPOINT  StartDistance, MILLIPOINT  EndDistance, SampleArray *  pRemovedPoints = NULL )

removes points from the Pressure Sampler list between the provided distances Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Start  - distance from which to delete [INPUTS] End - the distance to stop deleting at pRemovedPoints - an array to put the deleted points in (defaults to null) Returns: TRUE if successful, FALSE if not See also: - Definition at line 1061 of file brshattr.cpp. { if (StartDistance <0 || EndDistance < 0 || EndDistance <= StartDistance) { ERROR3("Invalid inputs to BrushAttrValue::DeletePressureingPoints"); return FALSE; } if (m_pPressureSampler == NULL) return FALSE; // find out what indexes correspond to our distances INT32 StartIndex = m_pPressureSampler->GetInternalIndexFromDistance(StartDistance); INT32 EndIndex = m_pPressureSampler->GetInternalIndexFromDistance(EndDistance); if (StartIndex == -1 || EndIndex == -1) { ERROR3("Attempting to remove from over the end of the array"); return FALSE; } INT32 NumPoints = EndIndex - StartIndex; if (NumPoints == 0) return TRUE; // ours not to reason why... // set the size of the sample array if (pRemovedPoints != NULL) pRemovedPoints->resize( NumPoints ); // ask the sampler to do its thing return m_pPressureSampler->RemoveData(StartIndex, EndIndex, pRemovedPoints); }

BOOL BrushAttrValue::DeleteTimeStampPoints (  MILLIPOINT  StartDistance, UINT32  NumPoints, TimeStampList *  pRemovedPoints = NULL )

removes points from the timestamping list between the provided distances Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Start  - distance from which to delete [INPUTS] NumPoints - the number to delete pList - a list to put the deleted points in (defaults to null) Returns: TRUE if successful, FALSE if not See also: - Definition at line 1535 of file brshattr.cpp. { if (StartDistance <0 || NumPoints < 1) { ERROR3("Invalid inputs to BrushAttrValue::DeleteTimeStampingPoints"); return FALSE; } if (m_pTimeStampList == NULL) return FALSE; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); TimeStampList::iterator LastPos = ListPos; TimeStampBrushPoint TSBP; MILLIPOINT Distance = 0; UINT32 count = 0; NumPoints --; while( ListPos != m_pTimeStampList->end() ) { LastPos = ListPos; TSBP = *ListPos; ++ListPos; Distance = TSBP.m_Distance; count++; if (Distance >= StartDistance) { TimeStampList::iterator RemPos = LastPos; while( NumPoints && LastPos != m_pTimeStampList->end() ) { TRACEUSER("Diccon", _T("Removing point %d\n"), count); if (count == m_pTimeStampList->size()) { //INT32 i = 1; // why is this here AMB 2006-01-31 } // if we're sending the removed points back, add this one to the list if (pRemovedPoints != NULL) pRemovedPoints->push_back(TSBP); RemPos = LastPos; TSBP = *LastPos; ++LastPos; TimeStampBrushPoint Test = *RemPos; // TRACEUSER("Diccon", _T("Removing point at %d\n"), Test.m_Distance); // remove it from the main list m_pTimeStampList->erase( RemPos ); NumPoints--; count++; } } if (NumPoints <= 0 || LastPos == m_pTimeStampList->end()) break; } return TRUE; }

BOOL BrushAttrValue::DeleteTimeStampPoints (  MILLIPOINT  StartDistance, MILLIPOINT  EndDistance, TimeStampList *  pRemovedPoints = NULL )

removes points from the timestamping list between the provided distances Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Start  - distance from which to delete [INPUTS] End - the distance to stop deleting at Returns: TRUE if successful, FALSE if not See also: - Definition at line 1475 of file brshattr.cpp. { if (StartDistance <0 || EndDistance < 0 || EndDistance <= StartDistance) { ERROR3("Invalid inputs to BrushAttrValue::DeleteTimeStampingPoints"); return FALSE; } if (m_pTimeStampList == NULL) return FALSE; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); TimeStampList::iterator LastPos = ListPos; TimeStampBrushPoint TSBP; MILLIPOINT Distance = 0; INT32 count = 0; INT32 removecount = 0; TRACEUSER( "Diccon", _T("Deleting from %d, to %d\n"), StartDistance, EndDistance ); TRACEUSER( "Diccon", _T("Num points pre-remove = %d\n"), m_pTimeStampList->size() ); while( ListPos != m_pTimeStampList->end() ) { LastPos = ListPos; TSBP = *ListPos; ++ListPos; Distance = TSBP.m_Distance; //TRACEUSER("Diccon", _T("Count %d, Distance = %d\n"), count, Distance); if (Distance >= StartDistance && Distance <= EndDistance) { // if we're sending the removed points back, add this one to the list if (pRemovedPoints != NULL) pRemovedPoints->push_back( TSBP ); // remove it from the main list m_pTimeStampList->erase( LastPos ); removecount++; TRACEUSER("Diccon", _T("Removing point %d\n"), count); } count++; } TRACEUSER("Diccon", _T("Removed %d points\n"), removecount); return TRUE; }

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

To convert our brush into its individual paths and attributes, works in a very similar way to the bounding box, by finding the paths of our parent node and asking our path processor to do the calculations. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/3/2000 Parameters: pBecomeA  - the object that tells us what to become, and recieves the results [INPUTS] pParent - the node that this attribute is applied to [OUTPUTS]  Returns: TRUE if everything went ok, Definition at line 680 of file brshattr.cpp. { ERROR2IF(pBecomeA == NULL, FALSE, "BecomeA pointer is NULL in BrushAttrValue::DoBecomeA"); ERROR2IF(pParent == NULL, FALSE, "Parent node is NULL in BrushAttrValue::DoBecomeA"); if (m_pProcessor == NULL) return FALSE; BOOL Success = FALSE; // UINT32 Dummy = 0; // if we have a nodepath then we can simply use its member path, otherwise we // have to ask it to become a nodepath if (pParent->IsNodePath()) { // we have a special calculation for nodepaths, because we can use their path Success = m_pProcessor->DoBecomeA(pBecomeA, &((NodePath*)pParent)->InkPath, pParent); } else { BecomeA TestBecomeAPath(BECOMEA_TEST, CC_RUNTIME_CLASS(NodePath)); if (pParent->CanBecomeA(&TestBecomeAPath)) { // we must be applied to some arbitrary shape. The thing is that we need to have // a path to pass to the PPB, so want to get a passback of all the paths in // the node // we need to allocate a path Path* pPath = new Path; if (pPath != NULL && pPath->Initialise()) { PathBecomeA BecomeAPath(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL, FALSE, pPath); if (pParent->DoBecomeA(&BecomeAPath)) { Success = m_pProcessor->DoBecomeA(pBecomeA, pPath, pParent); } delete pPath; } } } return Success; }

BOOL BrushAttrValue::EffectsParentBounds (   )

void BrushAttrValue::FlushCache (   )

clears out the cached points Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: - See also: - Definition at line 2631 of file brshattr.cpp. { #ifdef BRUSHPOINTSCACHE if (m_pCachedPoints != NULL) { m_pCachedPoints->clear(); delete m_pCachedPoints; m_pCachedPoints = NULL; } #endif }

void BrushAttrValue::FlushPressureCache (   )

clears out and deletes the cache of pressure values Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns: - Definition at line 882 of file brshattr.cpp. { if (m_pPressureSampler != NULL) { delete m_pPressureSampler; m_pPressureSampler = NULL; } }

void BrushAttrValue::FlushTimeStampCache (   )  [protected]

deletes the timestamp cache if we have one Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns: - Definition at line 1415 of file brshattr.cpp. { if (m_pTimeStampList != NULL) { m_pTimeStampList->clear(); delete m_pTimeStampList; m_pTimeStampList = NULL; } }

DocRect BrushAttrValue::GetAttrBoundingRect (  NodeRenderableInk *  pParent = NULL, CCAttrMap *  pAttribMap = NULL )

Virtual function for determining the bounding rect of an attribute. It achieves this by giving a path to the path processor which tells it the bounding rect. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/95 Parameters: pParent,the  parent Ink node that this attribute will effect. [INPUTS] -  [OUTPUTS] Returns: The Bounding rect of the attribute (NULL rectangle is it doesn't have any). See also: NodeAttribute::EffectsParentBounds Definition at line 2424 of file brshattr.cpp. { BrushDefinition* pBrushDef = GetBrushDefinition(); if (pBrushDef == NULL) return DocRect(0, 0, 0, 0); // get the biggest BBox of the brush objects DocRect BRect = pBrushDef->GetLargestBoundingBox(); DocRect ReturnRect(0,0,0,0); // if (!m_CachedBRect.IsEmpty()) // return m_CachedBRect; // get our path processor PathProcessorBrush* pPPB = GetPathProcessor(); if (pPPB == NULL) return DocRect(0,0,0,0); if (m_pTimeStampList != NULL) { ReturnRect = pPPB->TimeStampBoundingBox(); m_CachedBRect = ReturnRect; return ReturnRect; } if (pParent->IsNodePath()) { #ifdef NEWFASTBRUSHES if (pCachedBitmap) { ReturnRect = pCachedBitmap->GetBoundingRect (); } else { #endif // we have a special calculation for nodepaths, because we can use their path ReturnRect = pPPB->CalculateBoundingBox(&((NodePath*)pParent)->InkPath, pParent); #ifdef NEWFASTBRUSHES } #endif m_CachedBRect = ReturnRect; return ReturnRect; } BecomeA TestBecomeAPath(BECOMEA_TEST, CC_RUNTIME_CLASS(NodePath)); if (pParent->CanBecomeA(&TestBecomeAPath)) { // we must be applied to some arbitrary shape. The thing is that we need to have // a path to pass to the PPB, so want to get a passback of all the paths in // the node // we need to allocate a path Path* pPath = new Path; if (pPath != NULL && pPath->Initialise()) { PathBecomeA BecomeAPath(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL, FALSE, pPath); if (pParent->DoBecomeA(&BecomeAPath)) { ReturnRect = pPPB->CalculateBoundingBox(pPath, pParent); } delete pPath; } m_CachedBRect = ReturnRect; return ReturnRect; } if (pParent->IsATextChar()) { // text always has to be different doesn't it.. // create a format region to keep an attribute stack FormatRegion FRegion; FormatRegion* pFormatRegion=&FRegion; if (!pFormatRegion->Init(pParent)) { ERROR3("Failed to init format region"); return ReturnRect; } pFormatRegion->SaveContext(); NodePath* pNodePath = NULL; TextChar* pTextChar = (TextChar*)pParent; pTextChar->RenderChildAttrs(pFormatRegion); // create a nodepath that we can use to give the the PPB if (pTextChar->CreateNodePath(&pNodePath, pFormatRegion)) { if (pNodePath != NULL) { ReturnRect = pPPB->CalculateBoundingBox(&(pNodePath->InkPath), pParent); delete pNodePath; } } pFormatRegion->RestoreContext(); m_CachedBRect = ReturnRect; return ReturnRect; } // Still nothing? Last resort time. if (ReturnRect.IsEmpty()) { ReturnRect = pParent->GetBoundingRect(TRUE); double Scaling = 1.0; PathProcessorBrush* pPathProc = GetPathProcessor(); if (pPathProc != NULL) Scaling = pPathProc->GetBrushScaling(); // hack it a bit just to make sure if (!ReturnRect.IsEmpty()) ReturnRect.Inflate((MILLIPOINT)((BRect.Width() / 2) * Scaling) , (MILLIPOINT)((BRect.Height() / 2) * Scaling)); if (pPathProc->GetPathOffsetType() != OFFSET_NONE) ReturnRect.Inflate(pPathProc->GetPathOffsetValue(), pPathProc->GetPathOffsetValue()); } m_CachedBRect = ReturnRect; return ReturnRect; }

BrushDefinition * BrushAttrValue::GetBrushDefinition (  void   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The brush definition used by our path processor, or null if we haven't been assigned one yet Definition at line 2315 of file brshattr.cpp. { if (m_pProcessor != NULL) { return m_pProcessor->GetOurBrushDefinition(); } return NULL; }

BrushHandle BrushAttrValue::GetBrushHandle (  void   )

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

PointsMap* BrushAttrValue::GetCache (   )  [inline]

Definition at line 195 of file brshattr.h. {return m_pCachedPoints;}

MILLIPOINT BrushAttrValue::GetDefaultLineWidth (  BOOL  IgnorePressure = FALSE  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the default line width as defined by the largest bounding box of the brush definition, or -1 if this attribute has no brush definition Definition at line 2610 of file brshattr.cpp. { if (m_pProcessor == NULL) return - 1; return m_pProcessor->GetBrushSize(IgnorePressure); }

PathProcessorBrush* BrushAttrValue::GetPathProcessor (  void   )  const [inline]

Definition at line 186 of file brshattr.h. { return(m_pProcessor); };

CDistanceSampler * BrushAttrValue::GetPressureCache (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: the pressure cache Definition at line 902 of file brshattr.cpp. { return m_pPressureSampler; }

INT32 BrushAttrValue::GetPressureListIndexAtDistance (  MILLIPOINT  Distance  )

Finds the pressure list index corresponding to the brush object that would appear at Distance along the brushed path. Or rather asks the processor to do it. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/5/2000 Parameters: Distance  - the distance along the path that we wish to find the pressure [INPUTS] list index for Returns: the index into our pressure list, or -1 for an error See also: PathProcessorBrush::GetObjectCountToDistance Definition at line 1310 of file brshattr.cpp. { // some safety checks if (m_pPressureSampler == NULL) return -1; if (Distance < 0 ) return -1; if (m_pProcessor == NULL) return -1; INT32 Index = m_pPressureSampler->GetInternalIndexFromDistance(Distance); return Index; }

ListUpdateType BrushAttrValue::GetPressureUpdateType (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the member, described above See also: - Definition at line 1261 of file brshattr.cpp. { return m_PressureUpdateType; }

UINT32 BrushAttrValue::GetPressureValue (  UINT32  Index  )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: the pressure value at that index, or PRESSURE_INVALID if index is out of range Definition at line 920 of file brshattr.cpp. { if (m_pPressureVals == NULL) return PRESSURE_INVALID; if (Index >= (UINT32)m_pPressureVals->size()) return PRESSURE_INVALID; PressureItem Item = (*m_pPressureVals)[Index]; return Item.m_Pressure; }

BOOL BrushAttrValue::GetRidOfCrapFromList (  Path *  pPath  )  [protected]

The TimeStamping points lists can become rather disorderly if you edit them a lot. My woefully inadequate undo/redo actions for editing them can still leave some rogue points hanging around. This function proceeds through the list removing any points that are not on the path. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pPath  = the path that this timestamped brush supposedly follows [INPUTS] Returns: TRUE if successful, FALSE if not See also: - Definition at line 1923 of file brshattr.cpp. { if (m_pTimeStampList == NULL || pPath == NULL) return FALSE; TimeStampBrushPoint Point; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); TimeStampList::iterator LastPos = ListPos; MILLIPOINT Distance; while( ListPos != m_pTimeStampList->end() ) { LastPos = ListPos; Point = *ListPos; ++ListPos; if (!pPath->GetDistanceToPoint(Point.m_Point, &Distance)) { m_pTimeStampList->erase( LastPos ); TRACEUSER("Diccon", _T("Removing point at %d\n"), Point.m_Distance); } } return TRUE; }

TimeStampList* BrushAttrValue::GetTimeStampList (   )  [inline]

Definition at line 198 of file brshattr.h. { return m_pTimeStampList;}

ListUpdateType BrushAttrValue::GetTimeStampUpdateType (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: the member, described above See also: - Definition at line 2746 of file brshattr.cpp. { return m_TimeStampUpdateType; }

void BrushAttrValue::GoingOutOfScope (  RenderRegion *  pRegion  )  [virtual]

A sister function to Render(). Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/97 Parameters: pRegion  - the render region the attribute is in use by [INPUTS] This is called by a render region when an attribute goes out of scope, i.e. when the attribute is no longer in use and is popped off the stack for the last time. (Do NOT confuse this with being pushed onto the render stack when overridden by another attr) It gives the attribute a chance to remove any PathProcessor(s) it added to the RenderRegion when it was Render()ed. Notes: This attribute makes sure it removes any PathProcessor it added to handle path stroking in BrushAttrValue::Render See also: BrushAttrValue::Render() Reimplemented from AttributeValue. Definition at line 397 of file brshattr.cpp. { if (m_pProcessor != NULL) { //TRACEUSER("Diccon", _T("Popping path processor\n") ); pRegion->PopPathProcessor(); } }

BOOL BrushAttrValue::Init (  void   )  [static]

Registers a default attribute of this type with the attribute manager. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: TRUE if it initilised successfully Reimplemented from SimpleCCObject. Definition at line 273 of file brshattr.cpp. { // The default attribute is one that has no effect (i.e. produces old-style "lines") BrushAttrValue *pAttr = new BrushAttrValue; if (pAttr == NULL) return FALSE; UINT32 ID = AttributeManager::RegisterDefaultAttribute(CC_RUNTIME_CLASS(AttrBrushType), pAttr); if (ID == ATTR_BAD_ID) return FALSE; ENSURE(ID == ATTR_BRUSHTYPE, "Incorrect ID for attribute!"); //ERROR2IF(ID == ATTR_BAD_ID, FALSE, "Bad ID when Initialising BrushAttrValue"); //ENSURE(ID == ATTR_BRUSHTYPE, "Incorrect Attribute ID"); return(TRUE); }

void BrushAttrValue::InitialisePointsCache (   )  [protected]

allocates the map to store cached points Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Definition at line 809 of file brshattr.cpp. { #ifdef BRUSHPOINTSCACHE // get rid of the existing one (if there is one) FlushCache(); //allocate a new map m_pCachedPoints = new PointsMap; PORTNOTE("other","Not use hash based map, InitHashTable makes no sense") #ifndef EXCLUDE_FROM_XARALX if (m_pCachedPoints != NULL) m_pCachedPoints->InitHashTable(1277); // Init hash table size to a suitably large prime number #endif #endif }

BOOL BrushAttrValue::IsDifferent (  AttributeValue *  pAttr  )  [virtual]

Determines if this AttrValue is different from the given one. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: Errors: ERROR3 if the two attributes are not of the same type See also: AttributeValue::IsDifferent Reimplemented from AttributeValue. Definition at line 2148 of file brshattr.cpp. { ERROR3IF(!pAttr->IsKindOf(CC_RUNTIME_CLASS(BrushAttrValue)), "Different attribute types in BrushAttrValue::IsDifferent()"); // Check they are NOT the same using the == operator return ( !(*((BrushAttrValue *)pAttr) == *this) ); }

BOOL BrushAttrValue::IsTimeStamping (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns: TRUE if we are using the timestamp cache, FALSE otherwise (we never use both) Definition at line 1363 of file brshattr.cpp. { return (m_pTimeStampList != NULL); }

NodeAttribute * BrushAttrValue::MakeNode (   )  [virtual]

Make a new attribute node for this type of attr value - see base class. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Returns: Pointer to the new node, or NULL if out of memory. See also: AttributeValue::MakeNode Reimplemented from AttributeValue. Definition at line 2116 of file brshattr.cpp. { // Create new attribute node AttrBrushType *pAttr = new AttrBrushType; if (pAttr == NULL) return NULL; // Copy attribute value (if any) into the new node. if (pAttr->GetAttributeValue() != NULL) pAttr->GetAttributeValue()->SimpleCopy(this); return(pAttr); }

BrushAttrValue & BrushAttrValue::operator= (  BrushAttrValue &  Attrib  )  [virtual]

Assignment operator. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: Attrib  - the attribute to copy [INPUTS] Definition at line 2172 of file brshattr.cpp. { // Get rid of our old processor (if any) if (m_pProcessor != NULL) delete m_pProcessor; m_pProcessor = NULL; // Copy the other attr's processor. If this fails, we'll get back a NULL pointer, // and will simply "convert" into a simple no-stroke attribute. if (Attrib.m_pProcessor != NULL) m_pProcessor = Attrib.m_pProcessor->Clone(); // if we're timestamping then we need to clone the list of points if (Attrib.IsTimeStamping()) m_pTimeStampList = CopyTimeStampList(); // if we have pressure data then we need to copy that also m_pPressureSampler = Attrib.CopyPressureCache(); return(*this); }

INT32 BrushAttrValue::operator== (  const BrushAttrValue &  Attrib  )  [virtual]

Comparison operator. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: Attrib  - the attribute to compare this attribute with [INPUTS] Returns: TRUE if the attributes are considered equal Definition at line 2211 of file brshattr.cpp. { ERROR3IF(!Attrib.IsKindOf(CC_RUNTIME_CLASS(BrushAttrValue)), "Other attribute value isn't an BrushAttrValue"); BrushAttrValue *Other = (BrushAttrValue *) &Attrib; // two attributes can never have the same timestamp or pressure caches // If that is the case then why is it checking the points cache and // not the pressure cache!?? I'm changing this to check the "correct" cache // Gerry (21/11/05) // The points cache doesn't get copied in the = operator so don't check it // if (GetCache() != NULL && GetCache()->GetCount() != 0) // return(FALSE); // if (Other->GetCache() != NULL && Other->GetCache()->GetCount != 0) // return(FALSE); if (GetPressureCache() != NULL && GetPressureCache()->GetCount() != 0) return(FALSE); if (Other->GetPressureCache() != NULL && Other->GetPressureCache()->GetCount() != 0) return(FALSE); if (m_pTimeStampList != NULL && m_pTimeStampList->size() != 0) return FALSE; if (Other->GetTimeStampList() != NULL && Other->GetTimeStampList()->size() != 0) return FALSE; // Equal if they both have same processor (only applies if they are both NULL) if (m_pProcessor == Other->GetPathProcessor()) return(TRUE); // Otherwise, if one of them is NULL, they can't be the same if (m_pProcessor == NULL || Other->GetPathProcessor() == NULL) return(FALSE); // Finally, ask the processors if they are of the same type return(!m_pProcessor->IsDifferent(Other->GetPathProcessor())); }

void BrushAttrValue::PressureSpacingChange (  MILLIPOINT  OldSpacing, MILLIPOINT  NewSpacing )

BOOL BrushAttrValue::RecalculateDistances (  Path *  pPath  )  [protected]

for a timestamped brush, this fn. goes along the path and recalculates the distances of the coordinates along the line. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pPath  - the path of the nodepath of this timestamped brush [INPUTS] Returns: TRUE if successful, FALSE if not See also: - Definition at line 1769 of file brshattr.cpp. { if (pPath == NULL || m_pTimeStampList == NULL) { ERROR3("Input pointers are NULL"); return FALSE; } double PathLength = (MILLIPOINT)pPath->GetPathLength(); MILLIPOINT Distance; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); TimeStampList::iterator LastPos; TimeStampBrushPoint TSBPoint; while( ListPos != m_pTimeStampList->end() ) { LastPos = ListPos; TSBPoint = *ListPos; ++ListPos; // get the distance along the path if (pPath->GetDistanceToPoint(TSBPoint.m_Point, &Distance)) { TSBPoint.m_Distance = Distance; TSBPoint.m_Proportion = (double)TSBPoint.m_Distance / PathLength; // TRACEUSER("Diccon", _T("New Prop: %f\n"), TSBPoint.m_Proportion); *LastPos = TSBPoint; } else TRACEUSER("Diccon", _T("Point %d, %d, not found in line\n"), TSBPoint.m_Point.x, TSBPoint.m_Point.y); } return TRUE; }

BOOL BrushAttrValue::RecalculateTangents (  Path *  pPath  )  [protected]

for a timestamped brush, this fn. goes along the path and recalculates the tangents of the coordinates along the line. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pPath  - the path of the nodepath of this timestamped brush [INPUTS] Returns: TRUE if successful, FALSE if not See also: - Definition at line 1819 of file brshattr.cpp. { if (pPath == NULL || m_pTimeStampList == NULL) { ERROR3("Input pointers are NULL"); return FALSE; } // double PathLength = (MILLIPOINT)pPath->GetPathLength(); double Tangent; DocCoord DummyCoord; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); TimeStampBrushPoint TSBPoint; while( ListPos != m_pTimeStampList->end() ) { TSBPoint = *ListPos; ++ ListPos; // we need to use GetPointAtDistance to retrieve the tangent if (pPath->GetPointAtDistance(TSBPoint.m_Distance, &DummyCoord, &Tangent)) TSBPoint.m_Tangent = Tangent; } return TRUE; }

BOOL BrushAttrValue::RecalculateTimeStampList (  Path *  pPath  )

If time stamped lists are edited they can get out of shape, call this function to make sure the list is all in order. Note that it can be a bit slow Extra note, depending on exactly how the path was edited our update method differs. RepositionPointsByProportion is used when the path was edited by no points were added or removed from the timestamping list. If points were added then the other method should be used. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pPath  - the path of the nodepath of this timestamped brush [INPUTS] Returns: TRUE if successful, FALSE if not See also: - Definition at line 1686 of file brshattr.cpp. { if (m_pTimeStampList == NULL) return TRUE; if (pPath == NULL) return FALSE; BOOL Retval = TRUE; switch (m_TimeStampUpdateType) { case UPDATE_NONE: break; case UPDATE_PROPORTION: if (!RepositionPointsByProportion(pPath)) Retval = FALSE; break; case UPDATE_LIST: if (!RecalculateDistances(pPath)) { Retval = FALSE; break; } if (!SortTimeStampingList()) { Retval = FALSE; break; } // if (!RecalculateTangents(pPath)) // { // Retval = FALSE; // break; // } break; case UPDATE_POSITION: if (!RepositionPointsByPosition(pPath)) Retval = FALSE; break; case UPDATE_LISTANDPOSITION: if (!RepositionPointsByPosition(pPath)) { Retval = FALSE; break; } if (!RecalculateDistances(pPath)) { Retval = FALSE; break; } if (!SortTimeStampingList()) { Retval = FALSE; break; } // if (!RecalculateTangents(pPath)) // { // Retval = FALSE; // break; // } break; } // if (!GetRidOfCrapFromList(pPath)) // return FALSE; return Retval; }

void BrushAttrValue::Render (  RenderRegion *  pRegion, BOOL  Temp = FALSE )  [virtual]

Sets the BrushAttrValue attribute for the given render region. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pRegion  - the render region to render this attribute into. [INPUTS] Notes: This attribute makes itself current in the render region, and also (possibly) adds a PathProcessor to handle stroking of all future rendered paths (until the attr is "restored") See also: BrushAttrValue::Restore Implements AttributeValue. Definition at line 313 of file brshattr.cpp. { // Stack the current attribute and set ourselves up as the new one pRegion->SaveAttribute(ATTR_BRUSHTYPE, this, Temp); #ifdef BRUSHPOINTSCACHE // if we don't yet have a cache then make one here if (m_pCachedPoints == NULL) InitialisePointsCache(); #endif // Find if we have a path processor to do the stroking, and if we do, // stack a copy of it (a copy must be used to be thread-safe & bgrender-safe) if (m_pProcessor != NULL) { // TRACEUSER("Diccon", _T("Rendering brush attribute\n") ); // make a clone and push it onto the stack PathProcessorBrush *pNewProcessor = m_pProcessor->Clone(); if (pNewProcessor != NULL) { //TRACEUSER("Diccon", _T("Pushing path processor\n") ); #ifdef NEWFASTBRUSHES pNewProcessor->SetLinkedAttribute (this); #endif pRegion->PushPathProcessor(pNewProcessor); } } }

BOOL BrushAttrValue::RepositionPointsByPosition (  Path *  pPath  )

This function assumes that all the points in the timestamping list are in the path but that their distance and proportion information is incorrect. Therefore it runs through the list and finds the correct distance and proportion. This is useful for those times when the path editing functions conveniently decide to go and reverse the paths because they feel like it. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pPath  = the path that this timestamped brush supposedly follows [INPUTS] Returns: TRUE if successful, FALSE if not See also: - Definition at line 2028 of file brshattr.cpp. { if (m_pTimeStampList == NULL || pPath == NULL) return FALSE; TimeStampBrushPoint Point; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); TimeStampList::iterator LastPos = ListPos; double PathLength = pPath->GetPathLength(); MILLIPOINT PointDistance = 0; // double Tangent = 0; DocCoord NewPosition; UINT32 Counter = 0; while( ListPos != m_pTimeStampList->end() ) { LastPos = ListPos; Point = *ListPos; ++ListPos; if (pPath->GetDistanceToPoint(Point.m_Point, &PointDistance)) { Point.m_Distance = PointDistance; Point.m_Proportion = (double)PointDistance / PathLength; // put the point back in the list *LastPos = Point; } else { TRACEUSER("Diccon", _T("Failed to get distance to point at %d\n"), Counter); } Counter++; } return TRUE; }

BOOL BrushAttrValue::RepositionPointsByProportion (  Path *  pPath  )

This function moves all the points in the timestamping list to their proportional TimeStampList::iterator along pPath. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: pPath  = the path that this timestamped brush supposedly follows [INPUTS] Returns: TRUE if successful, FALSE if not See also: - Definition at line 1962 of file brshattr.cpp. { if (m_pTimeStampList == NULL || pPath == NULL) return FALSE; TimeStampBrushPoint Point; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); TimeStampList::iterator LastPos = ListPos; double PathLength = pPath->GetPathLength(); MILLIPOINT PointDistance = 0; double Tangent = 0; DocCoord NewPosition; UINT32 Counter = 0; while( ListPos != m_pTimeStampList->end() ) { LastPos = ListPos; Point = *ListPos; ++ListPos; // work out the new distance along the given path with the existing proportion PointDistance = (MILLIPOINT)(Point.m_Proportion * PathLength); if (PointDistance >= 0) { // get the coordinate and tangent for this distance if (pPath->GetPointAtDistance(PointDistance, &NewPosition, &Tangent)) { // assign the new data to the point Point.m_Point = NewPosition; Point.m_Tangent = Tangent; Point.m_Distance = PointDistance; // put the point back in the list *LastPos = Point; } else { TRACEUSER("Diccon", _T("Failed to find point on line with distance %d\n"), PointDistance); } } else { TRACEUSER("Diccon", _T("Negative path distance at point %d\n"), Counter); } Counter++; } return TRUE; }

BOOL BrushAttrValue::RepositionPressureDataByPosition (  Path *  pPath  )  [protected]

void BrushAttrValue::Restore (  RenderRegion *  pRegion, BOOL  Temp )  [virtual]

Restores the BrushAttrValue attribute for the given render region. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pRegion  - the render region to restore the attribute into. [INPUTS] Temp - TRUE if this is a temporary attribute, FALSE if it is permanent (e.g. it's in a document tree). Notes: This attribute makes sure it removes any PathProcessor it added to handle path stroking in BrushAttrValue::Render Implements AttributeValue. Definition at line 364 of file brshattr.cpp. { pRegion->RestoreAttribute(ATTR_BRUSHTYPE, this, Temp); }

BOOL BrushAttrValue::RotateBounds (  double  Angle, DocRect *  pBounds, DocCoord *  pCentre = NULL )  [static]

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

void BrushAttrValue::ScaleToLineWidth (  MILLIPOINT  Width  )

asks the processor to scale to this line width. Note that the relevant flag must also be set Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: Width  - the width to set [INPUTS] Definition at line 2291 of file brshattr.cpp. { if (m_pProcessor != NULL) { BOOL Pressure = m_pPressureSampler != NULL; m_pProcessor->ScaleToValue(Width, !Pressure); } }

void BrushAttrValue::SetCache (  PointsMap *  pMap  )

sets the cache member variable Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pointer  to list to use as cache [INPUTS] Definition at line 839 of file brshattr.cpp. { #ifdef BRUSHPOINTSCACHE FlushCache(); m_pCachedPoints = pMap; #endif }

void BrushAttrValue::SetCachedRect (  DocRect  Rect  )

This is designed to be called by the path processor, which calculates the bounding rect of this attribute, arbitrarily setting bounding rects by other objects is not recommended. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/95 Parameters: Rect  - the bounding rect of this attribute [INPUTS] -  [OUTPUTS] Returns: Definition at line 2360 of file brshattr.cpp. { m_CachedBRect = Rect; }

void BrushAttrValue::SetPathProcessor (  PathProcessorBrush *  pNewProcessor  )

To set the path processor used by this object. The processor is now "owned" by this attribute, and will be auto-deleted upon destruction. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pNewProcessor  - The new PathProcessorStroke to be used by this attr. [INPUTS] May be NULL, in which case it sets "old style lines" stroking mode. Definition at line 2268 of file brshattr.cpp. { if (m_pProcessor != NULL) delete m_pProcessor; m_pProcessor = pNewProcessor; }

void BrushAttrValue::SetPresssureCache (  CDistanceSampler *  pSampler  )

sets the pressure array memeber variable Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pointer  to array to use as cache [INPUTS] Definition at line 860 of file brshattr.cpp. { // Do we want to delete any existing cache? if (m_pPressureSampler != NULL) { delete m_pPressureSampler; } m_pPressureSampler = pSampler; }

void BrushAttrValue::SetPressureUpdateType (  ListUpdateType  Update  )

These flags determine what will happen in the NodePathUpdate function which is called after the freehand/brush or bezier tool is used to edit a brushed nodepath. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Update  can be: [INPUTS] UPDATE_NONE, UPDATE_LIST - means that points have been added or removed to the Pressureing list UPDATE_PROPORTION - means that the underlying path has changed but our list has not UPDATE_TimeStampList::iterator - means (usually) that the path has been reversed but our points are the same UPDATE_LISTANDTimeStampList::iterator - take a guess Returns: - See also: - Definition at line 1242 of file brshattr.cpp. { m_PressureUpdateType = Update; }

BOOL BrushAttrValue::SetPressureValue (  UINT32  Index, PressureItem  Value )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: Index  - the index in to the array [INPUTS] Value - the value to set Returns: TRUE if all went well Definition at line 945 of file brshattr.cpp. { if (m_pPressureVals == NULL) return FALSE; size_t NumValues = m_pPressureVals->size(); if (Index > NumValues) return FALSE; // if index is one greater than our current size then we can expanf if (Index == NumValues) m_pPressureVals->push_back( Value ); else (*m_pPressureVals)[Index] = Value; return FALSE; }

void BrushAttrValue::SetTimeStampList (  TimeStampList *  pList  )

sets the timestamp cache member variable Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pointer  to list to use as cache [INPUTS] Definition at line 1345 of file brshattr.cpp. { m_pTimeStampList = pList; }

void BrushAttrValue::SetTimeStampUpdateType (  ListUpdateType  Update  )

These flags determine what will happen in the NodePathUpdate function which is called after the freehand/brush or bezier tool is used to edit a brushed nodepath. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Update  can be: [INPUTS] UPDATE_NONE, UPDATE_LIST - means that points have been added or removed to the timestamping list UPDATE_PROPORTION - means that the underlying path has changed but our list has not UPDATE_TimeStampList::iterator - means (usually) that the path has been reversed but our points are the same UPDATE_LISTANDTimeStampList::iterator - take a guess Returns: - See also: - Definition at line 2727 of file brshattr.cpp. { m_TimeStampUpdateType = Update; }

static void BrushAttrValue::ShuffleArrayDown (  PressureArray *  pPressure, UINT32  StartIndex )  [static, protected]

void BrushAttrValue::ShuffleArrayUp (  PressureArray *  pPressure, UINT32  StartIndex )  [static, protected]

shuffles each element in the array up by one, assumes that there is already a spare element at the top of the array. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pArray  - the array to shuffle [INPUTS] StartIndex - the index to shuffle from Returns: - Definition at line 981 of file brshattr.cpp. { if (pPressure == NULL) { ERROR3("Pressure array is NULL"); return; } size_t NumValues = pPressure->size(); if (StartIndex >= NumValues) { ERROR3("Start index is greater than size of array"); return; } // we count down from the top value and move // each one up, recall that the extra array element has already been allocated PressureItem Item; for( size_t i = NumValues - 2; i >= StartIndex; i-- ) { Item = (*pPressure)[i]; // if (i+1 >= NumValues) // { // TRACEUSER("Diccon", _T("Adding array element at %d\n"), i+1); // pPressure->SetAtGrow(i+1, Item); // } // else (*pPressure)[i] = Item; } }

void BrushAttrValue::SimpleCopy (  AttributeValue *  pValue  )  [virtual]

See AttributeValue::SimpleCopy. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pValue  - pointer to the AttributeValue to copy [INPUTS] Implements AttributeValue. Definition at line 421 of file brshattr.cpp. { ERROR3IF(!IS_A(pValue, BrushAttrValue), "Invalid Attribute value passed to BrushAttrValue::SimpleCopy"); // Just uses the assignment operator *this = *((BrushAttrValue *) pValue); }

BOOL BrushAttrValue::SortTimeStampingList (   )  [protected]

The TimeStamping points lists can become rather disorderly if you edit them a lot. This function sorts them by order of distance using quicksort. Make sure you call RecalculateDistances() first. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: TRUE if successful, FALSE if not See also: - Definition at line 1862 of file brshattr.cpp. { if (m_pTimeStampList == NULL) return FALSE; // first we need to copy the elements out of the list into an array size_t NumElements = m_pTimeStampList->size(); // make the array TimeStampBrushPoint* pPointArray = new TimeStampBrushPoint[NumElements]; if (pPointArray == NULL) return FALSE; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); TimeStampBrushPoint PointInfo; UINT32 Counter = 0; // copy the points into the array while( ListPos != m_pTimeStampList->end() ) { PointInfo = *ListPos; ++ListPos; pPointArray[Counter++] = PointInfo; } // quick sort 'em qsort((void*)pPointArray, NumElements, sizeof(TimeStampBrushPoint), TimeStampBrushPoint::ComparePointInfo); // now put 'em back in the list m_pTimeStampList->clear(); for (unsigned i = 0; i < NumElements; i++) { m_pTimeStampList->push_back(pPointArray[i]); // TRACEUSER("Diccon", _T("Sorted distance = %d\n"), pPointArray[i].m_Distance); } delete pPointArray; return TRUE; }

void BrushAttrValue::TransformCache (  TransformBase &  Trans  )

transforms the cached path. Attempts to optimise straight transform case. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 6/11/2000 Parameters: transfromation  matrix [INPUTS] Returns: - See also: - Definition at line 2658 of file brshattr.cpp. { if (m_pCachedPoints) { BrushPointInfo PointInfo; PointsMap::iterator pos = m_pCachedPoints->begin(); TransformBase *pBase = &Trans; if (pBase->IS_KIND_OF(Trans2DMatrix)) { Trans2DMatrix* transMatrix = (Trans2DMatrix*) pBase; // check for a change in aspect if (transMatrix->GetMatrix().IsTranslation()) { // optimise translate .... DocCoord trans = transMatrix->GetTranslation (); while( pos != m_pCachedPoints->end() ) { pos->second.m_Point.x += trans.x; pos->second.m_Point.y += trans.y; ++pos; } } else { while( pos != m_pCachedPoints->end() ) { Trans.Transform( &pos->second.m_Point, 1 ); ++pos; } } } else { while( pos != m_pCachedPoints->end() ) { Trans.Transform( &pos->second.m_Point, 1 ); ++pos; } } } }

void BrushAttrValue::TransformCachedRect (  TransformBase &  Trans  )

Because it takes such a long time to calculate the bounding rect of a brushed object we prefer to calculate it once and then simply transform it. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/95 Parameters: Trans  - the transformation to perform [INPUTS] -  [OUTPUTS] Returns: Definition at line 2379 of file brshattr.cpp. { // if we have offsets from the path then simply transforming it doesn't work, // better to recalculate it if (m_pProcessor != NULL) { if (m_pProcessor->GetPathOffsetType() != OFFSET_NONE) m_CachedBRect.MakeEmpty(); } if (!m_CachedBRect.IsEmpty()) { DocCoord Coords[4]; Coords[0].x = m_CachedBRect.lo.x; Coords[0].y = m_CachedBRect.lo.y; Coords[1].x = m_CachedBRect.hi.x; Coords[1].y = m_CachedBRect.lo.y; Coords[2].x = m_CachedBRect.hi.x; Coords[2].y = m_CachedBRect.hi.y; Coords[3].x = m_CachedBRect.lo.x; Coords[3].y = m_CachedBRect.hi.y; Trans.Transform(Coords,4); m_CachedBRect.lo.x = min(min(Coords[0].x,Coords[1].x), min(Coords[2].x,Coords[3].x)); m_CachedBRect.hi.x = max(max(Coords[0].x,Coords[1].x), max(Coords[2].x,Coords[3].x)); m_CachedBRect.lo.y = min(min(Coords[0].y,Coords[1].y), min(Coords[2].y,Coords[3].y)); m_CachedBRect.hi.y = max(max(Coords[0].y,Coords[1].y), max(Coords[2].y,Coords[3].y)); } }

void BrushAttrValue::TransformTimeStampList (  TransformBase &  Trans  )

transforms all the points in the timestamping cache Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: the  transformation to perform [INPUTS] Returns: - See also: - Definition at line 1439 of file brshattr.cpp. { if (m_pTimeStampList == NULL) return; // pretty straightforward, just get the points out of the list and transform them TimeStampBrushPoint TSBP; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); while( ListPos != m_pTimeStampList->end() ) { TimeStampList::iterator OldPos = ListPos; TSBP = *ListPos; ++ListPos; Trans.Transform(&TSBP.m_Point, 1); *OldPos = TSBP; } }

BOOL BrushAttrValue::WritePressureData (  BaseCamelotFilter *  pFilter  )

If this attribute contains pressure data then it will write out that data to the filter provided. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pfilter  - filter to write to [INPUTS] Returns: TRUE if the list is correctly written See also: AttrBrushType::WritePreChildrenNative; BrushAttrRecordHandler::HandleRecord Definition at line 2815 of file brshattr.cpp. { ERROR2IF(pFilter == NULL, FALSE, "Filter is NULL in BrushAttrValue::WriteTimeStampList"); if (m_pPressureSampler == NULL) return TRUE; // return TRUE else we'll spring an error // make ourselves a record CXaraFileRecord Record ( static_cast<INT32> ( TAG_BRUSHPRESSURESAMPLEDATA ), static_cast<INT32> ( TAG_BRUSHSAMPLEDATA_SIZE ) ); BOOL ok = Record.Init(); if (ok) ok = m_pPressureSampler->WriteNative(&Record); if (ok) ok = pFilter->Write(&Record); return ok; }

BOOL BrushAttrValue::WriteTimeStampList (  BaseCamelotFilter *  pFilter  )

If this brush uses timestamping then this function writes the timestamped list to the filter provided. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pfilter  - filter to write to [INPUTS] Returns: TRUE if the list is correctly written See also: AttrBrushType::WritePreChildrenNative; BrushAttrRecordHandler::HandleRecord Definition at line 2768 of file brshattr.cpp. { ERROR2IF(pFilter == NULL, FALSE, "Filter is NULL in BrushAttrValue::WriteTimeStampList"); if (m_pTimeStampList == NULL) return TRUE; // return TRUE else we'll spring an error INT32 NumObjects = (INT32)m_pTimeStampList->size(); // make ourselves a record CXaraFileRecord Record ( static_cast<INT32> ( TAG_TIMESTAMPBRUSHDATA ), static_cast<INT32> ( TAG_TIMESTAMPBRUSHDATA_SIZE ) ); BOOL ok = Record.Init(); // the first entry in the record is how many objects there are if (ok) ok = Record.WriteINT32(NumObjects); // now write the data TimeStampBrushPoint ListItem; TimeStampList::iterator ListPos = m_pTimeStampList->begin(); while( ok && ListPos != m_pTimeStampList->end() ) { ListItem = *ListPos; ++ListPos; ok = ListItem.WriteNative(&Record); } if (ok) ok = pFilter->Write(&Record); return ok; }

---

Member Data Documentation

DocRect BrushAttrValue::m_CachedBRect [private]

Definition at line 296 of file brshattr.h.

PointsMap* BrushAttrValue::m_pCachedPoints [private]

Definition at line 288 of file brshattr.h.

CDistanceSampler* BrushAttrValue::m_pPressureSampler [private]

Definition at line 295 of file brshattr.h.

PressureArray* BrushAttrValue::m_pPressureVals [private]

Definition at line 293 of file brshattr.h.

PathProcessorBrush* BrushAttrValue::m_pProcessor [private]

Definition at line 284 of file brshattr.h.

ListUpdateType BrushAttrValue::m_PressureUpdateType [private]

Definition at line 300 of file brshattr.h.

TimeStampList* BrushAttrValue::m_pTimeStampList [private]

Definition at line 291 of file brshattr.h.

ListUpdateType BrushAttrValue::m_TimeStampUpdateType [private]

Definition at line 298 of file brshattr.h.

---

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

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

---