OpNodePathEditBlob Class Reference

This operation is started by the NodePath when it receives a drag message from one of the tools. It uses it to drag one (or many) of the paths control points around the screen to edit the path. As the control points are dragged about the new version of the path, corosponding to the new blob positions, will be EOR rendered to the window. More...

#include <pathedit.h>

Inheritance diagram for OpNodePathEditBlob:

List of all members.

Public Member Functions
	OpNodePathEditBlob ()
void	DoStartDragEdit (NodePath *, DocCoord Anchor, Spread *)
	This is called to start a drag operation on an endpoint on a path.
virtual void	DragPointerMove (DocCoord Pos, ClickModifiers Mods, Spread *pSpread, BOOL bSolidDrag)
	This is called every time the mouse moves, during a drag.
virtual void	DragFinished (DocCoord Pos, ClickModifiers Mods, Spread *pSpread, BOOL Success, BOOL bSolidDrag)
	This is called when a drag operation finishes.
virtual void	RenderDragBlobs (DocRect, Spread *, BOOL bSolidDrag)
	Renders the new version of the path to the window. It makes use of flags in the path to determine which segments of the path need to be rendered.
Static Public Member Functions
static BOOL	Init ()
	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	BuildEditPath ()
	Builds a copy of the path that we can edit, without destroying the original data. Also sets the NeedToRender flags for EOR display.
BOOL	BuildEditPaths ()
	Builds a copy of each path in the selection that we can edit, without destroying the original data. Also sets the NeedToRender flags for EOR display.
BOOL	CopyEditedPathBack ()
	Copies the contents of the edited path back into the original path.
BOOL	CopyEditedPathBack (NodePath *pOrigPath, Path *pEditPath)
	Copies the contents of the edited path back into the original path.
BOOL	CopyNeedToRenderFlags ()
	This function is used to copy the NeedToRender flags from EditPath to OriginalPath. This are then used in optimised region invalidation.
BOOL	CopyNeedToRenderFlags (NodePath *pOrigPath, Path *pEditPath)
	This function is used to copy the NeedToRender flags from EditPath to OriginalPath. This are then used in optimised region invalidation.
void	RecalculatePath (DocCoord Offset, BOOL SnapEnds=FALSE, INT32 SnapIndex=0)
	This goes through the path, moves all the selected coords by the offset and then performs some magic to smooth the rest of the path round the changes if it needs it.
void	RecalculatePaths (Path *pEditPath, DocCoord Offset, BOOL SnapEnds=FALSE, INT32 SnapIndex=0)
	This goes through the path, moves all the selected coords by the offset and then performs some magic to smooth the rest of the path round the changes if it needs it.
void	SnapEndsTogether ()
	Sets the closefigure flag in the last element in the subpath. Also turns off the rotate bit in the points we're snapping together if their smoothing bits are also turned off. This prevents us creating a cusp that has rotate flags set.
void	SnapEndsTogether (Path *pEditPath)
	Sets the closefigure flag in the last element in the subpath. Also turns off the rotate bit in the points we're snapping together if their smoothing bits are also turned off. This prevents us creating a cusp that has rotate flags set.
BOOL	JoinWithOtherPath ()
	Looks at the member variables dealing with snapping to another path and joins the paths together. It will always join the other path to the original path, keeping the original path's attributes intact. NOTE: This routine will alter the OriginalPath member variable if it joins paths, because it has to make a copy of the path for undo purposes.
BOOL	JoinWithOtherPath (NodePath **pOrigPath)
	Looks at the member variables dealing with snapping to another path and joins the paths together. It will always join the other path to the original path, keeping the original path's attributes intact. NOTE: This routine will alter the OriginalPath member variable if it joins paths, because it has to make a copy of the path for undo purposes.
BOOL	FillPathIfEndsSnapped ()
	Will look at the EndSnapped flag and set the IsFilled bit in the OriginalPath Builds undo information. Returns FALSE if it couldn't build the Undo info.
BOOL	FillPathIfEndsSnapped (NodePath *pOrigPath)
	Will look at the EndSnapped flag and set the IsFilled bit in the OriginalPath Builds undo information. Returns FALSE if it couldn't build the Undo info.
virtual void	RenderDraggingBlobs (DocRect, Spread *)
	Call this function to render all the blobs on screen from this operation.
