PathProcessorStroke Class Reference

This is the abstract base class for all PathProcessors. More...

#include <ppstroke.h>

Inheritance diagram for PathProcessorStroke:

List of all members.

Public Member Functions
	PathProcessorStroke ()
	Constructor.
virtual void	ProcessPath (Path *pPath, RenderRegion *pRender, PathShape ShapePath=PATHSHAPE_PATH)
	Called by the RenderRegion to apply the path processing operation to the given path.
virtual BOOL	WillChangeFillAndStrokeSeparately (void)
	Called by the RenderRegion to determine if this PathProcessorStroke affects the "fill" and "stroke" portions of the path separately. (Generally speaking, only fill/stroke providers will cause these two different "bits" of a path to be rendered separately). This call is made BEFORE this Processor's ProcessPath function will be called.
virtual BOOL	IsDifferent (PathProcessorStroke *pOther)
	Equality operator.
virtual PathProcessorStroke *	Clone (void)
	To copy PathProcessorStroke or derived-class object.
virtual BOOL	NeedsTransparency () const
virtual BOOL	DoBecomeA (BecomeA *pBecomeA, Path *pPath, Node *pParent)
	To return the processed path to a BecomeA object. Does pretty much the same as process path but withot rendering anything.
virtual BOOL	DoesActuallyDoAnything (RenderRegion *pRender)
	Allows the render region to know whether this PPS will do anything, if not then it can DrawPath normally allowing Dash patterns to be applied to nodes with constant VarWidth attributes applied to them.
virtual BOOL	IsAPathProcessorStroke ()
NodePath *	GetProcessedPath (Path *pPath, Node *pParent)
	To return the stroked path.
Path *	GetProcessedPath (Path *pPath, CCAttrMap *pAttrMap)
	This is a rehash of Diccon's GetProcessedPath method, except you needn't worry about any nodes but the four NodeAttributes below, which must live in the supplied attr-map.
NodePath *	GetSmoothProcessedPath (Path *pPath, Node *pParent)
Protected Member Functions
TrapsList *	PrepareTrapsForStroke (Path *pPath, RenderRegion *pRender, INT32 LineWidth)
	Precalculation function to be used in tandem with CreateVarWidthStroke(). If you want to create several strokes along the same path, then precalculating the trapezoids will give a large performance improvement.
Path *	CreateVarWidthStroke (Path *pPath, RenderRegion *pRender, INT32 LineWidth, TrapsList *pTrapezoids=NULL)
	Strokes the given path according to variable width parameters in the given render region, producing a new path representing the outline of a variable-width stroke.
BOOL	GetRequiredAttributes (CCAttrMap *pAttrMap, INT32 *pLineWidth, LineCapType *pLineCap, ValueFunction **ppValFunc, JointType *pJoinStyle)
	Extracts the following values, required for path stroking, from the supplied attribute map: Line width. Line start-cap - eg square or round end. Pointer to any applied width function - may be NULL. Join style - eg bevelled, mitred, round.
Path *	CreateSmoothVarWidthStroke (Path *pPath, RenderRegion *pRender, INT32 LineWidth, TrapsList *pTrapezoids=NULL)
Private Member Functions
	CC_DECLARE_DYNAMIC (PathProcessorStroke)
Friends
class	RenderRegion

---

Detailed Description

This is the abstract base class for all PathProcessors.

Author:

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

Date:

20/12/96

These classes are created by attributes (or similar) when rendered, and placed on a stack in the RenderRegion. Whenever RenderRegion::DrawPath is invoked to render a path, all stacked PathProcessors will be called in turn, and they call back to RenderRegion functions to render whatever they wish (usually a modified form of the original path).

This can be used to "filter" almost any rendering, but is mainly intended for use by stroke and fill providers, which replace input paths with more suitable shapes to be rendered.

See also:

RenderRegion::DrawPath; PathProcessor::ProcessPath

Definition at line 134 of file ppstroke.h.

---

Constructor & Destructor Documentation

PathProcessorStroke::PathProcessorStroke (   )

Constructor. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 31/12/96 Definition at line 142 of file ppstroke.cpp. { }

---

Member Function Documentation

PathProcessorStroke::CC_DECLARE_DYNAMIC (  PathProcessorStroke   )  [private]

PathProcessorStroke * PathProcessorStroke::Clone (  void   )  [virtual]

