NodeBlender Class Reference

A NodeBlender is the class that actually renders the blend stages of a blend object. It also generates NodePath objects when the user does a 'make shapes' on a blend. More...

#include <nodebldr.h>

Inheritance diagram for NodeBlender:

List of all members.

Public Member Functions
	NodeBlender ()
	This constructor creates a NodeBlender linked to no other with all status flags false and an uninitialized bounding rectangle. Note: Initialise() must be called before the NodeBlender is in a state in which it can be used.
	~NodeBlender ()
	Default deconstructor.
	NodeBlender (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	This constructor initialises the nodes flags and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated.
BOOL	Initialise (NodeRenderableInk *pNodeStart, NodeRenderableInk *pNodeEnd, INT32 PathIndexStart, INT32 PathIndexEnd, UndoableOperation *pUndoOp, Progress *pProgress, BOOL IgnoreEscape)
	This initialises the blender node so that it is in a state in which it can blend the two nodes together.
void	Deinit (BOOL bNodesMayBeChanged=FALSE)
	This deinits the node, setting its internal Initialised flag to FALSE, and deleting any memory that is created during initialisation. It's like a combination of the constructor and destructor, leaving it in a state similar to defualt construction. The state is such that a call to Reinit() can exactly recreate the blender node. Used when hiding NodeBlenders to free up some memory.
BOOL	Reinit (NodeRenderableInk *pInkNodeStart=NULL, NodeRenderableInk *pInkNodeEnd=NULL, BOOL ProgressBar=TRUE)
	This will try and reinitialise the blender by using either the relative reference values ObjIndexStart and ObjIndexEnd (if input params are NULL) or the nodes provided.
NodeRenderableInk *	GetNodeStart ()
NodeRenderableInk *	GetNodeEnd ()
virtual Node *	SimpleCopy ()
	Makes a copy of all the data in the node.
virtual DocRect	GetBoundingRect (BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE)
	if the bounding rect is valid it is returned, if not, it is recalculated and then returned.
virtual DocRect	GetBlobBoundingRect ()
	At the moment, blender nodes don't have any blobs, so just the standard bounding box is returned.
DocRect	GetUnionBlendedBounds (DocRect &BoundsStart, DocRect &BoundsEnd)
	Finds the blended bounds that lies at point BlendRatio and tests for intersection. Takes into account the path the blend is following, if it has one.
virtual void	Render (RenderRegion *pRender)
	Will render the blended steps of this blender node.
virtual void	RenderEorDrag (RenderRegion *)
	Renders a version of the blender node for EORed dragging of blends.
virtual void	RenderBlendBlobs (RenderRegion *pRender, BOOL RenderStart, BOOL RenderEnd)
	Renders the blobs of the blend paths associated with the given blender NOTE: This only renders blobs if there's only one blend path in both the start and the end of the blend.
virtual void	PreExportRender (RenderRegion *pRender)
	Called before this node or any of its children have been rendered to the export region. This outputs the "start blender" command. Supports ArtWorks EPS and Camelot EPS.
virtual BOOL	ExportRender (RenderRegion *pRender)
	Called after this node and all of its children have been rendered to the export region. This outputs the "end blender" command. Supports ArtWorks EPS and Camelot EPS.
BOOL	IsArtWorksEPSCompatible ()
	A blender is AW EPS compatible if ALL the following conditions are TRUE: 1) This node is between two path nodes. 2) The blender is blending the two path nodes it lies between 3) The two path nodes contain the same number of sub paths.
BOOL	IsComplex ()
	The blender is "complex" as far as AW EPS is concerned, if either the start path or the end path of the blend has more that one sub-path.
INT32	GetAWStartPathIndex ()
	This converts PathIndexStart into an index AW understands (compatible with RISCOS path format).
INT32	GetAWEndPathIndex ()
	This converts PathIndexEnd into an index AW understands (compatible with RISCOS path format).
INT32	GetAWPathIndex (BlendRef *pRef, INT32 PathIndex)
	This converts the index into an index AW understands (compatible with RISCOS path format).
virtual void	Transform (TransformBase &)
	Transforms all the paths attached to this blender node.
BOOL	IsPointOverBlob (DocCoord *pPointerPos, BlendPath **ppBlendPath, INT32 *pIndex, BOOL *pAStart)
	This sees if the point given lies on a selected blob. If a match is found, the ptr to the blend path and index to blob element is returned. Also, if found,*pAStart = TRUE if it belongs to the start path, FALSE for the end path.
BOOL	Remap (DocCoord PosStart, DocCoord PosEnd, DocCoord *pInvPosStart, DocCoord *pInvPosEnd)
	If this blender manages to remap a pair of blend paths, then this will return TRUE.
BOOL	ConvertAWPathIndexesToCamelot (INT32 *pPathIndexStart, INT32 *pPathIndexEnd)
	This converts ArtWorks path indexes to a Camelot path indexes, for this blender. An AW index is just an index to the nth end point, so all that's done is the nth end point in the path is found.
BOOL	FindPathEndPoint (Node *pNodePath, INT32 *pIndex)
	This finds the N'th end point in the given NodePath. This is used to convert AW end point indexes into Camelot end point indexes. If *pIndex <=0 on entry, *pIndex = 0 on exit.
NodeRenderableInk *	FindObjIndexedNode (INT32 ObjIndex)
	This scans the children of the parent of this blender, until it finds the ObjIndex'th NodeRenderableInk. I.e. if ObjIndex == 0, it returns the first child NodeRenderableInk. if ObjIndex == 1, returns the second child NodeRenderableInk. Fails if: ObjIndex >= number of children the parent has The node found is not a NodeRenderableInk or is a NodeBlender.
virtual BOOL	CanSelectAsSimple ()
	Ask a node whether or not it's prepared to become selected when it's clicked on. This function is called in the FindSimple routines when they have just detected a "hit" on a node. This virtual base function is overridden here to indicate that the NodeBlender object is definitely NOT prepared to become selected!
NodeBlend *	GetNodeBlend ()
	Central NodeBlend "getter".
BOOL	IsOneToOne ()
	Gets the one-to-one blend mapping state for this blender, by asking the parent blend node.
BOOL	IsNotAntialiased ()
	Gets the NotAntialiased state for this blender, by asking the parent blend node.
virtual UINT32	GetNodeSize () const
	For finding the size of the node.
virtual BOOL	CanBecomeA (BecomeA *pBecomeA)
	This function is used by the convert to shapes operation. It determines if the node or any of its children can convert themselves into an InkClass object.
virtual BOOL	DoBecomeA (BecomeA *pBecomeA)
	Transforms the object into another type of object.
void	GetDebugDetails (StringBase *Str)
	Displays debugging info of the tree For obtaining debug information about the Node.
void	GetDebugDetails (StringBase *Str, BlendRef *pBlendRef)
	For obtaining debug information about the blend reference.
virtual BOOL	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	Allows the Node to respond to clicks by selecting its blobs or starting drags etc. This functions should be overridden in the all the NodeRenderableInk classes so that this version never gets called. Eg the NodePath class might claim the click if it happened over one of its unselected blobs.
virtual BOOL	HidingNode ()
	Called whenever the node gets hidden. It calls the Deinit() member function.
virtual BOOL	ShowingNode ()
	Called whenever the node gets shown after it's been hidden. It calls the Reinit() member function.
virtual BOOL	Snap (DocCoord *pDocCoord)
	Snaps to given coord to the nearest point on the blender node. Just returns FALSE currently.
