OpToggleSmooth Class Reference

When a path point is double-clicked on, this operation is invoked to toggle the smoothness of the point. This works much like the equivalent feature in ArtWorks except that making a smooth point into a cusp will change the position of the control points. More...

#include <pathedit.h>

Inheritance diagram for OpToggleSmooth:

List of all members.

Public Member Functions
	OpToggleSmooth ()
	Constructor for toggle smooth/cusp operation.
void	DoTogglePoint (NodePath *, INT32 Index, Spread *, BOOL AllSmooth, BOOL DontMoveOnCusp)
	This operation will toggle the smoothness or otherwise of a point in a path. If the point is smooth, this operation will reset the smoothing bits on any adjacent control points. It will also change their positions, making the point visibly a corner. If the point is not smooth, this operation will set the smoothing flags on the control points and perform a smoothing operation on the points. If the path consists of a single curve element and the endpoint matches the start point, nothing is smoothed since we can't make any guesses as to where the control points go.
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	TogglePathPoints (NodePath *CurrentNode, INT32 Index, BOOL AllSmooth, BOOL DontMoveOnCusp)
	This operation will toggle the smoothness or otherwise of a point in a path. If the point is smooth, this operation will reset the smoothing bits on any adjacent control points. It will also change their positions, making the point visibly a corner. If the point is not smooth, this operation will set the smoothing flags on the control points and perform a smoothing operation on the points. If the path consists of a single curve element and the endpoint matches the start point, nothing is smoothed since we can't make any guesses as to where the control points go.
BOOL	MakePointCusp (NodePath *CurrentNode, INT32 Index, BOOL DontMoveOnCusp)
	Makes the specified endpoint in the path a cusp join.
BOOL	MakePointSmooth (NodePath *CurrentNode, INT32 Index)
	Makes the specified endpoint in the path a smooth join. Has to move the control points around the endpoint.

---

Detailed Description

When a path point is double-clicked on, this operation is invoked to toggle the smoothness of the point. This works much like the equivalent feature in ArtWorks except that making a smooth point into a cusp will change the position of the control points.

Author:

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

Date:

30/6/94

Definition at line 504 of file pathedit.h.

---

Constructor & Destructor Documentation

OpToggleSmooth::OpToggleSmooth (   )

