NodeBlend Class Reference

The NodeBlend class. More...

#include <nodeblnd.h>

Inheritance diagram for NodeBlend:

List of all members.

Public Member Functions
	NodeBlend ()
	This constructor creates a NodeBlend linked to no other, with all status flags false and an uninitialised bounding rectangle.
	NodeBlend (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	This method initialises the node and links it to ContextNode in the direction specified by Direction. All necessary tree links are updated.
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 blend" command. Supports ArtWorks EPS and Camelot EPS.
virtual BOOL	ExportRender (RenderRegion *pRender)
	Called afterCamelotEPSFilter this node and all of its children have been rendered to the export region. This outputs the "end blend" command. Supports ArtWorks EPS and Camelot EPS.
virtual void	RenderBlendBlobs (RenderRegion *pRender)
	This renders all the blobs associated with this blend node This node doesn't do any rendering itself. All it does is ask its child blender nodes to render their blend blobs.
virtual void	RenderObjectBlobs (RenderRegion *pRegion)
	Renders the object blobs.
void	RenderBlendOnCurveBlobs (RenderRegion *pRegion)
	This renders all the blobs associated with this blend node if it is on a curve. It needs to render blobs on the editable nodes, i.e. if the whole thing is on a curve then the first and last nodes are editable. if a blend on curve is blended to a straight blend then only the end on the curve is editable.
void	InvalidateBlendBoundingRect ()
	This calls InvalidateBoundingRect() on all bounded children of this blend.
DocRect	GetBlobBoundingRect ()
	This calls the base classes GetBlobBoundingRect(), and inflates the result by the width of a blob.
BOOL	AreBoundsValid ()
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.
BOOL	IsArtWorksEPSCompatible ()
	This asks all the child node blenders if they are AW compatible, and returns TRUE if ALL of them are AW compatible. If the m_AWEPSCompatibleCache flag is TRUE, the current setting of m_AWEPSCompatible is returned, else it is recalculated (setting m_AWEPSCompatibleCache to TRUE in the process).
INT32	GetNumInkObjects ()
	Used by the AW EPS blend export code to store the number of shapes this blend is blending.
virtual String	Describe (BOOL Plural, BOOL Verbose)
	To return a description of the Blend object in either the singular or the plural. This method is called by the DescribeRange method.
virtual Node *	SimpleCopy ()
	This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes.
virtual UINT32	GetNodeSize () const
	For finding the size of the node.
virtual BOOL	OnNodePopUp (Spread *pSpread, DocCoord PointerPos, ContextMenu *pMenu)
	Allows the Blend to respond to pop up menu clicks on itself.
virtual BOOL	PostImport ()
	This is called after the entire doc has been imported It first deinits the blend (in case they are initialised currently), then reinits the blend, returning the result.
virtual BOOL	IsABlend ()
virtual BOOL	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	Does nothing at the moment - Just returns FALSE.
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 ChangeCode	OnChildChange (ObjChangeParam *pParam)
	This function should be overridden in derived object classes. Composite objects can use this function to respond to one of their children undergoing a change. They should return CC_FAIL whenever they are unable to cope with the change.
virtual BOOL	AllowOp (ObjChangeParam *pParam, BOOL SetOpPermissionState=TRUE, BOOL DoPreTriggerEdit=TRUE)
	In this instance, the func gives the blend a chance to stop an op from happening to one of its children.
BOOL	IsPointOverBlob (DocCoord *pPointerPos, BlendPath **ppBlendPath, INT32 *pIndex, BOOL *pAStart, UINT32 *pRemapRef)
	This asks all its child blenders 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 blob belongs to start node, FALSE if end node. Also, if found,*pRemapRef contains a value that should be passed into NodeBlend::Remap().
BOOL	Remap (UINT32 RemapRef, DocCoord PosStart, DocCoord PosEnd, DocCoord *pInvPosStart, DocCoord *pInvPosEnd)
	This will ask the child blender referenced by RemapRef to remap its blend paths with the given params. If the child blender manages to remap a pair of blend paths, then this will return TRUE.
UINT32	GetNumBlenders ()
	This counts the number of child nodes that are NodeBlenders.
NodeBlender *	FindFirstBlender ()
	Convenience function. A drive-thru NodeBlender takeaway service.
NodeBlender *	FindNextBlender (NodeBlender *pNodeBlender)
	Convenience function. A drive-thru NodeBlender takeaway service.
NodeBlender *	FindLastBlender ()
	Convenience function. A drive-thru NodeBlender takeaway service.
BOOL	FindFirstAndLastBlenders (NodeBlender **ppFirstBlender, NodeBlender **ppLastBlender)
	Convenience function. A drive-thru NodeBlender takeaway service.
BOOL	IsOneToOne ()
	Get the state of the OneToOne flag for this blend.
void	SetOneToOne (BOOL state)
	Set the state of the OneToOne flag for this blend.
BOOL	IsNotAntialiased ()
	Get the state of the NotAntialiased flag for this blend.
void	SetNotAntialiased (BOOL state)
	Set the state of the NotAntialiased flag for this blend.
virtual BOOL	DoBecomeA (BecomeA *pBecomeA)
	Transforms the object into another type of object. This converts all its children, and replaces itself in the tree with a NodeGroup.
UINT32	GetNumBlendSteps ()
	Gets the number of blend steps in this blend.
void	SetNumBlendSteps (UINT32 NumSteps)
	Sets the number of blend steps in this blend.
ColourBlendType	GetColourBlendType ()
	How exactly will this blend blend colours? Use this func to find out.
void	SetColourBlendType (ColourBlendType Type)
	Sets up the way this blend blends colours.
EditState	GetEditState ()
	lets us know whether to edit the number of steps, or the distance between steps
void	SetEditState (EditState State)
	sets the type to edit according to which button is selected on the infobar. Also initialises the m_DistanceEntered member if it has not already been initialised. This is in case the user selected distance edit but does not enter a value. In this case, if the user has not selected a previous value I assume that they wish to keep the value generated.
BOOL	Reinit (BOOL ProgressBar=TRUE)
	This calls Reinit() on all child blenders.
void	Deinit (BOOL bNodesMayBeChanged=FALSE)
	This calls Deinit() on all child blenders.
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes the blend record to the filter.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
virtual BOOL	WritePreChildren (BaseCamelotFilter *pFilter)
	Writes the blend record to the filter.
virtual BOOL	CanWriteChildrenWeb (BaseCamelotFilter *pFilter)
	Determines whether the blend's children are to be saved or not.
virtual BOOL	CanWriteChildrenNative (BaseCamelotFilter *pFilter)
	Determines whether the blend's children are to be saved or not.
NodeBlendPath *	GetNodeBlendPath (UINT32 Index)
	Finds the path the blend with try and follow, if it's got one.
BOOL	BlendAlongThisPath (NodePath *pPath, CCAttrMap *pAttrMap, UndoableOperation *pUndoOp, BOOL BlendPathOnTop)
	Makes this blend object blend along the given path.
virtual Node *	HasEditableChild (CCRuntimeClass *ChildClass, Node *pPrevEditable)
	This function returns our edit node (the NodeBlendPath).
BOOL	TransformBlendEndObjects (UndoableOperation *pUndoOp)
BOOL	RotateBlendEndObjectsBack (UndoableOperation *pUndoOp)
BOOL	TransformNodeToPoint (NodeRenderableInk *pNode, DocCoord *pPoint, UndoableOperation *pUndoOp, double Angle)
BOOL	InitBlenderPathProportions (UndoableOperation *pUndoOp)
BOOL	DetachNodeBlendPath (Node *pContextNode, AttachNodeDirection AttDir, UndoableOperation *pUndoOp)
	Removes all nodeblendpaths.
BOOL	IsTangential ()
	Get the state of the m_Tangential flag for this blend.
void	SetTangential (BOOL Tangential)
	Set the state of the m_Tangential flag for this blend.
BOOL	IsOnACurve ()
	Get the state of the m_blendedoncurve flag.
void	SetBlendedOnCurve (BOOL State)
	Set the state of the m_BlendedOnCurve flag for this blend.
CProfileBiasGain *	GetObjectProfile ()
CProfileBiasGain *	GetAttrProfile ()
CProfileBiasGain *	GetPositionProfile ()
BOOL	GetBlendDistance (BOOL GetFullDistance, double *Distance)
	To find out how long the blend is.
BOOL	GetNumStepsFromDistance (double StepDistance, UINT32 *NumSteps)
	To determine the number of steps that will achieve a distance between steps close to the value passed.
double	GetStepDistance ()
	works out the distance between each step in the blend
void	UpdateStepDistance ()
	works out the distance between each step in the blend and updates the member variable
double	GetDistanceEntered ()
	to return the last distance between blend steps that user entered
void	SetDistanceEntered (double Distance)
	to set the distance between blend steps that user entered
EndObject	GetLastEdited ()
	Access function, lets you know which end object of a blend on a path was last edited.
void	SetLastEdited (EndObject ObjectEdited)
	Access function.
BOOL	GetStartAndEndProportions (double *StartProp, double *EndProp)
	To find the proportions along the path where the first and last objects are located.
BOOL	GetStartAndEndNodes (Node **ppStart, Node **ppEnd)
	To find the first and last objects in a blend.
BOOL	IsChildOfGroup ()
	to determine whether this nodeblend is part of a nodegroup
BOOL	HitOnEndDragBlob (DocCoord Point, Node **ppHitNode)
	To determine whether or not Point is over the central blob of one of the end objects of a blend on a curve.
NodeCompound *	GetParentController () const
	If the blend is part of a bevel, shadow, or contour then this returns the parent controller.
UINT32	GetNumNodeBlendPaths ()
	Access function.
void	SetNumNodeBlendPathsInc (BOOL Increase)
	Record a change in the number of nodeblendpaths.
void	SetNumNodeBlendPaths (INT32 Index)
	Record a change in the number of nodeblendpaths.
BOOL	HitOnDragBlob (NodeRenderableInk *pInk, DocCoord PointerPos)
	To find out if the pointer position is within the bounds of the blob in the middle of this node.
NodeBlender *	NodeIsPartOfBlender (Node *pNode, BOOL First)
	To find out if pNode is used by a blender in this nodeblend at the position specified. Useful if you are changing the node through a different blender and wish to update related blends.
NodeBlender *	NodeIsPartOfBlender (Node *pNode, NodeBlender *pBlender, BOOL *First)
	Overridden version of above, now that we have multi stage blends which can go to and from arbitrary end points we can't always rely on knowing the end position.
BOOL	NonLinearObjectProfile ()
	as above
BOOL	ContainsBrushedNode ()
	as above
void	RequestObjectProfileProcessing (BOOL newVal)
BOOL	GetObjectProfileProcessing ()
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.
BOOL	ReinitialiseOnChildChanged (UndoableOperation *pOp, NodeRenderableInk *pOldChild, NodeRenderableInk *pNewChild)
	Used by the shadowing code to reinitialise the blend when one of the blended nodes has had a shadow applied to it. In this case, the tree structure has changed, and the blend framework needs to know this.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
virtual BOOL	IsTypeExtendible () const
virtual DocRect	ValidateExtend (const ExtendParams &ExtParams)
	Checks whether or not performing an extend operation on this node will leave it in a state from which it would be impossible to return.
virtual void	Extend (const ExtendParams &ExtParams)
	Applies an Extend operation to this node. If we're just stretching, then we simply do a stretch transform on ourself. If the extend operation involves any actual extension, we must determine which of the nodes lying below us we must extend. The child nodes which are extended will fall into two categories: NodeBlendPaths will take care of themselves, via their Extend() fn. Nodes which are blended between will be translated appropriately. (Karim 17/04/2000 - behaviour has changed so that Nodes instead have their Extend() methods called) Note however that the choice of which nodes to translate is a little complex; look at FindExtendingChildren() for info.
Static Public Member Functions
static BOOL	GetDefaultAntialias ()
Protected Member Functions
void	FindExtendingChildren (std::list< NodeRenderableInk * > &, std::list< NodeBlendPath * > &)
	Performs a search of the children below this blend node, returning a list of object nodes which should be translated in an extension, and another list of blend-path nodes, which should be extended appropriately.
Private Member Functions
void	CopyNodeContents (NodeBlend *pCopyOfNode)
	Copies the data from 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.
void	ResetVars ()
	This sets all the member vars to the state they should be in on construction. All constructors should call this func.
Private Attributes
BOOL	objectProfileProcessing
String_32	m_BlendName
UINT32	m_NumBlendSteps
double	m_StepDistance
double	m_DistanceEntered
EndObject	m_LastEdited
BOOL	m_AWEPSCompatible
BOOL	m_AWEPSCompatibleCache
BOOL	m_OneToOne
BOOL	m_NotAntialiased
ColourBlendType	m_ColBlendType
BOOL	m_Tangential
BOOL	m_BlendedOnCurve
EditState	m_Edit
CProfileBiasGain	m_ObjectProfile
CProfileBiasGain	m_AttrProfile
CProfileBiasGain	m_PositionProfile
UINT32	m_NumNodeBlendPaths
Static Private Attributes
static BOOL	s_DefaultNotAntialiased

---

Detailed Description

The NodeBlend class.

Author:

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

Date:

6/10/94

Definition at line 129 of file nodeblnd.h.

---

Constructor & Destructor Documentation

NodeBlend::NodeBlend (   )

This constructor creates a NodeBlend linked to no other, with all status flags false and an uninitialised bounding rectangle. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/94 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: Definition at line 170 of file nodeblnd.cpp. : NodeGroup() { ResetVars(); }

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

This method initialises the node and links it to ContextNode in the direction specified by Direction. All necessary tree links are updated. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/94 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] Direction: Specifies the direction in which this 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 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 ? Parameters: -  [OUTPUTS] Returns: - Errors: An assertion error will occur if ContextNode is NULL Definition at line 219 of file nodeblnd.cpp. :NodeGroup(ContextNode, Direction, Locked, Mangled, Marked, Selected) { ResetVars(); }

