PenTool Class Reference

This class handles the Pen Tool that is used to draw lines and curves via clicking and draging on the workarea. More...

#include <pentool.h>

Inheritance diagram for PenTool:

List of all members.

Public Member Functions
	PenTool ()
	Dummy Constructor - It does nothing. All the real initialisation is done in PenTool::Init which is called by the Tool Manager.
	~PenTool ()
	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.
virtual void	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	To handle a Mouse Click event for the Pen Tool.
virtual void	RenderToolBlobs (Spread *, DocRect *)
	The blobs this tool renders are (1) a moveto floating endpoint (2) a dragto floating endpoint These are usually rendered after the first click/drag on a document.
virtual BOOL	GetStatusLineText (String_256 *, Spread *, DocCoord, ClickModifiers)
	generate up-to-date text for the status line (called on idles)
virtual void	OnMouseMove (DocCoord, Spread *, ClickModifiers)
	This routine is called whenever the mouse moves while we're in the pen tool. it sees what is under the pointer, and flips the cursor if clicking will have a different effect.
virtual BOOL	OnKeyPress (KeyPress *pKeyPress)
	To handle keypress events for the Pen 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	GenerateStatusLineText (NodePath *pNodePath, penclick WhatToDo, String_256 *pStatusMsg)
	Loads up an appropriate help string into the text buffer pointed to by pStatusMsg, using the nodepath and 'whattodo' information passed.
void	SetInternalState ()
	This function is called from an operation which tells the tool that there should be a virtual moveto coordinate and dragto coordinate set within the tool. If the dragto is equal to the moveto, then an internal move should be created, rather than an internal drag.
void	ClearInternalState ()
	Clears the internal condition.
BOOL	OverPathEnd (DocCoord, Spread *, NodePath **)
penclick	DetermineClickEffect (DocCoord, Spread *, NodePath **)
	Used when single clicking. This routine determines what effect a click will have. In this tool, clicking will add a segment to the end of a line, adjust the last element of a path or start a new path entirely.
void	RemoveSelection (DocCoord PointerPos, Spread *pSpread, NodePath *pNodePath=NULL)
	This routine scans the specified spread for all path objects and checks whether the mouse coord is over an open end point. It can be used to work out whether to change the mouse shape or not. This routine should really exist in some other file, available to all tools but I dont know where to put it yet so it shall have to stay here for the mo.
void	ClearPath ()
	Throw away the internal data of the pen path.
void	ClearOp ()
	Throw away the internal op state we've been holding.
void	CreateNewPath ()
	Once a drag has finished we need to build a new path with the data.
void	AddElementToPath ()
	Once a drag has finished we need to add the newly edited element to the specified path.
void	CloseWithPath ()
	Once a drag has finished we need to add the newly edited element to the specified path.
penopstate	GetPenOpState () const
	return the operation state the pen tool thinks its in.
Private Member Functions
	CC_DECLARE_MEMDUMP (PenTool)
void	ClickOnEndPoint (ClickType Click, ClickModifiers ClickMods, Spread *pSpread, NodePath *pNodePath)
	An end point click has occured. This function acts on such a click by selecting the point or editing the point dependent on the click type.
BOOL	CreatePenCursors ()
	Pen tool cursor creation.
void	DeletePenCursors ()
	Pen tool cursor deletion.
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.
Private Attributes
penstate	CurrPenState
penopstate	CurrPenOpState
Path	EditPath
ControlPts	EditHandles
NodePath *	pNodePath
INT32	NodeIndex
Cursor *	pcPenCursor
Cursor *	pcPenAdjustCursor
Cursor *	pcPenReshapeCursor
Cursor *	pcMoveBezCursor
Cursor *	MyCurrentCursor
INT32	CurrentCursorID
PenToolInfoBarOp *	pPenInfoBarOp
Static Private Attributes
static TCHAR *	FamilyName = _T("Drawing Tools")
static TCHAR *	ToolName = _T("Pen Tool")
static TCHAR *	Purpose = _T("To draw lines and curves")
static TCHAR *	Author = _T("Mike")

---

Detailed Description

This class handles the Pen Tool that is used to draw lines and curves via clicking and draging on the workarea.

Author:

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

Date:

19/9/94

Definition at line 158 of file pentool.h.

---

Constructor & Destructor Documentation

PenTool::PenTool (   )