Constructor for toggle smooth/cusp operation. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 30/6/94 Definition at line 5156 of file pathedit.cpp. { // Would initialise member variables here if there were any! }

---

Member Function Documentation

void OpToggleSmooth::DoTogglePoint (  NodePath *  ThisNode, INT32  Index, Spread *  pSpread, BOOL  AllSmooth, BOOL  DontMoveOnCusp )

This operation will toggle the smoothness or otherwise of a point in a path. If the point is smooth, this operation will reset the smoothing bits on any adjacent control points. It will also change their positions, making the point visibly a corner. If the point is not smooth, this operation will set the smoothing flags on the control points and perform a smoothing operation on the points. If the path consists of a single curve element and the endpoint matches the start point, nothing is smoothed since we can't make any guesses as to where the control points go. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com>/Mike/Peter Date: 4/7/94 Parameters: ThisNode  is the nodepath containing the point we want to toggle, if it [INPUTS] is NULL then all selected paths should be scanned. Index is the index into the path of the point clicked - if part of a curve, it points at the endpoint, not the first control point. If Index is -1 then all selected endpoints on the path should be processed pSpread points at the spread containing the path AllSmooth is only needed if Index is -1. If it is then AllSmooth is TRUE if all the points should be made smooth, otherwise they are made cusps. DontMoveOnCusp is TRUE if the control points shouldn't be moved when making a cusp -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 5230 of file pathedit.cpp. { if (!DoStartSelOp(TRUE,TRUE)) { FailAndExecute(); End(); return; } // We need to make sure the node or nodes that will be effected will allow this op to happen ObjChangeFlags cFlags; cFlags.TransformNode = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this); BOOL Failed = FALSE; if (ThisNode==NULL) { // If there's no node pointer then scan the selection! SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); while (pNode!=NULL && !Failed) { NodePath* pSelected = pNode->IsAnEditablePath(); if ( (pSelected != NULL) && (pSelected->AllowOp(&ObjChange)) ) { if (!TogglePathPoints(pSelected, Index, AllSmooth, DontMoveOnCusp)) { InformError(); Failed = TRUE; } } pNode = Selected->FindNext(pNode); } } else { if (ThisNode->AllowOp(&ObjChange)) { if (!TogglePathPoints(ThisNode, Index, AllSmooth, DontMoveOnCusp)) { InformError(); Failed = TRUE; } } } // Update all the parents of the effected paths. if (!Failed) { ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL,this); Failed = !UpdateChangedNodes(&ObjChange); } if (Failed) FailAndExecute(); End(); }

OpState OpToggleSmooth::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: 30/6/94 Parameters: -  [OUTPUTS] Returns: The state of the operation, so that menu items (ticks and greying can be done properly Definition at line 5195 of file pathedit.cpp. { OpState Blobby; // Ungreyed, unticked return Blobby; }

BOOL OpToggleSmooth::Init (  void   )  [static]

Adds the operation to the list of all known operations. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 30/6/94 Returns: TRUE if all went OK, FALSE otherwise Reimplemented from SimpleCCObject. Definition at line 5171 of file pathedit.cpp. { return (RegisterOpDescriptor( 0, _R(IDS_NODEPATH_EDIT), CC_RUNTIME_CLASS(OpToggleSmooth), OPTOKEN_NODEPATH, OpToggleSmooth::GetState, 0, // help ID _R(IDBBL_NODEPATHOP), 0 ) ); // bitmap ID }

BOOL OpToggleSmooth::MakePointCusp (  NodePath *  pPath, INT32  Index, BOOL  DontMoveOnCusp )  [protected]

Makes the specified endpoint in the path a cusp join. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> (made a function from Jim code) Date: 10/11/95 Parameters: pPath  points to the path to modify [INPUTS] Index - the index of the path to modify DontMoveOnCusp - TRUE if the control points should not move, FALSE to position them 1/3 between prev/next endpoint -  [OUTPUTS] Returns: TRUE/FALSE for success/failure Errors: Parameter checks. Creates actions which may fail See also: OpToggleSmooth::MakePointSmooth Definition at line 5417 of file pathedit.cpp. { // Parameter checks ERROR2IF(pPath == NULL, FALSE, "Path pointer was NULL"); ERROR2IF(Index < 0, FALSE, "Path index was negative"); ERROR2IF(Index >= pPath->InkPath.GetNumCoords(), FALSE, "Path index off end of path"); // Store the current state of the endpoint for undo then make it cusp ModifyElementAction* UnAction = NULL; PathFlags* Flags = NULL; PathVerb* Verbs = NULL; DocCoord* Coords = NULL; pPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); ERROR2IF((Verbs==NULL) || (Coords==NULL) || (Flags==NULL), FALSE, "Path array pointer was NULL (panic!)"); ActionCode Act = ModifyElementAction::Init(this, &UndoActions, Verbs[Index], Flags[Index], Coords[Index], Index, pPath, (Action**)&UnAction); if (Act == AC_FAIL) return FALSE; Flags[Index].IsSmooth = FALSE; Flags[Index].IsRotate = FALSE; // Modify the previous control point (if there is one) INT32 PrevControl = pPath->InkPath.FindPrevControlPoint(Index); if (PrevControl != -1) { Act = ModifyElementAction::Init(this, &UndoActions, Verbs[PrevControl], Flags[PrevControl], Coords[PrevControl], PrevControl, pPath, (Action**)&UnAction); if (Act == AC_FAIL) return FALSE; // Move the control point if required and it is possible if (!DontMoveOnCusp && (!((Verbs[Index] == PT_MOVETO) && (Verbs[Index+1] == PT_BEZIERTO) && (Verbs[Index+3] & PT_CLOSEFIGURE) && (Coords[Index] == Coords[Index+3])))) { Coords[PrevControl] = DocCoord::OneThird(Coords[PrevControl+1],Coords[PrevControl-2]); } Flags[PrevControl].IsSmooth = FALSE; Flags[PrevControl].IsRotate = FALSE; // Cope with the possibility that we have made the start/end of a closed // path a cusp - we can tell this if the endpoint associated with the // previous control point is not the same as Index if (Index != PrevControl+1) { Act = ModifyElementAction::Init(this, &UndoActions, Verbs[PrevControl+1], Flags[PrevControl+1], Coords[PrevControl+1], PrevControl+1, pPath, (Action**)&UnAction); if (Act == AC_FAIL) return FALSE; Flags[PrevControl+1].IsSmooth = FALSE; Flags[PrevControl+1].IsRotate = FALSE; } } // Modify the next control point (if there is one) INT32 NextControl = pPath->InkPath.FindNextControlPoint(Index); if (NextControl != -1) { Act = ModifyElementAction::Init(this, &UndoActions, Verbs[NextControl], Flags[NextControl], Coords[NextControl], NextControl, pPath, (Action**)&UnAction); if (Act == AC_FAIL) return FALSE; // Move the control point if required and it is possible // If this is a single-segment closed curve, in which case we'll never // be able to calculate sensible points. Just clear the rotate bits if (!DontMoveOnCusp && !((Verbs[Index] == PT_MOVETO) && (Verbs[Index+1] == PT_BEZIERTO) && (Verbs[Index+3] & PT_CLOSEFIGURE) && (Coords[Index] == Coords[Index+3]))) { Coords[NextControl] = DocCoord::OneThird(Coords[NextControl-1], Coords[NextControl+2]); } Flags[NextControl].IsSmooth = FALSE; Flags[NextControl].IsRotate = FALSE; } return TRUE; }

BOOL OpToggleSmooth::MakePointSmooth (  NodePath *  pPath, INT32  Index )  [protected]

Makes the specified endpoint in the path a smooth join. Has to move the control points around the endpoint. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> (made a function from Jim code) Date: 10/11/95 Parameters: pPath  points to the path to modify [INPUTS] Index - the index of the path to modify -  [OUTPUTS] Returns: TRUE/FALSE for success/failure Errors: Parameter checks. Creates actions which may fail See also: OpToggleSmooth::MakePointCusp Definition at line 5510 of file pathedit.cpp. { // Parameter checks ERROR2IF(pPath == NULL, FALSE, "Path pointer was NULL"); ERROR2IF(Index < 0, FALSE, "Path index was negative"); ERROR2IF(Index >= pPath->InkPath.GetNumCoords(), FALSE, "Path index off end of path"); // Store the current state of the endpoint for undo then make it smooth ModifyElementAction* UnAction = NULL; PathFlags* Flags = NULL; PathVerb* Verbs = NULL; DocCoord* Coords = NULL; pPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); ERROR2IF((Verbs==NULL) || (Coords==NULL) || (Flags==NULL), FALSE, "Path array pointer was NULL (panic!)"); ActionCode Act = ModifyElementAction::Init(this, &UndoActions, Verbs[Index], Flags[Index], Coords[Index], Index, pPath, (Action**)&UnAction); if (Act == AC_FAIL) return FALSE; Flags[Index].IsSmooth = TRUE; Flags[Index].IsRotate = TRUE; // Modify the previous control point (if there is one) INT32 PrevControl = pPath->InkPath.FindPrevControlPoint(Index); if (PrevControl != -1) { Act = ModifyElementAction::Init(this, &UndoActions, Verbs[PrevControl], Flags[PrevControl], Coords[PrevControl], PrevControl, pPath, (Action**)&UnAction); if (Act == AC_FAIL) return FALSE; Flags[PrevControl].IsSmooth = TRUE; Flags[PrevControl].IsRotate = TRUE; Coords[PrevControl] = pPath->InkPath.SmoothControlPoint(PrevControl); // if PrevControl+1 != Index we must be smoothing the joined ends // of a closed subpath, so we'll have to set the smoothing bits on this point too if (Index != PrevControl+1) { Act = ModifyElementAction::Init(this, &UndoActions, Verbs[PrevControl+1], Flags[PrevControl+1], Coords[PrevControl+1], PrevControl+1, pPath, (Action**)&UnAction); if (Act == AC_FAIL) return FALSE; Flags[PrevControl+1].IsSmooth = TRUE; Flags[PrevControl+1].IsRotate = TRUE; } } // Modify the next control point (if there is one) INT32 NextControl = pPath->InkPath.FindNextControlPoint(Index); if (NextControl != -1) { Act = ModifyElementAction::Init(this, &UndoActions, Verbs[NextControl], Flags[NextControl], Coords[NextControl], NextControl, pPath, (Action**)&UnAction); if (Act == AC_FAIL) return FALSE; Flags[NextControl].IsSmooth = TRUE; Flags[NextControl].IsRotate = TRUE; Coords[NextControl] = pPath->InkPath.SmoothControlPoint(NextControl); } return TRUE; }

BOOL OpToggleSmooth::TogglePathPoints (  NodePath *  CurrentNode, INT32  Index, BOOL  AllSmooth, BOOL  DontMoveOnCusp )  [protected]

This operation will toggle the smoothness or otherwise of a point in a path. If the point is smooth, this operation will reset the smoothing bits on any adjacent control points. It will also change their positions, making the point visibly a corner. If the point is not smooth, this operation will set the smoothing flags on the control points and perform a smoothing operation on the points. If the path consists of a single curve element and the endpoint matches the start point, nothing is smoothed since we can't make any guesses as to where the control points go. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 4/7/94 Parameters: ThisNode  is the nodepath containing the point we want to toggle. [INPUTS] Index is the index into the path of the point clicked - if part of a curve, it points at the endpoint, not the first control point. If Index is -1 then all selected endpoints on the path should be processed AllSmooth is only needed if Index is -1. If it is then AllSmooth is TRUE if all the points should be made smooth, otherwise they are made cusps. -  [OUTPUTS] Returns: FALSE if an error occured Errors: - See also: - Definition at line 5316 of file pathedit.cpp. { ERROR2IF(CurrentNode==NULL, FALSE, "Path pointer was NULL"); PathFlags* Flags = NULL; PathVerb* Verbs = NULL; DocCoord* Coords = NULL; CurrentNode->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); ERROR2IF((Verbs==NULL) || (Coords==NULL) || (Flags==NULL), FALSE, "Path array pointer was NULL (panic!)"); INT32 NumCoords = CurrentNode->InkPath.GetNumCoords(); INT32 LowIndex = (Index == -1) ? 0 : Index; INT32 HighIndex = (Index == -1) ? NumCoords-1 : Index; // Check to see if this is a single-segment closed curve, in which case we'll never // be able to smooth it. We can only be on the moveto... if ( (Verbs[0] == PT_MOVETO) && (Verbs[1] == PT_BEZIERTO) && (Verbs[3] & PT_CLOSEFIGURE) && (Coords[0] == Coords[3]) && (!Flags[0].IsRotate) ) return TRUE; BOOL Success = TRUE; BOOL ChangedThisPath = FALSE; for (INT32 CurrentIndex = LowIndex; (CurrentIndex <= HighIndex) && Success; CurrentIndex++) { BOOL Test = FALSE; // TRUE if this endpoint should be toggled CurrentNode->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); if (HighIndex != LowIndex) { if (Flags[CurrentIndex].IsEndPoint && Flags[CurrentIndex].IsSelected) { // Force selected point to be either cusp or smooth if (AllSmooth) Test = !(Flags[CurrentIndex].IsRotate); else Test = Flags[CurrentIndex].IsRotate; } else Test = FALSE; } else { // Toggle single point Test = Flags[CurrentIndex].IsEndPoint; } // Toggle the smooth state of this endpoint if (Test) { ERROR3IF(!Flags[CurrentIndex].IsEndPoint, "Attempting to toggle a control point"); // Force a re-draw of the place where the path used to be if (Success && !ChangedThisPath) { Success = (RecalcBoundsAction::DoRecalc(this, &UndoActions, CurrentNode) != AC_FAIL); // // Store the paths sub-selection state // if (Success) // Success = (StorePathSubSelStateAction::DoRecord(this, &UndoActions, &CurrentNode->InkPath) != AC_FAIL); ChangedThisPath = TRUE; } // Now let's adjust the smoothness of this point. if (Success) { CurrentNode->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); if (Flags[CurrentIndex].IsRotate) Success = MakePointCusp(CurrentNode, CurrentIndex, DontMoveOnCusp); else Success = MakePointSmooth(CurrentNode, CurrentIndex); } } } // Now create a RecordBoundsAction so that the action list has bounds recalculation // at both ends which ensures undo and redo both work properly if (Success && ChangedThisPath) { CurrentNode->InvalidateBoundingRect(); GetApplication()->FindSelection()->UpdateBounds(); Success = (RecordBoundsAction::DoRecord(this, &UndoActions, CurrentNode) != AC_FAIL); } return Success; }

---

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

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

---