StrokeTypeAttrValue Class Reference

StrokeType attribute value StrokeType attributes describe the stroking characteristics for a path. More...

#include <strkattr.h>

Inheritance diagram for StrokeTypeAttrValue:

List of all members.

Public Member Functions
	StrokeTypeAttrValue (PathProcessorStroke *pPathProcessor=NULL)
	Default Constuctor for StrokeTypeAttrValue.
	~StrokeTypeAttrValue ()
	Destructor Deletes any attached PathProcessor (see the constructor).
virtual void	Render (RenderRegion *pRegion, BOOL Temp=FALSE)
	Sets the StrokeTypeAttrValue attribute for the given render region.
virtual void	Restore (RenderRegion *pRegion, BOOL Temp)
	Restores the StrokeTypeAttrValue 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 StrokeTypeAttrValue &	operator= (StrokeTypeAttrValue &Attrib)
	Assignment operator.
virtual INT32	operator== (const StrokeTypeAttrValue &Attrib)
	Comparison operator.
void	SetPathProcessor (PathProcessorStroke *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.
PathProcessorStroke *	GetPathProcessor (void) const
BOOL	DoBecomeA (BecomeA *pBecomeA, Node *pParent)
	To convert our stroke into something more palatable. pParent should always be a nodepath.
Static Public Member Functions
static BOOL	Init (void)
	Registers a default attribute of this type with the attribute manager.
Private Attributes
PathProcessorStroke *	pProcessor

---

Detailed Description

StrokeType attribute value StrokeType attributes describe the stroking characteristics for a path.

Author:

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

Date:

7/1/97

Notes: This AttrValue just contains a pointer to a path processor which will stroke paths after some given fashion. The pointer may be NULL, in which case new-style stroking is disabled, and old-style "lines" will be rendered.

Definition at line 147 of file strkattr.h.

---

Constructor & Destructor Documentation

StrokeTypeAttrValue::StrokeTypeAttrValue (  PathProcessorStroke *  pPathProcessor = NULL  )

Default Constuctor for StrokeTypeAttrValue. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 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 StrokeTypeAttrValue, and will be deleted when the attribute value is deleted. Definition at line 617 of file strkattr.cpp. { // Remember our processor, and let it know that we "own" it pProcessor = pPathProcessor; if (pProcessor != NULL) pProcessor->SetParentAttr(this); }

StrokeTypeAttrValue::~StrokeTypeAttrValue (   )

Destructor Deletes any attached PathProcessor (see the constructor). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Definition at line 639 of file strkattr.cpp. { if (pProcessor != NULL) delete pProcessor; }

---

Member Function Documentation

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

To convert our stroke into something more palatable. pParent should always be a nodepath. 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, Notes: Due to problems with bevelling and contouring this function does not get called in the normal DoBecomeA procedure unless you specifically locate this attribute and call this function directly. Definition at line 967 of file strkattr.cpp. { ERROR2IF(pBecomeA == NULL, FALSE, "BecomeA pointer is NULL in VariableWidthAttrValue::DoBecomeA"); ERROR2IF(pParent == NULL, FALSE, "Parent node is NULL in VariableWidthAttrValue::DoBecomeA"); if (pProcessor == NULL) return FALSE; if (!pBecomeA->BAPath()) 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 = pProcessor->DoBecomeA(pBecomeA, &((NodePath*)pParent)->InkPath, pParent); } else if (pParent->CanBecomeA(pBecomeA)) { // 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 = pProcessor->DoBecomeA(pBecomeA, pPath, pParent); } delete pPath; } } return Success; }

PathProcessorStroke* StrokeTypeAttrValue::GetPathProcessor (  void   )  const [inline]

Definition at line 174 of file strkattr.h. { return(pProcessor); };

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

A sister function to Render(). Author: Jason_Williams (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 StrokeTypeAttrValue::Render See also: StrokeTypeAttrValue::Render() Reimplemented from AttributeValue. Definition at line 764 of file strkattr.cpp. { if (pProcessor != NULL) pRegion->PopPathProcessor(); }

BOOL StrokeTypeAttrValue::Init (  void   )  [static]

Registers a default attribute of this type with the attribute manager. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Returns: TRUE if it initilised successfully Reimplemented from SimpleCCObject. Definition at line 660 of file strkattr.cpp. { // The default attribute is one that has no effect (i.e. produces old-style "lines") StrokeTypeAttrValue *pAttr = new StrokeTypeAttrValue; if (pAttr == NULL) return FALSE; UINT32 ID = AttributeManager::RegisterDefaultAttribute(CC_RUNTIME_CLASS(StrokeTypeAttrValue), pAttr); ERROR2IF(ID == ATTR_BAD_ID, FALSE, "Bad ID when Initialising StrokeTypeAttrValue"); return(TRUE); }

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

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

NodeAttribute * StrokeTypeAttrValue::MakeNode (   )  [virtual]

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

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

Assignment operator. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Parameters: Attrib  - the attribute to copy [INPUTS] Definition at line 866 of file strkattr.cpp. { // Get rid of our old processor (if any) if (pProcessor != NULL) delete pProcessor; 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.pProcessor != NULL) { pProcessor = Attrib.pProcessor->Clone(); if (pProcessor != NULL) pProcessor->SetParentAttr(this); } return(*this); }

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

Comparison operator. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Parameters: Attrib  - the attribute to compare this attribute with [INPUTS] Returns: TRUE if the attributes are considered equal Definition at line 902 of file strkattr.cpp. { ERROR3IF(!Attrib.IsKindOf(CC_RUNTIME_CLASS(StrokeTypeAttrValue)), "Other attribute value isn't an StrokeTypeAttrValue"); StrokeTypeAttrValue *Other = (StrokeTypeAttrValue *) &Attrib; // Equal if they both have same processor (only applies if they are both NULL) if (pProcessor == Other->pProcessor) return(TRUE); // Otherwise, if one of them is NULL, they can't be the same if (pProcessor == NULL || Other->pProcessor == NULL) return(FALSE); // Finally, ask the processors if they are of the same type return(!pProcessor->IsDifferent(Other->pProcessor)); }

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

Sets the StrokeTypeAttrValue attribute for the given render region. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 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: StrokeTypeAttrValue::Restore Implements AttributeValue. Definition at line 696 of file strkattr.cpp. { // Stack the current attribute and set ourselves up as the new one pRegion->SetStrokeType(this, Temp); // 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 (pProcessor != NULL) { PathProcessorStroke *pNewProcessor = pProcessor->Clone(); if (pNewProcessor != NULL) pRegion->PushPathProcessor(pNewProcessor); } }

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

Restores the StrokeTypeAttrValue attribute for the given render region. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 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 StrokeTypeAttrValue::Render Implements AttributeValue. Definition at line 731 of file strkattr.cpp. { pRegion->RestoreStrokeType(this, Temp); }

void StrokeTypeAttrValue::SetPathProcessor (  PathProcessorStroke *  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: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 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 938 of file strkattr.cpp. { if (pProcessor != NULL) delete pProcessor; pProcessor = pNewProcessor; if (pProcessor != NULL) pProcessor->SetParentAttr(this); }

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

See AttributeValue::SimpleCopy. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/97 Parameters: pValue  - pointer to the AttributeValue to copy [INPUTS] Implements AttributeValue. Definition at line 785 of file strkattr.cpp. { ERROR3IF(!IS_A(pValue, StrokeTypeAttrValue), "Invalid Attribute value passed to StrokeTypeAttrValue::SimpleCopy"); // Just uses the assignment operator *this = *((StrokeTypeAttrValue *) pValue); }

---

Member Data Documentation

PathProcessorStroke* StrokeTypeAttrValue::pProcessor [private]

Definition at line 179 of file strkattr.h.

---

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

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

---