BezierTool Class Reference

This class handles the Free Hand Tool that is used to draw lines that follow the path of the Mouse Pointer. More...

#include <beztool.h>

Inheritance diagram for BezierTool:

List of all members.

Public Types
enum	CurrentMode { New, Add, Change }
Public Member Functions
	BezierTool ()
	Dump Constructor - It does nothing. All the real initialisation is done in BezierTool::Init which is called by the Tool Manager.
	~BezierTool ()
	Destructor (Virtual). Does nothing.
BOOL	Init ()
	Used to check if the Tool was properly constructed.
void	Describe (void *InfoPtr)
	Allows the tool manager to extract information about the tool.
UINT32	GetID ()
void	SelectChange (BOOL)
	Called when the tool is selected or deselected. Creates and pushes the tool's cursor; pops and destroys it.
void	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	To handle a Mouse Click event for the Bezier Tool. It starts up a Bezier Operation.
virtual void	RenderToolBlobs (Spread *, DocRect *)
	Renders the Tools Blobs. The only blob this tool renders is the floating endpoint which only appears the the flag is set.
void	HandleInfoBarMessage (CDlgMessage DlgMsg, CGadgetID Gadget)
void	OnMouseMove (DocCoord, Spread *, ClickModifiers)
	This routine is called whenever the mouse moves while we're in the freehand tool. it sees what is under the pointer, and flips the cursor if clicking will have a different effect. The rules are:.
BOOL	OnKeyPress (KeyPress *)
	To handle keypress events for the Bezier Tool. If it is a keypress that it know about it starts up an appropiate operation. THIS IS BADLY WRONG AT THE MOMENT - WHEN THERE IS THE TECHNOLOGY FOR USER DEFINABLE KEY-SHORTCUTS THIS FUNCTION WILL NEED FIXING.
void	SetMoveTo (DocCoord MovePos, Spread *pSpread, Document *pDoc)
	This function is called from an operation which tells the tool that there should be a virtual moveTo coordinate at the given point. This virtual coordinate looks much like the old single moveto used to in ArtWorks, with the added advantage that it doesn't really exist, so it can't cock up the tree like they used to do in ArtWorks.
void	ClearMoveTo ()
	Clears the floating endpoint condition.
BOOL	GetMoveTo (Spread **ppSpread, DocCoord *pCoord, Document **ppDoc)
	Read the state of the floating endpoint.
void	SetModeFlag ()
	Sets the current tool mode (new/add/change) and gets the infobar to redraw the text item that shows it. We are in New mode if there are no selected lines. We are in Add mode if there is just one endpoint on the end od a path selected. Otherwise we are in Change mode.
BOOL	GetStatusLineText (String_256 *ptext, Spread *pSpread, DocCoord DocPos, ClickModifiers ClickMods)
	generate up-to-date text for the status line (called on idles)
void	GenerateStatusLineText (String_256 *ptext, Spread *pSpread, DocCoord DocPos, ClickModifiers ClickMods)
	To find the string to display on the status line given the current mouse position.
Protected Member Functions
BOOL	CyclePathPoints (BOOL Fowards)
	Performs the cycle the selected points task. The selection status of each endpoint on selected paths is applied to the next endpoint.
BOOL	HomePathPoints ()
	Moves the selected endpoints back along the selected path(s) so that the first point is selected. The pattern of selection remains the same.
BOOL	EndPathPoints ()
	Moves the selected endpoints foward along the selected path(s) so that the last point is selected. The pattern of selection remains the same.
BOOL	AutoClosePaths ()
	Runs through all selected lines. If the path is open and either of the ends are selected then the path is closed.
void	RemoveFloater (DocCoord *FloatPos, Spread *FloatSpread, Document *pDoc)
	Invokes the operation to remove the floating endpoint.
void	RetroSmoothChanging (double Smooth)
	Scan the selection for a path to smooth. If we find only one path object selected then we should tell the retro smooth code to begin smoothing. Arh!, actually we need to be able to keep track of the selected object? possibly.... Surely its fast enough already to find the selected objects, there must be some caching going on somewhere. Ok, best thing to do is to make sure theres only one selected object and ignore the slider change if there isn't.
void	RetroSmoothFinished ()
	Calls the retro smooth finalisation code to perform the completed smoothing action.
void	RetroSmoothSet (INT32 percent, BOOL Enabled)
	Set the position of the retro smooth slider, given a percentage value. The function will also update the percent text field.
void	RetroSmoothInvalidate ()
	Invalidate the retro smooth cached information.
void	UpdateRetroSlider (Path *pPath)
	Sets the retro smooth slider position for a given path.
void	ResetRetroSlider ()
	There has been a change in the selection so we need to update the retro slider state.
Node *	OneNodePathSelected ()
	Checks the selection and determins whether exactly one nodepath object is selected.
void	ChangeCursor (Cursor *cursor)
	Changes to the specified cursor. Will only change the cursor if it isn't already this cursor, so it doesn't flicker.
clickeffect	DetermineClickEffect (DocCoord PointerPos, Spread *pSpread, NodeRenderableInk **ReturnNode, INT32 *ReturnPosition, INT32 *NumSelectedPaths, INT32 *NumSelectedPoints)
	Used when the cursor moves and when single clicking. This routine determines what effect a click will have. In this tool, clicking will either select a point on an already selected line, reshape a line segment (a la Corel), add a segment to the end of a line, or start a new path entirely.
NodePath *	FindEditablePath (Node *pSelected)
	Finds the node to edit (if it exists). This node could actually be the selected node passed as a parameter or one of its children which the node wants to be editable.
Protected Attributes
DocCoord	StartPos
Spread *	StartSpread
Cursor *	pcMoveBezCursor
Cursor *	pcReshapeLineCursor
Cursor *	pcNewPathCursor
Cursor *	pcAddPathCursor
Cursor *	pcClosePathCursor
Cursor *	MyCurrentCursor
INT32	CurrentCursorID
BOOL	FloatingEndpoint
Document *	MoveToDoc
DocCoord	MoveToPoint
Spread *	MoveToSpread
RetroSmooth *	pSmooth
BOOL	RetroFlag
Node *	pRetroNode
Spread *	pRetroSpread
BOOL	DontDrawOnClearMoveTo
CurrentMode	CurrentToolMode
Static Protected Attributes
static TCHAR *	FamilyName = _T("Drawing Tools")
static TCHAR *	ToolName = _T("Bezier Tool")
static TCHAR *	Purpose = _T("To Draw arbitrary lines")
static TCHAR *	Author = _T("Jim (latterly Peter)")
static BezToolInfoBarOp *	pBezToolInfoBarOp = NULL
static BOOL	CreateCurve = TRUE
static BOOL	CreateCusp = FALSE
Private Member Functions
	CC_DECLARE_MEMDUMP (BezierTool)
Friends
class	BezToolInfoBarOp

---

Detailed Description

This class handles the Free Hand Tool that is used to draw lines that follow the path of the Mouse Pointer.

Author:

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

Date:

20/7/93

Definition at line 242 of file beztool.h.

---

Member Enumeration Documentation

enum BezierTool::CurrentMode

Enumerator: New  Add  Change  Definition at line 250 of file beztool.h. {New, Add, Change};

---

Constructor & Destructor Documentation

BezierTool::BezierTool (   )

Dump Constructor - It does nothing. All the real initialisation is done in BezierTool::Init which is called by the Tool Manager. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 See also: BezierTool::Init Definition at line 197 of file beztool.cpp. { StartSpread = NULL; FloatingEndpoint = FALSE; MoveToDoc = NULL; MoveToSpread = NULL; pSmooth = NULL; RetroFlag = FALSE; DontDrawOnClearMoveTo = FALSE; CurrentToolMode = New; }

BezierTool::~BezierTool (   )

Destructor (Virtual). Does nothing. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 Definition at line 221 of file beztool.cpp. { // Destroy any resident retro smooth object if (pSmooth != NULL) { delete pSmooth; pSmooth = NULL; } pBezToolInfoBarOp->pBezTool = NULL; }

---

Member Function Documentation

BOOL BezierTool::AutoClosePaths (   )  [protected]

Runs through all selected lines. If the path is open and either of the ends are selected then the path is closed. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/12/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if all went well, FALSE if an error occured. See also: - Definition at line 4363 of file beztool.cpp. { OpState Calcium = OpCloseNodePaths::GetState(NULL, NULL); if (!Calcium.Greyed) { OpParam Param(CreateCurve, !CreateCusp); OpDescriptor* Apple = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpCloseNodePaths)); if (Apple != NULL) Apple->Invoke(&Param); } return TRUE; }

BezierTool::CC_DECLARE_MEMDUMP (  BezierTool   )  [private]

void BezierTool::ChangeCursor (  Cursor *  cursor  )  [protected]

