OpNodePathAddEndpoint Class Reference

This operation is started by the bezier editing tool when it wants to add a point to the start or end of a particular path. It uses the normal dragging of the base operation, but the action when the operation finishes is different. This class is derived from OpNodePathEditBlob which drags the normal selected points around. More...

#include <pathedit.h>

Inheritance diagram for OpNodePathAddEndpoint:

List of all members.

Public Member Functions
	OpNodePathAddEndpoint ()
void	DoStartDragEdit (NodePath *, DocCoord Anchor, Spread *pSpread, ClickModifiers Mods, INT32 PathIndex, BOOL CurveOrLine, BOOL CloseThePath=FALSE, BOOL SmoothOrCusp=TRUE)
	This is called when a Drag operation has been started when the user wants to add a line or curve element to the start or end of an open subpath. Anchor is the point we are adding (that's where the user clicked) and PathIndex tells us the nearest endpoint in the path. The flag CloseThePath tells the operation if it should close the path and select both the start and endpoints to drag around.
virtual void	DragFinished (DocCoord Pos, ClickModifiers Mods, Spread *pSpread, BOOL Success, BOOL bSolidDrag)
	This routine handles the end of the drag operation when adding an element to the end of a path. It will insert an element into the nodepath, then copy the contents of the temporary path into the nodepath.
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 (DocCoord NewPoint)
	Builds a copy of the path that we can edit, without destroying the original data. This version has to add an extra element which we will be dragging around. It will look at the member variable IsPathClosing to see if the path should be made to close.
BOOL	InsertElement (DocCoord NewPoint, Path *DestPath, INT32 InsPos, INT32 *NewPosition, BOOL RecordUndo=FALSE, NodePath *UndoPath=NULL)
	Inserts a new element (either line or curve, depending in internal flags) into the given path. It will set the selected bit in the element.
BOOL	Complete (DocCoord AddElementPoint)
	This routine does all the actions, with undo, for appending the additional endpoint onto the line, including the preparaty and concluding actions.
BOOL	CompleteThisPath (DocCoord AddElementPoint)
	This routine does all the actions, with undo, for appending the additional endpoint onto the line.
virtual void	SetStatusLineHelp ()
	Updates the status line message to reflect the current situation.
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.
Protected Attributes
INT32	NewPointIndex
INT32	InsertPosition
BOOL	IsPathClosing
BOOL	AddCurveFlag
BOOL	AddSmoothFlag

---

Detailed Description

This operation is started by the bezier editing tool when it wants to add a point to the start or end of a particular path. It uses the normal dragging of the base operation, but the action when the operation finishes is different. This class is derived from OpNodePathEditBlob which drags the normal selected points around.

Author:

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

Date:

14/6/94

Definition at line 318 of file pathedit.h.

---

Constructor & Destructor Documentation

OpNodePathAddEndpoint::OpNodePathAddEndpoint (   )  [inline]

Definition at line 325 of file pathedit.h. : OpNodePathEditBlob() {};

---

Member Function Documentation

BOOL OpNodePathAddEndpoint::BuildEditPath (  DocCoord  NewPoint  )  [protected]

Builds a copy of the path that we can edit, without destroying the original data. This version has to add an extra element which we will be dragging around. It will look at the member variable IsPathClosing to see if the path should be made to close. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 20/6/94 Input: NewPoint is the point that's being inserted 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 Definition at line 4322 of file pathedit.cpp. { // Find out how long the path is INT32 NumCoords = OriginalPath->InkPath.GetNumCoords(); // Ask for a path with 24 free slots in it to be going on with and fail if we do not get it if (!EditPath.Initialise(NumCoords, 24)) return FALSE; // Copy the path data from the original path to the editable one if (!EditPath.CopyPathDataFrom(&(OriginalPath->InkPath))) return FALSE; INT32 LastEndPoint = 0; // The EndPoint before this one INT32 LastLastEndPoint = 0; // The EndPoint before the last EndPoint 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 // Get pointers to the arrays that we are interested in PathFlags* Flags = EditPath.GetFlagArray(); DocCoord* PathCoords = EditPath.GetCoordArray(); PathVerb* PathVerbs = EditPath.GetVerbArray(); // Clear all the selected bits in the path because we're adding a new point INT32 i; for ( i=0; i<NumCoords; i++) { Flags[i].IsSelected = FALSE; } // Now add the new element to the correct place in the path. This we get from the // member variable InsertPosition. if (!InsertElement(NewPoint, &EditPath, InsertPosition, &NewPointIndex)) return FALSE; // Read the length of the path again NumCoords = EditPath.GetNumCoords(); // Get array pointers again, because the paths have moved Flags = EditPath.GetFlagArray(); PathCoords = EditPath.GetCoordArray(); PathVerbs = EditPath.GetVerbArray(); // Now check the IsPathClosing flag to see if we should make the path closed if (IsPathClosing) { // When closing the path, we have to snap the new endpoint to the opposite // endpoint. Thus, we need to know if this element was added to the start or end // of the path. This we can discover by looking at the previous element to // the element at NewPointIndex. If that is a MoveTo then the new point is // at the start, and we should snap the MoveTo coordinate to the coord at // the end of the path, otherwise it's at the end, and we have to snap the // coords of the final element to be the same as the coords of the initial // moveto element. if (PathVerbs[NewPointIndex-1] == PT_MOVETO) { // Snap the MoveTo coords to the coords of the endpoint for (i = NewPointIndex; i < NumCoords && PathVerbs[i] != PT_MOVETO; i++ ); // i now points one element above the endpoint of the path, so decrement i--; // Copy the coords of the endpoint to the moveto PathCoords[NewPointIndex-1] = PathCoords[i]; // And set the closed bit PathVerbs[i] |= PT_CLOSEFIGURE; // And select the other endpoint so it drags as well Flags[i].IsSelected = TRUE; } else { // Snap the endpoint coords to those of the moveto at the start, but first // set the CloseFigure flag in the verb. INT32 EndCoord = NewPointIndex; if ((PathVerbs[NewPointIndex] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) EndCoord = NewPointIndex + 2; PathVerbs[EndCoord] |= PT_CLOSEFIGURE; // scan back to the start of the path i = EndCoord; do { i--; } while (PathVerbs[i] != PT_MOVETO); PathCoords[EndCoord] = PathCoords[i]; // And select the moveto as well Flags[i].IsSelected = TRUE; } } EditPath.SmoothCurve(); // Go though all the coords, with scary amounts of looking back and forwards for (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].IsSmooth) SetNextNextEndPoint = TRUE; } // If its selected, then its renderable if (Flags[i].IsSelected) { Flags[i].NeedToRender = TRUE; Flags[LastEndPoint].NeedToRender = TRUE; // If the smooth flag is set then the re-draw area goes further if (Flags[LastEndPoint].IsSmooth) Flags[LastLastEndPoint].NeedToRender = TRUE; // Set the flag for the next endpoint SetNextEndPoint = TRUE; } // Make a note of the last endpoint, incase the next one is selected LastLastEndPoint = LastEndPoint; LastEndPoint = i; } } // It worked return TRUE; }

BOOL OpNodePathAddEndpoint::Complete (  DocCoord  AddElementPoint  )  [protected]

This routine does all the actions, with undo, for appending the additional endpoint onto the line, including the preparaty and concluding actions. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> - From Jim code Date: 2/6/95 Parameters: AddElementPoint  - the point at which the mouse finished [INPUTS] -  [OUTPUTS] Returns: TRUE/FALSE for success/failure Errors: - See also: OpNodePathAddEndpoint::CompleteThisPath Definition at line 4539 of file pathedit.cpp. { BeginSlowJob(); BOOL ok = TRUE; // Start the sel operation, removes blobs at start and end if (ok) ok = DoStartSelOp(TRUE,TRUE); // Create and send a change message about this path edit so parents can refuse ObjChangeFlags cFlags; cFlags.TransformNode = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,OriginalPath,this); if (ok) { if (!OriginalPath->AllowOp(&ObjChange, TRUE)) { FailAndExecute(); return TRUE; } } // Do all the work involved in closing the path if (ok) ok = CompleteThisPath(AddElementPoint); // Inform all the parents of this node that it has been changed. if (ok) { ObjChange.Define(OBJCHANGE_FINISHED,ObjChangeFlags(),OriginalPath,this); ok = UpdateChangedNodes(&ObjChange); } return ok; }

BOOL OpNodePathAddEndpoint::CompleteThisPath (  DocCoord  AddElementPoint  )  [protected]

This routine does all the actions, with undo, for appending the additional endpoint onto the line. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> - From Jim code Date: 19/12/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE/FALSE for success/failure Errors: FailAndExecute will have been called in the event of a failure See also: OpNodePathAddEndpoint::Complete Definition at line 4590 of file pathedit.cpp. { BOOL ok = TRUE; // Force a re-draw of the place where the path used to be if (ok) ok = (RecalcBoundsAction::DoRecalc(this, &UndoActions, OriginalPath) != AC_FAIL); // // Store the paths sub-selection state // if (ok) // ok = (StorePathSubSelStateAction::DoRecord(this, &UndoActions, &OriginalPath->InkPath) != AC_FAIL); // Snap the endpoint that we are dragging with the other end of the sub-path if (ok && EndSnapped) SnapEndsTogether(); // First thing to do is add a point into the path at the same place we added it // for the temporary path. if (ok) ok = InsertElement(AddElementPoint, &(OriginalPath->InkPath), InsertPosition, &NewPointIndex, TRUE, OriginalPath); // Copy the edited path back over the original path if (ok) ok = CopyEditedPathBack(); if (IsPathClosing) EndSnapped = TRUE; // If the ends snapped, set the filled bit on the path if (ok) ok = FillPathIfEndsSnapped() && JoinWithOtherPath() ; if (ok) { // Update the bounding rectangle OriginalPath->InvalidateBoundingRect(); // Announce this bounds change to the world GetApplication()->FindSelection()->UpdateBounds(); // Force a redraw of the place where the path is now. ok = (RecordBoundsAction::DoRecord(this, &UndoActions, OriginalPath) != AC_FAIL); } // DY 9/99 are we editing a blend on a curve? If so we may wish to change the number of // steps in the blend NodeGroup* pParent = GetGroupParentOfCurve(); if (pParent != NULL) { if (pParent->IS_KIND_OF(NodeBlend)) { if (ok) InsertChangeBlendStepsAction((NodeBlend*)pParent); } } ObjChangeFlags cFlags(FALSE,TRUE); ObjChangeParam ObjChange(OBJCHANGE_FINISHED,cFlags,NULL,this); ok = UpdateChangedNodes(&ObjChange); return ok; }

void OpNodePathAddEndpoint::DoStartDragEdit (  NodePath *  OrigPath, DocCoord  Anchor, Spread *  pSpread, ClickModifiers  Mods, INT32  PathIndex, BOOL  CurveOrLine, BOOL  CloseThePath = FALSE, BOOL  SmoothOrCusp = TRUE )

This is called when a Drag operation has been started when the user wants to add a line or curve element to the start or end of an open subpath. Anchor is the point we are adding (that's where the user clicked) and PathIndex tells us the nearest endpoint in the path. The flag CloseThePath tells the operation if it should close the path and select both the start and endpoints to drag around. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> (via Rik) Date: 17/6/94 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 PathIndex is the index into the path of the element to which we're adding CurveOrLine is TRUE if we're adding a curve segment, FALSE for a line CloseThePath is true if this click is to close the path SmoothOrCusp is TRUE if the new point is smooth, FALSE if it is a cusp. Definition at line 4213 of file pathedit.cpp. { // Remember the index of the point to which we're adding this element InsertPosition = PathIndex; OriginalPath = OrigPath; // We had better take a note of the starting point of the drag StartMousePos = Anchor; LastMousePos = Anchor; StartSpread = pSpread; IsPathClosing = CloseThePath; AddCurveFlag = CurveOrLine; AddSmoothFlag = SmoothOrCusp; // Now work out the position to constrain to. PathFlags* Flags = OrigPath->InkPath.GetFlagArray(); PathVerb* Verbs = OrigPath->InkPath.GetVerbArray(); DocCoord* Coords = OrigPath->InkPath.GetCoordArray(); if (Verbs[InsertPosition] == PT_MOVETO) ConstrainPoint = Coords[InsertPosition]; else { INT32 Temp = InsertPosition; while (!Flags[Temp].IsEndPoint && (Temp < OrigPath->InkPath.GetNumCoords())) Temp++; ConstrainPoint = Coords[Temp]; } ConstrainPrevPoint = ConstrainPoint; ConstrainNextPoint = ConstrainPoint; // Constrain the anchor and snap it to the grid ERROR3IF(ConstrainPoint == DocCoord(-1,-1),"DragConstrainPoint wasn't set"); if (Mods.Constrain) DocView::ConstrainToAngle(ConstrainPoint, &LastMousePos); DocView::SnapCurrent(pSpread, &LastMousePos); BOOL ok = TRUE; // We also need to make a version of the path that we can change if (ok) ok = BuildEditPath(LastMousePos); UpdatePoint = DragPoint; // If the path is closing we don't want to start a drag as it leads to complications with snapping to ourselves if (CloseThePath) { if (ok) ok = Complete(StartMousePos); if (!ok) { InformError(); FailAndExecute(); } End(); return; } else { // Create the drag cursors if (ok) ok = CreateCursors(); // Render the bits of the path that are different if (ok) { DocRect EditPathBBox = EditPath.GetBoundingRect(); // RenderPathEditBlobs(EditPathBBox, pSpread); // And tell the Dragging system that we need drags to happen ok = StartDrag(DRAGTYPE_AUTOSCROLL, &EditPathBBox, &LastMousePos); } if (ok) ChangeCursor(pCrossHairCursor); } if (!ok) { InformError(); FailAndExecute(); End(); } }

void OpNodePathAddEndpoint::DragFinished (  DocCoord  Pos, ClickModifiers  Mods, Spread *  pSpread, BOOL  Success, BOOL  bSolidDrag )  [virtual]

This routine handles the end of the drag operation when adding an element to the end of a path. It will insert an element into the nodepath, then copy the contents of the temporary path into the nodepath. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 22/6/94 Parameters: Pos  = mouse position at end of drag [INPUTS] Mods = click modifiers (Adjust, etc.) pSpread points at the spread the drag finished in Success indicates whether the drag was aborted with Escape -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from OpNodePathEditBlob. Definition at line 4499 of file pathedit.cpp. { RenderPathEditBlobs( EditPath.GetBoundingRect(), StartSpread ); EndDrag(); DestroyCursors(); if ( Success ) { if (!Complete(Pos)) { InformError(); FailAndExecute(); } } else FailAndExecute(); End(); }

BOOL OpNodePathAddEndpoint::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 - the last changed index pAttrBrush - the attribute to change outputs: - returns: TRUE if all went well Notes: Derived version does not do the remove points (as we are only adding here). Instead it makes itself some new data and inserts it at the insert point. Reimplemented from OpNodePathEditBlob. Definition at line 4676 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 // what we basically want to do here is to make a new section of data and insert ot // either at the beginning or the end MILLIPOINT SectionLength = GetLengthOfPathSection(&EditPath, FirstIndex, LastIndex); if (SectionLength == -1) // something went wrong return FALSE; // work out how many items we need INT32 NumItems = SectionLength / MIN_BRUSH_SPACING; // make a new CDistanceSampler CDistanceSampler* pNewSampler = new CDistanceSampler; if (pNewSampler == NULL) return FALSE; if (!pNewSampler->InitialiseData(NumItems)) // initialise the array { delete pNewSampler; return FALSE; } // we are inserting either at the beginning or the end INT32 InsertIndex = 0; if (FirstIndex != 0) InsertIndex = LastIndex; // Get the distance to the insert index DocCoord* pCoord = EditPath.GetCoordArray(); if (pCoord == NULL) { delete pNewSampler; return FALSE; } DocCoord InsertCoord = pCoord[InsertIndex]; MILLIPOINT InsertDistance = -1; if (!EditPath.GetDistanceToPoint(InsertCoord, &InsertDistance)) { delete pNewSampler; return FALSE; } // we want to get the pressure at this distance UINT32 InternalIndex = pDistSamp->GetInternalIndexFromDistance(InsertDistance); if (InternalIndex == (UINT32)-1) // we're over the end! InternalIndex = UINT32(pDistSamp->GetNumItems() - 1); pDistSamp->SetRetrievalSampleRate(1.0); CSampleItem TheItem; if (!pDistSamp->GetAt(InternalIndex, &TheItem)) { ERROR3("Unable to retrieve pressure item in OpNodePathAddEndpoint::EditBrushAttribute"); delete pNewSampler; return FALSE; } // whew, now we just have to fill up our new sampler with that item BOOL ok = pNewSampler->SetAt(0, TheItem); while (ok) { ok = pNewSampler->SetNext(TheItem); TRACEUSER( "Diccon", _T("Adding item pressure = %d\n"), TheItem.m_Pressure); } // now insert our new points into the attribute AddPressurePointsAction* pAddAction; // find out how many points we're inserting size_t NumAddPoints = pNewSampler->GetNumItems() + 1; if (AddPressurePointsAction::Init(this, &UndoActions, pAttrBrush, pNewSampler, InternalIndex, NumAddPoints, &pAddAction) == AC_FAIL) { delete pNewSampler; return FALSE; } return TRUE; }

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

Find out the state of the operation at the specific time. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/94 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 from OpNodePathEditBlob. Reimplemented in OpCloseNodePaths. Definition at line 4151 of file pathedit.cpp. { OpState Blobby; return Blobby; }

BOOL OpNodePathAddEndpoint::Init (  void   )  [static]

Adds the operation to the list of all known operations. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/94 Returns: TRUE if all went OK, False otherwise Reimplemented from OpNodePathEditBlob. Reimplemented in OpCloseNodePaths. Definition at line 4124 of file pathedit.cpp. { return (RegisterOpDescriptor( 0, _R(IDS_NODEPATH_ADDENDPOINT), CC_RUNTIME_CLASS(OpNodePathAddEndpoint), OPTOKEN_ADDENDPOINT, OpNodePathAddEndpoint::GetState, 0, // help ID _R(IDBBL_NODEPATHOP), 0 ) ); // bitmap ID }

BOOL OpNodePathAddEndpoint::InsertElement (  DocCoord  NewPoint, Path *  DestPath, INT32  InsPos, INT32 *  NewPosition, BOOL  RecordUndo = FALSE, NodePath *  UndoPath = NULL )  [protected]

Inserts a new element (either line or curve, depending in internal flags) into the given path. It will set the selected bit in the element. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 22/6/94 Parameters: NewPoint  is the point that should be added [INPUTS] DestPath is the path to which the element should be added InsPos is the index of the element which we're adding to (the first or last element in the path). RecordUndo is a flag telling the routine to build undo information (default FALSE) UndoPath is the path that's being operated on, for the undo recording NewPosition  is the index of the element [OUTPUTS] Also sets DragPoint Returns: BOOL indicating success or failure NOTE: This routine will move the path data around so any pointers to the arrays in the path should be re-read after any call to this routine. Returns: Errors: If no memory available to insert the point See also: - Definition at line 4966 of file pathedit.cpp. { Action* UnAction; // pointer to action that might be created ActionCode Act; // Action code that might be used // There are two possibilities here - that we're at the start of a path, or at the // end. The end case is easier - we just add an element after the end element. For a // point added to the start, we have to change the MoveToCoordinates to be the point // clicked, and add an element which goes from there to the original MoveTo position. // If we add a CurveTo element, we have to smooth the coordinates before the drag starts. DestPath->SetPathPosition(InsPos); if (DestPath->GetVerb() == PT_MOVETO) { DocCoord tempcoord = DestPath->GetEndPoint(); // Get coord of moveto DestPath->FindNext(); // Skip to after the MoveTo *NewPosition = DestPath->GetPathPosition(); // remember index of point we're inserting // If we're undoing, create an action for this insert if (RecordUndo) { if (AddCurveFlag) Act = RemovePathElementAction::Init(this, &UndoActions, 3,*NewPosition, (Action**)(&UnAction)); else Act = RemovePathElementAction::Init(this, &UndoActions, 1,*NewPosition, (Action**)(&UnAction)); if (Act == AC_FAIL) return FALSE; ((RemovePathElementAction*)UnAction)->RecordPath(UndoPath); } PathFlags tempflags; if (AddSmoothFlag) { tempflags.IsSmooth = TRUE; tempflags.IsRotate = TRUE; } else { tempflags.IsSmooth = TRUE; tempflags.IsRotate = FALSE; } if (AddCurveFlag) { // We insert a curve element with all three coords the same, since // they will get smoothed if (!DestPath->InsertCurveTo(tempcoord,tempcoord,tempcoord,&tempflags)) return FALSE; } else { if (!DestPath->InsertLineTo(tempcoord, &tempflags)) return FALSE; } // Read the pointers to the arrays. PathFlags* Flags = DestPath->GetFlagArray(); DocCoord* PathCoords = DestPath->GetCoordArray(); PathVerb* PathVerbs = DestPath->GetVerbArray(); // Set the selected bit on the point we have to move (the MoveTo) if (RecordUndo) { DoChangeSelection(UndoPath, InsPos, TRUE); if (AddCurveFlag) DoChangeSelection(UndoPath, InsPos+1, TRUE); } else { Flags[InsPos].IsSelected = TRUE; if (AddCurveFlag) Flags[InsPos+1].IsSelected = TRUE; } // Now to adjust the MoveTo coordinate, recording undo info if necessary if (RecordUndo) { Act = ModifyElementAction::Init(this, &UndoActions, PathVerbs[InsPos], Flags[InsPos], PathCoords[InsPos], InsPos, UndoPath, (Action**)&UnAction); } PathCoords[InsPos] = NewPoint; // Make it smooth/rotate Flags[InsPos].IsSmooth = TRUE; Flags[InsPos].IsRotate = TRUE; DragPoint = InsPos; // Now smooth the path // DestPath->SmoothCurve(); } else { // Adding to the end of a path is easier - insert an element after this one DestPath->FindNext(); *NewPosition = DestPath->GetPathPosition(); // If we're undoing, create an action for this insert if (RecordUndo) { if (AddCurveFlag) Act = RemovePathElementAction::Init(this, &UndoActions, 3,*NewPosition, (Action**)(&UnAction)); else Act = RemovePathElementAction::Init(this, &UndoActions, 1,*NewPosition, (Action**)(&UnAction)); if (Act == AC_FAIL) return FALSE; ((RemovePathElementAction*)UnAction)->RecordPath(UndoPath); } PathFlags tempflags; if (AddSmoothFlag) { tempflags.IsSmooth = TRUE; tempflags.IsRotate = TRUE; } else { tempflags.IsSmooth = TRUE; tempflags.IsRotate = FALSE; } if (AddCurveFlag) { if (!DestPath->InsertCurveTo(NewPoint,NewPoint,NewPoint,&tempflags)) return FALSE; } else { if (!DestPath->InsertLineTo(NewPoint,&tempflags)) return FALSE; } // Re-read the pointers to the arrays, in case they've changed PathFlags* Flags = DestPath->GetFlagArray(); // DocCoord* PathCoords = DestPath->GetCoordArray(); // PathVerb* PathVerbs = DestPath->GetVerbArray(); if (AddCurveFlag) { if (RecordUndo) { DoChangeSelection(UndoPath,(*NewPosition)+2, TRUE); // Select the endpoint DoChangeSelection(UndoPath, (*NewPosition)+1, TRUE); // Select the control point as well } else { Flags[(*NewPosition)+2].IsSelected = TRUE; Flags[(*NewPosition)+1].IsSelected = TRUE; } DragPoint = (*NewPosition)+2; // DestPath->SmoothCurve(); } else { if (RecordUndo) DoChangeSelection(UndoPath,(*NewPosition), TRUE); else Flags[(*NewPosition)].IsSelected = TRUE; DragPoint = *NewPosition; } } return TRUE; }

void OpNodePathAddEndpoint::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 from OpNodePathEditBlob. Definition at line 4167 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_PATHDRAGADDSEGMENT)); } GetApplication()->UpdateStatusBarText(&HelpString, FALSE); }

---

Member Data Documentation

BOOL OpNodePathAddEndpoint::AddCurveFlag [protected]

Definition at line 360 of file pathedit.h.

BOOL OpNodePathAddEndpoint::AddSmoothFlag [protected]

Definition at line 361 of file pathedit.h.

INT32 OpNodePathAddEndpoint::InsertPosition [protected]

Definition at line 358 of file pathedit.h.

BOOL OpNodePathAddEndpoint::IsPathClosing [protected]

Definition at line 359 of file pathedit.h.

INT32 OpNodePathAddEndpoint::NewPointIndex [protected]

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

---