OpReformShapeEdge Class Reference

This operation is started by a NodeRegularShape when someone drags on one of its edges. It is used to interactively reform the path used to form the edge of the shape. More...

#include <shapeops.h>

Inheritance diagram for OpReformShapeEdge:

List of all members.

Public Member Functions
	OpReformShapeEdge ()
	Constructor - set member variables to default values.
void	DoStartDragEdit (NodeRegularShape *OrigShape, BOOL EdgeOne, DocCoord Anchor, Spread *pSpread, INT32 SegmentIndex)
	This is called when a Drag operation has been started on the edge of a shape. It will try and reshape the edge as it's dragged according to the maths in the function RecalculatePath.
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 drag blobs of this operation.
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.
Private Types
enum	DragType { DRAG_EDGE1, DRAG_EDGE2 }
Private Member Functions
void	RecalculateEdge (DocCoord Offset)
	Will reshape the edge being edited using Jims curve distorting method.
BOOL	BuildEditEdge ()
	Builds a copy of the shape and the edge path that we can edit, without destroying the original data.
BOOL	BuildEditShape (BOOL CopyToBoth, BOOL ShouldMirror)
	Builds a copy of the shape into EditShape based upon the current edge path.
BOOL	ReversePath (Path *NewPath, BOOL ShouldMirror)
	Use to reverse an edit path before copying it to the other edge path NOTE: This function assumes that the edge path consists of a MoveTo-BezierTo.
Private Attributes
NodeRegularShape *	EditShape
NodeRegularShape *	OriginalShape
DocCoord	StartMousePos
DocCoord	UTStartMousePos
DocCoord	OrigControl1
DocCoord	OrigControl2
Spread *	StartSpread
Path *	EditEdge
INT32	Index
double	paramdist
DragType	EdgeDrag

---

Detailed Description

This operation is started by a NodeRegularShape when someone drags on one of its edges. It is used to interactively reform the path used to form the edge of the shape.

Author:

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

Date:

16/12/94

Definition at line 310 of file shapeops.h.

---

Member Enumeration Documentation

enum OpReformShapeEdge::DragType [private]

Enumerator: DRAG_EDGE1  DRAG_EDGE2  Definition at line 336 of file shapeops.h. {DRAG_EDGE1, DRAG_EDGE2};

---

Constructor & Destructor Documentation

OpReformShapeEdge::OpReformShapeEdge (   )

Constructor - set member variables to default values. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2779 of file shapeops.cpp. { StartSpread = NULL; EditShape = NULL; EditEdge = NULL; }

---

Member Function Documentation

BOOL OpReformShapeEdge::BuildEditEdge (   )  [private]