Changes to the specified cursor. Will only change the cursor if it isn't already this cursor, so it doesn't flicker. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 16/3/94 Parameters: ID  of the cursor you want to flip to [INPUTS] -  [OUTPUTS] Returns: - Errors: can fail if the cursor cannot be created - the cursor code will fail. See also: - Definition at line 1472 of file beztool.cpp. { // only change if this cursor is different from the current cursor if (cursor != MyCurrentCursor) { // set this cursor as the current cursor and immediately display it CursorStack::GSetTop(cursor, CurrentCursorID); // remember this is our current cursor MyCurrentCursor = cursor; } }

void BezierTool::ClearMoveTo (   )

Clears the floating endpoint condition. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: BezierTool::SetMoveTo Definition at line 1539 of file beztool.cpp. { if (FloatingEndpoint && IsCurrent() && !DontDrawOnClearMoveTo) { BlobManager* pBlobManager = GetApplication()->GetBlobManager(); ENSURE(pBlobManager, "Can't get BlobManager"); pBlobManager->RenderToolBlobsOff(this, MoveToSpread,NULL); } FloatingEndpoint = FALSE; }

BOOL BezierTool::CyclePathPoints (  BOOL  Fowards  )  [protected]

Performs the cycle the selected points task. The selection status of each endpoint on selected paths is applied to the next endpoint. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/10/94 Parameters: Fowards  - TRUE if the point selection status are to move fowards, otherwise [INPUTS] they move backwards. Returns: TRUE if all went well, FALSE if an error occured Errors: - See also: - Definition at line 2968 of file beztool.cpp. { // Obtain the current selections and the first node in the selection SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); NodePath* ThisPath; // Holds the coords of the last selected point we find on our travels, // we then call DocView::ScrolToShowWithMargin to ensure that this point is visible DocCoord LastSelectedPoint; BOOL LastSelectedPointValid = FALSE; // does LastSelectedPoint hold a valid value? while (pNode != NULL) { // we're only interested in NodePaths which have selected points NodePath* pSelected = FindEditablePath(pNode); if (pSelected) { // for convenience, cast the pointer to a pointer to a NodePath ThisPath = pSelected; // First get pointers to the arrays PathFlags* Flags = ThisPath->InkPath.GetFlagArray(); PathVerb* Verbs = ThisPath->InkPath.GetVerbArray(); DocCoord* Coords = ThisPath->InkPath.GetCoordArray(); const INT32 NumCoords = ThisPath->InkPath.GetNumCoords(); if (pSelected->InkPath.IsSubSelection()) { // Render off the current selection blobs ThisPath->InkPath.RenderPathSelectedControlBlobs(pNode->FindParentSpread()); if (Fowards) { INT32 Current = 0; INT32 Next = 0; BOOL MoreEndpoints = TRUE; BOOL PrevSelected = Flags[0].IsSelected; while (MoreEndpoints) { // Find the next endpoint MoreEndpoints = ThisPath->InkPath.FindNextEndPoint(&Next); if (MoreEndpoints && (Verbs[Next] & PT_CLOSEFIGURE)) MoreEndpoints = ThisPath->InkPath.FindNextEndPoint(&Next); if (MoreEndpoints) { BOOL temp = Flags[Next].IsSelected; Flags[Next].IsSelected = PrevSelected; if (Flags[Next].IsSelected) { LastSelectedPoint = Coords[Next]; LastSelectedPointValid = TRUE; } PrevSelected= temp; Current = Next; } else { Flags[0].IsSelected = PrevSelected; if (Flags[0].IsSelected) { LastSelectedPoint = Coords[0]; LastSelectedPointValid = TRUE; } } } // Tidy up the selection state ThisPath->InkPath.EnsureSelection(TRUE); } else { INT32 Current = NumCoords-1; INT32 Next = Current; BOOL MoreEndpoints = TRUE; BOOL PrevSelected = Flags[Current].IsSelected; BOOL ClosedPath = (Verbs[Next] & PT_CLOSEFIGURE); while (MoreEndpoints) { // Find the previous endpoint MoreEndpoints = ThisPath->InkPath.FindPrevEndPoint(&Next); if (MoreEndpoints && ClosedPath && (Verbs[Next] == PT_MOVETO)) MoreEndpoints = ThisPath->InkPath.FindPrevEndPoint(&Next); if (MoreEndpoints) { BOOL temp = Flags[Next].IsSelected; Flags[Next].IsSelected = PrevSelected; if (Flags[Next].IsSelected) { LastSelectedPoint = Coords[Next]; LastSelectedPointValid = TRUE; } PrevSelected = temp; Current = Next; } else { Flags[NumCoords-1].IsSelected = PrevSelected; if (Flags[NumCoords-1].IsSelected) { LastSelectedPoint = Coords[NumCoords-1]; LastSelectedPointValid = TRUE; } } } // Tidy up the selection state ThisPath->InkPath.EnsureSelection(FALSE); } } // If no SubSelection else { if (Fowards) { Flags[0].IsSelected = TRUE; ThisPath->InkPath.EnsureSelection(TRUE); } else Flags[NumCoords-1].IsSelected = TRUE; ThisPath->InkPath.EnsureSelection(FALSE); } // Render on the new selection blobs ThisPath->InkPath.RenderPathSelectedControlBlobs(pNode->FindParentSpread()); } pNode = Selected->FindNext(pNode); } DialogBarOp::SetSystemStateChanged(); if (LastSelectedPointValid) { DocView* pDocView = DocView::GetSelected(); if (pDocView != NULL) { pDocView->ScrollToShowWithMargin(&LastSelectedPoint); } } return TRUE; }

void BezierTool::Describe (  void *  InfoPtr  )  [virtual]

Allows the tool manager to extract information about the tool. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 Parameters: InfoPtr  - A pointer to a tool info block. It is passed cast to void* as [INPUTS] the version of the tool is unknown at this point. Later versions of the Tool class may have more items in this block, that this tool will not use InfoPtr  - The structure pointed to by InfoPtr will have had all the info [OUTPUTS] that this version of the Tool knows about Reimplemented from Tool_v1. Definition at line 334 of file beztool.cpp. { // Cast structure into the latest one we understand. ToolInfo_v1 *Info = (ToolInfo_v1 *) InfoPtr; Info -> InfoVersion = 1; Info -> InterfaceVersion = GetToolInterfaceVersion(); // You should always have this line. // These are all arbitrary at present. Info -> Version = 1; Info -> ID = GetID(); Info -> TextID = _R(IDS_BEZIER_TOOL); Info -> Family = FamilyName; Info -> Name = ToolName; Info -> Purpose = Purpose; Info -> Author = Author; Info -> InfoBarDialog = _R(IDD_BEZTOOLBAR); Info -> BubbleID = _R(IDBBL_LINETOOL); Info -> StatusID = _R(IDS_LINETOOL); }

clickeffect BezierTool::DetermineClickEffect (  DocCoord  PointerPos, Spread *  pSpread, NodeRenderableInk **  ReturnNode, INT32 *  ReturnPosition, INT32 *  NumSelectedPaths, INT32 *  NumSelectedPoints )  [protected]

Used when the cursor moves and when single clicking. This routine determines what effect a click will have. In this tool, clicking will either select a point on an already selected line, reshape a line segment (a la Corel), add a segment to the end of a line, or start a new path entirely. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/94 Parameters: PointerPos  is the mouse position [INPUTS] pSpread is a pointer to the spread containing the mouse position ReturnNode  returns a pointer to the node the mouse would click on [OUTPUTS] ReturnPosition returns the index into the nodepath of the affected point NumSelectedPaths is the number of paths in the selection NumSelectedPoints is the total number of selected points (on all paths) Returns: The effect of clicking - one of NewPath, AddSegment, OnPoint or ReshapeLine Definition at line 1199 of file beztool.cpp. { clickeffect WhatToDo = NewPath; // tells me what effect the click would have INT32 PathPosition = 0; // temp var for return value INT32 TempIndex = 0; // Temporary index into a path INT32 NumSelPaths = 0; // Number of selected paths double Distance = 0; // gets the returned distance from the nearest point double Nearest = 0; // distance of current nearest point NodeRenderableInk* WhichNode = NULL; // Saves me using a pointer to a pointer // Scan through the selected paths, and see if any of them want the click DocRect BlobRect; DocView* pDocView = DocView::GetCurrent(); ERROR2IF( pDocView==NULL, NewPath, "BezierTool::DetermineClickEffect: Can't find current DocView"); // Find the selected range of objects SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); INT32 NumSelectedEndpoints = 0; // Count selected points in paths if (pNode != NULL) { Spread* NodeSpread = pNode->FindParentSpread(); if (NodeSpread == pSpread) { // On the same spread, so see if the pointer is over an endpoint while ((pNode != NULL) && WhatToDo!=OnPoint) { NodePath* pActNode = FindEditablePath(pNode); if (pActNode) { // Now we know it's a NodePath, get a pointer to the Path object within it, so // we can find any endpoints Path* ThisPath = &((pActNode)->InkPath); // Increment the number of selected paths NumSelPaths++; // count the number of selected points on the path (excluding control points) INT32 NumCoords = ThisPath->GetNumCoords(); PathFlags* Flags = ThisPath->GetFlagArray(); for (INT32 i=0; i<NumCoords; i++) { if (Flags[i].IsSelected && Flags[i].IsEndPoint) NumSelectedEndpoints++; } if (ThisPath->FindStartOfPath()) { // First, check to see if this click occurs on a selected point INT32 tempPos; if (ThisPath->FindNearestPoint(PointerPos, POINTFLAG_ENDPOINTS | POINTFLAG_CONTROLPOINTS | POINTFLAG_ENDSFIRST, &tempPos) ) { // The click occurred on one of the points on the line // so remember this path, the position, and the fact that // the user clicked on a point WhatToDo = OnPoint; WhichNode = (NodeRenderableInk*)pActNode; PathPosition = tempPos; } else if (WhatToDo != OnPoint && ThisPath->PointCloseToLine(PointerPos, &tempPos)) { WhatToDo = ReshapeLine; WhichNode = (NodeRenderableInk*)pActNode; PathPosition = tempPos; } else if ((WhatToDo == AddSegment || WhatToDo == NewPath) && ThisPath->ClosestSelectedEndpoint(PointerPos,&TempIndex,&Distance)) { // TempIndex is the index into the path for the closest selected endpoint // Distance is the distance if (WhatToDo == NewPath) { WhatToDo = AddSegment; WhichNode = (NodeRenderableInk*)pActNode; Nearest = Distance; PathPosition = TempIndex; } else if (Nearest > Distance) { Nearest = Distance; WhichNode = (NodeRenderableInk*)pActNode; PathPosition = TempIndex; } } } } // Now find the next selected node pNode = Selected->FindNext(pNode); } } } // WhatToDo tells us what the action will be // WhichNode points to the node we are dealing with // PathPosition is the index into that path of the element we are using // If WhatToDo == OnPoint and it's the end of a subpath, and the opposite // end is selected, and the path isn't closed we should change WhatToDo // to be ClosePath if (WhatToDo == OnPoint && NumSelectedEndpoints == 1) { Path* ThisPath = &(((NodePath*)WhichNode)->InkPath); PathFlags* Flags = ThisPath->GetFlagArray(); PathVerb* Verbs = ThisPath->GetVerbArray(); // DocCoord* Coords = ThisPath->GetCoordArray(); INT32 NumCoords = ThisPath->GetNumCoords(); if (Verbs[PathPosition] == PT_MOVETO) // Start of subpath { INT32 i = PathPosition; ThisPath->FindEndElOfSubPath(&i); // i = index to end element if ((Flags[i].IsSelected) && !(Verbs[i] & PT_CLOSEFIGURE)) WhatToDo = ClosePath; } else if (PathPosition+1 == NumCoords || Verbs[PathPosition+1] == PT_MOVETO) { if (!(Verbs[PathPosition] & PT_CLOSEFIGURE)) { INT32 i = PathPosition; ThisPath->FindStartOfSubPath(&i); if (Flags[i].IsSelected) WhatToDo = ClosePath; } } // Now we must detect the case of an attempted closepath on a path consisting // of a moveto and one segment if ((WhatToDo == ClosePath) && ( (((NodePath*)WhichNode)->InkPath.GetNumCoords() == 2) || ((((NodePath*)WhichNode)->InkPath.GetNumCoords() == 4) && (Verbs[3] == PT_BEZIERTO)) ) ) { WhatToDo = OnPoint; } } if ((WhatToDo == AddSegment || WhatToDo == ClosePath) && NumSelectedEndpoints > 1) WhatToDo = NewPath; if (WhatToDo == AddSegment || WhatToDo == ReshapeLine) { // If we're pointing at a curve, make sure we're pointing to the first element Path* ThisPath = &(((NodePath*)WhichNode)->InkPath); PathFlags* flags = ThisPath->GetFlagArray(); while(!(flags[PathPosition].IsEndPoint )) PathPosition++; ThisPath->SetPathPosition(PathPosition); if (ThisPath->GetVerb() == PT_BEZIERTO) PathPosition-=2; } *ReturnPosition = PathPosition; *ReturnNode = WhichNode; *NumSelectedPoints = NumSelectedEndpoints; *NumSelectedPaths = NumSelPaths; return (WhatToDo); }

BOOL BezierTool::EndPathPoints (   )  [protected]

Moves the selected endpoints foward along the selected path(s) so that the last point is selected. The pattern of selection remains the same. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 5/1/94 Parameters: -  [INPUTS] Returns: TRUE if all went well, FALSE if an error occured Errors: - See also: BezierTool::HomePathPoints Definition at line 3247 of file beztool.cpp. { // Obtain the current selections and the first node in the selection SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); NodePath* ThisPath; // Variable to hold the position of the last 'end point'. This is updated as we // loop through the selection until it holds the end point of the last line // in the selection with subselection. DocCoord LastEndPoint; BOOL LastEndPointValid = FALSE; while (pNode != NULL) { // we're only interested in NodePaths which have selected points NodePath* pSelected = FindEditablePath(pNode); if (pSelected) { // for convenience, cast the pointer to a pointer to a NodePath ThisPath = pSelected; // First get pointers to the arrays PathFlags* Flags = ThisPath->InkPath.GetFlagArray(); PathVerb* Verbs = ThisPath->InkPath.GetVerbArray(); DocCoord* Coords = ThisPath->InkPath.GetCoordArray(); INT32 NumCoords = ThisPath->InkPath.GetNumCoords()-1; if (pSelected->InkPath.IsSubSelection() ) { // We only need to bother if the last endpoint is not selected! if (!Flags[NumCoords].IsSelected) { // Render off the current selection blobs ThisPath->InkPath.RenderPathSelectedControlBlobs(pNode->FindParentSpread()); // Find the last selected point INT32 Offset = NumCoords; while ((Offset > -1) && !(Flags[Offset].IsSelected && Flags[Offset].IsEndPoint)) { Offset--; } ERROR3IF(Offset == -1,"No selected endpoint found when there was one"); // Now we can move the selection on to the end INT32 Current = NumCoords; BOOL MoreEndpoints = TRUE; while (MoreEndpoints) { Flags[Current].IsSelected = Flags[Offset].IsSelected; MoreEndpoints = ThisPath->InkPath.FindPrevEndPoint(&Offset); if (MoreEndpoints && (Verbs[Offset] & PT_CLOSEFIGURE)) MoreEndpoints = ThisPath->InkPath.FindPrevEndPoint(&Offset); if (MoreEndpoints) { ThisPath->InkPath.FindPrevEndPoint(&Current); if (Verbs[Current] & PT_CLOSEFIGURE) ThisPath->InkPath.FindPrevEndPoint(&Current); } else Current --; } // Unselect the remaining endpoints while (Current > -1) { Flags[Current--].IsSelected = FALSE; } // Now fix up the selections so if the starts of subpaths are selected then so are the ends ThisPath->InkPath.EnsureSelection(FALSE); // Render on the new selection blobs ThisPath->InkPath.RenderPathSelectedControlBlobs(pNode->FindParentSpread()); } // this path is in the selection, and has a subselection, so remember its end point // position, as it may be the last end point LastEndPoint = Coords[NumCoords]; LastEndPointValid = TRUE; } else { Flags[NumCoords].IsSelected = TRUE; // Now fix up the selections so if the starts of subpaths are selected then so are the ends ThisPath->InkPath.EnsureSelection(FALSE); // Render on the new selection blobs ThisPath->InkPath.RenderPathSelectedControlBlobs(pNode->FindParentSpread()); } } pNode = Selected->FindNext(pNode); } DialogBarOp::SetSystemStateChanged(); // scroll to show the last end point (if it exists) at the coordinates we remembered earlier if (LastEndPointValid) { DocView* pDocView = DocView::GetSelected(); if (pDocView != NULL) { pDocView->ScrollToShowWithMargin(&LastEndPoint); } } return TRUE; }

NodePath * BezierTool::FindEditablePath (  Node *  pSelected  )  [protected]

Finds the node to edit (if it exists). This node could actually be the selected node passed as a parameter or one of its children which the node wants to be editable. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/3/95 Parameters: pSelected  = A pointer to the selected node to check [INPUTS] -  [OUTPUTS] Returns: A pointer to an editable node path (or derived) object NULL if there isn't one. Definition at line 1387 of file beztool.cpp. { if (pSelected->IsNodePath()) return ((NodePath*)pSelected); return ((NodePath*)pSelected->HasEditableChild(CC_RUNTIME_CLASS(NodePath), NULL)); }

void BezierTool::GenerateStatusLineText (  String_256 *  ptext, Spread *  pSpread, DocCoord  coord, ClickModifiers  mods )

To find the string to display on the status line given the current mouse position. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 08/12/94 Parameters: pSpread  - pointer to spread under mouse (else NULL) [INPUTS] DocPos - position of mouse in doc (in spread coords) ClickMods - mouse click modifiers ptext  - text for status line [OUTPUTS] Returns: - Errors: - Definition at line 3623 of file beztool.cpp. { // Call DetermineClickEffect to see what a click will do at this position INT32 PathPosition; // Needed to receive a return, not used otherwise NodeRenderableInk* node; // again, only temporary INT32 NumPts; // Number of selected points INT32 NumPaths; // Number of selected paths clickeffect WhatToDo = DetermineClickEffect(coord, pSpread, &node, &PathPosition, &NumPaths, &NumPts); switch (WhatToDo) { case AddSegment: if (CreateCurve) ptext->Load(_R(IDS_ADD_SEGMENT),Tool::GetModuleID(GetID())); else ptext->Load(_R(IDS_ADDLINESEGMENT),Tool::GetModuleID(GetID())); break; case NewPath: if (FloatingEndpoint) { if (CreateCurve) { if (NumPts == 0) ptext->Load(_R(IDS_CLICK_TO_MAKE_NEW),Tool::GetModuleID(GetID())); else ptext->Load(_R(IDS_CLICK_TO_MAKE_NEW),Tool::GetModuleID(GetID())); } else { ptext->Load(_R(IDS_CLICKMAKENEWLINE),Tool::GetModuleID(GetID())); } } else { if (CreateCurve) { if (NumPts == 0) ptext->Load(_R(IDS_STARTNEWCURVENOSEL),Tool::GetModuleID(GetID())); else ptext->Load(_R(IDS_CREATE_NEW_PATH),Tool::GetModuleID(GetID())); } else { if (NumPts == 0) ptext->Load(_R(IDS_STARTNEWLINENOSEL),Tool::GetModuleID(GetID())); else ptext->Load(_R(IDS_STARTNEWLINE),Tool::GetModuleID(GetID())); } } break; case OnPoint: // There are various different combinations of selected/unselected, which require // different status line messages { NodePath* ThisPath = (NodePath*)node; // PathVerb* Verbs = ThisPath->InkPath.GetVerbArray(); PathFlags* Flags = ThisPath->InkPath.GetFlagArray(); INT32 ptype = 0; if (Flags[PathPosition].IsSelected) ptype |= 1; if (Flags[PathPosition].IsEndPoint) ptype |= 2; if (Flags[PathPosition].IsRotate) ptype |= 4; // Now ptype holds a number from 0 to 7 which completely describes what type of // point this is, so we can use that to select the correct string switch(ptype) { case 0: //Unselected, unsmoothed control point case 4: // UnSelected, smoothed control point case 1: // Selected, unsmoothed control point case 5: // Selected, smoothed control point ptext->Load(_R(IDS_SELCONTROL),Tool::GetModuleID(GetID())); break; case 2: // UnSelected, unsmoothed end point ptext->Load(_R(IDS_UNSELCUSP),Tool::GetModuleID(GetID())); break; case 3: // Selected, unsmoothed end point ptext->Load(_R(IDS_SELCUSP),Tool::GetModuleID(GetID())); break; case 6: // UnSelected, smoothed end point ptext->Load(_R(IDS_UNSELSMOOTH),Tool::GetModuleID(GetID())); break; case 7: // Selected, smoothed end point ptext->Load(_R(IDS_SELSMOOTH),Tool::GetModuleID(GetID())); break; } } break; case ReshapeLine: ptext->Load(_R(IDS_RESHAPE_LINE),Tool::GetModuleID(GetID())); break; case ClosePath: ptext->Load(_R(IDS_CLOSEPATH),Tool::GetModuleID(GetID())); break; } }

UINT32 BezierTool::GetID (  void   )  [inline, virtual]

Reimplemented from Tool_v1. Definition at line 256 of file beztool.h. { return TOOLID_BEZTOOL; };

BOOL BezierTool::GetMoveTo (  Spread **  ppSpread, DocCoord *  pCoord, Document **  ppDoc )

Read the state of the floating endpoint. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 05/12/94 Parameters: ppSpread  - pointer to a pointer to a spread [INPUTS] pCoord - pointer to a DocCoord *ppSpread  is set to point to the spread the floating endpoint is on [OUTPUTS] pCoord is set to the location of the floating endpoint Returns: TRUE if there was a floating endpoint, FALSE if not (in this case there is no outputs) Errors: - See also: BezierTool::SetMoveTo, BezierTool::ClearMoveTo Definition at line 1570 of file beztool.cpp. { if (FloatingEndpoint) { *ppSpread = MoveToSpread; *pCoord = MoveToPoint; *ppDoc = MoveToDoc; return TRUE; } else return FALSE; }

BOOL BezierTool::GetStatusLineText (  String_256 *  ptext, Spread *  pSpread, DocCoord  DocPos, ClickModifiers  ClickMods )  [virtual]

generate up-to-date text for the status line (called on idles) Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 08/12/94 Parameters: pSpread  - pointer to spread under mouse (else NULL) [INPUTS] DocPos - position of mouse in doc (in spread coords) ClickMods - mouse click modifiers ptext  - text for status line [OUTPUTS] Returns: TRUE if outputting valid text Errors: ERROR3 if ptext is NULL Reimplemented from Tool_v1. Definition at line 3592 of file beztool.cpp. { ERROR2IF(ptext==NULL,FALSE,"ptext was NULL"); *ptext = ""; GenerateStatusLineText(ptext, pSpread, DocPos, ClickMods); return TRUE; }

void BezierTool::HandleInfoBarMessage (  CDlgMessage  DlgMsg, CGadgetID  Gadget )

BOOL BezierTool::HomePathPoints (   )  [protected]

Moves the selected endpoints back along the selected path(s) so that the first point is selected. The pattern of selection remains the same. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 5/1/94 Parameters: -  [INPUTS] Returns: TRUE if all went well, FALSE if an error occured Errors: - See also: BezierTool::EndPathPoints Definition at line 3125 of file beztool.cpp. { // Obtain the current selections and the first node in the selection SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); NodePath* ThisPath; // Variable to hold the position of the last 'first point'. This is updated as we // loop through the selection until it holds the first point of the last line // in the selection with subselection. DocCoord LastFirstPoint; BOOL LastFirstPointValid = FALSE; while (pNode != NULL) { // we're only interested in NodePaths which have selected points NodePath* pSelected = FindEditablePath(pNode); if (pSelected) { // for convenience, cast the pointer to a pointer to a NodePath ThisPath = pSelected; // First get pointers to the arrays PathFlags* Flags = ThisPath->InkPath.GetFlagArray(); PathVerb* Verbs = ThisPath->InkPath.GetVerbArray(); DocCoord* Coords = ThisPath->InkPath.GetCoordArray(); INT32 NumCoords = ThisPath->InkPath.GetNumCoords()-1; // We only need to bother if the first endpoint is not selected! if (pSelected->InkPath.IsSubSelection()) { if (!Flags[0].IsSelected) { // Render off the current selection blobs ThisPath->InkPath.RenderPathSelectedControlBlobs(pNode->FindParentSpread()); // Find the first selected point INT32 Offset = 0; while ((Offset <= NumCoords) && !(Flags[Offset].IsSelected && Flags[Offset].IsEndPoint)) { Offset ++; } ERROR3IF(Offset > NumCoords,"No selected endpoint found when there was one"); // Now we can move the selection back to the start BOOL MoreEndpoints = TRUE; INT32 Current = 0; while (MoreEndpoints) { Flags[Current].IsSelected = Flags[Offset].IsSelected; MoreEndpoints = ThisPath->InkPath.FindNextEndPoint(&Offset); if (Verbs[Offset] & PT_CLOSEFIGURE) MoreEndpoints = ThisPath->InkPath.FindNextEndPoint(&Offset); if (MoreEndpoints) { ThisPath->InkPath.FindNextEndPoint(&Current); if (Verbs[Current] & PT_CLOSEFIGURE) ThisPath->InkPath.FindNextEndPoint(&Current); } else Current ++; } // Unselect the remaining endpoints from Current onwards while (Current <= NumCoords) { Flags[Current++].IsSelected = FALSE; } // Now fix up the selection status of the path ThisPath->InkPath.EnsureSelection(TRUE); // Render on the new selection blobs ThisPath->InkPath.RenderPathSelectedControlBlobs(pNode->FindParentSpread()); } // current pNode is selected and has a seubselection, so update FirstPointCoord to // point to the first end point of this path LastFirstPoint = Coords[0]; LastFirstPointValid = TRUE; } else { Flags [0].IsSelected = TRUE; // Now fix up the selection status of the path ThisPath->InkPath.EnsureSelection(TRUE); // Render on the new selection blobs ThisPath->InkPath.RenderPathSelectedControlBlobs(pNode->FindParentSpread()); } } pNode = Selected->FindNext(pNode); } DialogBarOp::SetSystemStateChanged(); // scroll to show the last first point (if it exists) at the coordinates we remembered earlier if (LastFirstPointValid) { DocView* pDocView = DocView::GetSelected(); if (pDocView != NULL) { pDocView->ScrollToShowWithMargin(&LastFirstPoint); } } return TRUE; }

BOOL BezierTool::Init (  void   )  [virtual]

Used to check if the Tool was properly constructed. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 Returns: FALSE if it does not want to be created, TRUE otherwise See also: BezierTool::BezierTool Reimplemented from Tool_v1. Definition at line 247 of file beztool.cpp. { CCResTextFile file; // Resource File BezToolInfoBarOpCreate BarCreate; // Object that creates InfoBarOp objects #if 0 BOOL ok; ok = file.open(_R(IDM_BEZTOOL_BAR), _R(IDT_INFO_BAR_RES)); // Open resource if (ok) ok = DialogBarOp::ReadBarsFromFile(file,BarCreate); // Read and create info bar if (ok) file.close(); // Close resource ERROR2IF(!ok, FALSE, "Unable to load bezbar.ini from resource\n"); // Info bar now exists. Now get a pointer to it String_32 str = String_32(_R(IDS_BEZTOOL_INFOBARNAME)); DialogBarOp* pDialogBarOp = DialogBarOp::FindDialogBarOp(str); ERROR2IF(pDialogBarOp==NULL, FALSE, "Line tool infobar not found\n"); ERROR3IF(!(pDialogBarOp->IS_KIND_OF(BezToolInfoBarOp)), "Line tool infobar wrong type"); #endif pBezToolInfoBarOp = new BezToolInfoBarOp(); if (!pBezToolInfoBarOp) { ERROR3("Could not load bezier tool info bar"); return FALSE; } FloatingEndpoint = FALSE; MoveToDoc = NULL; MoveToSpread = NULL; pBezToolInfoBarOp->pBezTool = this; // Set a pointer from the op to this tool pBezToolInfoBarOp->CurrentIndex = -1; pBezToolInfoBarOp->CurrentNodePath = NULL; pBezToolInfoBarOp->CurrentInkPath = NULL; pBezToolInfoBarOp->CurrentSpread = NULL; pBezToolInfoBarOp->IgnoreNextUpdate = FALSE; pBezToolInfoBarOp->LastShownPrevLength = 0; pBezToolInfoBarOp->LastShownNextLength = 0; // Read in the preference settings from the file GetApplication()->DeclareSection(_T("ShapeEditorTool"),2); GetApplication()->DeclarePref(_T("ShapeEditorTool"),_T("CreateCusp"), &CreateCusp, 0, 1); GetApplication()->DeclarePref(_T("ShapeEditorTool"),_T("CreateCurved"), &CreateCurve, 0, 1); // create a retro smooth regions object if (pSmooth != NULL) { ERROR3("Initialisation failure in class BezierTool: smooth ptr not NULL"); return FALSE; } pSmooth = new RetroSmooth; if (pSmooth == NULL) return FALSE; if (!pSmooth->Initialise()) return FALSE; // Initialise operations in opbezier.cpp if (!( OpSelectPathPoints::Declare() && OpInsertFloater::Declare() && OpRemoveFloater::Declare() ) ) return FALSE; return TRUE; }

void BezierTool::OnClick (  DocCoord  PointerPos, ClickType  Click, ClickModifiers  ClickMods, Spread *  pSpread )  [virtual]

To handle a Mouse Click event for the Bezier Tool. It starts up a Bezier Operation. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> (via Rik) Date: 21/4/94 Parameters: PointerPos  - The Coords (in spread coords) of the point where the mouse [INPUTS] button was clicked Click - Describes the type of click that was detected. ClickMods - Indicates which buttons caused the click and which modifers were pressed at the same time pSpread - the spread in which the click happened Returns: TRUE if it handled the Click, FALSE otherwise See also: Tool::MouseClick; ClickType; ClickModifiers Reimplemented from Tool_v1. Definition at line 859 of file beztool.cpp. { if (ClickMods.Menu) return; // Don't do anything if the user clicked the Menu button // Have a flag telling me what we have to do (either click on an existing point, // create a new point on a path, create an all new path or reshape an existing line) // clickeffect is defined in the class header. INT32 PathPosition; // index into the path of interesting elements NodeRenderableInk* WhichNode = NULL; INT32 NumPts; INT32 NumPaths; // Set the infobars spread pointer so if any kernel op wants to force edit field values // there is a spread to get units from. pBezToolInfoBarOp->CurrentSpread = pSpread; clickeffect WhatToDo = DetermineClickEffect(PointerPos, pSpread,&WhichNode, &PathPosition, &NumPaths, &NumPts); // So, like, WhatToDo tells me what to do, WhichNode points at the node that's involved // and PathPosition is the index into WhichNode of the element we are dealing with. // if WhatToDo = OnPoint we have to pass the click onto the path // if WhatToDo = AddSegment we have to add a curve or line segment to the given path. // we should also remember to do things with the selected points. // if WhatToDo = NewPath there wasn't a suitable selected path, so we have to start a new // path. A stupid person (i.e. me) might create a new path, but I think this could be done // better. When they click in this mode, I'll start an operation which drags out a single // line/curve element, but if they release immediately I won't insert anything - I'll set // the FloatingEndpoint flag and set the MoveToPoint coords to that point. // Take note of the else ifs - this should help to ensure that only one event is ever triggered // by an incoming click event. Care should be taken in ordering these clauses so that the correct // results ensue from each click. // Special case: WhatToDo = ClosePath and the Adjust button is used. Instead of closing the path // we should select the point. Thus, we change it to OnPoint if ( WhatToDo == ClosePath && ClickMods.Adjust) WhatToDo = OnPoint; // Ordinary click from OnPoint if ( Click == CLICKTYPE_SINGLE && WhatToDo == OnPoint ) { WhichNode->OnClick(PointerPos, Click, ClickMods, pSpread); // Need to clear any exiting floating endpoint condition if (FloatingEndpoint) RemoveFloater(&MoveToPoint, MoveToSpread, NULL); } // If the click is AddSegment, I should add a segment to the end of the given path (WhichNode, // returned by DetermineClickEffect(). Unlike the clicking on existing nodes, it is the tool's // job to initiate this operation else if (Click == CLICKTYPE_SINGLE && WhatToDo == AddSegment && !ClickMods.Adjust) { OpNodePathAddEndpoint* pOpAddEnd = new OpNodePathAddEndpoint; if (!pOpAddEnd) InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); else pOpAddEnd->DoStartDragEdit((NodePath*) WhichNode, PointerPos, pSpread, ClickMods, PathPosition, CreateCurve, FALSE, !CreateCusp); } else if (Click == CLICKTYPE_SINGLE && (WhatToDo == NewPath || (WhatToDo == AddSegment && ClickMods.Adjust))) { if (FloatingEndpoint) { if (ClickMods.Adjust) { // Clear the floating endpoint condition RemoveFloater(&MoveToPoint, MoveToSpread, NULL); } else { // Handle adding of new path OpNewPath* pOpNew = new OpNewPath; if (!pOpNew) InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK)); else { pOpNew->DoStartDragEdit(MoveToPoint, PointerPos, MoveToSpread, ClickMods, CreateCurve, !CreateCusp); } } } else { if (!OpSelectPathPoints::DragInProgress()) { // Start a drag operation to marquee select points OpSelectPathPoints* pOpSelect = new OpSelectPathPoints; if (!pOpSelect) { InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); } else { // Start the drag, giving a pointer back to this tool so that if // the drag was not really a drag, we can insert a floater. pOpSelect->DoDrag( PointerPos, pSpread, ClickMods.Adjust , this, ClickMods); } } } } else if ( Click == CLICKTYPE_DOUBLE && WhatToDo == OnPoint && !ClickMods.Adjust) { WhichNode->OnClick(PointerPos, Click, ClickMods, pSpread); // DialogBarOp::SetSystemStateChanged(); // Inform the system that greying needs updating } else if ( Click == CLICKTYPE_SINGLE && WhatToDo == ClosePath) { // Create the same operation as for adding an endpoint, but call it using // the flag that tells the operation to close the path. OpNodePathAddEndpoint* pOpAddEnd = new OpNodePathAddEndpoint; if (!pOpAddEnd) { InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); } else { // Start dragging the path. The TRUE flag at the end tells the operation // to close the path // I have to flip the PathPosition index from the clicked-on point to the opposite // point so that the right segment is inserted ((NodePath*)WhichNode)->InkPath.SetPathPosition(PathPosition); ((NodePath*)WhichNode)->InkPath.FindStartOfSubPath(); if (PathPosition == ((NodePath*)WhichNode)->InkPath.GetPathPosition()) { ((NodePath*)WhichNode)->InkPath.FindEndOfSubPath(); PathPosition = ((NodePath*)WhichNode)->InkPath.GetPathPosition(); } else PathPosition = ((NodePath*)WhichNode)->InkPath.GetPathPosition(); pOpAddEnd->DoStartDragEdit((NodePath*) WhichNode, PointerPos, pSpread, ClickMods, PathPosition, CreateCurve, TRUE, !CreateCusp); } } else if (Click == CLICKTYPE_SINGLE && WhatToDo == ReshapeLine) { // Create the same operation as for adding an endpoint, but call it using // the flag that tells the operation to close the path. double pdist; INT32 tempel; ((NodePath*) WhichNode)->InkPath.SqrDistanceToPoint(PointerPos, &tempel, &pdist); OpReshapeOrAddPoint* pOpReshape = new OpReshapeOrAddPoint; if (!pOpReshape) InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); else pOpReshape->DoStartDragEdit((NodePath*) WhichNode, PointerPos, pSpread, PathPosition, pdist); } /* else if (Click == CLICKTYPE_DRAG && WhatToDo == NewPath && FloatingEndpoint && pSpread == MoveToSpread) { OpNodePathStartNew* pOpStartNew = new OpNodePathStartNew; if (!pOpStartNew) { if (IsUserName("Jim")) { TRACE( _T("Unable to create operation to start new path in Beztool\n")); } // Inform the user that we are out of memory InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); } else { // Start dragging the path pOpStartNew->DoStartDragEdit( PointerPos, pSpread ); } } */ else if ( Click == CLICKTYPE_DRAG && WhatToDo == OnPoint && (WhichNode != NULL) ) { WhichNode->OnClick(PointerPos, Click, ClickMods, pSpread); // ((NodeRenderableInk*)LastPathClicked)->OnClick(LastPointClicked,Click, ClickMods, LastSpreadClicked); // DialogBarOp::SetSystemStateChanged(); // Inform the system that greying needs updating } // Now update the cursor and status bar OnMouseMove(PointerPos, pSpread, ClickMods); SetModeFlag(); ResetRetroSlider(); }

Node * BezierTool::OneNodePathSelected (   )  [protected]

Checks the selection and determins whether exactly one nodepath object is selected. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 22/11/94 Parameters: -  [INPUTS] Returns: a pointer to the node if there is a single node path object selected NULL if no nodepath or more than one object is selected Definition at line 3439 of file beztool.cpp. { // Find the selected range of objects SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); if (pNode == NULL) return NULL; Node* qNode = Selected->FindNext(pNode); if (qNode != NULL) return NULL; // ok there's only one selected object so what kind is it? if (pNode->GetRuntimeClass() != CC_RUNTIME_CLASS(NodePath)) return NULL; return pNode; }

BOOL BezierTool::OnKeyPress (  KeyPress *  pKeyPress  )  [virtual]

To handle keypress events for the Bezier Tool. If it is a keypress that it know about it starts up an appropiate operation. THIS IS BADLY WRONG AT THE MOMENT - WHEN THERE IS THE TECHNOLOGY FOR USER DEFINABLE KEY-SHORTCUTS THIS FUNCTION WILL NEED FIXING. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/94 Parameters: pKeyPress  - pointer to a keypress object [INPUTS] Returns: TRUE if it handled the keypress, FALSE otherwise Reimplemented from Tool_v1. Definition at line 1069 of file beztool.cpp. { // We don't want to know about key release or character events if (!pKeyPress->IsPress()) return FALSE; // Comparing keypresses is exceeding greif! if (*pKeyPress == KeyPress(CAMKEY(TAB))) { CyclePathPoints(TRUE); goto UsedKey; } if (*pKeyPress == KeyPress(CAMKEY(TAB), TRUE)) { CyclePathPoints(FALSE); goto UsedKey; } if (*pKeyPress == KeyPress(CAMKEY(RETURN))) { if (!AutoClosePaths()) InformError(); goto UsedKey; } if ((pKeyPress->GetVirtKey() == CAMKEY(HOME)) && !pKeyPress->IsAdjust() && !pKeyPress->IsConstrain() && !pKeyPress->IsAlternative()) { HomePathPoints(); goto UsedKey; } if ((pKeyPress->GetVirtKey() == CAMKEY(END)) && !pKeyPress->IsAdjust() && !pKeyPress->IsConstrain() && !pKeyPress->IsAlternative()) { EndPathPoints(); goto UsedKey; } if (*pKeyPress == KeyPress(CAMKEY(Z))) { pBezToolInfoBarOp->HandleClickOnCuspButton(FALSE); goto UsedKey; } if (*pKeyPress == KeyPress(CAMKEY(S))) { pBezToolInfoBarOp->HandleClickOnSmoothButton(); goto UsedKey; } if (*pKeyPress == KeyPress(CAMKEY(L))) { pBezToolInfoBarOp->HandleClickOnLineButton(); goto UsedKey; } if (*pKeyPress == KeyPress(CAMKEY(C))) { pBezToolInfoBarOp->HandleClickOnCurveButton(); goto UsedKey; } if (*pKeyPress == KeyPress(CAMKEY(B))) { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpBreakAtPoints)); String_256 UIDesc; if (pOpDesc != NULL) { OpState State = OpBreakAtPoints::GetState(&UIDesc, pOpDesc); if (!State.Greyed) { pOpDesc->Invoke(); goto UsedKey; } } } if ((pKeyPress->GetVirtKey() == CAMKEY(DELETE)) || (*pKeyPress == KeyPress(WXK_BACK)) ) { // Run a delete selected points operation String_256 UIDesc; OpState State = OpDeletePoints::GetState(&UIDesc, NULL); OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpDeletePoints)); if ((!State.Greyed) && (pOpDesc != NULL)) { pOpDesc->Invoke(); goto UsedKey; } } // If ESCAPE is pressed then clear the floating endpoint, but don't claim the keypress // so the selection is also cleared. if ((*pKeyPress == KeyPress(CAMKEY(ESCAPE))) && FloatingEndpoint) RemoveFloater(&MoveToPoint, MoveToSpread, Document::GetSelected()); // If we get this far then the keypress wasn't handled return FALSE; UsedKey: pBezToolInfoBarOp->IgnoreNextUpdate = FALSE; return TRUE; }

void BezierTool::OnMouseMove (  DocCoord  coord, Spread *  pSpread, ClickModifiers  mods )  [virtual]

This routine is called whenever the mouse moves while we're in the freehand tool. it sees what is under the pointer, and flips the cursor if clicking will have a different effect. The rules are:. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 15/3/94 Parameters: coordinate  of mouse move, pointer to spread containing coord, mouse modifiers [INPUTS] -  [OUTPUTS] Returns: - Over space, no selection - freehand cursor Over selected endpoint - add freehand to line Returns: Errors: - See also: - Reimplemented from Tool_v1. Definition at line 1419 of file beztool.cpp. { // Call DetermineClickEffect to see what a click will do at this position INT32 PathPosition; // Needed to receive a return, not used otherwise NodeRenderableInk* node; // again, only temporary INT32 NumPts; // Number of selected points INT32 NumPaths; // Number of selected paths clickeffect WhatToDo = DetermineClickEffect(coord, pSpread, &node, &PathPosition, &NumPaths, &NumPts); // Generate the status line help string String_256 status(""); GenerateStatusLineText(&status, pSpread, coord, mods); GetApplication()->UpdateStatusBarText(&status); // Now change the cursor switch (WhatToDo) { case AddSegment: ChangeCursor(pcAddPathCursor); break; case NewPath: ChangeCursor(pcNewPathCursor); break; case OnPoint: ChangeCursor(pcMoveBezCursor); break; case ReshapeLine: ChangeCursor(pcReshapeLineCursor); break; case ClosePath: ChangeCursor(pcClosePathCursor); break; } }

void BezierTool::RemoveFloater (  DocCoord *  FloatPos, Spread *  FloatSpread, Document *  pDoc )  [protected]

Invokes the operation to remove the floating endpoint. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 23/1/96 Parameters: FloatPos  - the current position of the floating endpoint [INPUTS] FloatSpread - the spread it's on pDoc - points to document with the endpoint -  [OUTPUTS] Returns: - See also: OpRemoveFloater Definition at line 4485 of file beztool.cpp. { if (FloatingEndpoint) { InsertFloaterParam Param(FloatPos, FloatSpread, this, pDoc); OpDescriptor* Apple = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpRemoveFloater)); if (Apple != NULL) Apple->Invoke(&Param); else InformError(); } else { ERROR3("Attempted to remove floating endpoint but it wasn't there!"); } }

void BezierTool::RenderToolBlobs (  Spread *  pSpread, DocRect *  pClipRect )  [virtual]

Renders the Tools Blobs. The only blob this tool renders is the floating endpoint which only appears the the flag is set. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 18/7/94 Parameters: pSpread  - The spread that the blob is to appear on [INPUTS] pClipRect - Pointer to the rect that contains the blobs Reimplemented from Tool_v1. Definition at line 1598 of file beztool.cpp. { // Can only draw the path if there is a path to draw if (FloatingEndpoint) { RenderRegion* pRegion = DocView::RenderOnTop(pClipRect, pSpread, ClippedEOR); while (pRegion) { // Draw a Cross Hair pRegion->SetLineColour(COLOUR_BEZIERBLOB); pRegion->SetFillColour(COLOUR_TRANS); pRegion->DrawBlob(MoveToPoint,BT_SELECTED); // Get the next region in the list pRegion = DocView::GetNextOnTop(pClipRect); } } }

void BezierTool::ResetRetroSlider (   )  [protected]

There has been a change in the selection so we need to update the retro slider state. void BezierTool::ResetRetroSlider() Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 22/11/94 Parameters: -  [INPUTS] Returns: Definition at line 3472 of file beztool.cpp. { Node* pNode = OneNodePathSelected(); Path* pPath = NULL; if (pNode) pPath = &(((NodePath*)pNode)->InkPath); if (pPath && (!pPath->IsSubSelection())) pPath=NULL; UpdateRetroSlider(pPath); }

void BezierTool::RetroSmoothChanging (  double  smooth  )  [protected]

Scan the selection for a path to smooth. If we find only one path object selected then we should tell the retro smooth code to begin smoothing. Arh!, actually we need to be able to keep track of the selected object? possibly.... Surely its fast enough already to find the selected objects, there must be some caching going on somewhere. Ok, best thing to do is to make sure theres only one selected object and ignore the slider change if there isn't. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/11/94 Parameters: smooth  = smoothness level to use [INPUTS] Returns: Definition at line 3376 of file beztool.cpp. { if (!RetroFlag) { Node* pNode = OneNodePathSelected(); if (pNode == NULL) return; Spread* pSpread = pNode->FindParentSpread(); if (pSpread == NULL) return; RetroFlag = TRUE; pRetroNode = pNode; pRetroSpread = pSpread; } // ok, at this stage we should have a path to work with. pSmooth->Changing((NodePath*)pRetroNode, pRetroSpread, smooth); }

void BezierTool::RetroSmoothFinished (   )  [protected]

Calls the retro smooth finalisation code to perform the completed smoothing action. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/11/94 Parameters: [INPUTS]  Returns: Definition at line 3414 of file beztool.cpp. { // ok, at this stage we should have a path to work with. if (RetroFlag) { pSmooth->Finished(); RetroFlag = FALSE; } }

void BezierTool::RetroSmoothInvalidate (   )  [protected]

Invalidate the retro smooth cached information. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 22/11/94 Parameters: -  [INPUTS] Returns: Definition at line 3564 of file beztool.cpp. { // set the slider to full RetroSmoothSet(100, TRUE); // and tell the reto smooth op. if (pSmooth != NULL) pSmooth->Invalidate(); }

void BezierTool::RetroSmoothSet (  INT32  percent, BOOL  Enabled )  [protected]

Set the position of the retro smooth slider, given a percentage value. The function will also update the percent text field. void BezierTool::RetroSmoothSet(INT32 percent, BOOL Enabled) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/11/94 Parameters: percent  = the value to set the smooth slider to (0..100) [INPUTS] Returns: Definition at line 3526 of file beztool.cpp. { // Set the pip position if (pBezToolInfoBarOp) { if (pBezToolInfoBarOp->IsOpen()) { pBezToolInfoBarOp->SetLongGadgetValue(_R(IDC_SMOOTHSLIDER), percent); // Set the percentage string TCHAR Str[32]; String_32 jcf(_R(IDS_PERCENT_FORMAT)); camSnprintf(Str, 31, jcf, (INT32) percent); String_32 PercentStr(Str); pBezToolInfoBarOp->SetStringGadgetValue(_R(IDC_SMOOTHPERCENT), PercentStr); pBezToolInfoBarOp->EnableGadget(_R(IDC_SMOOTHSLIDER), Enabled); pBezToolInfoBarOp->EnableGadget(_R(IDC_SMOOTHPERCENT), Enabled); } } }

void BezierTool::SelectChange (  BOOL  isSelected  )  [virtual]

Called when the tool is selected or deselected. Creates and pushes the tool's cursor; pops and destroys it. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: If creating any cursor fails, all are deleted and the user is told about lack of memory See also: - Reimplemented from Tool_v1. Definition at line 376 of file beztool.cpp. { if (isSelected) { // This tool has just been selected. Create an appropriate cursor, and push it // onto the top of the cursor stack so it'll appear when the pointer moves into // our window. MyCurrentCursor = NULL; // in case we couldn't create one! pcMoveBezCursor = new Cursor(this, _R(IDC_MOVEBEZIERCURSOR)); if (!pcMoveBezCursor || !pcMoveBezCursor->IsValid()) { InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); return; } pcReshapeLineCursor = new Cursor(this, _R(IDC_RESHAPECURSOR)); if (!pcReshapeLineCursor || !pcReshapeLineCursor->IsValid()) { delete pcMoveBezCursor; InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); return; } pcNewPathCursor = new Cursor(this, _R(IDC_NEWPATHCURSOR)); if (!pcNewPathCursor || !pcNewPathCursor->IsValid()) { delete pcMoveBezCursor; delete pcReshapeLineCursor; InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); return; } pcClosePathCursor = new Cursor(this, _R(IDC_CLOSEPATHCURSOR)); if (!pcClosePathCursor || !pcClosePathCursor->IsValid()) { delete pcMoveBezCursor; delete pcReshapeLineCursor; delete pcNewPathCursor; InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); return; } pcAddPathCursor = new Cursor(this, _R(IDC_ADDPATHCURSOR)); if (!pcAddPathCursor || !pcAddPathCursor->IsValid()) { delete pcMoveBezCursor; delete pcReshapeLineCursor; delete pcNewPathCursor; delete pcClosePathCursor; InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); return; } CurrentCursorID = CursorStack::GPush(pcNewPathCursor, FALSE); MyCurrentCursor = pcNewPathCursor; // Which blobs do I want displayed BlobManager* BlobMgr = GetApplication()->GetBlobManager(); if (BlobMgr != NULL) { // Decide which blobs we will display BlobStyle MyBlobs; MyBlobs.Object = TRUE; // Tell the blob manager BlobMgr->ToolInterest(MyBlobs); } if (FloatingEndpoint) BlobMgr->RenderToolBlobsOn(this, MoveToSpread,NULL); pBezToolInfoBarOp->Create(); SetModeFlag(); RetroFlag = FALSE; ResetRetroSlider(); //Alias all the nudge ops to the path specific ones. OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEUP1); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeUp1),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEUP5); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeUp5),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEUP10); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeUp10),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEUPFIFTH); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeUpFifth),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEUPPIXEL1); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeUpPixel1),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEUPPIXEL10); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeUpPixel10),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEDOWN1); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeDown1),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEDOWN5); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeDown5),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEDOWN10); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeDown10),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEDOWNFIFTH); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeDownFifth),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEDOWNPIXEL1); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeDownPixel1),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGEDOWNPIXEL10); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeDownPixel10),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGELEFT1); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeLeft1),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGELEFT5); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeLeft5),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGELEFT10); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeLeft10),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGELEFTFIFTH); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeLeftFifth),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGELEFTPIXEL1); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeLeftPixel1),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGELEFTPIXEL10); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeLeftPixel10),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGERIGHT1); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeRight1),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGERIGHT5); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeRight5),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGERIGHT10); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeRight10),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGERIGHTFIFTH); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeRightFifth),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGERIGHTPIXEL1); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeRightPixel1),NULL,0); pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NUDGERIGHTPIXEL10); pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpPathNudgeRightPixel10),NULL,0); // If there is are TextStories or Blends with paths selected then select the paths // (PS. This is a rather disgusting way of doing things, and one you can't blame on me - MarkN 17-5-99) // Now its made even more disgusting - since we wan't to do this for bevels, contours and shadows as well! (CGS 18/9/2000) Range SelRng(*(GetApplication()->FindSelection())); Node* pNode = SelRng.FindFirst(); while (pNode != NULL) { if (IS_A(pNode, TextStory)) { TextStory* pStory = (TextStory*)pNode; if (pStory->GetTextPath() != NULL) pStory->GetTextPath()->Select(TRUE); } else if (IS_A(pNode, NodeBlend)) { NodeBlend* pNodeBlend = (NodeBlend*)pNode; UINT32 NBPCounter = 0; NodeBlendPath* pNodeBlendPath = pNodeBlend->GetNodeBlendPath(NBPCounter++); while (pNodeBlendPath != NULL) { pNodeBlendPath->Select(TRUE); pNodeBlendPath = pNodeBlend->GetNodeBlendPath(NBPCounter++); } } else if ((IS_A (pNode, NodeContour)) || (IS_A (pNode, NodeBevel)) || (IS_A (pNode, NodeShadow))) { Node* pControl = pNode->FindParent (); Node* pNode = SliceHelper::FindNextOfClass(pControl, pControl, CC_RUNTIME_CLASS (NodePath)); while (pNode) { ((NodeRenderable*) pNode)->Select (TRUE); pNode = (AttrFillGeometry*) SliceHelper::FindNextOfClass(pNode, pControl, CC_RUNTIME_CLASS (NodePath)); } pNode = SliceHelper::FindNextOfClass(pControl, pControl, CC_RUNTIME_CLASS (NodeRegularShape)); while (pNode) { ((NodeRenderable*) pNode)->Select (TRUE); pNode = (AttrFillGeometry*) SliceHelper::FindNextOfClass(pNode, pControl, CC_RUNTIME_CLASS (NodeRegularShape)); } } pNode = SelRng.FindNext(pNode); } } else { // Deselection - destroy the tool's cursor, if there is one. if (MyCurrentCursor) { CursorStack::GPop(CurrentCursorID); MyCurrentCursor = NULL; CurrentCursorID = 0; delete pcNewPathCursor; delete pcMoveBezCursor; delete pcReshapeLineCursor; delete pcClosePathCursor; delete pcAddPathCursor; } // ensure any tool object blobs are removed. BlobManager* BlobMgr = GetApplication()->GetBlobManager(); if (BlobMgr != NULL) { BlobStyle bsRemoves; bsRemoves.ToolObject = TRUE; BlobMgr->RemoveInterest(bsRemoves); } // Clear the floating endpoint condition if it exists // If camelot is shutting down then dont do it as the operation history has already been // vaped from the document! if (FloatingEndpoint && !GetApplication()->CamelotIsDying()) RemoveFloater(&MoveToPoint, MoveToSpread, Document::GetSelected()); pBezToolInfoBarOp->Delete(); } }

void BezierTool::SetModeFlag (   )

Sets the current tool mode (new/add/change) and gets the infobar to redraw the text item that shows it. We are in New mode if there are no selected lines. We are in Add mode if there is just one endpoint on the end od a path selected. Otherwise we are in Change mode. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/94 Parameters: -  [INPUTS] CurrentToolMode  is set the the current tool mode [OUTPUTS] Definition at line 1634 of file beztool.cpp. { SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); // CurrentMode OldMode = CurrentToolMode; CurrentToolMode = New; while ((pNode != NULL) && (CurrentToolMode != Change)) { NodePath* pSelected = FindEditablePath(pNode); if (pSelected) { Path* ThisPath = &(pSelected->InkPath); PathFlags* Flags = ThisPath->GetFlagArray(); INT32 UsedSlots = ThisPath->GetNumCoords(); // Go through the points in this path summing the selected endpoints for (INT32 i=0; i<UsedSlots; i++) { if (Flags[i].IsSelected && Flags[i].IsEndPoint) { if ( (i!=0) && (i!=(UsedSlots-1)) ) { CurrentToolMode = Change; break; } else { if (CurrentToolMode == Add) { CurrentToolMode = Change; break; } else CurrentToolMode = Add; } } } } pNode = Selected->FindNext(pNode); } DialogBarOp::SetSystemStateChanged(); }

void BezierTool::SetMoveTo (  DocCoord  MovePos, Spread *  pSpread, Document *  pDoc )

This function is called from an operation which tells the tool that there should be a virtual moveTo coordinate at the given point. This virtual coordinate looks much like the old single moveto used to in ArtWorks, with the added advantage that it doesn't really exist, so it can't cock up the tree like they used to do in ArtWorks. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 18/7/94 Parameters: MovePos  is the coordinate of the virtual moveto [INPUTS] pSpread points at the spread containing the coordinate pDoc pointer to the document that contains the endpoint -  [OUTPUTS] Returns: - Errors: - See also: BezierTool::ClearMoveTo Definition at line 1506 of file beztool.cpp. { // Set the member variables of the tool MoveToDoc = pDoc; MoveToPoint = MovePos; MoveToSpread = pSpread; FloatingEndpoint = TRUE; // Now display the blob if (IsCurrent()) { BlobManager* BlobMgr = GetApplication()->GetBlobManager(); if (BlobMgr) BlobMgr->RenderToolBlobsOn(this, pSpread, NULL); } }

void BezierTool::UpdateRetroSlider (  Path *  pPath  )  [protected]

Sets the retro smooth slider position for a given path. void BezierTool::UpdateRetroSlider(Path* pPath) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 22/11/94 Parameters: pPath  = a path pointer, if NULL then the slider is set to zero [INPUTS] Definition at line 3499 of file beztool.cpp. { if (pSmooth && pPath) { double acc = pSmooth->ReturnCachedAccuracy(pPath); INT32 lacc = (INT32) (acc+0.5); RetroSmoothSet(lacc, TRUE); } else RetroSmoothSet(0, FALSE); }

---

Friends And Related Function Documentation

friend class BezToolInfoBarOp [friend]

Definition at line 244 of file beztool.h.

---

Member Data Documentation

TCHAR * BezierTool::Author = _T("Jim (latterly Peter)") [static, protected]

Definition at line 302 of file beztool.h.

BOOL BezierTool::CreateCurve = TRUE [static, protected]

Definition at line 338 of file beztool.h.

BOOL BezierTool::CreateCusp = FALSE [static, protected]

Definition at line 339 of file beztool.h.

INT32 BezierTool::CurrentCursorID [protected]

Definition at line 316 of file beztool.h.

CurrentMode BezierTool::CurrentToolMode [protected]

Definition at line 348 of file beztool.h.

BOOL BezierTool::DontDrawOnClearMoveTo [protected]

Definition at line 346 of file beztool.h.

TCHAR * BezierTool::FamilyName = _T("Drawing Tools") [static, protected]

Definition at line 299 of file beztool.h.

BOOL BezierTool::FloatingEndpoint [protected]

Definition at line 322 of file beztool.h.

Document* BezierTool::MoveToDoc [protected]

Definition at line 323 of file beztool.h.

DocCoord BezierTool::MoveToPoint [protected]

Definition at line 324 of file beztool.h.

Spread* BezierTool::MoveToSpread [protected]

Definition at line 325 of file beztool.h.

Cursor* BezierTool::MyCurrentCursor [protected]

Definition at line 314 of file beztool.h.

BezToolInfoBarOp * BezierTool::pBezToolInfoBarOp = NULL [static, protected]

Definition at line 335 of file beztool.h.

Cursor* BezierTool::pcAddPathCursor [protected]

Definition at line 312 of file beztool.h.

Cursor* BezierTool::pcClosePathCursor [protected]

Definition at line 313 of file beztool.h.

Cursor* BezierTool::pcMoveBezCursor [protected]

Definition at line 309 of file beztool.h.

Cursor* BezierTool::pcNewPathCursor [protected]

Definition at line 311 of file beztool.h.

Cursor* BezierTool::pcReshapeLineCursor [protected]

Definition at line 310 of file beztool.h.

Node* BezierTool::pRetroNode [protected]

Definition at line 343 of file beztool.h.

Spread* BezierTool::pRetroSpread [protected]

Definition at line 344 of file beztool.h.

RetroSmooth* BezierTool::pSmooth [protected]

Definition at line 341 of file beztool.h.

TCHAR * BezierTool::Purpose = _T("To Draw arbitrary lines") [static, protected]

Definition at line 301 of file beztool.h.

BOOL BezierTool::RetroFlag [protected]

Definition at line 342 of file beztool.h.

DocCoord BezierTool::StartPos [protected]

Definition at line 305 of file beztool.h.

Spread* BezierTool::StartSpread [protected]

Definition at line 306 of file beztool.h.

TCHAR * BezierTool::ToolName = _T("Bezier Tool") [static, protected]

Definition at line 300 of file beztool.h.

---

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

• tools/beztool.h (r1785/r1282)
• tools/beztool.cpp (r1785/r1700)

---