---

Member Function Documentation

BOOL NodeBlend::AllowOp (  ObjChangeParam *  pParam, BOOL  SetOpPermissionState = TRUE, BOOL  DoPreTriggerEdit = TRUE )  [virtual]

In this instance, the func gives the blend a chance to stop an op from happening to one of its children. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com>; Karim 20/01/2000 Date: 6/5/95 Parameters: pParam  = describes the way an op wants to change the node [INPUTS] SetOpPermissionState = if TRUE the Op permission state of this node will be set according to the outcome of the call DoPreTriggerEdit = if TRUE then calls NameGallery::PreTriggerEdit. Must* be TRUE if the calling Op may make any nodes change their bounds, eg move, line width, cut. Use TRUE if unsure. Outputs: - Returns: TRUE means the node and all its parents are happy with this op, FALSE means don't do it Current implementation specs that blends will only allow you to change the appearence of a blend's child (e.g. change colour,translate, edit path). This must be called *before* the op is performed. See also: Node::AllowOp(),GetOpPermission(),SetOpPermission(); Reimplemented from Node. Definition at line 1851 of file nodeblnd.cpp. { ERROR2IF(pParam==NULL,FALSE,"NodeBlend::AllowOp() - pParam==NULL"); // clean out the calling-child ptr, so it doesn't get passed around unintentionally. pParam->SetCallingChild(NULL); // decide if we allow it ... (and if we'll still exist after the op) BOOL allowed=TRUE; ObjChangeFlags Flags=pParam->GetChangeFlags(); if (pParam->GetDirection()==OBJCHANGE_CALLEDBYCHILD) { if (Flags.DeleteNode || Flags.MultiReplaceNode || Flags.MoveNode) { pParam->SetReasonForDenial(_R(IDS_BLEND_CANT_OP_ON_CHILDREN)); allowed=FALSE; } } // if we allow it, (and our parents weren't calling us) see if our parents do ... if (allowed && pParam->GetDirection()!=OBJCHANGE_CALLEDBYPARENT && Parent!=NULL) { ObjChangeDirection OldDirection=pParam->GetDirection(); pParam->SetCallingChild(this); pParam->SetDirection(OBJCHANGE_CALLEDBYCHILD); allowed=Parent->AllowOp(pParam,SetOpPermissionState,DoPreTriggerEdit); pParam->SetDirection(OldDirection); } if (allowed && pParam->GetDirection() == OBJCHANGE_CALLEDBYCHILD) { // Ilan 5/4/00 // Inform attrs attached at compound level that children have changed UndoableOperation* pChangeOp = pParam->GetOpPointer(); BOOL InformGeomLinkedAttrs = SetOpPermissionState && pChangeOp && pChangeOp->MayChangeNodeBounds(); if(InformGeomLinkedAttrs) { NodeAttribute* pNA = FindFirstGeometryLinkedAttr(); while(pNA) { pNA->LinkedNodeGeometryHasChanged(pChangeOp); pNA = pNA->FindNextGeometryLinkedAttr(); } } } // if setting permissions ... (and possibly cause post-op code to be called) if (SetOpPermissionState) { if (allowed) { if (Parent!=NULL) Parent->SetOpPermission(PERMISSION_ALLOWED); // if post process required, ensure our OnChildChange is called (by setting permission on ourself), // insert an inverse action in the undo if (pParam->GetDirection()==OBJCHANGE_CALLEDBYCHILD || Flags.Attribute || Flags.RegenerateNode) { SetOpPermission(PERMISSION_ALLOWED); UndoableOperation* pOp=pParam->GetOpPointer(); if (pOp!=NULL) { if (allowed) allowed=(InitBlendAction::Init(pOp,pOp->GetUndoActionList(),this)!=AC_FAIL); if (allowed) allowed=pOp->DoInvalidateNodeRegion(this, TRUE, FALSE, FALSE, !pParam->GetRetainCachedData()); } } } else SetOpPermission(PERMISSION_DENIED,TRUE); } // if the op was allowed, inform our children by calling their AllowOp()s // this must be done after we've inserted our undo actions so that any child undo actions will be undone first! if (allowed && pParam->GetDirection()!=OBJCHANGE_CALLEDBYCHILD) AllowOp_AccountForCompound(pParam, SetOpPermissionState, DoPreTriggerEdit); if (allowed && Flags.Attribute && SetOpPermissionState) Deinit(); // if we're ok so far and were asked to do a PreTriggerEdit, then // determine whether the Op may change the bounds of some nodes. // If it may, then call NameGallery::PreTriggerEdit. if (allowed && DoPreTriggerEdit) { // if the Op is non-NULL then query its MayChangeNodeBounds() method. UndoableOperation* pChangeOp = pParam->GetOpPointer(); if (pChangeOp != NULL && pChangeOp->MayChangeNodeBounds()) { if (NameGallery::Instance()) allowed = NameGallery::Instance()->PreTriggerEdit(pChangeOp, pParam, this); } } // return result (directly, or indirectly via a child AllowOp()) to op return allowed; }

BOOL NodeBlend::AreBoundsValid (   )  [inline]

Definition at line 155 of file nodeblnd.h. { return IsBoundingRectValid; }

BOOL NodeBlend::BlendAlongThisPath (  NodePath *  pNodePath, CCAttrMap *  pAttrMap, UndoableOperation *  pUndoOp, BOOL  BlendPathOnTop )

Makes this blend object blend along the given path. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/99 Parameters: pPath  = ptr to the definition of the path to blend alone [INPUTS] pAttrMap = ptr to attrs to apply to given path (can be NULL) pUndoOp = ptr to undo op performing th operation. Returns: TRUE if all went to plan FALSE otherwise It creates a NodeBlendPath from the given NodePath, and inserts it a the last child of the blend Definition at line 2117 of file nodeblnd.cpp. { ERROR2IF(pUndoOp == NULL,FALSE,"I need an undoable op to perform this task"); ERROR2IF(pNodePath == NULL,FALSE,"Er, where is the path then?"); BOOL ok = TRUE; // DY at this point there should only be one nodeblendpath, hence the zero index NodeBlendPath* pNodeBlendPath = GetNodeBlendPath(0); if (pNodeBlendPath != NULL) ok = pUndoOp->DoHideNode(pNodeBlendPath,TRUE); if (ok) pNodeBlendPath = new NodeBlendPath(); if (ok) ok = (pNodeBlendPath != NULL); if (ok) ok = pNodeBlendPath->CopyNodePath(pNodePath); if (ok) ok = pUndoOp->DoLocaliseCommonAttributes(this); if (ok) //DY 16/9/99, previously blendpath was always inserted as last child { if (BlendPathOnTop) ok = pUndoOp->DoInsertNewNode(pNodeBlendPath,this,LASTCHILD,FALSE,FALSE,FALSE,FALSE); else ok = pUndoOp->DoInsertNewNode(pNodeBlendPath,this,FIRSTCHILD,FALSE,FALSE,FALSE,FALSE); } if (ok) ok = pNodeBlendPath->ApplyAttributes(pAttrMap); if (ok) ok = pUndoOp->DoFactorOutCommonChildAttributes(this); if (ok) ok = InitBlenderPathProportions(pUndoOp); if (ok) ok = TransformBlendEndObjects(pUndoOp); // Dont' need to do these two steps as the call to AllowOp() will take care of these things. // Deinit(); // InvalidateBlendBoundingRect(); return ok; }

BOOL NodeBlend::CanWriteChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Determines whether the blend's children are to be saved or not. > virtual BOOL NodeBlend::CanWriteChildrenNative(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/1/97 Parameters: pFilter  = ptr to the filter [INPUTS] Returns: TRUE if record is written, FALSE if not WEBSTER - markn 29/1/97 See also: - Reimplemented from Node. Definition at line 3665 of file nodeblnd.cpp. { #ifdef DO_EXPORT if (pFilter->IsCompactNativeFilter()) { if (pFilter->GetConvertBlendsToOutlines()) return FALSE; } return TRUE; #else return FALSE; #endif }

BOOL NodeBlend::CanWriteChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Determines whether the blend's children are to be saved or not. > virtual BOOL NodeBlend::CanWriteChildrenWeb(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/1/97 Parameters: pFilter  = ptr to the filter [INPUTS] Returns: TRUE if record is written, FALSE if not WEBSTER - markn 29/1/97 See also: - Reimplemented from Node. Definition at line 3636 of file nodeblnd.cpp. { #ifdef DO_EXPORT if (pFilter->GetConvertBlendsToOutlines()) return FALSE; return TRUE; #else return FALSE; #endif }

BOOL NodeBlend::ContainsBrushedNode (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if this blend contains an object with a brush attribute See also: - Definition at line 1038 of file nodeblnd.cpp. { Node* pNode = FindFirstChild(); NodeAttribute* pAttr = NULL; while (pNode != NULL) { if (pNode->IsAnObject()) { ((NodeRenderableInk*)pNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), &pAttr); if (pAttr != NULL) { AttrBrushType* pAttrBrush = (AttrBrushType*)pAttr; if (pAttrBrush->GetBrushHandle() != BrushHandle_NoBrush) return TRUE; } } pNode = pNode->FindNext(); } return FALSE; }

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

Copies the data from 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] -  [OUTPUTS] Returns: - See also: NodeGroup::CopyNodeContents Definition at line 333 of file nodeblnd.cpp. { NodeGroup::CopyNodeContents(pCopyOfNode); // Copy member vars here pCopyOfNode->m_NumBlendSteps = m_NumBlendSteps; pCopyOfNode->m_OneToOne = m_OneToOne; pCopyOfNode->m_NotAntialiased = m_NotAntialiased; pCopyOfNode->m_ColBlendType = m_ColBlendType; pCopyOfNode->m_Tangential = m_Tangential; pCopyOfNode->m_BlendedOnCurve = m_BlendedOnCurve; pCopyOfNode->m_Edit = m_Edit; pCopyOfNode->m_DistanceEntered = m_DistanceEntered; pCopyOfNode->m_NumNodeBlendPaths = m_NumNodeBlendPaths; pCopyOfNode->m_ObjectProfile = m_ObjectProfile; pCopyOfNode->m_AttrProfile = m_AttrProfile; pCopyOfNode->m_PositionProfile = m_PositionProfile; }

void NodeBlend::Deinit (  BOOL  bNodesMayBeChanged = FALSE  )

This calls Deinit() on all child blenders. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/2/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 1130 of file nodeblnd.cpp. { Node* pNode = FindFirstChild(); while (pNode != NULL) { if (IS_A(pNode,NodeBlender)) ((NodeBlender*)pNode)->Deinit(bNodesMayBeChanged); pNode = pNode->FindNext(); } }

String NodeBlend::Describe (  BOOL  Plural, BOOL  Verbose )  [virtual]

To return a description of the Blend object in either the singular or the plural. This method is called by the DescribeRange method. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/94 Parameters: Plural,:  Flag indicating if the string description should be plural or [INPUTS] singular. -  [OUTPUTS] Retuns: Description of the blend node The description will always begin with a lower case letter. Returns: Errors: - See also: - Reimplemented from NodeGroup. Definition at line 282 of file nodeblnd.cpp. { if (Plural) return(String(_R(IDS_BLEND_DESCRP))); else return(String(_R(IDS_BLEND_DESCRS))); };

BOOL NodeBlend::DetachNodeBlendPath (  Node *  pContextNode, AttachNodeDirection  AttDir, UndoableOperation *  pUndoOp )

Removes all nodeblendpaths. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/99 //changed Diccon 9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2372 of file nodeblnd.cpp. { ERROR2IF(pContextNode == NULL,FALSE,"NULL pContextNode"); ERROR2IF(pUndoOp == NULL,FALSE,"NULL pUndoOp"); BOOL ok = TRUE; UINT32 NBPCounter = 0; NodeBlendPath* pNodeBlendPath = GetNodeBlendPath(NBPCounter++); while (pNodeBlendPath != NULL) { NodePath* pNodePath = pNodeBlendPath->CreateNodePathCopy(); if (pNodePath != NULL) { CCAttrMap* pAttrMap = new CCAttrMap(30); ok = (pAttrMap != NULL); if (ok) ok = pNodeBlendPath->FindAppliedAttributes(pAttrMap); if (ok) ok = pUndoOp->DoInsertNewNode(pNodePath,pContextNode,AttDir,FALSE,FALSE,FALSE,FALSE); if (ok) ok = pUndoOp->DoHideNode(pNodeBlendPath,TRUE); if (ok) ok = pUndoOp->DoSelectNode(pNodePath); // Select it, because it's nicer that way if (ok) pNodePath->ApplyAttributes(pAttrMap,TRUE); if (pAttrMap != NULL) { delete pAttrMap; pAttrMap = NULL; } } // go through all the blenders and set their index flags to -1 // NOTE - need to make this undoable NodeBlender* pBlender = FindFirstBlender(); while (pBlender != NULL) { pBlender->SetNodeBlendPathIndex(-1); pBlender = FindNextBlender(pBlender); } pNodeBlendPath = GetNodeBlendPath(NBPCounter++); } return ok; }

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

Transforms the object into another type of object. This converts all its children, and replaces itself in the tree with a NodeGroup. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 18/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 Errors: - See also: Node::CanBecomeA Reimplemented from NodeCompound. Definition at line 502 of file nodeblnd.cpp. { if (!Reinit()) return FALSE; switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE: { // ERROR2IF(pBecomeA->GetUndoOp() == NULL,FALSE,"Trying to replace a NodeBlend, but pUndoOp == NULL"); UndoableOperation* pUndoOp = pBecomeA->GetUndoOp(); // Make all attrs children of the child nodes if (pUndoOp) { if (!pUndoOp->DoLocaliseCommonAttributes(this)) return FALSE; } else { if (!LocaliseCommonAttributes()) return FALSE; } // If being repaced in the tree, deselect the node BOOL IsSelected = this->IsSelected(); SetSelected(FALSE); // When becoming a new type of node AND replacing ourselves in the tree, we must first ask all the // blender child nodes, then the rest of the children, in that order. // This is because the blender nodes generate new nodes from other children in the tree, so // they have to do their stuff before the other nodes get replaced and hence disappear. // We need a list of all non-blender child nodes std::list<Node *> ListOfNodes; //(30); // Scan the children of the blend Node* pNode = FindFirstChild(); while (pNode != NULL) { Node* pThisNode = pNode; pNode = pNode->FindNext(); // If this node is a blender, call its DoBecomeA() method // otherwise add the node to the list of non-blender nodes to use later if (IS_A(pThisNode,NodeBlender)) pThisNode->DoBecomeA(pBecomeA); else ListOfNodes.push_back(pThisNode); } while( !ListOfNodes.empty() ) { // Here we must ask all the non-blender nodes to DoBecomeA() pNode = ListOfNodes.back(); ListOfNodes.pop_back(); // CGS: prevent NodeShadowControllers, NodeBevelControllers and NodeCountourControllers from // converting to paths when inside of a blend .... if (!pNode->IsController ()) { pNode->DoBecomeA(pBecomeA); } else { // BUT if we need them converted to paths, then do it .... if (pBecomeA->GetInsertComplexBlendStepsAsPaths ()) { pNode->DoBecomeA(pBecomeA); } } } // All the children have been delt with, so now's the time to deal with this blend node // When replacing the blend with shapes, hide the blend, create a group, and move all the children // so they become children of the new group node // Allocate a new NodeGroup node NodeGroup* pNodeGroup; ALLOC_WITH_FAIL(pNodeGroup, (new NodeGroup), pUndoOp); if (pNodeGroup == NULL) return FALSE; // Insert the NodeGroup where the NodeBlend used to be if (pUndoOp) { if (!pUndoOp->DoInsertNewNode(pNodeGroup,this,NEXT,FALSE,FALSE,FALSE,FALSE)) return FALSE; } else { pNodeGroup->AttachNode(this, NEXT); } // Select the group, but only if the caller wants us too (moulds don't, for example) if (IsSelected && pUndoOp) { if (!pUndoOp->DoSelectNode(pNodeGroup,FALSE)) return FALSE; } // Karim 15/05/2000 - rewrote to handle non-optimising attrs. // Move our children into the new group node. // // NOTE: The IsEffectAttribute function won't work when called from ShouldBeOptimized below // because it looks along the tree for bounded nodes and this function will have removed them // all by the time that call is made. // So bInEffectArea duplicates that logic by being set as soon as any bounded object // is met as we traverse the child list. Not nice... // BOOL ok = TRUE; BOOL bInEffectArea = FALSE; Node* pNextKid = NULL; Node* pThisKid = FindFirstChild(); while (ok && pThisKid != NULL) { pNextKid = pThisKid->FindNext(); if (pThisKid->IsBounded()) bInEffectArea = TRUE; // ink nodes just get moved. if (pThisKid->IsAnObject()) { if (pUndoOp) { CALL_WITH_FAIL(pUndoOp->DoMoveNode(pThisKid, pNodeGroup, LASTCHILD), pUndoOp, ok) } else { pThisKid->MoveNode(pNodeGroup, LASTCHILD); } } // non-optimising attrs just get copied, as DoMoveNode() doesn't like them. else if (pThisKid->IsAnAttribute() && (!((NodeAttribute*)pThisKid)->ShouldBeOptimized() || bInEffectArea) ) CALL_WITH_FAIL(pThisKid->CopyNode(pNodeGroup, LASTCHILD), pUndoOp, ok) pThisKid = pNextKid; } if (!ok) return FALSE; // Hide the blend node NodeHidden* pNodeHidden; if (pUndoOp) { if(!pUndoOp->DoHideNode(this, FALSE, &pNodeHidden, FALSE)) return FALSE; } else { CascadeDelete(); delete this; } // Factor out the attrs (needed after a call to DoLocaliseCommonAttributes if (pUndoOp) { if (!pUndoOp->DoFactorOutCommonChildAttributes(pNodeGroup)) return FALSE; } else { if (!pNodeGroup->FactorOutCommonChildAttributes()) return FALSE; } } break; case BECOMEA_PASSBACK: // the following case is executed when doing the blend of two grouped blends { // Sequentially ask the children of the blend to DoBecomeA // This is all that's required because the child objects are only passing back // the new node type, and NOT replacing themselves in the tree // This also ensures the receipient gets the list of paths in render order Node* pNode = FindFirstChild(); while (pNode != NULL) { if (!pNode->DoBecomeA(pBecomeA)) return FALSE; pNode = pNode->FindNext(); } } break; default: ERROR3_PF(("Unknown BecomeA reason %d",pBecomeA->GetReason())); break; } return TRUE; }

INT32 NodeBlend::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 NodeCompound. Definition at line 3107 of file nodeblnd.cpp. { NodeBlender* pBlender = FindFirstBlender(); INT32 total = 0; while (pBlender) { total += pBlender->EstimateNodeComplexity (details); pBlender = FindNextBlender(pBlender); } return (total); }

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

Called afterCamelotEPSFilter this node and all of its children have been rendered to the export region. This outputs the "end blend" 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 NodeGroup. Definition at line 1717 of file nodeblnd.cpp. { #ifdef DO_EXPORT if (IS_A(pRegion, CamelotEPSRenderRegion)) // We just want the paths in EPS. return FALSE; if (pRegion->IS_KIND_OF(ArtWorksEPSRenderRegion)) { EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); if (pRegion->IS_KIND_OF(CamelotEPSRenderRegion)) { pDC->OutputToken(_T("cebd")); // Camelot "end blend" token pDC->OutputNewLine(); } else if (IsArtWorksEPSCompatible()) { pDC->OutputToken(_T("aebd")); // ArtWorks "end blend" token pDC->OutputNewLine(); } // Tell caller we rendered ourselves ok return TRUE; } #endif // Render this node in the normal way return FALSE; }

void NodeBlend::Extend (  const ExtendParams &  ExtParams  )  [virtual]

Applies an Extend operation to this node. If we're just stretching, then we simply do a stretch transform on ourself. If the extend operation involves any actual extension, we must determine which of the nodes lying below us we must extend. The child nodes which are extended will fall into two categories: NodeBlendPaths will take care of themselves, via their Extend() fn. Nodes which are blended between will be translated appropriately. (Karim 17/04/2000 - behaviour has changed so that Nodes instead have their Extend() methods called) Note however that the choice of which nodes to translate is a little complex; look at FindExtendingChildren() for info. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 26/11/1999 Parameters: ExtParams  extend description parameters. [INPUTS] This  node and its children may undergo change in the process of extension. [OUTPUTS] Returns: Errors: See also: NodeBlend::FindExtendingChildren() Reimplemented from Node. Definition at line 3859 of file nodeblnd.cpp. { // try to perform a stretch first of all. TransformStretchObject(ExtParams); // figuring out which children to do what to is complicated and may take time, // so only continue if we _have_ to extend along either axis, otherwise quit now. if ( !(ExtParams.fExtendFlags & (X_EXTEND | Y_EXTEND)) ) return; // okay, compile lists of child nodes which will be extended. std::list<NodeRenderableInk*> lpInks; std::list<NodeBlendPath*> lpBlendPaths; FindExtendingChildren(lpInks, lpBlendPaths); // extend the blend-paths. for ( std::list<NodeBlendPath*>::iterator iterPath = lpBlendPaths.begin(); iterPath != lpBlendPaths.end(); iterPath ++ ) { ((NodeBlendPath*)(*iterPath))->Extend(ExtParams); } // Karim 17/04/2000 // We're changing things so that blended objects actually extend, rather than translate. // This _may_ cause some havoc with blend-on-a-path... // translate the objects. for ( std::list<NodeRenderableInk*>::iterator iterInk = lpInks.begin(); iterInk != lpInks.end(); iterInk ++ ) { // ((NodeRenderableInk*)(*iterInk))->TransformTranslateObject(ExtParams); ((NodeRenderableInk*)(*iterInk))->Extend(ExtParams); } }

void NodeBlend::FindExtendingChildren (  std::list< NodeRenderableInk * > &  lpInks, std::list< NodeBlendPath * > &  lpBlendPaths )  [protected]

Performs a search of the children below this blend node, returning a list of object nodes which should be translated in an extension, and another list of blend-path nodes, which should be extended appropriately. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 26/11/1999 Parameters: lpInks  a NodeRenderableInk list, to fill with translating objects. [INPUTS] lpBlendPaths a NodeBlendPath list, to fill with extending blend-paths. The  two lists passed will be filled with pointers to Nodes in the tree. [OUTPUTS] Returns: We travel down the tree, building a list of objects which belong to normal blender nodes but do not also belong to blender-on-a-path nodes, and a list of blender-on-a-path nodes also. This is a recursive algorithm, as blends can lie within other blends. This recursion is carried out in a loop within this function. Returns: Errors: See also: Definition at line 3922 of file nodeblnd.cpp. { std::list<NodeBlend*> lpBlends; // a stack of blends, used for recursion. std::list<NodeGroup*> lpGroups; // a stack of groups, used for recursion. // push ourself onto the blend stack, to start all the fun! lpBlends.push_back(this); NodeBlend* pNodeBlend = NULL; // NodeGroup* pNodeGroup = NULL; // NodeRenderableInk* pInk = NULL; // NodeBlendPath* pNodeBlendPath = NULL; // // loop until both stacks are empty. while (!lpBlends.empty() || !lpGroups.empty()) { // deal with the blends first, as these are the complicated beasties. if (!lpBlends.empty()) { // pull the next blend off our blend stack, for processing. pNodeBlend = lpBlends.front(); lpBlends.pop_front(); // process each of the blend's blender objects. // in our first pass, we add each blender's paths and objects to separate // lists. we need to discard any objects belonging to both a path-blender // and a normal blender, hence the two object-lists below. std::list<NodeRenderableInk*> lpBlendedObjects; std::list<NodeRenderableInk*> lpBlendPathObjects; NodeBlender* pBlender = pNodeBlend->FindFirstBlender(); while (pBlender != NULL) { // does this blender follow a path? pNodeBlendPath = pBlender->GetNodeBlendPath(); if (pNodeBlendPath != NULL) { // yes - stick its path on the list of paths to extend. lpBlendPaths.push_back(pNodeBlendPath); // note down its nodes, so they don't land on the extending list later. pInk = pBlender->GetNodeStart(); if (pInk != NULL) // should never happen, but test anyway. lpBlendPathObjects.push_back(pInk); pInk = pBlender->GetNodeEnd(); if (pInk != NULL) // should never happen, but test anyway. lpBlendPathObjects.push_back(pInk); } // no - ok, remember its nodes in our short-list of blended objects. else { pInk = pBlender->GetNodeStart(); if (pInk != NULL) // should never happen, but test anyway. lpBlendedObjects.push_back(pInk); pInk = pBlender->GetNodeEnd(); if (pInk != NULL) // should never happen, but test anyway. lpBlendedObjects.push_back(pInk); } pBlender = pNodeBlend->FindNextBlender(pBlender); } // ok, we now have a list of blended objects, some of which we must discard // if they are also blended along a path. lpBlendPathObjects.sort(); lpBlendedObjects.sort(); std::list<NodeRenderableInk*>::iterator iterNode = lpBlendedObjects.begin(); while (!lpBlendPathObjects.empty() && !lpBlendPathObjects.empty()) { // pop the next object to discard from the front of its list. pInk = lpBlendPathObjects.front(); lpBlendPathObjects.pop_front(); // move through the object-list until we find a pointer whose value // is not less than our discard-pointer. while (iterNode != lpBlendedObjects.end() && (*iterNode) < pInk) iterNode ++; // discard any elements from the object list whose pointer value // matches our discard pointer. while (iterNode != lpBlendedObjects.end() && (*iterNode) == pInk) iterNode = lpBlendedObjects.erase(iterNode); } // we move the remaining objects onto our group, blend and object lists. // if there were two or more blenders, then some nodes may occur twice // in our lists, so we test for these and only move them across once. pInk = NULL; while (!lpBlendedObjects.empty()) { if (pInk == lpBlendedObjects.front()) { lpBlendedObjects.pop_front(); continue; } pInk = lpBlendedObjects.front(); lpBlendedObjects.pop_front(); if (IS_A(pInk, NodeGroup)) // another group on the groups stack. lpGroups.push_front((NodeGroup*)pInk); else if (IS_A(pInk, NodeBlend)) // don't think a blender can hold lpBlends.push_front((NodeBlend*)pInk); // a blend directly, but only 99% // certain, so we check for it. else if (pInk->IsAnObject()) // wahey! got another object to extend. lpInks.push_back(pInk); } } // now groups - we add any renderable-ink children to the objects list, // and any group or blend children to the appropriate recursion list. if (!lpGroups.empty()) { // we needn't worry about avoiding hidden nodes in this loop, // as we explicitly check the type of all nodes iterated over. pNodeGroup = lpGroups.front(); lpGroups.pop_front(); Node* pChild = pNodeGroup->FindFirstChild(); while (pChild != NULL) { if (IS_A(pChild, NodeGroup)) // another group on the groups stack. lpGroups.push_front((NodeGroup*)pChild); else if (IS_A(pChild, NodeBlend)) // another blend on the blends stack. lpBlends.push_front((NodeBlend*)pChild); else if (pChild->IsAnObject()) // wahey! got another object to extend. lpInks.push_back((NodeRenderableInk*)pChild); pChild = pChild->FindNext(); } } } }

BOOL NodeBlend::FindFirstAndLastBlenders (  NodeBlender **  ppFirstBlender, NodeBlender **  ppLastBlender )

Convenience function. A drive-thru NodeBlender takeaway service. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 16/9/99 Parameters: -  [INPUTS] pFirstBlender,pLastBlender,as  the names suggest [OUTPUTS] Returns: TRUE if successful, FALSE otherwise See also: FindFirstBlender(), FindNextBlender() Definition at line 2522 of file nodeblnd.cpp. { NodeBlender* pTempBlender = FindFirstBlender(); if (pTempBlender == NULL) return FALSE; else *ppFirstBlender = pTempBlender; pTempBlender = NULL; pTempBlender = FindLastBlender(); if (pTempBlender == NULL) return FALSE; *ppLastBlender = pTempBlender; return TRUE; }

NodeBlender * NodeBlend::FindFirstBlender (   )

Convenience function. A drive-thru NodeBlender takeaway service. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Pointer to the first NodeBlender belonging to this blend object or NULL if there aren't any See also: FindNextBlender() Definition at line 2428 of file nodeblnd.cpp. { Node* pNode = FindFirstChild(); while (pNode != NULL) { if (IS_A(pNode,NodeBlender)) return ((NodeBlender*)pNode); pNode = pNode->FindNext(); } return NULL; }

NodeBlender * NodeBlend::FindLastBlender (   )

Convenience function. A drive-thru NodeBlender takeaway service. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 16/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Pointer to the last NodeBlender belonging to this blend object, in rendering order or NULL if there aren't any See also: FindFirstBlender(), FindNextBlender() Definition at line 2492 of file nodeblnd.cpp. { Node* pNode = FindLastChild(); while (pNode != NULL) { if (pNode->IS_KIND_OF(NodeBlender)) { return (NodeBlender*)pNode; } pNode = pNode->FindPrevious(); } return NULL; }

NodeBlender * NodeBlend::FindNextBlender (  NodeBlender *  pNodeBlender  )

Convenience function. A drive-thru NodeBlender takeaway service. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/99 Parameters: pNodeBlender  = ptr to previous NodeBlender found [INPUTS] -  [OUTPUTS] Returns: Pointer to the next NodeBlender belonging to this blend object, in rendering order or NULL if there aren't any See also: FindFirstBlender() Definition at line 2458 of file nodeblnd.cpp. { if (pNodeBlender) { Node* pNode = pNodeBlender->FindNext(); while (pNode != NULL) { if (IS_A(pNode,NodeBlender)) return ((NodeBlender*)pNode); pNode = pNode->FindNext(); } } return NULL; }

CProfileBiasGain* NodeBlend::GetAttrProfile (   )  [inline]

Definition at line 245 of file nodeblnd.h. { return &m_AttrProfile; }

BOOL NodeBlend::GetBlendDistance (  BOOL  FullDistance, double *  Distance )

To find out how long the blend is. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/99 Parameters: boolean  indicating whether to return the full length of the blendpath [INPUTS] or just the length that is currently occupied by the blend length  of the blend [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Definition at line 2586 of file nodeblnd.cpp. { NodeBlender* pBlender = FindFirstBlender(); double TempDistance = 0.0; while (pBlender != NULL) { if (pBlender->IsBlendedOnCurve()) { NodeBlendPath* pPath = pBlender->GetNodeBlendPath(); if (pPath == NULL) return FALSE; double PathDistance = pPath->GetPathLength(); double StartProportion = 0.0; double EndProportion = 1.0; if (FullDistance ==FALSE) { // the blend may only go part way along the curve, calculate how // much distance the actual blend takes up StartProportion = pBlender->GetProportionOfPathDistStart(); EndProportion = pBlender->GetProportionOfPathDistEnd(); } TempDistance += (PathDistance * (EndProportion - StartProportion)); } else { TempDistance += pBlender->GetLinearDistance(); } pBlender = FindNextBlender(pBlender); } ERROR2IF((TempDistance < 0), FALSE, "Negative path length"); *Distance = TempDistance; return TRUE; }

DocRect NodeBlend::GetBlobBoundingRect (   )  [virtual]

This calls the base classes GetBlobBoundingRect(), and inflates the result by the width of a blob. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/3/95 Returns: DocRect - The bounding rect of the node and its blobs Reimplemented from NodeGroup. Definition at line 1203 of file nodeblnd.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Find the base class blob bounding rectangle DocRect Rect = NodeGroup::GetBlobBoundingRect(); // inflate it by the width of a blob (plus a bit) DocRect TempRect; GetApplication()->GetBlobManager()->GetBlobRect(Rect.lo,&TempRect); INT32 Delta = ((TempRect.hi.x - TempRect.lo.x)*1)/1; Rect.Inflate(Delta); return Rect; #else return DocRect(0,0,0,0); #endif }

DocRect NodeBlend::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 NodeGroup. Definition at line 1237 of file nodeblnd.cpp. { if (IsBoundingRectValid && !DontUseAttrs) return BoundingRectangle; // NOTE! NodeGroup:;GetBoundingRect doesn't set BoundingRectangle if DontUseAttrs is TRUE // It returns a computed value instead. // So this routine must use the return value from calling NodeGroup::GetBoundingRectangle // to return a correct value. return NodeGroup::GetBoundingRect(DontUseAttrs, HitTest); }

ColourBlendType NodeBlend::GetColourBlendType (   )

How exactly will this blend blend colours? Use this func to find out. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/3/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The way the blend blends colours See also: - Definition at line 773 of file nodeblnd.cpp. { return m_ColBlendType; }

static BOOL NodeBlend::GetDefaultAntialias (   )  [inline, static]

Definition at line 220 of file nodeblnd.h. { return !s_DefaultNotAntialiased; }

double NodeBlend::GetDistanceEntered (   )

to return the last distance between blend steps that user entered Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the last distance that the user entered in the edit box, this will be initialised to -1 so if the user has not entered any value then -1 will be returned Definition at line 2722 of file nodeblnd.cpp. { return m_DistanceEntered; }

EditState NodeBlend::GetEditState (   )

lets us know whether to edit the number of steps, or the distance between steps Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 27/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The current state of the m_Edit flag See also: - Definition at line 949 of file nodeblnd.cpp. { return m_Edit; }

EndObject NodeBlend::GetLastEdited (   )

Access function, lets you know which end object of a blend on a path was last edited. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the last object edited, either FIRST, LAST or NONE. Definition at line 2759 of file nodeblnd.cpp. { return m_LastEdited; }

NodeBlendPath * NodeBlend::GetNodeBlendPath (  UINT32  Index  )

Finds the path the blend with try and follow, if it's got one. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/99, changed DY 23/9/99 Parameters: Index  - number of the NodeBlendPath that you want [INPUTS] Returns: Ptr to the NodeBlendPath associated with this blend, or NULL if it aint got one Definition at line 2078 of file nodeblnd.cpp. { Node* pNode = FindFirstChild(); UINT32 NBPCounter = 0; while (pNode) { if (IS_A(pNode,NodeBlendPath)) { //if (((NodeBlendPath*)pNode)->GetPathIndex() == Index) if (NBPCounter == Index) return (NodeBlendPath*)pNode; NBPCounter++; } pNode = pNode->FindNext(); } return NULL; }

UINT32 NodeBlend::GetNodeSize (   )  const [virtual]

For finding the size of the node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The size of the node in bytes See also: Node::GetSubtreeSize Reimplemented from NodeGroup. Definition at line 392 of file nodeblnd.cpp. { return (sizeof(NodeBlend)); }

UINT32 NodeBlend::GetNumBlenders (   )

This counts the number of child nodes that are NodeBlenders. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Num child NodeBlenders for this blend See also: - Definition at line 1073 of file nodeblnd.cpp. { UINT32 Count = 0; Node* pNode = FindFirstChild(); while (pNode != NULL) { if (IS_A(pNode,NodeBlender)) Count++; pNode = pNode->FindNext(); } return Count; }

UINT32 NodeBlend::GetNumBlendSteps (   )

Gets the number of blend steps in this blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Num blend steps in this blend See also: - Definition at line 735 of file nodeblnd.cpp. { return m_NumBlendSteps; }

INT32 NodeBlend::GetNumInkObjects (   )

Used by the AW EPS blend export code to store the number of shapes this blend is blending. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 Parameters: [INPUTS]  [OUTPUTS]  Returns: Returns the number of child ink objects that are NOT blender nodes Errors: Definition at line 1806 of file nodeblnd.cpp. { INT32 Count = 0; Node* pNode = FindFirstChild(); while (pNode != NULL) { if (!IS_A(pNode,NodeBlender) && pNode->IS_KIND_OF(NodeRenderableInk)) Count++; pNode = pNode->FindNext(); } return Count; }

UINT32 NodeBlend::GetNumNodeBlendPaths (   )

Access function. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the number of nodeblend paths this blend is using Definition at line 2796 of file nodeblnd.cpp. { UINT32 NBPCounter = 0; Node* pNode = FindFirstChild(); while (pNode != NULL) { if (pNode->IS_KIND_OF(NodeBlendPath)) NBPCounter++; pNode = pNode->FindNext(); } return NBPCounter; }

BOOL NodeBlend::GetNumStepsFromDistance (  double  Distance, UINT32 *  NumSteps )

To determine the number of steps that will achieve a distance between steps close to the value passed. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/99 Parameters: the  desired distance between steps [INPUTS] number  of steps required to achieve the distance closest to the specified value [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Definition at line 2643 of file nodeblnd.cpp. { ASSERT(Distance); double BlendLength = 0.0; BOOL Valid = GetBlendDistance(TRUE, &BlendLength); if (!Valid) return FALSE; UINT32 TempNumSteps = (UINT32)(BlendLength / Distance); ERROR3IF((TempNumSteps < 0), "Negative number of blend steps"); *NumSteps = TempNumSteps; return TRUE; }

CProfileBiasGain* NodeBlend::GetObjectProfile (   )  [inline]

Definition at line 244 of file nodeblnd.h. { return &m_ObjectProfile; }

BOOL NodeBlend::GetObjectProfileProcessing (   )  [inline]

Definition at line 292 of file nodeblnd.h. { return (objectProfileProcessing); }

NodeCompound * NodeBlend::GetParentController (   )  const [virtual]

If the blend is part of a bevel, shadow, or contour then this returns the parent controller. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Controller node if there is one, or NULL Reimplemented from NodeCompound. Definition at line 3247 of file nodeblnd.cpp. { Node* pParent = (Node*)this->FindParent(); if (pParent == NULL) { ERROR3("This blend has no parents"); return NULL; } while ((pParent != NULL) && (!pParent->IsLayer())) { if (pParent->IsCompoundClass() && pParent->IsController()) return static_cast<NodeCompound*>(pParent); pParent = pParent->FindParent(); } return NULL; }

CProfileBiasGain* NodeBlend::GetPositionProfile (   )  [inline]

Definition at line 246 of file nodeblnd.h. { return &m_PositionProfile; }

BOOL NodeBlend::GetStartAndEndNodes (  Node **  ppStart, Node **  ppEnd )

To find the first and last objects in a blend. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/99 Parameters: -  [INPUTS] pStart  - the first blend object [OUTPUTS] pEnd - the last blend object Returns: TRUE if successful, FALSE if not Definition at line 2938 of file nodeblnd.cpp. { NodeBlender* pFirstBlender = FindFirstBlender(); if (pFirstBlender == NULL) { ERROR3("No first blender"); return FALSE; } *ppStart = pFirstBlender->GetNodeStart(); if (*ppStart == NULL) { ERROR3("No start node"); return FALSE; } NodeBlender* pLastBlender = FindLastBlender(); if (pLastBlender == NULL) { ERROR3("No last blender"); return FALSE; } *ppEnd = pLastBlender->GetNodeEnd(); if (*ppEnd == NULL) { ERROR3("No last node"); return FALSE; } return TRUE; }

BOOL NodeBlend::GetStartAndEndProportions (  double *  StartProp, double *  EndProp )

To find the proportions along the path where the first and last objects are located. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/99 Parameters: -  [INPUTS] StartProp  - the proportion along the nodeblendpath where the first blend object is [OUTPUTS] EndProp - the proportion along the nodeblendpath where the last blend object is Returns: TRUE if successful, FALSE if not, or if the blend is not on a path Definition at line 2882 of file nodeblnd.cpp. { if (m_BlendedOnCurve == FALSE) { ERROR3("Blend is not on a curve"); return FALSE; } NodeBlender* pNodeBlender = FindFirstBlender(); if (pNodeBlender == NULL) { ERROR3("Can't find first blender"); return FALSE; } double TempStartProp = pNodeBlender->GetProportionOfPathDistStart(); if (TempStartProp < 0.0 || TempStartProp > 1.0) { ERROR3("Invalid value for start proportion"); return FALSE; } double TempEndProp = 1.0; while (pNodeBlender != NULL) { TempEndProp = pNodeBlender->GetProportionOfPathDistEnd(); pNodeBlender = FindNextBlender(pNodeBlender); } if (TempEndProp < 0.0 || TempEndProp > 1.0) { ERROR3("Invalid value for end proportion"); return FALSE; } *StartProp = TempStartProp; *EndProp = TempEndProp; return TRUE; }

double NodeBlend::GetStepDistance (   )

works out the distance between each step in the blend Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the distance between steps of the blend Definition at line 2673 of file nodeblnd.cpp. { double BlendLength = 0.0; GetBlendDistance(FALSE, &BlendLength); double StepDistance = BlendLength/m_NumBlendSteps; ERROR2IF((StepDistance < 0), 0, "Negative step distance"); return StepDistance; }

Node * NodeBlend::HasEditableChild (  CCRuntimeClass *  ChildClass, Node *  pPreviousChild )  [virtual]

This function returns our edit node (the NodeBlendPath). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/99 Parameters: ChildClass  = the runtime class of the editable object [INPUTS] pPreviousChild = a pointer to the previous editable child returned by 'this' node, NULL if this is the first call to this node. -  [OUTPUTS] Returns: A node pointer, to an object which forms part of the editable surface of its parent (this node). Reimplemented from Node. Definition at line 2559 of file nodeblnd.cpp. { if (ChildClass != CC_RUNTIME_CLASS(NodePath)) return NULL; NodeBlendPath* pNodeBlendPath = GetNodeBlendPath(0); // check to see if this has already been asked for once if (((Node*)pNodeBlendPath) == pPreviousChild) return NULL; return pNodeBlendPath; }

BOOL NodeBlend::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 434 of file nodeblnd.cpp. { // Call the base class first if (!NodeGroup::HidingNode()) return FALSE; BOOL ok = TRUE; Node* pNode = FindFirstChild(); while (pNode != NULL && ok) { ok = pNode->HidingNode(); pNode = pNode->FindNext(); } return ok; }

BOOL NodeBlend::HitOnDragBlob (  NodeRenderableInk *  pInk, DocCoord  PointerPos )

To find out if the pointer position is within the bounds of the blob in the middle of this node. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/99 Parameters: pInk  - the node to test [INPUTS] PointerPos - the point to test -  [OUTPUTS] Returns: TRUE if PointerPos is within the central blob of pink, else FALSE Definition at line 3062 of file nodeblnd.cpp. { if (pInk == NULL) { ERROR3("Ink node is NULL"); return FALSE; } BOOL ok = FALSE; // find the bounding rect of the centre blob DocRect BlobSize; BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr != NULL) { DocRect BoundingRect = pInk->GetBoundingRect(); DocCoord CentrePoint = BoundingRect.Centre(); pBlobMgr->GetBlobRect(CentrePoint, &BlobSize); ok = BlobSize.ContainsCoord(PointerPos); } return ok; }

BOOL NodeBlend::HitOnEndDragBlob (  DocCoord  Point, Node **  ppHitNode )

To determine whether or not Point is over the central blob of one of the end objects of a blend on a curve. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/99 Parameters: Point  - the point to test [INPUTS] ppHitNode  - the node that was hit, if there was one [OUTPUTS] Returns: TRUE if Point is within the central drag blob of an end node, otherwise false also FALSE if blend is not on a curve Definition at line 3010 of file nodeblnd.cpp. { NodeBlender* pBlender = FindFirstBlender(); BOOL ok = FALSE; while (pBlender != NULL) { /*NodeBlender* pNextBlender =*/ FindNextBlender(pBlender); // only the end objects of blends on curves are editable if (pBlender->IsBlendedOnCurve()) { Node* pFirstNode = pBlender->GetNodeStart(); Node* pLastNode = pBlender->GetNodeEnd(); if (pFirstNode == NULL || pLastNode == NULL) { return FALSE; } ok = HitOnDragBlob((NodeRenderableInk*)pFirstNode, Point); if (ok) { *ppHitNode = pFirstNode; return TRUE; } ok = HitOnDragBlob((NodeRenderableInk*)pLastNode, Point); if (ok) { *ppHitNode = pLastNode; return TRUE; } } pBlender = FindNextBlender(pBlender); } return ok; }

BOOL NodeBlend::InitBlenderPathProportions (  UndoableOperation *  pUndoOp  )

Definition at line 2155 of file nodeblnd.cpp. { BOOL ok = TRUE; UINT32 NumBlenders = GetNumBlenders(); UINT32 CurBlender = 0; double CurProp = 0.0; double PropIncrement = 1.0 / NumBlenders; NodeBlender* pNodeBlender = FindFirstBlender(); while (ok && pNodeBlender != NULL) { CurBlender++; pNodeBlender->SetBlendedOnCurve(TRUE); pNodeBlender->SetProportionOfPathDistStart(CurProp); CurProp += PropIncrement; pNodeBlender->SetProportionOfPathDistEnd(CurProp); pNodeBlender = FindNextBlender(pNodeBlender); } return ok; }

void NodeBlend::InvalidateBlendBoundingRect (   )

This calls InvalidateBoundingRect() on all bounded children of this blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/2/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 1179 of file nodeblnd.cpp. { Node* pNode = FindFirstChild(); while (pNode != NULL) { if (pNode->IsBounded()) ((NodeRenderableBounded*)pNode)->InvalidateBoundingRect(); pNode = pNode->FindNext(); } }

virtual BOOL NodeBlend::IsABlend (   )  [inline, virtual]

Reimplemented from Node. Definition at line 168 of file nodeblnd.h. { return (TRUE); }

BOOL NodeBlend::IsArtWorksEPSCompatible (   )

This asks all the child node blenders if they are AW compatible, and returns TRUE if ALL of them are AW compatible. If the m_AWEPSCompatibleCache flag is TRUE, the current setting of m_AWEPSCompatible is returned, else it is recalculated (setting m_AWEPSCompatibleCache to TRUE in the process). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/94 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if this blend is AW compatible A NodeBlend is only AWEPS compatible if the colour blend type is FADE (i.e. not rainbow or alt rainbow) See NodeBlender::IsArtWorksEPSCompatible() for the other things that must be true for this blend to be AWEPS compatible Returns: Errors: See also: NodeBlender::IsArtWorksEPSCompatible() Definition at line 1771 of file nodeblnd.cpp. { if (!m_AWEPSCompatibleCache) { m_AWEPSCompatible = (m_ColBlendType == COLOURBLEND_FADE); Node* pNode = FindFirstChild(); while (pNode != NULL && m_AWEPSCompatible) { if (IS_A(pNode,NodeBlender)) m_AWEPSCompatible = ((NodeBlender*)pNode)->IsArtWorksEPSCompatible(); pNode = pNode->FindNext(); } m_AWEPSCompatibleCache = TRUE; } return m_AWEPSCompatible; }

BOOL NodeBlend::IsChildOfGroup (   )

to determine whether this nodeblend is part of a nodegroup Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if this is a child of a nodegroup, FALSE otherwise See also: - Definition at line 1002 of file nodeblnd.cpp. { Node* pParent = ((Node*)this)->FindParent(CC_RUNTIME_CLASS(NodeGroup)); if (pParent == NULL) { // ERROR3("This blend has no parent"); return FALSE; } return TRUE; /* if (pParent->IS_KIND_OF(NodeBevelController) || pParent->IS_KIND_OF(NodeContourController) || pParent->IS_KIND_OF(NodeShadowController)) return FALSE; else if (pParent->IS_KIND_OF(NodeGroup)) return TRUE return FALSE;*/ }

BOOL NodeBlend::IsNotAntialiased (   )

Get the state of the NotAntialiased flag for this blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the blend steps should NOT be rendered anti-aliased See also: - Definition at line 830 of file nodeblnd.cpp. { return m_NotAntialiased; }

BOOL NodeBlend::IsOnACurve (   )

Get the state of the m_blendedoncurve flag. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if it blends on a curve See also: - Definition at line 908 of file nodeblnd.cpp. { return m_BlendedOnCurve; }

BOOL NodeBlend::IsOneToOne (   )

Get the state of the OneToOne flag for this blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if blend should be done using one-to-one mapping See also: - Definition at line 792 of file nodeblnd.cpp. { return m_OneToOne; }

BOOL NodeBlend::IsPointOverBlob (  DocCoord *  pPointerPos, BlendPath **  ppBlendPath, INT32 *  pIndex, BOOL *  pAStart, UINT32 *  pRemapRef )

This asks all its child blenders 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 blob belongs to start node, FALSE if end node. Also, if found,*pRemapRef contains a value that should be passed into NodeBlend::Remap(). 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 bool indicating start or end object flag pRemapRef = ptr to place remap ref that's passed into NodeBlend::Remap() *ppBlendPath  & *pIndex & *pAStart & *pRemapRef 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 1570 of file nodeblnd.cpp. { if (pPointerPos == NULL) return FALSE; #if !defined(EXCLUDE_FROM_RALPH) BOOL Found = FALSE; Node* pNode = FindFirstChild(); while (pNode != NULL && !Found) { if (IS_A(pNode,NodeBlender)) { Found = ((NodeBlender*)pNode)->IsPointOverBlob(pPointerPos,ppBlendPath,pIndex,pAStart); if (Found) *pRemapRef = pNode->GetTag(); } pNode = pNode->FindNext(); } return Found; #else return FALSE; #endif }

BOOL NodeBlend::IsTangential (   )

Get the state of the m_Tangential flag for this blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/5/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if it blends on a curve tangentially See also: - Definition at line 869 of file nodeblnd.cpp. { return m_Tangential; }

virtual BOOL NodeBlend::IsTypeExtendible (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 314 of file nodeblnd.h. { return TRUE; }

NodeBlender * NodeBlend::NodeIsPartOfBlender (  Node *  pNode, NodeBlender *  pBlender, BOOL *  First )

Overridden version of above, now that we have multi stage blends which can go to and from arbitrary end points we can't always rely on knowing the end position. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/99 Parameters: pNode  - the node to look for [INPUTS] pBlender - the blender that we already know pNode belongs to First,whether  the node is first on last in the newly found blender [OUTPUTS] Returns: the nodeblender which uses pNode and is not pBlender Definition at line 3187 of file nodeblnd.cpp. { if (pNode == NULL) { ERROR3("Node is NULL"); return NULL; } NodeBlender* pNodeBlender = FindFirstBlender(); if (pNodeBlender == NULL) { ERROR3("No nodeblender"); return NULL; } while (pNodeBlender != NULL) { if (pNodeBlender != pBlender) { Node* pStart = pNodeBlender->GetNodeStart(); Node* pEnd = pNodeBlender->GetNodeEnd(); if (pStart == NULL || pEnd == NULL) { ERROR3("Start or end node is NULL"); return NULL; } if (pStart == pNode) { *First = TRUE; return pNodeBlender; } else if (pEnd == pNode) { *First = FALSE; return pNodeBlender; } } pNodeBlender = FindNextBlender(pNodeBlender); } return NULL; }

NodeBlender * NodeBlend::NodeIsPartOfBlender (  Node *  pNode, BOOL  FirstNode )

To find out if pNode is used by a blender in this nodeblend at the position specified. Useful if you are changing the node through a different blender and wish to update related blends. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/99 Parameters: [INPUTS]  pNode - the node to look for -  [OUTPUTS] Returns: the nodeblender which uses pNode at the specified position Definition at line 3136 of file nodeblnd.cpp. { if (pNode == NULL) { ERROR3("Node is NULL"); return NULL; } NodeBlender* pNodeBlender = FindFirstBlender(); if (pNodeBlender == NULL) { ERROR3("No nodeblender"); return NULL; } while (pNodeBlender != NULL) { if (FirstNode) { Node* pCheckFirstNode = pNodeBlender->GetNodeStart(); if (pCheckFirstNode == pNode) return pNodeBlender; } else { Node* pCheckLastNode = pNodeBlender->GetNodeEnd(); if (pCheckLastNode == pNode) return pNodeBlender; } pNodeBlender = FindNextBlender(pNodeBlender); } return NULL; }

BOOL NodeBlend::NonLinearObjectProfile (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the blend currently has a non-linear object profile, otherwise false Definition at line 2986 of file nodeblnd.cpp. { if (m_ObjectProfile.GetBias() != 0.0) return TRUE; if (m_ObjectProfile.GetGain() != 0.0) return TRUE; return FALSE; }

ChangeCode NodeBlend::OnChildChange (  ObjChangeParam *  pParam  )  [virtual]

This function should be overridden in derived object classes. Composite objects can use this function to respond to one of their children undergoing a change. They should return CC_FAIL whenever they are unable to cope with the change. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 06/02/95 Parameters: pParam  = pointer to a object change parameter class [INPUTS] Returns: CC_OK if we have successfully processed the change. CC_FAIL if we cannot handle this particular change and must prevent the child from continuing Blends deinitialise, then reinitialise themselves. Hopefully that should do the trick. See also: WarnParentOfChange(),AllowOp(); Reimplemented from NodeGroup. Definition at line 1970 of file nodeblnd.cpp. { ERROR2IF(pParam == NULL,CC_FAIL,"pParam == NULL"); ObjChangeType cType = pParam->GetChangeType(); ObjChangeFlags cFlags = pParam->GetChangeFlags(); if (cType == OBJCHANGE_FINISHED) { UndoableOperation* pUndoOp = pParam->GetOpPointer(); // Node* pNodeChanging = pParam->GetChangeObj(); UINT32 NBPCounter = 0; NodeBlendPath* pNodeBlendPath = GetNodeBlendPath(NBPCounter++); // BOOL NodeBlendPathEdited = (pNodeChanging != NULL && pNodeChanging == pNodeBlendPath); // if the op has finished, and we're either the parent of a selected node OR an attribute // was applied OR our node blend path has been edited, deinit the blend in an undoable way while (pNodeBlendPath != NULL) { pNodeBlendPath->OnEdited(pParam); if (!TransformBlendEndObjects(pUndoOp)) return CC_FAIL; pNodeBlendPath = GetNodeBlendPath(NBPCounter++); } if (pUndoOp != NULL) { if (InitBlendAction::Init(pUndoOp,pUndoOp->GetUndoActionList(),this, FALSE, FALSE, cFlags.RegenerateNode) == AC_FAIL) return CC_FAIL; if (!pUndoOp->DoInvalidateNodeRegion(this, TRUE, FALSE, FALSE, !pParam->GetRetainCachedData())) return CC_FAIL; } else { // If no undo op ptr, deinit the blend in a non-undoable way InvalidateBlendBoundingRect(); Deinit(cFlags.RegenerateNode); DocRect rect = GetUnionBlobBoundingRect(); Document* pDoc = (Document*)FindOwnerDoc(); Spread* pSpread = FindParentSpread(); if (pDoc != NULL && pSpread != NULL && pDoc->IS_KIND_OF(Document)) pDoc->ForceRedraw(pSpread, rect, FALSE, this); } } return CC_OK; }

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

Does nothing at the moment - Just returns FALSE. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/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: TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented from NodeGroup. Definition at line 414 of file nodeblnd.cpp. { // we did not use the click, so let someone else try return FALSE; }

BOOL NodeBlend::OnNodePopUp (  Spread *  pSpread, DocCoord  PointerPos, ContextMenu *  pMenu )  [virtual]

Allows the Blend to respond to pop up menu clicks on itself. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/5/95 Parameters: pSpread  The spread in which things are happening [INPUTS] PointerPos The Location of the mouse pointer at the time of the click pMenu The menu to which items should be added 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 2041 of file nodeblnd.cpp. { //WEBSTER-ranbirr-01/12/96 #ifndef WEBSTER #if !defined(EXCLUDE_FROM_RALPH) BOOL ok = TRUE; ok = ok && pMenu->BuildCommand(TOOL_OPTOKEN_BLEND, TRUE); // ok = ok && pMenu->BuildCommand(OPTOKEN_ADDBLENDPATH, TRUE); // ok = ok && pMenu->BuildCommand(OPTOKEN_REMOVEBLEND, FALSE); // ok = ok && pMenu->BuildCommand(OPTOKEN_BLENDONETOONE, FALSE); // ok = ok && pMenu->BuildCommand(OPTOKEN_BLENDANTIALIAS, TRUE); return ok; #else return FALSE; #endif #else //webster return FALSE; #endif //webster }

void NodeBlend::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 NodeGroup. Definition at line 366 of file nodeblnd.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeBlend), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeBlend)) CopyNodeContents((NodeBlend*)pNodeCopy); }

BOOL NodeBlend::PostImport (  void   )  [virtual]

This is called after the entire doc has been imported It first deinits the blend (in case they are initialised currently), then reinits the blend, returning the result. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/5/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Reimplemented from Node. Definition at line 1158 of file nodeblnd.cpp. { Deinit(); InvalidateBlendBoundingRect(); return Reinit(FALSE); }

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

Called before this node or any of its children have been rendered to the export region. This outputs the "start blend" 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 NodeGroup. Definition at line 1655 of file nodeblnd.cpp. { #ifdef DO_EXPORT if (IS_A(pRegion, CamelotEPSRenderRegion)) // We ust want the paths in EPS. return; if (pRegion->IS_KIND_OF(ArtWorksEPSRenderRegion)) { EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); if (pRegion->IS_KIND_OF(CamelotEPSRenderRegion)) { // Output the Camelot format for blends pDC->OutputValue(INT32(0)); // Reserved INT32 1 pDC->OutputValue(INT32(0)); // Reserved INT32 2 pDC->OutputValue(INT32(0)); // Reserved INT32 3 pDC->OutputValue(INT32(m_ColBlendType)); // Colour blend type (fade, rainbow or alt rainbow) pDC->OutputValue(INT32(m_OneToOne)); // The "blend using a one to one mapping" flag pDC->OutputValue(INT32(m_NotAntialiased)); // The "don't antialias blend steps" flag pDC->OutputValue(INT32(m_NumBlendSteps)); // Num blend steps pDC->OutputValue(INT32(1)); // Version (Important that this is the last param!!!) pDC->OutputToken(_T("csbd")); // Camelot "start blend" token pDC->OutputNewLine(); } else { // Use a cached flag set up by the next call to IsArtWorksEPSCompatible() // The same function is called by every child blender, so we don't want to do this (possibly) // time consuming task more than once per blend. m_AWEPSCompatibleCache = FALSE; if (IsArtWorksEPSCompatible()) { // Output the AW format for blends, if this blend is ArtWorks-compatible pDC->OutputValue(INT32(1)); // Version pDC->OutputValue(INT32(0)); // Expanded flag pDC->OutputValue(GetNumInkObjects()); // Num objects we are blending pDC->OutputToken(_T("asbd")); // ArtWorks "start blend" token pDC->OutputNewLine(); } } } #endif }

BOOL NodeBlend::Reinit (  BOOL  ProgressBar = TRUE  )

This calls Reinit() on all child blenders. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/1/95 Parameters: ProgressBar  = if TRUE, a progress bar will be displayed [INPUTS] -  [OUTPUTS] Returns: TRUE if all child blenders reinit OK See also: - Definition at line 1100 of file nodeblnd.cpp. { Node* pNode = FindFirstChild(); while (pNode != NULL) { if (IS_A(pNode,NodeBlender)) { if (!((NodeBlender*)pNode)->Reinit(NULL,NULL,ProgressBar)) return FALSE; } pNode = pNode->FindNext(); } return TRUE; }

BOOL NodeBlend::ReinitialiseOnChildChanged (  UndoableOperation *  pOp, NodeRenderableInk *  pOldChild, NodeRenderableInk *  pNewChild )

Used by the shadowing code to reinitialise the blend when one of the blended nodes has had a shadow applied to it. In this case, the tree structure has changed, and the blend framework needs to know this. Returns: TRUE if success, FALSE otherwise. Errors: ERROR2 if any parameters are NULL. Definition at line 3703 of file nodeblnd.cpp. { // validate input params. ERROR2IF(pOp == NULL || pOldChild == NULL || pNewChild == NULL, FALSE, "NodeBlend::ReinitialiseOnChildChanged; NULL input parameters!"); // iterate over our NodeBlenders, looking for a ptr to the old child. NodeBlender* pBlender = FindFirstBlender(); while (pBlender != NULL) { // reinitialise the first blended node. if (pBlender->GetNodeStart() == pOldChild) { if (InitBlendAction::InitOnBlender(pOp, pOp->GetUndoActionList(), pBlender, TRUE, TRUE) == AC_FAIL) { ERROR3("NodeBlend::ReinitialiseOnChildChanged; couldn't init blend action"); } pBlender->Reinit(pNewChild, NULL, FALSE); } // reinitialise the second blended node. // (should be 'else if' here, but for robustness, we'll just use 'if'). if (pBlender->GetNodeEnd() == pOldChild) { if (InitBlendAction::InitOnBlender(pOp, pOp->GetUndoActionList(), pBlender, TRUE, TRUE) == AC_FAIL) { ERROR3("NodeBlend::ReinitialiseOnChildChanged; couldn't init blend action"); } pBlender->Reinit(NULL, pNewChild, FALSE); } pBlender = FindNextBlender(pBlender); } return TRUE; }

BOOL NodeBlend::Remap (  UINT32  RemapRef, DocCoord  PosStart, DocCoord  PosEnd, DocCoord *  pInvPosStart, DocCoord *  pInvPosEnd )

This will ask the child blender referenced by RemapRef to remap its blend paths with the given params. If the child 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: RemapRef  = special remap ref value allowing blend to identify blender to remap [INPUTS] PosStart = Coord of element to remap start node to 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 1620 of file nodeblnd.cpp. { BOOL Mapped = FALSE; Node* pNode = FindFirstChild(); while (pNode != NULL && !Mapped) { if (pNode->GetTag() == RemapRef && IS_A(pNode,NodeBlender)) Mapped = ((NodeBlender*)pNode)->Remap(PosStart,PosEnd,pInvPosStart,pInvPosEnd); pNode = pNode->FindNext(); } return Mapped; }

void NodeBlend::RenderBlendBlobs (  RenderRegion *  pRender  )  [virtual]

This renders all the blobs associated with this blend node This node doesn't do any rendering itself. All it does is ask its child blender nodes to render their blend blobs. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/11/94 Parameters: pRender  = render region to render into [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 1309 of file nodeblnd.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // The problem we have with this routine is that two adjacent blenders will reference the same // object, hence if we ask all blenders to render blobs for both its objects, blobs will get // rendered twice, EORing themselves off again. // So, we ask all but the last blender to just render the start object, then get the last one // to render both. Node* pLast = NULL; // Find the last blender Node* pNode = FindFirstChild(); while (pNode != NULL) { if (IS_A(pNode,NodeBlender)) pLast = pNode; pNode = pNode->FindNext(); } // Render the blender blobs pNode = FindFirstChild(); // altered by Diccon 3/9/99 to render the blobs of a blend on a path differently // so that it is apparent that the position of the end objects can be altered. // probably deserves a separate function but for now.. if (m_BlendedOnCurve == FALSE) { while (pNode != NULL) { if (IS_A(pNode,NodeBlender)) { BOOL RenderStart = TRUE; BOOL RenderEnd = FALSE; if (pNode == pLast) RenderEnd = TRUE; ((NodeBlender*)pNode)->RenderBlendBlobs(pRender,RenderStart,RenderEnd); } pNode = pNode->FindNext(); } } else RenderBlendOnCurveBlobs(pRender); #endif }

void NodeBlend::RenderBlendOnCurveBlobs (  RenderRegion *  pRegion  )

This renders all the blobs associated with this blend node if it is on a curve. It needs to render blobs on the editable nodes, i.e. if the whole thing is on a curve then the first and last nodes are editable. if a blend on curve is blended to a straight blend then only the end on the curve is editable. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/99 Parameters: pRender  = render region to render into [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 1374 of file nodeblnd.cpp. { NodeBlender* pNodeBlender = FindFirstBlender(); while (pNodeBlender != NULL) { NodeBlender* pNextBlender = FindNextBlender(pNodeBlender); if (pNodeBlender->IsBlendedOnCurve()) { Node* pStart = pNodeBlender->GetNodeStart(); Node* pEnd = pNodeBlender->GetNodeEnd(); if (pStart == NULL || pEnd == NULL) { ERROR3("This blender has no start and end"); return; } else { BOOL bFinish = FALSE; Node* pNodeToRender = pStart; DocCoord FirstPoint(0,0); while (bFinish == FALSE) { if (pNodeToRender->IsABaseTextClass()) { pRegion->SetLineColour(COLOUR_BEZIERBLOB); pRegion->SetFillColour(COLOUR_BEZIERBLOB); } else { pRegion->SetLineColour(COLOUR_UNSELECTEDBLOB); pRegion->SetFillColour(COLOUR_UNSELECTEDBLOB); } // Draw a blob at the centre point DocRect BlobSize; BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr != NULL) { DocRect BoundingRect = ((NodeRenderableBounded*)pNodeToRender)->GetBoundingRect(); DocCoord Point = BoundingRect.Centre(); // we may be blended on a circle in which case the start and end nodes will be in the same // place. In this case only do the first one if (pNodeToRender == pStart) FirstPoint = Point; else { // in fact as it turns out they may not be exactly in the same place, but very close double Distance = Point.Distance((Coord)FirstPoint); if (Distance < 10) break; } pBlobMgr->GetBlobRect(Point, &BlobSize); if (pNodeToRender->IsABaseTextClass()) { pRegion->DrawBlob(Point, BT_UNSELECTED); } else { pRegion->DrawLine(DocCoord(BlobSize.hi.x, BlobSize.hi.y), DocCoord(BlobSize.lo.x, BlobSize.lo.y)); pRegion->DrawLine(DocCoord(BlobSize.lo.x, BlobSize.hi.y), DocCoord(BlobSize.hi.x, BlobSize.lo.y)); pRegion->DrawPixel(DocCoord(BlobSize.hi.x, BlobSize.lo.y)); pRegion->DrawPixel(DocCoord(BlobSize.lo.x, BlobSize.lo.y)); } } if (pNodeToRender == pStart && pNextBlender == NULL) pNodeToRender = pEnd; else bFinish = TRUE; } } // end while } // End if on curve pNodeBlender = pNextBlender; } return; }

void NodeBlend::RenderObjectBlobs (  RenderRegion *  pRegion  )  [virtual]

Renders the object blobs. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/3/95 Parameters: pRender  - The region to draw the blobs in [INPUTS] Reimplemented from NodeGroup. Definition at line 1260 of file nodeblnd.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Find out about the groups bounding rect DocRect BoundingRect = GetBoundingRect(); // Inflate the bounds by the width of a blob DocRect TempRect; GetApplication()->GetBlobManager()->GetBlobRect(BoundingRect.lo,&TempRect); INT32 Delta = ((TempRect.hi.x - TempRect.lo.x)*3)/4; BoundingRect.Inflate(Delta); // Find out where to draw the blobs DocCoord Low = BoundingRect.LowCorner(); DocCoord High = BoundingRect.HighCorner(); // Set the colours of the blobs pRegion->SetFillColour(COLOUR_UNSELECTEDBLOB); pRegion->SetLineColour(COLOUR_NONE); // Draw all the blobs pRegion->DrawBlob(Low, BT_UNSELECTED); pRegion->DrawBlob(High, BT_UNSELECTED); pRegion->DrawBlob(DocCoord(Low.x, High.y), BT_UNSELECTED); pRegion->DrawBlob(DocCoord(High.x, Low.y), BT_UNSELECTED); /* NodeBlendPath* pNodeBlendPath = GetNodeBlendPath(); if (pNodeBlendPath) pNodeBlendPath->RenderObjectBlobs(pRegion); */ #endif }

void NodeBlend::RequestObjectProfileProcessing (  BOOL  newVal  )  [inline]

Definition at line 291 of file nodeblnd.h. { objectProfileProcessing = newVal; }

void NodeBlend::ResetVars (   )  [private]

This sets all the member vars to the state they should be in on construction. All constructors should call this func. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/94 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: Definition at line 246 of file nodeblnd.cpp. { m_NumBlendSteps = NUM_DEFAULT_BLENDSTEPS; m_OneToOne = FALSE; m_NotAntialiased = s_DefaultNotAntialiased; m_ColBlendType = COLOURBLEND_FADE; m_Tangential = FALSE; m_BlendedOnCurve = FALSE; m_Edit = EDIT_STEPS; m_DistanceEntered = -1; m_LastEdited = NONE; m_NumNodeBlendPaths = 0; objectProfileProcessing = FALSE; UpdateStepDistance(); }

BOOL NodeBlend::RotateBlendEndObjectsBack (  UndoableOperation *  pUndoOp  )

Definition at line 2178 of file nodeblnd.cpp. { BOOL ok = TRUE; Node* pLast = NULL; NodeBlender* pNodeBlender = FindFirstBlender(); while (ok && pNodeBlender != NULL) { NodeRenderableInk* pStart = pNodeBlender->GetNodeStart(); NodeRenderableInk* pEnd = pNodeBlender->GetNodeEnd(); if (pStart && pStart != pLast) { double AngleChange = -pNodeBlender->GetAngleStart(); ok = TransformNodeToPoint(pStart,NULL,pUndoOp,AngleChange); if (ok && pUndoOp && AngleChange != 0.0) { ChangeBlenderOpParam ChangeParam(CHANGEBLENDER_ANGLESTART); ChangeParam.m_NewAngleStart = 0.0; ActionCode Ac = ChangeBlenderAction::Init( pUndoOp,pUndoOp->GetUndoActionList(), pNodeBlender,ChangeParam); ok = (Ac !=AC_FAIL); } } if (pEnd && ok) { double AngleChange = -pNodeBlender->GetAngleEnd(); ok = TransformNodeToPoint(pEnd,NULL,pUndoOp,AngleChange); if (ok && pUndoOp && AngleChange != 0.0) { ChangeBlenderOpParam ChangeParam(CHANGEBLENDER_ANGLEEND); ChangeParam.m_NewAngleEnd = 0.0; ActionCode Ac = ChangeBlenderAction::Init( pUndoOp,pUndoOp->GetUndoActionList(), pNodeBlender,ChangeParam); ok = (Ac !=AC_FAIL); } pLast = pEnd; } pNodeBlender = FindNextBlender(pNodeBlender); } return ok; }

void NodeBlend::SetBlendedOnCurve (  BOOL  state  )

Set the state of the m_BlendedOnCurve flag for this blend. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/9/99 Parameters: state  = TRUE if it blends on a curve [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 928 of file nodeblnd.cpp. { m_BlendedOnCurve = state; }

void NodeBlend::SetColourBlendType (  ColourBlendType  Type  )

Sets up the way this blend blends colours. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/3/95 Parameters: Type  = the way colours are blended (i.e. fade, rainbow, or alt rainbow) [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 754 of file nodeblnd.cpp. { m_ColBlendType = Type; }

void NodeBlend::SetDistanceEntered (  double  Distance  )

to set the distance between blend steps that user entered Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/99 Parameters: Distance  between steps to set [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2740 of file nodeblnd.cpp. { m_DistanceEntered = Distance; }

void NodeBlend::SetEditState (  EditState  State  )

sets the type to edit according to which button is selected on the infobar. Also initialises the m_DistanceEntered member if it has not already been initialised. This is in case the user selected distance edit but does not enter a value. In this case, if the user has not selected a previous value I assume that they wish to keep the value generated. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 27/9/99 Parameters: the  type to edit (can be EDIT_DISTANCE or EDIT_STEPS) [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 976 of file nodeblnd.cpp. { m_Edit = State; if (m_DistanceEntered == -1.0) { // first update in case something has changed UpdateStepDistance(); m_DistanceEntered = GetStepDistance(); } }

void NodeBlend::SetLastEdited (  EndObject  LastEdited  )

Access function. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/99 Parameters: Object  last edited [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2777 of file nodeblnd.cpp. { m_LastEdited = LastEdited; }

void NodeBlend::SetNotAntialiased (  BOOL  state  )

Set the state of the NotAntialiased flag for this blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/11/94 Parameters: state  = TRUE if the blend steps should NOT be rendered anti-aliased [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 849 of file nodeblnd.cpp. { m_NotAntialiased = state; s_DefaultNotAntialiased = state; }

void NodeBlend::SetNumBlendSteps (  UINT32  NumSteps  )

Sets the number of blend steps in this blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/11/94 Parameters: NumSteps  = num steps to set in this blend [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 716 of file nodeblnd.cpp. { m_NumBlendSteps = NumSteps; }

void NodeBlend::SetNumNodeBlendPaths (  INT32  Index  )

Record a change in the number of nodeblendpaths. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/9/99 Parameters: Index  - number that you wish to set [INPUTS] -  [OUTPUTS] Returns: - Errors: If m_NumNodeBlendPaths = 0 and Increment = FALSE Definition at line 2855 of file nodeblnd.cpp. { if (Index < 0) { ERROR3("Index is less than zero"); return; } else m_NumNodeBlendPaths = Index; }

void NodeBlend::SetNumNodeBlendPathsInc (  BOOL  Increase  )

Record a change in the number of nodeblendpaths. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/9/99 Parameters: Increase  - TRUE if you wish to add, FALSE if you want to take away [INPUTS] -  [OUTPUTS] Returns: - Errors: If m_NumNodeBlendPaths = 0 and Increment = FALSE Definition at line 2825 of file nodeblnd.cpp. { if (Increase) m_NumNodeBlendPaths++; else { if (m_NumNodeBlendPaths == 0) { ERROR3("Blend has no nodeblend paths"); return; } m_NumNodeBlendPaths--; } }

void NodeBlend::SetOneToOne (  BOOL  state  )

Set the state of the OneToOne flag for this blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/11/94 Parameters: state  = TRUE if blend should be done using one-to-one [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 811 of file nodeblnd.cpp. { m_OneToOne = state; }

void NodeBlend::SetTangential (  BOOL  state  )

Set the state of the m_Tangential flag for this blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 29/11/94 Parameters: state  = TRUE if it blends on a curve tangentially [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 888 of file nodeblnd.cpp. { m_Tangential = state; }

BOOL NodeBlend::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 464 of file nodeblnd.cpp. { // Call the base class first if (!NodeGroup::ShowingNode()) return FALSE; // This doesn't need to be done!!! // The caller of ShowingNode recurses through the subtree by itself // BOOL ok = TRUE; // Node* pNode = FindFirstChild(); // while (pNode != NULL && ok) // { // ok = pNode->ShowingNode(); // pNode = pNode->FindNext(); // } // // return ok; return TRUE; }

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

This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A copy of the node, or NULL if memory has run out Errors: If memory runs out when trying to copy, then ERROR is called with an out of memory error and the function returns NULL. Reimplemented from NodeGroup. Definition at line 309 of file nodeblnd.cpp. { NodeBlend* pCopyOfNode = new NodeBlend(); ERROR1IF(pCopyOfNode == NULL,NULL,_R(IDE_NOMORE_MEMORY)); CopyNodeContents(pCopyOfNode); return (pCopyOfNode); }

BOOL NodeBlend::TransformBlendEndObjects (  UndoableOperation *  pUndoOp  )

Definition at line 2224 of file nodeblnd.cpp. { BOOL ok = TRUE; Node* pLast = NULL; NodeBlender* pNodeBlender = FindFirstBlender(); while (ok && pNodeBlender != NULL) { NodeRenderableInk* pStart = pNodeBlender->GetNodeStart(); NodeRenderableInk* pEnd = pNodeBlender->GetNodeEnd(); ERROR3IF(pStart == NULL,"No start node"); ERROR3IF(pEnd == NULL,"No end node"); if ((pStart == NULL) || (pEnd == NULL)) { return (FALSE); } DocCoord Point; double Angle = 0.0; if (pStart && pStart != pLast) { if (pNodeBlender->GetPointOnNodeBlendPath(0.0,&Point,&Angle)) { double AngleStart = pNodeBlender->GetAngleStart(); double AngleChange = Angle - AngleStart; ok = TransformNodeToPoint(pStart,&Point,pUndoOp,AngleChange); if (ok && pUndoOp && AngleChange != 0.0) { ChangeBlenderOpParam ChangeParam(CHANGEBLENDER_ANGLESTART); ChangeParam.m_NewAngleStart = AngleStart + AngleChange; ActionCode Ac = ChangeBlenderAction::Init( pUndoOp,pUndoOp->GetUndoActionList(), pNodeBlender,ChangeParam); ok = (Ac !=AC_FAIL); } } } if (pEnd && ok) { if (pNodeBlender->GetPointOnNodeBlendPath(1.0,&Point,&Angle)) { double AngleEnd = pNodeBlender->GetAngleEnd(); double AngleChange = Angle - AngleEnd; ok = TransformNodeToPoint(pEnd,&Point,pUndoOp,AngleChange); ERROR3IF (!ok, "one does not find this amusing!"); if (ok && pUndoOp && AngleChange != 0.0) { ChangeBlenderOpParam ChangeParam(CHANGEBLENDER_ANGLEEND); ChangeParam.m_NewAngleEnd = AngleEnd + AngleChange; ActionCode Ac = ChangeBlenderAction::Init( pUndoOp,pUndoOp->GetUndoActionList(), pNodeBlender,ChangeParam); ok = (Ac !=AC_FAIL); } } pLast = pEnd; } pNodeBlender = FindNextBlender(pNodeBlender); } return ok; }

BOOL NodeBlend::TransformNodeToPoint (  NodeRenderableInk *  pNode, DocCoord *  pPoint, UndoableOperation *  pUndoOp, double  Angle )

Definition at line 2288 of file nodeblnd.cpp. { ERROR2IF(pNode == NULL,FALSE,"Null node ptr"); BOOL ok = TRUE; // Get the node's bounds pNode->InvalidateBoundingRect(TRUE); DocRect Rect = pNode->GetBoundingRect(); // Work out the translation that will move the centre of the bounds onto the given point DocCoord centre = Rect.Centre(); //(Rect.lox + (Rect.Width()/2),Rect.loy + (Rect.Height()/2)); INT32 dx = 0; INT32 dy = 0; if (pPoint) { dx = pPoint->x - centre.x; dy = pPoint->y - centre.y; } if (pUndoOp) { // DoTransformNode() needs an instance of the matrix. It gets deleted when the action is destroyed if (Angle != 0.0) { Trans2DMatrix* pRotate = new Trans2DMatrix(centre,Angle); if (ok) { RangeControl rc(TRUE,TRUE); rc.SiblingsOnly = TRUE; // Don't look at children - stops children getting // transformed twice when select-inside is present Range r(pNode,pNode, rc); ok = pUndoOp->DoTransformNodes(r,pRotate); } } if (dx != 0 || dy != 0) { Trans2DMatrix* pTrans = new Trans2DMatrix(dx,dy); if (ok) { RangeControl rc(TRUE,TRUE); rc.SiblingsOnly = TRUE; // Don't look at children - stops children getting // transformed twice when select-inside is present Range r(pNode,pNode, rc); ok = pUndoOp->DoTransformNodes(r,pTrans); } } } else { // Non-undoable form of the transform if (Angle != 0.0) { Trans2DMatrix Rotate(centre,Angle); pNode->Transform(Rotate); } if (dx != 0 || dy != 0) { Trans2DMatrix Trans(dx,dy); pNode->Transform(Trans); } } return ok; }

void NodeBlend::UpdateStepDistance (   )

works out the distance between each step in the blend and updates the member variable Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2697 of file nodeblnd.cpp. { double BlendLength = 0.0; GetBlendDistance(FALSE, &BlendLength); m_StepDistance = BlendLength/m_NumBlendSteps; }

DocRect NodeBlend::ValidateExtend (  const ExtendParams &  ExtParams  )  [virtual]

Checks whether or not performing an extend operation on this node will leave it in a state from which it would be impossible to return. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 26/11/1999 Parameters: ExtParams  extend description parameters. [INPUTS] [OUTPUTS]  Returns: TRUE if this node and its children cannot be validly extended, FALSE otherwise. In the case of a NodeBlend, we consider its children, which will be the ones to move under a blend. Under extension, the choice of which child nodes to extend is fairly complicated - see NodeBlend::FindExtendingChildren for more information. Returns: Errors: See also: NodeBlend::Extend, NodeBlend::FindExtendingChildren. Reimplemented from Node. Definition at line 3767 of file nodeblnd.cpp. { // the routine for finding extending nodes may take a while, so check first // whether we're actually doing any extending, and if not, leave now. if (!(ExtParams.fExtendFlags & X_EXTEND) && !(ExtParams.fExtendFlags & Y_EXTEND)) return DocRect(INT32_MAX, INT32_MAX, INT32_MAX, INT32_MAX); // okay, compile lists of child nodes to validate for extension. std::list<NodeRenderableInk*> lpInks; std::list<NodeBlendPath*> lpBlendPaths; FindExtendingChildren(lpInks, lpBlendPaths); // under non-stretch extension, a blend's child nodes behave in two ways. // if the child node is a blend-path, it is extended, and requires validation, as a path. // we test blend-paths first, as these are more likely to invalidate the extension. DocRect drMinExtend(INT32_MAX, INT32_MAX, INT32_MAX, INT32_MAX), drThisMinExtend; for ( std::list<NodeBlendPath*>::iterator iterPath = lpBlendPaths.begin(); iterPath != lpBlendPaths.end(); iterPath ++ ) { drThisMinExtend = ((NodeBlendPath*)(*iterPath))->ValidateExtend(ExtParams); if (drMinExtend.lo.x > drThisMinExtend.lo.x) drMinExtend.lo.x = drThisMinExtend.lo.x; if (drMinExtend.lo.y > drThisMinExtend.lo.y) drMinExtend.lo.y = drThisMinExtend.lo.y; if (drMinExtend.hi.x > drThisMinExtend.hi.x) drMinExtend.hi.x = drThisMinExtend.hi.x; if (drMinExtend.hi.y > drThisMinExtend.hi.y) drMinExtend.hi.y = drThisMinExtend.hi.y; } // Karim 17/04/2000 // We're changing things so that blended objects actually extend, rather than translate. // This _may_ cause some havoc with blend-on-a-path... /* // if it is any other ink node, it is translated as a whole, so its centre needs testing. INT32 i = 0; INT32 numInks = lpInks.size(); DocCoord* doccArray = new DocCoord[numInks]; for ( std::list<NodeRenderableInk*>::iterator iterInk = lpInks.begin(); iterInk != lpInks.end(); iterInk ++ ) { doccArray[i ++] = ((NodeRenderableInk*)(*iterInk))->FindExtendCentre(); } drThisMinExtend = Extender::ValidateControlPoints(numInks, doccArray, ExtParams); if (drMinExtend.lox > drThisMinExtend.lox) drMinExtend.lox = drThisMinExtend.lox; if (drMinExtend.loy > drThisMinExtend.loy) drMinExtend.loy = drThisMinExtend.loy; if (drMinExtend.hix > drThisMinExtend.hix) drMinExtend.hix = drThisMinExtend.hix; if (drMinExtend.hiy > drThisMinExtend.hiy) drMinExtend.hiy = drThisMinExtend.hiy; delete doccArray; */ // if it is any other ink node, it is extended as if it is not even in a blend, // so we validate it as normal. /*size_t numInks = */lpInks.size(); for ( std::list<NodeRenderableInk*>::iterator iterInk = lpInks.begin(); iterInk != lpInks.end(); iterInk ++ ) { drThisMinExtend = ((NodeRenderableInk*)(*iterInk))->ValidateExtend(ExtParams); if (drMinExtend.lo.x > drThisMinExtend.lo.x) drMinExtend.lo.x = drThisMinExtend.lo.x; if (drMinExtend.lo.y > drThisMinExtend.lo.y) drMinExtend.lo.y = drThisMinExtend.lo.y; if (drMinExtend.hi.x > drThisMinExtend.hi.x) drMinExtend.hi.x = drThisMinExtend.hi.x; if (drMinExtend.hi.y > drThisMinExtend.hi.y) drMinExtend.hi.y = drThisMinExtend.hi.y; } return drMinExtend; }

BOOL NodeBlend::WritePreChildren (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes the blend record to the filter. > virtual BOOL NodeBlend::WritePreChildren(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: - Definition at line 3524 of file nodeblnd.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); BOOL ok = TRUE; // Diccon 9/99 added profile record if (ok) { CXaraFileRecord ProfileRec(TAG_BLENDPROFILES, TAG_BLENDPROFILES_SIZE); ok = ProfileRec.Init(); if (ok) ok = ProfileRec.WriteDOUBLE(m_ObjectProfile.GetBias()); if (ok) ok = ProfileRec.WriteDOUBLE(m_ObjectProfile.GetGain()); if (ok) ok = ProfileRec.WriteDOUBLE(m_AttrProfile.GetBias()); if (ok) ok = ProfileRec.WriteDOUBLE(m_AttrProfile.GetGain()); if (ok) ok = ProfileRec.WriteDOUBLE(/*m_PositionProfile.GetBias()*/0.0); if (ok) ok = ProfileRec.WriteDOUBLE(/*m_PositionProfile.GetGain()*/0.0); if (ok) ok = pFilter->Write(&ProfileRec); } CXaraFileRecord Rec(TAG_BLEND,TAG_BLEND_SIZE); UINT16 NumSteps = UINT16(m_NumBlendSteps); BYTE Flags =( m_OneToOne << 0) | ((m_NotAntialiased == 0) << 1) | ( m_Tangential << 2); ERROR3IF(BYTE(m_ColBlendType) > (1 << TAG_BLEND_COLEFFECT_SHIFT),"Col blend type will not fit into the flags byte"); BYTE ColEffect = (BYTE(m_ColBlendType) << TAG_BLEND_COLEFFECT_SHIFT) & TAG_BLEND_COLEFFECT_MASK; Flags = Flags | ColEffect; if (ok) ok = Rec.Init(); if (ok) ok = Rec.WriteUINT16(NumSteps); if (ok) ok = Rec.WriteBYTE(Flags); if (ok) ok = pFilter->Write(&Rec); return ok; #else return FALSE; #endif }

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

Reimplemented from NodeGroup. Definition at line 3605 of file nodeblnd.cpp. { #ifdef DO_EXPORT if (pFilter->IsCompactNativeFilter()) { if (pFilter->GetConvertBlendsToOutlines()) return pFilter->WriteNodeAsOutlines(this); } return WritePreChildren(pFilter); #else return FALSE; #endif }

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

Writes the blend record to the filter. > virtual BOOL NodeBlend::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 WEBSTER - markn 29/1/97 Changed so that it reacts to the "Convert blends to outlines" switch See also: - Reimplemented from NodeGroup. Definition at line 3590 of file nodeblnd.cpp. { #ifdef DO_EXPORT if (pFilter->GetConvertBlendsToOutlines()) return pFilter->WriteNodeAsOutlines(this); return WritePreChildren(pFilter); #else return FALSE; #endif }

---

Member Data Documentation

CProfileBiasGain NodeBlend::m_AttrProfile [private]

Definition at line 363 of file nodeblnd.h.

BOOL NodeBlend::m_AWEPSCompatible [private]

Definition at line 341 of file nodeblnd.h.

BOOL NodeBlend::m_AWEPSCompatibleCache [private]

Definition at line 342 of file nodeblnd.h.

BOOL NodeBlend::m_BlendedOnCurve [private]

Definition at line 357 of file nodeblnd.h.

String_32 NodeBlend::m_BlendName [private]

Definition at line 326 of file nodeblnd.h.

ColourBlendType NodeBlend::m_ColBlendType [private]

Definition at line 351 of file nodeblnd.h.

double NodeBlend::m_DistanceEntered [private]

Definition at line 335 of file nodeblnd.h.

EditState NodeBlend::m_Edit [private]

Definition at line 360 of file nodeblnd.h.

EndObject NodeBlend::m_LastEdited [private]

Definition at line 336 of file nodeblnd.h.

BOOL NodeBlend::m_NotAntialiased [private]

Definition at line 348 of file nodeblnd.h.

UINT32 NodeBlend::m_NumBlendSteps [private]

Definition at line 330 of file nodeblnd.h.

UINT32 NodeBlend::m_NumNodeBlendPaths [private]

Definition at line 368 of file nodeblnd.h.

CProfileBiasGain NodeBlend::m_ObjectProfile [private]

Definition at line 362 of file nodeblnd.h.

BOOL NodeBlend::m_OneToOne [private]

Definition at line 345 of file nodeblnd.h.

CProfileBiasGain NodeBlend::m_PositionProfile [private]

Definition at line 364 of file nodeblnd.h.

double NodeBlend::m_StepDistance [private]

Definition at line 334 of file nodeblnd.h.

BOOL NodeBlend::m_Tangential [private]

Definition at line 354 of file nodeblnd.h.

BOOL NodeBlend::objectProfileProcessing [private]

Definition at line 324 of file nodeblnd.h.

BOOL NodeBlend::s_DefaultNotAntialiased [static, private]

Definition at line 366 of file nodeblnd.h.

---

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

• Kernel/nodeblnd.h (r1785/r1282)
• Kernel/nodeblnd.cpp (r1785/r1688)

---