Dummy Constructor - It does nothing. All the real initialisation is done in PenTool::Init which is called by the Tool Manager. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/94 See also: PenTool::Init Definition at line 162 of file pentool.cpp. { pcPenCursor = NULL; pcPenAdjustCursor = NULL; pcPenReshapeCursor = NULL; pcMoveBezCursor = NULL; MyCurrentCursor = NULL; CurrPenState = IS_Undefined; }

PenTool::~PenTool (   )

Destructor (Virtual). Does nothing. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/94 Definition at line 186 of file pentool.cpp. { // Dummy destructor }

---

Member Function Documentation

void PenTool::AddElementToPath (   )

Once a drag has finished we need to add the newly edited element to the specified path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 30/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1668 of file pentool.cpp. { // Right, the last drag has created a new path section for me // I need to add it in to the specified nodepath object OpAddPathToPath* pOpAddPathToPath = new OpAddPathToPath; pOpAddPathToPath->DoAddPathToPath(pNodePath, &EditPath, NodeIndex); }

PenTool::CC_DECLARE_MEMDUMP (  PenTool   )  [private]

void PenTool::ChangeCursor (  Cursor *  cursor  )  [private]

Changes to the specified cursor. Will only change the cursor if it isn't already this cursor, so it doesn't flicker. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/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 1492 of file pentool.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 PenTool::ClearInternalState (   )

Clears the internal condition. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1556 of file pentool.cpp. { if (CurrPenState == IS_MoveTo || CurrPenState == IS_DragTo) { BlobManager* BlobMgr = GetApplication()->GetBlobManager(); ENSURE(BlobMgr!=NULL, "Blob Manager was not there"); BlobMgr->RenderToolBlobsOff(this, EditHandles.pHndSpread,NULL); } CurrPenState = IS_Undefined; }

void PenTool::ClearOp (   )

Throw away the internal op state we've been holding. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 30/9/94 Parameters: -  [INPUTS] Definition at line 1604 of file pentool.cpp. { CurrPenOpState = OS_Undefined; }

void PenTool::ClearPath (   )

Throw away the internal data of the pen path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 30/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1585 of file pentool.cpp. { // call the path clearing function! ClearInternalState(); EditPath.ClearPath(); }

void PenTool::ClickOnEndPoint (  ClickType  Click, ClickModifiers  ClickMods, Spread *  pSpread, NodePath *  pNodePath )  [private]

An end point click has occured. This function acts on such a click by selecting the point or editing the point dependent on the click type. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/94 Parameters: Click  - Describes the type of click that was detected. [INPUTS] ClickMods - Indicates which buttons caused the click and which modifers were pressed at the same time pSpread - the spread in which the click happened pNodePath - The path on which the click happened (current pos set to the point clicked on) -  [OUTPUTS] Returns: - Definition at line 913 of file pentool.cpp. { Path* pPath = &(pNodePath->InkPath); DocCoord* Coords = pPath->GetCoordArray(); PathFlags* Flags = pPath->GetFlagArray(); PathVerb* Verbs = pPath->GetVerbArray(); INT32 NumCoords = pPath->GetNumCoords(); // grab the index of the point actually clicked on! INT32 Pos = pPath->GetPathPosition(); // Clicks on control points have no effect // but clicks on endpoints do have an effect switch (Click) { case CLICKTYPE_SINGLE: { if (Flags[Pos].IsEndPoint) { pPath->RenderPathPenBlobs(pSpread); BOOL CurSelState = Flags[Pos].IsSelected; BOOL NewSelState = TRUE; BOOL ClearOthers = FALSE; // if shift held down then toggle the point whatever if (ClickMods.Adjust) NewSelState = !CurSelState; // if the end point is not selected and we're not toggling if (!CurSelState && !ClickMods.Adjust) ClearOthers=TRUE; if (ClearOthers) { for (INT32 i=0; i<NumCoords; i++) { Flags[i].IsSelected = FALSE; } } // Now change the selection of this point Flags[Pos].IsSelected = NewSelState; if ((Pos>0) && (!Flags[Pos-1].IsEndPoint)) Flags[Pos-1].IsSelected = NewSelState; if ((Pos+1<NumCoords) && (!Flags[Pos+1].IsEndPoint)) Flags[Pos+1].IsSelected = NewSelState; // Check for this being the first element in a closed subpath // If this element is a moveto, and the end of the path has the // CLOSEFIGURE flag set, we should select the endpoint as well if (Verbs[Pos] == PT_MOVETO) { // This for loop will find either the end of the path, or the next moveto INT32 j; for (j=Pos+1;j<NumCoords && Verbs[j] != PT_MOVETO;j++); // ; is intentional! j--; if (Verbs[j] & PT_CLOSEFIGURE) { //HandleBlobClick(Coords,Flags,j,NumCoords,TRUE); Flags[j].IsSelected = NewSelState; // If the previous point is a control point then deal with it if ((j>0) && (!Flags[j-1].IsEndPoint)) { // Change the control point's selection state Flags[j-1].IsSelected = NewSelState; } } } pPath->RenderPathPenBlobs(pSpread); } break; } case CLICKTYPE_DOUBLE: break; case CLICKTYPE_DRAG: { if ((Flags[Pos].IsEndPoint) && (!ClickMods.Menu)) { // Need to do a drag on the selected points, so we had better start an operation OpNodePathEditBlob* pOpNodePath = new OpNodePathEditBlob; if (pOpNodePath == NULL) InformError(); else pOpNodePath->DoStartDragEdit(pNodePath, Coords[Pos], pSpread); } } break; default: { } break; } }

void PenTool::CloseWithPath (   )

Once a drag has finished we need to add the newly edited element to the specified path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 30/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1694 of file pentool.cpp. { // Right, the last drag has closed a path. // I need to add it in to the specified nodepath object OpClosePathWithPath* pOpClosePathWithPath = new OpClosePathWithPath; pOpClosePathWithPath->DoClosePathWithPath(pNodePath, &EditPath, NodeIndex); }

void PenTool::CreateNewPath (   )

Once a drag has finished we need to build a new path with the data. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 30/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1642 of file pentool.cpp. { // Ok, the last drag has altered our internal drag path. We now // have a path ready to add to the tree, so we need to get on with it! OpAddNewPath* pOpAddNewPath = new OpAddNewPath; pOpAddNewPath->DoAddNewPath(&EditPath, EditHandles.pHndSpread); }

BOOL PenTool::CreatePenCursors (   )  [private]

Pen tool cursor creation. BOOL PenTool::CreatePenCursors() Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 27/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 406 of file pentool.cpp. { pcPenAdjustCursor = new Cursor(this, _R(IDC_PENADJUSTCURSOR)); if (!pcPenAdjustCursor || !pcPenAdjustCursor->IsValid()) { DeletePenCursors(); InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); return FALSE; } pcPenCursor = new Cursor(this, _R(IDC_NEWPATHCURSOR)); if (!pcPenCursor || !pcPenCursor->IsValid()) { DeletePenCursors(); InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); return FALSE; } pcPenReshapeCursor = new Cursor(this, _R(IDC_RESHAPECURSOR)); if (!pcPenReshapeCursor || !pcPenReshapeCursor->IsValid()) { DeletePenCursors(); InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); return FALSE; } pcMoveBezCursor = new Cursor(this, _R(IDC_MOVEBEZIERCURSOR)); if (!pcMoveBezCursor || !pcMoveBezCursor->IsValid()) { DeletePenCursors(); InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); return FALSE; } return TRUE; }

void PenTool::DeletePenCursors (   )  [private]

Pen tool cursor deletion. BOOL PenTool::DeletePenCursors() Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 27/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 457 of file pentool.cpp. { if (pcPenCursor!=NULL) { delete pcPenCursor; pcPenCursor=NULL; } if (pcPenAdjustCursor!=NULL) { delete pcPenAdjustCursor; pcPenAdjustCursor=NULL; } if (pcPenReshapeCursor!=NULL) { delete pcPenReshapeCursor; pcPenReshapeCursor=NULL; } if (pcMoveBezCursor!=NULL) { delete pcMoveBezCursor; pcMoveBezCursor=NULL; } }

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

Allows the tool manager to extract information about the tool. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 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 277 of file pentool.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_PEN_TOOL); Info -> Family = FamilyName; Info -> Name = ToolName; Info -> Purpose = Purpose; Info -> Author = Author; Info -> InfoBarDialog = _R(IDD_FREEHANDTOOL); Info -> BubbleID = _R(IDBBL_PEN_TOOL); }