virtual void	RenderDraggingBlobs (Path *pEditPath, Spread *)
	Call this function to render all the blobs on screen from this operation.
void	RenderPathEditBlobs (DocRect Rect, Spread *pSpread)
void	RenderPathEditBlobs (Path *pEditPath, Spread *pSpread)
	Call this function to render all the blobs on screen from this operation.
virtual void	SetStatusLineHelp ()
	Updates the status line message to reflect the current situation.
NodeGroup *	GetGroupParentOfCurve ()
	To determine if the current selection is a blend on a curve.
NodeGroup *	GetGroupParentOfCurve (NodePath *pOrigPath)
	To determine if the current selection is a blend on a curve.
BOOL	InsertChangeBlendStepsAction (NodeBlend *pNodeBlend)
	To adjust the number of steps in a blend on a path as a result of the path being edited (which is why its here rather than in the blend code). First the number of steps is calculated from the new path distance and if different a new action is inserted.
AttrBrushType *	GetAppliedBrush ()
	To get the brush attribute that is applied to the nodepath we are editing.
virtual BOOL	EditBrushAttribute (INT32 FirstIndex, INT32 LastIndex, AttrBrushType *pAttrBrush)
	If we use the shape editor to edit a nodepath with an applied brush attribute and this brush attribute makes use of sampled pressure or time information then the brush needs to resample its data. So here we will insert a few actions to make that happen.
MILLIPOINT	GetLengthOfPathSection (Path *pPath, INT32 FirstIndex, INT32 LastIndex)
	As above, if you want to know the distance between two points on the edit path then this function is for you.
MILLIPOINT	GetDistanceToPathIndex (Path *pPath, INT32 Index)
	As above,.
void	ChangeCursor (Cursor *cursor)
	Changes the mouse pointer to a new shape.
BOOL	CreateCursors ()
	Creates the cursor objects for the path operations.
void	DestroyCursors ()
	Deletes the path operation cursors.
Protected Attributes
Spread *	StartSpread
DocCoord	StartMousePos
DocCoord	LastMousePos
DocCoord	ConstrainPoint
DocCoord	ConstrainPrevPoint
DocCoord	ConstrainNextPoint
NodePath *	OriginalPath
Path	EditPath
List	OriginalPaths
List	EditPaths
List	PathsDragStarted
BOOL	MultiplePaths
BOOL	EndSnapped
BOOL	SnapToAnother
NodePath *	SnapToPath
INT32	SnapToIndex
BOOL	SnapToLineOrCurve
DocCoord	SnapToCoords [4]
Cursor *	pMoveCursor
Cursor *	pCloseCursor
Cursor *	pCrossHairCursor
Cursor *	MyCurrentCursor
INT32	CurrentCursorID
ObjChangePathEdit	EditObjChange
List	ObjChanges
INT32	DragPoint
INT32	UpdatePoint
BOOL	DragStarted

---

Detailed Description

This operation is started by the NodePath when it receives a drag message from one of the tools. It uses it to drag one (or many) of the paths control points around the screen to edit the path. As the control points are dragged about the new version of the path, corosponding to the new blob positions, will be EOR rendered to the window.

Author:

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

Date:

1/7/93

Definition at line 143 of file pathedit.h.

---

Constructor & Destructor Documentation

OpNodePathEditBlob::OpNodePathEditBlob (   )

---

Member Function Documentation

BOOL OpNodePathEditBlob::BuildEditPath (   )  [protected]

