OpDeletePoints Class Reference

This class will delete any selected points from selected paths. More...

#include <pathedit.h>

Inheritance diagram for OpDeletePoints:

List of all members.

Public Member Functions
	OpDeletePoints ()
	OpDeletePoints constructor.
void	Do (OpDescriptor *)
	Performs the Delete point(s) operation.
Static Public Member Functions
static BOOL	Init ()
	OpDeletePoints initialiser method.
static OpState	GetState (String_256 *, OpDescriptor *)
	For finding the OpDeletePoints's state.
Private Member Functions
BOOL	DeleteLineTo (NodePath *pPath, INT32 Index, BOOL *PathExists)
	This is called by OpDeletePoints::Do in order to delete a PT_LINETO endpoint from a path.
BOOL	DeleteMoveTo (NodePath *pPath, INT32 Index, BOOL *PathExists)
	This is called by OpDeletePoints::Do in order to delete a PT_MOVETO endpoint from a path.
BOOL	DeleteBezierTo (NodePath *pPath, INT32 Index, BOOL *PathExists)
	This is called by OpDeletePoints::Do in order to delete a PT_BEZIERTO endpoint from a path.
Static Private Member Functions
static BOOL	WillDeleteEntirePath (NodePath *pPath)
	Sees if some of the path will remain after a delete points operation.
static BOOL	TryDeleteLineTo (NodePath *pPath, INT32 Index, BOOL *PathExists)
	This is called by OpDeletePoints::WillDeletePath in order to delete a PT_LINETO endpoint from a path.
static BOOL	TryDeleteMoveTo (NodePath *pPath, INT32 Index, BOOL *PathExists)
	This is called by OpDeletePoints::WillDeletePath in order to delete a PT_MOVETO endpoint from a path.
static BOOL	TryDeleteBezierTo (NodePath *pPath, INT32 Index, BOOL *PathExists)
	This is called by OpDeletePoints::WillDeletePath in order to delete a PT_BEZIERTO endpoint from a path.

---

Detailed Description

This class will delete any selected points from selected paths.

Author:

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

Date:

20/7/94

See also:

-

Definition at line 590 of file pathedit.h.

---

Constructor & Destructor Documentation

OpDeletePoints::OpDeletePoints (   )

OpDeletePoints constructor. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 22/7/94 Definition at line 6613 of file pathedit.cpp. : SelOperation() { }

---

Member Function Documentation

BOOL OpDeletePoints::DeleteBezierTo (  NodePath *  pPath, INT32  Index, BOOL *  PathExists )  [private]

