OpEditBlendEndObject Class Reference

The operation to edit the position of the end objects of a blend on a path. More...

#include <blndtool.h>

Inheritance diagram for OpEditBlendEndObject:

List of all members.

Public Member Functions
	OpEditBlendEndObject ()
	OpEditBlendEndObject (BlendTool *pBlendTool)
	default constructor
	~OpEditBlendEndObject ()
	destructor, deletes pointers to dynamically created objects
virtual 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 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 and recalculates the blend.
virtual void	DragPointerIdle (DocCoord, ClickModifiers, Spread *, BOOL bSolidDrag)
	Pure virtual function which tells the operation that nothing is going on so that it has time to do background jobs.
void	RenderDragBlobs (Spread *pSpread, DocCoord CentrePosition, BOOL On)
	Calls the XOR outline function and draws an 'X' in the position specified.
void	RenderSelectedObjectBlobs (Spread *pSpread)
	To render the object blobs of the objects that were in the selection during the drag op. To dig myself out of the hole that I dug for myself in the implementaion of the drag op. Basically if you read the comments in DoDrag() you will be aware that we've had to temporarily change the selection for the purposes of this drag. However this means that all the objects that should really be selected lose their object blob. in order to restore them we must go through the stored selection by hand and render them individually. Awful, sorry. See also: SelState.h/.cpp DoDrag().
BOOL	DoDrag (DocCoord PointerPos, Spread *pSpread)
	This starts a drag to change the position of one of the end objects of a blend The DragFinished() method will do the hard work of recalculating the blend etc.
NodeBlendPath *	GetNodeBlendPath ()
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.
Protected Member Functions
BOOL	RecalculateBlend (DocCoord PointerPos)
	To recalculate the number of steps in the blend or distance between steps following the change of position of one of the end objects. Having done this it then creates the actions to perform the change.
BOOL	GetClosestPointOnPath (DocCoord PointerPos, DocCoord *ClosestPoint)
	To find the closest point on the nodeblend path to the point clicked or dragged on by the user. The function gets the closest point on all the paths and takes the closest. However this part is only done once as the nodeblendpath is then cached.
NodeBlender *	GetBlenderAndPosition (Node *pNode, BOOL *First)
	To find the NodeBlender on a curve that uses pNode as either its first or last node, and which position.
BOOL	InsertChangeEndActions (double NewPathProportion, DocCoord NewPosition, Node *pNodeToEdit)
	To calculate and perform the actions necessary to transform pNode to its new PathProportion whilst maintaining a constant number of blend steps.
BOOL	InsertChangeEndActions (double NewPathProportion, DocCoord NewPosition, double StepDistance, Node *pNodeToEdit)
	To calculate and perform the actions necessary to transform pNode to its new PathProportion whilst maintaining a constant distance between blend steps. This requires calculating a new position for the node that is not being edited in order to maintain the correct distance, it may also require changing the number of steps in the blend.
BOOL	CalculateNewNumStepsAndPosition (UINT32 OldNumSteps, double BlendDistance, double StepDistance, double *FixedDistance, double *MoveableDistance, UINT32 *NewNumSteps)
	Works out the number of steps needed to accomodate the new step distance, as well as working out the new positions of the end objects. This is nearly identical to the function of the same name in OpChangeBlendDistance, the difference being that if the operation cannot be performed without moving the fixed node then it will inform the user.
BOOL	InsertChangeProportion (double NewProp, BOOL FirstNode, NodeBlender *pEditBlender)
	inserts an action setting the proportion along the path variable to its new value
Protected Attributes
Matrix *	m_pTransMatrix
DocCoord	m_StartCoord
DocCoord	m_LastCoord
Range *	m_pRange
Range *	m_pCopyRange
NodeBlend *	m_pNodeBlend
SelectionState *	m_pSelState
NodeBlendPath *	m_pNodeBlendPath
BlendTool *	m_pBlendTool
Private Member Functions
	CC_DECLARE_DYNCREATE (OpEditBlendEndObject)

---

Detailed Description

The operation to edit the position of the end objects of a blend on a path.

Author:

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

Date:

6/9/99

Definition at line 919 of file blndtool.h.

---

Constructor & Destructor Documentation

OpEditBlendEndObject::OpEditBlendEndObject (   )  [inline]

Definition at line 924 of file blndtool.h. {}

OpEditBlendEndObject::OpEditBlendEndObject (  BlendTool *  pBlendTool  )

default constructor Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 Returns: Definition at line 8802 of file blndtool.cpp. { if (pBlendTool == NULL) { ERROR3("No blend tool"); return; } m_pTransMatrix = NULL; m_pNodeBlend = NULL; m_pRange = NULL; m_pNodeBlendPath = NULL; m_pBlendTool = pBlendTool; }

OpEditBlendEndObject::~OpEditBlendEndObject (   )

destructor, deletes pointers to dynamically created objects Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 Returns: Definition at line 8829 of file blndtool.cpp. { delete m_pTransMatrix; delete m_pSelState; }

---

Member Function Documentation

BOOL OpEditBlendEndObject::CalculateNewNumStepsAndPosition (  UINT32  OldNumSteps, double  BlendDistance, double  StepDistance, double *  FixedDistance, double *  MoveableDistance, UINT32 *  NewNumSteps )  [protected]