Builds a copy of the shape and the edge path that we can edit, without destroying the original data. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/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 Definition at line 3005 of file shapeops.cpp. { // Copy the shape if ( (EditShape = new (NodeRegularShape)) == NULL) return FALSE; OriginalShape->CopyNodeContents(EditShape); // Copy the edge path if ( (EditEdge = new (Path)) == NULL) return FALSE; // We need to make a copy of the edge path as it appears in the shape. INT32 Count1 = OriginalShape->EdgePath1.GetNumCoords(); INT32 Count2 = OriginalShape->EdgePath2.GetNumCoords(); if (Count1 == 2) Count1 = 4; if (Count2 == 2) Count2 = 4; Path* RenderPath; if (!OriginalShape->BuildShapePath(&RenderPath)) return FALSE; // Run through the path makeing linetos into straight curvetos BOOL FoundLine = TRUE; while (FoundLine) { INT32 NumCoords = RenderPath->GetNumCoords(); // find a lineto INT32 loop = 0; while ((loop < NumCoords) && ((RenderPath->GetVerbArray()[loop] & ~PT_CLOSEFIGURE) != PT_LINETO)) { loop ++; } if (loop < NumCoords) { DocCoord* EdgeCoords = RenderPath->GetCoordArray(); DocCoord CP1 (EdgeCoords[loop-1].x + (EdgeCoords[loop].x-EdgeCoords[loop-1].x)/3, EdgeCoords[loop-1].y + (EdgeCoords[loop].y-EdgeCoords[loop-1].y)/3); DocCoord CP2 (EdgeCoords[loop].x + (EdgeCoords[loop-1].x-EdgeCoords[loop].x)/3, EdgeCoords[loop].y + (EdgeCoords[loop-1].y-EdgeCoords[loop].y)/3); DocCoord End = EdgeCoords[loop]; RenderPath->SetPathPosition(loop); RenderPath->InsertCurveTo(CP1,CP2,End); RenderPath->DeleteSection(loop+3,1); } else FoundLine = FALSE; } // Now calculate paramdist RenderPath->SqrDistanceToPoint(StartMousePos, &Index, &paramdist); // Now set Index to point to the first element in the edge PathFlags* RenderFlags = RenderPath->GetFlagArray(); while ((!RenderFlags[Index].IsEndPoint) && (Index >= 0) ) { Index--; } INT32 EndCount = EdgeDrag==DRAG_EDGE1 ? Count1 : Count2; // Ask for a path with the required number of free slots in it if (!EditEdge->Initialise(EndCount, 1)) return FALSE; // now copy the data from the appropitae place in RenderPath into EdgeEdge if (!EditEdge->CopySectionFrom(*RenderPath, Index, EndCount)) return FALSE; // Set the first verb to be a MoveTo and clear any closefigure from the last verb PathVerb* EdgeVerbs = EditEdge->GetVerbArray(); DocCoord* EdgeCoords = EditEdge->GetCoordArray(); EdgeVerbs[0] = PT_MOVETO; EdgeVerbs[EditEdge->GetNumCoords()-1] = EdgeVerbs[EditEdge->GetNumCoords()-1] & ~PT_CLOSEFIGURE; // Untransform the path Matrix TransMat; EditShape->GetTransformMatrix(&TransMat); TransMat = TransMat.Inverse(); TransMat.transform((Coord*)EdgeCoords, EditEdge->GetNumCoords()); // We also need an untransformed starting point of the drag TransMat.transform(&UTStartMousePos); // Record the original positions of the two control points of the drag segment // NOTE Assumes that the edit path consists of one segment if (EdgeVerbs[1] == PT_BEZIERTO) { OrigControl1 = EdgeCoords[1]; OrigControl2 = EdgeCoords[2]; } Index = 1; return TRUE; }

BOOL OpReformShapeEdge::BuildEditShape (  BOOL  CopyToBoth, BOOL  ShouldMirror )  [private]

Builds a copy of the shape into EditShape based upon the current edge path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 20/12/94 Parameters: CopyToBoth  - TRUE if the status of EdgeDrag is to be ignored and the new edge [INPUTS] should be applied to both edges of the shape. -  [OUTPUTS] Returns: TRUE if the build succeded, FALSE if it failed Errors: - Definition at line 3121 of file shapeops.cpp. { ERROR2IF(EditShape == NULL, FALSE, "Can't build into a non-existant shape!"); BOOL Success = TRUE; if (CopyToBoth) { Path* RevPath = new Path; Path* Path1; Path* Path2; if ((RevPath == NULL) || !ReversePath(RevPath, ShouldMirror)) { if (RevPath != NULL) delete RevPath; RevPath = EditEdge; } if (EdgeDrag == DRAG_EDGE1) { Path1 = EditEdge; Path2 = RevPath; } else { Path1 = RevPath; Path2 = EditEdge; } Success = EditShape->EdgePath1.CopyPathDataFrom(Path1); if (Success) Success = EditShape->EdgePath2.CopyPathDataFrom(Path2); if (RevPath != EditEdge) delete RevPath; } else { if (EdgeDrag == DRAG_EDGE1) { Success = EditShape->EdgePath1.CopyPathDataFrom(EditEdge); if (Success) Success = EditShape->EdgePath2.CopyPathDataFrom(&(OriginalShape->EdgePath2)); } else { Success = EditShape->EdgePath2.CopyPathDataFrom(EditEdge); if (Success) Success = EditShape->EdgePath1.CopyPathDataFrom(&(OriginalShape->EdgePath1)); } } if (!Success) { Error::SetError(_R(IDS_OUT_OF_MEMORY)); } EditShape->InvalidateCache(); return Success; }

void OpReformShapeEdge::DoStartDragEdit (  NodeRegularShape *  OrigShape, BOOL  EdgeOne, DocCoord  Anchor, Spread *  pSpread, INT32  SegmentIndex )

This is called when a Drag operation has been started on the edge of a shape. It will try and reshape the edge as it's dragged according to the maths in the function RecalculatePath. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> - from Jim code in OpReshapeOrAddPoint Date: 19/12/95 Parameters: OrigShape  - The original shape object [INPUTS] Anchor - The position of the mouse at the start of the Drag pSpread - the spread that the drag started on SegmentIndex - The Coord number of the control point that we are dragging pdist - parametric distance along the curve we're dragging from (0 to 1) See also: OpReformShapeEdge::RecalculatePath Definition at line 2808 of file shapeops.cpp. { // We had better take a note of the starting point of the drag StartMousePos = Anchor; UTStartMousePos = Anchor; // We'll untransform this later in BuildEditShape StartSpread = pSpread; OriginalShape = OrigShape; Index = SegmentIndex; EdgeDrag = EdgeOne ? DRAG_EDGE1 : DRAG_EDGE2; // We need to make a version of the shape that we can change if (!BuildEditEdge()) { // 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 = EditShape->GetBoundingRect(); RenderDragBlobs(EditPathBBox, pSpread, FALSE); // And tell the Dragging system that we need drags to happen StartDrag(DRAGTYPE_AUTOSCROLL, &EditPathBBox, &StartMousePos); }

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

This is called when a drag operation finishes. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 21/12/94 Parameters: PointerPos  - The position of the mouse at the end of the drag [INPUTS] ClickMods - the key modifiers being pressed pSpread - pointer to the spared the drag ended on. 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. Definition at line 2903 of file shapeops.cpp. { RenderDragBlobs( EditEdge->GetBoundingRect(), StartSpread, bSolidDrag ); EndDrag(); BeginSlowJob(); BOOL Failed = FALSE; if ( Success ) { // Start the undo ball rolling Failed = !DoStartSelOp(FALSE, TRUE, FALSE, TRUE); if (!Failed) { Failed = RecalcBoundsAction::DoRecalc(this, &UndoActions, OriginalShape) == AC_FAIL; } // Will the original shape allow the op to happen? ObjChangeFlags cFlags; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,OriginalShape,this); if (!Failed) Failed = !OriginalShape->AllowOp(&ObjChange); if (!Failed) { if ((EdgeDrag == DRAG_EDGE1) || ClickMods.Constrain) { Failed = ChangeShapePathAction::DoReshape(this, &UndoActions, OriginalShape, ChangeShapePathAction::CHANGE_PATH1, &(OriginalShape->EdgePath1)) == AC_FAIL ; } if ((EdgeDrag == DRAG_EDGE2) || ClickMods.Constrain || !OriginalShape->IsStellated()) { if (!Failed) { Failed = ChangeShapePathAction::DoReshape(this, &UndoActions, OriginalShape, ChangeShapePathAction::CHANGE_PATH2, &(OriginalShape->EdgePath2)) == AC_FAIL ; } } } // Now do the change if (!Failed) { if ((EdgeDrag == DRAG_EDGE1) || ClickMods.Constrain ) { OriginalShape->EdgePath1.ClearPath(); OriginalShape->EdgePath1.CopyPathDataFrom(&(EditShape->EdgePath1)); } if ((EdgeDrag == DRAG_EDGE2) || ClickMods.Constrain || !OriginalShape->IsStellated() ) { OriginalShape->EdgePath2.ClearPath(); OriginalShape->EdgePath2.CopyPathDataFrom(&(EditShape->EdgePath2)); } // Recalculate the path's bounding box OriginalShape->InvalidateBoundingRect(); OriginalShape->InvalidateCache(); // tell the world that something in the selection has changed // so that selection bounds are updated GetApplication()->FindSelection()->Update(TRUE); Failed = RecordBoundsAction::DoRecord(this, &UndoActions, OriginalShape) == AC_FAIL ; } if (!Failed) { // Update effected parents ObjChange.Define(OBJCHANGE_FINISHED,cFlags,OriginalShape,this); Failed = !UpdateChangedNodes(&ObjChange); } } else { // Set up the flags that say it all went wrong Failed = TRUE; } delete (EditShape); delete (EditEdge); if (Failed) FailAndExecute(); End(); }

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

This is called every time the mouse moves, during a drag. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 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 Operation. Definition at line 2853 of file shapeops.cpp. { // 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 RenderDragBlobs( EditShape->GetBoundingRect(), StartSpread, bSolidDrag ); // This is the bit where we go off and re-calculate the edge path, // based on how much the mouse has moved. We need to work in untransfomed coordinates DocCoord Offset = PointerPos; Matrix TransMat; EditShape->GetTransformMatrix(&TransMat); TransMat = TransMat.Inverse(); TransMat.transform(&Offset); Offset = Offset-UTStartMousePos; RecalculateEdge( Offset ); if (!BuildEditShape(ClickMods.Constrain || !OriginalShape->IsStellated(), ClickMods.Adjust)) { InformError(); End(); } // Draw in the new version of the path and update the Last Mouse Position RenderDragBlobs( EditShape->GetBoundingRect(), StartSpread, bSolidDrag ); }

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

Find out the state of the operation at the specific time. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/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 Definition at line 3320 of file shapeops.cpp. { OpState Blobby; return Blobby; }

BOOL OpReformShapeEdge::Init (  void   )  [static]

Adds the operation to the list of all known operations. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/94 Returns: TRUE if all went OK, False otherwise Reimplemented from SimpleCCObject. Definition at line 3295 of file shapeops.cpp. { return (RegisterOpDescriptor( 0, _R(IDS_EDITREGULARSHAPEOP), CC_RUNTIME_CLASS(OpReformShapeEdge), OPTOKEN_RESHAPESHAPEEDGE, OpReformShapeEdge::GetState)); }

void OpReformShapeEdge::RecalculateEdge (  DocCoord  Offset  )  [private]

Will reshape the edge being edited using Jims curve distorting method. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> (stolen from Jim code) Date: 20/12/94 Parameters: Offset  - The Amount the pointer has moved from the *original* position (i.e. not [INPUTS] the last position). See also: OpReshapeOrAddPoint::RecalculatePath Definition at line 3198 of file shapeops.cpp. { const double factor = 0.656875; PathVerb* Verbs = EditEdge->GetVerbArray(); DocCoord* Coords = EditEdge->GetCoordArray(); if (Verbs[Index] == PT_BEZIERTO) // first ctrl pt won't have closefigure set { DocCoord ControlOffset; 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; Coords[Index].x += ControlOffset.x; Coords[Index].y += ControlOffset.y; 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; Coords[Index+1].x += ControlOffset.x; Coords[Index+1].y += ControlOffset.y; } }

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

Renders the drag blobs of this operation. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/94 Parameters: Rect  - the clipping rectangle [INPUTS] pSpread - the spread to draw onto -  [OUTPUTS] Returns: - Reimplemented from Operation. Definition at line 3343 of file shapeops.cpp. { // If being called from DocView::RenderView, then the spread could be wrong - so // convert the rectangle if necessary. if (pSpread != StartSpread) { Rect.lo = MakeRelativeToSpread(StartSpread, pSpread, Rect.lo); Rect.hi = MakeRelativeToSpread(StartSpread, pSpread, Rect.hi); } ERROR3IF(EditShape == NULL, "Can't render a non-existant shape!"); if (EditShape == NULL) return; // start a rendering loop RenderRegion* pRegion = DocView::RenderOnTop(NULL, pSpread, ClippedEOR); while (pRegion) { // Set the line colour pRegion -> SetFillColour(COLOUR_NONE); pRegion -> SetLineColour(COLOUR_XOREDIT); // Draw the outline EditShape->RenderEorDrag(pRegion); // Get the Next render region pRegion = DocView::GetNextOnTop(NULL); } }

BOOL OpReformShapeEdge::ReversePath (  Path *  NewPath, BOOL  ShouldMirror )  [private]

Use to reverse an edit path before copying it to the other edge path NOTE: This function assumes that the edge path consists of a MoveTo-BezierTo. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 13/1/95 Parameters: NewPath  - Points to an uninitialsed path. [INPUTS] ShouldMirror - TRUE if the path should be mirrored NewPath  contains a mirror image of EditEdge [OUTPUTS] Returns: TRUE for success, FALSE for failure See also: - Definition at line 3244 of file shapeops.cpp. { const INT32 NumCoords = EditEdge->GetNumCoords(); ERROR3IF(NumCoords != 4, "Edit edge was not a single Bezier section"); if (!( NewPath->Initialise(NumCoords,4) && NewPath->CopyPathDataFrom(EditEdge) )) return FALSE; if (!ShouldMirror) NewPath->Reverse(); /* if (ShouldMirror) { DocCoord* Points = NewPath->GetCoordArray(); // Transform point 1 double angle1 = atan2((double)Points[3].y-Points[0].y, (double)Points[3].x-Points[0].x) * (180/PI); double angle2 = atan2((double)Points[1].y-Points[0].y, (double)Points[1].x-Points[0].x) * (180/PI); Matrix Trans(-Points[0].x, -Points[0].x); Trans *= Matrix(-ANGLE((angle2-angle1))); Trans *= Matrix(Points[0].x, Points[0].x); Trans.transform(&(Points[1])); // Transform point 2 angle1 = atan2((double)Points[0].y-Points[3].y, (double)Points[0].x-Points[3].x) * (180/PI); angle2 = atan2((double)Points[2].y-Points[3].y, (double)Points[2].x-Points[3].x) * (180/PI); Trans = Matrix(-Points[3].x, -Points[3].x); Trans *= Matrix(-ANGLE((angle2-angle1))); Trans *= Matrix(Points[3].x, Points[3].x); Trans.transform(&(Points[2])); }*/ return TRUE; }

---

Member Data Documentation

DragType OpReformShapeEdge::EdgeDrag [private]

Definition at line 352 of file shapeops.h.

Path* OpReformShapeEdge::EditEdge [private]

Definition at line 349 of file shapeops.h.

NodeRegularShape* OpReformShapeEdge::EditShape [private]

Definition at line 342 of file shapeops.h.

INT32 OpReformShapeEdge::Index [private]

Definition at line 350 of file shapeops.h.

DocCoord OpReformShapeEdge::OrigControl1 [private]

Definition at line 346 of file shapeops.h.

DocCoord OpReformShapeEdge::OrigControl2 [private]

Definition at line 347 of file shapeops.h.

NodeRegularShape* OpReformShapeEdge::OriginalShape [private]

Definition at line 343 of file shapeops.h.

double OpReformShapeEdge::paramdist [private]

Definition at line 351 of file shapeops.h.

DocCoord OpReformShapeEdge::StartMousePos [private]

Definition at line 344 of file shapeops.h.

Spread* OpReformShapeEdge::StartSpread [private]

Definition at line 348 of file shapeops.h.

DocCoord OpReformShapeEdge::UTStartMousePos [private]

Definition at line 345 of file shapeops.h.

---

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

• Kernel/shapeops.h (r1785/r1282)
• Kernel/shapeops.cpp (r1785/r1776)

---