OpFreeHand Class Reference

This is the FreeHand Operation that builds a smoothed curve. More...

#include <opfree.h>

Inheritance diagram for OpFreeHand:

List of all members.

Public Member Functions
	OpFreeHand ()
	Constructor. This simply sets a few of the operation flags.
void	DoDrag (DocCoord Anchor, Spread *, INT32, FreeHandJoinInfo *pJoinInfo, Path *ToolPath)
	Starts up the drag operation by storing all start positions and setting up a Path to store the mouse movement in.
virtual BOOL	SnappingDrag ()
virtual BOOL	DragKeyPress (KeyPress *pKeyPress, BOOL bSolidDrag)
	Find out if any of the key modifiers are being pressed when the mouse is not moving.
virtual void	DragPointerMove (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL bSolidDrag)
	Handles the event of the mouse moving during a drag.
virtual void	DragPointerIdle (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL bSolidDrag)
	This function checks the Adjust Click modifier while the mouse is not moving to see if it is released during a straight line mode edit. This means that the shift key can be toggled in mid drag to create a straight line shape.
virtual void	DragFinished (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL Success, BOOL bSolidDrag)
	Handles the drag finishing by rubbing out an EOR on the screen and adding the path to the tree and building all the undo that will be needed.
void	RenderDragBlobs (DocRect, Spread *, BOOL bSolidDrag)
	EORs the whole path onto the screen a segment at a time. It needs to do it a segment at a time as that is how it is drawn as the path is created. This has to redraw it identically or there will be bits of EORed stuff left all over the place.
virtual BOOL	IsBrushOp ()
Static Public Member Functions
static BOOL	Declare ()
	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	LoadCursors ()
	Tries to Load all the cursors used by the Free Hand Operation.
void	RemoveCursors ()
	Gets rid of all this operations cursors. It takes the cursor I was using off the top of the stack and deletes all the cursors I had allocated.
void	SetCursorOnMove (ClickModifiers ClickMods, Spread *pSpread, DocCoord *PointerPos)
	Decides which cursor to display depending on which modifiers are pressed and where the mouse is. PointerPos can be changed in this function.
virtual void	SetCursorAndStatus (CursorType CurType)
	Chanages the cursor to the type requested and sets the status bar message to the appropriate message for the mode we are in.
BOOL	PrepareTrackDataPath ()
	Tries to initialise the path that we will store the track data in. It also sets up the pressure info stuff it there is pressure info coming in. If the path initialise ok, then it inserts the initial position (including its pressure) into the path. This function will only fail if there is no memory to init the path with.
void	RubOutPath (DocCoord Pos, Spread *pSpread)
	Tries to rub out sections of the path that have already been drawn.
void	AddPointsToPath (DocCoord Pos, Spread *pSpread)
	Adds a new point to the path of mouse moves. When the drag finishes the mouse moves will be smoothed.
BOOL	CheckMouseOverSelectedPath (DocCoord *Pos, Spread *pSpread, BOOL *IsNearEndpoint)
	Checks to see if the mouse is over the endpoint of any of the selected paths in the document and if it is, it makes a note of the path and which end it was attached to.
BOOL	AreSlotsInSameSubPath (INT32 Slot1, INT32 Slot2, Path *pPath)
	This function is used when editing lines with the freehand tool. If the drag was started in the middle of a path and the cursor is over that path again, we need to know if we can complete the edit. This is only possible if the start and end points are both on the same sub-path in the path. This function is used to determine if the 2 points are indeed in the same sub-path to allow the tool to display correct cursor etc.
BOOL	CompleteOperation ()
	Does all the steps required to build a new path, smooth it, try to join it with others and finally insert it into the tree.
BOOL	CreateNewPath (NodePath **pNewPath)
	Builds a new Node Path ready to have a Curve fitted into it. If anything goes wrong (not enough memory, the path was not worth fitting etc) then this function fails.
BOOL	SmoothNewCurve (NodePath *pNewNodePath)
	Sets up the curve fitter and finally smooths the data in the Track data buffer into the new node path.
BOOL	InsertSmoothCurveWithUndo (NodePath *pNewNodePath)
	Starts the Selection operation (recording the selection state etc) and trys to join our new path with any others touching it, before inserting it into the tree.