virtual BOOL	Snap (DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Snaps the given rect to the nearest CMapPtrToPtr::iterator on the grid, preserving its width and height. The coords of the rect used for the snapping are determined by the PrevCoord and CurCoord coords supplied. This is done to allow the user to control how a selection rectangle is snapped to the grid by the direction of his/her last mouse movement. To force the bottom left hand corner of the rect to be snapped, supply PrevCoord=(0,0) and CurCoord(-1,-1).
UINT32	GetNumBlendSteps ()
	Gets the number of blend steps for this blender, by asking the parent blend node for its num blend steps.
ColourBlendType	GetColourBlendType ()
	Gets the way colours are blended by asking the parent blend node.
void	SetPathIndexStart (INT32 Index)
void	SetPathIndexEnd (INT32 Index)
INT32	GetPathIndexStart ()
INT32	GetPathIndexEnd ()
void	SetObjIndexStart (INT32 ObjIndex)
void	SetObjIndexEnd (INT32 ObjIndex)
INT32	GetObjIndexStart ()
INT32	GetObjIndexEnd ()
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes the blender record to the filter.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
virtual BOOL	WriteBeginChildRecordsWeb (BaseCamelotFilter *pFilter)
	Same as the Native version.
virtual BOOL	WriteBeginChildRecordsNative (BaseCamelotFilter *pFilter)
	Begins the child record sequence for the blender.
virtual BOOL	WriteEndChildRecordsWeb (BaseCamelotFilter *pFilter)
	Same as the Native version.
virtual BOOL	WriteEndChildRecordsNative (BaseCamelotFilter *pFilter)
	Ends the child record sequence for the blend.
virtual BOOL	WriteBoundsRecord (BaseCamelotFilter *pFilter)
	Write out a record containing the bounds of this object.
BOOL	GetPointOnNodeBlendPath (double BlendRatio, DocCoord *pPoint, double *pAngle)
	Access function to make it easy to get the correct point in the path for this NodeBlender with the given blend ratio.
BOOL	GetPointFromDistance (double Distance, DocCoord *pPoint, double *pAngle)
	Access function to make it easy to get the correct point in the path for this NodeBlender with the given distance along the path.
NodeBlendPath *	GetNodeBlendPath ()
	It gets the node blend path from its parent.
Trans2DMatrix *	GetRotateMatrix (NodeRenderableBounded *pNode, double Angle)
	Function that returns a matrix that will rotate around the centre of the bounds of the given node.
double	GetProportionOfPathDistStart ()
double	GetProportionOfPathDistEnd ()
void	SetProportionOfPathDistStart (double p)
void	SetProportionOfPathDistEnd (double p)
double	GetAngleStart ()
double	GetAngleEnd ()
void	SetAngleStart (double Angle)
void	SetAngleEnd (double Angle)
void	RotateBounds (DocRect &Bounds, double Angle)
	The bounds are updated to contain the rotated version.
double	GetLinearDistance ()
	to get the distance between the start and end nodes of the blender when the blend is not on a curve. Note that it will return an incorrect value if the blend is on a curve.
BOOL	GetBlendDirection (double *Gradient)
	To get a vector of the direction of a linear blend.
BOOL	GetBlendObjectCentres (DocCoord *FirstCentre, DocCoord *LastCentre)
	To get the centres of the objects that are blended between.
BOOL	IsTangential ()
	See above.
void	SetUninitialised ()
void	SetBlendedOnCurve (BOOL value)
BOOL	IsBlendedOnCurve ()
void	SetReversed (BOOL value)
BOOL	IsReversed ()
void	SetNodeBlendPathIndex (INT32 Index)
	See above.
INT32	GetNodeBlendPathIndex ()
	See above.
BOOL	ReverseEnds ()
	reverses the blend so that the start node becomes the end node and vice versa
void	UpdateBlendStartAngles (Trans2DMatrix &trans)
	Updates a blend on curves start angles after we have rotated the blend.
virtual INT32	EstimateNodeComplexity (OpParam *details)
	This function estimates a complexity value for the node. The complexity value is based upon the total length of all paths in the node.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
Static Public Member Functions
static BOOL	ConvertLineToShape (Path *pPath, Path *pShapePath)
	This takes a line and creates a shape out of it, placing the shape in pShapePath.
static BOOL	ProcessBlendedPath (DocCoord *pCoords, PathVerb *pVerbs, PathFlags *pFlags, UINT32 Len, BOOL Filled)
	This does any processing necessary on the path generated by GBlend. The three arrays can be used to generate renderable paths, and also legal paths that can be used to create NodePath objects on the tree.
static void	SetPathFlags (PathVerb *pVerbs, PathFlags *pFlags, UINT32 Len)
	This generates a legal path flags array based on the given verbs. All it does is set the end point flags correctly, leaving all other flags FALSE.
static void	ReversePath (DocCoord *Coords, PathVerb *Verbs, UINT32 Len)
	This will reverse the path definition given in the two arrays.
Private Member Functions
	CC_DECLARE_DYNCREATE (NodeBlender)
void	ResetVars ()
	Resets all the member vars to default values. Should only be called by NodeBlender constructors.
void	CopyNodeContents (NodeBlender *NodeCopy)
	Copies the data in this node to pCopyOfNode by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected.
BOOL	InitBlendRef (NodeRenderableInk *pNode, BlendRef **ppRef, INT32 Index, UndoableOperation *pUndoOp, Progress *pProgress, BOOL IgnoreEscape, Trans2DMatrix *pMatrix)
	This creates and initialises a blend reference.
BOOL	CalcObjIndex (NodeRenderableInk *pInkNode, INT32 *pObjIndex)
	Firstly, this will check that this node and pInkNode have the same NodeBlend parent node. If all's well, it will scan the children of the NodeBlend, starting with the first child, counting until it comes to pInkNode. If pInkNode is the first child, *pObjIndex == 0. If the second child, *pObjIndex == 1, etc.
void	CheckFullyInitialised ()
	This will set the object's Initialise member to TRUE if it is fully initialised, i.e. pRefStart & pRefEnd != NULL, and ObjIndexStart and ObjIndexEnd and >= 0.
BOOL	BlendPaths (BlendPath *pBlendPathStart, BlendPath *pBlendPathEnd, double BlendRatio)
	Blends two BlendPath objects by the amount specified in BlendRatio.
void	CreateBlends (RenderRegion *pRender, HandleBecomeA *pHandleBecomeA)
	Will generate the blended steps of this blender node. If pRender != NULL, it will render each blend step to it. if pHandleBecomeA != NULL, it will pass each blend step to pHandleBecomeA->PassBack() as it's generated.
Matrix	MakeMatrix (BlendPath *pBlendPathStart, BlendPath *pBlendPathEnd, double BlendRatio)
	Makes the matrix for the transfrom that should be applied to blend paths and attributes.
BOOL	CheckBoundsIntersect (RenderRegion *pRender, DocRect &BoundsStart, DocRect &BoundsEnd, double BlendRatio)
	Finds the blended bounds that lies at point BlendRatio and tests for intersection.
DocRect	BlendBounds (DocRect &BoundsStart, DocRect &BoundsEnd, double BlendRatio, BOOL UseBlendPath)
	Finds the blended bounds that lies at point BlendRatio and tests for intersection. Takes into account the path the blend is following, if it has one.
BOOL	BlendAttributes (RenderRegion *pRender, BlendPath *pBlendPathStart, BlendPath *pBlendPathEnd, CCAttrMap *pBlendedAttribMap, double BlendRatio, double objectRatio, BOOL objectProfileProcessing)
	Blends the attributes of the two BlendPath objects by the amount specified in BlendRatio.
void	RenderAttributes (RenderRegion *pRender, CCAttrMap *pAttribMap)
	Renders the attributes to the given render region.
BOOL	PreBlend ()
	This should be called just before blending occurs. At the moment it does the following - Initialises stuff so you can call GetCoordArray(), GetVerbArray() and GetFlagArray().
void	PostBlend ()
	This should be called just after blending occurs. At the moment it does the following - Releases memory allocated for the temp path arrays.
BOOL	ReallocTempBuffers (UINT32 Size)
	Allocates memory for the temp path arrays, and sets the size var to 0 You can use calls to GetCoordArray(), GetVerbArray() and GetFlagArray() to get the alloced arrays.
void	DeallocTempBuffers ()
	Releases memory allocated for the temp path arrays, and sets the size var to 0.
DocCoord *	GetCoordArray (UINT32 MinSize)
	Used to get an array you can write to.
PathVerb *	GetVerbArray (UINT32 MinSize)
	Used to get an array you can write to.
PathFlags *	GetFlagArray (UINT32 MinSize)
	Used to get an array you can write to.
UINT32 *	GetGBlendBuff (UINT32 MinSize)
	Used to get a buffer you can write to.
double	MapObjectBlendRatio (double BlendRatio)
	Function that works out what blend ratio to use when creating a blended bath. Allows non-linear processing of blends.
double	MapAttrBlendRatio (double BlendRatio)
	Function that works out what blend ratio to use when blending attributes Allows non-linear processing of blend attributes.
double	MapPositionBlendRatio (double BlendRatio)
	Function that works out what blend ratio to use when CMapPtrToPtr::iteratoring the blended shapes Allows non-linear processing of blend shape CMapPtrToPtr::iteratoring.
double	GetObjectRatio ()
	returns the current mapping of objects
double	GetInvertedAttributeRatio ()
	Function that inverts the current attribute profile and returns the mapped value This is needed to fix the problem with profiles and transparencies and other fills that use control points.
BOOL	CallBeginBlendStep (BlendNodeParam *pParam, BOOL *usingSumAllPathsPathProcessor)
	Calls all begin blend step functions on appropriate nodes.
BOOL	CallEndBlendStep (BlendNodeParam *pParam)
	Calls all end blend step functions on appropriate nodes.
Private Attributes
BlendRef *	m_pRefStart
BlendRef *	m_pRefEnd
NodeRenderableInk *	m_pNodeStart
NodeRenderableInk *	m_pNodeEnd
INT32	m_ObjIndexStart
INT32	m_ObjIndexEnd
BOOL	m_Initialised
UINT32	m_BlendStep
UINT32	m_TempArraySize
DocCoord *	m_pTempCoords
PathVerb *	m_pTempVerbs
PathFlags *	m_pTempFlags
UINT32	m_GBlendBuffSize
UINT32 *	m_pGBlendBuff
UINT32	m_ArrayLength
INT32	m_PathIndexStart
INT32	m_PathIndexEnd
double	m_ProportionOfPathDistStart
double	m_ProportionOfPathDistEnd
double	m_AngleStart
double	m_AngleEnd
BOOL	m_BlendedOnCurve
BOOL	m_Reversed
INT32	m_NodeBlendPathIndex

---

Detailed Description

A NodeBlender is the class that actually renders the blend stages of a blend object. It also generates NodePath objects when the user does a 'make shapes' on a blend.

Author:

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

Date:

11/10/94

Definition at line 360 of file nodebldr.h.

---

Constructor & Destructor Documentation

NodeBlender::NodeBlender (   )

This constructor creates a NodeBlender linked to no other with all status flags false and an uninitialized bounding rectangle. Note: Initialise() must be called before the NodeBlender is in a state in which it can be used. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 See also: Initialise() Definition at line 317 of file nodebldr.cpp. : NodeRenderableInk() { ResetVars(); }

NodeBlender::~NodeBlender (   )

Default deconstructor. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Definition at line 332 of file nodebldr.cpp. { // Call PostBlend() in case we're trying to be deleted in the middle of rendering. PostBlend(); // Delete the two blend references DELPTR(m_pRefStart); DELPTR(m_pRefEnd); }

NodeBlender::NodeBlender (  Node *  ContextNode, AttachNodeDirection  Direction, BOOL  Locked = FALSE, BOOL  Mangled = FALSE, BOOL  Marked = FALSE, BOOL  Selected = FALSE )

This constructor initialises the nodes flags and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] MonoOn Direction: MonoOff Specifies the direction in which the node is to be attached to the ContextNode. The values this variable can take are as follows: PREV : Attach node as a previous sibling of the context node NEXT : Attach node as a next sibling of the context node FIRSTCHILD: Attach node as the first child of the context node LASTCHILD : Attach node as a last child of the context node BoundingRect: Bounding rectangle The remaining inputs specify the status of the node: Locked: Is node locked ? Mangled: Is node mangled ? Marked: Is node marked ? Selected: Is node selected ? Note: Initialise() must be called before the NodeBlender is in a state in which it can be used. See also: Initialise() Returns: Errors: An assertion error will occur if ContextNode is NULL Definition at line 289 of file nodebldr.cpp. :NodeRenderableInk(ContextNode, Direction, Locked, Mangled, Marked, Selected ) { ResetVars(); }

---

Member Function Documentation

BOOL NodeBlender::BlendAttributes (  RenderRegion *  pRender, BlendPath *  pBlendPathStart, BlendPath *  pBlendPathEnd, CCAttrMap *  pBlendedAttrMap, double  BlendRatio, double  objectRatio, BOOL  objectProfileProcessing )  [private]

Blends the attributes of the two BlendPath objects by the amount specified in BlendRatio. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/94 Parameters: pRender  = The Render Region into which we are rendering the blend, or [INPUTS] NULL if not rendering (i.e. doing a make shapes) pBlendPathStart = ptr to blend path to blend from pBlendPathEnd = ptr to blend path to blend to pBlendedAttrMap = ptr to map to store the blended attributes in BlendRatio = amount to blend by (0.0 <= BlendPath <= 1.0) objectRatio = the corresponding object ratio (CGS: allows us to blend object stuff with attributes) objectProfileProcessing = whether we are allowed to blend object (i.e. CMapPtrToPtr::iterator) data of attributes -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise See also: - Definition at line 1661 of file nodebldr.cpp. { // Check entry params BOOL ok = (pBlendPathStart != NULL && pBlendPathEnd != NULL && pBlendedAttrMap != NULL); ERROR3IF(!ok,"One or more NULL entry params"); if (!ok) return FALSE; // Find the attributes that are applied to the blend paths CCAttrMap* pAttrMapStart = m_pRefStart->FindAppliedAttributes(pBlendPathStart); CCAttrMap* pAttrMapEnd = m_pRefEnd ->FindAppliedAttributes(pBlendPathEnd); // If either are NULL, return FALSE if (pAttrMapStart == NULL || pAttrMapEnd == NULL) return FALSE; //#ifdef _DEBUG // AttrTranspFillGeometry* pLineWidth = NULL; // pMap->Lookup((void *)CC_RUNTIME_CLASS(AttrLineWidth), (void *&)pIndent); // //UINT32* pCol = pLineWidth->GetStartTransp (); // // pAttrMapEnd->Lookup((void*) CC_RUNTIME_CLASS(AttrTranspFillGeometry),(void* &)pLineWidth); // //ol = pLineWidth->GetStartTransp (); //#endif pAttrMapStart->attrMapCreator = pBlendPathStart->GetBlendNode (); pAttrMapEnd->attrMapCreator = pBlendPathEnd->GetBlendNode (); if (GetNodeBlendPath() != NULL) { Trans2DMatrix* pRotateStart = GetRotateMatrix(m_pNodeStart,360.0 - m_AngleStart); Trans2DMatrix* pRotateEnd = GetRotateMatrix(m_pNodeEnd ,360.0 - m_AngleEnd ); if (pRotateStart) pAttrMapStart->Transform(*pRotateStart); if (pRotateEnd) pAttrMapEnd ->Transform(*pRotateEnd); DELPTR(pRotateStart); DELPTR(pRotateEnd); } // Diccon 24/5/2000 Brush attributes need to know about stroke colour, so we need to // keep track of both as we find them AttrBrushType* pBlendedAttrBrush = NULL; AttrStrokeColour* pBlendedStrokeColour = NULL;; // These vars are used as params to the CCAttrMap funcs CCRuntimeClass* pTypeStart; void* pValStart; void* pValEnd; double OldBlendRatio = BlendRatio; // Process each attribute in turn CMapPtrToPtr::iterator PosStart = pAttrMapStart->GetStartPosition(); while ( PosStart != pAttrMapStart->GetEndPosition() ) { // Get a ptr to the attr at CMapPtrToPtr::iterator PosStart in the start node's attr map pAttrMapStart->GetNextAssoc(PosStart,pTypeStart,pValStart); NodeAttribute* pNodeAttrStart = (NodeAttribute *)pValStart; BlendRatio = OldBlendRatio; // Diccon 10/99 When using non-linear profiles for the objects those attributes // that make use of control points were not being profiled, making the objects look strange. // to avoid this those attributes now share the same profiles as the objects. if (pNodeAttrStart->IsAGradFill()) { if (!((AttrFillGeometry*)pNodeAttrStart)->IsAColourFill()) { BlendRatio = GetObjectRatio(); } else { BlendRatio = GetInvertedAttributeRatio(); } } if (pNodeAttrStart->IsAFlatFill() || (pNodeAttrStart->GetRuntimeClass() == CC_RUNTIME_CLASS(AttrLineWidth))) { BlendRatio = GetInvertedAttributeRatio(); } // Get a blended attribute NodeAttribute* pBlendedNodeAttr = NULL; // Find an attr of the same type in the end object's attr list, // and blend the two attrs together if (pAttrMapEnd->Lookup(pTypeStart,pValEnd)) { // We've found a matching end attr, so try to blend it with the start attr // Set up the param object to pass to the start attr's blend method BlendAttrParam BlendParam; // Initialise the BlendParam with the end attr and blend ratio if (BlendParam.Init(pRender, (NodeAttribute *)pValEnd,BlendRatio,objectRatio,objectProfileProcessing,GetColourBlendType(), pAttrMapStart, pAttrMapEnd) ) { // Successfully initialised, so now try blending the attributes if (pNodeAttrStart->Blend(&BlendParam)) { // Attrs successfully blended, now get a ptr to the new attr. // Once we get the blended attr ptr, it belongs to us, so we have // to delete it when it is not needed pBlendedNodeAttr = BlendParam.GetBlendedAttr(); } else { #ifdef _DEBUG void *tmp = NULL; ENSURE(!pBlendedAttrMap->Lookup(pNodeAttrStart->GetRuntimeClass(),tmp),"Didn't blend attr, but there's still one in pBlendedAttrMap"); #endif } } } // If we have a blended attr, pBlendedNodeAttr != NULL if (pBlendedNodeAttr != NULL) { // Get the type of the blended attr CCRuntimeClass* pTypeBlend = pBlendedNodeAttr->GetAttributeType(); void* pValBlend; // If we already have an attr in the blended attr map of the same type, // remove it and delete it, before inserting a new attr of this type if (pBlendedAttrMap->Lookup(pTypeBlend,pValBlend)) { if (pValBlend != NULL) { pBlendedAttrMap->RemoveKey(pTypeBlend); delete (NodeAttribute*)pValBlend; } } // add it to the blend map pBlendedAttrMap->SetAt(pTypeBlend,pBlendedNodeAttr); // find out if we are a stroke colour or a brush if (pBlendedNodeAttr->IsAStrokeColour()) pBlendedStrokeColour = (AttrStrokeColour*)pBlendedNodeAttr; if (pBlendedNodeAttr->IsABrush()) pBlendedAttrBrush = (AttrBrushType*)pBlendedNodeAttr; } } if (GetNodeBlendPath() != NULL) { Trans2DMatrix* pRotateStart = GetRotateMatrix(m_pNodeStart,m_AngleStart); Trans2DMatrix* pRotateEnd = GetRotateMatrix(m_pNodeEnd ,m_AngleEnd ); if (pRotateStart) pAttrMapStart->Transform(*pRotateStart); if (pRotateEnd) pAttrMapEnd ->Transform(*pRotateEnd); DELPTR(pRotateStart); DELPTR(pRotateEnd); } // if we got a stroke colour and a brush then tell the brush what the stroke colour is if (pBlendedAttrBrush != NULL && pBlendedStrokeColour != NULL) pBlendedAttrBrush->SetBlendedStrokeColour(&(pBlendedStrokeColour->Value.Colour)); return TRUE; }

DocRect NodeBlender::BlendBounds (  DocRect &  BoundsStart, DocRect &  BoundsEnd, double  BlendRatio, BOOL  UseBlendPath )  [private]

Finds the blended bounds that lies at point BlendRatio and tests for intersection. Takes into account the path the blend is following, if it has one. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/99 Parameters: BoundsStart  = the blob bounds of start object [INPUTS] BoundsEnd = the blob bounds of end object BlendRatio = current blend point (between 0.0 and 1.0) -  [OUTPUTS] Returns: The blended bounds. See also: - Definition at line 1434 of file nodebldr.cpp. { DocRect BlendedBounds,OldBoundsStart,OldBoundsEnd; if (UseBlendPath) { OldBoundsStart = BoundsStart; OldBoundsEnd = BoundsEnd; RotateBounds(BoundsStart,-m_AngleStart); RotateBounds(BoundsEnd,-m_AngleEnd); } BlendedBounds.lo.x = INT32(BoundsStart.lo.x + ((BoundsEnd.lo.x-BoundsStart.lo.x)*BlendRatio)); BlendedBounds.lo.y = INT32(BoundsStart.lo.y + ((BoundsEnd.lo.y-BoundsStart.lo.y)*BlendRatio)); BlendedBounds.hi.x = INT32(BoundsStart.hi.x + ((BoundsEnd.hi.x-BoundsStart.hi.x)*BlendRatio)); BlendedBounds.hi.y = INT32(BoundsStart.hi.y + ((BoundsEnd.hi.y-BoundsStart.hi.y)*BlendRatio)); if (UseBlendPath) { DocCoord PointOnPath; double Angle = 0.0; if (GetPointOnNodeBlendPath(BlendRatio,&PointOnPath,&Angle)) { DocCoord BBCentre = BlendedBounds.Centre(); BlendedBounds.Translate(PointOnPath.x-BBCentre.x,PointOnPath.y-BBCentre.y); RotateBounds(BlendedBounds,Angle); } } if (UseBlendPath) { BoundsStart = OldBoundsStart; BoundsEnd = OldBoundsEnd; } return BlendedBounds; }

BOOL NodeBlender::BlendPaths (  BlendPath *  pBlendPathStart, BlendPath *  pBlendPathEnd, double  BlendRatio )  [private]

Blends two BlendPath objects by the amount specified in BlendRatio. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/10/94 Parameters: pBlendPathStart  = ptr to blend path to blend from [INPUTS] pBlendPathEnd = ptr to blend path to blend to BlendRatio = amount to blend by (0.0 <= BlendPath <= 1.0) The  blended path is stored in three arrays: the coords, the verbs, and the flags. [OUTPUTS] The arrays are: pTempCoords pTempVerbs pTempFlags ArrayLength = the length of all three arrays This allows the caller to decide what to do with the blended path in a very flexible way. Returns: TRUE if successful, FALSE otherwise See also: - Definition at line 1850 of file nodebldr.cpp. { // Check entry params BOOL ok = (pBlendPathStart != NULL && pBlendPathEnd != NULL); if (ok) ok = (pBlendPathStart->GetBlendNode() != NULL && pBlendPathEnd->GetBlendNode() != NULL); ERROR3IF(!ok,"One or more NULL entry params"); if (!ok) return FALSE; // Get the types of the two paths PathTypeEnum PathTypeStart = pBlendPathStart->GetPathType(); PathTypeEnum PathTypeEnd = pBlendPathEnd ->GetPathType(); // The blended path will be closed if either of the paths is a shape BOOL Closed = (PathTypeStart == PATHTYPE_SHAPE) || (PathTypeEnd == PATHTYPE_SHAPE); Path * pPathStart = NULL; // Find the paths associated with the start and end blend paths if (pBlendPathStart->GetBlendNode()->IsNodePath()) { pPathStart = &(((NodePath *)pBlendPathStart->GetBlendNode())->InkPath); } else { pPathStart = &(((NodePath *)((NodeCompound *)pBlendPathStart->GetBlendNode())->GetNodeToBlend())->InkPath); } Path * pPathEnd = NULL; if (pBlendPathEnd->GetBlendNode()->IsNodePath()) { pPathEnd = &(((NodePath *)pBlendPathEnd->GetBlendNode())->InkPath); } else { pPathEnd = &(((NodePath *)((NodeCompound *)pBlendPathEnd->GetBlendNode())->GetNodeToBlend())->InkPath); } // Calculate how large the arrays have to be to store the blended path definition INT32 DestPathSize = ((pPathStart->GetNumCoords()+pPathEnd->GetNumCoords())*3)+500; // Get some arrays used to hold the blended path data, and error if any are NULL DocCoord* pDestCoords = GetCoordArray(DestPathSize); PathVerb* pDestVerbs = GetVerbArray(DestPathSize); PathFlags* pDestFlags = GetFlagArray(DestPathSize); UINT32* pBuff = GetGBlendBuff(DestPathSize); if (pDestCoords == NULL || pDestVerbs == NULL || pDestFlags == NULL || pBuff == NULL) return FALSE; // This section copes with the case when blending a line with a shape. // In this case we need to get a temp path the is actually a shape version of the line. // The line is simply reversed back onto itself to form a shape that would look identical to the // line if rendered. This allows the line to appear to open up to the shape when blended. Path Shape; if (PathTypeStart != PathTypeEnd) { BOOL ok = FALSE; if (!Shape.Initialise()) return FALSE; // if going from a line to a shape, convert the start path to a shape if (PathTypeStart == PATHTYPE_LINE && PathTypeEnd == PATHTYPE_SHAPE) { ok = NodeBlender::ConvertLineToShape(pPathStart,&Shape); pPathStart = &Shape; } // if going from a shape to a line, convert the end path to a shape if (PathTypeStart == PATHTYPE_SHAPE && PathTypeEnd == PATHTYPE_LINE) { ok = NodeBlender::ConvertLineToShape(pPathEnd,&Shape); pPathEnd = &Shape; } if (!ok) return FALSE; } // The blend should do a one-to-one mapping when the OneToOne flag is set AND both paths // have the same number of elements BOOL OneToOne = FALSE; if (IsOneToOne()) OneToOne = (pBlendPathStart->GetNumElements() == pBlendPathEnd->GetNumElements()); // Now actually blend the two paths GBlend GBlendObj; // Define the blend GBlendObj.Define( (PPOINT)pPathStart->GetCoordArray(), // Specify the start path pPathStart->GetVerbArray(), pPathStart->GetNumCoords(), (PPOINT)pPathEnd ->GetCoordArray(), // Specify the end path pPathEnd ->GetVerbArray(), pPathEnd ->GetNumCoords(), OneToOne, // The one-to-one flag FLATNESS, // Flatness pBuff, // Buffer for GBlend to use DestPathSize*sizeof(UINT32)); // The buffer size // Blend the paths m_ArrayLength = GBlendObj.Blend(BlendRatio, // The blend ratio, 0.0 < BlendRatio < 1.0 (PPOINT)pDestCoords, // Array to store blended coords pDestVerbs, // Array to store blended verbs DestPathSize); // The num elements in the two arrays // If we're blending a line to another line, we need to make sure that the blended line // is going in a direction that corresponds to the source lines. This ensures attributes // that depend on this direction (e.g. start and end arrows) look correct. // // When creating blend paths of lines, we can detect if the blend path has been reversed, // in relation to the original path, by the original mapping value. // If it's 0 it has NOT been reversed, otherwise it's been reversed. // // If the blend ratio is <=0.5, the blended path is closest to the start blend path, // so we look at the start blend path's original mapping. // // If blend ration > 0.5, look at the end blend path's original mapping. // // The (BlendRation <= 0.5) cut-off point is the same as the cut-off point used in the blending // of attributes. if (pBlendPathStart->IsLine() && pBlendPathEnd->IsLine()) { BlendPath* pBlendPath; if (BlendRatio <= 0.5) pBlendPath = pBlendPathStart; else pBlendPath = pBlendPathEnd; if (pBlendPath->GetOrigMapping() != 0) ReversePath(pDestCoords,pDestVerbs,m_ArrayLength); } // We need to do some work on the blended path if (!ProcessBlendedPath(pDestCoords,pDestVerbs,pDestFlags,m_ArrayLength,Closed)) return FALSE; return TRUE; }

BOOL NodeBlender::CalcObjIndex (  NodeRenderableInk *  pInkNode, INT32 *  pObjIndex )  [private]

Firstly, this will check that this node and pInkNode have the same NodeBlend parent node. If all's well, it will scan the children of the NodeBlend, starting with the first child, counting until it comes to pInkNode. If pInkNode is the first child, *pObjIndex == 0. If the second child, *pObjIndex == 1, etc. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: pInkNode  = ptr to a node that this blender will blend [INPUTS] pObjIndex = ptr to place to store the relative reference to this node *pObjIndex  will contain the reference if TRUE is returned, -1 if FALSE is returned [OUTPUTS] Returns: TRUE if successful, FALSE otherwise See also: - Definition at line 3188 of file nodebldr.cpp. { ERROR2IF(pInkNode == NULL,FALSE,"pInkNode is NULL"); ERROR2IF(pObjIndex == NULL,FALSE,"pObjIndex is NULL"); Node* pParent = pInkNode->FindParent(); /*if (pInkNode->IsNodeHidden ()) { ERROR3 ("Node is hidden!"); }*/ ERROR2IF(pParent == NULL,FALSE,"pInkNode has no parent"); if (!pParent->IsController ()) // CGS: we can now have compound nodes in here! { ERROR2IF(!IS_A(pParent,NodeBlend),FALSE,"pInkNode parent is not a NodeBlend"); ERROR2IF(pParent != this->FindParent(),FALSE,"pInkNode has different parent to this node"); } else { // compound might be shadowed - if it is, find the shadow, and check that its parent is the NodeBlend .... if (IS_A (pParent->FindParent (), NodeShadowController)) { pParent = pParent->FindParent ()->FindParent (); } ERROR2IF(pParent->FindParent () != this->FindParent(),FALSE,"pInkNode has different parent to this node"); } INT32 Index = 0; Node* pNode = pParent->FindFirstChild(); while (pNode != NULL && pNode != pInkNode) { if (pNode->IS_KIND_OF(NodeRenderableInk)) Index++; if (pNode->IS_KIND_OF(NodeBlendPath)) Index--; pNode = pNode->FindNext(); } if (pNode == pInkNode) *pObjIndex = Index; else *pObjIndex = -1; return (pNode == pInkNode); }

BOOL NodeBlender::CallBeginBlendStep (  BlendNodeParam *  pParam, BOOL *  usingSumAllPathsPathProcessor )  [private]

Calls all begin blend step functions on appropriate nodes. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/2000 Parameters: pParam  - the bevel node parameter to pass to all nodes [INPUTS] -  [OUTPUTS] Returns: - Definition at line 687 of file nodebldr.cpp. { if (pParam->GetRenderRegion() == NULL) { // CGS: if the RenderRegion == NULL, then we might be doing a convert to shapes // test whether or not we are if (!pParam->GetHandleBecomeA ()) { return TRUE; // er - there ain't much we can do } // else we are in a convert to editable shapes - continue } NodeRenderableInk * pCompoundStep = pParam->GetStartBlendPath()->GetBlendNode(); if (!pCompoundStep->IsCompound()) { *usingSumAllPathsPathProcessor = FALSE; return TRUE; } if (((NodeCompound *)pCompoundStep)->IsStartBlendGroupNode()) { if (!((NodeCompound *)pCompoundStep)->BeginBlendStep(pParam)) { return FALSE; } else { // we are using a path processor to do our funky stuff .... *usingSumAllPathsPathProcessor = TRUE; } } Node * pStep = pCompoundStep->FindFirstChild(); while (pStep) { if (pStep->IsCompound()) { NodeCompound * pCompound = (NodeCompound *)pStep; if (pCompound->IsStartBlendGroupNode()) { if (!pCompound->BeginBlendStep(pParam)) { return FALSE; } else { *usingSumAllPathsPathProcessor = TRUE; } } } pStep = pStep->FindNext(); } return TRUE; }

BOOL NodeBlender::CallEndBlendStep (  BlendNodeParam *  pParam  )  [private]

Calls all end blend step functions on appropriate nodes. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/2000 Parameters: pCompound  - the root of the tree to use [INPUTS] pParam - the bevel node parameter to pass to all nodes -  [OUTPUTS] Returns: - Definition at line 761 of file nodebldr.cpp. { // we need to do this bottom up if (pParam->GetRenderRegion() == NULL) { // CGS: if the RenderRegion == NULL, then we might be doing a convert to shapes // test whether or not we are (or were) if (!pParam->GetHandleBecomeA ()) { return TRUE; // er - there ain't much we can do } // else we are in a convert to editable shapes - continue } NodeRenderableInk * pCompoundStep = pParam->GetStartBlendPath()->GetBlendNode(); // View * pView = View::GetCurrent(); if (!pCompoundStep->IsCompound()) return TRUE; Node * pStep = pCompoundStep->FindFirstDepthFirst(); while (pStep && pStep != pCompoundStep) { if (pStep->IsCompound()) { NodeCompound * pCompound = (NodeCompound *)pStep; if (pCompound->IsEndBlendGroupNode()) { if (!pCompound->EndBlendStep(pParam)) { return FALSE; } } } pStep = pStep->FindNextDepthFirst(pCompoundStep); } if (((NodeCompound *)pCompoundStep)->IsEndBlendGroupNode()) { if (!((NodeCompound *)pCompoundStep)->EndBlendStep(pParam)) { return FALSE; } } return TRUE; }

BOOL NodeBlender::CanBecomeA (  BecomeA *  pBecomeA  )  [virtual]

This function is used by the convert to shapes operation. It determines if the node or any of its children can convert themselves into an InkClass object. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: InkClass,:  The class of object [INPUTS] pNumObjects = ptr to place number of objects of type pClass that will be created (Note: can be NULL). pNumObects in undefined on entry Returns: TRUE if the node, or any of its children can transmogrify themselves to become an InkClass object The number you put into pNumObjects (if it's not NULL) should exactly equal the total number of pClass objects you create. It should NOT contain any additional objects you may produce such as group objects for containing the pClass object, or attributes. Also, the entry value of *pNumObjects cannot be assumed to be 0. Reimplemented from Node. Definition at line 2746 of file nodebldr.cpp. { // The NodeBlender can become a NodePath if (pBecomeA->BAPath()) { if (pBecomeA->IsCounting()) { if (!Reinit()) return FALSE; // Check that we have a valid blender if (m_pRefStart == NULL || m_pRefEnd == NULL) return FALSE; UINT32 NumBlendSteps = GetNumBlendSteps(); // Find num blend paths in start and end, and keep hold of the MAX value // The max value is the number of individual paths created for each blend step UINT32 NumPathsInStart = m_pRefStart->GetNumBlendPaths(); UINT32 NumPathsInEnd = m_pRefEnd ->GetNumBlendPaths(); UINT32 MaxNumPaths = max(NumPathsInStart,NumPathsInEnd); // The number of objects // *pNumObjects = NumBlendSteps * MaxNumPaths; pBecomeA->AddCount(NumBlendSteps * MaxNumPaths); } return TRUE; } return FALSE; }

BOOL NodeBlender::CanSelectAsSimple (   )  [virtual]

Ask a node whether or not it's prepared to become selected when it's clicked on. This function is called in the FindSimple routines when they have just detected a "hit" on a node. This virtual base function is overridden here to indicate that the NodeBlender object is definitely NOT prepared to become selected! Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 06/01/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the node will allow itself to be selected when it has been "hit" FALSE otherwise Errors: - See also: NodeRenderableInk::FindSimpleAtPoint; NodeRenderableInk::FindCompoundAtPoint Reimplemented from NodeRenderableInk. Definition at line 3327 of file nodebldr.cpp. { return FALSE; }

NodeBlender::CC_DECLARE_DYNCREATE (  NodeBlender   )  [private]

BOOL NodeBlender::CheckBoundsIntersect (  RenderRegion *  pRender, DocRect &  BoundsStart, DocRect &  BoundsEnd, double  BlendRatio )  [private]

Finds the blended bounds that lies at point BlendRatio and tests for intersection. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pRender  = ptr to the current render region [INPUTS] BoundsStart = the blob bounds of start object BoundsEnd = the blob bounds of end object BlendRatio = current blend point (between 0.0 and 1.0) -  [OUTPUTS] Returns: TRUE if blended bounds intersect with the render region's clip rect. See also: - Definition at line 1403 of file nodebldr.cpp. { BOOL Clip = TRUE; if (pRender != NULL) { DocRect BlendedBounds = BlendBounds(BoundsStart,BoundsEnd,BlendRatio,TRUE); Clip = BlendedBounds.IsIntersectedWith(pRender->GetClipRect()); //pRender->DrawRect(&BlendedBounds); } return Clip; }

void NodeBlender::CheckFullyInitialised (   )  [private]

This will set the object's Initialise member to TRUE if it is fully initialised, i.e. pRefStart & pRefEnd != NULL, and ObjIndexStart and ObjIndexEnd and >= 0. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 3350 of file nodebldr.cpp. { m_Initialised = ((m_pRefStart != NULL) && (m_pRefEnd != NULL) && (m_ObjIndexStart >= 0) && (m_ObjIndexEnd >= 0)); }

BOOL NodeBlender::ConvertAWPathIndexesToCamelot (  INT32 *  pPathIndexStart, INT32 *  pPathIndexEnd )

This converts ArtWorks path indexes to a Camelot path indexes, for this blender. An AW index is just an index to the nth end point, so all that's done is the nth end point in the path is found. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 25/11/94 Parameters: pPathIndexStart  = index of element in start node [INPUTS] pPathIndexEnd = index of element in end node *pPathIndexStart  = possibly modified index for start node [OUTPUTS] pPathIndexEnd = possibly modified index for end node Returns: TRUE if ok, FALSE otherwise See also: - Definition at line 3994 of file nodebldr.cpp. { BOOL ok = FindPathEndPoint(FindPrevious(),pPathIndexStart); if (ok) ok = FindPathEndPoint(FindNext(), pPathIndexEnd); return ok; }

BOOL NodeBlender::ConvertLineToShape (  Path *  pPath, Path *  pShapePath )  [static]

This takes a line and creates a shape out of it, placing the shape in pShapePath. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/11/94 Parameters: pPath  = ptr to the line to convert [INPUTS] pShapePath = ptr to path to store the shape version of the line -  [OUTPUTS] Returns: TRUE if OK, FALSE if it goes bang It does this: A copy of the line is made, and reversed. The reversed copy has its start movetto element removed. A shape is formed by merging the line with the reversed copy. This allows us to blend a line with a shape, giving the impression that the line opens out into the shape. See also: - Definition at line 2142 of file nodebldr.cpp. { ERROR3IF(pPath == NULL || pShapePath == NULL,"One or more NULL entry params"); if (pPath == NULL || pShapePath == NULL) return FALSE; Path ReversePath; if (!ReversePath.Initialise(pPath->GetNumCoords())) return FALSE; if (!ReversePath.CopyPathDataFrom(pPath)) return FALSE; PathVerb* pRevVerb = ReversePath.GetVerbArray(); PathVerb* pShapeVerb = pShapePath->GetVerbArray(); ReversePath.Reverse(); ReversePath.FindStartOfPath(); ReversePath.DeleteElement(); pRevVerb = ReversePath.GetVerbArray(); pShapeVerb = pShapePath->GetVerbArray(); pShapePath->ClearPath(FALSE); if (!pShapePath->MergeTwoPaths(*pPath)) return FALSE; if (!pShapePath->MergeTwoPaths(ReversePath)) return FALSE; return TRUE; }

void NodeBlender::CopyNodeContents (  NodeBlender *  pCopyOfNode  )  [private]

Copies the data in this node to pCopyOfNode by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: pCopyOfNode  - The node to copy data to [INPUTS] See also: NodeRenderableInk::CopyNodeContents Definition at line 421 of file nodebldr.cpp. { NodeRenderableInk::CopyNodeContents(pCopyOfNode); // Copy contents specific to derived class here pCopyOfNode->m_ObjIndexStart = m_ObjIndexStart; pCopyOfNode->m_ObjIndexEnd = m_ObjIndexEnd; pCopyOfNode->m_PathIndexStart = m_PathIndexStart; pCopyOfNode->m_PathIndexEnd = m_PathIndexEnd; pCopyOfNode->m_ProportionOfPathDistStart = m_ProportionOfPathDistStart; pCopyOfNode->m_ProportionOfPathDistEnd = m_ProportionOfPathDistEnd; pCopyOfNode->m_NodeBlendPathIndex = m_NodeBlendPathIndex; pCopyOfNode->m_BlendedOnCurve = m_BlendedOnCurve; pCopyOfNode->SetReversed(m_Reversed); pCopyOfNode->m_AngleEnd = m_AngleEnd; pCopyOfNode->m_AngleStart = m_AngleStart; pCopyOfNode->SetUninitialised(); }

void NodeBlender::CreateBlends (  RenderRegion *  pRender, HandleBecomeA *  pHandleBecomeA )  [private]

Will generate the blended steps of this blender node. If pRender != NULL, it will render each blend step to it. if pHandleBecomeA != NULL, it will pass each blend step to pHandleBecomeA->PassBack() as it's generated. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/10/94 Parameters: pRender  = ptr to a render region (Can be NULL) [INPUTS] pHandleBecomeA = ptr to class to pass each created blended path to (can be NULL) -  [OUTPUTS] Returns: - Definition at line 829 of file nodebldr.cpp. { TRACEUSER( "ChrisS", _T("Entering create blends\n")); // Ensure that we are initialised (if it can be done!!) if (!Reinit()) return; if (!m_Initialised) return; // we MUST handle the this case! (blending NULL to NULL etc.) // Check the important member vars, to be on the safe side if (m_pRefStart == NULL || m_pRefEnd == NULL) { ERROR3("Dodgey pRef params"); return; } if (m_pNodeStart == NULL || m_pNodeEnd == NULL) { ERROR3("Dodgey m_pNodeStart and/or m_pNodeEnd params"); return; } // If the render region's quality does not state full blend rendering, // proceed as if we are not rendering at all (this is done by pretending we haven't // got a render region if (pRender != NULL && pRender->RRQuality.GetBlendQuality() != Quality::FullBlend) pRender = NULL; // If we're not rendering and not handling becoming paths, exit now. if (pRender == NULL && pHandleBecomeA == NULL) return; // Only allow background rendering when going to a DIB BOOL AllowBackgroundRender = (pRender!=NULL && ( IS_A(pRender,GRenderDIB) || pRender->IsHitDetect() ) ); // If somebody else has locked the sub render context, then we cannot BG render without stepping on their toes. if (AllowBackgroundRender && pRender->IsSubRenderStateLocked()) AllowBackgroundRender = FALSE; // This should stop any problems with blends not fully rendering in separation views if (AllowBackgroundRender && pRender->IsPrinting()) AllowBackgroundRender = FALSE; // If we are rendering (i.e. pRender != NULL) do some work with the quality settings if (pRender != NULL) { // If this blend is set for non-antialiased blend steps AND the quality is set for full antialiasing // we need to render an attr that means "do everything except antialias" if (IsNotAntialiased() && pRender->RRQuality.GetAntialiasQuality() == Quality::FullAntialias) { // Create a non-antialias quality attr to render Quality Qual; QualityAttribute *pQualAttrVal = new QualityAttribute(Qual); if (pQualAttrVal != NULL) { // Render the attribute, and mark it Temporary so it will be auto-deleted // when it is finished with. pRender->SetQuality(pQualAttrVal, TRUE); } } } // Get the start and end bounds so we can do fast blended bounds intersection tests // on the render region before going ahead with the heavy stuff DocRect BoundsStart = m_pNodeStart->GetBoundingRect(); DocRect BoundsEnd = m_pNodeEnd ->GetBoundingRect(); UINT32 NumBlendSteps = GetNumBlendSteps(); // Check for silly numbers of blend steps if (NumBlendSteps > MAX_NUM_BLEND_STEPS) NumBlendSteps = MAX_NUM_BLEND_STEPS; m_BlendStep = IsReversed() ? NumBlendSteps : 1; BlendSubRenderContext* pSubRenderContext = NULL; if (pRender != NULL) { pSubRenderContext = (BlendSubRenderContext*)pRender->GetSubRenderState(); // ERROR3IF(pSubRenderContext != NULL && !IS_A(pSubRenderContext,BlendSubRenderContext),"Sub render context is of wrong type"); // If we don't own the S.R.C, then we won't treat it as our own if (pSubRenderContext != NULL && !IS_A(pSubRenderContext,BlendSubRenderContext)) pSubRenderContext = NULL; if (pSubRenderContext != NULL) { m_BlendStep = pSubRenderContext->BlendStep; } } // Find num blend paths in start and end, and keep hold of the MAX value UINT32 NumPathsInStart = m_pRefStart->GetNumBlendPaths(); UINT32 NumPathsInEnd = m_pRefEnd ->GetNumBlendPaths(); UINT32 MaxNumPaths = max(NumPathsInStart,NumPathsInEnd); // If either start or end has 0 blend paths, return. // DMc - not any more ! if (min(NumPathsInStart,NumPathsInEnd) == 0) { return; } // Let the HandleBecomeA class know the max num paths in the start and end objects if (pHandleBecomeA != NULL) pHandleBecomeA->SetNumPathsPerStep(MaxNumPaths); // This object is used to step along the the two lists of objects choosing a pair to go and blend. // It mainly comes into play when there are different numbers of objects in the two lists. ListStepper Stepper; // BlendRatio - always a value between 0.0 and 1.0; // BlendRatioStep - the value that is added to BlendRatio on every blend step double BlendRatio; double BlendRatioStep = 1.0/(NumBlendSteps+1); Path BlendedPath; if (!BlendedPath.Initialise()) return; // Do some stuff before we start blending (if this is the first time this node has been asked to render) if (pSubRenderContext == NULL) { PreBlend(); } // This holds blended attributes that are generated during the blend CCAttrMap BlendedAttrMap(30); // If we will use background rendering, we must make sure nobody inside the blend tries // to do backgrounding as well, as we can only store one sub-render context. This bodge // locks the sub render state so that nobody else is allowed to use it. (Quick bodge // by Jason to allow strokes to background render, but not crash when they're inside // a blend - in this case, individual strokes become non-interruptible, and leave // the background render support entirely to the containing blend) // We must take care to see that we unlock the state when we are done rendering. if (AllowBackgroundRender) pRender->LockSubRenderState(TRUE); // ContinueRender is set to FALSE if we should stop rendering the blend BOOL ContinueRender = TRUE; INT32 Counter = 1; UINT32 StopBlendStep = NumBlendSteps +1 ; if (IsReversed()) { Counter = -1; StopBlendStep = 0; } // NodeRenderableInk * pLastCreatedByNode = NULL; // NodeRenderableInk * pLastBlendStartNode = NULL; // the parameter for the blending of nodes BlendNodeParam BNParam; // Graeme (21-11-00) - Tightened up the check on what was the for loop (and now a while // loop), so that it stops when the blend step gets to be equal to, or greater than, the // StopBlendStep value. (Or less than if it's a reversed blend.) // // The original code stopped when the current blend step equalled the stop value, which // meant that if the m_BlendStep value leapfrogged StopBlendStep an infinite loop could // occur. (The BlendRatio would get out of bounds pretty quick, though, and that would // stop the loop within a couple more iterations.) while ( ContinueRender && ( !IsReversed() && m_BlendStep < StopBlendStep ) || ( IsReversed() && m_BlendStep > StopBlendStep ) ) { // Calc the blend ratio using the current blend step double LinearBlendRatio = BlendRatioStep * m_BlendStep; BlendRatio = MapObjectBlendRatio(LinearBlendRatio); // Get the stepper object ready for the current blend step INT32 NextPathStart,NextPathEnd; Stepper.Init(NumPathsInStart,NumPathsInEnd,0); // Reset the ptrs and subpath IDs of the previously blended blendpath pairs. BlendPath* pPrevBlendPathStart = NULL; BlendPath* pPrevBlendPathEnd = NULL; UINT32 PrevSubPathIDStart = 0; UINT32 PrevSubPathIDEnd = 0; // Get the first pair of objects to blend Stepper.GetNext(&NextPathStart,&NextPathEnd); // The first pair of blend paths become the current blend path pair // Get ptrs to these, plus the subpath IDs of these BlendPath* pCurrBlendPathStart = m_pRefStart->GetBlendPath(NextPathStart); BlendPath* pCurrBlendPathEnd = m_pRefEnd ->GetBlendPath(NextPathEnd ); UINT32 CurrSubPathIDStart = pCurrBlendPathStart->GetSubPathID(); UINT32 CurrSubPathIDEnd = pCurrBlendPathEnd ->GetSubPathID(); // We also need info on the next blend path pair, so get some vars ready BlendPath* pNextBlendPathStart; BlendPath* pNextBlendPathEnd; UINT32 NextSubPathIDStart; UINT32 NextSubPathIDEnd; // Check to see if the blended bounds intersect with the render region's clip rect BOOL BoundsIntersect = TRUE; if (pRender != NULL && pHandleBecomeA == NULL) BoundsIntersect = CheckBoundsIntersect(pRender,BoundsStart,BoundsEnd,BlendRatio); DocRect RawBlendedBounds = BlendBounds(BoundsStart,BoundsEnd,BlendRatio,FALSE); DocCoord BBCentre = RawBlendedBounds.Centre(); // CGS: I have to allocate this here - because otherwise memory becomes toast within // subsequent iterations of the following loop .... SumAllPathsPathProcessor * ptrProc = new SumAllPathsPathProcessor (FALSE); BOOL* usingSumAllPathsPathProcessor = new BOOL; *usingSumAllPathsPathProcessor = FALSE; // and whether we are using it or not // this is reset within each call to // BeginBlendStep (). This allows us to select between conventional passback and // new SumAllPathsPathProcessor stuff when blending. // This thereby allows us to handles (.e.g): // simple shape to simple shape // shadow to shadow // grouped shadow(s) to shadow // shadowed group to shadow // shadow to simple shape // grouped shadow(s) to simple shape // shadowed group to simple shape // grouped shadow(s) to grouped shadow(s) // shadowed group to shadowed group // shadowed group to grouped shadow // you get the general gist .... // We need to blend all the blend paths together, so do MaxNumPaths blends for (UINT32 NextPath = 0; ContinueRender && BoundsIntersect && (NextPath < MaxNumPaths); NextPath++) { // Get the next pair of objects to blend Stepper.GetNext(&NextPathStart,&NextPathEnd); // Ensure GLA's which applied indiviually to child objects (ie individual BlendPaths within // either BlendRef) are removed from the BlendAttrMap when changing to next BlendPath // If this doesn't occur then blended GLA left from Blend of previous BlendPath will be // applied to subsequent BlendPaths if they're not replaced (ie if subsequent BlendPaths // don't have a valid GLA applied) BlendedAttrMap.RemoveGeometryLinkedAttrs(); if (NextPathStart >= 0 && NextPathEnd >= 0) { // There's another pair to blend, so get ptrs to them, plus their subpath IDs pNextBlendPathStart = m_pRefStart->GetBlendPath(NextPathStart); pNextBlendPathEnd = m_pRefEnd ->GetBlendPath(NextPathEnd ); NextSubPathIDStart = pNextBlendPathStart->GetSubPathID(); NextSubPathIDEnd = pNextBlendPathEnd ->GetSubPathID(); } else { // No more blend pairs after this one pNextBlendPathStart = NULL; pNextBlendPathEnd = NULL; NextSubPathIDStart = 0; NextSubPathIDEnd = 0; } // Check the ptrs to be on the safe side // DMc - we don't anymore - since if either are null this means we'll // go into the new code if (pCurrBlendPathStart == NULL || pCurrBlendPathEnd == NULL) { if (AllowBackgroundRender) pRender->LockSubRenderState(FALSE); // Unlock the sub-render state return; } double AttrBlendRatio = MapAttrBlendRatio(LinearBlendRatio); NodeRenderableInk * pStartBlendNode = NULL; NodeRenderableInk * pEndBlendNode = NULL; if (LinearBlendRatio <= 0.5) // CGS: 27/7/2000 We used to use BlendRatio for // this comparison. We now use LinearBlendRatio since // this avoids the problem of 'compound jumping' when // blending from a compound to a non-compound { BNParam.Init(GetNodeBlend (), pRender, pCurrBlendPathStart, pCurrBlendPathEnd, BlendRatio, AttrBlendRatio, m_AngleStart, m_AngleEnd, GetObjectRatio(), GetInvertedAttributeRatio(), GetColourBlendType(), pCurrBlendPathStart->GetBlendNode(), pCurrBlendPathEnd->GetBlendNode(), IsOneToOne(), GetNodeBlendPath(), pHandleBecomeA, ptrProc); pStartBlendNode = pCurrBlendPathStart->GetBlendNode(); pEndBlendNode = pCurrBlendPathEnd->GetBlendNode(); } else { BNParam.Init(GetNodeBlend (), pRender, pCurrBlendPathEnd, pCurrBlendPathStart, 1.0 - BlendRatio, 1.0 - AttrBlendRatio, m_AngleStart, m_AngleEnd, 1.0 - GetObjectRatio(), 1.0 - GetInvertedAttributeRatio(), GetColourBlendType(), pCurrBlendPathEnd->GetBlendNode(), pCurrBlendPathStart->GetBlendNode(), IsOneToOne(), GetNodeBlendPath(), pHandleBecomeA, ptrProc); pStartBlendNode = pCurrBlendPathEnd->GetBlendNode(); pEndBlendNode = pCurrBlendPathStart->GetBlendNode(); } if (!CallBeginBlendStep(&BNParam, usingSumAllPathsPathProcessor)) { return ; } if (BlendAttributes(pRender,pCurrBlendPathStart,pCurrBlendPathEnd,&BlendedAttrMap,AttrBlendRatio, BlendRatio, GetNodeBlend ()->GetObjectProfileProcessing ())) { // Blend the paths together, putting the blended path in BlendedPath if (BlendPaths(pCurrBlendPathStart,pCurrBlendPathEnd,BlendRatio)) { // The blended path will be filled if either of the paths are filled // The blended path will be stroked if either of the paths are stroked BOOL Filled = pCurrBlendPathStart->IsFilled() || pCurrBlendPathEnd->IsFilled(); BOOL Stroked = pCurrBlendPathStart->IsStroked() || pCurrBlendPathEnd->IsStroked(); // If the current subpath ID is the same as the previous one, and the current path is // different to the previous path, dont clear the blended path // (this applies to the start OR the end path) BOOL DontClearPath = ((CurrSubPathIDStart == PrevSubPathIDStart && pCurrBlendPathStart != pPrevBlendPathStart) || (CurrSubPathIDEnd == PrevSubPathIDEnd && pCurrBlendPathEnd != pPrevBlendPathEnd )); if (!DontClearPath) BlendedPath.ClearPath(FALSE); if (!BlendedPath.MakeSpaceInPath(m_ArrayLength)) goto ExitRender; BlendedPath.MergeTwoPaths(m_pTempCoords,m_pTempVerbs,m_pTempFlags,m_ArrayLength,Filled); BlendedPath.IsFilled = Filled; BlendedPath.IsStroked = Stroked; // We haven't yet got a complete path to render or pass back if next path has the same ID and is // a different path // (this applies to the start OR the end path) BOOL NotACompletePath = ((CurrSubPathIDStart == NextSubPathIDStart && pCurrBlendPathStart != pNextBlendPathStart) || (CurrSubPathIDEnd == NextSubPathIDEnd && pCurrBlendPathEnd != pNextBlendPathEnd )); if (!NotACompletePath) { // DY 9/99 added this condition to enable us to blend to // and from blends on paths. if (m_BlendedOnCurve) { DocCoord PointOnPath; double Angle = 0.0; if (GetPointOnNodeBlendPath(BlendRatio,&PointOnPath,&Angle)) { Trans2DMatrix Translate(PointOnPath.x-BBCentre.x,PointOnPath.y-BBCentre.y); Trans2DMatrix Rotate(BBCentre,Angle); if (Angle != 0.0) { Rotate.Transform( (DocCoord*)BlendedPath.GetCoordArray(), BlendedPath.GetNumCoords() ); BlendedAttrMap.Transform(Rotate); } Translate.Transform( (DocCoord*)BlendedPath.GetCoordArray(), BlendedPath.GetNumCoords() ); // not a regular transform for the attributes, as we may want to tile BlendedAttrMap.TransformForBrush(Translate); } } // Ilan 4/5/00 // Call the PostDynCreateInit functions for the attributes which require this // NB attrs which don't succeed in init'ing will mark themselves so that they don't NeedToRender() // ie the AttrMap can safely be rendered - the united attrs simply won't do their job BlendedAttrMap.PostBlendInit(&BlendedPath, GetRuntimeClass()); // CGS: Now are we doing a convert to editable shapes ???? if (pHandleBecomeA != NULL) { // we are - so test if we have a SumAllPathsPathProcessor .... if (!(*usingSumAllPathsPathProcessor)) { // we don't - so we are not dealing with compound nodes // Pass the path back (as usual) ContinueRender = pHandleBecomeA->PassBack(&BlendedPath,&BlendedAttrMap,m_BlendStep); } else { // we do - so we are dealing with compound nodes .... if ((pHandleBecomeA->GetBecomeA ()->GetReason () == BECOMEA_REPLACE) || (pHandleBecomeA->GetBecomeA ()->GetReason () == BECOMEA_PASSBACK) ) { Path* pNewBlendedPath = new Path; pNewBlendedPath->Initialise (BlendedPath.GetNumCoords ()); pNewBlendedPath->CopyPathDataFrom (&BlendedPath); CCAttrMap* pNewBlendedAttrMap = BlendedAttrMap.Copy (); SumAllPathsElem * pElem = new SumAllPathsElem(pNewBlendedPath, pNewBlendedAttrMap); ptrProc->InsertSumAllPathsElem (pElem); ContinueRender = TRUE; delete (pNewBlendedPath); } } } if (pRender != NULL) { pRender->SaveContext(); // CGS: if (!(*usingSumAllPathsPathProcessor)) { RenderAttributes(pRender,&BlendedAttrMap); pRender->DrawPath(&BlendedPath); } else { Path* pNewBlendedPath = new Path; pNewBlendedPath->Initialise (BlendedPath.GetNumCoords ()); pNewBlendedPath->CopyPathDataFrom (&BlendedPath); CCAttrMap* pNewBlendedAttrMap = BlendedAttrMap.Copy (); SumAllPathsElem * pElem = new SumAllPathsElem(pNewBlendedPath, pNewBlendedAttrMap); ptrProc->InsertSumAllPathsElem (pElem); ContinueRender = TRUE; delete (pNewBlendedPath); } pRender->RestoreContext(); } // Ilan 4/5/00 // Deinitialise the attrs which allocated memory in the PostBlendInit() fn call BlendedAttrMap.PostBlendDeinit(); } } } TRACEUSER( "ChrisS", _T("Blend step == %f\n"), BlendRatio); // restore the blend paths if (!CallEndBlendStep(&BNParam)) { return ; } // Set up the vars for the next pair of blend paths // The Current vars become the previous vars PrevSubPathIDStart = CurrSubPathIDStart; PrevSubPathIDEnd = CurrSubPathIDEnd; pPrevBlendPathStart = pCurrBlendPathStart; pPrevBlendPathEnd = pCurrBlendPathEnd; // The next vars become the current vars CurrSubPathIDStart = NextSubPathIDStart; CurrSubPathIDEnd = NextSubPathIDEnd; pCurrBlendPathStart = pNextBlendPathStart; pCurrBlendPathEnd = pNextBlendPathEnd; } if (usingSumAllPathsPathProcessor != NULL) { delete (usingSumAllPathsPathProcessor); // clear out the boolean that was allocated } if (ptrProc != NULL) { delete (ptrProc); // clear out the path processor if we allocated one } // This section communicates with the render region (if there is one) to see if // we have taken too long to render this step, and hence need to update the screen during // background redraw. // Have we got a render region and have we actually rendered anything on this step? if (pRender != NULL && BoundsIntersect) { View* pView = pRender->GetRenderView(); if (pView != NULL) { if (AllowBackgroundRender && (pRender->IsHitDetect() || !pRender->RenderTreeCanContinue())) { // CanContinue() has returned FALSE, so we need to try and save the sub render // context so that the render region can call us back next time // Have we got a sub render context object? if (pSubRenderContext == NULL) { // If not, create a new BlendSubRenderContext object and make this the one // the render region should use via SetSubRenderState() pSubRenderContext = new BlendSubRenderContext; if (pSubRenderContext != NULL && pRender->GetSubRenderState() != pSubRenderContext) { // Turn off the sub render lock now, or my silly ERROR3 will go off! pRender->LockSubRenderState(FALSE); pRender->SetSubRenderState(pSubRenderContext); } } if (pSubRenderContext != NULL) { // If we have a sub render context object, set it up and exit this render // call at an appropriate point pSubRenderContext->BlendStep = m_BlendStep+Counter; // Render the next blend step next time goto ExitRender; } } } } // Increment the counter. m_BlendStep+= Counter; } // end while if (pRender != NULL && pSubRenderContext != NULL) { // Here we have finished rendering the whole blender node // We must make sure we delete the sub render context object, and set the render region's // sub render state to NULL delete pSubRenderContext; pSubRenderContext = NULL; pRender->SetSubRenderState(NULL); } // Do some stuff after the blend PostBlend(); ExitRender: // delete any attributes that are left in the blended attr map BlendedAttrMap.DeleteAttributes(); // Finally, unlock the sub-render context so others may use it (now that it is relatively safe) if (AllowBackgroundRender) pRender->LockSubRenderState(FALSE); TRACEUSER( "ChrisS", _T("Exiting create blends\n")); }

void NodeBlender::DeallocTempBuffers (   )  [private]

Releases memory allocated for the temp path arrays, and sets the size var to 0. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 3797 of file nodebldr.cpp. { if (m_pTempCoords != NULL) { CCFree(m_pTempCoords); m_pTempCoords = NULL; } if (m_pTempVerbs != NULL) { CCFree(m_pTempVerbs); m_pTempVerbs = NULL; } if (m_pTempFlags != NULL) { CCFree(m_pTempFlags); m_pTempFlags = NULL; } m_TempArraySize = 0; if (m_pGBlendBuff != NULL) { CCFree(m_pGBlendBuff); m_pGBlendBuff = NULL; } m_GBlendBuffSize = 0; }

void NodeBlender::Deinit (  BOOL  bNodesMayBeChanged = FALSE  )

This deinits the node, setting its internal Initialised flag to FALSE, and deleting any memory that is created during initialisation. It's like a combination of the constructor and destructor, leaving it in a state similar to defualt construction. The state is such that a call to Reinit() can exactly recreate the blender node. Used when hiding NodeBlenders to free up some memory. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 3448 of file nodebldr.cpp. { // CGS: we must now delete any intermediate blend step generated stuff .... // NOTE: these lists will only contains items when we have been asked to do // a blend of a grouped blend to another grouped blend. Node* node = FindPrevious (); NodeBlend* node2 = (NodeBlend*) node->FindFirstChild (CC_RUNTIME_CLASS (NodeBlend)); NodeGroup::KillAllBlendBecomeAConsListItem (node2); if (bNodesMayBeChanged) { m_pNodeStart = NULL; m_pNodeEnd = NULL; } if (m_Initialised) { DELPTR(m_pRefStart); DELPTR(m_pRefEnd); m_Initialised = FALSE; } // if we are on a curve then destroy the cached points of the curve NodeBlendPath* pNodeBlendPath = GetNodeBlendPath(); if (pNodeBlendPath != NULL) pNodeBlendPath->DestroyCachedInformation(); }

BOOL NodeBlender::DoBecomeA (  BecomeA *  pBecomeA  )  [virtual]

Transforms the object into another type of object. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: pBecomeA  = ptr to a class that contains all the info needed to become a new [INPUTS] type of node. -  [OUTPUTS] Returns: TRUE if the object has been transformed, FALSE if we run out of memory See also: NodeBlender::CanBecomeA Reimplemented from Node. Definition at line 2795 of file nodebldr.cpp. { if (!Reinit()) return TRUE; if (!m_Initialised) return TRUE; // we MUST handle this for future versions ! // Check for a NULL entry param ERROR2IF(pBecomeA == NULL,FALSE,"pBecomeA is NULL"); // This lump checks that the Reason is one that we understand // It also makes sure that we don't have a NULL UndoOp ptr BOOL ValidReason = (pBecomeA->GetReason() == BECOMEA_REPLACE || pBecomeA->GetReason() == BECOMEA_PASSBACK); ERROR2IF_PF(!ValidReason,FALSE,("Unkown BecomeA reason %d",pBecomeA->GetReason())); // Set up a HandleBecomeA object and call CreateBlends(). // This mechanism means the the same code is used to both render blends and create paths // from blends. HandleBecomeA HBecomeA(this,this,pBecomeA); CreateBlends(NULL,&HBecomeA); switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE : { // It's a BECOMEA_REPLACE, so hide this node in an undoable way // Can't do it in an undoable way without an Undo Op // ERROR2IF(pBecomeA->GetUndoOp() == NULL,FALSE,"GetUndoOp() returned NULL"); UndoableOperation* pOp = pBecomeA->GetUndoOp(); // We need to make sure that all the groups we may have produced have their attrs correctly // factored out. This is so the final factoring out done by the NodeBlend node will be able // to complete the job. // Without this step, leaf nodes can have common child attrs that should be factored up the // to a higher level. Node* pNode = m_pNodeStart->FindNext(); while (pNode != NULL && pNode != m_pNodeEnd) { //if (IS_A (pNode, NodeGroup)) if (pNode->IsCompoundClass()) { if (pOp) { if (!pOp->DoFactorOutCommonChildAttributes((NodeCompound*)pNode)) return FALSE; } else { if (!((NodeCompound*)pNode)->FactorOutCommonChildAttributes()) return(FALSE); } } pNode = pNode->FindNext(); } NodeHidden* pHiddenNodeBlender = NULL; // hide this blender node if (pOp) { if (!pOp->DoHideNode(this, TRUE, &pHiddenNodeBlender)) return FALSE; } else { CascadeDelete(); delete this; } } break; case BECOMEA_PASSBACK : // Don't do anything for this reason break; default: break; } return TRUE; }

INT32 NodeBlender::EstimateNodeComplexity (  OpParam *  details  )  [virtual]

This function estimates a complexity value for the node. The complexity value is based upon the total length of all paths in the node. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 6/09/2000 Parameters: details  any data that should be used for the calculation [INPUTS] -  [OUTPUTS] Returns: an estimate of the nodes complexity See Also: OpBlendNodes::DeterminBlendObjectsProcessorHit () Reimplemented from Node. Definition at line 2092 of file nodebldr.cpp. { //m_pNodeStart,&m_pRefStart if ((m_pNodeStart == NULL) || (m_pNodeEnd == NULL)) { return (-1); } INT32 complexityEstimate1 = m_pNodeStart->EstimateNodeComplexity (details); INT32 complexityEstimate2 = m_pNodeEnd->EstimateNodeComplexity (details); UINT32 NumBlendStepsby2 = 0; if (!details) { NumBlendStepsby2 = GetNumBlendSteps()/2; } else { NumBlendStepsby2 = (UINT32) (INT32) details->Param1; } INT32 generatedPathsEstimate = NumBlendStepsby2+1*complexityEstimate1 + NumBlendStepsby2*complexityEstimate2; return (generatedPathsEstimate); }

BOOL NodeBlender::ExportRender (  RenderRegion *  pRegion  )  [virtual]

Called after this node and all of its children have been rendered to the export region. This outputs the "end blender" command. Supports ArtWorks EPS and Camelot EPS. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 Parameters: pRegion  = ptr to the export render region to export to [INPUTS] [OUTPUTS]  Returns: TRUE if ok, FALSE if something went wrong Errors: Reimplemented from NodeRenderableInk. Definition at line 6991 of file nodebldr.cpp. { #ifdef DO_EXPORT // Ensure that we are initialised (if it can be done!!) if (!Reinit()) return FALSE; if (pRegion->IS_KIND_OF(ArtWorksEPSRenderRegion)) { EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); if (IS_A(pRegion, CamelotEPSRenderRegion)) { // only want renderable stuff in EPS return FALSE; // render this as paths. } else if (pRegion->IS_KIND_OF(NativeRenderRegion)) { pDC->OutputToken(_T("cebr")); // Camelot "end blender" token pDC->OutputNewLine(); } else { NodeBlend* pNodeBlend = GetNodeBlend(); if (pNodeBlend != NULL) { if (pNodeBlend->IsArtWorksEPSCompatible()) { pDC->OutputToken(_T("aebr")); // ArtWorks "end blender" token pDC->OutputNewLine(); } } } // Tell caller we rendered ourselves ok return TRUE; } #endif // Render this node in the normal way return FALSE; }

NodeRenderableInk * NodeBlender::FindObjIndexedNode (  INT32  ObjIndex  )

This scans the children of the parent of this blender, until it finds the ObjIndex'th NodeRenderableInk. I.e. if ObjIndex == 0, it returns the first child NodeRenderableInk. if ObjIndex == 1, returns the second child NodeRenderableInk. Fails if: ObjIndex >= number of children the parent has The node found is not a NodeRenderableInk or is a NodeBlender. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Adjusted Diccon Yamanaka 16/9/99 Parameters: ObjIndex  = Relative ref to the object under the parent of this node [INPUTS] -  [OUTPUTS] Returns: Ptr to the node. NULL if couldn't be found or node is of wrong type See also: - Definition at line 3257 of file nodebldr.cpp. { ERROR3IF_PF(ObjIndex < 0,("ObjIndex is -ve!! (%ld)",ObjIndex)); if (ObjIndex < 0) return NULL; Node* pParent = this->FindParent(); Node* pFoundNode = NULL; ERROR3IF(pParent == NULL,"pInkNode has no parent"); ERROR3IF(!IS_A(pParent,NodeBlend),"parent is not a NodeBlend"); if (pParent != NULL && IS_A(pParent,NodeBlend)) { Node* pNode = pParent->FindFirstChild(); while (pNode != NULL && ObjIndex >= 0) { if (pNode->IS_KIND_OF(NodeRenderableInk)) { //DY 16/9/99 fix to make blending along a curve possible // as we insert NodeBlendPath during that operation. if (!pNode->IS_KIND_OF(NodeBlendPath)) { if (ObjIndex == 0) pFoundNode = pNode; ObjIndex--; } } pNode = pNode->FindNext(); } } if (pFoundNode != NULL) { if (IS_A(pFoundNode,NodeBlender)) { ERROR3("Found node is a NodeBlender"); pFoundNode = NULL; } else if (!pFoundNode->IS_KIND_OF(NodeRenderableInk)) { ERROR3("Found node is not a NodeRenderableInk"); pFoundNode = NULL; } } else ERROR3("Couldn't find ref node"); return ((NodeRenderableInk*)pFoundNode); }

BOOL NodeBlender::FindPathEndPoint (  Node *  pNodePath, INT32 *  pIndex )

This finds the N'th end point in the given NodePath. This is used to convert AW end point indexes into Camelot end point indexes. If *pIndex <=0 on entry, *pIndex = 0 on exit. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 25/11/94 Parameters: pNodePath  = ptr to a NodePath [INPUTS] pIndex = ptr to INT32 - must contain the number of the endpoint desired (N) *pIndex  = the index to the N'th endpoint. [OUTPUTS] Returns: TRUE if ok, FALSE otherwise See also: - Definition at line 4018 of file nodebldr.cpp. { ERROR3IF(pIndex == NULL,"pIndex == NULL"); ERROR3IF(pNodePath == NULL,"pNodePath == NULL"); if (pIndex == NULL || pNodePath == NULL) return FALSE; // ERROR3IF(!pNodePath->IS_KIND_OF(NodePath),"pNodePath is not kind of NodePath"); if (!pNodePath->IS_KIND_OF(NodePath)) *pIndex = 0; // if *pIndex < 0 then this has a special meaning so preserve it and return TRUE // (e.g. -1 means find bottom left element) if (*pIndex < 0) return TRUE; Path* pPath = &(((NodePath*)pNodePath)->InkPath); INT32 Index=0; for (INT32 n=*pIndex;n>0;n--) { if (!pPath->FindNextEndPoint(&Index)) return FALSE; } *pIndex = Index; return TRUE; }

double NodeBlender::GetAngleEnd (   )

Definition at line 7543 of file nodebldr.cpp. { return m_AngleEnd; }

double NodeBlender::GetAngleStart (   )

Definition at line 7538 of file nodebldr.cpp. { return m_AngleStart; }

INT32 NodeBlender::GetAWEndPathIndex (   )

This converts PathIndexEnd into an index AW understands (compatible with RISCOS path format). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 Parameters: [INPUTS]  [OUTPUTS]  Returns: AW path index based on the PathIndexEnd member var Errors: Definition at line 7126 of file nodebldr.cpp. { ERROR2IF(m_pRefEnd == NULL,-1,"m_pRefEnd == NULL"); return (GetAWPathIndex(m_pRefEnd,m_PathIndexEnd)); }

INT32 NodeBlender::GetAWPathIndex (  BlendRef *  pRef, INT32  PathIndex )

This converts the index into an index AW understands (compatible with RISCOS path format). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 Parameters: pRef  = ptr to a blend ref [INPUTS] PathIndex = index into the blend ref's first path [OUTPUTS]  Returns: AW path index based on PathIndex and the first path in the blend ref Errors: Definition at line 7147 of file nodebldr.cpp. { BlendPath* pBlendPath = pRef->GetFirstBlendPath(); if (pBlendPath == NULL || pBlendPath->GetPath() == NULL) return -1; Path* pPath = pBlendPath->GetPath(); INT32 AWPathIndex=0,Index=0; while (Index < PathIndex) { pPath->FindNextEndPoint(&Index); AWPathIndex++; } return AWPathIndex; }

INT32 NodeBlender::GetAWStartPathIndex (   )

This converts PathIndexStart into an index AW understands (compatible with RISCOS path format). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 Parameters: [INPUTS]  [OUTPUTS]  Returns: AW path index based on the PathIndexStart member var Errors: Definition at line 7106 of file nodebldr.cpp. { ERROR2IF(m_pRefStart == NULL,-1,"m_pRefStart == NULL"); return (GetAWPathIndex(m_pRefStart,m_PathIndexStart)); }

BOOL NodeBlender::GetBlendDirection (  double *  Gradient  )

To get a vector of the direction of a linear blend. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 Parameters: -  [INPUTS] Gradient  of the line that the blend follows [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Definition at line 7607 of file nodebldr.cpp. { if (IsBlendedOnCurve()) { ERROR3("Trying to get linear direction of blend on a curve"); return FALSE; } DocCoord StartCentre; DocCoord EndCentre; BOOL Valid = GetBlendObjectCentres(&StartCentre, &EndCentre); if (!Valid) return FALSE; double XDiff = EndCentre.x - StartCentre.x; double YDiff = EndCentre.y - StartCentre.y; *Gradient = YDiff/XDiff; return TRUE; }

BOOL NodeBlender::GetBlendObjectCentres (  DocCoord *  pFirstCentre, DocCoord *  pEndCentre )

To get the centres of the objects that are blended between. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 Parameters: -  [INPUTS] Coordinates  of the centres of the first and last objects of this blender [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Definition at line 7644 of file nodebldr.cpp. { // get the start and end nodes NodeRenderableInk* pBlendStart = GetNodeStart(); NodeRenderableInk* pBlendEnd = GetNodeEnd(); if (pBlendStart ==NULL || pBlendEnd == NULL) { ERROR3IF(pBlendStart ==NULL, "Blender has no start nodes"); ERROR3IF(pBlendEnd ==NULL, "Blender has no end nodes"); return FALSE; } DocRect StartRect = pBlendStart->GetBoundingRect(); DocRect EndRect = pBlendEnd->GetBoundingRect(); DocCoord StartCentre = StartRect.Centre(); DocCoord EndCentre = EndRect.Centre(); *pFirstCentre = StartCentre; *pEndCentre = EndCentre; return TRUE; }

DocRect NodeBlender::GetBlobBoundingRect (   )  [virtual]

At the moment, blender nodes don't have any blobs, so just the standard bounding box is returned. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Returns: DocRect - Returns the bounding rect of the blender node and its blobs Reimplemented from NodeRenderable. Definition at line 2667 of file nodebldr.cpp. { return (GetBoundingRect()); }

DocRect NodeBlender::GetBoundingRect (  BOOL  DontUseAttrs = FALSE, BOOL  HitTest = FALSE )  [virtual]

if the bounding rect is valid it is returned, if not, it is recalculated and then returned. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: DontUseAttrs  - TRUE if we should ignore the nodes attributes. [INPUTS] Defaults to FALSE HitTest - TRUE if being called during HitTest Returns: The nodes bounding rect See also: NodeBlender::GetBlobBoundingRect Reimplemented from NodeRenderableBounded. Definition at line 2572 of file nodebldr.cpp. { if (Parent != NULL && IS_A(Parent,NodeBlend) && !((NodeBlend*)Parent)->AreBoundsValid()) IsBoundingRectValid = FALSE; if (!IsBoundingRectValid || DontUseAttrs) { // We need ptrs to the start and end objects this blender is blending NodeRenderableInk* pStart = NULL; NodeRenderableInk* pEnd = NULL; // If we are initialised, get the start and end ink nodes if (m_pRefStart != NULL) pStart = m_pRefStart->GetNode(); if (m_pRefEnd != NULL) pEnd = m_pRefEnd ->GetNode(); if (pStart == NULL) pStart = m_pNodeStart; if (pEnd == NULL) pEnd = m_pNodeEnd; // If we don't have ptrs to the start and end objects of this blend, have a look for them if (pStart == NULL) pStart = (NodeRenderableInk*)FindPrevious(CC_RUNTIME_CLASS(NodeRenderableInk)); if (pEnd == NULL) pEnd = (NodeRenderableInk*)FindNext(CC_RUNTIME_CLASS(NodeRenderableInk)); // Check the ink nodes to ensure that they are what we expect. ERROR3IF(pStart == NULL,"pStart == NULL"); ERROR3IF(pEnd == NULL,"pEnd == NULL"); ERROR3IF(!pStart->IS_KIND_OF(NodeRenderableInk),"pStart not a NodeRenderableInk"); ERROR3IF(!pEnd ->IS_KIND_OF(NodeRenderableInk),"pEnd not a NodeRenderableInk"); ERROR3IF(pStart->IS_KIND_OF(NodeBlender),"pStart is a NodeBlender"); ERROR3IF(pEnd ->IS_KIND_OF(NodeBlender),"pEnd not a NodeBlender"); // Continue only if we have nodes that we expect BOOL ok = (pStart != NULL) && (pEnd != NULL) && (pStart->IS_KIND_OF(NodeRenderableInk)) && (pEnd ->IS_KIND_OF(NodeRenderableInk)) && (!pStart->IS_KIND_OF(NodeBlender)) && (!pEnd ->IS_KIND_OF(NodeBlender)); if (ok) { // The bounds for the entire blender is the union of the bounds of the start and end objects blended. // Assume here that blended paths can't lie outside this bounding rect. DocRect BoundsStart = pStart->GetBoundingRect(DontUseAttrs,HitTest); DocRect BoundsEnd = pEnd ->GetBoundingRect(DontUseAttrs,HitTest); DocRect NewBounds; NewBounds = BoundsStart; NewBounds = NewBounds.Union(BoundsEnd); if (GetNodeBlendPath() != NULL) NewBounds = NewBounds.Union(GetUnionBlendedBounds(BoundsStart,BoundsEnd)); // If the caller didn't want bounds included, then return the bounds immediately, // and do not cache the bounds rectangle. if (DontUseAttrs) return(NewBounds); // Cache the new bounding rectangle IsBoundingRectValid = TRUE; BoundingRectangle = NewBounds; } } /* if (!IsBoundingRectValid && Reinit()) { if (pRefStart != NULL && pRefStart->GetNode() != NULL && pRefEnd != NULL && pRefEnd ->GetNode() != NULL) { BoundingRectangle = pRefStart->GetNode()->GetBoundingRect(DontUseAttrs); BoundingRectangle = BoundingRectangle.Union(pRefEnd->GetNode()->GetBoundingRect(DontUseAttrs)); IsBoundingRectValid = TRUE; } } */ // return the current state of the bounding rect return BoundingRectangle; }

ColourBlendType NodeBlender::GetColourBlendType (   )

Gets the way colours are blended by asking the parent blend node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/3/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: How colours are blended See also: - Definition at line 3524 of file nodebldr.cpp. { ColourBlendType ColBlendType = COLOURBLEND_FADE; NodeBlend* pNode = GetNodeBlend(); if (pNode != NULL) ColBlendType = pNode->GetColourBlendType(); else { ERROR3("Parent of blender is not there, or is not a NodeBlend!!!"); } return ColBlendType; }

DocCoord * NodeBlender::GetCoordArray (  UINT32  MinSize  )  [private]

Used to get an array you can write to. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/94 Parameters: MinSize  = min size the array should be [INPUTS] -  [OUTPUTS] Returns: Ptr to the array, or NULL if can't get memory See also: - Definition at line 3822 of file nodebldr.cpp. { MinSize++; if (m_TempArraySize >= MinSize) return m_pTempCoords; if (ReallocTempBuffers(MinSize)) return m_pTempCoords; else return NULL; }

void NodeBlender::GetDebugDetails (  StringBase *  Str, BlendRef *  pBlendRef )

For obtaining debug information about the blend reference. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/2/95 Parameters: Str,:  String giving debug info about the node [OUTPUTS] Definition at line 549 of file nodebldr.cpp. { #ifdef _DEBUG String_256 TempStr; TempStr._MakeMsg( _T("Num blend paths = #1%d\r\n"),pBlendRef->GetNumBlendPaths()); *Str += TempStr; BlendPath* pBlendPath = pBlendRef->GetFirstBlendPath(); while (pBlendPath != NULL) { Path* pPath = pBlendPath->GetPath(); PathVerb* pVerbs = pPath->GetVerbArray(); PathFlags* pFlags = pPath->GetFlagArray(); DocCoord* pCoords = pPath->GetCoordArray(); TempStr._MakeMsg( _T("Original Mapping = #1%d\r\n"), pBlendPath->GetOrigMapping()); *Str += TempStr; for (INT32 i=0; i<pPath->GetNumCoords(); i++) { // Add the info to the string TempStr._MakeMsg( TEXT("#1%d.\t#2%d\t#3%ld,\t#4%ld\t"), i, pVerbs[i], pCoords[i].x, pCoords[i].y ); (*Str) += TempStr; if (pFlags[i].IsEndPoint) { TempStr._MakeMsg( _T(": E\t") ); (*Str) += TempStr; } *Str += _T("\r\n"); } pBlendPath = pBlendRef->GetNextBlendPath(pBlendPath); } #endif }

void NodeBlender::GetDebugDetails (  StringBase *  Str  )  [virtual]

Displays debugging info of the tree For obtaining debug information about the Node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: Str,:  String giving debug info about the node [OUTPUTS] Reimplemented from NodeRenderableBounded. Definition at line 499 of file nodebldr.cpp. { #ifdef _DEBUG // Call base class NodeRenderableInk::GetDebugDetails( Str ); (*Str) += TEXT( "\r\nBlender Data Dump\r\n" ); TCHAR buf[500]; camSnprintf( buf, 500, _T("Blend steps = %ld\r\n") _T("m_ObjIndex start = %ld\r\n") _T("m_ObjIndex end = %ld\r\n") _T("m_ProportionOfPathDistStart = %f\r\n") _T("m_ProportionOfPathDistEnd = %f\r\n") _T("m_AngleStart = %f\r\n") _T("m_AngleEnd = %f\r\n") _T("m_NodeBlendPathIndex = %ld\r\n") _T("\r\n"), GetNumBlendSteps(), m_ObjIndexStart, m_ObjIndexEnd, m_ProportionOfPathDistStart, m_ProportionOfPathDistEnd, m_AngleStart, m_AngleEnd, m_NodeBlendPathIndex ); *Str += buf; *Str += _T("--------- Start\r\n\r\n"); GetDebugDetails(Str,m_pRefStart); *Str += _T("--------- End\r\n\r\n"); GetDebugDetails(Str,m_pRefEnd); #endif }

PathFlags * NodeBlender::GetFlagArray (  UINT32  MinSize  )  [private]

Used to get an array you can write to. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/94 Parameters: MinSize  = min size the array should be [INPUTS] -  [OUTPUTS] Returns: Ptr to the array, or NULL if can't get memory See also: - Definition at line 3872 of file nodebldr.cpp. { MinSize++; if (m_TempArraySize >= MinSize) return m_pTempFlags; if (ReallocTempBuffers(MinSize)) return m_pTempFlags; else return NULL; }

UINT32 * NodeBlender::GetGBlendBuff (  UINT32  MinSize  )  [private]

Used to get a buffer you can write to. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/94 Parameters: MinSize  = min size the buffer should be [INPUTS] -  [OUTPUTS] Returns: Ptr to the buffer, or NULL if can't get memory See also: - Definition at line 3897 of file nodebldr.cpp. { MinSize++; if (m_GBlendBuffSize >= MinSize) return m_pGBlendBuff; if (m_pGBlendBuff != NULL) CCFree(m_pGBlendBuff); m_pGBlendBuff = (UINT32*) CCMalloc(MinSize*sizeof(UINT32)); if (m_pGBlendBuff != NULL) m_GBlendBuffSize = MinSize; else m_GBlendBuffSize = 0; return m_pGBlendBuff; }

double NodeBlender::GetInvertedAttributeRatio (   )  [private]

Function that inverts the current attribute profile and returns the mapped value This is needed to fix the problem with profiles and transparencies and other fills that use control points. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 1/10/99 Parameters: -  [INPUTS] Returns: The mapped blend ratio to use for blend attributes See also: NodePath::Render; NodeRenderableInk::RenderEorDrag Definition at line 2451 of file nodebldr.cpp. { UINT32 NumSteps = GetNumBlendSteps() + 1; double StepRatio = 1.0/NumSteps; double LinearRatio = StepRatio * m_BlendStep; CProfileBiasGain* AttributeProfile = GetNodeBlend()->GetAttrProfile(); CProfileBiasGain InvertedProfile; InvertedProfile.SetBias(-1*(AttributeProfile->GetBias())); InvertedProfile.SetGain(-1*(AttributeProfile->GetGain())); /*double Test =*/ AttributeProfile->MapZeroToOne(LinearRatio); return InvertedProfile.MapZeroToOne(LinearRatio); }

double NodeBlender::GetLinearDistance (   )

to get the distance between the start and end nodes of the blender when the blend is not on a curve. Note that it will return an incorrect value if the blend is on a curve. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/99 Parameters: -  [INPUTS] Returns: distance between the centre of the start and end nodes See also: NodeBlendPath::GetPathLength(); Definition at line 7575 of file nodebldr.cpp. { DocCoord StartCentre; DocCoord EndCentre; BOOL Valid = GetBlendObjectCentres(&StartCentre, &EndCentre); if (!Valid) return FALSE; Coord pStart = (Coord)StartCentre; Coord pEnd = (Coord)EndCentre; double Distance = pStart.Distance(pEnd); return Distance; }

NodeBlend * NodeBlender::GetNodeBlend (   )

Central NodeBlend "getter". Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/99 Parameters: -  [INPUTS] Returns: ptr to the blend that this blender belongs to, or NULL if it's all gone pear shaped See also: - Definition at line 7380 of file nodebldr.cpp. { Node* pNode = FindParent(); if (pNode != NULL && IS_A(pNode,NodeBlend)) return (NodeBlend*)pNode; return NULL; }

NodeBlendPath * NodeBlender::GetNodeBlendPath (   )

It gets the node blend path from its parent. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/99 Parameters: -  [INPUTS] Returns: ptr to the blend path for this blender, or NULL if it fails See also: - Definition at line 7402 of file nodebldr.cpp. { if (m_NodeBlendPathIndex > -1) { NodeBlend* pNode = GetNodeBlend(); if (pNode != NULL) return pNode->GetNodeBlendPath(m_NodeBlendPathIndex); } return NULL; }

INT32 NodeBlender::GetNodeBlendPathIndex (   )

See above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/99 Parameters: -  [INPUTS] Returns: the index to the nodeblendpath to which this blender refers, or -1 if it is not on a curve See also: - Definition at line 3634 of file nodebldr.cpp. { return m_NodeBlendPathIndex; }

NodeRenderableInk* NodeBlender::GetNodeEnd (   )  [inline]

Definition at line 401 of file nodebldr.h. { return m_pNodeEnd; }

UINT32 NodeBlender::GetNodeSize (   )  const [virtual]

For finding the size of the node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Returns: The size of the node in bytes See also: Node::GetSubtreeSize Reimplemented from Node. Definition at line 2687 of file nodebldr.cpp. { return (sizeof(NodeBlender)); }

NodeRenderableInk* NodeBlender::GetNodeStart (   )  [inline]

Definition at line 400 of file nodebldr.h. { return m_pNodeStart; }

UINT32 NodeBlender::GetNumBlendSteps (   )

Gets the number of blend steps for this blender, by asking the parent blend node for its num blend steps. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Num blend steps for this blender See also: - Definition at line 3495 of file nodebldr.cpp. { UINT32 NumBlendSteps = 5; NodeBlend* pNode = GetNodeBlend(); if (pNode != NULL) NumBlendSteps = pNode->GetNumBlendSteps(); else { ERROR3("Parent of blender is not there, or is not a NodeBlend!!!"); } return NumBlendSteps; }

double NodeBlender::GetObjectRatio (   )  [private]

returns the current mapping of objects Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 1/10/99 Parameters: -  [INPUTS] Returns: The mapped blend ratio to use for blend objects Definition at line 2422 of file nodebldr.cpp. { UINT32 NumSteps = GetNumBlendSteps() + 1; double StepRatio = 1.0/NumSteps; double LinearRatio = StepRatio * m_BlendStep; CProfileBiasGain* ObjectProfile = GetNodeBlend()->GetObjectProfile(); return ObjectProfile->MapZeroToOne(LinearRatio); }

INT32 NodeBlender::GetObjIndexEnd (   )  [inline]

Definition at line 485 of file nodebldr.h. { return m_ObjIndexEnd; }

INT32 NodeBlender::GetObjIndexStart (   )  [inline]

Definition at line 484 of file nodebldr.h. { return m_ObjIndexStart; }

INT32 NodeBlender::GetPathIndexEnd (   )  [inline]

Definition at line 478 of file nodebldr.h. { return m_PathIndexEnd; }

INT32 NodeBlender::GetPathIndexStart (   )  [inline]

Definition at line 477 of file nodebldr.h. { return m_PathIndexStart; }

BOOL NodeBlender::GetPointFromDistance (  double  Distance, DocCoord *  pPoint, double *  pAngle )

Access function to make it easy to get the correct point in the path for this NodeBlender with the given distance along the path. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/9/99 Parameters: Distance  - the distance along the nodeblendpath [INPUTS] pPoint  = ptr to store coord [OUTPUTS] pAngle = angle at this point in degrees (ptr can be NULL) Returns: TRUE if it could find the point on the NodeBlendPath FALSE if there's no path to blend along, or the point-on-path function fails See also: - Definition at line 7481 of file nodebldr.cpp. { ERROR2IF(pPoint == NULL,FALSE,"NULL coord ptr"); BOOL ok = FALSE; NodeBlendPath* pNodeBlendPath = GetNodeBlendPath(); if (pNodeBlendPath) { double Tangent = 0.0; ok = pNodeBlendPath->GetPointAtDistance((INT32)Distance,pPoint,&Tangent); if (ok && pAngle) { if (IsTangential()) *pAngle = Tangent/PI*180; else *pAngle = 0.0; } } return ok; }

BOOL NodeBlender::GetPointOnNodeBlendPath (  double  BlendRatio, DocCoord *  pPoint, double *  pAngle )

Access function to make it easy to get the correct point in the path for this NodeBlender with the given blend ratio. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/5/99 Parameters: BlendRatio  = the blend ratio to use [INPUTS] pPoint  = ptr to store coord [OUTPUTS] pAngle = angle at this point in degrees (ptr can be NULL) Returns: TRUE if it could find the point on the NodeBlendPath FALSE if there's no path to blend along, or the point-on-path function fails See also: - Definition at line 7430 of file nodebldr.cpp. { ERROR2IF(pPoint == NULL,FALSE,"NULL coord ptr"); BOOL ok = FALSE; NodeBlendPath* pNodeBlendPath = GetNodeBlendPath(); if (pNodeBlendPath) { double PropStart = GetProportionOfPathDistStart(); double PropEnd = GetProportionOfPathDistEnd(); double PathLen = pNodeBlendPath->GetPathLength(); double PropLen = PropEnd-PropStart; double PathLenOffset = PathLen*PropStart; double Tangent = 0.0; MILLIPOINT Dist = MILLIPOINT(((PathLen*PropLen) * BlendRatio)+PathLenOffset); ok = pNodeBlendPath->GetPointAtDistance(Dist,pPoint,&Tangent); if (ok && pAngle) { if (IsTangential()) *pAngle = Tangent/PI*180; else *pAngle = 0.0; } } return ok; }

double NodeBlender::GetProportionOfPathDistEnd (   )

Definition at line 7515 of file nodebldr.cpp. { if (m_ProportionOfPathDistEnd < 0.0) return 1.0; return m_ProportionOfPathDistEnd; }

double NodeBlender::GetProportionOfPathDistStart (   )

Definition at line 7509 of file nodebldr.cpp. { if (m_ProportionOfPathDistStart < 0.0) return 0.0; return m_ProportionOfPathDistStart; }

Trans2DMatrix * NodeBlender::GetRotateMatrix (  NodeRenderableBounded *  pNode, double  Angle )

Function that returns a matrix that will rotate around the centre of the bounds of the given node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 25/5/99 Parameters: pNode  = the node who's bounds define the centre of rotation [INPUTS] Angle = Angle to rotate by, in degrees -  [OUTPUTS] Returns: ptr to the matrix that will perform the rotation or NULL if no rotation is necessary (i.e. Angle % 360.0 == 0.0) See also: - Definition at line 1527 of file nodebldr.cpp. { Trans2DMatrix* pMatrix = NULL; if (pNode != NULL && fmod(Angle,360.0) != 0.0) { DocRect BoundsStart = pNode->GetBoundingRect(); DocCoord Centre = BoundsStart.Centre(); pMatrix = new Trans2DMatrix(Centre,Angle); } return pMatrix; }

DocRect NodeBlender::GetUnionBlendedBounds (  DocRect &  BoundsStart, DocRect &  BoundsEnd )

Finds the blended bounds that lies at point BlendRatio and tests for intersection. Takes into account the path the blend is following, if it has one. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The union of blended bounds. See also: - Definition at line 1556 of file nodebldr.cpp. { DocRect UnionBlendedBounds(0,0,0,0); UINT32 NumBlendSteps = GetNumBlendSteps(); double BlendRatio = 0.0; double BlendRatioStep = 1.0/(NumBlendSteps+1); for (UINT32 BlendStep = 1; BlendStep <= NumBlendSteps; BlendStep++) { // Calc the blend ratio using the current blend step BlendRatio = BlendRatioStep * BlendStep; DocRect BlendedBounds = BlendBounds(BoundsStart,BoundsEnd,BlendRatio,TRUE); if (BlendStep == 1) UnionBlendedBounds = BlendedBounds; else UnionBlendedBounds = UnionBlendedBounds.Union(BlendedBounds); } return UnionBlendedBounds; }

PathVerb * NodeBlender::GetVerbArray (  UINT32  MinSize  )  [private]

Used to get an array you can write to. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/94 Parameters: MinSize  = min size the array should be [INPUTS] -  [OUTPUTS] Returns: Ptr to the array, or NULL if can't get memory See also: - Definition at line 3847 of file nodebldr.cpp. { MinSize++; if (m_TempArraySize >= MinSize) return m_pTempVerbs; if (ReallocTempBuffers(MinSize)) return m_pTempVerbs; else return NULL; }

BOOL NodeBlender::HidingNode (   )  [virtual]

Called whenever the node gets hidden. It calls the Deinit() member function. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Reimplemented from Node. Definition at line 631 of file nodebldr.cpp. { PostBlend(); Deinit(); return TRUE; }

BOOL NodeBlender::InitBlendRef (  NodeRenderableInk *  pNode, BlendRef **  ppRef, INT32  Index, UndoableOperation *  pUndoOp, Progress *  pProgress, BOOL  IgnoreEscape, Trans2DMatrix *  pMatrix )  [private]

This creates and initialises a blend reference. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: pNode  = ptr to a node in the tree [INPUTS] ppRef = ptr to place to store a new BlendRef structure Index = index into path of blob clicked on (-1 means ignore) pUndoOp = ptr to an undoable op so that initialisation can be done in an undoable way (can be NULL) pProgress = ptr to progress object for maintaining hour glass IgnoreEscape= TRUE if you don't want this process abortable via the Escape key pMatrix = transformation to apply to each blend path (can be NULL) *ppRef  = ptr to an initialised blend reference [OUTPUTS] Returns: TRUE if successfully initialises, FALSE otherwise Definition at line 3158 of file nodebldr.cpp. { ERROR2IF(ppRef == NULL,FALSE,"ppRef == NULL"); ALLOC_WITH_FAIL(*ppRef,new BlendRef,pUndoOp); BOOL ok = (*ppRef != NULL); if (ok) ok = (*ppRef)->Initialise(pNode,Index,pUndoOp,pProgress,IgnoreEscape,pMatrix); return (ok); }

BOOL NodeBlender::Initialise (  NodeRenderableInk *  pThisNodeStart, NodeRenderableInk *  pThisNodeEnd, INT32  ThisPathIndexStart, INT32  ThisPathIndexEnd, UndoableOperation *  pUndoOp, Progress *  pProgress, BOOL  IgnoreEscape )

This initialises the blender node so that it is in a state in which it can blend the two nodes together. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: pNodeStart  = ptr to the start of the blend (can be NULL - see later) [INPUTS] pNodeEnd = ptr to the end of the blend (can be NULL - see later) ThisPathIndexStart = the index into the start path of the blob the user blended from (-1 means none) ThisPathIndexEnd = the index into the end path of the blob the user blended to (-1 means none) pUndoOp = ptr to an undoable op so that initialisation can be done in an undoable way (can be NULL) pProgress = ptr to progress object for maintaining hour glass IgnoreEscape = TRUE if you don't want this process abortable via the Escape key -  [OUTPUTS] Returns: TRUE if successfully initialises, FALSE otherwise This should be called AFTER this NodeBlender and its start and end nodes have been placed under the corresponding NodeBlend node. This is so that it can get a reference to the nodes relative to the parent NodeBlend node. If pNodeStart == NULL, then the previous node is chosen. If there isn't a previous node or the node is not a NodeRenderableInk, FALSE will be returned. If pNodeEnd == NULL, then the next node is chosen. If there isn't a next node or the node is not a NodeRenderableInk, FALSE will be returned. Definition at line 3037 of file nodebldr.cpp. { // Copy the ink node ptrs into member vars m_pNodeStart = pThisNodeStart; m_pNodeEnd = pThisNodeEnd; // Copy the path index params into member vars m_PathIndexStart = ThisPathIndexStart; m_PathIndexEnd = ThisPathIndexEnd; // If the ink nodes are NULL, search for appropriate ink nodes if (m_pNodeStart == NULL) m_pNodeStart = (NodeRenderableInk*)FindPrevious(); if (m_pNodeEnd == NULL) m_pNodeEnd = (NodeRenderableInk*)FindNext(); // Check the ink nodes ERROR2IF(m_pNodeStart == NULL,FALSE,"m_pNodeStart == NULL"); ERROR2IF(m_pNodeEnd == NULL,FALSE,"m_pNodeEnd == NULL"); ERROR2IF(!m_pNodeStart->IS_KIND_OF(NodeRenderableInk),FALSE,"m_pNodeStart not a NodeRenderableInk"); ERROR2IF(!m_pNodeEnd ->IS_KIND_OF(NodeRenderableInk),FALSE,"m_pNodeEnd not a NodeRenderableInk"); ERROR2IF(m_pNodeStart->IS_KIND_OF(NodeBlender),FALSE,"m_pNodeStart is a NodeBlender"); ERROR2IF(m_pNodeEnd ->IS_KIND_OF(NodeBlender),FALSE,"m_pNodeEnd not a NodeBlender"); // Delete old BlendRefs we may have (we might be reinitialising) DELPTR(m_pRefStart); DELPTR(m_pRefEnd); // Reset the member vars before we try and initialise the blender m_pRefStart = NULL; m_pRefEnd = NULL; m_ObjIndexStart = -1; m_ObjIndexEnd = -1; m_Initialised = FALSE; Trans2DMatrix* pRotateStart= NULL; Trans2DMatrix* pRotateEnd = NULL; if (GetNodeBlendPath() != NULL) { pRotateStart = GetRotateMatrix(m_pNodeStart,360.0 - m_AngleStart); pRotateEnd = GetRotateMatrix(m_pNodeEnd ,360.0 - m_AngleEnd ); } BOOL ok = TRUE; // CGS: we can have funky blends on paths. Everything works fine if they both have a path. // However, if they do NOT both have paths - then Mr Blender (incorrectly) blends the NodeBlendPath // into the paths generated by the other blend! // we SHOULD prevent this from happening .... if (ok) ok = InitBlendRef(m_pNodeStart,&m_pRefStart,m_PathIndexStart,pUndoOp,pProgress,IgnoreEscape,pRotateStart); if (ok) ok = InitBlendRef(m_pNodeEnd ,&m_pRefEnd ,m_PathIndexEnd ,pUndoOp,pProgress,IgnoreEscape,pRotateEnd); if (ok) { m_pRefStart->StripRedundantNodeBlendPaths (m_pRefEnd); } if (ok) ok = CalcObjIndex(m_pNodeStart,&m_ObjIndexStart); if (ok) ok = CalcObjIndex(m_pNodeEnd ,&m_ObjIndexEnd); // Ensure these indexes are kept up to date (needed for cut/copy/paste, export, etc). // Note that the following code dumps the indexes computed by the calls to InitBlendRef // above and recomputes them before assigning them to m_PathIndexStart and m_PathIndexEnd // (A lot of DoBecomeA work to compute two numbers...) if (((m_pRefStart->GetNumBlendPaths () > 1) && (m_pRefEnd->GetNumBlendPaths () == 1)) || ((m_pRefStart->GetNumBlendPaths () == 1) && (m_pRefEnd->GetNumBlendPaths () > 1))) { m_PathIndexStart = -1; m_PathIndexEnd = -1; DELPTR(m_pRefStart); DELPTR(m_pRefEnd); if (ok) ok = InitBlendRef(m_pNodeStart,&m_pRefStart,m_PathIndexStart,pUndoOp,pProgress,IgnoreEscape,pRotateStart); if (ok) ok = InitBlendRef(m_pNodeEnd ,&m_pRefEnd ,m_PathIndexEnd ,pUndoOp,pProgress,IgnoreEscape,pRotateEnd); if (ok) { m_pRefStart->StripRedundantNodeBlendPaths (m_pRefEnd); } } if (ok) m_PathIndexStart = m_pRefStart->GetOrigMapping(); if (ok) m_PathIndexEnd = m_pRefEnd ->GetOrigMapping(); // Make sure the Initialised flag is TRUE only if we have done everything successfully. if (ok) CheckFullyInitialised(); if (ok) ok = m_Initialised; DELPTR(pRotateStart); DELPTR(pRotateEnd); // Don't need to delete the BlendRefs if things go wrong. // They'll get deleted next time it's initialised, or by the deconstructor return (ok); }

BOOL NodeBlender::IsArtWorksEPSCompatible (   )

A blender is AW EPS compatible if ALL the following conditions are TRUE: 1) This node is between two path nodes. 2) The blender is blending the two path nodes it lies between 3) The two path nodes contain the same number of sub paths. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if this blender is AW compatible This is called by the parent blend's IsArtWorksEPSCompatible() func. Returns: Errors: Definition at line 7052 of file nodebldr.cpp. { ERROR2IF(m_pRefStart == NULL,FALSE,"m_pRefStart == NULL"); ERROR2IF(m_pRefEnd == NULL,FALSE,"m_pRefEnd == NULL"); Node* pPrevNode = FindPrevious(); Node* pNextNode = FindNext(); return (pPrevNode == m_pNodeStart && pNextNode == m_pNodeEnd && pPrevNode != NULL && pNextNode != NULL && IS_A(pPrevNode,NodePath) && IS_A(pNextNode,NodePath) && m_pRefStart->GetNumBlendPaths() == m_pRefEnd->GetNumBlendPaths()); }

BOOL NodeBlender::IsBlendedOnCurve (   )  [inline]

Definition at line 525 of file nodebldr.h. { return m_BlendedOnCurve;}

BOOL NodeBlender::IsComplex (   )

The blender is "complex" as far as AW EPS is concerned, if either the start path or the end path of the blend has more that one sub-path. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if this blender is complex Errors: Definition at line 7084 of file nodebldr.cpp. { ERROR2IF(m_pRefStart == NULL,FALSE,"m_pRefStart == NULL"); ERROR2IF(m_pRefEnd == NULL,FALSE,"m_pRefEnd == NULL"); return (m_pRefStart->GetAWComplex() || m_pRefEnd->GetAWComplex()); }

BOOL NodeBlender::IsNotAntialiased (   )

Gets the NotAntialiased state for this blender, by asking the parent blend node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The NotAntialiased flag state See also: - Definition at line 3582 of file nodebldr.cpp. { BOOL NotAntialiased = FALSE; NodeBlend* pNode = GetNodeBlend(); if (pNode != NULL) NotAntialiased = pNode->IsNotAntialiased(); else { ERROR3("Parent of blender is not there, or is not a NodeBlend!!!"); } return NotAntialiased; }

BOOL NodeBlender::IsOneToOne (   )

Gets the one-to-one blend mapping state for this blender, by asking the parent blend node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The one-to-one flag state See also: - Definition at line 3553 of file nodebldr.cpp. { BOOL OneToOne = FALSE; NodeBlend* pNode = GetNodeBlend(); if (pNode != NULL) OneToOne = pNode->IsOneToOne(); else { ERROR3("Parent of blender is not there, or is not a NodeBlend!!!"); } return OneToOne; }

BOOL NodeBlender::IsPointOverBlob (  DocCoord *  pPointerPos, BlendPath **  ppBlendPath, INT32 *  pIndex, BOOL *  pAStart )

This sees if the point given lies on a selected blob. If a match is found, the ptr to the blend path and index to blob element is returned. Also, if found,*pAStart = TRUE if it belongs to the start path, FALSE for the end path. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/11/94 Parameters: pPointerPos  = point to check against [INPUTS] ppBlendPath= ptr to place to store blend path ptr if a match is found pIndex = ptr to place to store index if match is found pAStart = ptr to place to store start or end flag *ppBlendPath  & *pIndex & *pAStart updated if TRUE returned, undefined otherwise [OUTPUTS] Returns: TRUE if match found, FALSE otherwise Markn 26-5-99: Modified so that if the function returns TRUE, *pPointerPos is updated so that it contains the coords of the blob it is over See also: - Definition at line 2956 of file nodebldr.cpp. { #if !defined(EXCLUDE_FROM_RALPH) if (m_pRefStart == NULL || m_pRefEnd == NULL || pPointerPos == NULL) return FALSE; BOOL Found = FALSE; if (m_pRefStart->GetNumBlendPaths() == 1 && m_pRefEnd->GetNumBlendPaths() == 1) { Trans2DMatrix* pRotateStart= NULL; Trans2DMatrix* pRotateEnd = NULL; if (GetNodeBlendPath() != NULL) { pRotateStart = GetRotateMatrix(m_pRefStart->GetNode(),m_AngleStart); pRotateEnd = GetRotateMatrix(m_pRefEnd ->GetNode(),m_AngleEnd ); } if (m_pRefStart->IsPointOverBlob(pPointerPos,ppBlendPath,pIndex,pRotateStart)) { Found = TRUE; *pAStart = TRUE; } if (m_pRefEnd->IsPointOverBlob(pPointerPos,ppBlendPath,pIndex,pRotateEnd)) { Found = TRUE; *pAStart = FALSE; } DELPTR(pRotateStart); DELPTR(pRotateEnd); } return Found; #else return FALSE; #endif }

BOOL NodeBlender::IsReversed (   )  [inline]

Definition at line 530 of file nodebldr.h. { return m_Reversed; }

BOOL NodeBlender::IsTangential (   )

See above. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/96 Parameters: -  [INPUTS] Returns: TRUE if this blend should follow the curve tangentially See also: - Definition at line 3610 of file nodebldr.cpp. { NodeBlend* pNode = GetNodeBlend(); if (pNode != NULL) return pNode->IsTangential(); return FALSE; }

Matrix NodeBlender::MakeMatrix (  BlendPath *  pBlendPathStart, BlendPath *  pBlendPathEnd, double  BlendRatio )  [private]

Makes the matrix for the transfrom that should be applied to blend paths and attributes. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> (clever bit by Mike) Date: 20/10/94 Parameters: pBlendPathStart  = ptr to blend path to blend from [INPUTS] pBlendPathEnd = ptr to blend path to blend to BlendRation = amount to blend by (0.0 <= BlendPath <= 1.0) -  [OUTPUTS] Returns: A matrix See also: - Definition at line 2271 of file nodebldr.cpp. { // Check entry params BOOL ok = (pBlendPathStart != NULL && pBlendPathEnd != NULL); if (ok) ok = (pBlendPathStart->GetCreatedByNode() != NULL && pBlendPathEnd->GetCreatedByNode() != NULL); ERROR3IF(!ok,"One or more NULL entry params"); if (!ok) { Matrix M; return M; } // Get the bounds of the objects that generated the paths DocRect BoundsStart = pBlendPathStart->GetCreatedByNode()->GetBoundingRect(TRUE); DocRect BoundsEnd = pBlendPathEnd ->GetCreatedByNode()->GetBoundingRect(TRUE); // The following creates a matrix that transforms the start rect to the end rect // dependent on the blend ratio, courtesy of Mike (thanks!) double Sx0 = BoundsStart.lo.x; double Sy0 = BoundsStart.lo.y; double Sx1 = BoundsStart.hi.x; double Sy1 = BoundsStart.hi.y; double Dx0 = BoundsEnd.lo.x; double Dy0 = BoundsEnd.lo.y; double Dx1 = BoundsEnd.hi.x; double Dy1 = BoundsEnd.hi.y; double Ex0 = Sx0 + BlendRatio*(Dx0-Sx0); double Ey0 = Sy0 + BlendRatio*(Dy0-Sy0); double Ex1 = Sx1 + BlendRatio*(Dx1-Sx1); double Ey1 = Sy1 + BlendRatio*(Dy1-Sy1); double t0 = (Ex1-Ex0)/(Sx1-Sx0); double t1 = 0; double t2 = 0; double t3 = (Ey1-Ey0)/(Sy1-Sy0); FIXED16 a(t0); FIXED16 b(t1); FIXED16 c(t2); FIXED16 d(t3); INT32 e = (INT32) (Ex0-Sx0*t0); INT32 f = (INT32) (Ey0-Sy0*t3); Matrix M(a,b,c,d,e,f); return (M); }

double NodeBlender::MapAttrBlendRatio (  double  BlendRatio  )  [private]

Function that works out what blend ratio to use when blending attributes Allows non-linear processing of blend attributes. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/6/99 Parameters: BlendRatio  - the linear blend ration, between 0.0 and 1.0 [INPUTS] Returns: The mapped blend ratio to use for attribute blending See also: NodePath::Render; NodeRenderableInk::RenderEorDrag Definition at line 2368 of file nodebldr.cpp. { NodeBlend* pNodeBlend = GetNodeBlend(); if (pNodeBlend) { IProfile* pProfile = pNodeBlend->GetAttrProfile(); if (pProfile) return pProfile->MapZeroToOne(BlendRatio); } return BlendRatio; }

double NodeBlender::MapObjectBlendRatio (  double  BlendRatio  )  [private]

Function that works out what blend ratio to use when creating a blended bath. Allows non-linear processing of blends. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/6/99 Parameters: BlendRatio  - the linear blend ration, between 0.0 and 1.0 [INPUTS] Returns: The mapped blend ratio to use for object blending See also: NodePath::Render; NodeRenderableInk::RenderEorDrag Definition at line 2341 of file nodebldr.cpp. { NodeBlend* pNodeBlend = GetNodeBlend(); if (pNodeBlend) { IProfile* pProfile = pNodeBlend->GetObjectProfile(); if (pProfile) return pProfile->MapZeroToOne(BlendRatio); } return BlendRatio; }

double NodeBlender::MapPositionBlendRatio (  double  BlendRatio  )  [private]

Function that works out what blend ratio to use when CMapPtrToPtr::iteratoring the blended shapes Allows non-linear processing of blend shape CMapPtrToPtr::iteratoring. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/6/99 Parameters: BlendRatio  - the linear blend ration, between 0.0 and 1.0 [INPUTS] Returns: The mapped blend ratio to use for CMapPtrToPtr::iteratoring the blended shapes See also: NodePath::Render; NodeRenderableInk::RenderEorDrag Definition at line 2395 of file nodebldr.cpp. { NodeBlend* pNodeBlend = GetNodeBlend(); if (pNodeBlend) { IProfile* pProfile = pNodeBlend->GetPositionProfile(); if (pProfile) return pProfile->MapZeroToOne(BlendRatio); } return BlendRatio; }

BOOL NodeBlender::OnClick (  DocCoord  PointerPos, ClickType  Click, ClickModifiers  ClickMods, Spread *  pSpread )  [virtual]

Allows the Node to respond to clicks by selecting its blobs or starting drags etc. This functions should be overridden in the all the NodeRenderableInk classes so that this version never gets called. Eg the NodePath class might claim the click if it happened over one of its unselected blobs. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: PointerPos  - The Location of the mouse pointer at the time of the click [INPUTS] Click - The type of click received (single, double, drag etc) ClickMods - The modifiers to the click (eg shift, control etc ) Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented from NodeRenderableInk. Definition at line 2714 of file nodebldr.cpp. { if (!Reinit()) return FALSE; // we did not use the click, so let someone else try return FALSE; }

void NodeBlender::PolyCopyNodeContents (  NodeRenderable *  pNodeCopy  )  [virtual]

Polymorphically copies the contents of this node to another. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/12/2003 Parameters: -  [OUTPUTS] Returns: Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Reimplemented from NodeRenderableBounded. Definition at line 458 of file nodebldr.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeBlender), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeBlender)) CopyNodeContents((NodeBlender*)pNodeCopy); }

void NodeBlender::PostBlend (   )  [private]

This should be called just after blending occurs. At the moment it does the following - Releases memory allocated for the temp path arrays. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 3740 of file nodebldr.cpp. { if (m_pRefStart != NULL) m_pRefStart->PostBlend(); if (m_pRefEnd != NULL) m_pRefEnd ->PostBlend(); DeallocTempBuffers(); }

BOOL NodeBlender::PreBlend (   )  [private]

This should be called just before blending occurs. At the moment it does the following - Initialises stuff so you can call GetCoordArray(), GetVerbArray() and GetFlagArray(). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if it's OK to continue, FALSE otherwise See also: - Definition at line 3713 of file nodebldr.cpp. { // Clean up in case PostBlend() wasn't called after the last PreBlend() call PostBlend(); if (m_pRefStart != NULL) m_pRefStart->PreBlend(); if (m_pRefEnd != NULL) m_pRefEnd ->PreBlend(); // Allocate the arrays return (ReallocTempBuffers(1000)); }

void NodeBlender::PreExportRender (  RenderRegion *  pRegion  )  [virtual]

Called before this node or any of its children have been rendered to the export region. This outputs the "start blender" command. Supports ArtWorks EPS and Camelot EPS. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 Parameters: pRegion  = ptr to the export render region to export to [INPUTS] [OUTPUTS]  Returns: Errors: Reimplemented from Node. Definition at line 6906 of file nodebldr.cpp. { #ifdef DO_EXPORT // Ensure that we are initialised (if it can be done!!) if (!Reinit()) return; if (pRegion->IS_KIND_OF(ArtWorksEPSRenderRegion)) { EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); if (IS_A(pRegion, CamelotEPSRenderRegion)) { // only want renderable stuff in EPS return; } else if (pRegion->IS_KIND_OF(NativeRenderRegion)) { // Output the Camelot format for blenders pDC->OutputValue(INT32(0)); // Reserved INT32 1 pDC->OutputValue(INT32(0)); // Reserved INT32 2 pDC->OutputValue(INT32(0)); // Reserved INT32 3 pDC->OutputValue(INT32(0)); // Reserved INT32 4 pDC->OutputValue(m_ObjIndexStart); // Index to object at start of blend pDC->OutputValue(m_ObjIndexEnd); // Index to object at end of blend pDC->OutputValue(m_PathIndexStart); // Path index to el num of start path pDC->OutputValue(m_PathIndexEnd); // Path index to el num of end path pDC->OutputToken(_T("csbr")); // Camelot "start blender" token pDC->OutputNewLine(); } else { NodeBlend* pNodeBlend = GetNodeBlend(); if (pNodeBlend != NULL) { if (pNodeBlend->IsArtWorksEPSCompatible()) { // Output the AW format for blenders, if this blender is ArtWorks-compatible pDC->OutputValue(INT32(0)); // Expanded flag pDC->OutputValue(INT32(IsComplex())); // Complex flag pDC->OutputValue(INT32(IsOneToOne())); // The OneToOne flag pDC->OutputValue(INT32(GetNumBlendSteps()+1)); // The number of blend steps (+1 for AW) pDC->OutputValue(GetAWStartPathIndex()); // Get start path index pDC->OutputValue(GetAWEndPathIndex()); // Get end path index pDC->OutputToken(_T("asbr")); // ArtWorks "start blender" token pDC->OutputNewLine(); // Blend is done return; } else { // Blend cannot be done as AW - just render intermediate shapes. Render(pRegion); } } else { ERROR3("Parent is not a NodeBlend"); } } } // These two lines will output the first pair of blendable paths - useful for testing //pRefStart->GetFirstBlendPath()->GetNodePath()->Render(pRegion); //pRefEnd ->GetFirstBlendPath()->GetNodePath()->Render(pRegion); #endif }

BOOL NodeBlender::ProcessBlendedPath (  DocCoord *  pCoords, PathVerb *  pVerbs, PathFlags *  pFlags, UINT32  Len, BOOL  Closed )  [static]

This does any processing necessary on the path generated by GBlend. The three arrays can be used to generate renderable paths, and also legal paths that can be used to create NodePath objects on the tree. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/11/94 Parameters: pCoords  = ptr to coords of the blended path [INPUTS] pVerbs = ptr to verbs of blended path pFlags = ptr to uninitialised flags array Len = num verbs in pVerbs Closed = The resultant path should be closed pCoords  array contains a valid set of coords [OUTPUTS] pVerbs array contains a valid set of verbs pFlags array contains valid flags for each of the verbs in pVerbs Returns: TRUE if OK, FALSE if it goes bang See also: - Definition at line 2190 of file nodebldr.cpp. { if (Len < 1) return FALSE; // Generate a legal path flags array SetPathFlags(pVerbs,pFlags,Len); // If closed, make sure there's a PT_CLOSEFIGURE on the last end point if (Closed) pVerbs[Len-1] = pVerbs[Len-1] | PT_CLOSEFIGURE; return TRUE; }

BOOL NodeBlender::ReallocTempBuffers (  UINT32  Size  )  [private]

Allocates memory for the temp path arrays, and sets the size var to 0 You can use calls to GetCoordArray(), GetVerbArray() and GetFlagArray() to get the alloced arrays. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/11/94 Parameters: Size  = Size the temp arrays should be [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 3762 of file nodebldr.cpp. { DeallocTempBuffers(); // Allocate the arrays m_TempArraySize = Size; m_pTempCoords = (DocCoord*) CCMalloc(Size*sizeof(DocCoord)); m_pTempVerbs = (PathVerb*) CCMalloc(Size*sizeof(PathVerb)); m_pTempFlags = (PathFlags*) CCMalloc(Size*sizeof(PathFlags)); // If any of the arrays are not allocated, dealloc the alloced ones, and return FALSE if (m_pTempCoords == NULL || m_pTempVerbs == NULL || m_pTempFlags == NULL) { DeallocTempBuffers(); return FALSE; } // It's all OK, so return TRUE return TRUE; }

BOOL NodeBlender::Reinit (  NodeRenderableInk *  pInkNodeStart = NULL, NodeRenderableInk *  pInkNodeEnd = NULL, BOOL  ProgressBar = TRUE )

This will try and reinitialise the blender by using either the relative reference values ObjIndexStart and ObjIndexEnd (if input params are NULL) or the nodes provided. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 adjusted Diccon Yamanaka 16/9/99 Parameters: pInkNodeStart  = ptr to the node to blend from (can be NULL) [INPUTS] pInkNodeEnd = ptr to the node to blend to (can be NULL) ProgressBar = if TRUE a progress bar will be displayed. -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise If using the indexes, it finds the actual pointers to the nodes that they reference, and calls Initialise() If already initialised, it returns TRUE immediately See also: - Definition at line 3380 of file nodebldr.cpp. { if (GetNodeBlend()) { CProfileBiasGain* pObjProfile = GetNodeBlend()->GetObjectProfile(); if (pObjProfile) { // this ensures that blend object profile processing is ON if we need it .... GetNodeBlend()->RequestObjectProfileProcessing(TRUE); } } if (m_Initialised) return TRUE; /* Diccon 9/99 changes to permit blending between two blends using arbitrary start and end points mean that NodeBlenders are no longer necessarily CMapPtrToPtr::iteratored in between the two nodes that they are blending. This means that the third method of finding start and end nodes is now likely to yield incorrect results, with the sole exception of when you are loading an old format file */ if (pInkNodeStart == NULL) pInkNodeStart = m_pNodeStart; if (pInkNodeEnd == NULL) pInkNodeEnd = m_pNodeEnd; // If still no start and end node, use the ObjIndex value to find them if (pInkNodeStart == NULL && m_ObjIndexStart >= 0) pInkNodeStart = FindObjIndexedNode(m_ObjIndexStart); if (pInkNodeEnd == NULL && m_ObjIndexEnd >= 0) pInkNodeEnd = FindObjIndexedNode(m_ObjIndexEnd); // the only time we should be using this method is if we are loading old format files with blends in them if (pInkNodeStart == NULL) pInkNodeStart = (NodeRenderableInk*)FindPrevious(CC_RUNTIME_CLASS(NodeRenderableInk)); if (pInkNodeEnd == NULL) pInkNodeEnd = (NodeRenderableInk*)FindNext(CC_RUNTIME_CLASS(NodeRenderableInk)); while (pInkNodeEnd->IS_KIND_OF(NodeBlendPath)) pInkNodeEnd = (NodeRenderableInk*)pInkNodeEnd->FindNext(CC_RUNTIME_CLASS(NodeRenderableInk)); // In debug builds, inform the user, as something's gone wrong ERROR3IF(pInkNodeStart == NULL,"pInkNodeStart is NULL"); ERROR3IF(pInkNodeEnd == NULL,"pInkNodeEnd is NULL"); if (pInkNodeStart == NULL || pInkNodeEnd == NULL) return TRUE; if (ProgressBar) { Progress Hourglass(_R(IDS_REINTBLEND)); return (Initialise(pInkNodeStart,pInkNodeEnd,m_PathIndexStart,m_PathIndexEnd,NULL,&Hourglass,TRUE)); } else return (Initialise(pInkNodeStart,pInkNodeEnd,m_PathIndexStart,m_PathIndexEnd,NULL,NULL,TRUE)); }

BOOL NodeBlender::Remap (  DocCoord  PosStart, DocCoord  PosEnd, DocCoord *  pInvPosStart, DocCoord *  pInvPosEnd )

If this blender manages to remap a pair of blend paths, then this will return TRUE. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/11/94 Parameters: PosStart  = Coord of element to remap start node to [INPUTS] PosEnd = Coord of element to remap end node to pInvPosStart= ptr to place to put the coord to use to invert the start mapping pInvPosEnd = ptr to place to put the coord to use to invert the end mapping -  [OUTPUTS] Returns: TRUE if remapped, FALSE otherwise See also: - Definition at line 3932 of file nodebldr.cpp. { BOOL Mapped = FALSE; if (m_pRefStart != NULL && m_pRefEnd != NULL) { BlendPath* pBlendPathStart = m_pRefStart->GetFirstBlendPath(); BlendPath* pBlendPathEnd = m_pRefEnd ->GetFirstBlendPath(); if (pBlendPathStart != NULL && pBlendPathEnd != NULL) { if (GetNodeBlendPath() != NULL) { Trans2DMatrix* pRotateStart = GetRotateMatrix(m_pRefStart->GetNode(),360.0 - m_AngleStart); Trans2DMatrix* pRotateEnd = GetRotateMatrix(m_pRefEnd ->GetNode(),360.0 - m_AngleEnd ); if (pRotateStart) pRotateStart->Transform(&PosStart,1); if (pRotateEnd) pRotateEnd ->Transform(&PosEnd ,1); DELPTR(pRotateStart); DELPTR(pRotateEnd); } *pInvPosStart = pBlendPathStart->MapPath(PosStart); *pInvPosEnd = pBlendPathEnd ->MapPath(PosEnd); Mapped = TRUE; if (GetNodeBlendPath() != NULL) { Trans2DMatrix* pRotateStart = GetRotateMatrix(m_pRefStart->GetNode(),m_AngleStart); Trans2DMatrix* pRotateEnd = GetRotateMatrix(m_pRefEnd ->GetNode(),m_AngleEnd ); if (pRotateStart) pRotateStart->Transform(pInvPosStart,1); if (pRotateEnd) pRotateEnd ->Transform(pInvPosEnd ,1); DELPTR(pRotateStart); DELPTR(pRotateEnd); } } // Keep the path mapping index up to date (necessary for cut/copy/paste, export, etc). m_PathIndexStart = m_pRefStart->GetOrigMapping(); m_PathIndexEnd = m_pRefEnd ->GetOrigMapping(); } return Mapped; }

void NodeBlender::Render (  RenderRegion *  pRender  )  [virtual]

Will render the blended steps of this blender node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: Pointer  to a render region [INPUTS] Reimplemented from Node. Definition at line 668 of file nodebldr.cpp. { pRender->SaveContext(); CreateBlends(pRender,NULL); // Only supply a render region, because we're only rendering pRender->RestoreContext(); }

void NodeBlender::RenderAttributes (  RenderRegion *  pRender, CCAttrMap *  pAttrMap )  [private]

Renders the attributes to the given render region. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/94 Parameters: pRender  = ptr to render region [INPUTS] pAttrMap = ptr to map of ttributes -  [OUTPUTS] Returns: - See also: - Definition at line 1595 of file nodebldr.cpp. { // Check entry params BOOL ok = (pRender != NULL && pAttrMap != NULL); ERROR3IF(!ok,"One or more NULL entry params"); if (!ok) return; CCRuntimeClass* pType; void* pVal; // iterating all (key, value) pairs for (CMapPtrToPtr::iterator Pos = pAttrMap->GetStartPosition(); Pos != pAttrMap->GetEndPosition();) { // Get attr at CMapPtrToPtr::iterator Pos pAttrMap->GetNextAssoc(Pos,pType,pVal); // Don't render quality attributes, to ensure steps are rendered with the same quality // as the start and end objects. if (pType != CC_RUNTIME_CLASS(AttrQuality)) { // pVal is actually an attribute, so get a ptr to it and render it NodeAttribute* pNodeAttr = (NodeAttribute *)pVal; // *********+**** BODGE (removed 1/12/94) **************** // Ignore these two attrs until I get Wills attr changes, involving unimplemented Restore() funcs // if (!pNodeAttr->IS_KIND_OF(AttrDashPattern) && !pNodeAttr->IS_KIND_OF(AttrTranspFillMapping)) // pNodeAttr->Render(pRender); if (pNodeAttr->IsABrush()) { //TRACEUSER( "Diccon", _T("Blend step %d, rendering Brush\n"), m_BlendStep); PathProcessor* pPathProc = pRender->GetFirstPathProcessor(); if (pPathProc != NULL && pPathProc->IsAPathProcessorBrush()) continue; } pNodeAttr->Render(pRender); } } }

void NodeBlender::RenderBlendBlobs (  RenderRegion *  pRender, BOOL  RenderStart, BOOL  RenderEnd )  [virtual]

Renders the blobs of the blend paths associated with the given blender NOTE: This only renders blobs if there's only one blend path in both the start and the end of the blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/11/94 Parameters: pRender  = region to render blobs into [INPUTS] RenderStart = TRUE if blobs of start of blend should be rendered RenderEnd = TRUE if blobs of end of blend should be rendered -  [OUTPUTS] Returns: - See also: - Definition at line 2505 of file nodebldr.cpp. { #if !defined(EXCLUDE_FROM_RALPH) if (!Reinit()) return; if (m_pRefStart == NULL || m_pRefEnd == NULL) return; if (m_pRefStart->GetNumBlendPaths() == 1 && m_pRefEnd->GetNumBlendPaths() == 1) { Trans2DMatrix* pRotateStart= NULL; Trans2DMatrix* pRotateEnd = NULL; if (GetNodeBlendPath() != NULL) { pRotateStart = GetRotateMatrix(m_pRefStart->GetNode(),m_AngleStart); pRotateEnd = GetRotateMatrix(m_pRefEnd ->GetNode(),m_AngleEnd ); } if (RenderStart) m_pRefStart->RenderBlendBlobs(pRender,pRotateStart); if (RenderEnd) m_pRefEnd ->RenderBlendBlobs(pRender,pRotateEnd); BlendPath* pBlendPathStart = m_pRefStart->GetFirstBlendPath(); BlendPath* pBlendPathEnd = m_pRefEnd ->GetFirstBlendPath(); if (pBlendPathStart != NULL && pBlendPathEnd != NULL) { DocCoord Start = pBlendPathStart->GetPathCoord(0); DocCoord End = pBlendPathEnd ->GetPathCoord(0); if (pRotateStart) pRotateStart->Transform(&Start,1); if (pRotateEnd) pRotateEnd ->Transform(&End ,1); // Get the scaled pixel size for the view FIXED16 ScaledPixelWidth, ScaledPixelHeight; // Not used pRender->GetRenderView()->GetScaledPixelSize(&ScaledPixelWidth, &ScaledPixelHeight); pRender->SetLineWidth((ScaledPixelWidth.MakeLong())*2); pRender->SetLineColour(COLOUR_BLACK); pRender->DrawLine(Start,End); } DELPTR(pRotateStart); DELPTR(pRotateEnd); } #endif }

void NodeBlender::RenderEorDrag (  RenderRegion *  pRender  )  [virtual]

Renders a version of the blender node for EORed dragging of blends. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: pRender  - A Pointer to the current RenderRegion [INPUTS] See also: NodePath::Render; NodeRenderableInk::RenderEorDrag Reimplemented from NodeRenderableInk. Definition at line 2482 of file nodebldr.cpp. { if (!Reinit()) return; }

void NodeBlender::ResetVars (   )  [private]

Resets all the member vars to default values. Should only be called by NodeBlender constructors. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/11/94 Definition at line 353 of file nodebldr.cpp. { m_pRefStart = NULL; m_pRefEnd = NULL; m_pNodeStart = NULL; m_pNodeEnd = NULL; m_ObjIndexStart = -1; m_ObjIndexEnd = -1; m_PathIndexStart = -1; m_PathIndexEnd = -1; m_Initialised = FALSE; m_TempArraySize = 0; m_pTempCoords = NULL; m_pTempVerbs = NULL; m_pTempFlags = NULL; m_GBlendBuffSize = 0; m_pGBlendBuff = NULL; m_ProportionOfPathDistStart = -1.0; m_ProportionOfPathDistEnd = -1.0; m_AngleStart = 0.0; m_AngleEnd = 0.0; m_Reversed = FALSE; m_BlendedOnCurve = FALSE; m_NodeBlendPathIndex = -2; //-2 to deal with the case of the previous file format - see // HandleBlendPathRecord for details }

BOOL NodeBlender::ReverseEnds (   )

reverses the blend so that the start node becomes the end node and vice versa Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 29/9/99 Parameters: -  [INPUTS] Returns: TRUE if successfull, FALSE otherwise See also: - Definition at line 3680 of file nodebldr.cpp. { NodeRenderableInk* pTemp = NULL; pTemp = m_pNodeStart; m_pNodeStart = m_pNodeEnd; m_pNodeEnd = pTemp; SetReversed(!IsReversed()); INT32 Temp = m_ObjIndexStart; m_ObjIndexStart = m_ObjIndexEnd; m_ObjIndexEnd = Temp; return TRUE; }

void NodeBlender::ReversePath (  DocCoord *  pCoords, PathVerb *  pVerbs, UINT32  Len )  [static]

This will reverse the path definition given in the two arrays. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 24/1/96 Parameters: pCoords  = ptr to coords array [INPUTS] pVerbs = ptr to verbs array Len = the length of above arrays -  [OUTPUTS] Returns: - Path flags are not delt with as these are specific to the Path class. This function is designed to process raw paths returned from Gavin. See also: - Definition at line 2012 of file nodebldr.cpp. { // First we will reverse all the Coords UINT32 LastPos = Len-1; UINT32 FirstPos = 0; while (FirstPos<LastPos) { SWAP(DocCoord,pCoords[FirstPos],pCoords[LastPos]); // change the order of the coords in the array // find the next two coords to swap FirstPos++; LastPos--; } // Now reverse the verbs. // The first verb always stays as a MoveTo and everything else gets sorted around it FirstPos = 1; LastPos = Len-1; while (FirstPos<LastPos) { SWAP(PathVerb,pVerbs[FirstPos],pVerbs[LastPos]); // Find the next two verbs to swap FirstPos++; LastPos--; } }

void NodeBlender::RotateBounds (  DocRect &  Bounds, double  Angle )

The bounds are updated to contain the rotated version. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/99 Parameters: Bounds  = the bounds to rotate [INPUTS] Angle = the angle in degrees by which to rotate it by -  [OUTPUTS] Returns: - See also: - Definition at line 1488 of file nodebldr.cpp. { if (Angle != 0.0) { DocCoord BBCentre = Bounds.Centre(); DocCoord Coords[4]; Coords[0].x = Bounds.lo.x; Coords[0].y = Bounds.lo.y; Coords[1].x = Bounds.hi.x; Coords[1].y = Bounds.lo.y; Coords[2].x = Bounds.hi.x; Coords[2].y = Bounds.hi.y; Coords[3].x = Bounds.lo.x; Coords[3].y = Bounds.hi.y; Trans2DMatrix Rotate(BBCentre,Angle); Rotate.Transform(Coords,4); Bounds.lo.x = min(min(Coords[0].x,Coords[1].x), min(Coords[2].x,Coords[3].x)); Bounds.hi.x = max(max(Coords[0].x,Coords[1].x), max(Coords[2].x,Coords[3].x)); Bounds.lo.y = min(min(Coords[0].y,Coords[1].y), min(Coords[2].y,Coords[3].y)); Bounds.hi.y = max(max(Coords[0].y,Coords[1].y), max(Coords[2].y,Coords[3].y)); } }

void NodeBlender::SetAngleEnd (  double  Angle  )

Definition at line 7553 of file nodebldr.cpp. { m_AngleEnd = fmod(Angle,360.0); }

void NodeBlender::SetAngleStart (  double  Angle  )

Definition at line 7548 of file nodebldr.cpp. { m_AngleStart = fmod(Angle,360.0); }

void NodeBlender::SetBlendedOnCurve (  BOOL  value  )  [inline]

Definition at line 524 of file nodebldr.h. { m_BlendedOnCurve = value;}

void NodeBlender::SetNodeBlendPathIndex (  INT32  Index  )

See above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/99 Parameters: the  index to the nodeblendpath to which this blender refers, or -1 [INPUTS] if it is not on a curve Returns: - See also: - Definition at line 3654 of file nodebldr.cpp. { if (Index < -2) { ERROR3("Invalid index value"); return; } m_NodeBlendPathIndex = Index; return; }

void NodeBlender::SetObjIndexEnd (  INT32  ObjIndex  )  [inline]

Definition at line 483 of file nodebldr.h. { m_ObjIndexEnd = ObjIndex; }

void NodeBlender::SetObjIndexStart (  INT32  ObjIndex  )  [inline]

Definition at line 482 of file nodebldr.h. { m_ObjIndexStart = ObjIndex; }

void NodeBlender::SetPathFlags (  PathVerb *  pVerbs, PathFlags *  pFlags, UINT32  Len )  [static]

This generates a legal path flags array based on the given verbs. All it does is set the end point flags correctly, leaving all other flags FALSE. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/11/94 Parameters: pVerbs  = ptr to path verbs [INPUTS] pFlags = ptr to flags Len = num verbs in pVerbs pFlags  array contains valid flags for each of the verbs in pVerbs [OUTPUTS] Returns: - See also: - Definition at line 2222 of file nodebldr.cpp. { UINT32 n; // Reset all the path flags to default values PathFlags DefaultPathFlags; for (n=0; n < Len; n++) pFlags[n] = DefaultPathFlags; // Scan the verbs, so that the end point flags can be set correctly for (n=0; n < Len; n++) { PathVerb Verb = pVerbs[n] & ~PT_CLOSEFIGURE; switch (Verb) { case PT_LINETO: case PT_MOVETO: pFlags[n].IsEndPoint = TRUE; break; case PT_BEZIERTO: n += 2; ERROR3IF(n>=Len,"Found a PT_BEZIERTO, but third pt is off the end of the array"); pFlags[n].IsEndPoint = TRUE; break; default: ERROR3_PF(("Illegal path verb found : %c",Verb)); break; } } }

void NodeBlender::SetPathIndexEnd (  INT32  Index  )  [inline]

Definition at line 476 of file nodebldr.h. { m_PathIndexEnd = Index; }

void NodeBlender::SetPathIndexStart (  INT32  Index  )  [inline]

Definition at line 475 of file nodebldr.h. { m_PathIndexStart = Index; }

void NodeBlender::SetProportionOfPathDistEnd (  double  p  )

Definition at line 7529 of file nodebldr.cpp. { if (p < 0.0) p = 0.0; if (p > 1.0) p = 1.0; if (p < GetProportionOfPathDistStart()) p = GetProportionOfPathDistStart(); m_ProportionOfPathDistEnd = p; }

void NodeBlender::SetProportionOfPathDistStart (  double  p  )

Definition at line 7521 of file nodebldr.cpp. { if (p < 0.0) p = 0.0; if (p > 1.0) p = 1.0; if (p > GetProportionOfPathDistEnd()) p = GetProportionOfPathDistEnd(); m_ProportionOfPathDistStart = p; }

void NodeBlender::SetReversed (  BOOL  value  )  [inline]

Definition at line 529 of file nodebldr.h. { m_Reversed = m_BlendedOnCurve ? value : FALSE; }

void NodeBlender::SetUninitialised (   )  [inline]

Definition at line 522 of file nodebldr.h. { m_Initialised = FALSE;}

BOOL NodeBlender::ShowingNode (   )  [virtual]

Called whenever the node gets shown after it's been hidden. It calls the Reinit() member function. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Reimplemented from Node. Definition at line 651 of file nodebldr.cpp. { return TRUE; // return (Reinit()); }

Node * NodeBlender::SimpleCopy (  void   )  [virtual]

Makes a copy of all the data in the node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Returns: Pointer to a Node Reimplemented from NodeRenderableInk. Definition at line 396 of file nodebldr.cpp. { // Make a new NodeBlender and then copy things into it NodeBlender* pCopyOfNode = new NodeBlender(); if (pCopyOfNode) CopyNodeContents(pCopyOfNode); return pCopyOfNode; }

BOOL NodeBlender::Snap (  DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )  [virtual]

Snaps the given rect to the nearest CMapPtrToPtr::iterator on the grid, preserving its width and height. The coords of the rect used for the snapping are determined by the PrevCoord and CurCoord coords supplied. This is done to allow the user to control how a selection rectangle is snapped to the grid by the direction of his/her last mouse movement. To force the bottom left hand corner of the rect to be snapped, supply PrevCoord=(0,0) and CurCoord(-1,-1). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: pDocCoord  - the rectangle to snap [INPUTS] StartDrag - Start coord of drag EndDrag - End coord of drag [OUTPUTS]  Returns: TRUE - the DocRect been snapped. FALSE - the DocRect has not been processed. ALWAYS RETURNS FALSE currently. Scope: public Reimplemented from NodeRenderableBounded. Definition at line 2929 of file nodebldr.cpp. { return FALSE; }

BOOL NodeBlender::Snap (  DocCoord *  pDocCoord  )  [virtual]

Snaps to given coord to the nearest point on the blender node. Just returns FALSE currently. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: pDocCoord  = a coord in Spread coords [INPUTS] [OUTPUTS]  Returns: TRUE - the DocCoord has been snapped . FALSE - the DocCoord has not been processed. Errors: Scope: public Reimplemented from NodeRenderableBounded. Definition at line 2896 of file nodebldr.cpp. { return FALSE; }

void NodeBlender::Transform (  TransformBase &  Trans  )  [virtual]

Transforms all the paths attached to this blender node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: Trans  - The transform Object [INPUTS] See also: NodeRenderableInk::Transform() Reimplemented from NodeRenderableBounded. Definition at line 600 of file nodebldr.cpp. { InvalidateBoundingRect(); Deinit(); /* if (!Initialised) return; // The blender's bounding rect is no longer valid InvalidateBoundingRect(); // Transform all the BlendPaths in the two blend references if (pRefStart != NULL) pRefStart->Transform(Trans); if (pRefEnd != NULL) pRefEnd ->Transform(Trans); */ }

void NodeBlender::UpdateBlendStartAngles (  Trans2DMatrix &  trans  )

Updates a blend on curves start angles after we have rotated the blend. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 25/7/2000 Parameters: trans  = the transformation matrix [INPUTS] -  [OUTPUTS] Returns: - See also: - NOTE: If problems arise the function should be modified to store undo information. However at present, this seems to be generated for us somewhere else; which is fine by me. Definition at line 2058 of file nodebldr.cpp. { // only update if these are non-zero if ((m_AngleStart != 0.0 || m_AngleEnd != 0.0)) { double ang = (trans.GetRotation ()).MakeDouble (); m_AngleStart += ang; m_AngleEnd += ang; } }

BOOL NodeBlender::WriteBeginChildRecordsNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Begins the child record sequence for the blender. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/99 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE ok, FALSE otherwise Blenders need to write out curve CMapPtrToPtr::iteratoring information if the blend is on a curve See also: WritePreChildrenNative() Reimplemented from NodeRenderableInk. Definition at line 7256 of file nodebldr.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); if (GetNodeBlendPath() == NULL) return NodeRenderableInk::WriteBeginChildRecordsNative(pFilter); // First thing to do is write out the Down record BOOL ok = (pFilter->WriteZeroSizedRecord(TAG_DOWN)); // Write out the blender's curve CMapPtrToPtr::iterator proportions { CamelotFileRecord PropRec(pFilter,TAG_BLENDER_CURVEPROP,TAG_BLENDER_CURVEPROP_SIZE); if (ok) ok = PropRec.Init(); if (ok) ok = PropRec.WriteDOUBLE(m_ProportionOfPathDistStart); if (ok) ok = PropRec.WriteDOUBLE(m_ProportionOfPathDistEnd); if (ok) ok = pFilter->Write(&PropRec); } // Write out the blender's curve angles if (m_AngleStart != 0.0 || m_AngleEnd != 0.0) { CamelotFileRecord AngleRec(pFilter,TAG_BLENDER_CURVEANGLES,TAG_BLENDER_CURVEANGLES_SIZE); if (ok) ok = AngleRec.Init(); if (ok) ok = AngleRec.WriteDOUBLE(m_AngleStart); if (ok) ok = AngleRec.WriteDOUBLE(m_AngleEnd); if (ok) ok = pFilter->Write(&AngleRec); } return ok; #else return TRUE; #endif //DO_EXPORT }

BOOL NodeBlender::WriteBeginChildRecordsWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Same as the Native version. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/99 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE ok, FALSE otherwise See also: WritePreChildrenNative() Reimplemented from NodeRenderableInk. Definition at line 7338 of file nodebldr.cpp. { return WriteBeginChildRecordsNative(pFilter); }

virtual BOOL NodeBlender::WriteBoundsRecord (  BaseCamelotFilter *  pFilter  )  [inline, virtual]

Write out a record containing the bounds of this object. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/05 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise Reimplemented from NodeRenderableInk. Definition at line 496 of file nodebldr.h. { return(TRUE); }

BOOL NodeBlender::WriteEndChildRecordsNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Ends the child record sequence for the blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/99 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE ok, FALSE otherwise Only does anything if the blend is on a curve See also: WritePreChildrenNative() Reimplemented from NodeRenderableInk. Definition at line 7309 of file nodebldr.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); if (GetNodeBlendPath() == NULL) return NodeRenderableInk::WriteEndChildRecordsNative(pFilter); return pFilter->WriteZeroSizedRecord(TAG_UP); #else return FALSE; #endif }

BOOL NodeBlender::WriteEndChildRecordsWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Same as the Native version. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/99 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE ok, FALSE otherwise See also: WritePreChildrenNative() Reimplemented from NodeRenderableInk. Definition at line 7358 of file nodebldr.cpp. { return WriteEndChildRecordsNative(pFilter); }

BOOL NodeBlender::WritePreChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Reimplemented from Node. Definition at line 7230 of file nodebldr.cpp. { #ifdef DO_EXPORT return WritePreChildrenWeb(pFilter); #else return FALSE; #endif }

BOOL NodeBlender::WritePreChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes the blender record to the filter. > virtual BOOL NodeBlender::WritePreChildrenWeb(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 30/5/96 Parameters: pFilter  = ptr to the filter [INPUTS] Returns: TRUE if record is written, FALSE if not See also: - Reimplemented from Node. Definition at line 7181 of file nodebldr.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); BOOL ok = TRUE; CXaraFileRecord Rec(TAG_BLENDER,TAG_BLENDER_SIZE); if (ok) ok = Rec.Init(); if (ok) ok = Rec.WriteINT32(m_PathIndexStart); if (ok) ok = Rec.WriteINT32(m_PathIndexEnd); if (ok) ok = pFilter->Write(&Rec); // Diccon 9/99 added extra record CXaraFileRecord Additional(TAG_BLENDERADDITIONAL, TAG_BLENDERADDITIONAL_SIZE); if (ok) ok = Additional.Init(); if (ok) ok = Additional.WriteINT32(m_BlendedOnCurve); if (ok) { if (m_NodeBlendPathIndex == -2) ok = Additional.WriteINT32(-1); else ok = Additional.WriteINT32(m_NodeBlendPathIndex); } if (ok) ok = Additional.WriteINT32(m_ObjIndexStart); if (ok) ok = Additional.WriteINT32(m_ObjIndexEnd); // Karim 05/02/2001 // Extra bitfield tacked onto the end of the record. // Currently this stores only our reversed-on-path flag. if (ok) { BYTE BitField = IsReversed() ? 1 : 0; ok = Additional.WriteBYTE(BitField); } if (ok) ok = pFilter->Write(&Additional); return ok; #else return FALSE; #endif }

---

Member Data Documentation

double NodeBlender::m_AngleEnd [private]

Definition at line 656 of file nodebldr.h.

double NodeBlender::m_AngleStart [private]

Definition at line 655 of file nodebldr.h.

UINT32 NodeBlender::m_ArrayLength [private]

Definition at line 640 of file nodebldr.h.

BOOL NodeBlender::m_BlendedOnCurve [private]

Definition at line 660 of file nodebldr.h.

UINT32 NodeBlender::m_BlendStep [private]

Definition at line 630 of file nodebldr.h.

UINT32 NodeBlender::m_GBlendBuffSize [private]

Definition at line 638 of file nodebldr.h.

BOOL NodeBlender::m_Initialised [private]

Definition at line 626 of file nodebldr.h.

INT32 NodeBlender::m_NodeBlendPathIndex [private]

Definition at line 664 of file nodebldr.h.

INT32 NodeBlender::m_ObjIndexEnd [private]

Definition at line 621 of file nodebldr.h.

INT32 NodeBlender::m_ObjIndexStart [private]

Definition at line 620 of file nodebldr.h.

INT32 NodeBlender::m_PathIndexEnd [private]

Definition at line 646 of file nodebldr.h.

INT32 NodeBlender::m_PathIndexStart [private]

Definition at line 645 of file nodebldr.h.

UINT32* NodeBlender::m_pGBlendBuff [private]

Definition at line 639 of file nodebldr.h.

NodeRenderableInk* NodeBlender::m_pNodeEnd [private]

Definition at line 611 of file nodebldr.h.

NodeRenderableInk* NodeBlender::m_pNodeStart [private]

Definition at line 610 of file nodebldr.h.

BlendRef* NodeBlender::m_pRefEnd [private]

Definition at line 606 of file nodebldr.h.

BlendRef* NodeBlender::m_pRefStart [private]

Definition at line 605 of file nodebldr.h.

double NodeBlender::m_ProportionOfPathDistEnd [private]

Definition at line 653 of file nodebldr.h.

double NodeBlender::m_ProportionOfPathDistStart [private]

Definition at line 652 of file nodebldr.h.

DocCoord* NodeBlender::m_pTempCoords [private]

Definition at line 635 of file nodebldr.h.

PathFlags* NodeBlender::m_pTempFlags [private]

Definition at line 637 of file nodebldr.h.

PathVerb* NodeBlender::m_pTempVerbs [private]

Definition at line 636 of file nodebldr.h.

BOOL NodeBlender::m_Reversed [private]

Definition at line 661 of file nodebldr.h.

UINT32 NodeBlender::m_TempArraySize [private]

Definition at line 634 of file nodebldr.h.

---

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

• Kernel/nodebldr.h (r1785/r1282)
• Kernel/nodebldr.cpp (r1785/r1315)

---