Works out the number of steps needed to accomodate the new step distance, as well as working out the new positions of the end objects. This is nearly identical to the function of the same name in OpChangeBlendDistance, the difference being that if the operation cannot be performed without moving the fixed node then it will inform the user. Parameters: NewNumSteps  - the new number of steps required [OUTPUTS] MoveableDistance - the new position of the end that we don't care about FixedDistance - in some rare instances we may have adjust the fixed position in order to accomodate the desired step distance is the last object. returns: TRUE if all went well, FALSE if the step distance gives and invalid number of steps. See Also: Definition at line 9806 of file blndtool.cpp. { // First check parameters if (OldNumSteps < 0 || StepDistance < 0) { ERROR3("Invalid parameter"); return FALSE; } if (BlendDistance < (*FixedDistance + *MoveableDistance)) { ERROR3("Invalid distance parameter"); return FALSE; } //initialise to zero *NewNumSteps = 0; // get the distance currently occupied by the blend double DistanceUsed = BlendDistance - (*FixedDistance + *MoveableDistance); // try to use all the space UINT32 TempNumSteps = (UINT32)(DistanceUsed / StepDistance); if (TempNumSteps > 0) { *NewNumSteps = TempNumSteps; double NewDistance = TempNumSteps * StepDistance; *MoveableDistance = BlendDistance - (*FixedDistance + NewDistance); } // thats too long, try moving the other node all the way to the end else { TempNumSteps = (UINT32)((BlendDistance - *FixedDistance)/ StepDistance); if (TempNumSteps > 0) { double NewDistance = TempNumSteps * StepDistance; *NewNumSteps = TempNumSteps; *MoveableDistance = BlendDistance - (*FixedDistance + NewDistance); } else { // still didn't work, just quit for now but maybe // think about bringing up a dialog asking the user if they // wish to go to edit steps mode. return FALSE; } } // test to see that what we have is ok. if (*NewNumSteps > 0) return TRUE; else return FALSE; }

OpEditBlendEndObject::CC_DECLARE_DYNCREATE (  OpEditBlendEndObject   )  [private]

BOOL OpEditBlendEndObject::Declare (   )  [static]

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

BOOL OpEditBlendEndObject::DoDrag (  DocCoord  PointerPos, Spread *  pSpread )

