OpBlendNodes Class Reference

#include <blndtool.h>

Inheritance diagram for OpBlendNodes:

List of all members.

Public Member Functions
	OpBlendNodes ()
	Constructor.
	~OpBlendNodes ()
	Destructor.
BOOL	DoDrag (BlendTool *pBlendTool)
	This starts a drag that may lead to a blend. The DragFinished() method will do the hard work of blending if it can be done.
virtual BOOL	SnappingDrag ()
virtual void	DragPointerMove (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL bSolidDrag)
	Pure virtual function which tells the operation that the mouse has moved.
virtual void	DragFinished (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL Success, BOOL bSolidDrag)
	Ends the drag. Either creates a new grid or resizes GridClicked depending on the state of affairs when the drag started.
void	RenderMyDragBlobs ()
	Draws an EORed rectangle defined by AnchorPoint and DragPoint.
void	RenderDragBlobs (DocRect Rect, Spread *pSpread, BOOL bSolidDrag)
	Draws an EORed rectangle defined by AnchorPoint and DragPoint.
void	GetOpName (String_256 *OpName)
	The GetOpName fn is overridden so that we return back a description appropriate to the type of attribute that the operation applies.
virtual BOOL	Undo ()
	Gets called whenever this operation is undone.
virtual BOOL	Redo ()
	Gets called whenever this operation is Redone.
BOOL	RecordBlenderInfo (List &BlenderList, NodeBlend *pNodeBlend)
	This scans the blenders in the given blend node, creating a BlenderInfoItem for each NodeBlender. Each BlenderInfoItem is placed on BlenderList.
void	DeinitBlenders (List &BlenderList)
	This scans the blenders, calling the Deinit() method for each of them.
BOOL	ReinitBlenders (List &BlenderList)
	This scans the blenders, calling the Reinit() method for each of them. It uses the start and end node pointers gathered by RecordBlenderInfo() when calling Reinit().
BOOL	GetNodeClosestToPoint (NodeRenderableInk **ppInk, BOOL StartBlend)
	when blending from two blends, this retrieves the node closest to the actual point where the blend began or ended
Static Public Member Functions
static BOOL	Declare ()
	Adds the operation to the list of all known operations.
static OpState	GetState (String_256 *Description, OpDescriptor *)
	Find out the state of the operation at the specific time.
Private Member Functions
	CC_DECLARE_DYNCREATE (OpBlendNodes)
BOOL	DoBlendObjects ()
	This blends two objects together to form a new blend object in the tree. All the data that's required is stored in pRefStart (for the start object) and pRefEnd (for the end object). It assumes that neither the start or end objects are blends, so no clever merging of blend objects will take place here.
BOOL	DoCreateBlender (NodeRenderableInk *pNodeStart, INT32 IndexStart, NodeRenderableInk *pNodeEnd, INT32 IndexEnd, Node *pContextNode, AttachNodeDirection AttachDir)
	This forms a blender object in the tree that can blend pRefStart->pNode to pRefEnd->pNode.
BOOL	DoRemapBlend ()
	This tries to remap a blend using the data held in pRefStart && pRefEnd. It asks the pNodeBlend object to try and remap the two paths by rotating the path elements so that the element at Index is the first element in the path.
BOOL	DoBlendBlendAndObject ()
	This blends a blend object with another non-blend object. This is like a concatination of the the two nodes, resulting a single blend with an extra blend stage. E.g. blending a blend containing two paths (i.e. a single blend of two objects) with another path. The result will be a single blend object, blending the first path to the second, and the second to the third.
BOOL	DoBlendBlendAndBlend ()
	This merges to blend nodes together, so that the last object in the first blend is blended with the first of the second blend.
BOOL	DoDeinitBlenders (List &BlenderList)
	This calls DeinitBlenders() on the given list, and creates an action that will call ReinitBlenders() on undo, and DeinitBlenders() on redo.
BOOL	DoReinitBlenders (List &BlenderList)
	This calls ReinitBlenders() on the given list, and creates an action that will call DeinitBlenders() on undo, and ReinitBlenders() on redo.
BOOL	DeterminBlendObjectsProcessorHit ()
	This function provides a quick (and rough) estimate on the amount of work that will have to be done to create the blend. This estimate is based upon the total length of all paths that exist within the start and end nodes. An attempt is also made at altering the 'threshold' based upon the CPU type.
BOOL	RemoveCompoundNodes (CompoundNodeTreeFactoryList *pList)
	Removes all compound nodes.