To copy PathProcessorStroke or derived-class object. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 8/1/97 Returns: NULL if we're out of memory, else a pointer to a clone (exact copy) of this object Reimplemented in PathProcessorStrokeAirbrush, and PathProcessorStrokeVector. Definition at line 577 of file ppstroke.cpp. { // Clone this object - this can be done by just creating a new one PathProcessorStroke *pClone = new PathProcessorStroke; // And copy the (base class) parent-attribute pointer so we know when our // parent attribute is "current" in the render region. if (pClone != NULL) pClone->SetParentAttr(GetParentAttr()); return(pClone); }

Path * PathProcessorStroke::CreateSmoothVarWidthStroke (  Path *  pPath, RenderRegion *  pRender, INT32  LineWidth, TrapsList *  pTrapezoids = NULL )  [protected]

Definition at line 1076 of file ppstroke.cpp. { ERROR3IF(pPath == NULL || pRender == NULL, "Illegal NULL Params"); ERROR3IF(!pPath->IsStroked, "PathProcessor expects to be given a stroked path"); // --- Ignore infinitely thin strokes if (LineWidth < 1) return(NULL); // --- Create a new path to be rendered in place of the provided path // Note that I use a large allocation size so that reallocation need not be done // frequently, which also helps reduce memory fragmentation. Path *pOutput = new Path; if (pOutput == NULL) return(NULL); pOutput->Initialise(128, 128); // --- Get the current cap style from the render region // In case of failure, we initialise with suitable defaults LineCapType LineCap = LineCapButt; // BLOCK { StartCapAttribute *pCapAttr = (StartCapAttribute *) pRender->GetCurrentAttribute(ATTR_STARTCAP); if (pCapAttr != NULL) LineCap = pCapAttr->StartCap; } // --- Get the variable line width descriptor from the render region ValueFunction *pValFunc = NULL; // BLOCK { VariableWidthAttrValue *pVarWidthAttr = (VariableWidthAttrValue *) pRender->GetCurrentAttribute(ATTR_VARWIDTH); if (pVarWidthAttr != NULL) pValFunc = pVarWidthAttr->GetWidthFunction(); // If it is a constant width stroke, we'll just get GDraw to stroke it for us, // as that code is optimised assembler, and need not worry about variable width, // and as a result is about 4 times faster! if (pValFunc == NULL || IS_A(pValFunc, ValueFunctionConstant)) { // Get the current line join style from the render region JointType JoinStyle = RoundJoin; JoinTypeAttribute *pJoinAttr = (JoinTypeAttribute *) pRender->GetCurrentAttribute(ATTR_JOINTYPE); if (pJoinAttr != NULL) JoinStyle = pJoinAttr->JoinType; pPath->StrokePathToPath(LineWidth, LineCap, JoinStyle, NULL, pOutput); pOutput->IsFilled = TRUE; pOutput->IsStroked = FALSE; return(pOutput); } } // --- If none were passed in, generate the set of trapezoids for the dest path BOOL MustDeleteTraps = FALSE; if (pTrapezoids == NULL) { MustDeleteTraps = TRUE; pTrapezoids = PrepareTrapsForStroke(pPath, pRender, LineWidth); if (pTrapezoids == NULL) return(NULL); } // --- Stroke the trapezoids into a variable-width path PathStroker Stroker(pValFunc, LineWidth, LineCap); // our new option allows us to only get the forward mapped path if (!Stroker.StrokeSmoothPath(pTrapezoids, pOutput)) { if (MustDeleteTraps) delete pTrapezoids; return(NULL); } if (MustDeleteTraps) delete pTrapezoids; return(pOutput); }

Path * PathProcessorStroke::CreateVarWidthStroke (  Path *  pPath, RenderRegion *  pRender, INT32  LineWidth, TrapsList *  pTrapezoids = NULL )  [protected]

Strokes the given path according to variable width parameters in the given render region, producing a new path representing the outline of a variable-width stroke. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 31/12/96 (split into new function, 6/2/97) Parameters: pPath  - The source path to be stroked [INPUTS] pRender - The render region it will be drawn to LineWidth - The maximum width of the stroke. Normally this is the current line width from the RndRgn, but derived classes like airbrushes like to vary this value, hence it is a parameter. pTrapezoids - NULL (in which case this function will generate the TrapList for itself), or a pointer to a precalculated trapezoid list (this should be generated by calling PathProcessorStroke::PrepareTrapsForStroke, and should be used if you are generating multiple strokes from one source (e.g. see the Airbrush stroker - ppairbsh.cpp)). (NOTE that using one TrapsList for multiple strokes will also give more consistent positioning of width/pattern elements along the path length) Returns: NULL if it failed, else a pointer to a new Path object (which the caller must delete) to be drawn instead of the provided pPath parameter. Internal helper funciton for this class and derived classes. See also: PathProcessorStroke::ProcessPath; PathProcessorStroke::PrepareTrapsForStroke Definition at line 737 of file ppstroke.cpp. { ERROR3IF(pPath == NULL || pRender == NULL, "Illegal NULL Params"); ERROR3IF(!pPath->IsStroked, "PathProcessor expects to be given a stroked path"); // --- Ignore infinitely thin strokes if (LineWidth < 1) return(NULL); // --- Create a new path to be rendered in place of the provided path // Note that I use a large allocation size so that reallocation need not be done // frequently, which also helps reduce memory fragmentation. Path *pOutput = new Path; if (pOutput == NULL) return(NULL); pOutput->Initialise(128, 128); // --- Get the current cap style from the render region // In case of failure, we initialise with suitable defaults LineCapType LineCap = LineCapButt; // BLOCK { StartCapAttribute *pCapAttr = (StartCapAttribute *) pRender->GetCurrentAttribute(ATTR_STARTCAP); if (pCapAttr != NULL) LineCap = pCapAttr->StartCap; } // --- Get the variable line width descriptor from the render region ValueFunction *pValFunc = NULL; // BLOCK { VariableWidthAttrValue *pVarWidthAttr = (VariableWidthAttrValue *) pRender->GetCurrentAttribute(ATTR_VARWIDTH); if (pVarWidthAttr != NULL) pValFunc = pVarWidthAttr->GetWidthFunction(); // If it is a constant width stroke, we'll just get GDraw to stroke it for us, // as that code is optimised assembler, and need not worry about variable width, // and as a result is about 4 times faster! if (pValFunc == NULL || IS_A(pValFunc, ValueFunctionConstant)) { // Get the current line join style from the render region JointType JoinStyle = RoundJoin; JoinTypeAttribute *pJoinAttr = (JoinTypeAttribute *) pRender->GetCurrentAttribute(ATTR_JOINTYPE); if (pJoinAttr != NULL) JoinStyle = pJoinAttr->JoinType; pPath->StrokePathToPath(LineWidth, LineCap, JoinStyle, NULL, pOutput); pOutput->IsFilled = TRUE; pOutput->IsStroked = FALSE; return(pOutput); } } // --- If none were passed in, generate the set of trapezoids for the dest path BOOL MustDeleteTraps = FALSE; if (pTrapezoids == NULL) { MustDeleteTraps = TRUE; pTrapezoids = PrepareTrapsForStroke(pPath, pRender, LineWidth); if (pTrapezoids == NULL) return(NULL); } // --- Stroke the trapezoids into a variable-width path PathStroker Stroker(pValFunc, LineWidth, LineCap); // our new option allows us toonly get the forward mapped path if (!Stroker.StrokePath(pTrapezoids, pOutput)) { if (MustDeleteTraps) delete pTrapezoids; return(NULL); } if (MustDeleteTraps) delete pTrapezoids; return(pOutput); }

BOOL PathProcessorStroke::DoBecomeA (  BecomeA *  pBecomeA, Path *  pPath, Node *  pParent )  [virtual]

To return the processed path to a BecomeA object. Does pretty much the same as process path but withot rendering anything. 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] pPath - the path that we are processing pParent- the node that this brush is applied to [OUTPUTS]  Returns: TRUE if everything went ok, Note: Because of the problems with bevelling and contouring this function will never be called as part of the normal DoBecomeA procedure. You have to specifically locate the AttrStrokeType and call its DoBecomeA directly if you wish to extract the paths from a stroke. This should be resolved somehow after the release. 25/10/2000 Extra note: We are now working out a mechanism which uses GetProcessedPath and GetOutlinePath, so this function may become obsolete Reimplemented from PathProcessor. Definition at line 325 of file ppstroke.cpp. { ERROR2IF(pBecomeA == NULL, FALSE, "BecomeA pointer is NULL in PathProcessorStroke::DoBecomeA"); ERROR2IF(pParent == NULL, FALSE, "Parent is NULL in PathProcessorStroke::DoBecomeA"); ERROR2IF(pPath == NULL, FALSE, "Path is NULL in PathProcessorStroke::DoBecomeA"); // we need to make a new nodepath NodePath* pNewNode = GetSmoothProcessedPath(pPath, pParent); if (pNewNode == FALSE) return FALSE; BOOL Success = FALSE; // now what we do depends on what type of BecomeA we've got if (pBecomeA->BAPath()) { switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE: { UndoableOperation* pUndoOp = pBecomeA->GetUndoOp(); ERROR2IF(pUndoOp == NULL, FALSE, "No op pointer in PathProcessorStroke::DoBecomeA"); // apply attributes to our new node // Get the attributes CCAttrMap AttribMap(30); if (!((NodeRenderableInk*)pParent)->FindAppliedAttributes(&AttribMap)) break; // another bodge: this time if we have a stroked path that is not closed and // we have given it a stroke colour then we want this stroke colour to become // the fill colour of the new shape AttrStrokeColour * pColour = NULL; // if (!pParent->IsNodePath() && ((NodePath*)pParent)->InkPath.IsClosed()) { // look up the stroke colour attribute //AttribMap.Lookup((void *)CC_RUNTIME_CLASS(AttrStrokeColour), // (void *&)pColour); ((NodeRenderableInk*)pParent)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), (NodeAttribute**)&pColour); // make a new flat fill attribute and apply this to the node if (pColour) { StrokeColourAttribute * pAttrVal = (StrokeColourAttribute *)pColour->GetAttributeValue(); if (pAttrVal) { AttrFlatColourFill *pFill = NULL; // create and insert at first child ALLOC_WITH_FAIL(pFill, new AttrFlatColourFill(pNewNode, FIRSTCHILD), pUndoOp); pFill->SetStartColour(&(pAttrVal->Colour)); // remove from the map so we don't duplicate AttribMap.RemoveKey(pFill->GetAttributeType()); } } } if (!pNewNode->ApplyAttributes(&AttribMap)) break; // insert the new node and delete the original BOOL ok = TRUE; // If we don't own the parent node, we should insert after (on top of) it if (pBecomeA->IsSecondary()) ok = pUndoOp->DoInsertNewNode(pNewNode,pParent,NEXT,FALSE,FALSE,FALSE,FALSE); else { ok = pUndoOp->DoInsertNewNode(pNewNode,pParent,PREV,FALSE,FALSE,FALSE,FALSE); // If this BecomeA is a primary, then delete the source node if (ok) ok = pUndoOp->DoHideNode((NodeRenderableInk*)pParent, TRUE); } if (!ok) break; if (!pBecomeA->IsCombineBecomeA()) { // pass it back then pBecomeA->PassBack(pNewNode,(NodeRenderableInk*)pParent); } else { CombineBecomeA* pPassback = (CombineBecomeA*) pBecomeA; pPassback->SetStrokeCreatedPassbackPath(TRUE); pBecomeA->PassBack(pNewNode,(NodeRenderableInk*)pParent); pPassback->SetStrokeCreatedPassbackPath(FALSE); } Success = TRUE; } break; case BECOMEA_PASSBACK : { if (!pBecomeA->IsCombineBecomeA ()) { // pass it back then Success = pBecomeA->PassBack(pNewNode,(NodeRenderableInk*)pParent); } else { CombineBecomeA* pPassback = (CombineBecomeA*) pBecomeA; pPassback->SetStrokeCreatedPassbackPath(TRUE); Success = pBecomeA->PassBack(pNewNode,(NodeRenderableInk*)pParent); pPassback->SetStrokeCreatedPassbackPath(FALSE); } } break; default: break; } } if (!Success) delete pNewNode; return Success; }

BOOL PathProcessorStroke::DoesActuallyDoAnything (  RenderRegion *  pRender  )  [virtual]

Allows the render region to know whether this PPS will do anything, if not then it can DrawPath normally allowing Dash patterns to be applied to nodes with constant VarWidth attributes applied to them. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/9/2000 Parameters: pRender  - the render region we are about to render into. Note that it is [INPUTS] important that the region has had all its attributes rendered into it Returns: TRUE if this PPS is going to change the path, FALSE if it will not. Reimplemented from PathProcessor. Definition at line 607 of file ppstroke.cpp. { ERROR2IF(pRender == NULL, FALSE, "RenderRegion is NULL in PathProcessorStroke::DoesActuallyDoAnything"); if (IsDisabled()) return FALSE; // Get the value function from the render region and have a look at it ValueFunction *pValFunc = NULL; VariableWidthAttrValue *pVarWidthAttr = (VariableWidthAttrValue *) pRender->GetCurrentAttribute(ATTR_VARWIDTH); if (pVarWidthAttr != NULL) pValFunc = pVarWidthAttr->GetWidthFunction(); // If it is a constant width stroke, then we don't really do anything if (pValFunc == NULL || IS_A(pValFunc, ValueFunctionConstant)) return FALSE; // likewise if we have a brush don't do anything either, because we will use the stroke to // generate a pressure curve for the brush BrushAttrValue* pBrush = (BrushAttrValue*) pRender->GetCurrentAttribute(ATTR_BRUSHTYPE); if (pBrush != NULL && pBrush->GetBrushHandle() != BrushHandle_NoBrush) return FALSE; return TRUE; }

Path * PathProcessorStroke::GetProcessedPath (  Path *  pPath, CCAttrMap *  pAttrMap )

This is a rehash of Diccon's GetProcessedPath method, except you needn't worry about any nodes but the four NodeAttributes below, which must live in the supplied attr-map. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 17/11/2000 Parameters: pPath  the path to stroke [INPUTS] pAttrMap the attr-map to get things like line-width and cap styles from. Returns: ptr to a new path which is a stroked version of the supplied source path, or NULL if unsuccessful. We also don't use render-regions, as their not actually necessary (the other version of this method does). Notes: The following valid NodeAttributes must live in the attr-map: AttrLineWidth AttrStartCap AttrVariableWidth AttrJoinType Returns: Errors: ERROR2 with FALSE if anything goes wrong, or our inputs are NULL or invalid. See also: Diccon's GetProcessedPath() higher up this file. Definition at line 853 of file ppstroke.cpp. { ERROR2IF(pPath == NULL || pAttrMap == NULL, NULL, "PathProcessorStroke::GetProcessedPath; NULL input parameters!"); INT32 LineWidth; LineCapType LineCap; ValueFunction* pValFunc; JointType JoinStyle; if (!GetRequiredAttributes(pAttrMap, &LineWidth, &LineCap, &pValFunc, &JoinStyle)) return NULL; if (LineWidth < 1) return NULL; // Create a path to hold our stroking exploits! // We'll prob'ly be generating loads of data, so be generous with our path's // initialisation, so it's not continually reallocating memory as it runs out. Path* pStroke = new Path; if (pStroke == NULL) return NULL; if (!pStroke->Initialise(128, 128)) { delete pStroke; return NULL; } // if it's a constant-width stroke, ask GDraw to stroke it - it's // quicker and if it goes wrong, it's Gavin's fault (only joking ;o) if (pValFunc == NULL || IS_A(pValFunc, ValueFunctionConstant)) { pPath->StrokePathToPath(LineWidth, LineCap, JoinStyle, NULL, pStroke); pStroke->IsFilled = TRUE; pStroke->IsStroked = TRUE; return pStroke; } // ok, GDraw didn't deal with it, so let's get down to business. // Generate the set of trapezoids for the dest path. ProcessPathToTrapezoids GenerateTraps(64); TrapsList *pTrapezoids = new TrapsList; BOOL ok = (pTrapezoids != NULL); if (ok) ok = GenerateTraps.Init(pPath, pTrapezoids); if (ok) { // Flags are: Flatten, QuantiseLines, QuantiseAll ProcessFlags PFlags(TRUE, FALSE, FALSE); ok = GenerateTraps.Process(PFlags, TrapTravel_Parametric, JoinStyle); } // Stroke the trapezoids into a variable-width path. if (ok) { PathStroker Stroker(pValFunc, LineWidth, LineCap); ok = Stroker.StrokeSmoothPath(pTrapezoids, pStroke); } // tidy up temporary info. if (pTrapezoids != NULL) { delete pTrapezoids; pTrapezoids = NULL; } // tidy up the path and pass it out. if (pStroke != NULL) { if (ok) { if (!pStroke->IsClosed()) pStroke->TryToClose(); } else { delete pStroke; pStroke = NULL; } } return pStroke; }

NodePath * PathProcessorStroke::GetProcessedPath (  Path *  pPath, Node *  pParent )

To return the stroked path. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/3/2000 Parameters: pPath  - the path that we are processing [INPUTS] pParent- the node that this brush is applied to [OUTPUTS]  Returns: A NodePath, containing the path generated by our path stroker Notes: Definition at line 467 of file ppstroke.cpp. { // we need to fake a renderregion as our helper functions need one, // luckily FormatRegion is on hand from the text stuff FormatRegion FakeRender; if (!FakeRender.Init((NodeRenderableInk*)pParent)) // init renders all applied attributes into the region return NULL; // From here copied from ProcessPath: // --- Get the current line width, cap style, and join style from the render region // In case of failure, we initialise with suitable defaults INT32 LineWidth = 5000; // BLOCK { LineWidthAttribute *pWidthAttr = (LineWidthAttribute *) FakeRender.GetCurrentAttribute(ATTR_LINEWIDTH); if (pWidthAttr != NULL) LineWidth = pWidthAttr->LineWidth; } // --- Create a stroke outline by calling our helper function Path *pOutput = CreateVarWidthStroke(pPath, &FakeRender, LineWidth); if (pOutput == NULL) return FALSE; if (!pOutput->IsClosed()) pOutput->TryToClose(); // we need to make a new nodepath NodePath* pNewNode = new NodePath; if (pNewNode == NULL) { delete pOutput; return FALSE; } // initialise the path if (!pNewNode->InkPath.Initialise(pOutput->GetNumCoords(), 128)) { delete pOutput; delete pNewNode; return FALSE; } // Copy our path data into it //CALL_WITH_FAIL(!pNewNode->InkPath.CopyPathDataFrom(pOutput), pUndoOp, Success) if (!pNewNode->InkPath.CopyPathDataFrom(pOutput)) { delete pOutput; delete pNewNode; return FALSE; } // don't need that path anymore delete pOutput; pOutput = NULL; return pNewNode; }

BOOL PathProcessorStroke::GetRequiredAttributes (  CCAttrMap *  pAttrMap, INT32 *  pLineWidth, LineCapType *  pLineCap, ValueFunction **  ppValFunc, JointType *  pJoinStyle )  [protected]

Extracts the following values, required for path stroking, from the supplied attribute map: Line width. Line start-cap - eg square or round end. Pointer to any applied width function - may be NULL. Join style - eg bevelled, mitred, round. Parameters: pAttrMap  ptr to the attr-map to search. [INPUTS] pLineWidth line width ptr to fill. pLineCap end-cap type ptr to fill. ppValFunc variable line-width function ptr to fill. pJoinStyle join style ptr to fill. If  successful, the supplied pointers are filled with the appropriate values [OUTPUTS] from the attribute map, otherwise they are filled with default values. Returns: TRUE if successful, FALSE otherwise. Notes: If this function fails, *DO NOT* use the output values! They are only there in case you screw up and *do* decide to use them, in which case they should hopefully not bring Camelot down around your ears! Returns: Errors: An error message is output to TRACE if we were unsuccessful. I'm not putting in an ERROR2 or 3, as I think from a user view-point, a quiet failure is more graceful. Definition at line 977 of file ppstroke.cpp. { AttrLineWidth* pAttrWidth = NULL; AttrStartCap* pAttrCap = NULL; AttrVariableWidth* pAttrVarWidth = NULL; AttrJoinType* pAttrJoinType = NULL; pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrLineWidth), (void*&)pAttrWidth); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrStartCap), (void*&)pAttrCap); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrVariableWidth),(void*&)pAttrVarWidth); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrJoinType), (void*&)pAttrJoinType); if (pAttrWidth == NULL || pAttrCap == NULL || pAttrVarWidth == NULL || pAttrJoinType == NULL) { TRACEALL( _T("PathProcessorStroke::GetProcessedPath; AttrMap doesn't contain the required attrs!") ); *pLineWidth = 0; *pLineCap = LineCapButt; *ppValFunc = NULL; *pJoinStyle = RoundJoin; return FALSE; } *pLineWidth = pAttrWidth->Value.LineWidth; *pLineCap = pAttrCap->Value.StartCap; *ppValFunc = pAttrVarWidth->Value.GetWidthFunction(); *pJoinStyle = pAttrJoinType->Value.JoinType; return TRUE; }

NodePath * PathProcessorStroke::GetSmoothProcessedPath (  Path *  pPath, Node *  pParent )

Definition at line 1014 of file ppstroke.cpp. { // we need to fake a renderregion as our helper functions need one, // luckily FormatRegion is on hand from the text stuff FormatRegion FakeRender; if (!FakeRender.Init((NodeRenderableInk*)pParent)) // init renders all applied attributes into the region return FALSE; // From here copied from ProcessPath: // --- Get the current line width, cap style, and join style from the render region // In case of failure, we initialise with suitable defaults INT32 LineWidth = 5000; // BLOCK { LineWidthAttribute *pWidthAttr = (LineWidthAttribute *) FakeRender.GetCurrentAttribute(ATTR_LINEWIDTH); if (pWidthAttr != NULL) LineWidth = pWidthAttr->LineWidth; } // --- Create a stroke outline by calling our helper function Path *pOutput = CreateSmoothVarWidthStroke(pPath, &FakeRender, LineWidth); if (pOutput == NULL) return FALSE; if (!pOutput->IsClosed()) pOutput->TryToClose(); // we need to make a new nodepath NodePath* pNewNode = new NodePath; if (pNewNode == NULL) { delete pOutput; return FALSE; } // initialise the path if (!pNewNode->InkPath.Initialise(pOutput->GetNumCoords(), 128)) { delete pOutput; delete pNewNode; return FALSE; } // Copy our path data into it //CALL_WITH_FAIL(!pNewNode->InkPath.CopyPathDataFrom(pOutput), pUndoOp, Success) if (!pNewNode->InkPath.CopyPathDataFrom(pOutput)) { delete pOutput; delete pNewNode; return FALSE; } // don't need that path anymore delete pOutput; pOutput = NULL; return pNewNode; }

virtual BOOL PathProcessorStroke::IsAPathProcessorStroke (   )  [inline, virtual]

Reimplemented from PathProcessor. Definition at line 162 of file ppstroke.h. {return TRUE;}

BOOL PathProcessorStroke::IsDifferent (  PathProcessorStroke *  pOther  )  [virtual]

Equality operator. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 8/1/97 Parameters: pOther  - The other PathProcessorStroke [INPUTS] Returns: TRUE if they're considered different, FALSE if they are equivalent Notes: The base class implementation compares the runtime classes of the 2 objects to see if they are different classes. If they are the same class, it assumes they're cnsidered equal - derived classes should override this behaviour if further comparisons are necessary. Reimplemented in PathProcessorStrokeAirbrush, and PathProcessorStrokeVector. Definition at line 550 of file ppstroke.cpp. { ERROR3IF(pOther == NULL, "Illegal NULL param"); if (GetRuntimeClass() != pOther->GetRuntimeClass()) return(TRUE); // Assume that we're the same, as the base class is very simple return(FALSE); }

virtual BOOL PathProcessorStroke::NeedsTransparency (  void   )  const [inline, virtual]

Reimplemented from PathProcessor. Reimplemented in PathProcessorStrokeAirbrush, and PathProcessorStrokeVector. Definition at line 155 of file ppstroke.h. {return FALSE;};

TrapsList * PathProcessorStroke::PrepareTrapsForStroke (  Path *  pPath, RenderRegion *  pRender, INT32  LineWidth )  [protected]

Precalculation function to be used in tandem with CreateVarWidthStroke(). If you want to create several strokes along the same path, then precalculating the trapezoids will give a large performance improvement. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 31/12/96 (split into new function, 6/2/97) Parameters: pPath  - The source path to be stroked [INPUTS] pRender - The render region it will be drawn to LineWidth - The maximum width of all strokes you intend to render with the resulting TrapsList. Normally this is the current line width from the output RenderRegion. Returns: NULL if it failed, else a pointer to a new TrapsList object (which the caller must delete). Call this with the width of the largest stroke you intend to render, and then render all strokes using the provided trapezoids. See also: PathProcessorStroke::CreateVarWidthStroke Definition at line 662 of file ppstroke.cpp. { LineCapType LineCap = LineCapButt; JointType JoinStyle = RoundJoin; // BLOCK { // --- Get the current line cap style from the render region StartCapAttribute *pCapAttr = (StartCapAttribute *) pRender->GetCurrentAttribute(ATTR_STARTCAP); if (pCapAttr != NULL) LineCap = pCapAttr->StartCap; // --- Get the current line join style from the render region JoinTypeAttribute *pJoinAttr = (JoinTypeAttribute *) pRender->GetCurrentAttribute(ATTR_JOINTYPE); if (pJoinAttr != NULL) JoinStyle = pJoinAttr->JoinType; } ProcessPathToTrapezoids GenerateTraps(64); TrapsList *pTrapezoids = new TrapsList; if (pTrapezoids != NULL && GenerateTraps.Init(pPath, pTrapezoids)) { // Flags are: Flatten, QuantiseLines, QuantiseAll ProcessFlags PFlags(TRUE, FALSE, FALSE); if (!GenerateTraps.Process(PFlags, TrapTravel_Parametric, JoinStyle)) { delete pTrapezoids; pTrapezoids = NULL; } } return pTrapezoids; }

void PathProcessorStroke::ProcessPath (  Path *  pPath, RenderRegion *  pRender, PathShape  ShapePath = PATHSHAPE_PATH )  [virtual]

Called by the RenderRegion to apply the path processing operation to the given path. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 31/12/96 The PathProcessorStroke class changes the stroking (only) of paths passed into it. Notes: * When rendering a path, always pass in your 'this' pointer to RenderRegion::DrawPath, so that you don't start an infinite recursion! To stop rendering of the path, simply return without calling the RR To render this path unchanged, simply call directly back to the RR: pRender->DrawPath(pPath, this); Only affect the fill of this path if pPath->IsFilled Only affect the stroke of this path if pPath->IsStroked If converting a path into a "filled path" for stroking, the output path should be rendered with IsStroked=FALSE or it'll get a line around the outside! Implements PathProcessor. Reimplemented in PathProcessorStrokeAirbrush, and PathProcessorStrokeVector. Definition at line 212 of file ppstroke.cpp. { TRACEUSER( "Diccon", _T("Rendering stroke\n")); ERROR3IF(pPath == NULL || pRender == NULL, "Illegal NULL Params"); // --- If the provided path is not stroked, then we'll just pass it straight through // We also don't touch it if we're doing EOR rendering if (!pPath->IsStroked || pRender->DrawingMode != DM_COPYPEN) { pRender->DrawPath(pPath, this, ShapePath); return; } // --- If the quality is set low, strokes are just rendered as centrelines // BLOCK { QualityAttribute *pQuality = (QualityAttribute *) pRender->GetCurrentAttribute(ATTR_QUALITY); if (pQuality != NULL && pQuality->QualityValue.GetLineQuality() != Quality::FullLine) { pRender->DrawPath(pPath, this, ShapePath); return; } } // --- If the attribute which created us is not the current StrokeType attribute, then // we have been overridden by a different stroke type, so we do nothing. // BLOCK { StrokeTypeAttrValue *pTypeAttr = (StrokeTypeAttrValue *) pRender->GetCurrentAttribute(ATTR_STROKETYPE); if (pTypeAttr != NULL && pTypeAttr != GetParentAttr()) { pRender->DrawPath(pPath, this); return; } } // --- We don't expect the input path to be stroked AND filled on entry ERROR3IF(pPath->IsFilled, "PathProcessor expected RenderRegion to handle IsFilled case"); // --- Get the current line width, cap style, and join style from the render region // In case of failure, we initialise with suitable defaults INT32 LineWidth = 5000; // BLOCK { LineWidthAttribute *pWidthAttr = (LineWidthAttribute *) pRender->GetCurrentAttribute(ATTR_LINEWIDTH); if (pWidthAttr != NULL) LineWidth = pWidthAttr->LineWidth; } // --- Create a stroke outline by calling our helper function // (ChrisG 4/11/00) - Use smoothed paths with AIExport. This is only done for the export, as the smooth // path creation function is about five times slower than the non-smoothed one. Path * pOutput = NULL; if (pRender->IsKindOf (CC_RUNTIME_CLASS (AIEPSRenderRegion))) { pOutput = CreateSmoothVarWidthStroke(pPath, pRender, LineWidth); } else { pOutput = CreateVarWidthStroke(pPath, pRender, LineWidth); } if (pOutput == NULL) { pRender->DrawPath(pPath, this); return; } // --- Finally, render the new stroke outline path in place of the one we were given pRender->SaveContext(); // !!!!****ToDo - for now, strokes always render flat-filled with the stroke colour StrokeColourAttribute *pStrokeColour = (StrokeColourAttribute *) pRender->GetCurrentAttribute(ATTR_STROKECOLOUR); if (pStrokeColour != NULL) pRender->SetFillColour(pStrokeColour->Colour); pRender->SetWindingRule(NonZeroWinding); pRender->DrawPath(pOutput, this); pRender->RestoreContext(); // --- And clean up delete pOutput; }

BOOL PathProcessorStroke::WillChangeFillAndStrokeSeparately (  void   )  [virtual]

Called by the RenderRegion to determine if this PathProcessorStroke affects the "fill" and "stroke" portions of the path separately. (Generally speaking, only fill/stroke providers will cause these two different "bits" of a path to be rendered separately). This call is made BEFORE this Processor's ProcessPath function will be called. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 31/12/96 Returns: TRUE If the caller gets a TRUE back, the stroke and fill paths will be rendered separately. Notes: Base class implementation returns FALSE. Derived Stroke and Fill processors (such as this one) override this method to return TRUE. Reimplemented from PathProcessor. Reimplemented in PathProcessorStrokeAirbrush, and PathProcessorStrokeVector. Definition at line 171 of file ppstroke.cpp. { return(TRUE); }

---

Friends And Related Function Documentation

friend class RenderRegion [friend]

Reimplemented from PathProcessor. Reimplemented in PathProcessorStrokeAirbrush, and PathProcessorStrokeVector. Definition at line 136 of file ppstroke.h.

---

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

• Kernel/ppstroke.h (r1785/r751)
• Kernel/ppstroke.cpp (r1785/r1502)

---