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->DoStartDragEdit(pNodePath, PointerPos, pSpread, PathPos, pdist); else InformError( _R(IDS_OUT_OF_MEMORY), _R(IDS_OK) ); } break; } break; case CLICKTYPE_DOUBLE: break; case CLICKTYPE_DRAG: switch (WhatToDo) { case PenOnPoint: if (pNodePath) ClickOnEndPoint(Click, ClickMods, pSpread, pNodePath); break; default: break; } break; default: break; } }

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

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. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 15/08/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 1034 of file pentool.cpp. { // We don't want to know about key release events if (pKeyPress->IsRelease()) return FALSE; // 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))) { if ((CurrPenState == IS_MoveTo) || (CurrPenState == IS_DragTo)) { ClearInternalState(); return TRUE; } } // break at points op key short cut. 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(); return TRUE; } } } // if delete pressed, try to delete the selected points in this path if ((pKeyPress->GetVirtKey() == CAMKEY(DELETE)) || (*pKeyPress == KeyPress(CAMKEY(BACK))) ) { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpDeletePoints)); String_256 UIDesc; if (pOpDesc != NULL) { OpState State = OpDeletePoints::GetState(&UIDesc, NULL); if (!State.Greyed) { pOpDesc->Invoke(); return TRUE; } } } // If we get this far then the keypress wasn't handled return FALSE; }

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

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. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: coord  - The DocCoord of the point where the mouse has moved to [INPUTS] pSpread - The spread in which the move occurred mods - which buttons/keys are down -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Tool_v1. Definition at line 1107 of file pentool.cpp. { NodePath* pNodePath = NULL; Cursor* whichCursor = NULL; // find what type of click we will generate penclick WhatToDo = DetermineClickEffect(coord, pSpread, &pNodePath); String_256 StatusMsg(""); GenerateStatusLineText(pNodePath, WhatToDo, &StatusMsg); GetApplication()->UpdateStatusBarText(&StatusMsg); switch (WhatToDo) { case PenNewPath: case PenAddSegment: case PenEditInternalMove: whichCursor = pcPenCursor; break; case PenOnPoint: whichCursor = pcMoveBezCursor; break; case PenClosePath: whichCursor = pcPenAdjustCursor; break; case PenReshapeLine: whichCursor = pcPenReshapeCursor; break; default: whichCursor = pcPenCursor; } ChangeCursor(whichCursor); }

BOOL PenTool::OverPathEnd (  DocCoord  , Spread *  , NodePath **  )

void PenTool::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. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/94 Parameters: PointerPos  = The position of the mouse click [INPUTS] pSpread = The spread that the occured on pNodePath = A pointer to a particular node path to leave out (defaults to NULL) Definition at line 1358 of file pentool.cpp. { // deselect any points within the spread the click occured over SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); if (pNode && pNode->FindParentSpread() == pSpread ) { while (pNode) { if (pNode!=pNodePath) { if (pNode->GetRuntimeClass() == CC_RUNTIME_CLASS(NodePath)) { Path* ThisPath = &(((NodePath*)pNode)->InkPath); PathFlags* Flags = ThisPath->GetFlagArray(); INT32 UsedSlots = ThisPath->GetNumCoords(); BOOL selected = FALSE; for (INT32 i=0; i<UsedSlots; i++) { if (Flags[i].IsSelected) { if (!selected) { // right, red selection blobs off! ThisPath->RenderPathPenBlobs(pSpread); selected = TRUE; } Flags[i].IsSelected=FALSE; } } // now, black selection blobs back on! if (selected) ThisPath->RenderPathPenBlobs(pSpread); } } pNode = Selected->FindNext(pNode); } } }

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

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. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pSpread  - The spread that the blob is to appear on [INPUTS] pClipRect - Pointer to the rect that contains the blobs (Can be NULL) Reimplemented from Tool_v1. Definition at line 1417 of file pentool.cpp. { // Can only draw the path if there is a path to draw ERROR3IF(pSpread==NULL,"PenTool::RenderToolBlobs() called with a null spread"); RenderRegion* pRegion; DocCoord LastMove = EditHandles.HndClick; DocCoord LastDrag = EditHandles.HndDrag; switch (CurrPenState) { case IS_MoveTo: pRegion = DocView::RenderOnTop(pClipRect, pSpread, ClippedEOR); while (pRegion) { // Draw a moveto blob pRegion->SetLineColour(COLOUR_BEZIERBLOB); pRegion->SetFillColour(COLOUR_TRANS); pRegion->DrawBlob(LastMove,BT_SELECTED); // Get the next region in the list pRegion = DocView::GetNextOnTop(pClipRect); } break; case IS_DragTo: { pRegion = DocView::RenderOnTop(pClipRect, pSpread, ClippedEOR); DocCoord OtherDrag; OtherDrag.x = LastMove.x - (LastDrag.x - LastMove.x); OtherDrag.y = LastMove.y - (LastDrag.y - LastMove.y); while (pRegion) { // Draw three end blobs and an eor'd dotted line pRegion->SetLineColour(COLOUR_BEZIERLINE); pRegion->DrawLine(OtherDrag,LastDrag); pRegion->SetLineColour(COLOUR_BEZIERBLOB); pRegion->SetFillColour(COLOUR_TRANS); pRegion->DrawBlob(LastMove,BT_SELECTED); pRegion->SetFillColour(COLOUR_UNSELECTEDBLOB); pRegion->SetLineColour(COLOUR_TRANS); pRegion->DrawBlob(LastDrag,BT_UNSELECTED); pRegion->DrawBlob(OtherDrag,BT_UNSELECTED); // Get the next region in the list pRegion = DocView::GetNextOnTop(pClipRect); } break; } default: break; } }

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

Called when the tool is selected or deselected. Creates and pushes the tool's cursor; pops and destroys it. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: Sends warning to debugging terminal if creating the cursor fails. See also: - Reimplemented from Tool_v1. Definition at line 319 of file pentool.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; if (!CreatePenCursors()) return; CurrentCursorID = CursorStack::GPush(pcPenCursor, FALSE); // Push, but don't display now MyCurrentCursor = pcPenCursor; // Create and display my info bar please if (pPenInfoBarOp != NULL) pPenInfoBarOp->Create(); // Which blobs do I want displayed BlobManager* BlobMgr = GetApplication()->GetBlobManager(); if (BlobMgr != NULL) { // Decide which blobs we will display BlobStyle MyBlobs; MyBlobs.Pen = TRUE; // Tell the blob manager BlobMgr->ToolInterest(MyBlobs); } // Now set some local variables so we know what state we are // in to start with CurrPenState = IS_Undefined; // alias the delete function to delete points. // OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_DELETE); // pOpDesc->AliasOperation(CC_RUNTIME_CLASS(OpDeletePoints),OpDeletePoints::GetState,0); // remove the alias to the delete function // OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_DELETE); // pOpDesc->RemoveAlias(); } else { // Deselection - destroy the tool's current cursor, if there is one. if (MyCurrentCursor) { CursorStack::GPop(CurrentCursorID); MyCurrentCursor = NULL; CurrentCursorID = 0; } DeletePenCursors(); // Hide and destroy my info bar please if (pPenInfoBarOp != NULL) pPenInfoBarOp->Delete(); // ensure any tool object blobs are removed. BlobManager* BlobMgr = GetApplication()->GetBlobManager(); if (BlobMgr != NULL) { BlobStyle bsRemoves; bsRemoves.ToolObject = TRUE; BlobMgr->RemoveInterest(bsRemoves); } ClearInternalState(); } }

void PenTool::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. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1523 of file pentool.cpp. { // Check that the handles are actually defined. if (EditHandles.pHndSpread==NULL) return; if (EditHandles.HndClick == EditHandles.HndDrag) CurrPenState = IS_MoveTo; else CurrPenState = IS_DragTo; // Now display the blobs BlobManager* BlobMgr = GetApplication()->GetBlobManager(); ENSURE(BlobMgr!=NULL, "Blob Manager was not there"); BlobMgr->RenderToolBlobsOn(this, EditHandles.pHndSpread, NULL); }

---

Member Data Documentation

TCHAR * PenTool::Author = _T("Mike") [static, private]

Definition at line 203 of file pentool.h.

INT32 PenTool::CurrentCursorID [private]

Definition at line 221 of file pentool.h.

penopstate PenTool::CurrPenOpState [private]

Definition at line 206 of file pentool.h.

penstate PenTool::CurrPenState [private]

Definition at line 205 of file pentool.h.

ControlPts PenTool::EditHandles [private]

Definition at line 209 of file pentool.h.

Path PenTool::EditPath [private]

Definition at line 208 of file pentool.h.

TCHAR * PenTool::FamilyName = _T("Drawing Tools") [static, private]

Definition at line 200 of file pentool.h.

Cursor* PenTool::MyCurrentCursor [private]

Definition at line 219 of file pentool.h.

INT32 PenTool::NodeIndex [private]

Definition at line 212 of file pentool.h.

Cursor* PenTool::pcMoveBezCursor [private]

Definition at line 218 of file pentool.h.

Cursor* PenTool::pcPenAdjustCursor [private]

Definition at line 216 of file pentool.h.

Cursor* PenTool::pcPenCursor [private]

Definition at line 215 of file pentool.h.

Cursor* PenTool::pcPenReshapeCursor [private]

Definition at line 217 of file pentool.h.

NodePath* PenTool::pNodePath [private]

Definition at line 211 of file pentool.h.

PenToolInfoBarOp* PenTool::pPenInfoBarOp [private]

Definition at line 225 of file pentool.h.

TCHAR * PenTool::Purpose = _T("To draw lines and curves") [static, private]

Definition at line 202 of file pentool.h.

TCHAR * PenTool::ToolName = _T("Pen Tool") [static, private]

Definition at line 201 of file pentool.h.

---

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

• tools/pentool.h (r1785/r1282)
• tools/pentool.cpp (r1785/r1282)

---