BOOL	RemoveCompoundNodesFromNode (Node *pNode, Node **pRetnNode, CompoundNodeTreeFactoryList *pList)
	Removes all compound nodes from the given node (i.e. unshadows and unbevels nodes).
BOOL	DoContourNode (Node *pNode, DocCoord PointerPos, UINT32 Steps)
	Applies a contour to the given node.
Private Attributes
BlendToolRef *	pRefStart
BlendToolRef *	pRefEnd
OpBlendOpType	OpType
NodeBlend *	pNodeBlend
NodeBlend *	pNodeBlendStart
NodeBlend *	pNodeBlendEnd
BlendTool *	m_pBlendTool

---

Detailed Description

Definition at line 475 of file blndtool.h.

---

Constructor & Destructor Documentation

OpBlendNodes::OpBlendNodes (   )

Constructor. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Definition at line 3081 of file blndtool.cpp. { pRefStart = NULL; pRefEnd = NULL; OpType = BLENDOPTYPE_NONE; pNodeBlend = NULL; pNodeBlendStart = NULL; pNodeBlendEnd = NULL; }

OpBlendNodes::~OpBlendNodes (   )

Destructor. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Definition at line 3102 of file blndtool.cpp. { }

---

Member Function Documentation

OpBlendNodes::CC_DECLARE_DYNCREATE (  OpBlendNodes   )  [private]

BOOL OpBlendNodes::Declare (   )  [static]

Adds the operation to the list of all known operations. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Returns: TRUE if all went OK, FALSE otherwise Definition at line 4561 of file blndtool.cpp. { return (RegisterOpDescriptor( 0, _R(IDS_BLEND_TOOL), CC_RUNTIME_CLASS(OpBlendNodes), OPTOKEN_BLENDNODES, OpBlendNodes::GetState, 0, /* help ID */ _R(IDBBL_NOOP), /* bubble ID */ 0 /* bitmap ID */ )); }

void OpBlendNodes::DeinitBlenders (  List &  BlenderList  )

This scans the blenders, calling the Deinit() method for each of them. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/94 Parameters: BlenderList  = reference to a list of blender info items [INPUTS] -  [OUTPUTS] Returns: - Definition at line 3819 of file blndtool.cpp. { BlenderInfoItem* pItem = (BlenderInfoItem*) BlenderList.GetHead(); while (pItem != NULL) { pItem->pNodeBlender->Deinit(); pItem = (BlenderInfoItem*) BlenderList.GetNext(pItem); } }

BOOL OpBlendNodes::DeterminBlendObjectsProcessorHit (   )  [private]

