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 if (pSpread != pRefStart->pSpread) PointerPos = MakeRelativeToSpread(pRefStart->pSpread, pSpread, PointerPos); if (Tool::GetCurrent()->GetID() == TOOLID_BLEND) { BlendTool::UpdateRef(pRefEnd,pRefStart->pSpread,PointerPos); BlendTool::CheckNodeRemapping(pRefStart,pRefEnd); } else { FailAndExecute(); EndDrag(); delete this; return; } String_32 ProgString = _T("Calculating blend, please wait.."); Progress Hourglass(&ProgString, -1, FALSE); Node* pNodeStart = pRefStart->pNode; Node* pNodeEnd = pRefEnd ->pNode; // make the start & end nodes point to any 'needs parent' compounds while (pNodeStart) { if (!pNodeStart->PromoteHitTestOnChildrenToMe() && pNodeStart->IsAnObject()) { pRefStart->pNode = (NodeRenderableInk *)pNodeStart; } pNodeStart = pNodeStart->FindParent(); } while (pNodeEnd) { if (!pNodeEnd->PromoteHitTestOnChildrenToMe() && pNodeEnd->IsAnObject()) { pRefEnd->pNode = (NodeRenderableInk *)pNodeEnd; } pNodeEnd = pNodeEnd->FindParent(); } BOOL ok = FALSE; if (pRefStart->pNode == NULL || pRefEnd->pNode == NULL) { // can't blend so exit FailAndExecute(); EndDrag(); delete this; return; } else if (pRefStart->pNode == pRefEnd->pNode) { if (pRefStart->RemapRef == pRefEnd->RemapRef && pRefStart->RemapRef > 0) { // User's tried to remap two blend blobs if (pRefStart->AStartNode != pRefEnd->AStartNode) // The blobs lie on opposite ends of a blend ok = DoRemapBlend(); } else { // can't blend so exit FailAndExecute(); EndDrag(); delete this; return; } } else if (IS_A(pRefStart->pNode,NodeBlend) && IS_A(pRefEnd ->pNode,NodeBlend)) { // Blending a blend to a blend ok = DoBlendBlendAndBlend(); } else if (IS_A(pRefStart->pNode,NodeBlend) || IS_A(pRefEnd ->pNode,NodeBlend)) { // Blending an object to a blend, or a blend to an object ok = DoBlendBlendAndObject(); } else { ok = DoBlendObjects(); } if (!ok) FailAndExecute(); // Do this at the end so that the status bar text doesn't get wiped before the op begins if (Tool::GetCurrent()->GetID() == TOOLID_BLEND) { BlendTool::UpdateCursorAndStatus(); } else { } } else FailAndExecute(); // End the drag and the op EndDrag(); End(); }

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