virtual BOOL	TryToReplaceSection (NodePath *pNewNodePath)
	Replaces a section from the path that the drag was started and finished on with the newly drawn curve section.
BOOL	SplitAtPoint (const DocCoord &SplitPoint, INT32 *, INT32 *)
	Splits the path, building undo info, at the coord supplied.
BOOL	ReplaceMiddleOfPath (NodePath *pNewPath, INT32 FirstChangedIndex, INT32 NumElements)
	This will replace a section of the path with a new path, building undo as it goes. This function will also set up the Retro Curve fitting data so that it is able to retro fit the new section of the path.
virtual BOOL	EditBrushLists (NodePath *pNewPath, INT32 FirstChangedIndex, INT32 NumElements)
	When a path is edited that has a timestamping brush applied to it we those points are stored in a list that is generated when the path is drawn. If we subsequently want to edit that path we have to insert or remove points from that list. This function works out what points should be inserted or removed, and performs that action on the applied brush.
virtual BOOL	SimpleJoinBrush (NodePath *pNodePath, Path *pPath)
	Currently this only has to do work if we are editing a brush containing pressure data. In this case we must generate a new list of pressure info and insert it into the brush.
virtual BOOL	ReverseBrushPressure ()
	The base class version does nothing, derived class should reverse its pressure cache.
virtual BOOL	RetroSmoothBrush (NodePath *pNodePath)
	As above, the base class version does nothing.
BOOL	TryToJoinNewPathWithOthers (NodePath *FreePath)
	Tries to Join the new path with any of the existing paths.
BOOL	SimpleJoin (NodePath *FreePath, NodePath *OldPath)
	Joins a Simple path with the new freehand path and builds all the undo that is needed in the process.
BOOL	ComplexJoin (NodePath *FreePath, NodePath *OldPath)
	Joins a Complex path with the new freehand path and builds all the undo that is needed in the process.
BOOL	ComplexToComplexJoin (NodePath *FreePath, NodePath *OldPath)
	Joins a Complex path with the new freehand path and builds all the undo that is needed in the process. The new freehand path joins two of the complex paths sub-paths together.
BOOL	VeryComplexToComplexJoin (NodePath *FreePath, NodePath *TopPath, NodePath *BotPath)
	Joins the new freehand path with two other paths (Which may or may not be complex) and builds all the undo info that is needed.
virtual BOOL	ApplyAttributes (NodePath *NewPath, Document *pDocument)
	Applies the current attributes to the Node passed in. It has to find the current document to do this and will ENSURE if it fails to find one.
BOOL	AddPressureAttribute (NodePath *NewPath)
	If pressure recording is enabled, this method builds attributes to apply to the path in order to attach the pressure as a variable-width stroking description.
NodePath *	MakeCopy (Node *pOriginalNode)
	Copies the node pOriginalNode and all its children an returns a pointer to them. It makes sure that the Node is a NodePath (Which it should be).
BOOL	InsertNewNode (NodePath *pNewNode, DocRect &Invalid, Node *pOldNode, Node *pOtherOld=NULL)
	Inserts a new path into the tree and hides the original node that it was Joined to. It will also invalidate the region of the new path that is different.
void	SetRetroPath (NodePath *pNodePath, INT32 Start, INT32 Len)
	Calls the freehand tool with details about the new path, so that future changes in the smoothness will re-build the new path.
void	AddStraightLine ()
	Adds a straight line to the Path, that has been made by the Straight Line Mode. This means it has to set some flags in the path to stop the curve fitter from smoothing this straight line segment out.
void	RenderLine (RenderRegion *pRender, Path *pPath, INT32 CoordIndex, BOOL StartCoord=FALSE)
	Renders an EORed line between 2 coordinates in the path. May render pressure information feedback using the pressure stored with the path corrdinates.
void	RenderLine (DocRect *Rect, Spread *pSpread, Path *pPath, INT32 Index, BOOL StartCoord=FALSE)
	Renders an EORed line between 2 coordinates in the path. May render pressure information feedback using the pressure stored with the path corrdinates.
void	RenderEorStraightLine (DocRect *, Spread *pSpread, DocCoord *Start=NULL, DocCoord *End=NULL)
	Renders the EORed rubber band straight line that is used in Straight Line Mode. It simply draws a single Straight Line segment.