This function provides a quick (and rough) estimate on the amount of work that will have to be done to create the blend. This estimate is based upon the total length of all paths that exist within the start and end nodes. An attempt is also made at altering the 'threshold' based upon the CPU type. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if should continue, FALSE otherwise This system could probably be enhanced - but for now it seems to work fine. Definition at line 4338 of file blndtool.cpp. { Node* pStart = pRefStart->pNode; Node* pEnd = pRefEnd->pNode; INT32 complexityEstimate1 = pStart->EstimateNodeComplexity (NULL); INT32 complexityEstimate2 = pEnd->EstimateNodeComplexity (NULL); INT32 generatedPathsEstimate = 3*complexityEstimate1 + 2*complexityEstimate2; static BOOL foundCPU = FALSE; static INT32 pathsBeforeAsk = 0; if (!foundCPU) { /* SYSTEM_INFO systemInfo; GetSystemInfo (&systemInfo); if (systemInfo.dwProcessorType == PROCESSOR_INTEL_386) { pathsBeforeAsk = 6000; } else if (systemInfo.dwProcessorType == PROCESSOR_INTEL_486) { pathsBeforeAsk = 12000; } else if (systemInfo.dwProcessorType == PROCESSOR_INTEL_PENTIUM) { pathsBeforeAsk = 20000; } else */ { // assume its faster than a pentium .... (in 2005 this will alwys be the case!) pathsBeforeAsk = 24000; } foundCPU = TRUE; } if (generatedPathsEstimate > pathsBeforeAsk) { // Load and build the question text. String_256 QueryString(_R(IDS_ASKLONGJOB)); // The only way of bringing up a box with a string in it Error::SetError(0, QueryString, 0); INT32 DlgResult = InformMessage(0, _R(IDS_YES), _R(IDS_NO)); Error::ClearError(); switch (DlgResult) { case 1: // YES return (TRUE); break; case 2: // NO return (FALSE); // break out of this stuff! } } return (TRUE); }

BOOL OpBlendNodes::DoBlendBlendAndBlend (   )  [private]

This merges to blend nodes together, so that the last object in the first blend is blended with the first of the second blend. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/94 Parameters: -  (data is taken from pRefStart and pRefEnd member vars) [INPUTS] -  [OUTPUTS] Returns: TRUE if all when well, FALSE otherwise Definition at line 3498 of file blndtool.cpp. { // Get ptr to the NodeBlends in question, and put them in the member vars pNodeBlendStart & pNodeBlendEnd pNodeBlendStart = (NodeBlend*)pRefStart->pNode; pNodeBlendEnd = (NodeBlend*)pRefEnd ->pNode; // DY changed to allow for new blending to and from a blend on a path if (pNodeBlendStart->IsOnACurve() || pNodeBlendEnd->IsOnACurve()) { OpType = BLENDOPTYPE_BLENDBLENDONPATH; pNodeBlendStart->SetBlendedOnCurve(TRUE); } else OpType = BLENDOPTYPE_BLENDANDBLEND; if (pNodeBlendStart == NULL || pNodeBlendEnd == NULL || pNodeBlendStart == pNodeBlendEnd) return FALSE; ERROR3IF(!IS_A(pNodeBlendStart,NodeBlend) || !IS_A(pNodeBlendEnd,NodeBlend),"Either start or end is not a NodeBlend"); if (!IS_A(pNodeBlendStart,NodeBlend) || !IS_A(pNodeBlendEnd,NodeBlend)) return FALSE; // Get a record of all the blenders in the blend nodes List BlenderListStart,BlenderListEnd; if (!RecordBlenderInfo(BlenderListStart,pNodeBlendStart) || !RecordBlenderInfo(BlenderListEnd,pNodeBlendEnd)) { // Tidy up if we fail to get blender info on the two blend nodes BlenderListStart.DeleteAll(); BlenderListEnd .DeleteAll(); return FALSE; } //BlenderInfoItem* pItemStart = (BlenderInfoItem*)BlenderListStart.GetTail(); //BlenderInfoItem* pItemEnd = (BlenderInfoItem*)BlenderListEnd .GetHead(); NodeRenderableInk* pNodeStart = NULL; //pItemStart->pNodeEnd; NodeRenderableInk* pNodeEnd = NULL; //pItemEnd ->pNodeStart; BOOL ok = GetNodeClosestToPoint(&pNodeStart, TRUE); if (ok) ok = GetNodeClosestToPoint(&pNodeEnd, FALSE); ERROR3IF(pNodeStart == NULL,"The start node ptr is NULL"); ERROR3IF(pNodeEnd == NULL,"The end node ptr is NULL"); if (pNodeStart == NULL || pNodeEnd == NULL) return FALSE; BlobManager* pBlobManager = GetApplication()->GetBlobManager(); ENSURE(pBlobManager, "Can't get BlobManager"); ok = DeterminBlendObjectsProcessorHit (); // Now we are ready to do the actual blend // Firstly, record the selection state if (ok) ok = DoStartSelOp(TRUE,TRUE); if (ok) ok = (Tool::GetCurrent() != NULL); if (ok) pBlobManager->RenderToolBlobsOff(Tool::GetCurrent(), pRefStart->pSpread,NULL); if (ok) NodeRenderableInk::DeselectAll(FALSE); // Select the start blend node if (ok) pNodeBlendStart->SetSelected(TRUE); // Deinit all the blenders in the end blend. if (ok) ok = DoDeinitBlenders(BlenderListEnd); // Localise the attributes in the start blend if (ok) ok = DoLocaliseCommonAttributes(pNodeBlendStart); // Localise the attributes in the end blend if (ok) ok = DoLocaliseCommonAttributes(pNodeBlendEnd); // Hide the end blend node NodeHidden* pNodeHidden; if (ok) ok = DoHideNode(pNodeBlendEnd,TRUE,&pNodeHidden); if (ok) { // DY update blendpath indexes in existing blenders before we // move them INT32 FirstBlendNumPaths = pNodeBlendStart->GetNumNodeBlendPaths(); NodeBlender* pBlender = pNodeBlendEnd->FindFirstBlender(); while (pBlender != NULL) { INT32 CurrentIndex = pBlender->GetNodeBlendPathIndex(); if (CurrentIndex > -1) { ChangeBlenderOpParam Param; Param.m_NewNodeBlendPathIndex = (CurrentIndex + FirstBlendNumPaths); Param.m_ChangeType = CHANGEBLENDER_NBPINDEX; ok = ChangeBlenderAction::Init(this, &UndoActions, pBlender, Param); } pBlender = pNodeBlendEnd->FindNextBlender(pBlender); } } // Now move all the end blend's children (except hidden nodes) into the start blend. if (ok) { Node* pNode = pNodeBlendEnd->FindFirstChild(); while (pNode != NULL && ok) { Node* pNext = pNode->FindNext(); if (!pNode->IS_KIND_OF(NodeHidden)) ok = DoMoveNode(pNode,pNodeBlendStart,LASTCHILD); // DY keep track of which nodeblendpath this is //if (pNode->IS_KIND_OF(NodeBlendPath)) // ((NodeBlendPath*)pNode)->SetPathIndex(); pNode = pNext; } } // Create a blender node to blend the two nodes if (ok) ok = DoCreateBlender(pNodeStart,-1,pNodeEnd,-1,pNodeStart,NEXT); // Reinit the end blenders using the same start and end pointers they were using before the blend if (ok) ok = DoReinitBlenders(BlenderListEnd); // Factor out any common attrs that might have been copied during the blend if (ok) ok = DoFactorOutCommonChildAttributes(pNodeBlendStart); // Invalid the whole of the start blend if (ok) ok = DoInvalidateNodeRegion(pNodeBlendStart,TRUE); // Clear out the lists (we don't want memory leaks, do we). BlenderListStart.DeleteAll(); BlenderListEnd .DeleteAll(); // Throw away the selection cache GetApplication()->UpdateSelection(); return (ok); }

BOOL OpBlendNodes::DoBlendBlendAndObject (   )  [private]

This blends a blend object with another non-blend object. This is like a concatination of the the two nodes, resulting a single blend with an extra blend stage. E.g. blending a blend containing two paths (i.e. a single blend of two objects) with another path. The result will be a single blend object, blending the first path to the second, and the second to the third. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/94 Parameters: -  (data is taken from pRefStart and pRefEnd member vars) [INPUTS] -  [OUTPUTS] Returns: TRUE if all when well, FALSE otherwise The order in which the two objects are concatinated depends on which is is the start of the blend and which is the end. Definition at line 3649 of file blndtool.cpp. { ERROR3IF(!IS_A(pRefStart->pNode,NodeBlend) && !IS_A(pRefEnd->pNode,NodeBlend),"Neither start or end are NodeBlends"); if (!IS_A(pRefStart->pNode,NodeBlend) && !IS_A(pRefEnd->pNode,NodeBlend)) return FALSE; OpType = BLENDOPTYPE_BLENDANDOBJECT; // BlendIsStart == TRUE if the blend node was the start of the blend and not the end BOOL BlendIsStart = IS_A(pRefStart->pNode,NodeBlend); // Get ptr to the NodeBlend in question, and put it in the member var pNodeBlend pNodeBlend = NULL; if (BlendIsStart) pNodeBlend = (NodeBlend*)pRefStart->pNode; else pNodeBlend = (NodeBlend*)pRefEnd->pNode; if (pNodeBlend == NULL) return FALSE; // Get a record of all the blenders in the blend node List BlenderList; if (!RecordBlenderInfo(BlenderList,pNodeBlend)) return FALSE; NodeRenderableInk* pNodeStart = NULL; NodeRenderableInk* pNodeEnd = NULL; Node* pContextNode; AttachNodeDirection AttachDir; BOOL ok = FALSE; if (BlendIsStart) { // BlenderInfoItem* pItem = (BlenderInfoItem*)BlenderList.GetTail(); pNodeBlendStart = pNodeBlend; ok = GetNodeClosestToPoint(&pNodeStart, TRUE); pNodeEnd = pRefEnd->pNode; pContextNode = pNodeEnd; AttachDir = PREV; } else { // BlenderInfoItem* pItem = (BlenderInfoItem*)BlenderList.GetHead(); pNodeStart = pRefStart->pNode; pNodeBlendEnd = pNodeBlend; ok = GetNodeClosestToPoint(&pNodeEnd, FALSE); pContextNode = pNodeStart; AttachDir = NEXT; } ERROR3IF(pNodeBlend == NULL,"Neither start or end are NodeBlends"); ERROR3IF(pNodeStart == NULL,"The start node ptr is NULL"); ERROR3IF(pNodeEnd == NULL,"The end node ptr is NULL"); if (pNodeBlend == NULL || pNodeStart == NULL || pNodeEnd == NULL) return FALSE; BlobManager* pBlobManager = GetApplication()->GetBlobManager(); ENSURE(pBlobManager, "Can't get BlobManager"); ok = DeterminBlendObjectsProcessorHit (); // Firstly, record the selection state if (ok) ok = DoStartSelOp(TRUE,TRUE); if (ok) ok = (Tool::GetCurrent() != NULL); if (ok) pBlobManager->RenderToolBlobsOff(Tool::GetCurrent(), pRefStart->pSpread,NULL); if (ok) NodeRenderableInk::DeselectAll(FALSE); // Select th blend node if (ok) pNodeBlend->SetSelected(TRUE); // Deinit all the blenders in the blend. if (ok) ok = DoDeinitBlenders(BlenderList); // Localise the attributes in the blend before we start moving node around if (ok) ok = DoLocaliseCommonAttributes(pNodeBlend); // If blending to a blend, move the start node, and make sure it's deselected // Also find the number of paths that will be passed back (for the progress display) if (ok && !BlendIsStart) ok = DoMoveNode(pNodeStart,pNodeBlend,FIRSTCHILD); if (ok && !BlendIsStart) ok = DoDeselectNode(pNodeStart); // If blending from a blend, move the end node, and make sure it's deselected // Also find the number of paths that will be passed back (for the progress display) if (ok && BlendIsStart) ok = DoMoveNode(pNodeEnd,pNodeBlend,LASTCHILD); if (ok && BlendIsStart) ok = DoDeselectNode(pNodeEnd); // Create a blender node to blend the two nodes if (ok) ok = DoCreateBlender(pNodeStart,-1,pNodeEnd,-1,pContextNode,AttachDir); // Factor out any common attrs that might have been copied during the blend if (ok) ok = DoFactorOutCommonChildAttributes(pNodeBlend); // Invalidate the whole blend if (ok) ok = DoInvalidateNodeRegion(pNodeBlend,TRUE); // Reinit the blenders using the same start and end pointers they were using before the blend if (ok) ok = DoReinitBlenders(BlenderList); // Clear out the list (we don't want memory leaks, do we). BlenderList.DeleteAll(); // Throw away the selection cache GetApplication()->UpdateSelection(); return (ok); }

BOOL OpBlendNodes::DoBlendObjects (   )  [private]

This blends two objects together to form a new blend object in the tree. All the data that's required is stored in pRefStart (for the start object) and pRefEnd (for the end object). It assumes that neither the start or end objects are blends, so no clever merging of blend objects will take place here. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: (data  is taken from pRefStart and pRefEnd member vars) [INPUTS] -  [OUTPUTS] Returns: TRUE if all when well, FALSE otherwise Definition at line 4230 of file blndtool.cpp. { // DMc - are the nodes to be blended shadowed or bevelled ? // BOOL bIsShadowed = FALSE; // BOOL bIsBevelled = FALSE; // What type of blend op are we doing? OpType = BLENDOPTYPE_NEW; // Are we going mad? Better check our onions... ERROR3IF_PF(pRefStart == NULL,("pRefStart == NULL")); ERROR3IF_PF(pRefEnd == NULL,("pRefEnd == NULL")); ERROR3IF_PF(pRefStart->pNode == NULL,("pRefStart->pNode == NULL")); ERROR3IF_PF(pRefEnd ->pNode == NULL,("pRefEnd->pNode == NULL")); BOOL ok = DeterminBlendObjectsProcessorHit (); if (!ok) { return (FALSE); } ok = DoStartSelOp(TRUE,TRUE); CompoundNodeTreeFactoryList CFList; RemoveCompoundNodes(&CFList); NodeBlend* pNodeBlend; // DMc // move the end nodes upwards to include compound nodes Node * pParent = pRefStart->pNode; while (pParent) { if (!pParent->PromoteHitTestOnChildrenToMe() && pParent->IsAnObject()) { pRefStart->pNode = (NodeRenderableInk *)pParent; } pParent = pParent->FindParent(); } pParent = pRefEnd->pNode; while (pParent) { if (!pParent->PromoteHitTestOnChildrenToMe() && pParent->IsAnObject()) { pRefEnd->pNode = (NodeRenderableInk *)pParent; } pParent = pParent->FindParent(); } BlobManager* pBlobManager = GetApplication()->GetBlobManager(); ENSURE(pBlobManager, "Can't get BlobManager"); if (ok) ok = (Tool::GetCurrent() != NULL); if (ok) pBlobManager->RenderToolBlobsOff(Tool::GetCurrent(), pRefStart->pSpread,NULL); if (ok) NodeRenderableInk::DeselectAll(FALSE,FALSE); if (ok) ALLOC_WITH_FAIL(pNodeBlend,new NodeBlend,this); if (ok) ok = (pNodeBlend != NULL); if (ok) pRefStart->pNode->SetSelected(FALSE); if (ok) pRefEnd ->pNode->SetSelected(FALSE); if (ok) ok = DoInsertNewNode(pNodeBlend,pRefEnd->pNode,NEXT,FALSE,FALSE,FALSE,FALSE); if (ok) ok = DoMoveNode(pRefStart->pNode,pNodeBlend,LASTCHILD); if (ok) ok = DoMoveNode(pRefEnd ->pNode,pNodeBlend,LASTCHILD); if (ok) ok = DoCreateBlender(pRefStart->pNode,pRefStart->Index,pRefEnd->pNode,pRefEnd->Index,pRefStart->pNode,NEXT); if (ok) ok = DoInvalidateNodeRegion(pNodeBlend,TRUE); // Simon - Factor out the blend's common attributes if (ok) ok = DoFactorOutCommonChildAttributes(pNodeBlend); if (ok) pNodeBlend->SetSelected(TRUE); // Select the new node // Throw away the selection cache GetApplication()->UpdateSelection(); return (ok); }

BOOL OpBlendNodes::DoContourNode (  Node *  pNode, DocCoord  PointerPos, UINT32  Steps )  [private]

Applies a contour to the given node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 18/8/99 Parameters: Node  to contour [INPUTS] -  [OUTPUTS] Returns: TRUE if all when well, FALSE otherwise Definition at line 3342 of file blndtool.cpp. { /* List NodeList; // get the bounding rect of the node to be contoured DocRect br = ((NodeRenderableBounded *)pNode)->GetBoundingRect(); UINT32 Width = 0; INT32 OffsetX = 0; INT32 OffsetY = 0; // try to work out the width of the contour if (PointerPos.x < br.lo.x && PointerPos.y >= br.lo.y && PointerPos.y <= br.hi.y) { Width = br.lo.x - PointerPos.x; } else if (PointerPos.x > br.hi.x && PointerPos.y >= br.lo.y && PointerPos.y <= br.hi.y) { Width = PointerPos.x - br.hi.x; } else if (PointerPos.x >= br.lo.x && PointerPos.x <= br.hi.x && PointerPos.y < br.lo.y) { Width = br.lo.y - PointerPos.y; } else if (PointerPos.x >= br.lo.x && PointerPos.x <= br.hi.x && PointerPos.y > br.hi.y) { Width = PointerPos.y - br.hi.y; } else if (PointerPos.x < br.lo.x && PointerPos.y < br.lo.y) { OffsetX = br.lo.x - PointerPos.x; OffsetY = br.lo.y - PointerPos.y; if (OffsetX > OffsetY) { Width = OffsetX; } else { Width = OffsetY; } } else if (PointerPos.x > br.hi.x && PointerPos.y < br.lo.y) { OffsetX = PointerPos.x - br.hi.x ; OffsetY = br.lo.y - PointerPos.y; if (OffsetX > OffsetY) { Width = OffsetX; } else { Width = OffsetY; } } else if (PointerPos.x > br.hi.x && PointerPos.y > br.hi.y) { OffsetX = PointerPos.x - br.hi.x ; OffsetY = PointerPos.y - br.hi.y; if (OffsetX > OffsetY) { Width = OffsetX; } else { Width = OffsetY; } } else if (PointerPos.x < br.lo.x && PointerPos.y > br.hi.y) { OffsetX = br.lo.x - PointerPos.x ; OffsetY = PointerPos.y - br.hi.y; if (OffsetX > OffsetY) { Width = OffsetX; } else { Width = OffsetY; } } // find top level of the node to contour Node * pParent = pNode->FindParent(); BOOL bContourExists = FALSE; while (pParent) { if (pParent->IsKindOf(CC_RUNTIME_CLASS(NodeContourController))) { pNode = pParent; bContourExists = TRUE; } pParent = pParent->FindParent(); } NodeListItem * pItem = new NodeListItem(pNode); NodeList.AddTail(pItem); // if a contour exists then change its width if (!bContourExists) { CreateContourParam Param(&NodeList, Steps, Width); OpDescriptor * pOpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpCreateContour)); if (pOpDesc && Width > 0) { pOpDesc->Invoke(&Param); } } else { ChangeContourWidthParam Param(&NodeList, Width, FALSE); OpDescriptor * pOpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpChangeContourWidth)); if (pOpDesc && Width > 0) { pOpDesc->Invoke(&Param); } } NodeList.DeleteAll(); */ return TRUE; }

BOOL OpBlendNodes::DoCreateBlender (  NodeRenderableInk *  pNodeStart, INT32  PathIndexStart, NodeRenderableInk *  pNodeEnd, INT32  PathIndexEnd, Node *  pContextNode, AttachNodeDirection  AttachDir )  [private]

This forms a blender object in the tree that can blend pRefStart->pNode to pRefEnd->pNode. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: pNodeStart  = the start node to blend [INPUTS] PathIndexStart = index into start path, if applicable (-1 means not applicable) pNodeEnd = the end node to blend PathIndexEnd = index into end path, if applicable (-1 means not applicable) pContextNode = ptr to context for insertion of the blender AttachDir = how to attach the blender to the tree in relation to pContextNode -  [OUTPUTS] Returns: TRUE if all when well, FALSE otherwise Definition at line 4421 of file blndtool.cpp. { ERROR2IF(pNodeStart == NULL,FALSE,"pNodeStart is NULL"); ERROR2IF(pNodeEnd == NULL,FALSE,"pNodeEnd is NULL"); // Work out how many paths will be passed back // The sum will be used to determine the final count for the progress bar BecomeA TestStart(BECOMEA_TEST, CC_RUNTIME_CLASS(NodePath)); BecomeA TestEnd(BECOMEA_TEST, CC_RUNTIME_CLASS(NodePath)); TestStart.ResetCount(); TestEnd.ResetCount(); pNodeStart->CanBecomeA(&TestStart); pNodeEnd ->CanBecomeA(&TestEnd); // Create the hourglass with the correct final count. Progress Hourglass(_R(IDS_BLENDING), INT32(TestStart.GetCount() + TestEnd.GetCount()) ); BOOL ok = FALSE; NodeBlender* pNodeBlender; ALLOC_WITH_FAIL(pNodeBlender,new NodeBlender,this); ok = (pNodeBlender != NULL); // If either of the indexes are -ve, make sure both are -ve if (PathIndexStart < 0 || PathIndexEnd < 0) PathIndexStart = PathIndexEnd = -1; if (ok) ok = DoInsertNewNode(pNodeBlender,pContextNode,AttachDir,FALSE,FALSE,FALSE,FALSE); if (ok) ok = pNodeBlender->Initialise(pNodeStart,pNodeEnd,PathIndexStart,PathIndexEnd,this,&Hourglass,FALSE); pRefStart->pNode = pNodeStart; pRefEnd->pNode = pNodeEnd; return (ok); }

BOOL OpBlendNodes::DoDeinitBlenders (  List &  BlenderList  )  [private]

This calls DeinitBlenders() on the given list, and creates an action that will call ReinitBlenders() on undo, and DeinitBlenders() on redo. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: BlenderList  = list of blenders to deinit. [INPUTS] -  [OUTPUTS] Returns: - Definition at line 3768 of file blndtool.cpp. { InitBlendersAction* pAction; BOOL ok = (InitBlendersAction::Init(this,&UndoActions,&BlenderList,TRUE,&pAction) != AC_FAIL); if (ok) DeinitBlenders(BlenderList); return (ok); }

BOOL OpBlendNodes::DoDrag (  BlendTool *  pBlendTool  )

This starts a drag that may lead to a blend. The DragFinished() method will do the hard work of blending if it can be done. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 3121 of file blndtool.cpp. { // DMc // find out the active tool for the drag if (Tool::GetCurrent()->GetID() == TOOLID_BLEND) { pRefStart = BlendTool::GetPtrRefStart(); pRefEnd = BlendTool::GetPtrRefEnd(); } ERROR2IF_PF(pRefStart == NULL || pRefEnd == NULL,FALSE,("Blend tool refs are NULL")); pRefEnd->PointerPos = pRefStart->PointerPos; RenderMyDragBlobs(); m_pBlendTool = pBlendTool; // Tell the Dragging system that we need drags to happen StartDrag( DRAGTYPE_AUTOSCROLL ); return TRUE; }

BOOL OpBlendNodes::DoReinitBlenders (  List &  BlenderList  )  [private]

This calls ReinitBlenders() on the given list, and creates an action that will call DeinitBlenders() on undo, and ReinitBlenders() on redo. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: BlenderList  = list of blenders to deinit. [INPUTS] -  [OUTPUTS] Returns: - Definition at line 3792 of file blndtool.cpp. { InitBlendersAction* pAction; BOOL ok = (InitBlendersAction::Init(this,&UndoActions,&BlenderList,FALSE,&pAction) != AC_FAIL); if (ok) { ok = ReinitBlenders(BlenderList); if (!ok) FailAndExecuteAllButLast(); } return ok; }

BOOL OpBlendNodes::DoRemapBlend (   )  [private]

This tries to remap a blend using the data held in pRefStart && pRefEnd. It asks the pNodeBlend object to try and remap the two paths by rotating the path elements so that the element at Index is the first element in the path. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/11/94 Parameters: -  (data is taken from pRefStart and pRefEnd member vars) [INPUTS] -  [OUTPUTS] Returns: TRUE if all when well, FALSE otherwise Definition at line 3922 of file blndtool.cpp. { // What type of blend op are we doing? OpType = BLENDOPTYPE_REMAP; // Are we going mad? Better check our onions... ERROR3IF(pRefStart == NULL,"pRefStart == NULL"); ERROR3IF(pRefEnd == NULL,"pRefEnd == NULL"); ERROR3IF(pRefStart->pNode == NULL,"pRefStart->pNode == NULL"); ERROR3IF(pRefEnd ->pNode == NULL,"pRefEnd->pNode == NULL"); ERROR3IF(pRefStart->pNodeBlend == NULL,"pRefStart->pNodeBlend == NULL"); ERROR3IF(pRefEnd ->pNodeBlend == NULL,"pRefEnd->pNodeBlend == NULL"); ERROR3IF(pRefStart->pNodeBlend != pRefEnd->pNodeBlend,"Start and end blend nodes not equal"); ERROR3IF(pRefStart->RemapRef != pRefEnd->RemapRef,"Start and end remap refs not equal"); ERROR3IF(pRefStart->AStartNode == pRefEnd->AStartNode,"Start and end AStartNode vals equal"); BOOL ok = TRUE; RemapBlendAction* pAction; NodeBlend* pNodeBlend = pRefStart->pNodeBlend; UINT32 RemapRef = pRefStart->RemapRef; DocCoord PosStart = pRefStart->PointerPos; DocCoord PosEnd = pRefEnd ->PointerPos; if (!pRefStart->AStartNode) { // Swap the coords around DocCoord Temp = PosStart; PosStart = PosEnd; PosEnd = Temp; } ObjChangeFlags cFlags; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,pNodeBlend,this); ok = pNodeBlend->AllowOp(&ObjChange); if (ok) ok = DoInvalidateNodeRegion(pRefStart->pNodeBlend,TRUE); if (ok) ok = RemapBlendAction::Init(this,&UndoActions, pNodeBlend,RemapRef,PosStart,PosEnd, &pAction) != AC_FAIL; if (ok) { ObjChange.Define(OBJCHANGE_FINISHED,cFlags,pNodeBlend,this); UpdateChangedNodes(&ObjChange); } return (ok); }

void OpBlendNodes::DragFinished (  DocCoord  PointerPos, ClickModifiers  ClickMods, Spread *  pSpread, BOOL  Success, BOOL  bSolidDrag )  [virtual]

Ends the drag. Either creates a new grid or resizes GridClicked depending on the state of affairs when the drag started. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: PointerPos  - The position of the mouse at the end of the drag [INPUTS] ClickMods - the key modifiers being pressed pSpread - The spread that the drag finished on Success - TRUE if the drag was terminated properly, FALSE if it was ended with the escape key being pressed See also: ClickModifiers Reimplemented from Operation. Definition at line 3206 of file blndtool.cpp. { ERROR3IF(pRefStart == NULL,"pRefStart is NULL"); ERROR3IF(pRefEnd == NULL,"pRefEnd is NULL"); if ((pRefStart == NULL) || (pRefEnd == NULL)) return; // First Rub out the old box RenderMyDragBlobs(); if (Success) { // Make sure that start and end refer to the same spread