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 // Any guesses as to why? // Answer: cause its the one that is being dragged! if (DragPoint != -1) { NodeListItem* pCurrentOrig = (NodeListItem*) OriginalPaths.GetHead (); NodePath* pOrigPath = (NodePath*) (pCurrentOrig->pNode); ConstrainPoint = pOrigPath->InkPath.GetCoordArray()[DragPoint]; // Get the previous endpoint INT32 OtherEndpoint = DragPoint; if (pOrigPath->InkPath.FindPrevEndPoint(&OtherEndpoint)) ConstrainPrevPoint = pOrigPath->InkPath.GetCoordArray()[OtherEndpoint]; else ConstrainPrevPoint = ConstrainPoint; // Get the next endpoint OtherEndpoint = DragPoint; if (pOrigPath->InkPath.FindNextEndPoint(&OtherEndpoint)) ConstrainNextPoint = pOrigPath->InkPath.GetCoordArray()[OtherEndpoint]; else ConstrainNextPoint = ConstrainPoint; } else { ConstrainPoint = Anchor; ConstrainPrevPoint = Anchor; ConstrainNextPoint = Anchor; } // We also need to make versions of the paths that we can change Success = BuildEditPaths(); // Create and send a change message about this path edit // This one is handled by moulds in their OnChildChange() function if (Success) { NodeListItem* pCurrentOrig = (NodeListItem*) OriginalPaths.GetHead (); NodeListItem* pCurrentEdit = (NodeListItem*) EditPaths.GetHead (); while ((pCurrentOrig) && (pCurrentEdit)) { NodePath* pOrigPath = (NodePath*) (pCurrentOrig->pNode); Path* pEditPath = (Path*) (pCurrentEdit->pNode); ObjChangePathEdit* NewEditObjChange = new ObjChangePathEdit; Success = (NewEditObjChange->ObjChangeStarting(pOrigPath,this,pEditPath,StartSpread,TRUE) == CC_OK); NodeListItem* pInsert = new NodeListItem; pInsert->pNode = (Node*) NewEditObjChange; ObjChanges.AddTail (pInsert); BOOL* NewDragStartVal = new BOOL; *NewDragStartVal = FALSE; NodeListItem* pInsert2 = new NodeListItem; pInsert2->pNode = (Node*) NewDragStartVal; PathsDragStarted.AddTail (pInsert2); if (Success) { pCurrentOrig = (NodeListItem*) OriginalPaths.GetNext (pCurrentOrig); pCurrentEdit = (NodeListItem*) EditPaths.GetNext (pCurrentEdit); } else { pCurrentOrig = NULL; pCurrentEdit = NULL; } //delete (NewEditObjChange); // delete (NewDragStartVal); } } // Create and display the cursors for this operation (only once - obviously) if (Success) Success = CreateCursors(); if (Success) ChangeCursor(pCrossHairCursor); // // Render the bits of the path that are different DocRect EditPathBBox;// = EditPath.GetBoundingRect(); SelRange* Selected = GetApplication()->FindSelection(); EditPathBBox = Selected->GetBlobBoundingRect (); // 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(); } } }

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