penclick PenTool::DetermineClickEffect (  DocCoord  PointerPos, Spread *  pSpread, NodePath **  ReturnNode )

Used when single clicking. This routine determines what effect a click will have. In this tool, clicking will add a segment to the end of a line, adjust the last element of a path or start a new path entirely. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 26/9/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 has clicked on [OUTPUTS] Returns: The effect of clicking - one of NewPath, AddSegment, OnPoint or EditInternalMove Definition at line 752 of file pentool.cpp. { penclick WhatToDo = PenNewPath; // tells me what effect the click would have NodePath* WhichNode = NULL; // Saves me using a pointer to a pointer // Now scan through the selected paths, and see if we've clicked on any endpoints DocView* pDocView = DocView::GetSelected(); ENSURE( pDocView != NULL, "PenTool::DetermineClickEffect: Can't find selected DocView"); if (pDocView==NULL) return(PenNewPath); // Find the Rect round the mouse pos that counts as a hit DocRect BlobRect; OSRenderRegion::GetBlobRect(pDocView->GetViewScale(), PointerPos, BT_SELECTEDLARGEST, &BlobRect); // if we're in an internal state and someone has clicked on the moveto // again then go and edit it. if (CurrPenState == IS_MoveTo || CurrPenState == IS_DragTo) { if (BlobRect.ContainsCoord(EditHandles.HndClick)) return (PenEditInternalMove); } // Find the selected range of objects SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); INT32 TotSelectedEndpoints = 0; // Count selected points in paths BOOL MultiSegments = FALSE; 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==PenNewPath) || (WhatToDo==PenAddSegment))) { if (pNode->GetRuntimeClass() == CC_RUNTIME_CLASS(NodePath)) { // 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); // count the number of selected points on the path (excluding control points) INT32 NumCoords = ThisPath->GetNumCoords(); PathFlags* Flags = ThisPath->GetFlagArray(); // Count selected points in this path INT32 NumSelectedEndpoints = 0; INT32 lastsel = 0; for (INT32 i=0; i<NumCoords; i++) { if (Flags[i].IsSelected && Flags[i].IsEndPoint) { lastsel = i; NumSelectedEndpoints++; } } // Sum up TotSelectedEndpoints+=NumSelectedEndpoints; INT32 point; // First, see if the mouse is over a point. if (ThisPath->FindNearestPoint(PointerPos, POINTFLAG_ENDPOINTS | POINTFLAG_ENDSFIRST, &point)) { WhichNode = (NodePath*)pNode; WhatToDo = PenOnPoint; ThisPath->SetPathPosition(point); // if the mouse was over an open end and the other end of this sub // path is selected then we need to close the path // find the start and end of the subpath the point was found in INT32 start = point; INT32 end = point; ThisPath->FindStartOfSubPath(&start); ThisPath->FindEndElOfSubPath(&end); if (point==start || point==end) { INT32 other; (point==start) ? (other=end) : (other=start); if ((Flags[other].IsSelected) && (!Flags[point].IsSelected)) WhatToDo = PenClosePath; } continue; } // if the mouse is close to an element, then it might be close // enough to reshape the line if (ThisPath->PointCloseToLine(PointerPos, &point)) { WhichNode=(NodePath*)pNode; WhatToDo=PenReshapeLine; ThisPath->SetPathPosition(point); continue; } if (!MultiSegments && NumSelectedEndpoints==1) { INT32 start = lastsel; INT32 end = lastsel; ThisPath->FindStartOfSubPath(&start); ThisPath->FindEndElOfSubPath(&end); if (lastsel==start || lastsel==end) { if (WhatToDo==PenNewPath) { WhichNode=(NodePath*)pNode; WhatToDo=PenAddSegment; ThisPath->SetPathPosition(lastsel); } else { // We have more than one path with a selected end point. // Adding elements is ambiguous so force a NewPath creation WhichNode=(NodePath*)pNode; WhatToDo=PenNewPath; MultiSegments=TRUE; } } } } // 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 *ReturnNode = WhichNode; return (WhatToDo); }

void PenTool::GenerateStatusLineText (  NodePath *  pNodePath, penclick  WhatToDo, String_256 *  pStatusMsg )

Loads up an appropriate help string into the text buffer pointed to by pStatusMsg, using the nodepath and 'whattodo' information passed. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/95 Parameters: pNodePath  = pointer to a node path the mouse is over [INPUTS] (can be NULL) WhatToDo = what action to be taken (return param of DetermineClickEffect) pStatusMsg = pointer to a 256 character text buffer pStatusMsg  - holds a text string [OUTPUTS] Returns: - Errors: - Definition at line 1200 of file pentool.cpp. { switch (WhatToDo) { case PenNewPath: switch(CurrPenState) { case IS_MoveTo: pStatusMsg->Load(_R(IDS_PENADDPOINT), Tool::GetModuleID(GetID())); break; case IS_DragTo: pStatusMsg->Load(_R(IDS_PENADDCURVE), Tool::GetModuleID(GetID())); break; default: pStatusMsg->Load(_R(IDS_PENNEWPATH), Tool::GetModuleID(GetID())); break; } break; case PenAddSegment: if (pNodePath != NULL) { PathVerb Verb = (pNodePath->InkPath).GetVerb(); PathFlags Flags = (pNodePath->InkPath).GetFlags(); switch (Verb) { case PT_BEZIERTO: if (Flags.IsRotate) pStatusMsg->Load(_R(IDS_PENADDCURVE), Tool::GetModuleID(GetID())); else pStatusMsg->Load(_R(IDS_PENADDPOINT), Tool::GetModuleID(GetID())); break; default: pStatusMsg->Load(_R(IDS_PENADDPOINT), Tool::GetModuleID(GetID())); break; } } else pStatusMsg->Load(_R(IDS_PENADDPOINT), Tool::GetModuleID(GetID())); break; case PenEditInternalMove: pStatusMsg->Load(_R(IDS_PENEDITINT), Tool::GetModuleID(GetID())); break; case PenClosePath: pStatusMsg->Load(_R(IDS_PENCLOSEPATH), Tool::GetModuleID(GetID())); break; case PenReshapeLine: pStatusMsg->Load(_R(IDS_RESHAPE_LINE),Tool::GetModuleID(GetID())); break; case PenOnPoint: if (pNodePath != NULL) { PathFlags Flags = (pNodePath->InkPath).GetFlags(); if (Flags.IsSelected) pStatusMsg->Load(_R(IDS_PENONSELPOINT), Tool::GetModuleID(GetID())); else pStatusMsg->Load(_R(IDS_PENONPOINT), Tool::GetModuleID(GetID())); } break; default: pStatusMsg->Load(_R(IDS_PENADDPOINT), Tool::GetModuleID(GetID())); break; } }

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

Reimplemented from Tool_v1. Definition at line 169 of file pentool.h. { return TOOLID_PEN; };

penopstate PenTool::GetPenOpState (   )  const

return the operation state the pen tool thinks its in. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 30/9/94 Parameters: -  [INPUTS] Definition at line 1621 of file pentool.cpp. { return (CurrPenOpState); }

BOOL PenTool::GetStatusLineText (  String_256 *  ptext, Spread *  pSpread, DocCoord  coord, ClickModifiers  mods )  [virtual]

generate up-to-date text for the status line (called on idles) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/95 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 1161 of file pentool.cpp. { ERROR1IF(ptext==NULL,FALSE,"PenTool::GetStatusLineText() passed a NULL text buffer"); *ptext = ""; NodePath* pNodePath = NULL; // find what type of click we will generate penclick WhatToDo = DetermineClickEffect(coord, pSpread, &pNodePath); GenerateStatusLineText(pNodePath, WhatToDo, ptext); return TRUE; }

BOOL PenTool::Init (  void   )  [virtual]

Used to check if the Tool was properly constructed. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/94 Returns: FALSE if it does not want to be created, TRUE otherwise See also: PenTool::PenTool Reimplemented from Tool_v1. Definition at line 204 of file pentool.cpp. { BOOL ok; CCResTextFile file; // Resource File PenToolInfoBarOpCreate BarCreate; // Object that creates PenInfoBarOp objects // This should be set to NULL by default. It will be set properly below, if // everthing is working as it should pPenInfoBarOp = NULL; // initially, no cursor pcPenCursor = 0; pPenInfoBarOp = new PenToolInfoBarOp(); ok = (pPenInfoBarOp != NULL); if (ok) pPenInfoBarOp->pPenTool = this; // Set a pointer from the op to this tool #if 0 ok = file.open(_R(IDM_PENTOOL_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. ENSURE(ok,"Unable to load penbar.ini from resource\n"); if (ok) { // Info bar now exists. Now get a pointer to it String_32 str = String_32(_R(IDS_PENTOOL_INFOBARNAME)); DialogBarOp* pDialogBarOp = DialogBarOp::FindDialogBarOp(str); ok = (pDialogBarOp != NULL); if (ok) ok = pDialogBarOp->IsKindOf(CC_RUNTIME_CLASS(PenToolInfoBarOp)); if (ok) pPenInfoBarOp = (PenToolInfoBarOp*)pDialogBarOp; if (ok) pPenInfoBarOp->pPenTool = this; // Set a pointer from the op to this tool ENSURE(ok,"Failed to create PENTOOL info bar"); } #endif if (ok) ok = EditPath.Initialise(12,24); // create the edit path buffers please // Register our pen operation(s). if (ok) { ok = OpPenCreateInternal::Init(); if (ok) ok = OpPenEditInternal::Init(); if (ok) ok = OpPenCreatePath::Init(); if (ok) ok = OpPenAddElement::Init(); if (ok) ok = OpAddNewPath::Init(); if (ok) ok = OpPenClosePath::Init(); } return ok; }

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

To handle a Mouse Click event for the Pen Tool. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> (via Rik) Date: 20/9/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 592 of file pentool.cpp. { if (ClickMods.Menu) return; // Don't do anything if the user clicked the Menu button // determine what to do with this click penclick WhatToDo = DetermineClickEffect(PointerPos, pSpread, &pNodePath); // if someones holding the adjust down and we're not on a point then clear the sel if (Click==CLICKTYPE_SINGLE && ClickMods.Adjust && WhatToDo!=PenOnPoint) { RemoveSelection(PointerPos,pSpread); ClearInternalState(); return; } switch (Click) { case CLICKTYPE_SINGLE: switch (WhatToDo) { case PenNewPath: { BOOL MakeInternal = TRUE; if ((CurrPenState == IS_MoveTo) || (CurrPenState == IS_DragTo)) { // create a new path using the internal data points. // If LastDragTo==LastMoveTo, then the internal is a point, // else a curve control end exists. if (EditHandles.pHndSpread==pSpread) { MakeInternal = FALSE; OpPenCreatePath* pOpCreatePath = new OpPenCreatePath; if (pOpCreatePath!=NULL) { pOpCreatePath->DoPenCreatePath(&EditHandles, PointerPos, pSpread, &EditPath); CurrPenOpState = OS_CreatePath; } } } if (MakeInternal) { // First remove any selected points in the spread and create an // internal move or dragto RemoveSelection(PointerPos,pSpread); OpPenCreateInternal* pOpCreateInternal = new OpPenCreateInternal; if (pOpCreateInternal!=NULL) { pOpCreateInternal->DoPenCreateInternal(PointerPos, pSpread, &EditHandles); CurrPenOpState = OS_EditInternal; } } } break; case PenClosePath: { NodeIndex = pNodePath->InkPath.GetPathPosition(); OpPenClosePath* pOpPenClosePath = new OpPenClosePath; if (pOpPenClosePath!=NULL) { pOpPenClosePath->DoPenClosePath(pNodePath, NodeIndex, pSpread, &EditPath); CurrPenOpState = OS_ClosePath; } } break; case PenOnPoint: { // Ordinary click from OnPoint // Currently this does not work correctly because of eor'ing. The wrong // Eor blobs get put on by the node path click handler RemoveSelection(PointerPos,pSpread,pNodePath); ClickOnEndPoint(Click, ClickMods, pSpread, pNodePath); } break; case PenAddSegment: { NodeIndex = pNodePath->InkPath.GetPathPosition(); OpPenAddElement* pOpPenAddElement = new OpPenAddElement; if (pOpPenAddElement!=NULL) { pOpPenAddElement->DoPenAddElement(pNodePath, NodeIndex, PointerPos, pSpread, &EditPath); CurrPenOpState = OS_AddElement; } } break; case PenEditInternalMove: { OpPenEditInternal* pOpEditInternal = new OpPenEditInternal; if (pOpEditInternal!=NULL) { pOpEditInternal->DoPenEditInternal(&EditHandles); CurrPenOpState = OS_EditInternal; } } break; case PenReshapeLine: { double pdist; INT32 tempel; pNodePath->InkPath.SqrDistanceToPoint(PointerPos, &tempel, &pdist); INT32 PathPos = pNodePath->InkPath.GetPathPosition(); OpReshapeOrAddPoint* pOpReshape = new OpReshapeOrAddPoint; if (pOpReshape!=NULL) pOpReshape->