Pure virtual function which tells the operation that the mouse has moved. virtual void Operation::DragPointerMove( DocCoord PointerPos, ClickModifiers ClickMods, Spread *pSpread, BOOL bSolidDrag) Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/93 Parameters: PointerPos,:  Position of the mouse pointer [INPUTS] ClickMods: Click modifiers -  [OUTPUTS] Returns: - Errors: - See also: ClickModifiers Reimplemented from Operation. Definition at line 3161 of file blndtool.cpp. { // First Rub out the old box RenderMyDragBlobs(); // Make sure that start and end refer to the same spread if (pSpread != pRefStart->pSpread) PointerPos = MakeRelativeToSpread(pRefStart->pSpread, pSpread, PointerPos); // DMc // find out the active tool for the drag if (Tool::GetCurrent()->GetID() == TOOLID_BLEND) { BlendTool::UpdateRef(pRefEnd,pRefStart->pSpread,PointerPos,FALSE); BlendTool::CheckNodeRemapping(pRefStart,pRefEnd); BlendTool::UpdateCursorAndStatus(); } // Render the new drag box RenderMyDragBlobs(); }

BOOL OpBlendNodes::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 Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 27/9/99 Parameters: -  [INPUTS] Outputs; ppInk, the starting node of the blend StartBlend - do we wish to find the start or end Returns: TRUE if successful , FALSE otherwise, or if we are not blending two blends. Definition at line 4783 of file blndtool.cpp. { // ERROR3IF_PF(pNodeBlendStart == NULL; "Nodeblend start is NULL"); // ERROR3IF_PF(pNodeBlendEnd == NULL; "Nodeblend end is NULL"); DocCoord Point; // Node* pStart = NULL; // Node* pEnd = NULL; // BOOL ok = FALSE; NodeBlend* pBlend = NULL; if (StartBlend) { Point = pRefStart->PointerPos; //ok = pNodeBlendStart->GetStartAndEndNodes(&pStart, &pEnd); pBlend = pNodeBlendStart; } else { Point = pRefEnd->PointerPos; //ok = pNodeBlendEnd->GetStartAndEndNodes(&pStart, &pEnd); pBlend = pNodeBlendEnd; } double ClosestDistance = 9999999999999.9; Node* pClosestNode = NULL; Node* pNode = pBlend->FindFirstChild(); while (pNode != NULL) { // we are looking for inks but don't want blenders or nodeblendpaths // could do with some virtual functions here if (pNode->IS_KIND_OF(NodeRenderableInk) && (!pNode->IS_KIND_OF(NodeBlender)) && (!pNode->IS_KIND_OF(NodeBlendPath))) { DocRect Rect = ((NodeRenderableInk*)pNode)->GetBoundingRect(); Coord Centre = (Coord)(Rect.Centre()); double Distance = Point.Distance(Centre); if (Distance < ClosestDistance) { pClosestNode = pNode; ClosestDistance = Distance; } } pNode = pNode->FindNext(); } if (pClosestNode != NULL) { *ppInk = (NodeRenderableInk*)pClosestNode; return TRUE; } else { ERROR3("Couldn't find a node close to point"); return FALSE; } }

void OpBlendNodes::GetOpName (  String_256 *  OpName  )  [virtual]

The GetOpName fn is overridden so that we return back a description appropriate to the type of attribute that the operation applies. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: OpName  = ptr to str to place op name in [INPUTS] The  undo string for the operation [OUTPUTS] Returns: Errors: - See also: - Reimplemented from Operation. Definition at line 4613 of file blndtool.cpp. { switch (OpType) { case BLENDOPTYPE_NEW: case BLENDOPTYPE_BLENDANDOBJECT: case BLENDOPTYPE_BLENDANDBLEND: *OpName = String_256(_R(IDS_BLEND_UNDO)); break; case BLENDOPTYPE_REMAP: *OpName = String_256(_R(IDS_REMAP_UNDO)); break; default: break; } }

OpState OpBlendNodes::GetState (  String_256 *  Description, OpDescriptor *  )  [static]

Find out the state of the operation at the specific time. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: Description  - GetState fills this string with an approriate description [OUTPUTS] of the current state of the push tool Returns: The state of the operation, so that menu items (ticks and greying can be done properly Definition at line 4590 of file blndtool.cpp. { OpState State; return State; }

BOOL OpBlendNodes::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. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/94 Parameters: BlenderList  = reference to a list to put all the blender info items on [INPUTS] pNodeBlend = the blend containing the blenders of interested -  [OUTPUTS] Returns: TRUE if all when well, FALSE otherwise Definition at line 3874 of file blndtool.cpp. { ERROR3IF(pNodeBlend == NULL,"pNodeBlend == NULL"); if (pNodeBlend == NULL) return FALSE; BOOL ok = TRUE; Node* pNode = pNodeBlend->FindFirstChild(); while (pNode != NULL && ok) { if (IS_A(pNode,NodeBlender)) { NodeBlender* pNodeBlender = (NodeBlender*)pNode; BlenderInfoItem* pItem = new BlenderInfoItem; ok = (pItem != NULL); if (ok) { pItem->pNodeBlender = pNodeBlender; pItem->pNodeStart = pNodeBlender->GetNodeStart(); pItem->pNodeEnd = pNodeBlender->GetNodeEnd(); ok = (pItem->pNodeStart != NULL && pItem->pNodeEnd != NULL); } if (ok) BlenderList.AddTail(pItem); } pNode = pNode->FindNext(); } return ok; }

BOOL OpBlendNodes::Redo (   )  [virtual]

Gets called whenever this operation is Redone. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 15/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if all OK, FALSE otherwise Errors: - See also: - Reimplemented from Operation. Definition at line 4715 of file blndtool.cpp. { // Pre-Redo stuff switch (OpType) { case BLENDOPTYPE_NEW: case BLENDOPTYPE_BLENDANDBLEND: case BLENDOPTYPE_REMAP: case BLENDOPTYPE_BLENDANDOBJECT: case BLENDOPTYPE_BLENDBLENDONPATH: break; default: ERROR3_PF(("Unknown blend OpType (%d)",OpType)); break; } SelRange* pSel = GetApplication()->FindSelection(); /*Node* pNode =*/ pSel->FindFirst(); // Do the Redo SelOperation::Redo(); // Post-Redo stuff switch (OpType) { case BLENDOPTYPE_NEW: case BLENDOPTYPE_REMAP: break; case BLENDOPTYPE_BLENDANDBLEND: /* // Check that we have a blend object ERROR3IF(pNodeBlendStart==NULL,"pNodeBlendStart == NULL"); if (pNodeBlendStart == NULL) return TRUE; DeinitAndReinitBlend(pNodeBlendStart); */ break; case BLENDOPTYPE_BLENDANDOBJECT: /* // Check that we have a blend object ERROR3IF(pNodeBlend==NULL,"pNodeBlend == NULL"); if (pNodeBlend == NULL) return TRUE; DeinitAndReinitBlend(pNodeBlend); */ break; default: break; } return TRUE; }

BOOL OpBlendNodes::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(). 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: TRUE if all when well, FALSE otherwise Definition at line 3845 of file blndtool.cpp. { BOOL ok = TRUE; BlenderInfoItem* pItem = (BlenderInfoItem*) BlenderList.GetHead(); while (pItem != NULL && ok) { ok = pItem->pNodeBlender->Reinit(pItem->pNodeStart,pItem->pNodeEnd); pItem = (BlenderInfoItem*) BlenderList.GetNext(pItem); } return (ok); }

BOOL OpBlendNodes::RemoveCompoundNodes (  CompoundNodeTreeFactoryList *  pList  )  [private]

Removes all compound nodes. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/99 Parameters: The  list to return the class factories necessary to regenerate any [INPUTS] compound nodes which have been removed TRUE  if all when well, FALSE otherwise [OUTPUTS] Definition at line 3985 of file blndtool.cpp. { /* Node * pNewStartNode = NULL; Node * pNewEndNode = NULL; if (!RemoveCompoundNodesFromNode(pRefStart->pNode, &pNewStartNode, NULL)) { ERROR3("OpBlendNodes::RemoveCompoundNodes - Removal of compound nodes\n\ from start node has failed"); } if (!RemoveCompoundNodesFromNode(pRefEnd->pNode, &pNewEndNode, pList)) { ERROR3("OpBlendNodes::RemoveCompoundNodes - Removal of compound nodes\n\ from end node has failed"); } pRefStart->pNode = (NodeRenderableInk *)pNewStartNode; pRefEnd->pNode = (NodeRenderableInk *)pNewEndNode; GetApplication()->UpdateSelection();*/ return TRUE; }

BOOL OpBlendNodes::RemoveCompoundNodesFromNode (  Node *  pNode, Node **  pRetnNode, CompoundNodeTreeFactoryList *  pList )  [private]

Removes all compound nodes from the given node (i.e. unshadows and unbevels nodes). Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/99 Parameters: The  node to remove all compound nodes from, and the return node to be [INPUTS] used in the blend as well as the list of compound node factories needed to regenerate the compounds nodes removed The  return node to use in the blend [OUTPUTS] Returns: TRUE if all when well, FALSE otherwise Definition at line 4027 of file blndtool.cpp. { /*if (!pNode) return FALSE; if (!pRetnNode) return FALSE; // first, get the first parent in the hierarchy which has a PromoteHitTestOnChildrenToMe() set Node * pParent = pNode->FindParent(); Node * pPromoteParent = NULL; *pRetnNode = pNode; while (pParent) { if (!pParent->PromoteHitTestOnChildrenToMe()) { pPromoteParent = pParent; } pParent = pParent->FindParent(); } // if we haven't found one - this means that there is one under me if (!pPromoteParent) { pPromoteParent = pNode; } List CompoundNodeList; // get the compound node list for the whole subtree BevelTools::GetAllNodesUnderNode(pPromoteParent, &CompoundNodeList, CC_RUNTIME_CLASS(NodeCompound)); NodeListItem * pNodeToGroupItem = (NodeListItem *)CompoundNodeList.GetHead(); Node * pChildNode = NULL; Node * pNextChildNode = NULL; NodeHidden * pHidden = NULL; Node * pChildNode2 = NULL; BOOL ok = TRUE; // first, invalidate all the compound node's regions while (pNodeToGroupItem && ok) { if (ok) ok = DoInvalidateNodeRegion((NodeRenderableBounded *)pNodeToGroupItem->pNode, TRUE); pNodeToGroupItem = (NodeListItem *)CompoundNodeList.GetNext(pNodeToGroupItem); } // now, run through all the compound nodes turning them into groups pNodeToGroupItem = (NodeListItem *)CompoundNodeList.GetHead(); while (pNodeToGroupItem && ok) { if (pNodeToGroupItem->pNode->ShouldITransformWithChildren()) { // find out how many children we have - // if there are more than 1 that don't need their parents then we need to group them // otherwise, just promote them INT32 NumChildren = 0; pChildNode2 = pNodeToGroupItem->pNode->FindFirstChild(); while (pChildNode2) { if (!pChildNode2->NeedsParent(pNodeToGroupItem->pNode) && !pChildNode2->IsAnAttribute() && !pChildNode2->IsNodeHidden() && pChildNode2->IsAnObject()) { NumChildren ++; } pChildNode2 = pChildNode2->FindNext(); } // localise the common attributes underneath the compound node if (ok) ok = DoLocaliseCommonAttributes((NodeRenderableInk *)pNodeToGroupItem->pNode, TRUE); if (NumChildren > 1) { // make a new group node and transfer all child nodes which don't need their // parents into this group node NodeGroup * pGroup = NULL; ALLOC_WITH_FAIL(pGroup, new NodeGroup, this); *pRetnNode = pGroup; // get the first child pChildNode = pNodeToGroupItem->pNode->FindFirstChild(); while (pChildNode && ok) { pNextChildNode = pChildNode->FindNext(); if (!pChildNode->NeedsParent(pNodeToGroupItem->pNode) && pChildNode->IsAnObject() && !pChildNode->IsNodeHidden()) { if (ok) ok = DoMoveNode(pChildNode, pGroup, LASTCHILD); } // continuity check else if (pChildNode->ShouldITransformWithChildren()) { ERROR3("Found a child node which is a compound node !"); } pChildNode = pNextChildNode; } // insert the group node into the tree, and hide the original node if (ok) { ok = DoInsertNewNode( pGroup, pNodeToGroupItem->pNode, NEXT, FALSE); } } else { // if there's only one node, then move it // find the first node that NeedParent returns FALSE pChildNode = pNodeToGroupItem->pNode->FindFirstChild(); while (pChildNode->NeedsParent(pNodeToGroupItem->pNode) || pChildNode->IsAnAttribute() || pChildNode->IsNodeHidden() || !pChildNode->IsAnObject() ) { pChildNode = pChildNode->FindNext(); } // ok, move the node & set the passback variable if (ok) { ok = DoMoveNode(pChildNode, pNodeToGroupItem->pNode, NEXT); *pRetnNode = pChildNode; } } // before we hide the original, add its class factory to the list if (pList) { CompoundNodeTreeFactory * pFactory = NULL; ((NodeCompound *)pNodeToGroupItem->pNode)->CreateCompoundNodeTreeFactory(&pFactory); if (pFactory) { pList->AddItem(pFactory); } } // hide the original if (ok) { ok = DoHideNode ( pNodeToGroupItem->pNode, TRUE, &pHidden, TRUE); } } pNodeToGroupItem = (NodeListItem *)CompoundNodeList.GetNext(pNodeToGroupItem); } CompoundNodeList.DeleteAll(); */ return TRUE; }

void OpBlendNodes::RenderDragBlobs (  DocRect  Rect, Spread *  pSpread, BOOL  bSolidDrag )  [virtual]

Draws an EORed rectangle defined by AnchorPoint and DragPoint. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: Rect  - The region that needs the blobs to be drawn [INPUTS] pSpread - The spread that the drawing will happen on Reimplemented from Operation. Definition at line 4500 of file blndtool.cpp. { if (pRefStart->PointerPos == pRefEnd->PointerPos) return; // Get the scaled pixel size for the view. FIXED16 ScaledPixelWidth, ScaledPixelHeight; GetWorkingView()->GetScaledPixelSize(&ScaledPixelWidth, &ScaledPixelHeight); MILLIPOINT LineWidth = ScaledPixelWidth.MakeLong()*2; StockColour Colour = COLOUR_BLACK; if (pRefStart->RemapRef == pRefEnd->RemapRef && pRefStart->RemapRef > 0 && pRefStart->AStartNode != pRefEnd->AStartNode) { Colour = COLOUR_RED; LineWidth += LineWidth; } else if ((pRefStart->pNode != NULL) && (pRefEnd ->pNode != NULL) && (pRefStart->pNode != pRefEnd->pNode) && (pRefStart->Index >= 0) && (pRefEnd ->Index >= 0)) { Colour = COLOUR_RED; LineWidth += LineWidth; } // Inflate for the width of the line Rect.Inflate(LineWidth); RenderRegion* pRegion = DocView::RenderOnTop( &Rect, pSpread, UnclippedEOR ); while ( pRegion != NULL ) { // Set the line colour and Draw the rect pRegion->SetLineColour(Colour); // Draw the line pRegion->SetLineWidth(LineWidth); pRegion->DrawLine(pRefStart->PointerPos,pRefEnd->PointerPos); // Get the Next render region pRegion = DocView::GetNextOnTop( &Rect ); } }

void OpBlendNodes::RenderMyDragBlobs (   )

Draws an EORed rectangle defined by AnchorPoint and DragPoint. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/94 Parameters: Rect  - The region that needs the blobs to be drawn [INPUTS] pSpread - The spread that the drawing will happen on Definition at line 4474 of file blndtool.cpp. { INT32 x0 = pRefStart->PointerPos.x; INT32 y0 = pRefStart->PointerPos.y; INT32 x1 = pRefEnd ->PointerPos.x; INT32 y1 = pRefEnd ->PointerPos.y; DocRect Rect = DocRect( min(x0,x1),min(y0,y1),max(x0,x1),max(y0,y1)); RenderDragBlobs(Rect, pRefStart->pSpread, FALSE); }

virtual BOOL OpBlendNodes::SnappingDrag (   )  [inline, virtual]

Reimplemented from Operation. Definition at line 486 of file blndtool.h. { return FALSE; }

BOOL OpBlendNodes::Undo (   )  [virtual]

Gets called whenever this operation is undone. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 15/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if all OK, FALSE otherwise Errors: - See also: - Reimplemented from Operation. Definition at line 4647 of file blndtool.cpp. { // Pre-undo stuff switch (OpType) { case BLENDOPTYPE_NEW: case BLENDOPTYPE_BLENDANDBLEND: case BLENDOPTYPE_REMAP: case BLENDOPTYPE_BLENDANDOBJECT: case BLENDOPTYPE_BLENDBLENDONPATH: break; default: ERROR3_PF(("Unknown blend OpType (%d)",OpType)); break; } // Do the Undo SelOperation::Undo(); // Post-undo stuff switch (OpType) { case BLENDOPTYPE_NEW: case BLENDOPTYPE_REMAP: break; case BLENDOPTYPE_BLENDANDBLEND: /* // Check that we have a blend object ERROR3IF(pNodeBlendStart==NULL,"pNodeBlendStart == NULL"); ERROR3IF(pNodeBlendEnd ==NULL,"pNodeBlendEnd == NULL"); if (pNodeBlendStart == NULL || pNodeBlendEnd == NULL) return TRUE; DeinitAndReinitBlend(pNodeBlendStart); DeinitAndReinitBlend(pNodeBlendEnd); */ break; case BLENDOPTYPE_BLENDANDOBJECT: /* // Check that we have a blend object ERROR3IF(pNodeBlend==NULL,"pNodeBlend == NULL"); if (pNodeBlend == NULL) return TRUE; DeinitAndReinitBlend(pNodeBlend); */ break; default: break; } return TRUE; }

---

Member Data Documentation

BlendTool* OpBlendNodes::m_pBlendTool [private]

Definition at line 543 of file blndtool.h.

OpBlendOpType OpBlendNodes::OpType [private]

Definition at line 536 of file blndtool.h.

NodeBlend* OpBlendNodes::pNodeBlend [private]

Definition at line 539 of file blndtool.h.

NodeBlend* OpBlendNodes::pNodeBlendEnd [private]

Definition at line 541 of file blndtool.h.

NodeBlend* OpBlendNodes::pNodeBlendStart [private]

Definition at line 540 of file blndtool.h.

BlendToolRef* OpBlendNodes::pRefEnd [private]

Definition at line 534 of file blndtool.h.

BlendToolRef* OpBlendNodes::pRefStart [private]

Definition at line 533 of file blndtool.h.

---

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

• tools/blndtool.h (r1785/r1386)
• tools/blndtool.cpp (r1785/r1401)

---