This is called when a drag operation finishes. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/93 Parameters: PointerPos  - The position of the mouse at the end of the drag [INPUTS] ClickMods - the key modifiers being pressed 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. Reimplemented in OpNodePathAddEndpoint, OpReshapeOrAddPoint, and OpNewPath. Definition at line 1169 of file pathedit.cpp. { if (!MultiplePaths) { if (DragStarted) RenderDraggingBlobs( EditPath.GetBoundingRect(), StartSpread ); DestroyCursors(); EndDrag(); BeginSlowJob(); ChangeCode Chge; BOOL NotFailed = Success; // DY, if we are editing a brushed nodepath then we need a couple of extra actions AttrBrushType* pAttrBrush = GetAppliedBrush(); if (NotFailed) { if (!DragStarted) { INT32 i; if (OriginalPath->InkPath.FindNearestPoint( PointerPos, POINTFLAG_ENDPOINTS | POINTFLAG_CONTROLPOINTS | POINTFLAG_ENDSFIRST, &i) ) { // Deselect all but the clicked endpoint OriginalPath->InkPath.RenderPathSelectedControlBlobs(StartSpread); OriginalPath->InkPath.ClearSubSelection(); PathFlags* pFlags = OriginalPath->InkPath.GetFlagArray(); pFlags[i].IsSelected = TRUE; OriginalPath->InkPath.EnsureSelection(TRUE); OriginalPath->InkPath.RenderPathSelectedControlBlobs(StartSpread); // Send a sel-changed message so tools update (hello jason 8-) GetApplication()->FindSelection()->Update(); // Kill the op so we dont appear in the undo history FailAndExecute(); End(); return; } } else { NotFailed = DoStartSelOp(TRUE,TRUE); // Create and send a change message about this path edit if (NotFailed) { ObjChangeFlags cFlags; cFlags.TransformNode = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,OriginalPath,this); NotFailed = OriginalPath->AllowOp(&ObjChange, TRUE); } // // Store the paths sub-selection state // if (NotFailed) // NotFailed = (StorePathSubSelStateAction::DoRecord(this, &UndoActions, &OriginalPath->InkPath) != AC_FAIL); // Check we are dealing with a node path. If not, we shouldn't optimise the redraw. // Really we should ask the node whether it can cope with optimised redraw. This means // whether its correct simply to redraw the changed rectangular section around the moved // coordinate. For envelope and perspective moulds whose shapes are govened by derived // path objects its not correct to redraw optimally as this can result in sections of the // object being left undrawn when the whole surface / contents have changed. BOOL OptimiseRedraw = CopyNeedToRenderFlags() && !(EndSnapped || SnapToAnother); if (!IS_A(OriginalPath,NodePath)) OptimiseRedraw = FALSE; // if we are editing a brush we don't want to optimise either, as it redraws incorrectly if (pAttrBrush != NULL) OptimiseRedraw = FALSE; // We had better copy the path back over the original and re-calc the bounding box // Force a re-draw of the place where the path used to be if (NotFailed) NotFailed = RecalcBoundsAction::DoRecalc(this, &UndoActions, OriginalPath, OptimiseRedraw) != AC_FAIL; //if we are editing a brushed nodepath we need to have this here for the undo to work if (pAttrBrush != NULL && pAttrBrush->IsTimeStamping() && NotFailed) { UpdateBrushAction* pAction; NotFailed = (UpdateBrushAction::Init(this, &UndoActions, OriginalPath, &pAction) != AC_FAIL); } // If the EndSnapped flag is set, we have to set the PT_CLOSEFIGURE flag in the last // element of the copied path if (NotFailed && EndSnapped) SnapEndsTogether(); // Go and copy the edited path back over the original path if (NotFailed) NotFailed = CopyEditedPathBack(); // If the ends snapped, set the filled bit on the path if (NotFailed) NotFailed = FillPathIfEndsSnapped(); if (NotFailed) NotFailed = JoinWithOtherPath(); if (NotFailed) { // Recalculate the path's bounding box OriginalPath->InvalidateBoundingRect(); SelRange *Sel = GetApplication()->FindSelection(); Sel->UpdateBounds(); // Expand the pasteboard as necessary to include the new object bounds DocRect NewBounds = Sel->GetBoundingRect(TRUE); ERROR3IF(pSpread == NULL, "Unexpectedly NULL spread pointer"); pSpread->ExpandPasteboardToInclude(NewBounds); // Force a redraw of the place where the path is now. NotFailed = RecordBoundsAction::DoRecord(this, &UndoActions, OriginalPath, OptimiseRedraw) != AC_FAIL; } } } // DY 9/99 Check to see if we are editing a blend on a curve, if so we may wish to // change the number of steps in the blend (making use of the path distance). NodeGroup* pParent = GetGroupParentOfCurve(); if (pParent != NULL) { if (pParent->IS_KIND_OF(NodeBlend)) { if (NotFailed) InsertChangeBlendStepsAction((NodeBlend*)pParent); } } // Inform all the parents of this node that it has been changed. if (NotFailed) { ObjChangeFlags ChgeFlags; EditObjChange.Define(OBJCHANGE_FINISHED,ChgeFlags,OriginalPath,this,&EditPath,StartSpread); NotFailed = UpdateChangedNodes(&EditObjChange); } else { if (EditObjChange.ChangeMask.Finished) Chge=EditObjChange.ObjChangeFailed(OriginalPath,this,&EditPath,StartSpread,TRUE); } if (!NotFailed) FailAndExecute(); OriginalPaths.DeleteAll (); GetApplication()->UpdateSelection(); End(); } else { NodeListItem* pCurrentOrig = (NodeListItem*) OriginalPaths.GetHead (); NodeListItem* pCurrentEdit = (NodeListItem*) EditPaths.GetHead (); NodeListItem* pCurrentChange = (NodeListItem*) ObjChanges.GetHead (); NodeListItem* pCurrentDragS = (NodeListItem*) PathsDragStarted.GetHead (); DocCoord Offset; DestroyCursors(); EndDrag(); BeginSlowJob(); ChangeCode Chge; BOOL NotFailed = Success; // DY, if we are editing a brushed nodepath then we need a couple of extra actions AttrBrushType* pAttrBrush = GetAppliedBrush(); if (NotFailed) NotFailed = DoStartSelOp(TRUE,TRUE); while ((pCurrentOrig) && (pCurrentEdit) && (pCurrentChange) && (pCurrentDragS)) { NodePath* pOrigPath = (NodePath*) (pCurrentOrig->pNode); Path* pEditPath = (Path*) (pCurrentEdit->pNode); // ObjChangePathEdit* pObjChange = (ObjChangePathEdit*) (pCurrentChange->pNode); BOOL* pDragStarted = (BOOL*) (pCurrentDragS->pNode); if (*pDragStarted == TRUE) { RenderDraggingBlobs( pEditPath/*EditPath.GetBoundingRect()*/, StartSpread ); } if (NotFailed) { if (*pDragStarted == FALSE) { INT32 i; if (pOrigPath->InkPath.FindNearestPoint(PointerPos, POINTFLAG_ENDPOINTS | POINTFLAG_CONTROLPOINTS | POINTFLAG_ENDSFIRST, &i) ) { // Deselect all but the clicked endpoint pOrigPath->InkPath.RenderPathSelectedControlBlobs(StartSpread); pOrigPath->InkPath.ClearSubSelection(); PathFlags* pFlags = pOrigPath->InkPath.GetFlagArray(); pFlags[i].IsSelected = TRUE; pOrigPath->InkPath.EnsureSelection(TRUE); pOrigPath->InkPath.RenderPathSelectedControlBlobs(StartSpread); // Send a sel-changed message so tools update (hello jason 8-) GetApplication()->FindSelection()->Update(); // Kill the op so we dont appear in the undo history FailAndExecute(); End(); return; } } else { //NotFailed = DoStartSelOp(TRUE,TRUE); // Create and send a change message about this path edit if (NotFailed) { ObjChangeFlags cFlags; cFlags.TransformNode = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,pOrigPath,this); NotFailed = pOrigPath->AllowOp(&ObjChange, TRUE); } // // Store the paths sub-selection state // if (NotFailed) // NotFailed = (StorePathSubSelStateAction::DoRecord(this, &UndoActions, &OriginalPath->InkPath) != AC_FAIL); // Check we are dealing with a node path. If not, we shouldn't optimise the redraw. // Really we should ask the node whether it can cope with optimised redraw. This means // whether its correct simply to redraw the changed rectangular section around the moved // coordinate. For envelope and perspective moulds whose shapes are govened by derived // path objects its not correct to redraw optimally as this can result in sections of the // object being left undrawn when the whole surface / contents have changed. BOOL OptimiseRedraw = CopyNeedToRenderFlags(pOrigPath, pEditPath) && !(EndSnapped || SnapToAnother); if (!IS_A(pOrigPath,NodePath)) OptimiseRedraw = FALSE; // if we are editing a brush we don't want to optimise either, as it redraws incorrectly if (pAttrBrush != NULL) OptimiseRedraw = FALSE; // We had better copy the path back over the original and re-calc the bounding box // Force a re-draw of the place where the path used to be if (NotFailed) NotFailed = RecalcBoundsAction::DoRecalc(this, &UndoActions, pOrigPath, OptimiseRedraw) != AC_FAIL; //if we are editing a brushed nodepath we need to have this here for the undo to work if (pAttrBrush != NULL && pAttrBrush->IsTimeStamping() && NotFailed) { UpdateBrushAction* pAction; NotFailed = (UpdateBrushAction::Init(this, &UndoActions, pOrigPath, &pAction) != AC_FAIL); } if (pCurrentOrig == (NodeListItem*) OriginalPaths.GetHead ()) { // If the EndSnapped flag is set, we have to set the PT_CLOSEFIGURE flag in the last // element of the copied path if (NotFailed && EndSnapped) { SnapEndsTogether (pEditPath); } } // Go and copy the edited path back over the original path if (NotFailed) NotFailed = CopyEditedPathBack(pOrigPath, pEditPath); if (pCurrentOrig == (NodeListItem*) OriginalPaths.GetHead ()) { // If the ends snapped, set the filled bit on the path if (NotFailed) NotFailed = FillPathIfEndsSnapped(pOrigPath); } // CGS: BUT, we need to delay the snapping of a control point to another // paths until here. These is because the path that we are snapping to // could have also of been dragged; and it is NOT guaranteed to have been // updated until now .... BOOL useHeadPath = FALSE; NodePath* pHeadPath = NULL; NodePath** hHeadPath = NULL; if (pOrigPath == SnapToPath) { if (NotFailed) { NodeListItem* pHeadOrig = (NodeListItem*) OriginalPaths.GetHead (); /*NodePath**/ pHeadPath = (NodePath*) (pHeadOrig->pNode); hHeadPath = &pHeadPath; NotFailed = JoinWithOtherPath(hHeadPath); if (NotFailed) { useHeadPath = TRUE; } } } if (NotFailed) { // Recalculate the path's bounding box pOrigPath->InvalidateBoundingRect(); SelRange *Sel = GetApplication()->FindSelection(); Sel->UpdateBounds(); // Expand the pasteboard as necessary to include the new object bounds DocRect NewBounds = Sel->GetBoundingRect(); ERROR3IF(pSpread == NULL, "Unexpectedly NULL spread pointer"); pSpread->ExpandPasteboardToInclude(NewBounds); if (!useHeadPath) { // Force a redraw of the place where the path is now. NotFailed = RecordBoundsAction::DoRecord(this, &UndoActions, pOrigPath, OptimiseRedraw) != AC_FAIL; } else { //NodeListItem* pHeadOrig = (NodeListItem*) OriginalPaths.GetHead (); //NodePath* pHeadPath = (NodePath*) (pHeadOrig->pNode); // Force a redraw of the place where the path is now. NotFailed = RecordBoundsAction::DoRecord(this, &UndoActions, (*hHeadPath), OptimiseRedraw) != AC_FAIL; } } } } // DY 9/99 Check to see if we are editing a blend on a curve, if so we may wish to // change the number of steps in the blend (making use of the path distance). NodeGroup* pParent = GetGroupParentOfCurve(pOrigPath); if (pParent != NULL) { if (pParent->IS_KIND_OF(NodeBlend)) { if (NotFailed) InsertChangeBlendStepsAction((NodeBlend*)pParent); } } // Inform all the parents of this node that it has been changed. if (NotFailed) { ObjChangeFlags ChgeFlags; EditObjChange.Define(OBJCHANGE_FINISHED,ChgeFlags,pOrigPath,this,pEditPath,StartSpread); NotFailed = UpdateChangedNodes(&EditObjChange); } else { if (EditObjChange.ChangeMask.Finished) Chge=EditObjChange.ObjChangeFailed(pOrigPath,this,pEditPath,StartSpread,TRUE); } pCurrentOrig = (NodeListItem*) OriginalPaths.GetNext (pCurrentOrig); pCurrentEdit = (NodeListItem*) EditPaths.GetNext (pCurrentEdit); pCurrentChange = (NodeListItem*) ObjChanges.GetNext (pCurrentChange); pCurrentDragS = (NodeListItem*) PathsDragStarted.GetNext (pCurrentDragS); } if (!NotFailed) FailAndExecute(); GetApplication()->UpdateSelection(); // now we need to handle destruction ourselves .... // pCurrentOrig = (NodeListItem*) OriginalPaths.GetHead (); pCurrentEdit = (NodeListItem*) EditPaths.GetHead (); pCurrentChange = (NodeListItem*) ObjChanges.GetHead (); pCurrentDragS = (NodeListItem*) PathsDragStarted.GetHead (); while (/*(pCurrentOrig) &&*/ (pCurrentEdit) && (pCurrentChange) && (pCurrentDragS)) { // NodePath* pOrigPath = (NodePath*) (pCurrentOrig->pNode); Path* pEditPath = (Path*) (pCurrentEdit->pNode); ObjChangePathEdit* pObjChange = (ObjChangePathEdit*) (pCurrentChange->pNode); BOOL* pDragStarted = (BOOL*) (pCurrentDragS->pNode); // delete (pCurrentOrig->pNode); delete (pEditPath); delete (pObjChange); delete (pDragStarted); // pCurrentOrig = (NodeListItem*) OriginalPaths.GetNext (pCurrentOrig); pCurrentEdit = (NodeListItem*) EditPaths.GetNext (pCurrentEdit); pCurrentChange = (NodeListItem*) ObjChanges.GetNext (pCurrentChange); pCurrentDragS = (NodeListItem*) PathsDragStarted.GetNext (pCurrentDragS); } OriginalPaths.DeleteAll (); EditPaths.DeleteAll (); ObjChanges.DeleteAll (); PathsDragStarted.DeleteAll (); End(); } }

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

This is called every time the mouse moves, during a drag. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/93 Parameters: PointerPos  - The current position of the mouse in Doc Coords [INPUTS] ClickMods - Which key modifiers are being pressed See also: ClickModifiers Reimplemented from Operation. Reimplemented in OpNodePathEditControlBlob, and OpReshapeOrAddPoint. Definition at line 602 of file pathedit.cpp. { if (!MultiplePaths) { // If drag has moved onto a different spread, convert the coord to be relative to the // original spread. if (pSpread != StartSpread) PointerPos = MakeRelativeToSpread(StartSpread, pSpread, PointerPos); Path TempPath; // inform the parent a change is happening if (EditObjChange.ChangeMask.EorBlobs) { ChangeCode Chge = EditObjChange.RenderCurrentBlobs(OriginalPath,this,&EditPath,StartSpread,TRUE); if (Chge!=CC_OK) return; // Create a local copy of the edit path if (!TempPath.Initialise(EditPath.GetNumCoords(), 12)) return; TempPath.CopyPathDataFrom(&EditPath); } // Rub out the old EORed version of the path if (DragStarted) RenderPathEditBlobs( EditPath.GetBoundingRect(), StartSpread ); else DragStarted = TRUE; // Here is where we do all the snapping to grids and endpoints // and constrain. First we check for snapping to line ends, then // we check constrain, then we check grid snapping EndSnapped = FALSE; // TRUE if this point snaps to the other end SnapToAnother = FALSE; // TRUE if this point snaps to another line end SnapToLineOrCurve = FALSE; // No snapped other line // We might be snapping to an endpoint if the point we're dragging around is either // a moveto, or is the last point in the subpath. We will also only snap if there is // only one point selected on the path DocRect PointerBlobRect; GetApplication()->GetBlobManager()->GetBlobRect(PointerPos,&PointerBlobRect); DocCoord* Coords = EditPath.GetCoordArray(); // PathFlags* Flags = EditPath.GetFlagArray(); PathVerb* Verbs = EditPath.GetVerbArray(); INT32 NumCoords = EditPath.GetNumCoords(); INT32 i; if (DragPoint != -1) { // Look to see if the selected point is a real endpoint if (Verbs[DragPoint] == PT_MOVETO) { // This is the start element of the path i = DragPoint; if (!EditPath.IsSubPathClosed(i)) { INT32 NextEndpoint = i; if (EditPath.FindNextEndPoint(&NextEndpoint)) { EditPath.FindEndElOfSubPath(&i); // i indexes to the end element // If this sub-path is one element long then closing it is not allowed if ((i != NextEndpoint) && PointerBlobRect.ContainsCoord(Coords[i])) { PointerPos.x = Coords[i].x + LastMousePos.x - Coords[DragPoint].x; PointerPos.y = Coords[i].y + LastMousePos.y - Coords[DragPoint].y; EndSnapped = TRUE; } } } } else if (DragPoint+1 == NumCoords || Verbs[DragPoint+1] == PT_MOVETO) { // This is the last element in the sub-path i = DragPoint; if (!EditPath.IsSubPathClosed(i)) { INT32 PrevEndpoint = i; if (EditPath.FindPrevEndPoint(&PrevEndpoint)) { EditPath.FindStartOfSubPath(&i); // i is the index of the start of the sub-path // If this sub-path is one element long then closing it is not allowed if ((i != PrevEndpoint) && PointerBlobRect.ContainsCoord(Coords[i])) { PointerPos.x = Coords[i].x + LastMousePos.x - Coords[DragPoint].x; PointerPos.y = Coords[i].y + LastMousePos.y - Coords[DragPoint].y; EndSnapped = TRUE; } } } } } // That detects snapping to the opposite endpoint, but what about snapping to another // endpoint altogether? Time to check for that eventuality if (!EndSnapped && DragPoint != -1 && (Verbs[DragPoint] == PT_MOVETO || DragPoint+1 == NumCoords || Verbs[DragPoint+1] == PT_MOVETO) ) { // Get a snapshot of the selection SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); INT32 SubIndex,SubEnd; while (pNode) { if ((pNode->FindParentSpread() == StartSpread) && (pNode->GetRuntimeClass() == CC_RUNTIME_CLASS(NodePath)) /*&& (pNode != OriginalPath)*/ ) { Path* ThisPath = &(((NodePath*)pNode)->InkPath); INT32 ThisNum = ThisPath->GetNumCoords(); SubIndex = 0; SubEnd = 0; while (SubIndex<ThisNum) { DocCoord tempStart,tempEnd; ThisPath->SetPathPosition(SubIndex); // Set the path's internal pos index if (ThisPath->GetSubPathEnds(&tempStart, &tempEnd)) { SubEnd = ThisPath->GetPathPosition(); // Now SubIndex is the index of the first, and SubEnd is the index // of the last element (N.B. might be a curveto, in which case add 2) if (ThisPath->GetVerb() == PT_BEZIERTO) SubEnd+=2; BOOL ClosedPath = (ThisPath->GetVerbArray()[SubEnd] & PT_CLOSEFIGURE) ; // Now compare start and end with pointer position, but not if this // subpath is the currently dragging subpath if ( !ClosedPath && ( (pNode != OriginalPath) || ((pNode == OriginalPath) && (DragPoint != SubIndex) && (DragPoint != SubEnd)) ) ) { if (PointerBlobRect.ContainsCoord(tempStart)) { break; } if (PointerBlobRect.ContainsCoord(tempEnd)) { SubIndex = SubEnd; break; } } } else { SubEnd = ThisPath->GetPathPosition(); } SubIndex = SubEnd+1; // Points at start of next subpath // or top of whole path } // if SubIndex < ThisNum we must have found a matching coord // so that's what we'll snap to if (SubIndex < ThisNum) break; // Exit the outer while condition } pNode = Selected->FindNext(pNode); } // At this point, if pNode == NULL we haven't snapped to anything // otherwise pNode is the path we've snapped to, and SubIndex is the index // of the point we've snapped to if (pNode) { // if the snap to path is the path being edited check that it has the same number of points! if (((NodePath*)pNode == OriginalPath) && (OriginalPath->InkPath.GetNumCoords() != EditPath.GetNumCoords())) { // PATRACE( _T("Attempted to join an edited path!\n")); // The problem is that if the OriginalPath has been edited by adding an endpoint then // SnapToIndex will be wrong as it counted along the original path, not the edited one.... } else { SnapToAnother = TRUE; SnapToPath = (NodePath*)pNode; SnapToIndex = SubIndex; SnapToPath->InkPath.SetPathPosition(SnapToIndex); PointerPos.x = SnapToPath->InkPath.GetCoord().x + LastMousePos.x - Coords[DragPoint].x; PointerPos.y = SnapToPath->InkPath.GetCoord().y + LastMousePos.y - Coords[DragPoint].y; } } } // We don't allow closed paths consiting of two straight segments if (EndSnapped && NumCoords < 4) EndSnapped = FALSE; if ((EndSnapped || SnapToAnother) && (pMoveCursor != NULL)) ChangeCursor(pCloseCursor); else ChangeCursor(pCrossHairCursor); // Now constrain the mouse point ERROR3IF(ConstrainPoint == DocCoord(-1,-1),"ConstrainPoint wasn't set"); ERROR3IF(ConstrainPrevPoint == DocCoord(-1,-1),"ConstrainPrevPoint wasn't set"); ERROR3IF(ConstrainNextPoint == DocCoord(-1,-1),"ConstrainNextPoint wasn't set"); if (!EndSnapped && ClickMods.Constrain) { if (ClickMods.Adjust) { if (ClickMods.Alternative1 || ClickMods.Alternative2) DocView::ConstrainToAngle(ConstrainNextPoint, &PointerPos); else DocView::ConstrainToAngle(ConstrainPrevPoint, &PointerPos); } else DocView::ConstrainToAngle(ConstrainPoint, &PointerPos); } // Only snap to grid if we didn't snap to the end of a path if (!EndSnapped) DocView::SnapCurrent(StartSpread,&PointerPos); // This is the bit where we go off and re-calculate the paths position, // based on how much the mouse has moved DocCoord Offset; Offset.x = PointerPos.x - LastMousePos.x; Offset.y = PointerPos.y - LastMousePos.y; RecalculatePath(Offset, EndSnapped, DragPoint); if (EditObjChange.ChangeMask.EorBlobs) { ChangeCode Chge = EditObjChange.RenderChangedBlobs(OriginalPath,this,&EditPath,StartSpread,TRUE); if (Chge!=CC_OK) { // replace the old edit path EditPath.CopyPathDataFrom(&TempPath); RenderPathEditBlobs( EditPath.GetBoundingRect(), StartSpread ); return; } } // Update the Last Mouse Position LastMousePos = PointerPos; // Draw in the new version of the path RenderPathEditBlobs( EditPath.GetBoundingRect(), StartSpread ); // If there is just one selected point being dragged then we should show // its new position in the line tool infobar. if (UpdatePoint != -1) BROADCAST_TO_ALL(PathEditedMsg(&EditPath, pSpread, UpdatePoint)); SetStatusLineHelp(); } else { NodeListItem* pCurrentOrig = (NodeListItem*) OriginalPaths.GetHead (); NodeListItem* pCurrentEdit = (NodeListItem*) EditPaths.GetHead (); NodeListItem* pCurrentChange = (NodeListItem*) ObjChanges.GetHead (); NodeListItem* pCurrentDragS = (NodeListItem*) PathsDragStarted.GetHead (); DocCoord Offset(0,0); while ((pCurrentOrig) && (pCurrentEdit) && (pCurrentChange) && (pCurrentDragS)) { NodePath* pOrigPath = (NodePath*) (pCurrentOrig->pNode); Path* pEditPath = (Path*) (pCurrentEdit->pNode); ObjChangePathEdit* pObjChange = (ObjChangePathEdit*) (pCurrentChange->pNode); BOOL* pDragStarted = (BOOL*) (pCurrentDragS->pNode); // If drag has moved onto a different spread, convert the coord to be relative to the // original spread. if (pSpread != StartSpread) PointerPos = MakeRelativeToSpread(StartSpread, pSpread, PointerPos); Path TempPath; // inform the parent a change is happening if (pObjChange->ChangeMask.EorBlobs) { ChangeCode Chge = pObjChange->RenderCurrentBlobs(pOrigPath,this,pEditPath,StartSpread,TRUE); if (Chge!=CC_OK) return; // Create a local copy of the edit path if (!TempPath.Initialise(pEditPath->GetNumCoords(), 12)) return; TempPath.CopyPathDataFrom(pEditPath); } // Rub out the old EORed version of the path if (*pDragStarted == TRUE) { RenderPathEditBlobs(pEditPath, /*pEditPath->GetBoundingRect(),*/ StartSpread ); } else { *pDragStarted = TRUE; // pCurrentDragS->pNode = (Node*) pDragStarted; } DocRect PointerBlobRect; GetApplication()->GetBlobManager()->GetBlobRect(PointerPos,&PointerBlobRect); DocCoord* Coords = pEditPath->GetCoordArray(); // PathFlags* Flags = pEditPath->GetFlagArray(); PathVerb* Verbs = pEditPath->GetVerbArray(); INT32 NumCoords = pEditPath->GetNumCoords(); if (pCurrentOrig == (NodeListItem*) OriginalPaths.GetHead ()) { // CGS: all of the operations to do with snapping to grid, snapping to opposite // end point and snapping to another lines endpoint are relevant only for // that control point that the drag was initiated from .... // Here is where we do all the snapping to grids and endpoints // and constrain. First we check for snapping to line ends, then // we check constrain, then we check grid snapping EndSnapped = FALSE; // TRUE if this point snaps to the other end SnapToAnother = FALSE; // TRUE if this point snaps to another line end SnapToLineOrCurve = FALSE; // No snapped other line // We might be snapping to an endpoint if the point we're dragging around is either // a moveto, or is the last point in the subpath. We will also only snap if there is // only one point selected on the path INT32 i; if (DragPoint != -1) { // Look to see if the selected point is a real endpoint if (Verbs[DragPoint] == PT_MOVETO) { // This is the start element of the path i = DragPoint; if (!pEditPath->IsSubPathClosed(i)) { INT32 NextEndpoint = i; if (pEditPath->FindNextEndPoint(&NextEndpoint)) { pEditPath->FindEndElOfSubPath(&i); // i indexes to the end element // If this sub-path is one element long then closing it is not allowed if ((i != NextEndpoint) && PointerBlobRect.ContainsCoord(Coords[i])) { PointerPos.x = Coords[i].x + LastMousePos.x - Coords[DragPoint].x; PointerPos.y = Coords[i].y + LastMousePos.y - Coords[DragPoint].y; EndSnapped = TRUE; } } } } else if (DragPoint+1 == NumCoords || Verbs[DragPoint+1] == PT_MOVETO) { // This is the last element in the sub-path i = DragPoint; if (!pEditPath->IsSubPathClosed(i)) { INT32 PrevEndpoint = i; if (pEditPath->FindPrevEndPoint(&PrevEndpoint)) { pEditPath->FindStartOfSubPath(&i); // i is the index of the start of the sub-path // If this sub-path is one element long then closing it is not allowed if ((i != PrevEndpoint) && PointerBlobRect.ContainsCoord(Coords[i])) { PointerPos.x = Coords[i].x + LastMousePos.x - Coords[DragPoint].x; PointerPos.y = Coords[i].y + LastMousePos.y - Coords[DragPoint].y; EndSnapped = TRUE; } } } } } // That detects snapping to the opposite endpoint, but what about snapping to another // endpoint altogether? Time to check for that eventuality if (!EndSnapped && DragPoint != -1 && (Verbs[DragPoint] == PT_MOVETO || DragPoint+1 == NumCoords || Verbs[DragPoint+1] == PT_MOVETO) ) { // Get a snapshot of the selection SelRange* Selected = GetApplication()->FindSelection(); // do something extra in here .... Node* pNode = Selected->FindFirst(); INT32 SubIndex,SubEnd; while (pNode) { if ((pNode->FindParentSpread() == StartSpread) && (pNode->GetRuntimeClass() == CC_RUNTIME_CLASS(NodePath)) /*&& (pNode != OriginalPath)*/ ) { Path* ThisPath = &(((NodePath*)pNode)->InkPath); INT32 ThisNum = ThisPath->GetNumCoords(); SubIndex = 0; SubEnd = 0; while (SubIndex<ThisNum) { DocCoord tempStart,tempEnd; ThisPath->SetPathPosition(SubIndex); // Set the path's internal pos index if (ThisPath->GetSubPathEnds(&tempStart, &tempEnd)) { SubEnd = ThisPath->GetPathPosition(); // Now SubIndex is the index of the first, and SubEnd is the index // of the last element (N.B. might be a curveto, in which case add 2) if (ThisPath->GetVerb() == PT_BEZIERTO) SubEnd+=2; BOOL ClosedPath = (ThisPath->GetVerbArray()[SubEnd] & PT_CLOSEFIGURE) ; // Now compare start and end with pointer position, but not if this // subpath is the currently dragging subpath if ( !ClosedPath && ( (pNode != OriginalPath) || ((pNode == OriginalPath) && (DragPoint != SubIndex) && (DragPoint != SubEnd)) ) ) { if (PointerBlobRect.ContainsCoord(tempStart)) { break; } if (PointerBlobRect.ContainsCoord(tempEnd)) { SubIndex = SubEnd; break; } } } else { SubEnd = ThisPath->GetPathPosition(); } SubIndex = SubEnd+1; // Points at start of next subpath // or top of whole path } // if SubIndex < ThisNum we must have found a matching coord // so that's what we'll snap to if (SubIndex < ThisNum) break; // Exit the outer while condition } pNode = Selected->FindNext(pNode); } // At this point, if pNode == NULL we haven't snapped to anything // otherwise pNode is the path we've snapped to, and SubIndex is the index // of the point we've snapped to if (pNode) { // if the snap to path is the path being edited check that it has the same number of points! if (((NodePath*)pNode == pOrigPath) && (pOrigPath->InkPath.GetNumCoords() != pEditPath->GetNumCoords())) { // PATRACE( _T("Attempted to join an edited path!\n")); // The problem is that if the OriginalPath has been edited by adding an endpoint then // SnapToIndex will be wrong as it counted along the original path, not the edited one.... } else { SnapToAnother = TRUE; SnapToPath = (NodePath*)pNode; SnapToIndex = SubIndex; SnapToPath->InkPath.SetPathPosition(SnapToIndex); PointerPos.x = SnapToPath->InkPath.GetCoord().x + LastMousePos.x - Coords[DragPoint].x; PointerPos.y = SnapToPath->InkPath.GetCoord().y + LastMousePos.y - Coords[DragPoint].y; } } } // only do the following for the node that the drag was started from .... //if (pCurrentOrig == (NodeListItem*) OriginalPaths.GetHead ()) //{ // We don't allow closed paths consiting of two straight segments if (EndSnapped && NumCoords < 4) EndSnapped = FALSE; if ((EndSnapped || SnapToAnother) && (pMoveCursor != NULL)) ChangeCursor(pCloseCursor); else ChangeCursor(pCrossHairCursor); //} // Now constrain the mouse point ERROR3IF(ConstrainPoint == DocCoord(-1,-1),"ConstrainPoint wasn't set"); ERROR3IF(ConstrainPrevPoint == DocCoord(-1,-1),"ConstrainPrevPoint wasn't set"); ERROR3IF(ConstrainNextPoint == DocCoord(-1,-1),"ConstrainNextPoint wasn't set"); if (!EndSnapped && ClickMods.Constrain) { if (ClickMods.Adjust) { if (ClickMods.Alternative1 || ClickMods.Alternative2) DocView::ConstrainToAngle(ConstrainNextPoint, &PointerPos); else DocView::ConstrainToAngle(ConstrainPrevPoint, &PointerPos); } else DocView::ConstrainToAngle(ConstrainPoint, &PointerPos); } // Only snap to grid if we didn't snap to the end of a path if (!EndSnapped) DocView::SnapCurrent(StartSpread,&PointerPos); } // This is the bit where we go off and re-calculate the paths position, // based on how much the mouse has moved if (pCurrentOrig == (NodeListItem*) OriginalPaths.GetHead ()) { Offset.x = PointerPos.x - LastMousePos.x; Offset.y = PointerPos.y - LastMousePos.y; } // need to consider the validness of EndSnapped and DragPoint as well .... // CSG says: we MUST pass EndSnapped and DragPoint as passed in below, // since these two values are reserved for the path that the drag was iniated // on (i.e. the head of our linked list). If we don't do this, then we get // loads of nasty asserts and errors going off. RecalculatePaths (pEditPath, Offset, FALSE /*EndSnapped*/, -1 /*DragPoint*/); if (pObjChange->ChangeMask.EorBlobs) { ChangeCode Chge = pObjChange->RenderChangedBlobs(pOrigPath,this,pEditPath,StartSpread,TRUE); if (Chge!=CC_OK) { // replace the old edit path pEditPath->CopyPathDataFrom(&TempPath); RenderPathEditBlobs( pEditPath/*->GetBoundingRect()*/, StartSpread ); return; } } // Update the Last Mouse Position LastMousePos = PointerPos; // Draw in the new version of the path RenderPathEditBlobs( pEditPath/*->GetBoundingRect()*/, StartSpread ); // If there is just one selected point being dragged then we should show // its new position in the line tool infobar. // if (UpdatePoint != -1) // BROADCAST_TO_ALL(PathEditedMsg(pEditPath, pSpread, UpdatePoint)); pCurrentOrig = (NodeListItem*) OriginalPaths.GetNext (pCurrentOrig); pCurrentEdit = (NodeListItem*) EditPaths.GetNext (pCurrentEdit); pCurrentChange = (NodeListItem*) ObjChanges.GetNext (pCurrentChange); pCurrentDragS = (NodeListItem*) PathsDragStarted.GetNext (pCurrentDragS); } SetStatusLineHelp(); } }

BOOL OpNodePathEditBlob::EditBrushAttribute (  INT32  FirstIndex, INT32  LastIndex, AttrBrushType *  pAttrBrush )  [protected, virtual]

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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/2000 inputs : FirstIndex - first changed index of the path LastIndex - last changed index pAttrBrush - the attribute to change outputs: - returns: TRUE if all went well Reimplemented in OpNodePathAddEndpoint. Definition at line 3927 of file pathedit.cpp. { if (FirstIndex < 0 || LastIndex < 0 || LastIndex <= FirstIndex || pAttrBrush == NULL) { //ERROR3("Invalid inputs to OpNodePathEditBlob::EditBrushAttribute"); return FALSE; } // currently we only have pressure implemented, and if this attribute does not use // pressure then theres nothing for us to do CDistanceSampler* pDistSamp = pAttrBrush->GetPressureCache(); if (pDistSamp == NULL) return TRUE; // not an error /* Basically what we want to do here is resample the data that applies to the changed section of the path, so that we have the same data applying over a different distance. The way to implement this in an undoable way is this: 1) Find out the new length of the changed section of the path; 2) Ask the sampler to copy out the current data between the changed points; 4) Resample that data over the new length(the sampler can do this for us); 4) Create an action to undoably remove the original section of data from the attribute 5) Create an action to undoably insert the new resampled section; */ MILLIPOINT ChangedLength = GetLengthOfPathSection(&EditPath, FirstIndex, LastIndex); // MILLIPOINT OrigLength = GetLengthOfPathSection(&(OriginalPath->InkPath), FirstIndex, LastIndex); // Get the distances to the changed indexes in the original path MILLIPOINT OrigStartDist = GetDistanceToPathIndex(&(OriginalPath->InkPath), FirstIndex); MILLIPOINT OrigEndDist = GetDistanceToPathIndex(&(OriginalPath->InkPath), LastIndex); if (OrigStartDist == -1 || OrigEndDist == -1) { ERROR3("Error getting distance to index in OpNodePathEditBlob::EditBrushAttribute"); return FALSE; } // we need another sampler to store the section data, needs to be allocated as we're putting // it into an action later CDistanceSampler* pSection = new CDistanceSampler; if (pSection == NULL) return FALSE; // Ask the sampler for its data section BOOL ok = pDistSamp->GetDataSection(OrigStartDist, OrigEndDist, pSection); if (!ok) return FALSE; // ask the section to resample itself if (!pSection->ReSample(ChangedLength)) { delete pSection; return FALSE; } pSection->SetNumItemsFromArraySize(); INT32 StartPressIndex = pDistSamp->GetInternalIndexFromDistance(OrigStartDist); INT32 EndPressIndex = pDistSamp->GetInternalIndexFromDistance(OrigEndDist); INT32 NumIndexes = EndPressIndex - StartPressIndex; if (StartPressIndex == -1 || EndPressIndex == -1 || NumIndexes <= 0) { delete pSection; return FALSE; } // now make a removepoints action RemovePressurePointsAction* pAction; if (RemovePressurePointsAction::Init(this, &UndoActions, pAttrBrush, StartPressIndex, NumIndexes, NULL, &pAction) == AC_FAIL) return FALSE; // now insert our new points into the attribute AddPressurePointsAction* pAddAction; // find out how many points we're inserting size_t NumAddPoints = pSection->GetNumItems(); if (AddPressurePointsAction::Init(this, &UndoActions, pAttrBrush, pSection, StartPressIndex, NumAddPoints, &pAddAction) == AC_FAIL) { delete pSection; return FALSE; } return TRUE; }

BOOL OpNodePathEditBlob::FillPathIfEndsSnapped (  NodePath *  pOrigPath  )  [protected]

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. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (based upon Jim) Date: 17/5/00 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Errors: - See also: - Definition at line 4922 of file pathedit.cpp. { // If the ends snapped, set the filled bit on the path if (EndSnapped && !(pOrigPath->InkPath.IsFilled)) { ModifyFilledAction* pAction; if (ModifyFilledAction::Init(this, &UndoActions, TRUE, FALSE, pOrigPath, (Action**)(&pAction))== AC_FAIL) return FALSE; pOrigPath->InkPath.IsFilled = TRUE; } return TRUE; }

BOOL OpNodePathEditBlob::FillPathIfEndsSnapped (   )  [protected]

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. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Errors: - See also: - Definition at line 4893 of file pathedit.cpp. { // If the ends snapped, set the filled bit on the path if (EndSnapped && !(OriginalPath->InkPath.IsFilled)) { ModifyFilledAction* pAction; if (ModifyFilledAction::Init(this, &UndoActions, TRUE, FALSE, OriginalPath, (Action**)(&pAction))== AC_FAIL) return FALSE; OriginalPath->InkPath.IsFilled = TRUE; } return TRUE; }

AttrBrushType * OpNodePathEditBlob::GetAppliedBrush (   )  [protected]

To get the brush attribute that is applied to the nodepath we are editing. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/99 inputs : - outputs: - returns: pointer to the attrbrushtype that is applied to this nodepath, or NULL if there isn't one. Note that if the applied brush is the default 'no brush' then we also return NULL Definition at line 3889 of file pathedit.cpp. { if (OriginalPath == NULL) return NULL; NodeAttribute* pAttr = NULL; AttrBrushType* pAttrBrush = NULL; OriginalPath->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), &pAttr); if (pAttr != NULL) { // just check that our applied brush isn't the default if (((AttrBrushType*)pAttr)->GetBrushHandle() != BrushHandle_NoBrush) pAttrBrush = (AttrBrushType*)pAttr; } return pAttrBrush; }

INT32 OpNodePathEditBlob::GetDistanceToPathIndex (  Path *  pPath, INT32  Index )  [protected]

As above,. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/2000 Parameters: pPath  - the path containing the index [INPUTS] Index - the index to which we wish to find the distance Returns: The distance along pPath to Index, or -1 if theres a problem Notes: Should really move this into Path at some point Definition at line 4088 of file pathedit.cpp. { // some checks ERROR2IF(pPath == NULL, -1, "Path is NULL in OpNodePathEditBlob::GetDistanceToPathIndex"); if (Index >= pPath->GetNumCoords()) { ERROR3("Invalid index in OpNodePathEditBlob::GetDistanceToPathIndex"); return -1; } // get the coordinates DocCoord* pCoords = pPath->GetCoordArray(); ERROR2IF(pCoords == NULL, -1, "Failed to get coord array in OpNodePathEditBlob::GetLengthOfEditSection"); DocCoord Coord = pCoords[Index]; MILLIPOINT Distance = -1; if (!pPath->GetDistanceToPoint(Coord, &Distance)) return -1; return Distance; }

NodeGroup * OpNodePathEditBlob::GetGroupParentOfCurve (  NodePath *  pOrigPath  )  [protected]

To determine if the current selection is a blend on a curve. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (based upon Diccon Yamanaka's) Date: 20/4/2000 inputs : - outputs: returns: pointer to the first nodeblend in the selection if successful, NULL otherwise Definition at line 3852 of file pathedit.cpp. { if (pOrigPath == NULL) return NULL; Node* pParent = pOrigPath->FindParent(); if (pParent != NULL) { if (pParent->IS_KIND_OF(NodeBlend)) { return (NodeGroup*)pParent; } else return NULL; } return NULL; }

NodeGroup * OpNodePathEditBlob::GetGroupParentOfCurve (   )  [protected]

To determine if the current selection is a blend on a curve. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/99 inputs : - outputs: returns: pointer to the first nodeblend in the selection if successful, NULL otherwise Definition at line 3815 of file pathedit.cpp. { if (OriginalPath == NULL) return NULL; Node* pParent = OriginalPath->FindParent(); if (pParent != NULL) { if (pParent->IS_KIND_OF(NodeBlend)) { return (NodeGroup*)pParent; } else return NULL; } return NULL; }

MILLIPOINT OpNodePathEditBlob::GetLengthOfPathSection (  Path *  pPath, INT32  FirstIndex, INT32  LastIndex )  [protected]

As above, if you want to know the distance between two points on the edit path then this function is for you. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/2000 Parameters: FirstIndex,LastIndex  - the indexes marking the start and end of the section [INPUTS] of path we are interested in pPath - the path we are interested in Returns: The distance along the pPath between the two indexes, or -1 if something went wrong Notes: I can't believe no-one has written a Path function to do this. There must be a better way to do this but currently I must get the two coordinates corresponding to the indexes, and call GetDistanceToPoint for both of them and do a subtraction. I will shift this into Path at some point but I don't want to hang around for the rebuild right now. Definition at line 4035 of file pathedit.cpp. { ERROR2IF(pPath == NULL, -1, "Path is NULL in OpNodePathEditBlob::GetLengthOfPathSection"); // find out how many elements there are in EditPath INT32 NumElements = pPath->GetNumCoords(); // check that our indexes are ok if (FirstIndex < 0 || LastIndex < 0 || LastIndex <= FirstIndex || FirstIndex >= NumElements || LastIndex > NumElements) { ERROR3("Invalid inputs to OpNodePathEditBlob::GetLengthOfEditSection"); return -1; } // get the coordinates DocCoord* pCoords = pPath->GetCoordArray(); ERROR2IF(pCoords == NULL, -1, "Failed to get coord array in OpNodePathEditBlob::GetLengthOfEditSection"); DocCoord FirstCoord = pCoords[FirstIndex]; DocCoord LastCoord = pCoords[LastIndex]; // Now get the distances along the path to these points MILLIPOINT FirstDistance = -1; MILLIPOINT LastDistance = -1; BOOL ok = pPath->GetDistanceToPoint(FirstCoord, &FirstDistance); if (ok) ok = pPath->GetDistanceToPoint(LastCoord, &LastDistance); MILLIPOINT SectionLength = -1; if (ok) SectionLength = LastDistance - FirstDistance; return SectionLength; }

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

Find out the state of the operation at the specific time. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/93 Parameters: Description  - GetState fills this string with an approriate description [OUTPUTS] of the current state of the selector tool Returns: The state of the operation, so that menu items (ticks and greying can be done properly Reimplemented in OpNodePathEditControlBlob, OpNodePathAddEndpoint, OpCloseNodePaths, OpReshapeOrAddPoint, and OpNewPath. Definition at line 3351 of file pathedit.cpp. { OpState Blobby; return Blobby; }

BOOL OpNodePathEditBlob::Init (  void   )  [static]

Adds the operation to the list of all known operations. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/93 Returns: TRUE if all went OK, False otherwise Reimplemented from SimpleCCObject. Reimplemented in OpNodePathEditControlBlob, OpNodePathAddEndpoint, OpCloseNodePaths, OpReshapeOrAddPoint, and OpNewPath. Definition at line 3325 of file pathedit.cpp. { return (RegisterOpDescriptor( 0, _R(IDS_NODEPATH_EDIT), CC_RUNTIME_CLASS(OpNodePathEditBlob), OPTOKEN_NODEPATH, OpNodePathEditBlob::GetState, 0, // help ID _R(IDBBL_NODEPATHOP), 0 ) ); // bitmap ID */ }

BOOL OpNodePathEditBlob::InsertChangeBlendStepsAction (  NodeBlend *  pNodeBlend  )  [protected]

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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 1/9/99 Parameters: the  node blend to change [INPUTS] -  [OUTPUTS] Returns: - Errors: Error2 if pNodeBlend is null See also: called from OpNodePathEditBlob::DragFinished or OpNodePathAddEndpoint::CompleteThisPath Definition at line 1601 of file pathedit.cpp. { ERROR2IF(pNodeBlend==NULL, FALSE, "NodeBlend pointer is NULL"); // do we wish to keep the distance between steps constant? If so then determine // how many steps we need with the new length and make an action. if (pNodeBlend->GetEditState() == EDIT_DISTANCE) { UINT32 NewNumSteps = 0; UINT32 OldNumSteps = pNodeBlend->GetNumBlendSteps(); double StepDistance = pNodeBlend->GetDistanceEntered(); double NewPathLength = EditPath.GetPathLength(); NewNumSteps = (UINT32)(NewPathLength/StepDistance); BOOL ok = TRUE; if (OldNumSteps != NewNumSteps) { ChangeBlendStepsAction* pAction; if (ok) ok = (InvalidateBoundsAction::Init(this,&UndoActions,pNodeBlend,TRUE) != AC_FAIL); if (ok) ok = ChangeBlendStepsAction::Init(this,&UndoActions,pNodeBlend,OldNumSteps,StepDistance,&pAction) != AC_FAIL; if (ok) ok = DoInvalidateNodeRegion(pNodeBlend,TRUE,FALSE); if (ok) ok = (InvalidateBoundsAction::Init(this,&UndoActions,pNodeBlend,TRUE) != AC_FAIL); pNodeBlend->SetNumBlendSteps(NewNumSteps); } // added 9/9/99 now we are shifting the last object along the curve to ensure precise // step distances. To do this we must set the proportion of the curve used in the // NodeBlender objects. if (ok) { double PathDistanceUsed = NewNumSteps * StepDistance; double PathProportion = PathDistanceUsed / NewPathLength; // double PathDistanceUnused = NewPathLength - PathDistanceUsed; if (PathProportion != 1.0) { ChangeBlenderOpParam BlenderParam; BlenderParam.m_ChangeType = CHANGEBLENDER_PATHEND; NodeBlender* pNodeBlender = pNodeBlend->FindFirstBlender(); INT32 NumBlenders = pNodeBlend->GetNumBlenders(); while (pNodeBlender != NULL) { NumBlenders--; if (NumBlenders ==0) { BlenderParam.m_NewPathEnd = PathProportion; ok = ChangeBlenderAction::Init(this, &UndoActions, pNodeBlender, BlenderParam); if (ok) { DocCoord NewPoint; double ExtraParam = 0.0; //passed to the function but not used afterwards ok = pNodeBlender->GetPointOnNodeBlendPath(1.0,&NewPoint,&ExtraParam); if (ok) { NodeRenderableInk* pEnd = pNodeBlender->GetNodeEnd(); NodeBlend* pNodeBlend = pNodeBlender->GetNodeBlend(); ok = ((pEnd != NULL) && (pNodeBlend != NULL)); if (ok) ok = pNodeBlend->TransformNodeToPoint(pEnd,&NewPoint,this,ExtraParam); } } } pNodeBlender = pNodeBlend->FindNextBlender(pNodeBlender); } } // end if (pathproportion.. } // end if(ok) } return TRUE; }

BOOL OpNodePathEditBlob::JoinWithOtherPath (  NodePath **  pOrigPath  )  [protected]

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. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (based upon Jim) Date: 17/5/00 Returns: FALSE if it failed (lack of memory maybe) TRUE otherwise Errors: If it runs out of memory then it will return FALSE Definition at line 1984 of file pathedit.cpp. { // If SnapToAnother is false there's no snapping to be done, so just return successfully if (!SnapToAnother) return TRUE; // If we're joining with another path, the rules say we can only have one selected point. PathFlags* Flags = (*pOrigPath)->InkPath.GetFlagArray(); INT32 NumCoords = (*pOrigPath)->InkPath.GetNumCoords(); NodePath* OldSnapPath = SnapToPath; INT32 MainIndex; for (MainIndex=0; MainIndex<NumCoords; MainIndex++) { if (Flags[MainIndex].IsEndPoint && Flags[MainIndex].IsSelected) break; } // on exit, MainIndex is the selected endpoint, or = NumCoords ENSURE(MainIndex<NumCoords,"There isn't a selected endpoint in the original path (JoinWithAnotherPath)"); // We're joining to another path, so the easiest way to handle undo is to make a deep copy // of the original path, then join that with the othe path, put it back into the tree // and delete the old one. Simple. Node* pnp; (*pOrigPath)->NodeCopy(&pnp); // Make a deep copy of the original path, with attributes NodePath* MainPath = (NodePath*)pnp; if (!MainPath) return FALSE; // Now that we have a copy of this path, let's join it with the other path if (SnapToAnother) { // If we're snapping to a subpath in the same path, change SnapToPath because we're // no longer joining to OriginalPath. if (SnapToPath == (*pOrigPath)) SnapToPath = MainPath; // If we're snapping to another, the first thing I have to do is change the control // point of the point in the other path that we're snapping to, because it might // have been smoothed. if (SnapToLineOrCurve) // TRUE if the path has been smoothed { PathVerb* OtherVerbs = SnapToPath->InkPath.GetVerbArray(); PathFlags* OtherFlags = SnapToPath->InkPath.GetFlagArray(); DocCoord* OtherCoords = SnapToPath->InkPath.GetCoordArray(); if (OtherVerbs[SnapToIndex] == PT_MOVETO) { // Don't need to undo if SnapToPath == MainPath if (SnapToPath == MainPath) OtherCoords[SnapToIndex+1] = SnapToCoords[1]; else DoAlterPathElement( SnapToPath, SnapToIndex+1, SnapToCoords[1], OtherFlags[SnapToIndex+1], OtherVerbs[SnapToIndex+1]); } else { if (SnapToPath == MainPath) OtherCoords[SnapToIndex-1] = SnapToCoords[1]; else DoAlterPathElement( SnapToPath, SnapToIndex-1, SnapToCoords[1], OtherFlags[SnapToIndex-1], OtherVerbs[SnapToIndex-1]); } } if (!MainPath->InkPath.JoinToAnother(&(SnapToPath->InkPath), MainIndex, SnapToIndex)) { MainPath->CascadeDelete(); delete MainPath; return FALSE; } } // We've joined successfully, so let's insert this new node into the tree next to the original if (!DoInsertNewNode(MainPath, (*pOrigPath), NEXT, TRUE, FALSE)) { MainPath->CascadeDelete(); delete MainPath; return FALSE; } // Hide the original path if (!DoHideNode((*pOrigPath), TRUE)) return FALSE; // Hide the node we joined to if (OldSnapPath != (*pOrigPath)) { if (!DoHideNode(OldSnapPath, TRUE)) return FALSE; } // Change the pOrigPath variable so that subsequent operations work properly (*pOrigPath) = MainPath; return TRUE; }

BOOL OpNodePathEditBlob::JoinWithOtherPath (   )  [protected]

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. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 5/10/94 Returns: FALSE if it failed (lack of memory maybe) TRUE otherwise Errors: If it runs out of memory then it will return FALSE Definition at line 1856 of file pathedit.cpp. { // If SnapToAnother is false there's no snapping to be done, so just return successfully if (!SnapToAnother) return TRUE; // If we're joining with another path, the rules say we can only have one selected point. PathFlags* Flags = OriginalPath->InkPath.GetFlagArray(); INT32 NumCoords = OriginalPath->InkPath.GetNumCoords(); NodePath* OldSnapPath = SnapToPath; INT32 MainIndex; for (MainIndex=0; MainIndex<NumCoords; MainIndex++) { if (Flags[MainIndex].IsEndPoint && Flags[MainIndex].IsSelected) break; } // on exit, MainIndex is the selected endpoint, or = NumCoords ENSURE(MainIndex<NumCoords,"There isn't a selected endpoint in the original path (JoinWithAnotherPath)"); // We're joining to another path, so the easiest way to handle undo is to make a deep copy // of the original path, then join that with the othe path, put it back into the tree // and delete the old one. Simple. Node* pnp; OriginalPath->NodeCopy(&pnp); // Make a deep copy of the original path, with attributes NodePath* MainPath = (NodePath*)pnp; if (!MainPath) return FALSE; // Now that we have a copy of this path, let's join it with the other path if (SnapToAnother) { // If we're snapping to a subpath in the same path, change SnapToPath because we're // no longer joining to OriginalPath. if (SnapToPath == OriginalPath) SnapToPath = MainPath; // If we're snapping to another, the first thing I have to do is change the control // point of the point in the other path that we're snapping to, because it might // have been smoothed. if (SnapToLineOrCurve) // TRUE if the path has been smoothed { PathVerb* OtherVerbs = SnapToPath->InkPath.GetVerbArray(); PathFlags* OtherFlags = SnapToPath->InkPath.GetFlagArray(); DocCoord* OtherCoords = SnapToPath->InkPath.GetCoordArray(); if (OtherVerbs[SnapToIndex] == PT_MOVETO) { // Don't need to undo if SnapToPath == MainPath if (SnapToPath == MainPath) OtherCoords[SnapToIndex+1] = SnapToCoords[1]; else DoAlterPathElement( SnapToPath, SnapToIndex+1, SnapToCoords[1], OtherFlags[SnapToIndex+1], OtherVerbs[SnapToIndex+1]); } else { if (SnapToPath == MainPath) OtherCoords[SnapToIndex-1] = SnapToCoords[1]; else DoAlterPathElement( SnapToPath, SnapToIndex-1, SnapToCoords[1], OtherFlags[SnapToIndex-1], OtherVerbs[SnapToIndex-1]); } } if (!MainPath->InkPath.JoinToAnother(&(SnapToPath->InkPath), MainIndex, SnapToIndex)) { MainPath->CascadeDelete(); delete MainPath; return FALSE; } } // We've joined successfully, so let's insert this new node into the tree next to the original if (!DoInsertNewNode(MainPath, OriginalPath, NEXT, TRUE, FALSE)) { MainPath->CascadeDelete(); delete MainPath; return FALSE; } // Hide the original path if (!DoHideNode(OriginalPath, TRUE)) return FALSE; // Hide the node we joined to if (OldSnapPath != OriginalPath) { if (!DoHideNode(OldSnapPath, TRUE)) return FALSE; } // Change the OriginalPath member variable so that subsequent operations work properly OriginalPath = MainPath; return TRUE; }

void OpNodePathEditBlob::RecalculatePath (  DocCoord  Offset, BOOL  SnapEnds = FALSE, INT32  SnapIndex = 0 )  [protected]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 9/11/93 Parameters: Offset  - The Amount to move the selected blobs by before re-calcing everything [INPUTS] SnapEnds is TRUE if the start and endpoint should snap (affects smoothing) SnapIndex is the index of the point that's being snapped, so we can only snap one subpath out of many Scope: Private Definition at line 2658 of file pathedit.cpp. { // Get the array that I need PathFlags* Flags = EditPath.GetFlagArray(); DocCoord* Coords = EditPath.GetCoordArray(); INT32 NumCoords = EditPath.GetNumCoords(); // Go though all the points for (INT32 i=0; i<NumCoords; i++) { // and translate them by the drag offset if they are selected if (Flags[i].IsSelected) Coords[i].translate( Offset.x, Offset.y ); } // And now smooth out the new path EditPath.SmoothCurve(TRUE, SnapEnds, SnapIndex); // Now to snap (possibly) to another path, if the SnapToAnother flag is set // This not only entails changing the part of the line we're dragging, but it might // also mean we have to set the SnapToCoords array to contain a snapped bezier segment if (SnapToAnother) { // Get the array pointers PathVerb* Verbs = EditPath.GetVerbArray(); Flags = EditPath.GetFlagArray(); Coords = EditPath.GetCoordArray(); PathVerb* OtherVerbs = SnapToPath->InkPath.GetVerbArray(); PathFlags* OtherFlags = SnapToPath->InkPath.GetFlagArray(); DocCoord* OtherCoords = SnapToPath->InkPath.GetCoordArray(); // Because we're snapping, we must be on either the start or the end of a subpath // And the CloseFigure flag will never be set. // There are sixteen possibilities - for each line, we could be looking at // a curve or a line, at the start or end of each subpath. This logic enumerates // all of the possibilities. It may look tortuous, but it gets them all. if (Verbs[SnapIndex] == PT_MOVETO) { // We're dragging the start of a subpath. See if it's a curve if (Verbs[SnapIndex+1] == PT_BEZIERTO) { // We are dragging a curve at the start of the path. See what we've snapped to if (OtherVerbs[SnapToIndex] == PT_MOVETO) { // Snapping a curve at start to the start of the other one if (OtherVerbs[SnapToIndex+1] == PT_BEZIERTO) { // Snapping curve at beginning with curve at beginning // Let's smooth this bezier according to the snapping if (Flags[SnapIndex+1].IsSmooth) Coords[SnapIndex+1] = EditPath.SmoothControlPoint( SnapIndex+1, FALSE, // start end not snapped TRUE, // Joined to another TRUE, // Other is a curve OtherCoords[SnapToIndex+3] ); // Note that the other control point is not affected by the snap // Since the other segment is a curve, we have to set up the SnapToCoords array // so that the render routine works properly // Notice that the assignment in the if below is required if ((SnapToLineOrCurve = OtherFlags[SnapToIndex+1].IsSmooth)) { SnapToCoords[0] = OtherCoords[SnapToIndex]; SnapToCoords[1] = SnapToPath->InkPath.SmoothControlPoint( SnapToIndex+1, FALSE, TRUE, TRUE, Coords[SnapIndex+3] ); SnapToCoords[2] = OtherCoords[SnapToIndex+2]; SnapToCoords[3] = OtherCoords[SnapToIndex+3]; } } else { // Snapping curve at beginning with line at beginning if (Flags[SnapIndex+1].IsSmooth) Coords[SnapIndex+1] = EditPath.SmoothControlPoint( SnapIndex+1, FALSE, // start end not snapped TRUE, // Joined to another FALSE, // Other is a line OtherCoords[SnapToIndex+1] ); // Since we're snapping to a line, we just need to set SnapToLineOrCurve to FALSE SnapToLineOrCurve = FALSE; } } else { // Snapping curve at beginning with the end of the other one if (OtherVerbs[SnapToIndex] == PT_BEZIERTO) { // Snapping curve at beginning with curve at end of other one // Smooth the editpath bezier if the flag says we can if (Flags[SnapIndex+1].IsSmooth) Coords[SnapIndex+1] = EditPath.SmoothControlPoint( SnapIndex+1, FALSE, TRUE, TRUE, OtherCoords[SnapToIndex-3] ); // Now set up SnapToCoords array if ((SnapToLineOrCurve = OtherFlags[SnapToIndex-1].IsSmooth)) // yes the other path is a curve { SnapToCoords[0] = OtherCoords[SnapToIndex]; SnapToCoords[1] = SnapToPath->InkPath.SmoothControlPoint( SnapToIndex-1, FALSE, TRUE, TRUE, Coords[SnapIndex+3] ); SnapToCoords[2] = OtherCoords[SnapToIndex-2]; SnapToCoords[3] = OtherCoords[SnapToIndex-3]; } } else { // snapping curve at beginning with line at end of other one if (Flags[SnapIndex+1].IsSmooth) Coords[SnapIndex+1] = EditPath.SmoothControlPoint( SnapIndex+1, FALSE, TRUE, FALSE, OtherCoords[SnapToIndex-1] ); // Other is a line, so the SnapToCoords array isn't used SnapToLineOrCurve = FALSE; } } } else { // Dragging a line at the beginning. What are we snapping to if (OtherVerbs[SnapToIndex] == PT_MOVETO) { // Snapping a line at start to the start of the other one if (OtherVerbs[SnapToIndex+1] == PT_BEZIERTO) { // Snapping line at beginning with curve at beginning // There's nothing to smooth in the edit path, but we have to // set up the SnapToCoords array if ((SnapToLineOrCurve = OtherFlags[SnapToIndex+1].IsSmooth)) { SnapToCoords[0] = OtherCoords[SnapToIndex]; SnapToCoords[1] = SnapToPath->InkPath.SmoothControlPoint( SnapToIndex+1, FALSE, TRUE, FALSE, Coords[SnapIndex+1] ); SnapToCoords[2] = OtherCoords[SnapToIndex+2]; SnapToCoords[3] = OtherCoords[SnapToIndex+3]; } } { // Snapping line at beginning with line at beginning // Nothing whatever to smooth, just clear the flag SnapToLineOrCurve = FALSE; } } else { // Snapping line at beginning with the end of the other one if (OtherVerbs[SnapToIndex] == PT_BEZIERTO) { // Snapping line at beginning with curve at end of other one // Nothing to smooth in editpath, let's set up SnapToCoords array if ((SnapToLineOrCurve = OtherFlags[SnapToIndex-1].IsSmooth)) { SnapToCoords[0] = OtherCoords[SnapToIndex]; SnapToCoords[1] = SnapToPath->InkPath.SmoothControlPoint( SnapToIndex-1, FALSE, TRUE, FALSE, Coords[SnapIndex+1] ); SnapToCoords[2] = OtherCoords[SnapToIndex-2]; SnapToCoords[3] = OtherCoords[SnapToIndex-3]; } } else { // snapping line at beginning with line at end of other one // Just clear the flag SnapToLineOrCurve = FALSE; } } } } else { // We're snapping the end of the path, let's see what if (Verbs[SnapIndex] == PT_BEZIERTO) { // Snapping a curve at the end to... what? if (OtherVerbs[SnapToIndex] == PT_MOVETO) { // Snapping a curve at the end to the start of the other one if (OtherVerbs[SnapToIndex+1] == PT_BEZIERTO) { // Snapping curve at the end with curve at beginning if (Flags[SnapIndex-1].IsSmooth) Coords[SnapIndex-1] = EditPath.SmoothControlPoint( SnapIndex-1, FALSE, TRUE, TRUE, OtherCoords[SnapToIndex+3] ); // Set up the SnapToCoords array if ((SnapToLineOrCurve = OtherFlags[SnapToIndex+1].IsSmooth)) { SnapToCoords[0] = OtherCoords[SnapToIndex]; SnapToCoords[1] = SnapToPath->InkPath.SmoothControlPoint( SnapToIndex+1, FALSE, TRUE, TRUE, Coords[SnapIndex-3] ); SnapToCoords[2] = OtherCoords[SnapToIndex+2]; SnapToCoords[3] = OtherCoords[SnapToIndex+3]; } } else { // Snapping curve at the end with line at beginning if (Flags[SnapIndex-1].IsSmooth) Coords[SnapIndex-1] = EditPath.SmoothControlPoint( SnapIndex-1, FALSE, TRUE, FALSE, OtherCoords[SnapToIndex+1] ); // Clear flag for SnapToCoords array SnapToLineOrCurve = FALSE; } } else { // Snapping curve at the end with the end of the other one if (OtherVerbs[SnapToIndex] == PT_BEZIERTO) { // Snapping curve at the end with curve at end of other one if (Flags[SnapIndex-1].IsSmooth) Coords[SnapIndex-1] = EditPath.SmoothControlPoint( SnapIndex-1, FALSE, TRUE, TRUE, OtherCoords[SnapToIndex-3] ); // Init the SnapToCoords array if ((SnapToLineOrCurve = OtherFlags[SnapToIndex-1].IsSmooth)) { SnapToCoords[0] = OtherCoords[SnapToIndex]; SnapToCoords[1] = SnapToPath->InkPath.SmoothControlPoint( SnapToIndex-1, FALSE, TRUE, TRUE, Coords[SnapIndex-3] ); SnapToCoords[2] = OtherCoords[SnapToIndex-2]; SnapToCoords[3] = OtherCoords[SnapToIndex-3]; } } else { // snapping curve at the end with line at end of other one if (Flags[SnapIndex-1].IsSmooth) Coords[SnapIndex-1] = EditPath.SmoothControlPoint( SnapIndex-1, FALSE, TRUE, FALSE, OtherCoords[SnapToIndex-1] ); // Other is a line so clear the flag SnapToLineOrCurve = FALSE; } } } else { // Snapping a line at the end with something if (OtherVerbs[SnapToIndex] == PT_MOVETO) { // Snapping a line at the end to the start of the other one if (OtherVerbs[SnapToIndex+1] == PT_BEZIERTO) { // Snapping line at the end with curve at beginning // Nothing to smooth in the edit path, but we should set up SnapToCoords array if ((SnapToLineOrCurve = OtherFlags[SnapToIndex+1].IsSmooth)) { SnapToCoords[0] = OtherCoords[SnapToIndex]; SnapToCoords[1] = SnapToPath->InkPath.SmoothControlPoint( SnapToIndex+1, FALSE, TRUE, FALSE, Coords[SnapIndex-1] ); SnapToCoords[2] = OtherCoords[SnapToIndex+2]; SnapToCoords[3] = OtherCoords[SnapToIndex+3]; } } { // Snapping line at the end with line at beginning // Just clear the flag SnapToLineOrCurve = FALSE; } } else { // Snapping line at the end with the end of the other one if (OtherVerbs[SnapToIndex] == PT_BEZIERTO) { // Snapping line at the end with curve at end of other one // Nothing to smooth in Editpath, but we have to do the array if ((SnapToLineOrCurve = OtherFlags[SnapToIndex-1].IsSmooth)) { SnapToCoords[0] = OtherCoords[SnapToIndex]; SnapToCoords[1] = SnapToPath->InkPath.SmoothControlPoint( SnapToIndex-1, FALSE, TRUE, FALSE, Coords[SnapIndex-1] ); SnapToCoords[2] = OtherCoords[SnapToIndex-2]; SnapToCoords[3] = OtherCoords[SnapToIndex-3]; } } else { // snapping line at the end with line at end of other one // Just clear the flag SnapToLineOrCurve = FALSE; } } } } } }

void OpNodePathEditBlob::RecalculatePaths (  Path *  pEditPath, DocCoord  Offset, BOOL  SnapEnds = FALSE, INT32  SnapIndex = 0 )  [protected]

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. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 20/4/2000 Parameters: Offset  - The Amount to move the selected blobs by before re-calcing everything [INPUTS] SnapEnds is TRUE if the start and endpoint should snap (affects smoothing) SnapIndex is the index of the point that's being snapped, so we can only snap one subpath out of many Scope: Private Definition at line 3027 of file pathedit.cpp. { //NodeListItem* pCurrentOrig = (NodeListItem*) OriginalPaths.GetHead (); //NodeListItem* pCurrentEdit = (NodeListItem*) EditPaths.GetHead (); //while (/*(pCurrentOrig) &&*/ (pCurrentEdit)) //{ //NodePath* pOrigPath = (NodePath*) (pCurrentOrig->pNode); // Path* pEditPath = (Path*) (pCurrentEdit->pNode); // Get the array that I need PathFlags* Flags = pEditPath->GetFlagArray(); DocCoord* Coords = pEditPath->GetCoordArray(); INT32 NumCoords = pEditPath->GetNumCoords(); // Go though all the points for (INT32 i=0; i<NumCoords; i++) { // and translate them by the drag offset if they are selected if (Flags[i].IsSelected) Coords[i].translate( Offset.x, Offset.y ); } // And now smooth out the new path pEditPath->SmoothCurve(TRUE, SnapEnds, SnapIndex); //pCurrentOrig = (NodeListItem*) OriginalPaths.GetNext (pCurrentOrig); // pCurrentEdit = (NodeListItem*) EditPaths.GetNext (pCurrentEdit); //} }

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

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/93 Reimplemented from Operation. Reimplemented in OpNodePathEditControlBlob. Definition at line 3069 of file pathedit.cpp. { RenderPathEditBlobs(Rect,pSpread); if (EditObjChange.ChangeMask.EorBlobs) EditObjChange.RenderCurrentBlobs(OriginalPath,this,&EditPath,StartSpread,TRUE); }

void OpNodePathEditBlob::RenderDraggingBlobs (  Path *  pEditPath, Spread *  pSpread )  [protected, virtual]

Call this function to render all the blobs on screen from this operation. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 20/4/2000 Definition at line 3100 of file pathedit.cpp. { RenderPathEditBlobs(pEditPath, pSpread); }

void OpNodePathEditBlob::RenderDraggingBlobs (  DocRect  Rect, Spread *  pSpread )  [protected, virtual]

Call this function to render all the blobs on screen from this operation. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 1/5/95 Reimplemented in OpNodePathEditControlBlob. Definition at line 3085 of file pathedit.cpp. { RenderPathEditBlobs(Rect, pSpread); }

void OpNodePathEditBlob::RenderPathEditBlobs (  Path *  pEditPath, Spread *  pSpread )  [protected]

Call this function to render all the blobs on screen from this operation. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 20/4/2000 Definition at line 3213 of file pathedit.cpp. { // First we have to build a path to render Path RenderPath; if ( RenderPath.Initialise(24, 12) == FALSE ) { // We did not get the memory, so don't draw anything return; } DocRect Rect = pEditPath->GetBoundingRect(); BOOL IsInCurve = FALSE; INT32 NumCoords = pEditPath->GetNumCoords(); for (INT32 i=0; i<NumCoords; i++) { // Dereference the pointers I need PathFlags* Flags = pEditPath->GetFlagArray(); DocCoord* Coords = pEditPath->GetCoordArray(); PathVerb* Verbs = pEditPath->GetVerbArray(); // We only consider the end points if (Flags[i].IsEndPoint) { if (IsInCurve) { // we are already adding to the curve, so see if we should continue adding if (Flags[i].NeedToRender) { switch (Verbs[i] & (~PT_CLOSEFIGURE)) { case PT_MOVETO: RenderPath.InsertMoveTo(Coords[i]); break; case PT_LINETO: RenderPath.InsertLineTo(Coords[i]); break; case PT_BEZIERTO: RenderPath.InsertCurveTo(Coords[i-2], Coords[i-1], Coords[i]); break; default: break; } } else { IsInCurve = FALSE; } } else { // We are not currently adding to the render path, so start if (Flags[i].NeedToRender) { switch (Verbs[i] & (~PT_CLOSEFIGURE)) { case PT_MOVETO: RenderPath.InsertMoveTo(Coords[i]); break; case PT_BEZIERTO: RenderPath.InsertMoveTo(Coords[i-3]); RenderPath.InsertCurveTo(Coords[i-2],Coords[i-1],Coords[i]); break; case PT_LINETO: RenderPath.InsertMoveTo(Coords[i-1]); RenderPath.InsertLineTo(Coords[i]); break; } IsInCurve = TRUE; } } } } // And if we've snapped to another curve if (SnapToLineOrCurve) { // We are snapping to another curve, so render the curve RenderPath.InsertMoveTo(SnapToCoords[0]); RenderPath.InsertCurveTo(SnapToCoords[1],SnapToCoords[2],SnapToCoords[3]); } // Make sure that there is something to draw if (RenderPath.GetNumCoords()==0) return; // And this bit actually draws the path we have just made RenderRegion* pRegion = DocView::RenderOnTop( NULL, StartSpread, ClippedEOR ); while (pRegion != NULL) { pRegion->SetLineColour( COLOUR_XORNEW ); // Set the line colour pRegion->DrawPath( &RenderPath ); // Draw an EORed version of how the path will turn out pRegion = DocView::GetNextOnTop( &Rect ); // Get the next render region } }

void OpNodePathEditBlob::RenderPathEditBlobs (  DocRect  Rect, Spread *  pSpread )  [protected]

Definition at line 3106 of file pathedit.cpp. { // First we have to build a path to render Path RenderPath; if ( RenderPath.Initialise(24, 12) == FALSE ) { // We did not get the memory, so don't draw anything return; } BOOL IsInCurve = FALSE; INT32 NumCoords = EditPath.GetNumCoords(); for (INT32 i=0; i<NumCoords; i++) { // Dereference the pointers I need PathFlags* Flags = EditPath.GetFlagArray(); DocCoord* Coords = EditPath.GetCoordArray(); PathVerb* Verbs = EditPath.GetVerbArray(); // We only consider the end points if (Flags[i].IsEndPoint) { if (IsInCurve) { // we are already adding to the curve, so see if we should continue adding if (Flags[i].NeedToRender) { switch (Verbs[i] & (~PT_CLOSEFIGURE)) { case PT_MOVETO: RenderPath.InsertMoveTo(Coords[i]); break; case PT_LINETO: RenderPath.InsertLineTo(Coords[i]); break; case PT_BEZIERTO: RenderPath.InsertCurveTo(Coords[i-2], Coords[i-1], Coords[i]); break; default: break; } } else { IsInCurve = FALSE; } } else { // We are not currently adding to the render path, so start if (Flags[i].NeedToRender) { switch (Verbs[i] & (~PT_CLOSEFIGURE)) { case PT_MOVETO: RenderPath.InsertMoveTo(Coords[i]); break; case PT_BEZIERTO: RenderPath.InsertMoveTo(Coords[i-3]); RenderPath.InsertCurveTo(Coords[i-2],Coords[i-1],Coords[i]); break; case PT_LINETO: RenderPath.InsertMoveTo(Coords[i-1]); RenderPath.InsertLineTo(Coords[i]); break; } IsInCurve = TRUE; } } } } // And if we've snapped to another curve if (SnapToLineOrCurve) { // We are snapping to another curve, so render the curve RenderPath.InsertMoveTo(SnapToCoords[0]); RenderPath.InsertCurveTo(SnapToCoords[1],SnapToCoords[2],SnapToCoords[3]); } // Make sure that there is something to draw if (RenderPath.GetNumCoords()==0) return; // And this bit actually draws the path we have just made RenderRegion* pRegion = DocView::RenderOnTop( NULL, StartSpread, ClippedEOR ); while (pRegion != NULL) { pRegion->SetLineColour( COLOUR_XORNEW ); // Set the line colour pRegion->DrawPath( &RenderPath ); // Draw an EORed version of how the path will turn out pRegion = DocView::GetNextOnTop( &Rect ); // Get the next render region } }

void OpNodePathEditBlob::SetStatusLineHelp (   )  [protected, virtual]

Updates the status line message to reflect the current situation. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 4/1/95 Reimplemented in OpNodePathEditControlBlob, OpNodePathAddEndpoint, and OpReshapeOrAddPoint. Definition at line 3367 of file pathedit.cpp. { String_256 HelpString; if (EndSnapped) HelpString = String_256(_R(IDS_PATHDRAGCREATESHAPE)); else { if (SnapToAnother) HelpString = String_256(_R(IDS_PATHDRAGJOINPATHS)); else HelpString = String_256(_R(IDS_PATHDRAGFINISH)); } GetApplication()->UpdateStatusBarText(&HelpString, FALSE); }

void OpNodePathEditBlob::SnapEndsTogether (  Path *  pEditPath  )  [protected]

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. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (based upon Jim) Date: 17/5/00 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1775 of file pathedit.cpp. { // If ends are snapping, there can only be one selected point on the path... // Get a pointer to the path's verbs PathVerb* Verbs = pEditPath->GetVerbArray(); PathFlags* Flags = pEditPath->GetFlagArray(); INT32 NumCoords = pEditPath->GetNumCoords(); // Find the selected point INT32 pos; for ( pos = 0;pos<NumCoords && !(Flags[pos].IsEndPoint && Flags[pos].IsSelected);pos++); // Now pos is the index of the selected point // This next may seem like a lot of faffing around, but we don't know whether the // selected point is the start or the end of the path, so this code doesn't care // (thus it's not very optimal, but it shouldn't matter). // Move to the start of the edit path INT32 startpos = pos; pEditPath->FindStartOfSubPath(&startpos); // find the end element (might be a curve or a line) pos=startpos; pEditPath->FindEndOfSubPath(&pos); // if the last element is a bezier, pos points at the first control point // so we have to add 2 to move to the endpoint of the curve if (Verbs[pos] == PT_BEZIERTO) pos+=2; // Now simply set the PT_CLOSEFIGURE flag in this verb Verbs[pos] |= PT_CLOSEFIGURE; // make sure the first and last points are selected, along with adjacent ctrl points Flags[pos].IsSelected = TRUE; // if it's a bezier, select previous control point and check state of smooth/rotate bits if ((Verbs[pos] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) { Flags[pos-1].IsSelected = TRUE; // if the smooth flag is not set, clear the rotate flag as well, otherwise // We'll have something that looks like a cusp, but as soon as you drag a control // point, the opposite point will rotate around. if (!Flags[pos-1].IsSmooth) Flags[pos-1].IsRotate = FALSE; // Do the same for the endpoint... if (!Flags[pos].IsSmooth) Flags[pos].IsRotate = FALSE; } pos = startpos; Flags[pos].IsSelected = TRUE; if (Verbs[pos+1] == PT_BEZIERTO) { Flags[pos+1].IsSelected = TRUE; // As above, clear the rotate bit if the smooth bit is clear if (!Flags[pos+1].IsSmooth) Flags[pos+1].IsRotate = FALSE; // Do the same for the endpoint... if (!Flags[pos].IsSmooth) Flags[pos].IsRotate = FALSE; } }

void OpNodePathEditBlob::SnapEndsTogether (   )  [protected]

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. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1692 of file pathedit.cpp. { // If ends are snapping, there can only be one selected point on the path... // Get a pointer to the path's verbs PathVerb* Verbs = EditPath.GetVerbArray(); PathFlags* Flags = EditPath.GetFlagArray(); INT32 NumCoords = EditPath.GetNumCoords(); // Find the selected point INT32 pos; for( pos = 0; pos < NumCoords && !( Flags[pos].IsEndPoint && Flags[pos].IsSelected); pos++ ); // Now pos is the index of the selected point // This next may seem like a lot of faffing around, but we don't know whether the // selected point is the start or the end of the path, so this code doesn't care // (thus it's not very optimal, but it shouldn't matter). // Move to the start of the edit path INT32 startpos = pos; EditPath.FindStartOfSubPath(&startpos); // find the end element (might be a curve or a line) pos=startpos; EditPath.FindEndOfSubPath(&pos); // if the last element is a bezier, pos points at the first control point // so we have to add 2 to move to the endpoint of the curve if (Verbs[pos] == PT_BEZIERTO) pos+=2; // Now simply set the PT_CLOSEFIGURE flag in this verb Verbs[pos] |= PT_CLOSEFIGURE; // make sure the first and last points are selected, along with adjacent ctrl points Flags[pos].IsSelected = TRUE; // if it's a bezier, select previous control point and check state of smooth/rotate bits if ((Verbs[pos] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) { Flags[pos-1].IsSelected = TRUE; // if the smooth flag is not set, clear the rotate flag as well, otherwise // We'll have something that looks like a cusp, but as soon as you drag a control // point, the opposite point will rotate around. if (!Flags[pos-1].IsSmooth) Flags[pos-1].IsRotate = FALSE; // Do the same for the endpoint... if (!Flags[pos].IsSmooth) Flags[pos].IsRotate = FALSE; } pos = startpos; Flags[pos].IsSelected = TRUE; if (Verbs[pos+1] == PT_BEZIERTO) { Flags[pos+1].IsSelected = TRUE; // As above, clear the rotate bit if the smooth bit is clear if (!Flags[pos+1].IsSmooth) Flags[pos+1].IsRotate = FALSE; // Do the same for the endpoint... if (!Flags[pos].IsSmooth) Flags[pos].IsRotate = FALSE; } }

---

Member Data Documentation

DocCoord OpNodePathEditBlob::ConstrainNextPoint [protected]

Definition at line 205 of file pathedit.h.

DocCoord OpNodePathEditBlob::ConstrainPoint [protected]

Definition at line 203 of file pathedit.h.

DocCoord OpNodePathEditBlob::ConstrainPrevPoint [protected]

Definition at line 204 of file pathedit.h.

INT32 OpNodePathEditBlob::CurrentCursorID [protected]

Definition at line 232 of file pathedit.h.

INT32 OpNodePathEditBlob::DragPoint [protected]

Definition at line 241 of file pathedit.h.

BOOL OpNodePathEditBlob::DragStarted [protected]

Definition at line 244 of file pathedit.h.

ObjChangePathEdit OpNodePathEditBlob::EditObjChange [protected]

Definition at line 237 of file pathedit.h.

Path OpNodePathEditBlob::EditPath [protected]

Definition at line 209 of file pathedit.h.

List OpNodePathEditBlob::EditPaths [protected]

Definition at line 213 of file pathedit.h.

BOOL OpNodePathEditBlob::EndSnapped [protected]

Definition at line 221 of file pathedit.h.

DocCoord OpNodePathEditBlob::LastMousePos [protected]

Definition at line 202 of file pathedit.h.

BOOL OpNodePathEditBlob::MultiplePaths [protected]

Definition at line 216 of file pathedit.h.

Cursor* OpNodePathEditBlob::MyCurrentCursor [protected]

Definition at line 231 of file pathedit.h.

List OpNodePathEditBlob::ObjChanges [protected]

Definition at line 239 of file pathedit.h.

NodePath* OpNodePathEditBlob::OriginalPath [protected]

Definition at line 208 of file pathedit.h.

List OpNodePathEditBlob::OriginalPaths [protected]

Definition at line 212 of file pathedit.h.

List OpNodePathEditBlob::PathsDragStarted [protected]

Definition at line 214 of file pathedit.h.

Cursor* OpNodePathEditBlob::pCloseCursor [protected]

Definition at line 229 of file pathedit.h.

Cursor* OpNodePathEditBlob::pCrossHairCursor [protected]

Definition at line 230 of file pathedit.h.

Cursor* OpNodePathEditBlob::pMoveCursor [protected]

Definition at line 228 of file pathedit.h.

BOOL OpNodePathEditBlob::SnapToAnother [protected]

Definition at line 222 of file pathedit.h.

DocCoord OpNodePathEditBlob::SnapToCoords[4] [protected]

Definition at line 226 of file pathedit.h.

INT32 OpNodePathEditBlob::SnapToIndex [protected]

Definition at line 224 of file pathedit.h.

BOOL OpNodePathEditBlob::SnapToLineOrCurve [protected]

Definition at line 225 of file pathedit.h.

NodePath* OpNodePathEditBlob::SnapToPath [protected]

Definition at line 223 of file pathedit.h.

DocCoord OpNodePathEditBlob::StartMousePos [protected]

Definition at line 201 of file pathedit.h.

Spread* OpNodePathEditBlob::StartSpread [protected]

Definition at line 200 of file pathedit.h.

INT32 OpNodePathEditBlob::UpdatePoint [protected]

Definition at line 242 of file pathedit.h.

---

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

• Kernel/pathedit.h (r1785/r1282)
• Kernel/pathedit.cpp (r1785/r1282)

---