void	RenderEorStraightLine (RenderRegion *pRender, DocCoord *pStart, INT32 StartWidth, DocCoord *pEnd, INT32 EndWidth)
	Simply renders a straight-line segment to the given render region.
SimpleJoinType	GetSimpleJoinType (Path *pNewPath, Path *ExistingPath)
	This function works out how the new path joins onto the existing path.
INT32	GetCurrentLineWidth (void)
	Determines the current line width (the width of any future lines the user will draw) by asking the attribute manager.
NodeGroup *	GetParentOfNodePath ()
	To determine if the current selection is a blend on a curve.
BOOL	InsertChangeBlendStepsAction (NodeBlend *pNodeBlend)
	To adjust the number of steps in a blend on a path as a result of the path being edited (which is why its here rather than in the blend code). First the number of steps is calculated from the new path distance and if different a new action is inserted.
BOOL	InvalidateBrushRegion (NodePath *pNodePath)
	We may be editing a brushed path with the FHT so this function makes sure the correct region is invalidated.
Protected Attributes
Path *	TrackData
DocCoord	StartPoint
Spread *	StartSpread
Spread *	PreviousSpread
INT32	Smoothness
DocCoord	PreviousPoint
INT32	LineSegmentCount
BOOL	CanLineJoin
BOOL	IsStraightLineMode
DocCoord	StraightLinePos
BOOL	AddPressureToPath
UINT32	FreeHandPressure
FreeHandJoinInfo *	pJoinInfo
NodePath *	StartPath
NodePath *	EndPath
INT32	CloseTo
double	Mu
BOOL	IsEndNearEndpoint
Cursor *	pFreeHandCursor
Cursor *	pJoinCursor
Cursor *	pRubOutCursor
Cursor *	pStraightCursor
Cursor *	pModifyCursor
Cursor *	MyCurrentCursor
INT32	CurrentCursorID
NodePath *	m_pNewNodePath
Private Member Functions
	CC_DECLARE_DYNCREATE (OpFreeHand)

---

Detailed Description

This is the FreeHand Operation that builds a smoothed curve.

Author:

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

Date:

1/7/93

Definition at line 167 of file opfree.h.

---

Constructor & Destructor Documentation

OpFreeHand::OpFreeHand (   )