This is called by OpDeletePoints::Do in order to delete a PT_BEZIERTO endpoint from a path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> - from Jim code Date: 27/10/94 Parameters: pPath  - Pointer to the NodePath to delete the endpoint from. [INPUTS] Index - The number of the endpoint to delete PathExists - pointer to a BOOL for flaging that the whole path has been deleted. PathExists  - If the entire path has been deleted, *DeletedPath is set to TRUE [OUTPUTS] Returns: FALSE if an error occured during deletion, otherwise TRUE for sucess. See also: OpDeletePoints::Do. OpDeletePoints::DeleteMoveTo. OpDeletePoints::DeleteLineTo Definition at line 7255 of file pathedit.cpp. { PathVerb* Verbs = pPath->InkPath.GetVerbArray(); // PathFlags* Flags = pPath->InkPath.GetFlagArray(); // DocCoord* Coords = pPath->InkPath.GetCoordArray(); INT32 NumCoords = pPath->InkPath.GetNumCoords(); PathFlags TempFlags; DocCoord EndPoint; // See if this is the end of the path if (Index+1 != NumCoords) { // See what the next element is switch (Verbs[Index+1] & ~ PT_CLOSEFIGURE) { case PT_LINETO: // A curve followed by a line. Just delete the curve. return DoDeletePathSection(pPath, Index-2, 3); break; case PT_BEZIERTO: // A curve followed by a curve. First delete the second control point, // the endpoint, and the first control point of the next (curve) element // Then we should smooth it somehow (later) return DoDeletePathSection(pPath, Index-1, 3); break; case PT_MOVETO: // Tricky again, the next point is a MoveTo, so we have to check all the special // cases like closed paths, paths with single elements, etc. if (Verbs[Index] & PT_CLOSEFIGURE) { // The path is closed, it's fiddle time again (see above) // For now, deselect it return DoChangeSelection(pPath, Index, FALSE); } else { // At least the path isn't closed. We might safely be able to delete this // section, as long as the previous element isn't a MoveTo, in which case // we have to delete the whole subpath if (Verbs[Index-3] == PT_MOVETO) { // Delete the whole subpath return DoDeletePathSection(pPath, Index-3, 4); } else { // Only delete the curve section return DoDeletePathSection(pPath, Index-2, 3); } } break; default: ERROR2(FALSE,"Corrupt path found in DeleteBezierTo"); } } else { // This is the case when we're at the end of the path // Is the path a closed one if (Verbs[Index] & PT_CLOSEFIGURE) { // the path is closed. This is still tricky (see above and above) // so trick that I'll just deselect it return DoChangeSelection(pPath, Index, FALSE); } else { // The path isn't closed, so check for this being the only element in // the path if (Verbs[Index-3] == PT_MOVETO) { // Either this could be one of many subpaths, or the only subpath if (NumCoords == 4) { // This is the only subpath, it only has one element, so delete // the whole path *PathExists = FALSE; return (DoInvalidateNodeRegion(pPath,TRUE,TRUE) && DoHideNode(pPath, TRUE)); } else { // There are other subpaths, so just delete this one return DoDeletePathSection(pPath, Index-3, 4); } } else { // It's not the only element in the path so delete it return DoDeletePathSection(pPath, Index-2, 3); } } } }

BOOL OpDeletePoints::DeleteLineTo (  NodePath *  pPath, INT32  Index, BOOL *  PathExists )  [private]

This is called by OpDeletePoints::Do in order to delete a PT_LINETO endpoint from a path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> - from Jim code Date: 27/10/94 Parameters: pPath  - Pointer to the NodePath to delete the endpoint from. [INPUTS] Index - The number of the endpoint to delete PathExists - pointer to a BOOL for flaging that the whole path has been deleted. PathExists  - If the entire path has been deleted, *DeletedPath is set to TRUE [OUTPUTS] Returns: FALSE if an error occured during deletion, otherwise TRUE for sucess. See also: OpDeletePoints::Do. OpDeletePoints::DeleteMoveTo. OpDeletePoints::DeleteBezierTo Definition at line 6882 of file pathedit.cpp. { PathVerb* Verbs = pPath->InkPath.GetVerbArray(); PathFlags* Flags = pPath->InkPath.GetFlagArray(); DocCoord* Coords = pPath->InkPath.GetCoordArray(); INT32 NumCoords = pPath->InkPath.GetNumCoords(); PathVerb TempVerb; PathFlags TempFlags; DocCoord EndPoint; // work differently depending on if this is the last point in the path if (Index+1 != NumCoords) { // See what the next element is switch (Verbs[Index+1] & ~PT_CLOSEFIGURE) { case PT_LINETO: return DoDeletePathSection(pPath, Index, 1) ; break; case PT_BEZIERTO: // for a line next to a bezier, delete the bezier segment // and change the line coordinate to go to the end of the bezier EndPoint = Coords[Index+3]; // Get coords of bez endpt TempVerb = Verbs[Index]; TempFlags = Flags[Index]; TempFlags.IsSelected = Flags[Index+3].IsSelected; // Change the LineTo element to go to the old end pos of the bezier // setting the selection status of the new point // Delete whole bezier section return (DoAlterPathElement(pPath, Index, EndPoint, TempFlags, TempVerb) && DoDeletePathSection(pPath, Index+1, 3)); break; case PT_MOVETO: // Next point is a MoveTo so this is the last point in a subpath // See if the path is closed if (Verbs[Index] & PT_CLOSEFIGURE) { // The subpath is closed, so do something clever (see below) // As a temporary measure to prevent an infinite loop we'll // deselect this point return DoChangeSelection(pPath, Index, FALSE) ; } else { // This subpath is open, so we either just delete the element // or if the previous element is a MoveTo, we delete that as well if (Verbs[Index-1] == PT_MOVETO) return DoDeletePathSection(pPath, Index-1, 2); else return DoDeletePathSection(pPath, Index, 1); } break; default : ERROR2(FALSE, "Corrupted path found in DeleteLineTo"); } } else { // Here, the point being deleted is the last point in the path // See if the path is being closed if (Verbs[Index] & PT_CLOSEFIGURE) { // We're deleting the last point of a closed path. HELP! // This entails deleting the corresponding MoveTo as well // Which is quite complicated. I'll do that in a minute. // For now, I'll just clear selection return DoChangeSelection(pPath, Index, FALSE); } else { // This is an open path, so the only worry is if this is the only // line element in the path if (Verbs[Index-1] == PT_MOVETO) { // Two possiblilities here, either this is the only path, or // it's part of a subpath. if (NumCoords == 2) { // This is the only path, so delete the whole node *PathExists = FALSE; return (DoInvalidateNodeRegion(pPath,TRUE,TRUE) && DoHideNode(pPath, TRUE)) ; } else { // It's not the only subpath, so just delete these two elements return DoDeletePathSection(pPath, Index-1, 2); } } else { // It's not the only element in the subpath, so just delete it return DoDeletePathSection(pPath, Index, 1); } } } }

BOOL OpDeletePoints::DeleteMoveTo (  NodePath *  pPath, INT32  Index, BOOL *  PathExists )  [private]

This is called by OpDeletePoints::Do in order to delete a PT_MOVETO endpoint from a path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> - from Jim code Date: 27/10/94 Parameters: pPath  - Pointer to the NodePath to delete the endpoint from. [INPUTS] Index - The number of the endpoint to delete PathExists - pointer to a BOOL for flaging that the whole path has been deleted. PathExists  - If the entire path has been deleted, *DeletedPath is set to TRUE [OUTPUTS] Returns: FALSE if an error occured during deletion, otherwise TRUE for sucess. See also: OpDeletePoints::Do. OpDeletePoints::DeleteLineTo. OpDeletePoints::DeleteBezierTo Definition at line 7000 of file pathedit.cpp. { PathVerb* Verbs = pPath->InkPath.GetVerbArray(); PathFlags* Flags = pPath->InkPath.GetFlagArray(); DocCoord* Coords = pPath->InkPath.GetCoordArray(); INT32 NumCoords = pPath->InkPath.GetNumCoords(); PathFlags TempFlags; DocCoord EndPoint; // I think this is slightly simpler than all the others (except for closed) // First see if this subpath is closed if (pPath->InkPath.IsSubPathClosed(Index)) { // Great, the path is closed, so I'll have to do all sorts of difficult things // (yet again, see above) // or just deselect it, whichever's easier if (!DoChangeSelection(pPath, Index, FALSE)) return FALSE; // Right, time to bite the bullet and do this. // This is actually the only occasion when this type of point can be // deleted - when a path is closed, the endpoint cannot be selected // without the start point being selected, so we only have to cope with // this situation and ensure that we clear the selection bits // on the corresponding endpoints INT32 EndIndex = Index; pPath->InkPath.FindEndOfSubPath(&EndIndex); // There are situations where we have got a two element path, a MoveTo, then either // a LineTo or a BezierTo. We must deal with the case of both endpoints being // selected and remove the entire sub-path. INT32 SubPathElements = EndIndex - Index; if (Verbs[EndIndex] == PT_BEZIERTO) SubPathElements += 2; if (((SubPathElements == 1) && (Flags[Index+1].IsSelected) ) || ((SubPathElements == 3) && (Flags[Index+3].IsSelected) && ((Verbs[Index+3] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) ) ) { if (SubPathElements == 1) { return (DoChangeSelection(pPath, Index+1, FALSE) && DoDeletePathSection(pPath, Index, 2) ); } else { return (DoChangeSelection(pPath, Index+3, FALSE) && DoDeletePathSection(pPath, Index, 4) ); } } // What we have to do here is find the last element, and the first element, // delete one of them (probably the first one but it might depend on what // type of point they are) // Now EndIndex tells us where the end element is // Let's see what the two elements are PathVerb StartVerb = Verbs[Index+1] & ~PT_CLOSEFIGURE; PathVerb EndVerb = Verbs[EndIndex] & ~PT_CLOSEFIGURE; if ( StartVerb == PT_BEZIERTO && EndVerb == PT_BEZIERTO ) { // Both beziers. What we do here is remember the second // control point of the first bezier, as well as the endpoint, // then change the second control point and the endpoint // of the last bezier accordingly if ( ! (DoAlterPathElement(pPath, EndIndex+1, Coords[Index+2], Flags[Index+2], Verbs[Index+2]) && // Alter the endpoint, keeping the same verb but changing the other elements DoAlterPathElement(pPath, EndIndex+2, Coords[Index+3], Flags[Index+3], Verbs[EndIndex+2]) && // Now alter the MoveTo coordinates DoAlterPathElement(pPath, Index, Coords[Index+3], Flags[Index], Verbs[Index]) && // And now delete the first curve element altogether DoDeletePathSection(pPath, Index+1, 3) ) ) { return FALSE; } } else if (StartVerb == PT_LINETO && EndVerb == PT_BEZIERTO) { // When one element is a line, we always keep the line // In this case, we have to change the coords of the // moveto to be the same as the start of the final section, // then delete the final section if ( ! (DoAlterPathElement(pPath, Index, Coords[EndIndex-1], Flags[Index], Verbs[Index]) && // Alter the element previous to the curve to have the close bit set DoAlterPathElement(pPath, EndIndex-1, Coords[EndIndex-1], Flags[EndIndex-1], Verbs[EndIndex-1] | PT_CLOSEFIGURE) && // And delete the curve section DoDeletePathSection(pPath, EndIndex, 3) ) ) { return FALSE; } } else if (StartVerb == PT_BEZIERTO && EndVerb == PT_LINETO) { // Similar to the previous case, except the lineto is at the end // What we do here is set the lineto coord and the moveto coord // to the the endpoint of the first (curve) element, making sure the // lineto selection bit is clear. if ( ! (DoChangeSelection(pPath, EndIndex, Flags[Index+3].IsSelected) && DoAlterPathElement(pPath, EndIndex, Coords[Index+3], Flags[EndIndex], Verbs[EndIndex]) && DoAlterPathElement(pPath, Index, Coords[Index+3], Flags[Index], Verbs[Index]) && // Now delete the curve element DoDeletePathSection(pPath, Index+1, 3) ) ) { return FALSE; } } else { // start and end must be linetos // Alter the final lineto and the moveto to have the coords of // the end of the first lineto if ( ! (DoAlterPathElement(pPath, Index, Coords[Index+1], Flags[Index], Verbs[Index]) && DoAlterPathElement(pPath, EndIndex, Coords[Index+1], Flags[EndIndex], Verbs[EndIndex]) && // make sure the endpoint isn't selected DoChangeSelection(pPath, EndIndex, Flags[Index+1].IsSelected) && // delete the first lineto DoDeletePathSection(pPath, Index+1, 1) ) ) { return FALSE; } } // Now recache the pointers Coords = pPath->InkPath.GetCoordArray(); Verbs = pPath->InkPath.GetVerbArray(); Flags = pPath->InkPath.GetFlagArray(); // The last thing I have to do is check the selected status of the new endpoint // and select the MoveTo if it is selected, and deselect the moveto otherwise // Index is still valid for the start of the path EndIndex = Index; pPath->InkPath.FindEndOfSubPath(&EndIndex); BOOL IsSelected; if ((Verbs[EndIndex] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) IsSelected = Flags[EndIndex+2].IsSelected; else IsSelected = Flags[EndIndex].IsSelected; // Change the selection of the MoveTo to match the selection // of the endpoint in this closed path return DoChangeSelection(pPath, Index, IsSelected); } else { // The path isn't closed. // Are we looking at the start of a curve or a line? if ((Verbs[Index+1] & ~ PT_CLOSEFIGURE) == PT_BEZIERTO) { // We're deleting this bezier segment. We have to check if this is a lone element if (Index+4 == NumCoords || Verbs[Index+4] == PT_MOVETO) { // It's a lone element, so either delete the subpath or delete the whole node if (NumCoords == 4) { // It's all there is in the path, so delete the whole thing *PathExists = FALSE; return (DoInvalidateNodeRegion(pPath,TRUE,TRUE) && DoHideNode(pPath, TRUE)) ; } else { return DoDeletePathSection(pPath, Index, 4); } } else { // It's not a lone element, so delete the curveto, and change the MoveTo // so that it now moves to the endpoint of the curve EndPoint = Coords[Index+3]; // Look at the selected bit of the end of the curve, and copy that // to the moveto, in case that point wanted deleting as well BOOL WasSelected = Flags[Index+3].IsSelected; // Delete the section containing the curve PathFlags TempFlags = Flags[Index]; TempFlags.IsSelected = WasSelected; PathVerb TempVerb = Verbs[Index]; if (!DoDeletePathSection(pPath, Index+1, 3)) return FALSE; // Alter the MoveTo element so coords and flags are correct return DoAlterPathElement(pPath, Index, EndPoint, TempFlags, TempVerb); } } else { // Since we can't have a moveto following a moveto, the next element // has to be a path (let's check that with an ENSURE) ERROR2IF(((Verbs[Index+1] & ~PT_CLOSEFIGURE) != PT_LINETO), FALSE, "Badly formed path in DeletePoint"); // Check if it's a single element if (Index+2 == NumCoords || Verbs[Index+2] == PT_MOVETO) { // It's a lone element so either delete the subpath or the whole path // See if this is the only subpath if (NumCoords == 2) { // This is the only element in the path, so hide the whole node *PathExists = FALSE; return (DoInvalidateNodeRegion(pPath,TRUE,TRUE) && DoHideNode(pPath, TRUE)) ; } else { // Just delete this subpath return DoDeletePathSection(pPath, Index, 2); } } else { // There is another element after this, so delete the line element // and alter the Moveto element so that it goes to where the endpoint // used to go EndPoint = Coords[Index+1]; // Look at the selected bit of the line element BOOL WasSelected = Flags[Index+1].IsSelected; // Delete the section containing the line PathFlags TempFlags = Flags[Index]; TempFlags.IsSelected = WasSelected; PathVerb TempVerb = Verbs[Index]; if (!DoDeletePathSection(pPath, Index+1, 1)) return FALSE; // Alter the MoveTo so that it goes to the position of the lineto, and it's selected // if necessary return DoAlterPathElement(pPath, Index, EndPoint, TempFlags, TempVerb); } } } }

void OpDeletePoints::Do (  OpDescriptor *   )  [virtual]

Performs the Delete point(s) operation. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> - latterly Peter Date: 22/7/94 Parameters: OpDescriptor  (unused) [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Operation. Definition at line 6720 of file pathedit.cpp. { // Obtain the current selections SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); BOOL ok = DoStartSelOp(TRUE,TRUE); // We need to ask the effected nodes if they (and their parents) can handle this node being deleted ObjChangeFlags cFlags/*(TRUE)*/; cFlags.TransformNode = TRUE; ObjChangeParam ObjDelete(OBJCHANGE_STARTING,ObjChangeFlags(TRUE),NULL,this); ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this); // loop through the selection while (pNode != NULL) { // First see where the next node is, in case this one gets deleted Node* NextNode = Selected->FindNext(pNode); // Is the node of interest? // we're only interested in NodePaths which have selected points, and that will allow this op to happen BOOL DoThisPath = (IS_A(pNode, NodePath) || IS_A(pNode,NodeBlendPath)) && ((NodePath*)pNode)->InkPath.IsSubSelection(); // Check with the path and it's parents BOOL WillDelete = FALSE; if (DoThisPath) { WillDelete = WillDeleteEntirePath((NodePath*)pNode); if (WillDelete) DoThisPath = pNode->AllowOp(&ObjDelete); else DoThisPath = pNode->AllowOp(&ObjChange); } // Do the delete if required if (DoThisPath && ok) { NodePath* ThisPath = (NodePath*)pNode; INT32 NumCoords = ThisPath->InkPath.GetNumCoords(); PathVerb* Verbs = NULL; PathFlags* Flags = NULL; DocCoord* Coords = NULL; ThisPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); BOOL PathStillExists = TRUE; // Record the bounds and do a redraw ok = RecalcBoundsAction::DoRecalc(this, &UndoActions, ThisPath) != AC_FAIL ; // // Store the sub-selection state of the path // if (ok) // ok = (StorePathSubSelStateAction::DoRecord(this, &UndoActions, &ThisPath->InkPath) != AC_FAIL); // Simply hide all the path if all of it is to be deleted if (WillDelete) { if (ok) ok = DoHideNode(pNode, TRUE); PathStillExists = FALSE; } // We have to delete every selected endpoint in the path (if it still exists) while (ok && PathStillExists && ThisPath->InkPath.IsSubSelection()) { // First refresh the pointers to the arrays ThisPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); NumCoords = ThisPath->InkPath.GetNumCoords(); // Scan for a selected endpoint INT32 i; for ( i =0;i<NumCoords && (!Flags[i].IsSelected || !Flags[i].IsEndPoint);i++) ; // ; deliberate // Now, either i == NumCoords or it points at a selected endpoint // if i == NumCoords there weren't any selected endpoints, so clear // the selected bits on random control points if (i == NumCoords) { for (i=0;i<NumCoords;i++) { ok = ok && DoChangeSelection(ThisPath, i,FALSE); } } else { // i indexes into a selected endpoint, which is the one we have to delete. // Are we looking at a MoveTo, CurveTo or a LineTo? switch (Verbs[i] & ~PT_CLOSEFIGURE) { case PT_LINETO: ok = DeleteLineTo(ThisPath, i, &PathStillExists); break; case PT_BEZIERTO: ok = DeleteBezierTo(ThisPath, i, &PathStillExists); break; case PT_MOVETO: ok = DeleteMoveTo(ThisPath, i, &PathStillExists); break; } } } // now that we have deleted every selected point on the path we need to check to see if we are // left with a closed path consisting of a moveto followed by a single line or a curve. // if we are then we should delete the node. if (ok && PathStillExists && !ThisPath->IsPathAllowable()) { if (ok) ok = DoInvalidateNodeRegion(ThisPath,TRUE,TRUE); if (ok) ok = DoHideNode(ThisPath, TRUE); PathStillExists = FALSE; } // Having finished deleting, record the bounds of the new path // This is the partner to the RecalcBoundsAction at the start of this Op if (PathStillExists && ok) { ThisPath->InvalidateBoundingRect(); ok = RecordBoundsAction::DoRecord(this, &UndoActions, ThisPath) != AC_FAIL; } } pNode = NextNode; } // Update all the parents of this node if (ok) { ObjChange.Define(OBJCHANGE_FINISHED,ObjChangeFlags(),NULL,this); ok = UpdateChangedNodes(&ObjChange); } if (!ok) { InformError(); FailAndExecute(); } GetApplication()->UpdateSelection(); End(); }

OpState OpDeletePoints::GetState (  String_256 *  UIDescription, OpDescriptor *  pOpDesc )  [static]

For finding the OpDeletePoints's state. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> - latterly Peter Date: 27/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The state of the OpDeletePoints Errors: - See also: - Definition at line 6654 of file pathedit.cpp. { // Look at the current selection SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); // We need to ask the effected nodes if they (and their parents) can handle this node being deleted ObjChangeParam ObjDelete(OBJCHANGE_STARTING, ObjChangeFlags(TRUE), NULL, NULL); ObjChangeParam ObjChange(OBJCHANGE_STARTING, ObjChangeFlags(), NULL, NULL); // Go through the selection until we find a selected point BOOL FoundSelected = FALSE; while (pNode != NULL) { if (IS_A(pNode, NodePath) || IS_A(pNode,NodeBlendPath)) { if (((NodePath*)pNode)->InkPath.IsSubSelection()) { // See if this will delete the node or not BOOL WillHide = WillDeleteEntirePath((NodePath*)pNode); // Check that we can do this op of the node BOOL Result = FALSE; if (WillHide) Result = pNode->AllowOp(&ObjDelete, FALSE); else Result = pNode->AllowOp(&ObjChange, FALSE); if (Result) { // We've found at least one node we can act upon FoundSelected = TRUE; break; } } } pNode = Selected->FindNext(pNode); } OpState OpSt; // The operation is disabled if there are no complex paths selected if (!FoundSelected) { OpSt.Greyed = TRUE; *UIDescription = String_256(_R(IDS_NEEDS_SELECTED_POINT)); } return(OpSt); }

BOOL OpDeletePoints::Init (  void   )  [static]

OpDeletePoints initialiser method. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 26/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the operation could be successfully initialised FALSE if no more memory could be allocated Errors: ERROR will be called if there was insufficient memory to allocate the operation. See also: - Reimplemented from SimpleCCObject. Definition at line 6632 of file pathedit.cpp. { BTNOP( DELETEPOINTSOP, OpDeletePoints, EDIT) return TRUE; }

BOOL OpDeletePoints::TryDeleteBezierTo (  NodePath *  pPath, INT32  Index, BOOL *  PathExists )  [static, private]

This is called by OpDeletePoints::WillDeletePath in order to delete a PT_BEZIERTO endpoint from a path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> - from Jim code Date: 27/10/94 Parameters: pPath  - Pointer to the NodePath to delete the endpoint from. [INPUTS] Index - The number of the endpoint to delete PathExists - pointer to a BOOL for flaging that the whole path has been deleted. PathExists  - If the entire path has been deleted, *DeletedPath is set to TRUE [OUTPUTS] Returns: FALSE if an error occured during deletion, otherwise TRUE for sucess. See also: OpDeletePoints::WillDeletePath. OpDeletePoints::DeleteMoveTo. OpDeletePoints::DeleteLineTo Definition at line 7752 of file pathedit.cpp. { PathVerb* Verbs = pPath->InkPath.GetVerbArray(); PathFlags* Flags = pPath->InkPath.GetFlagArray(); // DocCoord* Coords = pPath->InkPath.GetCoordArray(); INT32 NumCoords = pPath->InkPath.GetNumCoords(); PathFlags TempFlags; DocCoord EndPoint; // See if this is the end of the path if (Index+1 != NumCoords) { // See what the next element is switch (Verbs[Index+1] & ~PT_CLOSEFIGURE) { case PT_LINETO: // A curve followed by a line. Just delete the curve. return pPath->InkPath.DeleteSection(Index-2, 3); break; case PT_BEZIERTO: // A curve followed by a curve. First delete the second control point, // the endpoint, and the first control point of the next (curve) element return pPath->InkPath.DeleteSection(Index-1, 3); break; case PT_MOVETO: // Tricky again, the next point is a MoveTo, so we have to check all the special // cases like closed paths, paths with single elements, etc. if (Verbs[Index] & PT_CLOSEFIGURE) { // The path is closed, For now, deselect it Flags[Index].IsSelected = FALSE; return TRUE; } else { // We might safely be able to delete this // section, as long as the previous element isn't a MoveTo, in which case // we have to delete the whole subpath if (Verbs[Index-3] == PT_MOVETO) { // Delete the whole subpath return pPath->InkPath.DeleteSection(Index-3, 4); } else { // Only delete the curve section return pPath->InkPath.DeleteSection(Index-2, 3); } } break; default: ERROR2(FALSE,"Corrupt path found in DeleteBezierTo"); } } else { // This is the case when we're at the end of the path if (Verbs[Index] & PT_CLOSEFIGURE) { // the path is closed. This is still tricky (see above and above) Flags[Index].IsSelected = FALSE; return TRUE; } else { // The path isn't closed, so check for this being the only element in the path if (Verbs[Index-3] == PT_MOVETO) { // Either this could be one of many subpaths, or the only subpath if (NumCoords == 4) { *PathExists = FALSE; return TRUE; } else { // There are other subpaths, so just delete this one return pPath->InkPath.DeleteSection(Index-3, 4); } } else { // It's not the only element in the path so delete it return pPath->InkPath.DeleteSection(Index-2, 3); } } } }

BOOL OpDeletePoints::TryDeleteLineTo (  NodePath *  pPath, INT32  Index, BOOL *  PathExists )  [static, private]

This is called by OpDeletePoints::WillDeletePath in order to delete a PT_LINETO endpoint from a path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> - from Jim code Date: 29/04/95 Parameters: pPath  - Pointer to the NodePath to delete the endpoint from. [INPUTS] Index - The number of the endpoint to delete PathExists - pointer to a BOOL for flaging that the whole path has been deleted. PathExists  - If the entire path has been deleted, *DeletedPath is set to TRUE [OUTPUTS] Returns: FALSE if an error occured during deletion, otherwise TRUE for sucess. See also: OpDeletePoints::WillDeletePath. OpDeletePoints::DeleteMoveTo. OpDeletePoints::DeleteBezierTo Definition at line 7456 of file pathedit.cpp. { // Get the path pointers INT32 NumCoords = pPath->InkPath.GetNumCoords(); PathVerb* Verbs = NULL; DocCoord* Coords = NULL; PathFlags* Flags = NULL; pPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); // work differently depending on if this is the last point in the path if (Index+1 != NumCoords) { // See what the next element is switch (Verbs[Index+1] & ~PT_CLOSEFIGURE) { case PT_LINETO: // Delete the current line, createing a line from Index-1 to Index +1 return (pPath->InkPath.DeleteSection(Index, 1)); break; case PT_BEZIERTO: // Delete the folloing curve, creating a line from Index-1 to Index+3 Flags[Index].IsSelected = Flags[Index+3].IsSelected; Coords[Index] = Coords[Index+3]; return pPath->InkPath.DeleteSection(Index+1, 3); break; case PT_MOVETO: // Next point is a MoveTo so this is the last point in a subpath if (Verbs[Index] & PT_CLOSEFIGURE) { // Subpath is closed, leave it it to the next moveto Flags[Index].IsSelected = FALSE; return TRUE; } else { // This subpath is open, so we either just delete the element // or if the previous element is a MoveTo, we delete that as well if (Verbs[Index-1] == PT_MOVETO) return (pPath->InkPath.DeleteSection(Index-1, 2)); else return (pPath->InkPath.DeleteSection(Index, 1)); } break; default : ERROR2(FALSE, "Corrupted path found in DeleteLineTo"); } } else { // Here, the point being deleted is the last point in the path // See if the path is closed if (Verbs[Index] & PT_CLOSEFIGURE) { // Just deselect the last point Flags[Index].IsSelected = FALSE; return TRUE; } else { if (Verbs[Index-1] == PT_MOVETO) { if (NumCoords == 2) { // This is the only path, so delete the whole node *PathExists = FALSE; return TRUE; } else { // It's not the only subpath, so just delete these two elements return (pPath->InkPath.DeleteSection(Index-1, 2)); } } else { // It's not the only element in the subpath, so just delete it return (pPath->InkPath.DeleteSection(Index, 1)); } } } }

BOOL OpDeletePoints::TryDeleteMoveTo (  NodePath *  pPath, INT32  Index, BOOL *  PathExists )  [static, private]

This is called by OpDeletePoints::WillDeletePath in order to delete a PT_MOVETO endpoint from a path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> - from Jim code Date: 27/10/94 Parameters: pPath  - Pointer to the NodePath to delete the endpoint from. [INPUTS] Index - The number of the endpoint to delete PathExists - pointer to a BOOL for flaging that the whole path has been deleted. PathExists  - If the entire path has been deleted, *DeletedPath is set to TRUE [OUTPUTS] Returns: FALSE if an error occured during deletion, otherwise TRUE for sucess. See also: OpDeletePoints::WillDeletePath. OpDeletePoints::DeleteLineTo. OpDeletePoints::DeleteBezierTo Definition at line 7554 of file pathedit.cpp. { // Get the path pointers INT32 NumCoords = pPath->InkPath.GetNumCoords(); PathVerb* Verbs = NULL; DocCoord* Coords = NULL; PathFlags* Flags = NULL; pPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); // See if this subpath is closed if (pPath->InkPath.IsSubPathClosed(Index)) { // Deselect it Flags[Index].IsSelected = FALSE; // Get the index of the other end of the subpath INT32 EndIndex = Index; pPath->InkPath.FindEndOfSubPath(&EndIndex); // There are situations where we have got a two element path, a MoveTo, then either // a LineTo or a BezierTo. We must deal with the case of both endpoints being // selected and remove the entire sub-path. INT32 SubPathElements = EndIndex - Index; if (Verbs[EndIndex] == PT_BEZIERTO) SubPathElements += 2; if (((SubPathElements == 1) && (Flags[Index+1].IsSelected) ) || ((SubPathElements == 3) && (Flags[Index+3].IsSelected) && ((Verbs[Index+3] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) ) ) { if (SubPathElements == 1) { Flags[Index+1].IsSelected = FALSE; return (pPath->InkPath.DeleteSection(Index, 2)); } else { Flags[Index+3].IsSelected = FALSE; return (pPath->InkPath.DeleteSection(Index, 4)); } } // Now EndIndex tells us where the end element is PathVerb StartVerb = Verbs[Index+1] & ~PT_CLOSEFIGURE; PathVerb EndVerb = Verbs[EndIndex] & ~PT_CLOSEFIGURE; if ( StartVerb == PT_BEZIERTO && EndVerb == PT_BEZIERTO ) { // Both beziers. What we do here is remember the second // control point of the first bezier, as well as the endpoint, // then change the second control point and the endpoint // of the last bezier accordingly Coords[EndIndex+1] = Coords[Index+2]; Flags[EndIndex+1] = Flags[Index+2]; Verbs[EndIndex+1] = Verbs[Index+2]; Coords[EndIndex+2] = Coords[Index+3]; Flags[EndIndex+2] = Flags[Index+3]; Coords[Index] = Coords[Index+3]; return pPath->InkPath.DeleteSection(Index+1, 3); } else if (StartVerb == PT_LINETO && EndVerb == PT_BEZIERTO) { // When one element is a line, we always keep the line // In this case, we have to change the coords of the // moveto to be the same as the start of the final section, // then delete the final section Coords[Index] = Coords[EndIndex-1]; Verbs[EndIndex-1] = Verbs[EndIndex-1] | PT_CLOSEFIGURE; Coords[Index] = Coords[Index+3]; return pPath->InkPath.DeleteSection(EndIndex, 3); } else if (StartVerb == PT_BEZIERTO && EndVerb == PT_LINETO) { // Similar to the previous case, except the lineto is at the end // What we do here is set the lineto coord and the moveto coord // to the the endpoint of the first (curve) element, making sure the // lineto selection bit is clear. Flags[EndIndex].IsSelected = Flags[Index+3].IsSelected; Coords[EndIndex] = Coords[Index+3]; Coords[Index] = Coords[Index+3]; return pPath->InkPath.DeleteSection(Index+1, 3); } else { // start and end must be linetos // Alter the final lineto and the moveto to have the coords of // the end of the first lineto Coords[Index] = Coords[Index+1]; Coords[EndIndex] = Coords[Index+1]; Flags[EndIndex].IsSelected = Flags[Index+1].IsSelected; return pPath->InkPath.DeleteSection(Index+1, 1); } // Recache the pointers pPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); // The last thing I have to do is check the selected status of the new endpoint // and select the MoveTo if it is selected, and deselect the moveto otherwise // Index is still valid for the start of the path EndIndex = Index; pPath->InkPath.FindEndOfSubPath(&EndIndex); BOOL IsSelected; if ((Verbs[EndIndex] & ~PT_CLOSEFIGURE) == PT_BEZIERTO) IsSelected = Flags[EndIndex+2].IsSelected; else IsSelected = Flags[EndIndex].IsSelected; // Change the selection of the MoveTo to match the selection // of the endpoint in this closed path Flags[Index].IsSelected = IsSelected; } else { // The path isn't closed. // Are we looking at the start of a curve or a line? if ((Verbs[Index+1] & ~ PT_CLOSEFIGURE) == PT_BEZIERTO) { // We're deleting this bezier segment. We have to check if this is a lone element if (Index+4 == NumCoords || Verbs[Index+4] == PT_MOVETO) { // It's a lone element, so either delete the subpath or delete the whole node if (NumCoords == 4) { *PathExists = FALSE; return TRUE; } else return pPath->InkPath.DeleteSection(Index, 4); } else { Coords[Index] = Coords[Index+3]; Flags[Index].IsSelected = Flags[Index+3].IsSelected; return pPath->InkPath.DeleteSection(Index+1, 3); } } else { // Since we can't have a moveto following a moveto, the next element // has to be a path (let's check that with an ENSURE) ERROR2IF(((Verbs[Index+1] & ~PT_CLOSEFIGURE) != PT_LINETO), FALSE, "Badly formed path in DeletePoint"); // Check if it's a single element if (Index+2 == NumCoords || Verbs[Index+2] == PT_MOVETO) { // It's a lone element so either delete the subpath or the whole path // See if this is the only subpath if (NumCoords == 2) { *PathExists = FALSE; return TRUE; } else return pPath->InkPath.DeleteSection(Index, 2); } else { // There is another element after this, so delete the line element // and alter the Moveto element so that it goes to where the endpoint // used to go Coords[Index] = Coords[Index+1]; Flags[Index].IsSelected = Flags[Index+1].IsSelected; return pPath->InkPath.DeleteSection(Index+1, 1); } } } }

BOOL OpDeletePoints::WillDeleteEntirePath (  NodePath *  pTreePath  )  [static, private]

Sees if some of the path will remain after a delete points operation. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 29/04/95 Parameters: Points  to a NodePath in the tree [INPUTS] -  [OUTPUTS] Returns: TRUE if a call to DeletePoints will result in the entire path being deleted FALSE if some of the path will remain in the document Errors: - See also: OpDeletePoints::GetState Definition at line 7364 of file pathedit.cpp. { // If the path has no selected endpoints then it won't be deleted if (!pTreePath->InkPath.IsSubSelection()) return FALSE; // Get the path pointers; INT32 NumCoords = pTreePath->InkPath.GetNumCoords(); PathVerb* Verbs = NULL; DocCoord* Coords = NULL; PathFlags* Flags = NULL; pTreePath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); BOOL PathStillExists = TRUE; // We need to scan all the endpoints. If there are ALL selected then we can // just delete the whole path. INT32 loop = 0; BOOL Selected = TRUE; while (Selected && (loop < NumCoords)) { if (Flags[loop].IsEndPoint && !Flags[loop].IsSelected) Selected = FALSE; loop++; } if (Selected) return TRUE; // Make a copy of the path before testing the delete NodePath* pPath = (NodePath*)pTreePath->SimpleCopy(); if (pPath == NULL) return FALSE; // We have to delete every selected endpoint in the path while (PathStillExists) { // First refresh the pointers to the arrays NumCoords = pPath->InkPath.GetNumCoords(); pPath->InkPath.GetPathArrays(&Verbs, &Coords, &Flags); // Scan for a selected endpoint INT32 i; for ( i =0;i<NumCoords && (!Flags[i].IsSelected || !Flags[i].IsEndPoint);i++) ; // ; deliberate // break out if we didn't find an endpoint if (i == NumCoords) break; // i indexes into a selected endpoint which we have to delete. switch (Verbs[i] & ~PT_CLOSEFIGURE) { case PT_LINETO: TryDeleteLineTo(pPath, i, &PathStillExists); break; case PT_BEZIERTO: TryDeleteBezierTo(pPath, i, &PathStillExists); break; case PT_MOVETO: TryDeleteMoveTo(pPath, i, &PathStillExists); break; default: ERROR3("What was that path verb?"); } } // now that we have deleted every selected point on the path we need to check // the path to see if is still valid if (PathStillExists) PathStillExists = pPath->IsPathAllowable(); delete pPath; return !PathStillExists; }

---

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

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

---