OpReshapeOrAddPoint Class Reference

This operation serves two purposes - while dragging, it will reshape a bezier segment, changing the path on ending the drag. However, if the drag is released immediately after it is initiated, a point is added to the bezier curve (or line) at the click point. More...

#include <pathedit.h>

Inheritance diagram for OpReshapeOrAddPoint:

List of all members.

Public Member Functions
	OpReshapeOrAddPoint ()
	Constructor to initialise the members variables.
void	DoStartDragEdit (NodePath *, DocCoord Anchor, Spread *pSpread, INT32, double)
	This is called when a Drag operation has been started on the middle of a path. It will try and reshape the curve as it's dragging according to the maths in the function RecalculatePath.
virtual void	DragPointerMove (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, 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.
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. If the dragged segment is a line then it is converted to a curve segment Also sets the NeedToRenderFlags for the EOR rendering during the drag. The parts of the path need to be rendered during the drag is the segment being dragged and the next and previous segmetns if the rotate flags are on the endpoints at each end of the dragged segment.
void	RecalculatePath (DocCoord Offset)
	Will reshape a curve segment using a bit of voodoo maths.
BOOL	DragFinishedAddPoint ()
	This is called when a drag on a path segment finishes and we want to add a new point on the segment.
BOOL	DragFinishedReshapeLine ()
	This is called when a drag on a path line segment finishes and we want to reshape it.
void	SetStatusLineHelp ()
	For getting a message for the status line during drag operations.
Protected Attributes
INT32	Index
double	paramdist
DocCoord	OrigControl1
DocCoord	OrigControl2
DocCoord	FurthestPoint
BOOL	HaveMadeCurve

---

Detailed Description

This operation serves two purposes - while dragging, it will reshape a bezier segment, changing the path on ending the drag. However, if the drag is released immediately after it is initiated, a point is added to the bezier curve (or line) at the click point.

Author:

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

Date:

30/8/94

Definition at line 404 of file pathedit.h.

---

Constructor & Destructor Documentation

OpReshapeOrAddPoint::OpReshapeOrAddPoint (   )

Constructor to initialise the members variables. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 18/03/95 Definition at line 8539 of file pathedit.cpp. : OpNodePathEditBlob() { Index = -1; paramdist = -1; HaveMadeCurve = FALSE; };

---

Member Function Documentation

BOOL OpReshapeOrAddPoint::BuildEditPath (   )  [protected]

Builds a copy of the path that we can edit, without destroying the original data. If the dragged segment is a line then it is converted to a curve segment Also sets the NeedToRenderFlags for the EOR rendering during the drag. The parts of the path need to be rendered during the drag is the segment being dragged and the next and previous segmetns if the rotate flags are on the endpoints at each end of the dragged segment. 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 from OpNodePathEditBlob. Definition at line 8314 of file pathedit.cpp. { // Make a copy of the path UINT32 NumCoords = OriginalPath->InkPath.GetNumCoords(); if (!EditPath.Initialise(NumCoords, 24)) return FALSE; if (!EditPath.CopyPathDataFrom(&(OriginalPath->InkPath))) return FALSE; // If the drag segment is a line then convert it to a curve PathFlags* Flags; PathVerb* Verbs; DocCoord* Coords; EditPath.GetPathArrays(&Verbs, &Coords, &Flags); if ((Verbs[Index] & ~PT_CLOSEFIGURE) == PT_LINETO) { const DocCoord Start = Coords[Index-1]; const DocCoord End = Coords[Index]; BOOL IsClosed = OriginalPath->InkPath.GetVerbArray()[Index] & PT_CLOSEFIGURE; BOOL IsSelected = OriginalPath->InkPath.GetFlagArray()[Index].IsSelected; // Insert a curve segment DocCoord OneThird((Start.x+(End.x-Start.x)/3), (Start.y+(End.y-Start.y)/3) ); DocCoord TwoThird((End.x+(Start.x-End.x)/3), (End.y+(Start.y-End.y)/3) ); EditPath.SetPathPosition(Index); if (!EditPath.InsertCurveTo(OneThird, TwoThird, End)) return FALSE; // Remove the line segment if (!EditPath.DeleteSection(Index+3, 1)) return FALSE; // Copy the selection and closure state of the LineTo EditPath.GetPathArrays(&Verbs, &Coords, &Flags); Flags[Index+2].IsSelected = IsSelected; if (IsClosed) Verbs[Index+2] = Verbs[Index+2] | PT_CLOSEFIGURE; // We need to recalc paramdist now HaveMadeCurve = TRUE; INT32 tempel; EditPath.SqrDistanceToPoint(StartMousePos, &tempel, &paramdist); } // Clear the NeedToRender flags EditPath.ClearNeedToRender(); // Set the render flag on this segment EditPath.GetPathArrays(&Verbs, &Coords, &Flags); if ((Verbs[Index] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) Flags[Index+2].NeedToRender = TRUE; else Flags[Index].NeedToRender = TRUE; // Clear the smooth bit on the endpoints of this curve Flags[Index-1].IsSmooth = FALSE; Flags[Index+2].IsSmooth = FALSE; // Check before setting the NeedToRender on the adjacent segments as well if ((Verbs[Index] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) { INT32 Opposite = EditPath.FindOppositeControlPoint(Index); if ( (Opposite>=0) && (Flags[Opposite+1].IsRotate || Flags[Index-1].IsRotate) ) Flags[Opposite+1].NeedToRender = TRUE; Opposite = EditPath.FindOppositeControlPoint(Index+1); if ( (Opposite>=0) && (Flags[Opposite-1].IsRotate || Flags[Index+2].IsRotate) ) Flags[Opposite+2].NeedToRender = TRUE; } // It worked return TRUE; }

void OpReshapeOrAddPoint::DoStartDragEdit (  NodePath *  OrigPath, DocCoord  Anchor, Spread *  pSpread, INT32  SegmentIndex, double  pdist )

This is called when a Drag operation has been started on the middle of a path. It will try and reshape the curve as it's dragging according to the maths in the function RecalculatePath. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/93 Parameters: OrigPath  - The original Node path object [INPUTS] Anchor - The position of the mouse at the start of the Drag pSpread - the spread that the drag started on ControlIndex - The Coord number of the control point that we are dragging this is the index of the first element of the segment plus 1 pdist - parametric distance along the curve we're dragging from (0 to 1) See also: OpReshapeOrAddPoint::RecalculatePath Definition at line 7869 of file pathedit.cpp. { // We had better take a note of the starting point of the drag LastMousePos = Anchor; StartMousePos = Anchor; FurthestPoint = Anchor; StartSpread = pSpread; OriginalPath = OrigPath; Index = SegmentIndex; paramdist = pdist; CreateCursors(); // We also need to make a version of the path that we can change if (!BuildEditPath()) { // Failed to get the memory that we needed to copy the path, so moan TRACEUSER( "Jim", _T("Failed to get the mem to copy the path data for editing\n") ); // Inform the person doing the clicking that life is not looking so good InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); End(); return; } // Render the bits of the path that are different DocRect EditPathBBox = EditPath.GetBoundingRect(); RenderPathEditBlobs(EditPathBBox, pSpread); // Record the original positions of the two control points DocCoord* Coords = EditPath.GetCoordArray(); PathVerb* Verbs = EditPath.GetVerbArray(); if (Verbs[Index] == PT_BEZIERTO) { OrigControl1 = Coords[Index]; OrigControl2 = Coords[Index+1]; } else { ERROR3("Control Point wasn't a control point!"); } // And tell the Dragging system that we need drags to happen StartDrag(DRAGTYPE_AUTOSCROLL, &EditPathBBox, &LastMousePos); SetStatusLineHelp(); }

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

This is called when a drag operation finishes. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 30/8/94 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 OpNodePathEditBlob. Definition at line 7987 of file pathedit.cpp. { RenderPathEditBlobs( EditPath.GetBoundingRect(), StartSpread ); EndDrag(); DestroyCursors(); BeginSlowJob(); BOOL Worked = TRUE; if ( Success ) { ObjChangeFlags cFlags; cFlags.TransformNode = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,OriginalPath,this); Worked = DoStartSelOp(TRUE,TRUE) ; // Create and send a change message about this path edit if (Worked) { Worked = OriginalPath->AllowOp(&ObjChange) ; } // If the furthest mouse position is close to the start, add a point instead if (Worked) { // // Store the paths sub-selection state // if (Worked) // Worked = (StorePathSubSelStateAction::DoRecord(this, &UndoActions, &OriginalPath->InkPath) != AC_FAIL); // Due to popular request, I've changed this test so that moving by even a pixel // will reshape the line, so a single click has to be a single click to add a // point. if (StartMousePos == FurthestPoint) { Worked = DragFinishedAddPoint(); } else { BOOL Optimise = CopyNeedToRenderFlags() && !(EndSnapped || SnapToAnother); // 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. if (!IS_A(OriginalPath,NodePath)) Optimise = FALSE; // Force a re-draw of the place where the path used to be if (RecalcBoundsAction::DoRecalc(this, &UndoActions, OriginalPath, Optimise) == AC_FAIL) Worked = FALSE; if (Worked && HaveMadeCurve) { Worked = DragFinishedReshapeLine(); } if (Worked) { // The drag was a real drag (man) so replace the edited path // Go and copy the edited path back over the original path if (!CopyEditedPathBack()) { // if (IsUserName("Jim")) TRACE( _T("Failed to copy the edited path back to the original") ); Error::SetError( _R(IDS_OUT_OF_MEMORY) ); Worked = FALSE; } } // Recalculate the path's bounding box OriginalPath->InvalidateBoundingRect(); // tell the world that something in the selection has changed // so that selection bounds are updated GetApplication()->UpdateSelection(); // Force a redraw of the place where the path is now. if (Worked && (RecordBoundsAction::DoRecord(this, &UndoActions, OriginalPath, Optimise) == AC_FAIL)) { Worked = FALSE; } } } // Inform all the parents of this node that it has been changed. if (Worked) { ObjChange.Define(OBJCHANGE_FINISHED,cFlags,OriginalPath,this); Worked = UpdateChangedNodes(&ObjChange); } } else FailAndExecute(); if (!Worked) { // InformError(); FailAndExecute(); } End(); }

BOOL OpReshapeOrAddPoint::DragFinishedAddPoint (   )  [protected]

This is called when a drag on a path segment finishes and we want to add a new point on the segment. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/95 Parameters: -  [INPUTS] Changes  OriginalPath, adding a point when the drag started, creating two new [OUTPUTS] path segments, one either side. Also builds undo information into the operation history. Returns: TRUE/FALSE for success/failure. See also: OpReshapeOrAddPoint::DragFinished Definition at line 8111 of file pathedit.cpp. { // First, find the closest point, the element it's at, and go from there INT32 SplitElement = 0; PathVerb NewVerbs[6]; DocCoord NewCoords[6]; PathFlags NewFlags[6]; for (INT32 j=0;j<6;j++) { NewCoords[j].x = 0; NewCoords[j].y = 0; } UINT32 NumElements = 0; if (OriginalPath->InkPath.SplitAtPoint(StartMousePos, &SplitElement, &NumElements, NewVerbs, NewCoords)) { // The path was split, so we know where, and how, so let's party on the path PathVerb* Verbs = NULL; PathFlags* Flags = NULL; DocCoord* Coords = NULL; OriginalPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); ERROR2IF((Verbs == NULL) || (Flags == NULL) || (Coords == NULL), FALSE, "Path array pointer was NULL"); // UINT32 NumCoords = OriginalPath->InkPath.GetNumCoords(); // Before we go any further we want to deselect all current points // for (UINT32 loop = 0; loop < NumCoords; loop++) // { // if (!DoChangeSelection(OriginalPath, loop, FALSE)) // return FALSE; // } OriginalPath->InkPath.ClearSubSelection(); INT32 NumToChange = 0; // We're adding something, either a line or curve - check which if ((Verbs[SplitElement] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) { // Adding a curve - number to change = 6 NumToChange = 6; // Initialise the flags appropriately INT32 i; for (i=0;i<3;i++) { NewFlags[i] = Flags[SplitElement+i]; NewFlags[i+3] = Flags[SplitElement+i]; } for (i = 1; i <=3; i++) { NewFlags[i].IsSelected = TRUE; NewFlags[i].IsSmooth = FALSE; NewFlags[i].IsRotate = TRUE; } NewFlags[0].IsSmooth = Flags[SplitElement].IsSmooth; NewFlags[0].IsRotate = Flags[SplitElement].IsRotate; NewFlags[4].IsSmooth = Flags[SplitElement+1].IsSmooth; NewFlags[4].IsRotate = Flags[SplitElement+1].IsRotate; NewFlags[5].IsSmooth = Flags[SplitElement+2].IsSmooth; NewFlags[5].IsRotate = Flags[SplitElement+2].IsRotate; if (Verbs[SplitElement+2] & PT_CLOSEFIGURE) NewVerbs[5] |= PT_CLOSEFIGURE; } else { NumToChange = 2; NewFlags[0] = NewFlags[1] = Flags[SplitElement]; NewFlags[0].IsSmooth = NewFlags[0].IsRotate = FALSE; NewFlags[0].IsSelected = TRUE; if (Verbs[SplitElement] & PT_CLOSEFIGURE) NewVerbs[1] |= PT_CLOSEFIGURE; } // NumToChange is the number of elements that want changing Action* UnAction; ActionCode Act = RemovePathElementAction::Init(this, &UndoActions, NumToChange / 2, SplitElement, (Action**)(&UnAction)); if (Act == AC_FAIL) { return FALSE; } ((RemovePathElementAction*)UnAction)->RecordPath(OriginalPath); PathFlags tempflags; tempflags.IsSmooth = TRUE; tempflags.IsRotate = TRUE; tempflags.IsSelected = TRUE; if (NumToChange == 6) { OriginalPath->InkPath.SetPathPosition(SplitElement); if (!(OriginalPath->InkPath.InsertCurveTo(NewCoords[0], NewCoords[1], NewCoords[2], &tempflags))) { return FALSE; } } else { if (!(OriginalPath->InkPath.InsertLineTo(NewCoords[0], &tempflags))) { return FALSE; } } // Refresh the path pointers in case things have moved OriginalPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); // Build an action to record the changes we're about to make to the path ModifyPathAction* ModAction; Act = ModifyPathAction::Init(this, &UndoActions, NumToChange, (Action**)(&ModAction)); if (Act == AC_FAIL) { return FALSE; } if ((Act!=AC_NORECORD) && (ModAction!=NULL)) { PathVerb* ChangedVerbs; PathFlags* ChangedFlags; DocCoord* ChangedCoords; INT32* ChangedIndices; ALLOC_WITH_FAIL(ChangedVerbs, (PathVerb*) CCMalloc(NumToChange * sizeof(PathVerb)), this); ALLOC_WITH_FAIL(ChangedFlags, (PathFlags*) CCMalloc(NumToChange* sizeof(PathFlags)), this); ALLOC_WITH_FAIL(ChangedCoords, (DocCoord*) CCMalloc(NumToChange* sizeof(DocCoord)), this); ALLOC_WITH_FAIL(ChangedIndices, (INT32*) CCMalloc(NumToChange* sizeof(INT32)), this); if (!ChangedVerbs || !ChangedFlags || !ChangedCoords || !ChangedIndices) { if (ChangedVerbs) CCFree(ChangedVerbs); if (ChangedFlags) CCFree(ChangedFlags); if (ChangedCoords) CCFree(ChangedCoords); if (ChangedIndices) CCFree(ChangedIndices); return FALSE; } // Now record the arrays... for (INT32 i=0; i<NumToChange; i++) { ChangedIndices[i] = SplitElement+i; ChangedVerbs[i] = Verbs[SplitElement+i]; ChangedFlags[i] = Flags[SplitElement+i]; ChangedCoords[i] = Coords[SplitElement+i]; } ModAction->StoreArrays(ChangedVerbs, ChangedFlags, ChangedCoords, ChangedIndices, OriginalPath); } // Reread the pointers, in case they've changed OriginalPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); // Now that the undo rigmarole has been done, let's change the path for (INT32 i=0; i<NumToChange; i++) { Verbs[SplitElement+i] = NewVerbs[i]; Flags[SplitElement+i] = NewFlags[i]; Coords[SplitElement+i] = NewCoords[i]; } GetApplication()->FindSelection()->UpdateBounds(); } else { return FALSE; } return TRUE; }

BOOL OpReshapeOrAddPoint::DragFinishedReshapeLine (   )  [protected]

This is called when a drag on a path line segment finishes and we want to reshape it. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/95 Parameters: -  [INPUTS] Changes  OriginalPath, converting the dragged line segment into a curve, then [OUTPUTS] reshaping it as required by the drag. Returns: TRUE/FALSE for success/failure. See also: OpReshapeOrAddPoint::DragFinished, OpMakeSegmentsCurves::CarryOut Definition at line 8293 of file pathedit.cpp. { return OpMakeSegmentsCurves::CarryOut(Index, Index-1, OriginalPath, this, &UndoActions); }

void OpReshapeOrAddPoint::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 pSpread - the spread that the cursor is over now See also: ClickModifiers Reimplemented from OpNodePathEditBlob. Definition at line 7935 of file pathedit.cpp. { EndSnapped = FALSE; // Always false in this operation // 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); // Now snap it to the current grid DocView::SnapCurrent(StartSpread,&PointerPos); // Rub out the old EORed version of the path RenderPathEditBlobs( EditPath.GetBoundingRect(), StartSpread ); // 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 - StartMousePos.x; Offset.y = PointerPos.y - StartMousePos.y; RecalculatePath( Offset ); // Compare this point with the furthest point so far if (PointerPos.Distance(StartMousePos) > FurthestPoint.Distance(StartMousePos)) { FurthestPoint.x = PointerPos.x; FurthestPoint.y = PointerPos.y; } // Draw in the new version of the path and update the Last Mouse Position LastMousePos = PointerPos; RenderPathEditBlobs( EditPath.GetBoundingRect(), StartSpread ); SetStatusLineHelp(); }

OpState OpReshapeOrAddPoint::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 from OpNodePathEditBlob. Definition at line 8562 of file pathedit.cpp. { OpState Blobby; return Blobby; }

BOOL OpReshapeOrAddPoint::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 OpNodePathEditBlob. Definition at line 8513 of file pathedit.cpp. { return (RegisterOpDescriptor( 0, _R(IDS_NODEPATH_EDIT), CC_RUNTIME_CLASS(OpReshapeOrAddPoint), OPTOKEN_NODEPATH, OpReshapeOrAddPoint::GetState, 0, // help ID _R(IDBBL_NODEPATHOP), 0 ) ); // bitmap ID }

void OpReshapeOrAddPoint::RecalculatePath (  DocCoord  Offset  )  [protected]

Will reshape a curve segment using a bit of voodoo maths. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 1/9/94 Parameters: Offset  - The Amount the pointer has moved from the *original* position (i.e. not [INPUTS] the last position). Scope: Private Assuming the mouse was originally clicked on the path a certain distance along it (say 1/4 of the whole curve). The parametric distance would thus be 0.25 - this is the distance that controls the first control point. 1-0.25 controls the second control point. Given: (px,py) = current pointer position (ox,oy) = original pointer position (x0,y0) = first control point (x1,y1) = second control point (x2,y2) = endpoint of curve pdist = parametric distance then: newx0 = x0+(px-ox)*3/pdist newy0 = y0+(py-oy)*3/pdist newx1 = x1+(px-ox)*3/(1-pdist) newy1 = y1+(py-oy)*3/(1-pdist) Disclaimer: This maths was plucked out of the blue, and so might not be the best way of doing it. Definition at line 8422 of file pathedit.cpp. { // Don't recalculate if the segment is a straight line... const double factor = 0.656875; PathVerb* Verbs = EditPath.GetVerbArray(); DocCoord* Coords = EditPath.GetCoordArray(); PathFlags* Flags = EditPath.GetFlagArray(); if (Verbs[Index] == PT_BEZIERTO) // first ctrl pt won't have closefigure set { // We have to calculate by how much to move the two control points on the curve, // and if the endpoints are set to rotate, we have to rotate the opposite control // points as well // Since the routine CalcRotate will change the *current* coords of the control point, // and we calculate the new coords from the *original* control point (to avoid accumulated // inaccuracies) we have to generate an offset that CalcRotate can use. DocCoord ControlOffset; INT32 OppositeIndex = EditPath.FindOppositeControlPoint(Index); ControlOffset.x = (INT32)(OrigControl1.x + (Offset.x) * factor / paramdist); ControlOffset.y = (INT32)(OrigControl1.y + (Offset.y) * factor / paramdist); ControlOffset.x -= Coords[Index].x; ControlOffset.y -= Coords[Index].y; if (Flags[Index-1].IsRotate && OppositeIndex >= 0) { EditPath.CalcRotate(Coords[Index-1], &Coords[Index], &Coords[OppositeIndex], ControlOffset); } else { Coords[Index].x += ControlOffset.x; Coords[Index].y += ControlOffset.y; } // We need to clear the smooth flags off the endpoints and control points around where // the path is being dragged. We know Index-1 to Index+2 are Beziers. if ((Index > 1) && ((Verbs[Index-1] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) ) Flags[Index-2].IsSmooth = FALSE; Flags[Index-1].IsSmooth = FALSE; Flags[Index].IsSmooth = FALSE; Flags[Index+1].IsSmooth = FALSE; Flags[Index+2].IsSmooth = FALSE; if ((Index < EditPath.GetNumCoords()-3) && ((Verbs[Index+3] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) ) Flags[Index+3].IsSmooth = FALSE; // If the index was at the very start or end of the path then we also need to turn off the // rotate flags so future path extension is correct if (Index == 1) { Flags[Index].IsRotate = FALSE; Flags[Index-1].IsRotate = FALSE; } if (Index == EditPath.GetNumCoords()-3) { Flags[Index+1].IsRotate = FALSE; Flags[Index+2].IsRotate = FALSE; } ControlOffset.x = (INT32)(OrigControl2.x + (Offset.x) * factor / (1.0-paramdist)); ControlOffset.y = (INT32)(OrigControl2.y + (Offset.y) * factor / (1.0-paramdist)); ControlOffset.x -= Coords[Index+1].x; ControlOffset.y -= Coords[Index+1].y; OppositeIndex = EditPath.FindOppositeControlPoint(Index+1); if (Flags[Index+2].IsRotate && OppositeIndex >= 0) { EditPath.CalcRotate(Coords[Index+2], &Coords[Index+1], &Coords[OppositeIndex], ControlOffset); } else { Coords[Index+1].x += ControlOffset.x; Coords[Index+1].y += ControlOffset.y; } } }

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

For getting a message for the status line during drag operations. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 4/1/96 Reimplemented from OpNodePathEditBlob. Definition at line 8577 of file pathedit.cpp. { String_256 HelpString; if (StartMousePos == FurthestPoint) HelpString = String_256(_R(IDS_PATHDRAGADDREFORM)); else HelpString = String_256(_R(IDS_PATHDRAGFINISHREFORM)); GetApplication()->UpdateStatusBarText(&HelpString, FALSE); }

---

Member Data Documentation

DocCoord OpReshapeOrAddPoint::FurthestPoint [protected]

Definition at line 441 of file pathedit.h.

BOOL OpReshapeOrAddPoint::HaveMadeCurve [protected]

Definition at line 442 of file pathedit.h.

INT32 OpReshapeOrAddPoint::Index [protected]

Definition at line 437 of file pathedit.h.

DocCoord OpReshapeOrAddPoint::OrigControl1 [protected]

Definition at line 439 of file pathedit.h.

DocCoord OpReshapeOrAddPoint::OrigControl2 [protected]

Definition at line 440 of file pathedit.h.

double OpReshapeOrAddPoint::paramdist [protected]

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

---