Builds a copy of the path that we can edit, without destroying the original data. Also sets the NeedToRender flags for EOR display. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> - later attacked by Peter Date: 17/02/94 Returns: TRUE if it managed to build the path, FALSE if it failed Errors: If it runs out of memory then it will return FALSE Reimplemented in OpNodePathEditControlBlob, and OpReshapeOrAddPoint. Definition at line 2197 of file pathedit.cpp. { // Make a copy of the original path UINT32 NumCoords = OriginalPath->InkPath.GetNumCoords(); if (!EditPath.Initialise(NumCoords, 24)) return FALSE; if (!EditPath.CopyPathDataFrom(&(OriginalPath->InkPath))) return FALSE; // Go though all the coords, with scary amounts of looking back and forwards UINT32 LastEndPoint = 0; // The EndPoint before this one BOOL SetNextEndPoint = FALSE; // TRUE if we want to set the next EndPoint to render BOOL SetNextNextEndPoint = FALSE; // TRUE if we want the one after the next one to render PathFlags* Flags = EditPath.GetFlagArray(); for (UINT32 i=0; i<NumCoords; i++) { // Make all the flags FALSE by default Flags[i].NeedToRender = FALSE; if (Flags[i].IsEndPoint) { // if the endpoint 2 elements back was selected and the last element was smooth // then we need to mark this point for rendering if (SetNextNextEndPoint) { Flags[i].NeedToRender = TRUE; SetNextNextEndPoint = FALSE; } // We have found an Endpoint, do we want to mark this one as renderable if (SetNextEndPoint) { // As the last element was selected, this element needs to render Flags[i].NeedToRender = TRUE; SetNextEndPoint = FALSE; // If the smooth flag is set then the next item needs to render as well if (Flags[i].IsRotate || Flags[i].IsSmooth) SetNextNextEndPoint = TRUE; } // If its selected, then its renderable if (Flags[i].IsSelected) { Flags[i].NeedToRender = TRUE; if (Flags[LastEndPoint].IsRotate || Flags[LastEndPoint].IsSmooth) Flags[LastEndPoint].NeedToRender = TRUE; // Set the flag for the next endpoint SetNextEndPoint = TRUE; } LastEndPoint = i; } } return TRUE; }

BOOL OpNodePathEditBlob::BuildEditPaths (   )  [protected]

Builds a copy of each path in the selection that we can edit, without destroying the original data. Also sets the NeedToRender flags for EOR display. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (based upon Rik/Peter) Date: 17/02/94 Returns: TRUE if it managed to build the paths, FALSE if it failed Errors: If it runs out of memory then it will return FALSE Definition at line 2107 of file pathedit.cpp. { NodeListItem* pCurrent = (NodeListItem*) OriginalPaths.GetHead (); while (pCurrent) { NodePath* pCurrentPath = (NodePath*) (pCurrent->pNode); Path* NewEditPath = new Path (); UINT32 NumCoords = pCurrentPath->InkPath.GetNumCoords(); if (!NewEditPath->Initialise(NumCoords, 24)) return FALSE; if (!NewEditPath->CopyPathDataFrom(&(pCurrentPath->InkPath))) return FALSE; // Go though all the coords, with scary amounts of looking back and forwards UINT32 LastEndPoint = 0; // The EndPoint before this one BOOL SetNextEndPoint = FALSE; // TRUE if we want to set the next EndPoint to render BOOL SetNextNextEndPoint = FALSE; // TRUE if we want the one after the next one to render PathFlags* Flags = NewEditPath->GetFlagArray(); for (UINT32 i=0; i<NumCoords; i++) { // Make all the flags FALSE by default Flags[i].NeedToRender = FALSE; if (Flags[i].IsEndPoint) { // if the endpoint 2 elements back was selected and the last element was smooth // then we need to mark this point for rendering if (SetNextNextEndPoint) { Flags[i].NeedToRender = TRUE; SetNextNextEndPoint = FALSE; } // We have found an Endpoint, do we want to mark this one as renderable if (SetNextEndPoint) { // As the last element was selected, this element needs to render Flags[i].NeedToRender = TRUE; SetNextEndPoint = FALSE; // If the smooth flag is set then the next item needs to render as well if (Flags[i].IsRotate || Flags[i].IsSmooth) SetNextNextEndPoint = TRUE; } // If its selected, then its renderable if (Flags[i].IsSelected) { Flags[i].NeedToRender = TRUE; if (Flags[LastEndPoint].IsRotate || Flags[LastEndPoint].IsSmooth) Flags[LastEndPoint].NeedToRender = TRUE; // Set the flag for the next endpoint SetNextEndPoint = TRUE; } LastEndPoint = i; } } NodeListItem* pInsert = new NodeListItem; pInsert->pNode = (Node*) NewEditPath; EditPaths.AddTail (pInsert);//NewEditPath); pCurrent = (NodeListItem*) OriginalPaths.GetNext (pCurrent); //delete (pInsert); // delete (NewEditPath); // cleanup that is necessary } return (TRUE); }

void OpNodePathEditBlob::ChangeCursor (  Cursor *  cursor  )  [protected]

Changes the mouse pointer to a new shape. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/94 Parameters: Pointer  to the cursor to use now. [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: OpNodePathEditBlob::CreateCursors(), OpNodePathEditBlob::DestroyCursors() Definition at line 4787 of file pathedit.cpp. { if (cursor != MyCurrentCursor) { // only change if this cursor is different from the current cursor if (MyCurrentCursor != NULL) { // If one of our cursors is on the stack then get it off CursorStack::GPop(CurrentCursorID); } MyCurrentCursor = cursor; CurrentCursorID = CursorStack::GPush(cursor); } }

BOOL OpNodePathEditBlob::CopyEditedPathBack (  NodePath *  pOrigPath, Path *  pEditPath )  [protected]

Copies the contents of the edited path back into the original path. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (based upon Will/Peter) Date: 20/4/2000 Returns: TRUE if it worked, FALSE if it failed Definition at line 2441 of file pathedit.cpp. { // Now to do some undo information. To do this, I have to look at each element in the path // and each element in the copy, and see which ones differ. I then have to work out how many // elements that was, and create a path to contain those elements, along with an array of indices // telling me where those elements came from INT32 NumElements = pOrigPath->InkPath.GetNumCoords(); PathVerb* SourceVerbs = pOrigPath->InkPath.GetVerbArray(); DocCoord* SourceCoords = pOrigPath->InkPath.GetCoordArray(); PathFlags* SourceFlags = pOrigPath->InkPath.GetFlagArray(); PathVerb* DestVerbs = pEditPath->GetVerbArray(); DocCoord* DestCoords = pEditPath->GetCoordArray(); PathFlags* DestFlags = pEditPath->GetFlagArray(); INT32 ChangedElements = 0; INT32 i; for (i=0;i<NumElements;i++) { if (SourceVerbs[i] != DestVerbs[i] || SourceCoords[i] != DestCoords[i] || SourceFlags[i] != DestFlags[i] ) ChangedElements++; } // ChangedElements is the number of elements in this path that will change. // We have to create three arrays to contain the changed elements, plus one array // to tell me where the elements should go (the indices) // I also have to create an action object to contain these arrays. I have to create the action // object first because that does all the work of deciding if there's enough memory in the // undo buffer to store the action, and prompting the user accordingly of there isn't if (ChangedElements > 0) { ModifyPathAction* ModAction; ActionCode Act; Act = ModifyPathAction::Init(this, &UndoActions, ChangedElements, (Action**)(&ModAction)); if (Act == AC_FAIL) { FailAndExecute(); End(); return FALSE; } PathVerb* ChangedVerbs=NULL; DocCoord* ChangedCoords=NULL; PathFlags* ChangedFlags=NULL; INT32* ChangedIndices=NULL; // If the function returned AC_NO_RECORD we shouldn't record any undo information in the action // NOTE - during unwind all actions return AC_OK with a NULL ModAction pointer!! if ((Act!=AC_NORECORD) && (ModAction!=NULL)) { // This next bit is a bit hellish. Any one of these four allocations can fail, in which case // we have to tidy up afterwards. Cue a lot of nested ifs and elses. ALLOC_WITH_FAIL(ChangedVerbs,(PathVerb*) CCMalloc(ChangedElements * sizeof(PathVerb)),this); if (ChangedVerbs) { ALLOC_WITH_FAIL(ChangedCoords,(DocCoord*) CCMalloc(ChangedElements * sizeof(DocCoord)),this); if (ChangedCoords) { ALLOC_WITH_FAIL(ChangedFlags,(PathFlags*) CCMalloc(ChangedElements * sizeof(PathFlags)),this); if (ChangedFlags) { ALLOC_WITH_FAIL(ChangedIndices,(INT32*) CCMalloc(ChangedElements * sizeof(INT32)),this); if (!ChangedIndices) { CCFree( ChangedFlags ); CCFree( ChangedCoords ); CCFree( ChangedVerbs); FailAndExecute(); End(); return FALSE; } } else { CCFree( ChangedCoords ); CCFree( ChangedVerbs ); FailAndExecute(); End(); return FALSE; } } else { CCFree( ChangedVerbs); FailAndExecute(); End(); return FALSE; } } // Now to put the undo data into the undo action INT32 index = 0; for (i=0;i<NumElements;i++) { if (SourceVerbs[i] != DestVerbs[i] || SourceCoords[i] != DestCoords[i] || SourceFlags[i] != DestFlags[i] ) { ChangedVerbs[index] = SourceVerbs[i]; ChangedFlags[index] = SourceFlags[i]; ChangedCoords[index] = SourceCoords[i]; ChangedIndices[index] = i; index++; } } // Now we've allocated the arrays, let's tell the action about 'em ModAction->StoreArrays(ChangedVerbs, ChangedFlags, ChangedCoords, ChangedIndices, pOrigPath); } } if (!pOrigPath->InkPath.CopyPathDataFrom(pEditPath)) return FALSE; else return TRUE; }

BOOL OpNodePathEditBlob::CopyEditedPathBack (   )  [protected]

Copies the contents of the edited path back into the original path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/02/94 Returns: TRUE if it worked, FALSE if it failed Definition at line 2269 of file pathedit.cpp. { // Now to do some undo information. To do this, I have to look at each element in the path // and each element in the copy, and see which ones differ. I then have to work out how many // elements that was, and create a path to contain those elements, along with an array of indices // telling me where those elements came from INT32 NumElements = OriginalPath->InkPath.GetNumCoords(); PathVerb* SourceVerbs = OriginalPath->InkPath.GetVerbArray(); DocCoord* SourceCoords = OriginalPath->InkPath.GetCoordArray(); PathFlags* SourceFlags = OriginalPath->InkPath.GetFlagArray(); PathVerb* DestVerbs = EditPath.GetVerbArray(); DocCoord* DestCoords = EditPath.GetCoordArray(); PathFlags* DestFlags = EditPath.GetFlagArray(); // DY now we want to keep track of the indexes of the changed section INT32 ChangedElements = 0; INT32 FirstChanged = -1; INT32 LastChanged = -1; INT32 i; for (i=0;i<NumElements;i++) { if (SourceVerbs[i] != DestVerbs[i] || SourceCoords[i] != DestCoords[i] || SourceFlags[i] != DestFlags[i] ) { ChangedElements++; // if (SourceCoords[i] != DestCoords[i]) { // if we have not yet set the first changed index then set it if (FirstChanged == -1) FirstChanged = i; // always set the last changed index LastChanged = i; } } } // ChangedElements is the number of elements in this path that will change. // We have to create three arrays to contain the changed elements, plus one array // to tell me where the elements should go (the indices) // I also have to create an action object to contain these arrays. I have to create the action // object first because that does all the work of deciding if there's enough memory in the // undo buffer to store the action, and prompting the user accordingly of there isn't if (ChangedElements > 0) { // do the brush editing here // the following block deals with editing path blobs. For some reason I could not get a // sensible value for the distance of the edited path from the changed indexes, however // it works quite nicely by finding the contraining points. if (DragPoint != -1) { // this section only applies for editing blobs (as reshaping has no drag point) FirstChanged = DragPoint; LastChanged = DragPoint; OriginalPath->InkPath.FindPrevEndPoint(&FirstChanged); OriginalPath->InkPath.FindNextEndPoint(&LastChanged); } AttrBrushType* pAttrBrush = GetAppliedBrush(); if (pAttrBrush != NULL) EditBrushAttribute(FirstChanged, LastChanged, pAttrBrush); ModifyPathAction* ModAction; ActionCode Act; Act = ModifyPathAction::Init(this, &UndoActions, ChangedElements, (Action**)(&ModAction)); if (Act == AC_FAIL) { FailAndExecute(); End(); return FALSE; } PathVerb* ChangedVerbs=NULL; DocCoord* ChangedCoords=NULL; PathFlags* ChangedFlags=NULL; INT32* ChangedIndices=NULL; // If the function returned AC_NO_RECORD we shouldn't record any undo information in the action // NOTE - during unwind all actions return AC_OK with a NULL ModAction pointer!! if ((Act!=AC_NORECORD) && (ModAction!=NULL)) { // This next bit is a bit hellish. Any one of these four allocations can fail, in which case // we have to tidy up afterwards. Cue a lot of nested ifs and elses. ALLOC_WITH_FAIL(ChangedVerbs,(PathVerb*) CCMalloc(ChangedElements * sizeof(PathVerb)),this); if (ChangedVerbs) { ALLOC_WITH_FAIL(ChangedCoords,(DocCoord*) CCMalloc(ChangedElements * sizeof(DocCoord)),this); if (ChangedCoords) { ALLOC_WITH_FAIL(ChangedFlags,(PathFlags*) CCMalloc(ChangedElements * sizeof(PathFlags)),this); if (ChangedFlags) { ALLOC_WITH_FAIL(ChangedIndices,(INT32*) CCMalloc(ChangedElements * sizeof(INT32)),this); if (!ChangedIndices) { CCFree( ChangedFlags ); CCFree( ChangedCoords ); CCFree( ChangedVerbs); FailAndExecute(); End(); return FALSE; } } else { CCFree( ChangedCoords ); CCFree( ChangedVerbs ); FailAndExecute(); End(); return FALSE; } } else { CCFree( ChangedVerbs); FailAndExecute(); End(); return FALSE; } } // Now to put the undo data into the undo action INT32 index = 0; for (i=0;i<NumElements;i++) { if (SourceVerbs[i] != DestVerbs[i] || SourceCoords[i] != DestCoords[i] || SourceFlags[i] != DestFlags[i] ) { ChangedVerbs[index] = SourceVerbs[i]; ChangedFlags[index] = SourceFlags[i]; ChangedCoords[index] = SourceCoords[i]; ChangedIndices[index] = i; index++; } } // Now we've allocated the arrays, let's tell the action about 'em ModAction->StoreArrays(ChangedVerbs, ChangedFlags, ChangedCoords, ChangedIndices, OriginalPath); } } if (!OriginalPath->InkPath.CopyPathDataFrom(&EditPath)) return FALSE; else return TRUE; }

BOOL OpNodePathEditBlob::CopyNeedToRenderFlags (  NodePath *  pOrigPath, Path *  pEditPath )  [protected]

This function is used to copy the NeedToRender flags from EditPath to OriginalPath. This are then used in optimised region invalidation. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (based upon Peter) Date: 20/04/95 Parameters: -  [INPUTS] (see  below) [OUTPUTS] Returns: TRUE if the flags have been copied; FALSE if the paths were different lengths Definition at line 2618 of file pathedit.cpp. { const INT32 OrigLength = pOrigPath->InkPath.GetNumCoords(); const INT32 EditLength = pEditPath->GetNumCoords(); if (EditLength != OrigLength) return FALSE; PathFlags* EditFlags = pEditPath->GetFlagArray(); PathFlags* OrigFlags = pOrigPath->InkPath.GetFlagArray(); for (INT32 loop = 0; loop < EditLength; loop ++) { OrigFlags[loop].NeedToRender = EditFlags[loop].NeedToRender; } return TRUE; }

BOOL OpNodePathEditBlob::CopyNeedToRenderFlags (   )  [protected]

This function is used to copy the NeedToRender flags from EditPath to OriginalPath. This are then used in optimised region invalidation. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 10/03/95 Parameters: -  [INPUTS] (see  below) [OUTPUTS] Returns: TRUE if the flags have been copied; FALSE if the paths were different lengths Definition at line 2583 of file pathedit.cpp. { const INT32 OrigLength = OriginalPath->InkPath.GetNumCoords(); const INT32 EditLength = EditPath.GetNumCoords(); if (EditLength != OrigLength) return FALSE; PathFlags* EditFlags = EditPath.GetFlagArray(); PathFlags* OrigFlags = OriginalPath->InkPath.GetFlagArray(); for (INT32 loop = 0; loop < EditLength; loop ++) { OrigFlags[loop].NeedToRender = EditFlags[loop].NeedToRender; } return TRUE; }

BOOL OpNodePathEditBlob::CreateCursors (   )  [protected]

Creates the cursor objects for the path operations. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: FALSE if the cursors wern't created, TRUE if they were. Errors: - See also: OpNodePathEditBlob::DestroyCursors() Definition at line 4816 of file pathedit.cpp. { if (pMoveCursor == NULL) { // If already created then don't create a new set. MyCurrentCursor = NULL; pMoveCursor = new Cursor(TOOLID_BEZTOOL, _R(IDC_MOVEBEZIERCURSOR)); pCloseCursor = new Cursor(TOOLID_BEZTOOL, _R(IDC_CLOSEPATHCURSOR)); pCrossHairCursor = new Cursor(TOOLID_BEZTOOL, _R(IDC_CROSSHAIRCURSOR)); // See if any of them failed if ((!pMoveCursor || !pMoveCursor->IsValid()) || (!pCloseCursor || !pCloseCursor->IsValid()) || (!pCrossHairCursor || !pCrossHairCursor->IsValid())) { // They did fail, so clean up TRACE( _T("Cursors not created in OpNodePathEditBlob::CreateCursors\n")); delete pMoveCursor; delete pCloseCursor; delete pCrossHairCursor; pMoveCursor = NULL; return FALSE; } } return TRUE; }

void OpNodePathEditBlob::DestroyCursors (   )  [protected]

Deletes the path operation cursors. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: OpNodePathEditBlob::CreateCursors() Definition at line 4858 of file pathedit.cpp. { if (pMoveCursor != NULL) { // If one is NULL then the rest don't exist if (MyCurrentCursor != NULL) { CursorStack::GPop(CurrentCursorID); } delete pMoveCursor; delete pCloseCursor; delete pCrossHairCursor; pMoveCursor = NULL; MyCurrentCursor = NULL; CurrentCursorID = 0; } }

void OpNodePathEditBlob::DoStartDragEdit (  NodePath *  OrigPath, DocCoord  Anchor, Spread *  pSpread )

This is called to start a drag operation on an endpoint on a path. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> - latterly Peter Date: 5/7/93 Parameters: OrigPath  - Pointer to the path we are about to edit [INPUTS] Anchor - The position of the mouse at the start of the Drag pSpread - The spread that the path is on Definition at line 227 of file pathedit.cpp. { BOOL Success = TRUE; // We had better take a note of the starting point of the drag LastMousePos = Anchor; StartMousePos = Anchor; StartSpread = pSpread; SelRange* theSelection = GetApplication ()->FindSelection (); BOOL selectionContainsMoulds = FALSE; if (theSelection) { // we need to do some special processing to handle moulds .... Node* pCurrentNode = (Node*) theSelection->FindFirst (); while (pCurrentNode) { if (IS_A (pCurrentNode, NodeMould)) { selectionContainsMoulds = TRUE; pCurrentNode = NULL; } else { pCurrentNode = (Node*) theSelection->FindNext (pCurrentNode); } } } if (!selectionContainsMoulds) { BevelTools::BuildListOfSelectedNodes(&OriginalPaths, CC_RUNTIME_CLASS(NodePath)); } else { // now go and get those moulds baby ! BevelTools::BuildListOfSelectedNodes(&OriginalPaths, CC_RUNTIME_CLASS(NodeMouldPath)); // now, we also have to rescan the selection (again!) BUT this time without // the moulds Node* pCurrentNode = (Node*) theSelection->FindFirst (); while (pCurrentNode) { if (IS_A (pCurrentNode, NodeMould)) { pCurrentNode = (Node*) theSelection->FindNext (pCurrentNode); } else { if (IS_A (pCurrentNode, NodePath)) { NodeListItem* pInsert = new NodeListItem (); if (pInsert) // and insert into the paths list .... { pInsert->pNode = pCurrentNode; OriginalPaths.AddHead (pInsert); } } pCurrentNode = (Node*) theSelection->FindNext (pCurrentNode); } } } if (OriginalPaths.GetCount () == 1) //if (TRUE) { MultiplePaths = FALSE; OriginalPath = OrigPath; // Now calculate DragPoint and UpdatePoint if (Success) { PathFlags* Flags = OriginalPath->InkPath.GetFlagArray(); PathVerb* Verbs = OriginalPath->InkPath.GetVerbArray(); INT32 NumCoords = OriginalPath->InkPath.GetNumCoords(); for (INT32 i=0;i<NumCoords;i++) { if (Flags[i].IsEndPoint && Flags[i].IsSelected && !(OriginalPath->InkPath.IsSubPathClosed(i) && (Verbs[i] == PT_MOVETO)) ) { // If you are dragging a closepoint then you are actually dragging two points // but we need to update the line tool as the user thinks they are dragging one. // If we are on the opening moveto then just skip the tests. if (DragPoint != -1) { UpdatePoint = -1; DragPoint = -1; break; } else { UpdatePoint = i; DragPoint = i; } } } // On exit from that loop, DragPoint = -1 if there are multiple selected endpoints, // otherwise DragPoint is the index to the selected endpoint. UpdatePoint is the // index of the point displaied in the Line tool } // Set the constrain point if (DragPoint != -1) { ConstrainPoint = OriginalPath->InkPath.GetCoordArray()[DragPoint]; // Get the previous endpoint INT32 OtherEndpoint = DragPoint; if (OriginalPath->InkPath.FindPrevEndPoint(&OtherEndpoint)) ConstrainPrevPoint = OriginalPath->InkPath.GetCoordArray()[OtherEndpoint]; else ConstrainPrevPoint = ConstrainPoint; // Get the next endpoint OtherEndpoint = DragPoint; if (OriginalPath->InkPath.FindNextEndPoint(&OtherEndpoint)) ConstrainNextPoint = OriginalPath->InkPath.GetCoordArray()[OtherEndpoint]; else ConstrainNextPoint = ConstrainPoint; } else { ConstrainPoint = Anchor; ConstrainPrevPoint = Anchor; ConstrainNextPoint = Anchor; } // We also need to make a version of the path that we can change Success = BuildEditPath(); // Create and send a change message about this path edit // This one is handled by moulds in their OnChildChange() function if (Success) Success = (EditObjChange.ObjChangeStarting(OrigPath,this,&EditPath,StartSpread,TRUE) == CC_OK); // Create and display the cursors for this operation if (Success) Success = CreateCursors(); if (Success) ChangeCursor(pCrossHairCursor); // // Render the bits of the path that are different DocRect EditPathBBox = EditPath.GetBoundingRect(); // if (Success) // RenderPathEditBlobs(EditPathBBox, pSpread); // Tell the Dragging system that we need drags to happen if (Success) Success = StartDrag(DRAGTYPE_AUTOSCROLL, &EditPathBBox, &LastMousePos); if (!Success) { InformError(); FailAndExecute(); End(); } } else { // lets try and keep things the same for the blobs parent as in the one selection case // BUT lets also try and do our extra stuff .... I expect time MUCK UPS to occur !!!! MultiplePaths = TRUE; OriginalPath = OrigPath; // we need to make OrigPath the first one in our linked list .... NodeListItem* pCurrentOrig = (NodeListItem*) OriginalPaths.GetHead (); while (pCurrentOrig) { NodePath* pOrigPath = (NodePath*) (pCurrentOrig->pNode); if (pOrigPath == OrigPath) { NodeListItem* newHead = (NodeListItem*) OriginalPaths.RemoveItem (pCurrentOrig); OriginalPaths.AddHead (newHead); pCurrentOrig = NULL; } else { pCurrentOrig = (NodeListItem*) OriginalPaths.GetNext (pCurrentOrig); } } // Now calculate DragPoint and UpdatePoint if (Success) { NodeListItem* pCurrentOrig = (NodeListItem*) OriginalPaths.GetHead (); // CGS: while loop taken out since we can only be 'drag sensitive' to the point // that is actually being dragged //while (pCurrentOrig) { NodePath* pOrigPath = (NodePath*) (pCurrentOrig->pNode); PathFlags* Flags = pOrigPath->InkPath.GetFlagArray(); PathVerb* Verbs = pOrigPath->InkPath.GetVerbArray(); INT32 NumCoords = pOrigPath->InkPath.GetNumCoords(); for (INT32 i=0;i<NumCoords;i++) { if (Flags[i].IsEndPoint && Flags[i].IsSelected && !(pOrigPath->InkPath.IsSubPathClosed(i) && (Verbs[i] == PT_MOVETO)) ) { // If you are dragging a closepoint then you are actually dragging two points // but we need to update the line tool as the user thinks they are dragging one. // If we are on the opening moveto then just skip the tests. if (DragPoint != -1) { UpdatePoint = -1; DragPoint = -1; break; } else { UpdatePoint = i; DragPoint = i; } } } // pCurrentOrig = (NodeListItem*) OriginalPaths.GetNext (pCurrentOrig); } // On exit from that loop, DragPoint = -1 if there are multiple selected endpoints, // otherwise DragPoint is the index to the selected endpoint. UpdatePoint is the // index of the point displaied in the Line tool } // Set the constrain point - do this only for the path that was clicked on