Constructor. This simply sets a few of the operation flags. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/93 Definition at line 168 of file opfree.cpp. { // Set all our cursors to NULL to start with pFreeHandCursor = NULL; pJoinCursor = NULL; pStraightCursor = NULL; pRubOutCursor = NULL; pModifyCursor = NULL; // Set other default values TrackData = NULL; StartSpread = NULL; PreviousSpread = NULL; Smoothness = 512; LineSegmentCount = 0; CanLineJoin = FALSE; IsStraightLineMode = FALSE; AddPressureToPath = FALSE; FreeHandPressure = 0; // The paths that we are joined to, or NULL if we are joined to none pJoinInfo = NULL; StartPath = NULL; EndPath = NULL; CloseTo = 0; Mu = 0.0; IsEndNearEndpoint = FALSE; CurrentCursorID = 0; m_pNewNodePath = NULL; }

---

Member Function Documentation

void OpFreeHand::AddPointsToPath (  DocCoord  PointerPos, Spread *  pSpread )  [protected]

Adds a new point to the path of mouse moves. When the drag finishes the mouse moves will be smoothed. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 13/4/94 Parameters: Pos  - The position of the mouse [INPUTS] pSpread - Pointer to the spread that we are drawing on Reimplemented in OpDrawBrush. Definition at line 1079 of file opfree.cpp. { // If this coord is the same as the last one, then do not bother adding to the track data if (PreviousPoint == PointerPos) return; // Insert the move if (TrackData->InsertLineTo(PointerPos)) { // and add pressure info if needed if (AddPressureToPath) TrackData->AddExtraInfo(CI_PRESSURE, FreeHandPressure); } else { // Oh no, we ran out of mem in the middle of making a new path // Tidy up and report back to HQ EndDrag(); // Tell the World that it all went horribly wrong InformError(); // Remove it from the tree and delete it TrackData->ClearPath(); // End this operation and return FailAndExecute(); End(); return; } // Now we have to render a new bit of EORed data to the screen RenderLine(NULL, pSpread, TrackData, TrackData->GetNumCoords()-1); // Make a note of the coord, inc the line count and mark joining to the start as active. PreviousPoint = PointerPos; LineSegmentCount++; CanLineJoin = TRUE; }

BOOL OpFreeHand::AddPressureAttribute (  NodePath *  pNewPath  )  [protected]

If pressure recording is enabled, this method builds attributes to apply to the path in order to attach the pressure as a variable-width stroking description. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/1/97 Parameters: NewPath  - The NodePath to apply the attributes to [INPUTS] Returns: TRUE if it worked, FALSE if it did not This attaches an AttrStrokeType to control stroking, and an AttrVariableWidth to record the pressure values Definition at line 1858 of file opfree.cpp. { if (IsBrushOp()) return TRUE; // Taken out by vector stroking code Neville 2/10/97 #ifdef VECTOR_STROKING ERROR3IF(GetWorkingDoc() == NULL, "No working doc"); ERROR3IF(pNewPath == NULL, "Illegal NULL param"); ERROR3IF(TrackData == NULL, "Trackdata is NULL"); // If pressure recording is disabled, then we don't need to do anything if (TrackData == NULL || !AddPressureToPath) return(TRUE); // --- Generate a smoothed pressure function from the recorded pressure samples // If this fails, then we still return TRUE, and the path just loses pressure information PressureSmoother Bob; ValueFunction *pValFunc = Bob.Smooth(TrackData, GetCurrentLineWidth()); if (pValFunc == NULL) return(TRUE); // We only want to override the stroke type if it is a simple constant-width line // - if there is any new-style stroke type applied, we won't try to override it BOOL ApplyType = FALSE; // BLOCK { Node *pNode = pNewPath->FindFirstChild(); if (pNode != NULL) pNode = pNode->FindNext(CC_RUNTIME_CLASS(AttrStrokeType)); ApplyType = (pNode == NULL); // If there are no StrokeType attrs applied already, we must apply one if (!ApplyType) { // If there is another StrokeType, but it will not stroke using the variable width info, // (i.e. has a NULL PathProcessor attached to it) we will need to replace it. StrokeTypeAttrValue *pSAV = (StrokeTypeAttrValue *) ((AttrStrokeType *)pNode)->GetAttributeValue(); if (pSAV->GetPathProcessor() == NULL) ApplyType = TRUE; } } // --- Create a simple variable-width path stroke attribute AttrStrokeType *pStrokeType = NULL; if (ApplyType) { pStrokeType = new AttrStrokeType; if (pStrokeType == NULL) return(TRUE); // Return TRUE - we'll only lose the pressure info PathProcessorStroke *pProcessor = new PathProcessorStroke; if (pProcessor == NULL) { delete pStrokeType; return(TRUE); // Return TRUE - we'll only lose the pressure info } // And attach the stroker to the attribute ((StrokeTypeAttrValue *)pStrokeType->GetAttributeValue())->SetPathProcessor(pProcessor); } // --- Create a pressure table variable-width attribute AttrVariableWidth *pVarWidth = new AttrVariableWidth; if (pVarWidth != NULL) ((VariableWidthAttrValue *)pVarWidth->GetAttributeValue())->SetWidthFunction(pValFunc); if (pVarWidth == NULL) { if (pStrokeType != NULL) delete pStrokeType; return(TRUE); // Return TRUE - we'll only lose the pressure info } // --- Now apply the attributes to the path, removing any of a similar type which // are already applied to it. if (ApplyType) { DoRemoveAttrTypeFromSubtree(pNewPath, pStrokeType->GetRuntimeClass()); pStrokeType->AttachNode(pNewPath, FIRSTCHILD, FALSE, FALSE); } // And apply the variable width attribute DoRemoveAttrTypeFromSubtree(pNewPath, pVarWidth->GetRuntimeClass()); pVarWidth->AttachNode(pNewPath, FIRSTCHILD, FALSE, FALSE); #endif // VECTOR_STROKING return(TRUE); }

void OpFreeHand::AddStraightLine (   )  [protected]

Adds a straight line to the Path, that has been made by the Straight Line Mode. This means it has to set some flags in the path to stop the curve fitter from smoothing this straight line segment out. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/4/94 Definition at line 1132 of file opfree.cpp. { PathFlags Flags; Flags.Spare1 = TRUE; // If this coord is the same as the last one, then do not bother adding to the track data if (PreviousPoint == StraightLinePos) return; // add the line segment into the path if (TrackData->InsertLineTo(StraightLinePos, &Flags)) { // and add pressure info if needed if (AddPressureToPath) TrackData->AddExtraInfo(CI_PRESSURE, FreeHandPressure); } else { // Oh no, we ran out of mem in the middle of making a new path // Tidy up and report back to HQ EndDrag(); // Tell the World that it all went horribly wrong InformError(); // Remove it from the tree and delete it TrackData->ClearPath(); // End this operation and return FailAndExecute(); End(); return; } // Count this bit of line LineSegmentCount++; CanLineJoin = TRUE; }

BOOL OpFreeHand::ApplyAttributes (  NodePath *  NewPath, Document *  pDocument )  [protected, virtual]

Applies the current attributes to the Node passed in. It has to find the current document to do this and will ENSURE if it fails to find one. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 4/5/94 Parameters: NewPath  - The NodePath to apply the current attributes to [INPUTS] pDocument - the document this path will be placed into. Returns: TRUE if it worked, FALSE if it did not Reimplemented in OpDrawBrush. Definition at line 1812 of file opfree.cpp. { // Find the current document to get the current attributes from ENSURE(pDocument!=NULL, "Null Document while setting attributes for new NodePath"); if (pDocument!=NULL) { // Apply the current attributes to the path if (pDocument->GetAttributeMgr().ApplyCurrentAttribsToNode((NodeRenderableInk*)NewPath)) { // ok special case exception here, if we have a brush attribute then delete it Node* pNode = NewPath->FindFirstChild(CC_RUNTIME_CLASS(AttrBrushType)); if (pNode) { pNode->CascadeDelete(); delete pNode; } return TRUE; } } // We failed to apply the attributes, so fail return FALSE; }

BOOL OpFreeHand::AreSlotsInSameSubPath (  INT32  Slot1, INT32  Slot2, Path *  pPath )  [protected]

This function is used when editing lines with the freehand tool. If the drag was started in the middle of a path and the cursor is over that path again, we need to know if we can complete the edit. This is only possible if the start and end points are both on the same sub-path in the path. This function is used to determine if the 2 points are indeed in the same sub-path to allow the tool to display correct cursor etc. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 2/6/95 Parameters: Slot1,Slot2  - The slot numbers of the 2 points in question. [INPUTS] pPath - the path that the slots live in Returns: TRUE if both these slots live in the same sub-path of pPath, FALSE if they are in different sub-paths, or there was an error. Definition at line 1304 of file opfree.cpp. { // saftey check ERROR2IF(pPath==NULL, FALSE, "NULL pointer passed to OpFreeHand::AreSlotsInSameSubPath"); // We need to look at the verb array in the path. PathVerb* pVerbs = pPath->GetVerbArray(); INT32 NumSlots = pPath->GetNumCoords(); // find the largest and smallest slot numbers INT32 First = Slot1<Slot2 ? Slot1 : Slot2; INT32 Last = Slot1<Slot2 ? Slot2 : Slot1; // Make sure that the slot numbers make sense ERROR2IF(Last>NumSlots, FALSE, "Bad Slot numbers in OpFreeHand::AreSlotsInSameSubPath"); // loop from the first to the last slot looking for MoveTos while (Last>First) { // See if the current last slot is a MoveTo if (pVerbs[Last]==PT_MOVETO) return FALSE; // move the last point back Last--; } // We did not find any MoveTos between the points return TRUE; }

OpFreeHand::CC_DECLARE_DYNCREATE (  OpFreeHand   )  [private]

BOOL OpFreeHand::CheckMouseOverSelectedPath (  DocCoord *  PointerPos, Spread *  pSpread, BOOL *  IsNearEndpoint )  [protected]

Checks to see if the mouse is over the endpoint of any of the selected paths in the document and if it is, it makes a note of the path and which end it was attached to. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/4/94 Parameters: PointerPos  - The position of the mouse [INPUTS] pSpread - the spread that the cursor is over IsNearEndPoint  - if this function returns TRUE this param is valid, otherwise [OUTPUTS] it is not. It will be TRUE if the cursor was found to be close to an open end of the path, or FALSE if it was near the middle of the path Returns: TRUE if the pointer was over the end of a selected line, FALSE if it was not Definition at line 1191 of file opfree.cpp. { // Assume we do not find a path EndPath = NULL; // Find out about the blob manager so we can find the size of a blob BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr==NULL) return FALSE; // Find out about the size of a blob DocRect BlobRect; pBlobMgr->GetBlobRect(*PointerPos, &BlobRect); // Find the selected range of objects SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); // see if the selection is on the same spread as the drag if (pNode!=NULL) { // Get the spread and return if it is different from the one with the cursor Spread* pNodeSpread = pNode->FindParentSpread(); if (pNodeSpread!=pSpread) return FALSE; } // Walk through the selection while (pNode!=NULL) { if (pNode->IsNodePath()) { // Now we know it's a NodePath, get a pointer to the Path object within it, so // we can find any endpoints Path* ThisPath = &(((NodePath*)pNode)->InkPath); // See if it touches any point in this path INT32 CloseSlot = 0; if (ThisPath->IsNearOpenEnd(BlobRect, &CloseSlot)) { // Yep, better work out where and set the path where is all happens ThisPath->SetPathPosition(CloseSlot); *PointerPos = ThisPath->GetCoord(); *IsNearEndpoint = TRUE; EndPath = (NodePath*)pNode; return TRUE; } // See if it is near the middle of the path // This is only relavent if this node is the same as the one we started on // and we started in the middle of it if ((StartPath!=NULL) && (StartPath==pNode) && (pJoinInfo->IsNearEndPoint==FALSE)) { INT32 Range = BlobRect.Width() / 2; if (ThisPath->IsPointCloseTo(*PointerPos, Range*Range, &CloseTo, &Mu)) { // OK, we are near the path we started on // see if we are in the same sub-path as we started on if (AreSlotsInSameSubPath(CloseTo, pJoinInfo->CloseSlot, ThisPath)) { // Yep, better work out where and set the path where is all happens *IsNearEndpoint = FALSE; EndPath = (NodePath*)pNode; return TRUE; } } } } // Now find the next selected node pNode = Selected->FindNext(pNode); } // we will see if this point is anywhere near the start point if ((BlobRect.ContainsCoord(StartPoint)) && (StartPath==NULL)) { // Note the path that we are starting at and modify the coord // This will make the start and end points the same, causing the path to be closed *PointerPos = StartPoint; // Wait till the cursor has moved out of the original snap range before we start joining if (CanLineJoin==TRUE) { *IsNearEndpoint = TRUE; return TRUE; } } // Did not find a join return FALSE; }

BOOL OpFreeHand::CompleteOperation (   )  [protected]

Does all the steps required to build a new path, smooth it, try to join it with others and finally insert it into the tree. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/94 Returns: TRUE if it worked, FALSE if not Definition at line 783 of file opfree.cpp. { // Create a new path to be inserted into the tree NodePath* pNewNodePath = NULL; if (!CreateNewPath(&pNewNodePath)) return FALSE; if (!SmoothNewCurve(pNewNodePath)) { // Get rid of the path we created and fail delete pNewNodePath; return FALSE; } if (!InsertSmoothCurveWithUndo(pNewNodePath)) { // Get rid of the path we created, and fail pNewNodePath->CascadeDelete(); delete pNewNodePath; return FALSE; } // Mark the selection as no longer valid (the Bounding Box will have changed) SelRange* Selection = GetApplication()->Selection; if (Selection) Selection->Update(); // All worked return TRUE; }

BOOL OpFreeHand::ComplexJoin (  NodePath *  FreePath, NodePath *  OldPath )  [protected]

Joins a Complex path with the new freehand path and builds all the undo that is needed in the process. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/94 Parameters: FreePath  - The New freehand Path that is to be joined [INPUTS] OldPath - The path that we are trying to Join to Returns: TRUE if it worked, FALSE if it failed Definition at line 1653 of file opfree.cpp. { // First we should make a note of the region that we will need redrawing DocRect InvalidRect = FreePath->GetBlobBoundingRect(); // Need to know where in the joined path that the new section will be INT32 NumSlots = FreePath->InkPath.GetNumCoords(); INT32 StartSlot; // Make a copy of the node we are joining with NodePath* JoinPath = MakeCopy(OldPath); if (JoinPath == NULL) return FALSE; // before Joining them BOOL NewPathReversed = FALSE; if (!JoinPath->InkPath.ComplexJoin(&FreePath->InkPath, &StartSlot, &NewPathReversed)) return FALSE; // Insert the new object if (!InsertNewNode(JoinPath, InvalidRect, OldPath)) return FALSE; // Reverse the original mouse move data if the fitted path was reversed if (NewPathReversed) TrackData->Reverse(); // Tell the freehand tool all about it SetRetroPath(JoinPath, StartSlot, NumSlots); m_pNewNodePath = JoinPath; // It Worked! return TRUE; }

BOOL OpFreeHand::ComplexToComplexJoin (  NodePath *  FreePath, NodePath *  OldPath )  [protected]

Joins a Complex path with the new freehand path and builds all the undo that is needed in the process. The new freehand path joins two of the complex paths sub-paths together. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/94 Parameters: FreePath  - The New freehand Path that is to be joined [INPUTS] OldPath - The path that we are trying to Join to Returns: TRUE if it worked, FALSE if it failed Definition at line 1705 of file opfree.cpp. { // First we should make a note of the region that we will need redrawing DocRect InvalidRect = FreePath->GetBlobBoundingRect(); // Need to know where in the joined path that the new section will be INT32 NumSlots = FreePath->InkPath.GetNumCoords(); INT32 StartSlot; // Make a copy of the of the path we are Joining to NodePath* JoinPath = MakeCopy(OldPath); if (JoinPath==NULL) return FALSE; // Join the new path with the one already there BOOL NewPathReversed = FALSE; if (!JoinPath->InkPath.ComplexToSameComplexJoin(&FreePath->InkPath, &StartSlot, &NewPathReversed)) return FALSE; // Insert the new object if (!InsertNewNode(JoinPath, InvalidRect, OldPath)) return FALSE; // Reverse the original mouse move data if the fitted path was reversed if (NewPathReversed) TrackData->Reverse(); // Tell the freehand tool all about it SetRetroPath(JoinPath, StartSlot, NumSlots); // It Worked! return TRUE; }

BOOL OpFreeHand::CreateNewPath (  NodePath **  pNewPath  )  [protected]

Builds a new Node Path ready to have a Curve fitted into it. If anything goes wrong (not enough memory, the path was not worth fitting etc) then this function fails. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/94 Parameters: pNewPath  - This will be a pointer to an initialised NodePath or NULL [OUTPUTS] Returns: TRUE if it worked, FALSE if something went wrong Definition at line 831 of file opfree.cpp. { // Get a pointer to the path and set it to NULL NodePath*& pFreeHandPath = *pNewPath; pFreeHandPath = NULL; // Only bother if they had actually drawn something if (LineSegmentCount==0) return FALSE; // See if the path ever got away from the initial snap coord DocCoord* Coords = TrackData->GetCoordArray(); INT32 NumCoords = TrackData->GetNumCoords(); BOOL IsAllSame = TRUE; // loop through all the coords comparing them with the first one for (INT32 i=0; (i<NumCoords) && (IsAllSame); i++) { // if this coord is different from the first one, then we are ok if (Coords[0] != Coords[i]) IsAllSame = FALSE; } // If it did not (ie all the coordinates were the same, then chuck it away) if (IsAllSame) return FALSE; // Init the path with the default memory block sizes pFreeHandPath = new NodePath; if (pFreeHandPath==NULL) return FALSE; // Ok, we got a new NodePath, try and init the Path inside it if (!pFreeHandPath->SetUpPath(24, 12)) { // The path failed to init, so get rid of it and fail delete pFreeHandPath; pFreeHandPath = NULL; return FALSE; } // Must have worked return TRUE; }

BOOL OpFreeHand::Declare (   )  [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 in OpDrawBrush. Definition at line 3278 of file opfree.cpp. { return (RegisterOpDescriptor( 0, _R(IDS_FREE_HAND_TOOL), CC_RUNTIME_CLASS(OpFreeHand), OPTOKEN_FREEHAND, OpFreeHand::GetState, 0, /* help ID */ _R(IDBBL_FREEHANDTOOLOP), 0 /* bitmap ID */)); }

void OpFreeHand::DoDrag (  DocCoord  Anchor, Spread *  pSpread, INT32  Smooth, FreeHandJoinInfo *  pFreeHandInfo, Path *  ToolPath )

Starts up the drag operation by storing all start positions and setting up a Path to store the mouse movement in. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/93 Parameters: Anchor  - The position of the mouse at the start of the Drag [INPUTS] pSpread - The spread that the drag started on Smooth - Closeness of fit value pFreeHandInfo - Pointer to the info about the Joining set up by the freehand tool ToolPath - The path to store the mouse tracking info in Definition at line 221 of file opfree.cpp. { TRACEUSER( "Diccon", _T("Do Drag Free, StartPos = %d, %d\n"), Anchor.x, Anchor.y); // WEBSTER - markn 25/4/97 // No pen stuff required in Webster // Taken out by vector stroking code Neville 2/10/97 #ifdef VECTOR_STROKING // Tell the pressure pen that we're starting a new stroke CCPen *pPen = GetApplication()->GetPressurePen(); if (pPen != NULL) pPen->StartStroke(); #endif // VECTOR_STROKING // Snap the starting coord if we are not joining to something else if ((pFreeHandInfo==NULL) || (pFreeHandInfo->pJoinPath==NULL)) DocView::SnapCurrent(pSpread, &Anchor, FALSE, TRUE); // Make a note of various starting conditions TrackData = ToolPath; Smoothness = Smooth; pJoinInfo = pFreeHandInfo; StartPath = pJoinInfo->pJoinPath; EndPath = NULL; // Make a mental note of the start point StartPoint = Anchor; StartSpread = pSpread; PreviousSpread= pSpread; PreviousPoint = Anchor; LineSegmentCount = 0; IsStraightLineMode = FALSE; CanLineJoin = FALSE; // Prepare the Track data path and add in the initial click point to the path if (!PrepareTrackDataPath()) { // We failed to get the memory to initialise the track data InformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK)); FailAndExecute(); End(); return; } // Create some cursors that I might need if (!LoadCursors()) { // The cursors did not load, so fail? FailAndExecute(); End(); return; } // Push my new cursor onto the stack CurrentCursorID = CursorStack::GPush(pFreeHandCursor, TRUE); MyCurrentCursor = pFreeHandCursor; // And tell the Dragging system that we need drags to happen StartDrag( DRAGTYPE_NOSCROLL ); }

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

Handles the drag finishing by rubbing out an EOR on the screen and adding the path to the tree and building all the undo that will be needed. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/93 Parameters: PointerPos  - The position of the mouse at the end of the drag [INPUTS] ClickMods - the key modifiers being pressed pSpread - The spread that the drag finished 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. Reimplemented in OpDrawBrush. Definition at line 647 of file opfree.cpp. { // Erase the whole EORed line DocRect ClipRect(0,0,0,0); RenderDragBlobs(ClipRect, StartSpread, bSolidDrag); // Get rid of all the cursors RemoveCursors(); // Put the hour glass up as we have to and end the drag BeginSlowJob(); EndDrag(); // Add the new path to the tree if it was valid BOOL Worked = FALSE; if (Success) { // were we in the middle of drawing a straight line if (IsStraightLineMode) { // we were so add it in to the track data AddStraightLine(); PreviousPoint = StraightLinePos; IsStraightLineMode = FALSE; } // try and smooth the path and insert it into the tree Worked = CompleteOperation(); // DY 9/99 Check to see if we are editing a blend on a curve, if so we may wish to // change the number of steps in the blend (making use of the path distance). NodeGroup* pParent = GetParentOfNodePath(); if (pParent!= NULL) { if (pParent->IS_KIND_OF(NodeBlend)) { InsertChangeBlendStepsAction((NodeBlend*)pParent); ObjChangeFlags cFlags(