This starts a drag to change the position of one of the end objects of a blend The DragFinished() method will do the hard work of recalculating the blend etc. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 Parameters: Position  of the pointer to start the drag from. [INPUTS] The current spread. -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Definition at line 8913 of file blndtool.cpp. { GetApplication()->RegisterIdleProcessor(IDLEPRIORITY_HIGH, this); List BlendList; Node* pNodeUnderPoint = NULL; BOOL ok = BevelTools::BuildListOfSelectedNodes(&BlendList, CC_RUNTIME_CLASS(NodeBlend), FALSE); if (ok) { NodeListItem* pListItem = (NodeListItem*)BlendList.GetHead(); while (pListItem != NULL) { NodeBlend* pNodeBlend = (NodeBlend*)pListItem->pNode; ok = pNodeBlend->HitOnEndDragBlob(PointerPos, &pNodeUnderPoint); if (ok) { ObjChangeFlags cFlags; cFlags.TransformNode = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this); if (pNodeBlend->AllowOp(&ObjChange, TRUE)) { m_pNodeBlend = pNodeBlend; break; } } pListItem = (NodeListItem*)BlendList.GetNext(pListItem); } } else { // that didn't work, but it may be selected inside so try this; pNodeUnderPoint = NodeRenderableInk::FindSimpleAtPoint(pSpread, PointerPos); if (pNodeUnderPoint == NULL) { // op shouldn't have been allowed as we are not above a node, lets quit FailAndExecute(); End(); BlendList.DeleteAll(); return FALSE; } Node* pParent = pNodeUnderPoint->FindParentOfSelected(); if (pParent == NULL || (!pParent->IS_KIND_OF(NodeBlend))) { FailAndExecute(); End(); BlendList.DeleteAll(); return FALSE; } // its ok, we can continue m_pNodeBlend = (NodeBlend*)pParent; } BlendList.DeleteAll(); // see if there is a node between the blend and the simple node, if so it may be a group NodeRenderableInk* pGroupUnderPoint = NodeRenderableInk::FindInnerCompound(pNodeUnderPoint, m_pNodeBlend); Node* pNodeToEdit = NULL; if (pGroupUnderPoint != NULL) { // if the group is the same as the nodeblend if (pGroupUnderPoint == m_pNodeBlend) { pNodeToEdit = (Node*) pNodeUnderPoint; } else { pNodeToEdit = (Node*)pGroupUnderPoint; } } else { FailAndExecute(); End(); return FALSE; } // save the selection state for restoring at the end of the drag ALLOC_WITH_FAIL(m_pSelState, new SelectionState, this); ok = m_pSelState->Record(); if (!ok) { ERROR3("Could not record selection"); FailAndExecute(); End(); return FALSE; } m_pRange = GetApplication()->FindSelection(); if (m_pRange == NULL) { ERROR3("No Selection"); FailAndExecute(); End(); return FALSE; } // the bodging continues... When the TransformNodeAction gets called as part of // the undoing of this op it changes the selection so that only the transformed node is // selected. Hence we need to insert an action that will occur after TransformNode in the // undo list in order to have the selection as it started....nice Action* pRestoreAction; SelectionState* pCopySelState = NULL; ALLOC_WITH_FAIL(pCopySelState, new SelectionState, this); // gets destroyed by RestoreSelectionsAction pCopySelState->Record(); ok = RestoreSelectionsAction::Init(this, &UndoActions, pCopySelState, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, &pRestoreAction); /* the function proto RestoreSelectionsAction::Init(Operation* const pOp, ActionList* pActionList, SelectionState* SelState, BOOL Toggle, BOOL ToggleStatus, BOOL SelStateShared, BOOL RenderStartBlobs, BOOL RenderEndBlobs, BOOL StartRestore, Action** NewAction) */ // setting the selection so that only the node we wish to be XOR'd during the // drag is selected - ugh. if (ok) { NodeRenderableInk::DeselectAll(); ((NodeRenderable*)pNodeToEdit)->Select(TRUE); // we don't want to see those object blobs whilst dragging BlobManager* BlobMgr = GetApplication()->GetBlobManager(); if (BlobMgr != NULL) { // Decide which blobs we will display BlobStyle MyBlobs; MyBlobs.Object = FALSE; MyBlobs.Tiny = FALSE; BlobMgr->ToolInterest(MyBlobs); } m_pRange->ResetXOROutlineRenderer(); // work out where we need to translate to and create a matrix for it DocRect BRect = ((NodeRenderableBounded*)pNodeToEdit)->GetBoundingRect(); m_StartCoord = BRect.Centre(); ALLOC_WITH_FAIL(m_pTransMatrix, new Matrix, this) m_pTransMatrix->SetTranslation(PointerPos - m_StartCoord); m_pRange->RenderXOROutlinesOn(NULL, pSpread, m_pTransMatrix, pNodeUnderPoint); m_LastCoord = m_StartCoord; RenderSelectedObjectBlobs(pSpread); // And tell the Dragging system that we need drags to happen StartDrag( DRAGTYPE_AUTOSCROLL ); } else { FailAndExecute(); End(); } return ok; }

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

Ends the drag and recalculates the blend. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 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, DoDrag() for an explanation of whats going on with the selection. Reimplemented from Operation. Definition at line 9171 of file blndtool.cpp. { GetApplication()->RemoveIdleProcessor(IDLEPRIORITY_HIGH, this); DocCoord PointOnLine; BOOL ValidPoint = GetClosestPointOnPath(PointerPos, &PointOnLine); if (!ValidPoint) { EndDrag(); // not sure this is correct, should we make some attempt to return; // render the xor outlines off? } Matrix NewMatrix; NewMatrix.SetTranslation(PointOnLine - m_StartCoord); m_pRange->RenderXOROutlinesOff(NULL, pSpread, &NewMatrix); EndDrag(); if (Success) Success = RecalculateBlend(PointOnLine); // bring back the object blobs // we don't want to see those object blobs whilst dragging BlobManager* BlobMgr = GetApplication()->GetBlobManager(); if (BlobMgr != NULL) { // Decide which blobs we will display BlobStyle MyBlobs; MyBlobs.Object = TRUE; MyBlobs.Tiny = FALSE; BlobMgr->ToolInterest(MyBlobs); } // restore the selection - very important m_pSelState->Restore(); if (Success) { SelRange* pSel = GetApplication()->FindSelection(); pSel->Update(); } else FailAndExecute(); // Inform all changed nodes that we have finished ObjChangeFlags cFlags; ObjChangeParam ObjChange(OBJCHANGE_FINISHED, cFlags, NULL, this); /*BOOL ok =*/ UpdateChangedNodes(&ObjChange); End(); //TRACEUSER( "Diccon", _T("\nFinished dragging end object\n")); }

void OpEditBlendEndObject::DragPointerIdle (  DocCoord  PointerPos, ClickModifiers  Clickmodifiers, Spread *  pSpread, BOOL  bSolidDrag )  [virtual]

Pure virtual function which tells the operation that nothing is going on so that it has time to do background jobs. virtual void Operation::DragPointerIdle( 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 9146 of file blndtool.cpp. { m_pRange->RenderXOROutlinesOn(NULL, pSpread, m_pTransMatrix, NULL); }

void OpEditBlendEndObject::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 9109 of file blndtool.cpp. { // get rid of existing blobs RenderDragBlobs(pSpread, m_LastCoord, FALSE); if (m_pBlendTool != NULL) m_pBlendTool->DisplayStatusBarHelp(_R(IDS_BLENDSTATUS_MOVEEND)); DocCoord PointOnLine; BOOL ValidPoint = GetClosestPointOnPath(PointerPos, &PointOnLine); if (!ValidPoint) { EndDrag(); // not sure this is correct, should we make some attempt to return; // render the xor outlines off? } // draw new blobs RenderDragBlobs(pSpread, PointOnLine, TRUE); //RenderAllBlobs(pSpread); m_LastCoord = PointOnLine; }

NodeBlender * OpEditBlendEndObject::GetBlenderAndPosition (  Node *  pEditNode, BOOL *  pFirst )  [protected]

To find the NodeBlender on a curve that uses pNode as either its first or last node, and which position. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 Parameters: pNode  - the blend object that is being edited [INPUTS] pFirst  - TRUE if pNode is the first object of the blender, FALSE if it [OUTPUTS] is the last object. returns: pointer to the nodeblender responsible for the blend being edited, or NULL if invalid. Definition at line 9887 of file blndtool.cpp. { if (pEditNode == NULL) { ERROR3("Node is NULL"); return NULL; } if (m_pNodeBlend == NULL) { ERROR3("m_pNodeBlend is NULL"); return NULL; } NodeBlender* pBlender = m_pNodeBlend->FindFirstBlender(); while (pBlender != NULL) { if (pBlender->IsBlendedOnCurve()) { if (pBlender->GetNodeStart() == pEditNode) { *pFirst = TRUE; return pBlender; } else if (pBlender->GetNodeEnd() == pEditNode) { *pFirst = FALSE; return pBlender; } else { // also need to check for compound nodes .... if (pBlender->GetNodeStart ()->IsNodeInSubtree (pEditNode)) { *pFirst = TRUE; return pBlender; } else // check the end node { if (pBlender->GetNodeEnd ()->IsNodeInSubtree (pEditNode)) { *pFirst = FALSE; return pBlender; } } } } pBlender = m_pNodeBlend->FindNextBlender(pBlender); } // we didn't find a nodeblender ERROR3("Couldn't find a nodeblender"); return NULL; }

BOOL OpEditBlendEndObject::GetClosestPointOnPath (  DocCoord  PointerPos, DocCoord *  ClosestPoint )  [protected]

To find the closest point on the nodeblend path to the point clicked or dragged on by the user. The function gets the closest point on all the paths and takes the closest. However this part is only done once as the nodeblendpath is then cached. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 Parameters: PointerPos  - The current position of the mouse in Doc Coords [INPUTS] ClosestPoint  - the closest point on the nodeblendpath to pointerpos [OUTPUTS] returns: TRUE if successful , FALSE otherwise Definition at line 9962 of file blndtool.cpp. { if (m_pNodeBlend == NULL) { ERROR3("There is no NodeBlend"); return FALSE; } if (m_pNodeBlendPath == NULL) { UINT32 NBPCounter = 0; NodeBlendPath* pNodeBlendPath = m_pNodeBlend->GetNodeBlendPath(NBPCounter); if (pNodeBlendPath == NULL) { ERROR3("This blend has no nodeblendpath"); return FALSE; } UINT32 ClosestIndex = 0; double ClosestDistance = 999999999999.; INT32 ClosestPath=0; double ClosestMu=0; while (pNodeBlendPath != NULL) { INT32 Index; double Mu; double SqrDistance = pNodeBlendPath->InkPath.SqrDistanceToPoint(PointerPos, &Index, &Mu); if (SqrDistance < ClosestDistance) { ClosestDistance = SqrDistance; ClosestPath = NBPCounter; ClosestIndex = Index; ClosestMu = Mu; } pNodeBlendPath = m_pNodeBlend->GetNodeBlendPath(++NBPCounter); } pNodeBlendPath = m_pNodeBlend->GetNodeBlendPath(ClosestPath); DocCoord PointOnLine = pNodeBlendPath->InkPath.ClosestPointTo(ClosestMu, ClosestIndex); // assign the point *ClosestPoint = PointOnLine; // assign the path to the member variable m_pNodeBlendPath = pNodeBlendPath; } else { // if we have already cached the nodeblendpath INT32 Index=0; double Mu=0; /*double SqrDistance = */m_pNodeBlendPath->InkPath.SqrDistanceToPoint(PointerPos, &Index, &Mu); DocCoord PointOnLine = m_pNodeBlendPath->InkPath.ClosestPointTo(Mu, Index); *ClosestPoint = PointOnLine; } return TRUE; }

NodeBlendPath* OpEditBlendEndObject::GetNodeBlendPath (   )

void OpEditBlendEndObject::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: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 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 10039 of file blndtool.cpp. { String_256 test = "test string"; }

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

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

BOOL OpEditBlendEndObject::InsertChangeEndActions (  double  NewPathProp, DocCoord  NewPosition, double  StepDistance, Node *  pNodeToEdit )  [protected]

To calculate and perform the actions necessary to transform pNode to its new PathProportion whilst maintaining a constant distance between blend steps. This requires calculating a new position for the node that is not being edited in order to maintain the correct distance, it may also require changing the number of steps in the blend. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/9/99 Parameters: PathProportion  - the new proportion along the path to move the end object to [INPUTS] pNode - the blend object that is being edited NewPosition - the new position as a coordinate pNodeToEdit  - some members are altered by these actions [OUTPUTS] returns: TRUE if all actions were correctly carried out, else FALSE See Also: Overridden version of this function for use with constant number of blend steps Definition at line 9489 of file blndtool.cpp. { // couple of quick checks if (pNodeToEdit == NULL) { ERROR3("Node to edit is NULL"); return FALSE; } if (NewPathProp < 0.0 || NewPathProp > 1.0) { ERROR3("Invalid path proportion"); return FALSE; } if (m_pNodeBlend == NULL) { ERROR3("m_pNodeBlend is NULL"); return FALSE; } // find out if this node is the first or last node of the blend BOOL NodeIsFirst; NodeBlender* pNodeBlender = GetBlenderAndPosition(pNodeToEdit, &NodeIsFirst); if (pNodeBlender == NULL) { ERROR3("No NodeBlender"); return FALSE; } // get the variables that we need to pass to CalculateNewNumSteps() double OtherDistance = 0.0; double ThisDistance = 0.0; double StartProp = 0.0; double EndProp = 1.0; UINT32 CurrentSteps = m_pNodeBlend->GetNumBlendSteps(); UINT32 NewNumSteps = CurrentSteps; double BlendDistance = 0.0; BOOL Valid = m_pNodeBlend->GetBlendDistance(TRUE, &BlendDistance); if (Valid) { Valid = m_pNodeBlend->GetStartAndEndProportions(&StartProp, &EndProp); if (Valid) { // we must pass the distance of each object from their respective ends, // i.e. the distance of the end object is the distance from the object to // the end of the path. if (NodeIsFirst) { // have we reversed the order? If so then do it as an action if (NewPathProp >= EndProp) { // Swap the ends Valid = InsertChangeProportion(NewPathProp, NodeIsFirst, pNodeBlender); // get the new proportions if (Valid) Valid = m_pNodeBlend->GetStartAndEndProportions(&StartProp, &EndProp); // work out the distances from the closest end to each object OtherDistance = BlendDistance * StartProp; ThisDistance = BlendDistance * (1-NewPathProp); // we have swapped ends NodeIsFirst = FALSE; } else { OtherDistance = BlendDistance * (1-EndProp); ThisDistance = BlendDistance * NewPathProp; } } else { if (NewPathProp <= StartProp) { Valid = InsertChangeProportion(NewPathProp, NodeIsFirst, pNodeBlender); if (Valid) Valid = m_pNodeBlend->GetStartAndEndProportions(&StartProp, &EndProp); OtherDistance = BlendDistance * (1-EndProp); ThisDistance = BlendDistance * NewPathProp; NodeIsFirst = TRUE; } else { OtherDistance = BlendDistance * StartProp; ThisDistance = BlendDistance * (1-NewPathProp); } } Valid = CalculateNewNumStepsAndPosition(CurrentSteps, BlendDistance, StepDistance, &ThisDistance, &OtherDistance, &NewNumSteps); if (Valid) { double NewOtherProp = 0.0; // if we are editing the start node make the other distance go from the // start of the path if (NodeIsFirst) OtherDistance = BlendDistance - OtherDistance; NewOtherProp = OtherDistance / BlendDistance; Valid = DoInvalidateNodeRegion((NodeRenderableInk*)m_pNodeBlend,TRUE,FALSE); if (Valid) Valid = (InvalidateBoundsAction::Init(this,&UndoActions,m_pNodeBlend,TRUE) != AC_FAIL); if (Valid) { // NodeBlender* pThisBlender = NULL; NodeBlender* pOtherBlender = NULL; Node* pOtherNode = NULL; if (NodeIsFirst) { pOtherBlender = m_pNodeBlend->FindLastBlender(); if (pOtherBlender == NULL) { ERROR3("Couldn't find blender"); return FALSE; } pOtherNode = pOtherBlender->GetNodeEnd(); } else { pOtherBlender = m_pNodeBlend->FindFirstBlender(); if (pOtherBlender == NULL) { ERROR3("Couldn't find blender"); return FALSE; } pOtherNode = pOtherBlender->GetNodeStart(); } if (pOtherNode == NULL) { ERROR3("Couldn't find other blend node"); return FALSE; } // insert a change steps action if we need one if (NewNumSteps != CurrentSteps) { double DistanceEntered = m_pNodeBlend->GetDistanceEntered(); ChangeBlendStepsAction* pStepAction; NodeRenderableInk * pInk = (NodeRenderableInk *)m_pNodeBlend; Valid = ChangeBlendStepsAction::Init(this,&UndoActions,pInk,CurrentSteps,DistanceEntered, &pStepAction) != AC_FAIL; m_pNodeBlend->SetNumBlendSteps(NewNumSteps); } // insert change proportion for the node we edited Valid = InsertChangeProportion(NewPathProp, NodeIsFirst, pNodeBlender); // insert change for the node that was moved in order to retain constant step distance if (Valid) Valid = InsertChangeProportion(NewOtherProp, (!NodeIsFirst), pOtherBlender); // transform the edited node to its new position if (Valid) Valid = m_pNodeBlend->TransformNodeToPoint((NodeRenderableInk*)pNodeToEdit,&NewPosition,this,0.0); // transform the other node to its new position if (Valid) { DocCoord NewPoint; double VoidParam; Valid = pOtherBlender->GetPointFromDistance(OtherDistance, &NewPoint, &VoidParam); if (Valid) Valid = m_pNodeBlend->TransformNodeToPoint((NodeRenderableInk*)pOtherNode, &NewPoint, this, 0.0); // find out if we are part of a bevel, shadow or contour, if so then we must regenerate Node* pController = m_pNodeBlend->GetParentController(); if (pController != NULL) pController->RegenerateNode(this); if (Valid) Valid = DoInvalidateNodeRegion((NodeRenderableInk*)m_pNodeBlend,TRUE,FALSE); if (Valid) Valid = (InvalidateBoundsAction::Init(this,&UndoActions,m_pNodeBlend,TRUE) != AC_FAIL); } } } } } return Valid; }

BOOL OpEditBlendEndObject::InsertChangeEndActions (  double  NewPathProp, DocCoord  NewPosition, Node *  pNodeToEdit )  [protected]

To calculate and perform the actions necessary to transform pNode to its new PathProportion whilst maintaining a constant number of blend steps. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/9/99 Parameters: PathProportion  - the new proportion along the path to move the end object to [INPUTS] pNodeToEdit - the blend object that is being edited NewPosition - the new position as a coordinate pNodeToEdit  - some members are altered by these actions [OUTPUTS] returns: TRUE if all actions were correctly carried out, else FALSE See Also: Overridden version of this function for use with constant distance between blend steps NodeIsFirst); Definition at line 9320 of file blndtool.cpp. { // couple of quick checks if (pNodeToEdit == NULL) { ERROR3("Node to edit is NULL"); return FALSE; } if (NewPathProp < 0.0 || NewPathProp > 1.0) { ERROR3("Invalid path proportion"); return FALSE; } // find out if this node is the first or last node of the blender on a curve BOOL NodeIsFirst; NodeBlender* pNodeBlender = GetBlenderAndPosition(pNodeToEdit, &NodeIsFirst); BOOL Valid = FALSE; if (pNodeBlender == NULL) { ERROR3("No NodeBlender"); return FALSE; } else { Valid = DoInvalidateNodeRegion((NodeRenderableInk*)m_pNodeBlend,TRUE,FALSE); if (Valid) Valid = (InvalidateBoundsAction::Init(this,&UndoActions,m_pNodeBlend,TRUE) != AC_FAIL); // change the proportion along the path to the new value if (Valid) Valid = InsertChangeProportion(NewPathProp, NodeIsFirst, pNodeBlender); double AngleChange = 0.0; // if we are rotated along the curve then calculate the new angle if (m_pNodeBlend->IsTangential() && Valid) { NodeBlendPath* pNodeBlendPath = pNodeBlender->GetNodeBlendPath(); if (pNodeBlendPath != NULL) { double NewAngle = 0.0; double OldAngle = 0.0; double BlendRatio = 0.0; ChangeBlenderOpParam ChangeParam; if (NodeIsFirst) { OldAngle = pNodeBlender->GetAngleStart(); ChangeParam.m_ChangeType = CHANGEBLENDER_ANGLESTART; BlendRatio = 0.0; } else { OldAngle = pNodeBlender->GetAngleEnd(); ChangeParam.m_ChangeType = CHANGEBLENDER_ANGLEEND; BlendRatio = 1.0; } // MILLIPOINT PathDistance = (MILLIPOINT)(pNodeBlendPath->GetPathLength()); // MILLIPOINT PointDistance = (MILLIPOINT)(NewPathProp * PathDistance); DocCoord Point; Valid = pNodeBlender->GetPointOnNodeBlendPath(BlendRatio, &Point, &NewAngle); if (Valid) { AngleChange = NewAngle - OldAngle; TRACEUSER( "Diccon", _T("Moved end: OldAngle: %f, NewAngle %f, Change %f\n"), OldAngle, NewAngle, AngleChange); // make it undoable if (!NodeIsFirst) ChangeParam.m_NewAngleEnd = NewAngle; else ChangeParam.m_NewAngleStart = NewAngle; ActionCode Ac = ChangeBlenderAction::Init( this, &UndoActions, pNodeBlender,ChangeParam); Valid = (Ac !=AC_FAIL); } } } // transform the edited node to its new location if (Valid) Valid = m_pNodeBlend->TransformNodeToPoint((NodeRenderableInk*)pNodeToEdit,&NewPosition,this,AngleChange); // find out if this node is part of another blend, and if so then regenerate it if (Valid) { BOOL OtherEnd; NodeBlender* pOtherBlender = m_pNodeBlend->NodeIsPartOfBlender( pNodeToEdit, pNodeBlender, &OtherEnd); if (pOtherBlender != NULL && pOtherBlender != pNodeBlender) { // if its not on a curve just ask it to reninitialise if (!pOtherBlender->IsBlendedOnCurve()) { ChangeBlenderOpParam Param; Param.m_ChangeType = CHANGEBLENDER_REGEN; Valid = ChangeBlenderAction::Init(this, &UndoActions, pOtherBlender, Param); } // if it is on a curve work set the new position for the other blender else { ChangeBlenderOpParam ChangeParam; if (OtherEnd) { ChangeParam.m_ChangeType = CHANGEBLENDER_PATHSTART; ChangeParam.m_NewPathStart = NewPathProp; } else { ChangeParam.m_ChangeType = CHANGEBLENDER_PATHEND; ChangeParam.m_NewPathEnd = NewPathProp; } ActionCode Ac = ChangeBlenderAction::Init( this, &UndoActions, pOtherBlender,ChangeParam); Valid = (Ac !=AC_FAIL); } } } } // regenerate any shadows, bevels or contours Node* pController = ((Node*)m_pNodeBlend)->FindParent(CC_RUNTIME_CLASS(NodeShadowController)); if (pController != NULL) pController->RegenerateNode(this); else { pController = ((Node*)m_pNodeBlend)->FindParent(CC_RUNTIME_CLASS(NodeBevelController)); if (pController != NULL) pController->RegenerateNode(this); else { pController = ((Node*)m_pNodeBlend)->FindParent(CC_RUNTIME_CLASS(NodeContourController)); if (pController != NULL) pController->RegenerateNode(this); } } if (Valid) Valid = DoInvalidateNodeRegion((NodeRenderableInk*)m_pNodeBlend,TRUE,FALSE); if (Valid) Valid = (InvalidateBoundsAction::Init(this,&UndoActions,m_pNodeBlend,TRUE) != AC_FAIL); return Valid; }

BOOL OpEditBlendEndObject::InsertChangeProportion (  double  NewProp, BOOL  FirstNode, NodeBlender *  pEditBlender )  [protected]

inserts an action setting the proportion along the path variable to its new value Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/9/99 Parameters: PathProportion  - the new proportion along the path to move the end object to [INPUTS] pNode - the blend object that is being edited pNodeToEdit  - some members are altered by these actions [OUTPUTS] returns: TRUE if all actions were correctly carried out, else FALSE Definition at line 9683 of file blndtool.cpp. { // insert the change blender action ChangeBlenderOpParam BlenderParam; ChangeBlendOpParam BlendParam; BOOL Valid; // lets see if we need to swap the ends if (FirstNode) { // if the new proportion of path is past the other end then // we need to swap ends. if (NewProp > pEditBlender->GetProportionOfPathDistEnd()) { BlenderParam.m_ChangeType = CHANGEBLENDER_SWAPENDS; Valid = ChangeBlenderAction::Init(this, &UndoActions, pEditBlender, BlenderParam); if (Valid) { // set the new start proportion to the old end proportion BlenderParam.m_ChangeType = CHANGEBLENDER_PATHSTART; BlenderParam.m_NewPathStart = pEditBlender->GetProportionOfPathDistEnd(); BlendParam.NewEndObject = FIRST; Valid = ChangeBlenderAction::Init(this, &UndoActions, pEditBlender, BlenderParam); if (Valid) { BlenderParam.m_ChangeType = CHANGEBLENDER_PATHEND; BlenderParam.m_NewPathEnd = NewProp; BlendParam.NewEndObject = LAST; Valid = ChangeBlenderAction::Init(this, &UndoActions, pEditBlender, BlenderParam); } } } else { // just a regular end edit BlenderParam.m_ChangeType = CHANGEBLENDER_PATHSTART; BlenderParam.m_NewPathStart = NewProp; BlendParam.NewEndObject = FIRST; Valid = ChangeBlenderAction::Init(this, &UndoActions, pEditBlender, BlenderParam); } } else { if (NewProp < pEditBlender->GetProportionOfPathDistStart()) { BlenderParam.m_ChangeType = CHANGEBLENDER_SWAPENDS; Valid = ChangeBlenderAction::Init(this, &UndoActions, pEditBlender, BlenderParam); if (Valid) { // set the new end proportion to the old start proportion BlenderParam.m_ChangeType = CHANGEBLENDER_PATHEND; BlenderParam.m_NewPathEnd = pEditBlender->GetProportionOfPathDistStart(); BlendParam.NewEndObject = LAST; Valid = ChangeBlenderAction::Init(this, &UndoActions, pEditBlender, BlenderParam); if (Valid) { BlenderParam.m_ChangeType = CHANGEBLENDER_PATHSTART; BlenderParam.m_NewPathStart = NewProp; BlendParam.NewEndObject = FIRST; Valid = ChangeBlenderAction::Init(this, &UndoActions, pEditBlender, BlenderParam); } } } else { // just a regular end edit BlenderParam.m_ChangeType = CHANGEBLENDER_PATHEND; BlenderParam.m_NewPathEnd = NewProp; BlendParam.NewEndObject = LAST; Valid = ChangeBlenderAction::Init(this, &UndoActions, pEditBlender, BlenderParam); } } return Valid; }

BOOL OpEditBlendEndObject::RecalculateBlend (  DocCoord  EndPosition  )  [protected]

To recalculate the number of steps in the blend or distance between steps following the change of position of one of the end objects. Having done this it then creates the actions to perform the change. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 Parameters: PointerPos  - The position to move the end object to [INPUTS] [OUTPUTS]  returns: TRUE if successful , FALSE otherwise Definition at line 9244 of file blndtool.cpp. { // check the inputs if (m_pNodeBlend == NULL) { ERROR3("NodeBlend is not initialised"); return FALSE; } // get a pointer to the path if (m_pNodeBlendPath == NULL) { ERROR3("NodeBlend is not on a path"); return FALSE; } // find out how far the point is along the path double PathLength = m_pNodeBlendPath->GetPathLength(); INT32 DistanceAlongPath = 0; BOOL Valid = m_pNodeBlendPath->InkPath.GetDistanceToPoint(EndPosition, &DistanceAlongPath); // Range::FindFirst() always returns NULL for some reason so I'm forced // to use FindLast(), given that there is only one this seems ok. Node* pNode = m_pRange->FindLast(); NodeRenderableInk* pNodeToEdit= NULL; if (pNode == NULL) { ERROR3("Range is empty"); Valid = FALSE; } else pNodeToEdit = (NodeRenderableInk*)pNode; if (Valid) { // depending on which Edit mode the blend is in try to keep either // number of steps or distance between steps constant. double NewPathProportion = DistanceAlongPath / PathLength; if (m_pNodeBlend->GetEditState() == EDIT_STEPS) { Valid = InsertChangeEndActions(NewPathProportion, EndPosition, pNode); } else { double StepDistance = m_pNodeBlend->GetDistanceEntered(); Valid = InsertChangeEndActions(NewPathProportion, EndPosition, StepDistance, pNode); } } return Valid; }

void OpEditBlendEndObject::RenderDragBlobs (  Spread *  pSpread, DocCoord  CentrePosition, BOOL  On )

Calls the XOR outline function and draws an 'X' in the position specified. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/9/99 Parameters: CentrePosition  - the centre of the 'X' to be drawn [INPUTS] pSpread - The spread that the drawing will happen on On - are we rendering the blobs on or off? Definition at line 10061 of file blndtool.cpp. { if (pSpread == NULL) { ERROR3("No Spread"); return; } if (m_pRange == NULL || m_pTransMatrix == NULL) { ERROR3("Null member variables"); return; } Matrix NewMatrix; NewMatrix.SetTranslation(CentrePosition - m_StartCoord); if (On == FALSE) m_pRange->RenderXOROutlinesOff(NULL, pSpread, m_pTransMatrix); else { m_pRange->RenderXOROutlinesOn(NULL, pSpread, &NewMatrix, NULL); m_pTransMatrix->SetTranslation(CentrePosition - m_StartCoord); } //we'll render the 'X' directly so we need a render region RenderRegion* pRegion = DocView::RenderOnTop(NULL, pSpread, UnclippedEOR); while ( pRegion != NULL ) { pRegion->SetLineColour(COLOUR_UNSELECTEDBLOB); pRegion->SetFillColour(COLOUR_UNSELECTEDBLOB); // Draw a blob at the centre point DocRect BlobSize; BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr != NULL) { pBlobMgr->GetBlobRect(CentrePosition, &BlobSize); 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)); } pRegion = DocView::GetNextOnTop(NULL); } }

void OpEditBlendEndObject::RenderSelectedObjectBlobs (  Spread *  pSpread  )

To render the object blobs of the objects that were in the selection during the drag op. To dig myself out of the hole that I dug for myself in the implementaion of the drag op. Basically if you read the comments in DoDrag() you will be aware that we've had to temporarily change the selection for the purposes of this drag. However this means that all the objects that should really be selected lose their object blob. in order to restore them we must go through the stored selection by hand and render them individually. Awful, sorry. See also: SelState.h/.cpp DoDrag(). Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 28/9/99 Parameters: pSpread  - The spread that the drawing will happen on [INPUTS] Definition at line 10131 of file blndtool.cpp. { // variables we want so long as the selection state member is ok Node** pSelectionNodes = NULL; UINT32 NumNodes = 0; SelNdRng* pSelectedRanges = NULL; UINT32 NumRanges = 0; // check out the member if (m_pSelState == NULL) { ERROR3("m_pSelState is NULL"); return; } else { pSelectionNodes = m_pSelState->GetNodeList(); NumNodes = m_pSelState->GetNumNodes(); pSelectedRanges = m_pSelState->GetSelectionList(); NumRanges = m_pSelState->GetNumRanges(); } if ((NumNodes == 0 || pSelectionNodes[0] == NULL) && (NumRanges == 0 || pSelectedRanges[0].FirstNode == NULL)) { ERROR3("No selection nodes"); EndDrag(); return; } UINT32 i; for ( i = 0; i < NumRanges; i++) { NodeRenderable* pNode = (NodeRenderable*)pSelectedRanges[i].FirstNode; for (UINT32 j = 0; j < pSelectedRanges[i].NumSelected; j++) { if (pNode == NULL) { ERROR3("Node is null"); break; } RenderRegion* pOnTopRegion = DocView::RenderOnTop(NULL, pSpread, ClippedEOR); while (pOnTopRegion) { pNode->RenderObjectBlobs(pOnTopRegion); // Go find the next region pOnTopRegion = DocView::GetNextOnTop(NULL); } pNode = (NodeRenderable*)pNode->FindNext(CC_RUNTIME_CLASS(NodeRenderableInk)); } } for ( i = 0; i < NumNodes; i++) { NodeRenderable* pNode = (NodeRenderable*)pSelectionNodes[i]; RenderRegion* pOnTopRegion = DocView::RenderOnTop(NULL, pSpread, ClippedEOR); while (pOnTopRegion) { pNode->RenderObjectBlobs(pOnTopRegion); // Go find the next region pOnTopRegion = DocView::GetNextOnTop(NULL); } } }

---

Member Data Documentation

DocCoord OpEditBlendEndObject::m_LastCoord [protected]

Definition at line 972 of file blndtool.h.

BlendTool* OpEditBlendEndObject::m_pBlendTool [protected]

Definition at line 978 of file blndtool.h.

Range* OpEditBlendEndObject::m_pCopyRange [protected]

Definition at line 974 of file blndtool.h.

NodeBlend* OpEditBlendEndObject::m_pNodeBlend [protected]

Definition at line 975 of file blndtool.h.

NodeBlendPath* OpEditBlendEndObject::m_pNodeBlendPath [protected]

Definition at line 977 of file blndtool.h.

Range* OpEditBlendEndObject::m_pRange [protected]

Definition at line 973 of file blndtool.h.

SelectionState* OpEditBlendEndObject::m_pSelState [protected]

Definition at line 976 of file blndtool.h.

Matrix* OpEditBlendEndObject::m_pTransMatrix [protected]

Definition at line 970 of file blndtool.h.

DocCoord OpEditBlendEndObject::m_StartCoord [protected]

Definition at line 971 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)

---