FreeHandTool 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 <freehand.h>

Inheritance diagram for FreeHandTool:

List of all members.

Public Member Functions
	FreeHandTool ()
	Dummp Constructor - It does nothing. All the real initialisation is done in FreeHandTool::Init which is called by the Tool Manager.
	~FreeHandTool ()
	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 ()
virtual 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 FreeHand Tool. It starts up a FreeHand Operation.
virtual 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:.
virtual BOOL	GetStatusLineText (String_256 *ptext, Spread *, DocCoord, ClickModifiers)
	Sets the status line text on request from the app.
virtual BOOL	OnIdle ()
virtual void	RenderToolBlobs (Spread *, DocRect *)
	Renders the Tools Blobs. This will be used to draw paths as they are retro fitted live, as the accuracy bar is dragged!
void	SetSmoothness (INT32 Smooth)
	Sets the freehand tools accuracy setting.
INT32	GetSmoothness ()
	for finding out the freehand tools current smoothing accuracy value
void	PreviousPathInvalid ()
	Marks the previous path as invalid. After calling this function, attempts to re-fit a path by changing the smoothing values will be ignored. This function should be called when something happens that would make it impossible to re-fit the path (eg the original is translated or rotated or undone).
void	SetPreviousPath (NodePath *, INT32 Start, INT32 Len)
	Marks the previously drawn path as valid so that it can be retro fitted. Retro fitting will be allowed until PreviousPathInvalid() is called.
FreeHandInfoBarOp *	GetInfoBar ()
BOOL	IsRetroPathStillValid ()
	Finds out if we are able to do retro fitting and is used by the info bar as well as the tool when it becomes the selected tool and when a drag of the slider starts.
INT32	BuildPathCRC (NodePath *)
	Goes though the path and adds all the coordinate offsets together to come up with a number that will hopefully identify the path uniquly, so that we can tell if this is in fact the path we want, only translated.
void	TranslateTrackData ()
	If the path in the tree has been translated since it was drawn, we have to translate the original retro fit data to match. This functions checks if a translation is required, and translates all the coords if it is needed.
void	RetroFitChanging ()
	Tries to re-fit the previous path with the current smoothness setting.
void	RetroFitFinished ()
	Should be called when any changes to the accuracy slider have been completed.
void	CreateBrush ()
	Called from the infobar, creates a brush definition from the ink objects in the selection and passes it over to the BrushComponent. Also creates a GRenderBrush render region which is used for rendering the brush into when the user begins to draw.
void	SetCurrentBrushHandle ()
	Sets the brush handle member to that of the current default brush attribute.
MILLIPOINT	GetBrushSpacing ()
	for finding out the freehand tools current brush spacing
void	SetBrushSpacing (MILLIPOINT Spacing)
	for setting the freehand tools current brush spacing
BrushHandle	GetBrushHandle ()
void	BrushFinished ()
	Called by OpDrawBrush to tell the tool that the previous draw brush op has finished. Therefore the tool must prepare for the next one (if any).
BOOL	BrushSelected (BrushHandle Handle, BOOL ApplyToSelection=TRUE)
	sets the brushhandle member of the tool to Handle. Designed to be called by the infobar when it receives a brushmessage. Also initiates a number of steps that must be taken to ensure that real time drawing with this brush can proceed smoothly
BOOL	ApplyBrushToSelection (BrushHandle Handle)
	Applies the chosen brush to all items in the selection via the attribute manager. However we do not want to make this a default attribute so if the selection is empty then nothing happens.
void	ScreenChanged (BOOL WipeRegion=FALSE)
	Called by the infobar to let the tool know that the screen has changed. Essentially this means that if we are in brush drawing mode then we need to blit the contents of the screen into our big render region.
void	InitialiseJoinInfoForBrush (AttrBrushType *pAttrBrush, NodePath *pNodePath, DocCoord JoinPoint)
	Initialises the JoinInfo struct so that we correctly join the existing brush.
void	BrushDeleted (BrushHandle Handle)
	Lets the tool know that a brush has been deactivated (we call it deleted in the UI but its actually still there). If this brush is the current brush then we need to set the current brush to default. Also informs the infobar.
BOOL	SetBrushUpdateState (UPDATE_STATE State)
	Tells us when we should next update the offscreen buffer used by the brush. Often it is wise ot wait until the next idle to update because that gives time for the screen to redraw after the brush combo has closed.
Static Public Attributes
static BOOL	FreehandPtrCrosshair = FALSE
	Determine whether freehand pointer has crosshairs or not.
Protected Member Functions
GRenderBrush *	GetBigGRenderBrush (Spread *pSpread)
	Gets a GRenderBrush the size of the current view, then renders into it the contents of the current view.
BOOL	InitialiseBrushBitmaps (GRenderBrush *pGRender)
	To work out how large our brush bitmaps must be and allocate them to the render region supplied.
BrushDefinition *	GetSelectedBrush ()
	In order to determine which brush to draw with when performing a real time draw brush operation.
BOOL	LoadCursors ()
	Loads all the cursors used by the freehand tool and pushs the normal one onto the top of the cursor stack.
void	RemoveCursors ()
	Pops the freehand tools cursor off the top of the cursor stack, frees the memory used by all the cursors in the freehand tool and sets all the pointers to NULL.
void	ChangeCursor (Cursor *pCursor)
	Changes to the specified cursor. Will only change the cursor if it isn't already this cursor, so it doesn't flicker.
BOOL	IsCursorNearEndPoint (NodePath *pPath, const DocRect &BlobRect)
	Scans the path in the NodePath to see any of its endpoints lie inside the DocRect supplied. The DocRect should be the snapping rectangle around the cursor position. If this function finds that one of the endpoints is in the rect, it will remember the path, and the position of the endpoint so that when a new freehand line is started, this data can be passed in. This function also changes the cursor to the Join cursor and sets the status bar text if it finds a match.
BOOL	IsCursorNearPath (NodePath *pPath, INT32 Range, const DocCoord &PointerPos)
	This function tests to see if any point along the paths length is close to the cursor. If it finds that it is, then the cursor and the status bar help are changed and the information about the path is remembered in case a drag starts soon.
BOOL	GetNewPaths ()
	Gets rid of the old path data and creates new paths. One of the useful side effects of doing this is that it helps to keep the path data near the top of the heap, make the freehand tool seem more responsive.
BOOL	DeletePaths ()
	Deletes the paths that hold the track data and the smoothed path and sets thier params to NULL.
BOOL	InitialiseBlendRef (NodeRenderableInk *pInk)
	To initialise a BlendRef object.
BOOL	NodeHasLineWidth (NodeRenderableInk *pNode)
void	SetColourEditorProcessing (BOOL Value)
	Tells the colour editor whether or not to do timer processing, we need to turn it off in order to draw a brush stroke.
DocRect	GetLargestInkBoundingRect ()
	as above, note that the m_brushinknodes pointer must be initialised
void	InitialiseBrushInkNodeArray (UINT32 NumObjects)
	Clears out the m_BrushRefPtrArray if it is not empty, and sets the size.
void	LaunchBrushDefinitionDialog (BrushHandle Handle)
	launches the brush edit dialog for the brush handle supplied. A good idea to call this just after creating a brush so the user can edit it before using it.
Protected Attributes
GRenderBrush *	m_pGRenderBrush
UPDATE_STATE	m_UpdateBrushState
INT32	Smoothness
String_256	StatusMsg
DocCoord	StartPos
Spread *	StartSpread
Path *	TrackData
Path *	RetroPath
INT32	StartSlot
INT32	NumSlots
INT32	PathCRC
NodePath *	PreviousPath
BOOL	AreWeRetroFitting
BOOL	IsPreviousPathValid
BOOL	IsRetroPathValid
BOOL	IsSelectBlobsOnScreen
Cursor *	pNormalCursor
Cursor *	pJoinCursor
Cursor *	pActiveCursor
Cursor *	pModifyCursor
INT32	CurrentCursorID
FreeHandJoinInfo	JoinInfo
FreeHandInfoBarOp *	pInfoBarOp
std::vector< NodeRenderableInk * >	m_BrushInkNodeArray
BlendRef *	m_pBlendRef
MILLIPOINT	m_BrushSpacing
UINT32	m_NumInkNodes
BrushHandle	m_BrushHandle
BOOL	m_bBrushReady
String_256	m_LastBrushDocument
Static Protected Attributes
static TCHAR *	FamilyName = _T("Drawing Tools")
static TCHAR *	ToolName = _T("Free Hand Tool")
static TCHAR *	Purpose = _T("To Draw arbitrary lines")
static TCHAR *	Author = _T("Rik")
Private Member Functions
	CC_DECLARE_MEMDUMP (FreeHandTool)

---

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 170 of file freehand.h.

---

Constructor & Destructor Documentation

FreeHandTool::FreeHandTool (   )

Dummp Constructor - It does nothing. All the real initialisation is done in FreeHandTool::Init which is called by the Tool Manager. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 See also: FreeHandTool::Init Definition at line 205 of file freehand.cpp. { // The Default smoothness Smoothness = 50; // No info bar or previous path by default pInfoBarOp = NULL; PreviousPath = NULL; // The previous path is not valid IsPreviousPathValid = FALSE; IsRetroPathValid = FALSE; AreWeRetroFitting = FALSE; // The actual paths TrackData = NULL; RetroPath = NULL; // Positions in the previous path to default values StartSlot = 0; NumSlots = 0; // Set the cursor pointers to null pNormalCursor = NULL; pActiveCursor = NULL; pJoinCursor = NULL; // Set the vars to deal with the Joining of paths JoinInfo.pJoinPath = NULL; JoinInfo.IsNearEndPoint = FALSE; JoinInfo.CloseSlot = 0; JoinInfo.Into = 0.0; JoinInfo.pAttrBrush = NULL; JoinInfo.FirstBrushSpacing = 25; // Make sure that the status line text is a valid string StatusMsg = String_256(""); m_pBlendRef = NULL; m_BrushSpacing = 10000; m_NumInkNodes = 0; m_pGRenderBrush = NULL; m_BrushHandle = BrushHandle_NoBrush; m_LastBrushDocument = TEXT("No document"); }

FreeHandTool::~FreeHandTool (   )

Destructor (Virtual). Does nothing. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 Definition at line 264 of file freehand.cpp. { //Clear out the old paths DeletePaths(); PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX if (m_pGRenderBrush != NULL) delete m_pGRenderBrush; #endif }

---

Member Function Documentation

BOOL FreeHandTool::ApplyBrushToSelection (  BrushHandle  Handle  )

Applies the chosen brush to all items in the selection via the attribute manager. However we do not want to make this a default attribute so if the selection is empty then nothing happens. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: Handle  to the selected brush [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Definition at line 2680 of file freehand.cpp. { // first check to see if we have a selection SelRange* pSel = GetApplication()->FindSelection(); if (pSel == NULL) { ERROR3("No selection in FreeHandTool::ApplyBrushToSelection"); return FALSE; } // we have decided that if the selection is not empty then we will not try to // go ahead and apply the attribute, as this gets annoying when you only want to // draw with a different brush if (pSel->IsEmpty()) return TRUE; // ok so we have a selection, now get an attribute node from the brush component NodeAttribute* pNewAttr = BrushComponent::CreateNode(Handle); if (pNewAttr != NULL) AttributeManager::AttributeSelected(pNewAttr); // we may have a scenario where we wish to apply the default brush if (Handle == BrushHandle_NoBrush) { // in this case we just need to make an attribute node NodeAttribute* pAttr = new AttrBrushType; if (pAttr != NULL) AttributeManager::AttributeSelected(pAttr); } return TRUE; }

void FreeHandTool::BrushDeleted (  BrushHandle  Handle  )

Lets the tool know that a brush has been deactivated (we call it deleted in the UI but its actually still there). If this brush is the current brush then we need to set the current brush to default. Also informs the infobar. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: Handle  to the brush that has been deleted [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2579 of file freehand.cpp. { if (Handle == m_BrushHandle) BrushSelected(BrushHandle_NoBrush, FALSE); if (pInfoBarOp != NULL) pInfoBarOp->RemoveBrush(Handle); }

void FreeHandTool::BrushFinished (   )

Called by OpDrawBrush to tell the tool that the previous draw brush op has finished. Therefore the tool must prepare for the next one (if any). Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - TRACEUSER( "Diccon", _T("Brush Finished\n")); Definition at line 2601 of file freehand.cpp. { // turn the colour picker back on SetColourEditorProcessing(TRUE); // turn background rendering back on Document* pDoc = Document::GetSelected(); DocView* pDocView = pDoc->GetFirstDocView(); while (pDocView) { pDocView->SetPreventRenderView(FALSE); pDocView = pDoc->GetNextDocView(pDocView); } /* DocView* pDocView = DocView::GetSelected(); //gotta be getselected in case we have multiple views if (pDocView != NULL) pDocView->SetPreventRenderView(FALSE); */ m_bBrushReady = FALSE; m_UpdateBrushState = UPDATE_ONIDLE; BrushSelected(m_BrushHandle, FALSE); }

BOOL FreeHandTool::BrushSelected (  BrushHandle  Handle, BOOL  ApplyToSelection = TRUE )

sets the brushhandle member of the tool to Handle. Designed to be called by the infobar when it receives a brushmessage. Also initiates a number of steps that must be taken to ensure that real time drawing with this brush can proceed smoothly Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: Handle  to the selected brush [INPUTS] ApplyToSelection - whether or not we wish to apply this brush to the selection -  [OUTPUTS] Returns: TRUE if successful, FALSE if something went wrong Definition at line 2398 of file freehand.cpp. { if (m_UpdateBrushState == UPDATE_NEVER) return TRUE; // first apply what we've got to the selection if (ApplyToSelection) { // if this fails then quit if (!ApplyBrushToSelection(Handle)) return FALSE; m_UpdateBrushState = UPDATE_ONIDLE; // So that we update on the next idle rather than immediately } //TRACEUSER( "Diccon", _T("Start Brush selected\n")); m_BrushHandle = Handle; // note that we do not do the update straight unless the flag is set. If it is not set then // we set the flag and then do the update on the next idle event. The reason for this is that // if we do not wait then the brush combo will still be on the screen whilst we do our screen grab if (m_UpdateBrushState == UPDATE_NOW) m_UpdateBrushState = UPDATE_NEVER; else { m_UpdateBrushState = UPDATE_ONIDLE; return TRUE; } // if its the 'null' brush then just kill the render region and leave if (m_BrushHandle == BrushHandle_NoBrush) { PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX if (m_pGRenderBrush != NULL) { delete m_pGRenderBrush; m_pGRenderBrush = NULL; } #endif return TRUE; } PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX // if we are <24BPP display then make the whole thing again from scratch // as we will need different sized brush bitmaps and everything if (m_pGRenderBrush != NULL && m_pGRenderBrush->GetScreenDepth() < 24) { delete m_pGRenderBrush; m_pGRenderBrush = NULL; } String_32 ProgString = _T("Preparing brush, please wait.."); Progress Hourglass(&ProgString, -1, FALSE); // set smoothness to zero // SetSmoothness(0); Spread* pCurrentSpread = Document::GetSelectedSpread(); // make a new GRenderBrush for the new brush if (pCurrentSpread == NULL) { ERROR3("No Spread in FreeHandTool::BrushSelected"); return FALSE; } // inform the join info of what we're going to draw JoinInfo.m_BrushHandle = m_BrushHandle; if (m_pGRenderBrush == NULL) { m_pGRenderBrush = GetBigGRenderBrush(pCurrentSpread); if (m_pGRenderBrush != NULL) { if (!InitialiseBrushBitmaps(m_pGRenderBrush)) { InformWarning(_R(IDS_BRUSHBITMAP_INVALID)); delete m_pGRenderBrush; m_pGRenderBrush = NULL; return FALSE; } m_bBrushReady = TRUE; } else { ToolInformError(_R(IDS_OUT_OF_MEMORY)); return FALSE; } } else { // grab whats on the screen BOOL ok = m_pGRenderBrush->CaptureView(pCurrentSpread); // tell GDraw to use this bitmap if (ok) m_pGRenderBrush->SetupMainBitmap(); return ok; //m_pGRenderBrush->CaptureView(pCurrentSpread); } #endif return TRUE; }

INT32 FreeHandTool::BuildPathCRC (  NodePath *  PrevPath  )

Goes though the path and adds all the coordinate offsets together to come up with a number that will hopefully identify the path uniquly, so that we can tell if this is in fact the path we want, only translated. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/94 Parameters: PrevPath  - The path to build a CRC checksum for. [INPUTS] Returns: The CRC checksum for the path, relative to the first coord Definition at line 1378 of file freehand.cpp. { INT32 TotalCRC = 0; // Get at the path in the NodePath Path* CRCPath = &(PrevPath->InkPath); // Find out about the coords and how many there are DocCoord* Coords = CRCPath->GetCoordArray(); INT32 NumCoords = StartSlot+NumSlots; // go though the coords for (INT32 i=StartSlot; i<NumCoords; i++) { // Get the coords relative from the first coord // making this process transparent to trnslation // Add it in to the CRC total TotalCRC += (Coords[i].x-Coords[StartSlot].x) + (Coords[i].y-Coords[StartSlot].y); } // return the CRC I have return TotalCRC; }

FreeHandTool::CC_DECLARE_MEMDUMP (  FreeHandTool   )  [private]

void FreeHandTool::ChangeCursor (  Cursor *  pCursor  )  [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] Returns: Errors: can fail if the cursor cannot be created - the cursor code will fail. Definition at line 708 of file freehand.cpp. { // only change if this cursor is different from the current cursor if ((pCursor!=pActiveCursor) && (pCursor!=NULL)) { // set this cursor as the current cursor and immediately display it CursorStack::GSetTop(pCursor, CurrentCursorID); // remember this is our current cursor pActiveCursor = pCursor; } }

void FreeHandTool::CreateBrush (   )

Called from the infobar, creates a brush definition from the ink objects in the selection and passes it over to the BrushComponent. Also creates a GRenderBrush render region which is used for rendering the brush into when the user begins to draw. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/99 Returns: - Definition at line 1758 of file freehand.cpp. { //TRACEUSER( "Diccon", _T("\nCreating Brush")); SelRange* pSel = GetApplication()->FindSelection(); if (pSel == NULL) { return ; } m_NumInkNodes = 0; Node* pNode = pSel->FindFirst(); if (pNode == NULL) { InformWarning(_R(IDS_BRUSHCREATENOSEL)); return; } // first count the number of objects while (pNode != NULL) { if (pNode->IsAnObject()) { if (BrushDefinition::ObjectCanCreateBrush((NodeRenderableInk*)pNode)) m_NumInkNodes++; if (m_NumInkNodes >= MAX_BRUSH_OBJECTS) { InformWarning(_R(IDS_BRUSHCREATE_TOOMANY)); break; } } pNode = pSel->FindNext(pNode); } if (m_NumInkNodes == 0) { InformWarning(_R(IDS_BRUSHCREATE_INVALID)); return; } InitialiseBrushInkNodeArray((UINT32)m_NumInkNodes); DocRect BBox; // // iterate through again and assign the selection pointers to the new array UINT32 Counter = 0; pNode = pSel->FindFirst(); while (pNode != NULL && Counter < m_NumInkNodes) { if (pNode->IsAnObject()) { // check to see that its not too big BBox = ((NodeRenderableInk*)pNode)->GetBoundingRect(); if (BBox.Height() > MAX_BRUSH_SPACING || BBox.Width() > MAX_BRUSH_SPACING) { InformWarning(_R(IDS_BRUSH_TOOBIG)); return; } if (BrushDefinition::ObjectCanCreateBrush((NodeRenderableInk*)pNode)) { m_BrushInkNodeArray[Counter++] = (NodeRenderableInk*)pNode; } } pNode = pSel->FindNext(pNode); } Spread *pBrushSpread = new Spread; if (pBrushSpread == NULL) { ERROR3("Couldn't create new brush spread"); return; } Layer *pBrushLayer = new Layer(pBrushSpread, FIRSTCHILD, String_256(TEXT("Diccon did this"))); if (pBrushLayer == NULL) { ERROR3("Couldn't create new brush (5)"); delete pBrushSpread; return; } BOOL LineWidth = FALSE; BOOL Compound = FALSE; // And attach the clipart tree to our new layer Node* pLastNode = NULL; // AttrBrushType* pAttrBrush = NULL; for (UINT32 i = 0; i < m_NumInkNodes; i++) { NodeRenderableInk* pInk = m_BrushInkNodeArray[i]; // do a quick line width check - we need this info later if (NodeHasLineWidth(pInk)) LineWidth = TRUE; if (pInk->IsCompound()) Compound = TRUE; pInk->MakeAttributeComplete(); Node* pInsertNode = NULL; // OK if we're trying to make a brush out of an object that is already a brush then // convert the object to normal shapes first. /* pInk->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), (NodeAttribute**)&pAttrBrush); if (pAttrBrush && pAttrBrush->GetBrushHandle() != BrushHandle_NoBrush) { //Turn the brush into a group with lots of nodepaths BrushBecomeAGroup BecomeA(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL); pAttrBrush->DoBecomeA(&BecomeA, pInk); // the brush will create a group out of itself and we want to retrieve that NodeGroup* pBrushGroup = BecomeA.GetNodeGroup(); if (pBrushGroup != NULL) pInsertNode = pBrushGroup; else { ERROR3("Unable to make group from brush"); return; } pAttrBrush = NULL; } else*/ { // the normal case pInsertNode = pInk->PublicCopy(); if (pInsertNode == NULL) { ERROR3("Error copying node"); return; } pInk->CopyChildrenTo(pInsertNode); } pInk->NormaliseAttributes(); if (i==0) pInsertNode->AttachNode(pBrushLayer, FIRSTCHILD, FALSE, TRUE); else pInsertNode->AttachNode(pLastNode, NEXT, FALSE, TRUE); pLastNode = pInsertNode; } // convert any indexed colours in our subtree LineDefinition::ConvertIndexedColours(pBrushSpread); // now create the brush definition BrushDefinition* pBrushDef = new BrushDefinition(pBrushSpread); if (pBrushDef == NULL) { ERROR3("Couldn't allocate brush def"); delete pBrushSpread; delete pBrushLayer; return; } // just double check if (!pBrushDef->IsActivated()) { ERROR3("Brush failed to initialise correctly, aborting Create Brush"); delete pBrushDef; delete pBrushSpread; delete pBrushLayer; return; } // set the default spacing DocRect BRect = pBrushDef->GetLargestBoundingBox(); MILLIPOINT Width = BRect.Width(); if (pBrushDef->GetNumBrushObjects() > 1 || LineWidth || Compound) { MILLIPOINT Spacing = (MILLIPOINT)(Width * 1.1); if (Spacing > MAX_BRUSH_SPACING) Spacing = MAX_BRUSH_SPACING; pBrushDef->SetSpacing(Spacing); } else pBrushDef->SetSpacing(Width / 5); // get the brush component of the document Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) { ERROR3("No document"); delete pBrushSpread; delete pBrushLayer; return; } BrushComponent *pBrushComp = (BrushComponent*)(pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent))); if (pBrushComp == NULL) { ERROR3("Couldn't get brush component"); delete pBrushSpread; delete pBrushLayer; return; } BrushHandle NewHandle = pBrushComp->AddNewItem(pBrushDef, TRUE); if (NewHandle != BrushHandle_NoBrush) { if (pInfoBarOp != NULL) pInfoBarOp->AddBrush(); // we want this brush selected BrushSelected(NewHandle, FALSE); // and we want to clear the document selection NodeRenderableInk::DeselectAll(); } else delete pBrushDef; }

BOOL FreeHandTool::DeletePaths (   )  [protected]

Deletes the paths that hold the track data and the smoothed path and sets thier params to NULL. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 1/5/95 Returns: TRUE - always Definition at line 1684 of file freehand.cpp. { // Retro fitting is no longer an option PreviousPathInvalid(); // Clear out the old Track Data if (TrackData!=NULL) { delete TrackData; TrackData = NULL; } // Clear out the smoothed version of the path if (RetroPath!=NULL) { delete RetroPath; RetroPath = NULL; } // always return TRUE at present return TRUE; }

void FreeHandTool::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 368 of file freehand.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_FREE_HAND_TOOL); Info->BubbleID = _R(IDBBL_FHND_TOOLBOX); Info->Family = FamilyName; Info->Name = ToolName; Info->Purpose = Purpose; Info->Author = Author; Info->InfoBarDialog = _R(IDD_FREEHANDTOOL); }

GRenderBrush * FreeHandTool::GetBigGRenderBrush (  Spread *  pSpread  )  [protected]

Gets a GRenderBrush the size of the current view, then renders into it the contents of the current view. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Returns: - Definition at line 2081 of file freehand.cpp. { PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX m_bBrushReady = FALSE; Document* pDoc = Document::GetSelected(); if (!pDoc) return NULL; DocView * pDocView = DocView::GetSelected(); // get the docview rect and convert to spread coords DocRect ViewRect = pDocView->GetDocViewRect(pSpread); pSpread->DocCoordToSpreadCoord(&ViewRect); // find out about our device //View* pView = View::GetSelectedView(); CCamView* pCCamView = pDocView->GetConnectionToOilView(); CDC* pDevContext = ((ScreenCamView*)pCCamView)->GetRenderDC(); HDC DeviceHdc = pDevContext->GetSafeHdc(); INT32 DeviceBPP = GetDeviceCaps(DeviceHdc, BITSPIXEL); // a couple more variables we need to get the GRenderBrush Matrix RenderMat = pDocView->ConstructRenderingMatrix(pSpread); FIXED16 Scale = 1; // INT32 i = 0; GRenderBrush* pGRender = NULL; INT32 DeviceRes = GetDeviceCaps( DeviceHdc, LOGPIXELSX ); // create a new GRenderBrush at 32BPP and 96 dpi pGRender = new GRenderBrush(ViewRect, RenderMat, Scale, 32, DeviceRes); // Check to see if the Render Region is valid! if (pGRender == NULL) { ERROR3("Failed to allocate DIB"); return NULL; } BOOL ok = pGRender->AttachDevice(pDocView, pDevContext, pSpread); if (!ok) { delete pGRender; pGRender = NULL; return NULL; } if (DeviceBPP < 24) pGRender->SetDeepDIB(FALSE); else pGRender->SetDeepDIB(TRUE); pGRender->InitDevice(); pGRender->m_DoCompression = TRUE; pGRender->InitAttributes(); pGRender->RRQuality.SetQuality(QUALITY_MAX); pGRender->SetQualityLevel(); pGRender->SetLineAttributes(); pGRender->SetFillAttributes(); // lleeeets geeet ready to render! if (!pGRender->StartRender()) { ERROR3("Unable to setup bitmap"); delete pGRender; return NULL; } // if we're less than 24 bit then we need to allocate smaller brush bitmaps as well if (DeviceBPP < 24) { if (!InitialiseBrushBitmaps(pGRender)) { InformWarning(_R(IDS_BRUSHBITMAP_INVALID)); delete pGRender; return NULL; } } // or blit, in this case, as it is quicker than rendering the view if (!pGRender->CaptureView(pSpread)) { ERROR3("Unable to capture view"); delete pGRender; return NULL; } m_bBrushReady = TRUE; return pGRender; #else return NULL; #endif }

BrushHandle FreeHandTool::GetBrushHandle (  void   )  [inline]

Definition at line 219 of file freehand.h. { return m_BrushHandle;}

MILLIPOINT FreeHandTool::GetBrushSpacing (   )

for finding out the freehand tools current brush spacing Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/99 Returns: The current brush spacing Definition at line 2191 of file freehand.cpp. { return m_BrushSpacing; }

UINT32 FreeHandTool::GetID (   )  [virtual]

Reimplemented from Tool_v1. Definition at line 391 of file freehand.cpp. { return TOOLID_FREEHAND; }

FreeHandInfoBarOp* FreeHandTool::GetInfoBar (   )  [inline]

Definition at line 199 of file freehand.h. { return pInfoBarOp;}

DocRect FreeHandTool::GetLargestInkBoundingRect (   )  [protected]

as above, note that the m_brushinknodes pointer must be initialised Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: the bounding rect of the largest brush ink object, or an empty rect Definition at line 2263 of file freehand.cpp. { DocRect LargestBRect; //create an empty rect INT32 BiggestArea = 0; for (UINT32 i = 0; i < m_NumInkNodes; i++) { DocRect TempRect = m_BrushInkNodeArray[i]->GetBoundingRect(); INT32 TempArea = TempRect.Height() * TempRect.Width(); if (TempArea > BiggestArea) { LargestBRect = TempRect; BiggestArea = TempArea; } } return LargestBRect; }

BOOL FreeHandTool::GetNewPaths (   )  [protected]

Gets rid of the old path data and creates new paths. One of the useful side effects of doing this is that it helps to keep the path data near the top of the heap, make the freehand tool seem more responsive. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 1/5/95 Returns: TRUE if everything worked like a dream, FALSE if it screwed up big time Definition at line 1628 of file freehand.cpp. { // Delete the paths that we have DeletePaths(); // Create some new paths if ((RetroPath==NULL) && (TrackData==NULL)) { // Create a new path for the track data TrackData = new Path(); if (TrackData==NULL) return FALSE; // Create a new path for the smoothed data RetroPath = new Path(); if (RetroPath==NULL) { delete TrackData; TrackData = NULL; return FALSE; } // init the track buffer and fail if it does not work if (!TrackData->Initialise(48,48)) { DeletePaths(); return FALSE; } // Same with the retro fitting path if (!RetroPath->Initialise(12, 12)) { DeletePaths(); return FALSE; } } // All Worked return TRUE; }

BrushDefinition * FreeHandTool::GetSelectedBrush (   )  [protected]

In order to determine which brush to draw with when performing a real time draw brush operation. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: pointer to the brush definition of the current default brush attribute this can be NULL. Definition at line 2334 of file freehand.cpp. { Document* pDoc = Document::GetCurrent(); ERROR2IF(pDoc == NULL, NULL, "No document"); BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent)); if (pBrushComp == NULL) { ERROR3("No brush component"); return NULL; } return pBrushComp->FindBrushDefinition(m_BrushHandle); }

INT32 FreeHandTool::GetSmoothness (   )

for finding out the freehand tools current smoothing accuracy value Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Returns: The freehand accuracy setting Definition at line 1242 of file freehand.cpp. { return Smoothness; }

BOOL FreeHandTool::GetStatusLineText (  String_256 *  ptext, Spread *  , DocCoord  , ClickModifiers  )  [virtual]

Sets the status line text on request from the app. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 5/1/95 Parameters: Others  not used [INPUTS] pText  - pointer to a string that will hold the text [OUTPUTS] Returns: TRUE if it set the text, FALSE if not Reimplemented from Tool_v1. Definition at line 1043 of file freehand.cpp. { *ptext = StatusMsg; return TRUE; }

BOOL FreeHandTool::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: FreeHandTool::FreeHandTool Reimplemented from Tool_v1. Definition at line 289 of file freehand.cpp. { // This should be set to NULL by default. It will be set properly below, if // everthing is working as it should pInfoBarOp = NULL; if (!OpRetroFit::Init()) return FALSE; // Now we have to declare all our operations and if that works, try to find // the freehand tools info bar and create it if (OpFreeHand::Declare()) { pInfoBarOp = new FreeHandInfoBarOp(); if (pInfoBarOp) pInfoBarOp->pTool = this; PORTNOTE("dialog", "Removed Bar reading") #if 0 // Resource File and Object that creates FreeHandInfoBarOp objects CCResTextFile ResFile; FreeHandInfoBarOpCreate BarCreate; if (ResFile.open(_R(IDM_FREEHAND_BAR), _R(IDT_INFO_BAR_RES))) { // Found the file and opened it if (DialogBarOp::ReadBarsFromFile(ResFile,BarCreate)) { // read it in ok, so close it ResFile.close(); // Info bar now exists. Now get a pointer to it String_32 str = String_32(_R(IDS_FREEHAND_INFOBARNAME)); DialogBarOp* pDialogBarOp = DialogBarOp::FindDialogBarOp(str); // Should have a dialog bar op by now if (pDialogBarOp != NULL) { // Make sure it is what we were expecting and set it if (pDialogBarOp->IsKindOf(CC_RUNTIME_CLASS(FreeHandInfoBarOp))) { pInfoBarOp = (FreeHandInfoBarOp*) pDialogBarOp; pInfoBarOp->pTool = this; } } } } #endif } GetApplication()->DeclareSection(_T("Mouse"), 10); GetApplication()->DeclarePref(_T("Mouse"), _T("FreehandPtrCrosshair"), &FreehandPtrCrosshair, FALSE, TRUE); // See if it all worked and return depending on the result ENSURE(pInfoBarOp!=NULL, "Failed to create FreeHand Info Bar" ); if (pInfoBarOp==NULL) return FALSE; else return TRUE; }

BOOL FreeHandTool::InitialiseBlendRef (  NodeRenderableInk *  pInk  )  [protected]

To initialise a BlendRef object. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: pInk  - inknode to generate the blendref from [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, false otherwise Definition at line 2229 of file freehand.cpp. { ERROR2IF(pInk == NULL,FALSE,"InkNode is NULL"); if (m_pBlendRef != NULL) { delete m_pBlendRef; m_pBlendRef = NULL; } m_pBlendRef = new BlendRef; BOOL ok = (m_pBlendRef != NULL); // initialise the blender Progress* pProgress = NULL; if (ok) ok = m_pBlendRef->Initialise(pInk, -1, NULL, pProgress, FALSE, NULL); return ok; }

BOOL FreeHandTool::InitialiseBrushBitmaps (  GRenderBrush *  pGRender  )  [protected]

To work out how large our brush bitmaps must be and allocate them to the render region supplied. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: pGRender  - the render region for which we want brush bitmaps for [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE if something went wrong Definition at line 2523 of file freehand.cpp. { ERROR2IF(pGRender == NULL, FALSE, "GRenderBrush is NULL in FreeHandTool::InitialiseBrushBitmaps"); // first work out the largest possible size of our brush BrushDefinition* pBrushDef = GetSelectedBrush(); if (pBrushDef == NULL) { ERROR3("No brush definition"); return FALSE; } // find out how big the biggest shape is DocRect LargestRect = pBrushDef->GetLargestPossibleRect(TRUE); if (LargestRect.IsEmpty()) { ERROR3("Empty bounding rect"); return FALSE; } // Oh dear it still isn't big enough, guess I'll just have to resort to // this nasty hack (please look away) /* INT32 Height = LargestRect.Height(); INT32 Width = LargestRect.Width(); LargestRect.Inflate((INT32)(Height * 0.1), (INT32)(Width *0.1)); */ PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX if (!pGRender->InitialiseBrushBitmaps(LargestRect)) { return FALSE; } #endif return TRUE; }

void FreeHandTool::InitialiseBrushInkNodeArray (  UINT32  NumObjects  )  [protected]

Clears out the m_BrushRefPtrArray if it is not empty, and sets the size. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Number  of objects to size the array at [INPUTS] Returns: - Definition at line 2049 of file freehand.cpp. { UINT32 i = 0; // we don't wish to delete any pointers as they point to objects // that are actually in the document. m_BrushInkNodeArray.clear(); m_BrushInkNodeArray.resize(NumObjects); // fill the array with NULL objects so that we can check later // to see if our allocations have worked i = 0; while (i < m_BrushInkNodeArray.size()) { m_BrushInkNodeArray[i++] = NULL; } }

void FreeHandTool::InitialiseJoinInfoForBrush (  AttrBrushType *  pAttrBrush, NodePath *  pPath, DocCoord  JoinPoint )

Initialises the JoinInfo struct so that we correctly join the existing brush. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/5/2000 Parameters: pAttrBrush  - the brush that we are going to join to [INPUTS] NodepPath - the path that we are going to join to JoinPoint - the point where we will join Returns: - Definition at line 2813 of file freehand.cpp. { if (pAttrBrush == NULL || pPath == NULL) { ERROR3("NULL entry pointers in FreeHandTool::InitialiseJoinInfoForBrush"); return; } // initialise joininfo with the data JoinInfo.m_BrushHandle = pAttrBrush->GetBrushHandle(); // Now we need to find out the spacing of the first brush object. //find out how far along the path we are MILLIPOINT Distance = 0; if (!pPath->InkPath.GetDistanceToPoint(JoinPoint, &Distance)) { ERROR3("Unable to find distance to point in FreeHandTool::InitialiseJoinInfoForBrush"); return; } // didn't bother to write an access fn. for this, ask the path processor to work // out the spacing. BrushAttrValue* pVal = (BrushAttrValue*)pAttrBrush->GetAttributeValue(); if (pVal != NULL) { PathProcessorBrush* pPPB = pVal->GetPathProcessor(); if (pPPB != NULL) { // we want to get the scaling and spacing at this distance along the path double Scaling = 1.0; MILLIPOINT Spacing = pPPB->GetSpacing(); pPPB->GetSpacingAndScalingAtDistance(Distance, &Spacing, &Scaling); JoinInfo.FirstBrushSpacing = (MILLIPOINT)((double)Spacing * Scaling); JoinInfo.BrushDistance = Distance; pPPB->CopyBrushData(&JoinInfo.m_BrushData); // get the stroke colour JoinInfo.UseLocalColour = pPPB->GetUseLocalFillColour(); JoinInfo.UseNamedColour = pPPB->GetUseNamedColours(); if ( JoinInfo.UseLocalColour == TRUE || JoinInfo.UseNamedColour == FALSE) { AttrStrokeColour *pStrokeCol = NULL; pPath->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), (NodeAttribute**)&pStrokeCol); if (pStrokeCol) { JoinInfo.StrokeColour = pStrokeCol->Value.Colour; } } } JoinInfo.pAttrBrush = pAttrBrush; } }

BOOL FreeHandTool::IsCursorNearEndPoint (  NodePath *  pNodePath, const DocRect &  BlobRect )  [protected]

Scans the path in the NodePath to see any of its endpoints lie inside the DocRect supplied. The DocRect should be the snapping rectangle around the cursor position. If this function finds that one of the endpoints is in the rect, it will remember the path, and the position of the endpoint so that when a new freehand line is started, this data can be passed in. This function also changes the cursor to the Join cursor and sets the status bar text if it finds a match. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/94 Parameters: pNodePath  - The Node Path that we want to test [INPUTS] BlobRect - The rectangle that the endpoints have to be in to qualify Returns: TRUE if it found an endpoint in the rect, FALSE if it did not Definition at line 1069 of file freehand.cpp. { // Find the path associated with this NodePath Path* pPath = &(pNodePath->InkPath); // Test to see if the cursor was anywhere near any of the paths endpoints INT32 CloseSlot; if (pPath->IsNearOpenEnd(BlobRect, &CloseSlot)) { // Yep, so set the eventual starting position of any new freehand paths to the // endpoint in question pPath->SetPathPosition(CloseSlot); StartPos = pPath->GetCoord(); // Also remember the path that we can Join with JoinInfo.pJoinPath = pNodePath; JoinInfo.IsNearEndPoint = TRUE; // And set the cursor ChangeCursor(pJoinCursor); // And the status bar text StatusMsg.Load(_R(IDS_FREEHANDSTARTJOIN), Tool::GetModuleID(GetID())); GetApplication()->UpdateStatusBarText(&StatusMsg); // now test to see if our nodepath is brushed NodeAttribute* pAttr = NULL; pNodePath->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), &pAttr); if (pAttr != NULL) { InitialiseJoinInfoForBrush((AttrBrushType*)pAttr, pNodePath, BlobRect.Centre()); } // and tell our caller that we found a match return TRUE; } // No match was found return FALSE; }

BOOL FreeHandTool::IsCursorNearPath (  NodePath *  pNodePath, INT32  Range, const DocCoord &  PointerPos )  [protected]

This function tests to see if any point along the paths length is close to the cursor. If it finds that it is, then the cursor and the status bar help are changed and the information about the path is remembered in case a drag starts soon. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 24/10/94 Parameters: pNodePath  - The Path that we want to see if we are near [INPUTS] Range - The squared distance away from the path that we count as being close to the line PointerPos - The position of the mouse cursor Returns: TRUE if we find that the path goes through the rectangle, FALSE if not Definition at line 1131 of file freehand.cpp. { // Find the path associated with this NodePath Path* pPath = &(pNodePath->InkPath); // Test to see if the cursor was anywhere near any of the paths endpoints INT32 CloseSlot = 0; double mu; if (pPath->IsPointCloseTo(PointerPos, Range, &CloseSlot, &mu)) { // Yep, so set the eventual starting position of any new freehand paths to the // endpoint in question StartPos = pPath->ClosestPointTo(mu, CloseSlot); // Also remember the path that we can Join with JoinInfo.pJoinPath = pNodePath; JoinInfo.IsNearEndPoint = FALSE; JoinInfo.CloseSlot = CloseSlot; JoinInfo.Into = mu; // And set the cursor ChangeCursor(pModifyCursor); // And the status bar text StatusMsg.Load(_R(IDS_FREEHANDMODSTART), Tool::GetModuleID(GetID())); GetApplication()->UpdateStatusBarText(&StatusMsg); // now test to see if our nodepath is brushed NodeAttribute* pAttr = NULL; pNodePath->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), &pAttr); if (pAttr != NULL) { AttrBrushType* pAttrBrush = (AttrBrushType*)pAttr; InitialiseJoinInfoForBrush(pAttrBrush, pNodePath, PointerPos); } // tell the caller that some point along the path is close to the pointer return TRUE; } // This path is not close to the cursor return FALSE; }

BOOL FreeHandTool::IsRetroPathStillValid (   )

Finds out if we are able to do retro fitting and is used by the info bar as well as the tool when it becomes the selected tool and when a drag of the slider starts. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/8/94 Returns: TRUE if we can Retro fit the currently selected object Definition at line 1336 of file freehand.cpp. { // Need to find out if we can retro fit the path or not BOOL IsStillValid = FALSE; SelRange* Selected = GetApplication()->FindSelection(); DocView* pDocView = DocView::GetSelected(); // If there is only one thing selected if ((pDocView!=NULL) && (Selected->Count()==1)) { // Get the selected node Node* pNode = Selected->FindFirst(); // see if it is our path if ((pNode==PreviousPath) && (pNode->IS_KIND_OF(NodePath))) { // Build the CRC for the path now and if it matches, flag that we can do retro fitting INT32 CurrentCRC = BuildPathCRC(PreviousPath); if (CurrentCRC==PathCRC) IsStillValid = TRUE; } } // and return the state of IsStillValid return IsStillValid; }

void FreeHandTool::LaunchBrushDefinitionDialog (  BrushHandle  Handle  )  [protected]

launches the brush edit dialog for the brush handle supplied. A good idea to call this just after creating a brush so the user can edit it before using it. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Handle  of the brush definition to edit [INPUTS] Returns: - Definition at line 1997 of file freehand.cpp. { // first get the brush definition from the component // get the brush component from the document Document* pDoc = Document::GetCurrent(); if (!pDoc) return; BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent)); if (!pBrushComp) return; BrushDefinition* pBrushDef = pBrushComp->FindBrushDefinition(Handle); if (!pBrushDef) return; // now launch the edit dialog BrushData* pData = pBrushDef->GetBrushData(); if (pData != NULL) { PORTNOTE("other", "Removed CBrushGadget support"); #ifndef EXCLUDE_FROM_XARALX // get the line gallery, as we want to edit the definition version LineGallery* pLineGallery = LineGallery::GetInstance(); if (pLineGallery != NULL) { // get a pointer to the gadget CBrushGadget* pGadget = pLineGallery->GetBrushGadget(); if (pGadget != NULL) { // brush definitions don't know their own handle so we need to tell the data pData->m_BrushHandle = Handle; pGadget->EnableEditingBrushDefinition (); pGadget->HandleBrushButtonClick(pData->m_BrushHandle); } // we need to delete the data delete pData; } #endif } }

BOOL FreeHandTool::LoadCursors (   )  [protected]

Loads all the cursors used by the freehand tool and pushs the normal one onto the top of the cursor stack. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/94 Returns: TRUE if it worked, FALSE if it did not Errors: ERROR1 (_R(IDE_FHAND_BADCURSORS)) if it fails to load the cursors Definition at line 607 of file freehand.cpp. { // This tool has just been selected, so it is not displaying a cursor pActiveCursor = NULL; // Try to create all our cursors - The normal cursor if (FreehandPtrCrosshair) { pNormalCursor = new Cursor(this, _R(IDC_FREEHANDTOOLCURSOR_X)); pJoinCursor = new Cursor(this, _R(IDC_FREEHANDJOINCURSOR_X)); pModifyCursor = new Cursor(this, _R(IDC_FREEHANDMODIFY_X)); } else { pNormalCursor = new Cursor(this, _R(IDC_FREEHANDTOOLCURSOR)); pJoinCursor = new Cursor(this, _R(IDC_FREEHANDJOINCURSOR)); pModifyCursor = new Cursor(this, _R(IDC_FREEHANDMODIFY)); } // did we get all the cursors ok if ((pNormalCursor==NULL) || (!pNormalCursor->IsValid()) || (pJoinCursor==NULL) || (!pJoinCursor->IsValid()) || (pModifyCursor==NULL) || (!pModifyCursor->IsValid())) { // No, at least one of them was NULL, so delete them all // Deleting the null cursor will be ok delete pNormalCursor; delete pJoinCursor; delete pModifyCursor; // and ensure that the pointers are set to NULL pNormalCursor = NULL; pJoinCursor = NULL; pModifyCursor = NULL; // and set an error and return ERROR1(FALSE, _R(IDE_FHAND_BADCURSORS)); } // All the cursors loaded ok if we got to here // So push the normal cursor onto the stack and mark it as active CurrentCursorID = CursorStack::GPush(pNormalCursor, FALSE); pActiveCursor = pNormalCursor; // return that it worked return TRUE; }

BOOL FreeHandTool::NodeHasLineWidth (  NodeRenderableInk *  pNode  )  [protected]

Definition at line 2297 of file freehand.cpp. { ERROR2IF(pNode == NULL, FALSE, "pNode is NULL in FreeHandTool::NodeHasLineWidth"); NodeAttribute* pAttr = NULL; pNode->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), &pAttr); if (pAttr == NULL) return FALSE; // ok so we've got an attribute, lets see if it has the NoColour flag set StrokeColourAttribute* pVal = (StrokeColourAttribute*)pAttr->GetAttributeValue(); if (pVal != NULL) { DocColour Col = pVal->Colour; if (Col.IsTransparent()) return FALSE; } return TRUE; }

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

To handle a Mouse Click event for the FreeHand Tool. It starts up a FreeHand Operation. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 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 DragTool. Definition at line 746 of file freehand.cpp. { if (ClickMods.Menu) return; // Don't do anything if the user clicked the Menu button // See if there is already a drag going on if (Operation::GetCurrentDragOp()!=NULL) return; // If we get a click, treat it like a mouse move, allowing the tool to set up // any info that is passed to the operation in the drag // NEW 17/4/2000 Now we also want to click-select in the Freehand tool if (Click==CLICKTYPE_SINGLE) { OnMouseMove(PointerPos, pSpread, ClickMods); DragTool::OnClick (PointerPos, Click, ClickMods, pSpread); } if (Click == CLICKTYPE_UP) { // so long as we are not interfering with any drawing operations we will // try and change the selection //if (JoinInfo.pJoinPath == NULL) { DragTool::OnClick (PointerPos, Click, ClickMods, pSpread); BROADCAST_TO_ALL(CommonAttrsChangedMsg); } } // Make sure this click is one that we want if (Click==CLICKTYPE_DRAG) { // Just what we wanted - Someone is dragging the mouse about // We need to make an operation to perform the drag with // quick safety check - if the current line width is less than 501MP then we want // to launch a freehand op even if we have a brush selected MILLIPOINT LineWidth = OpDrawBrush::GetCurrentLineWidthIfNotDefault(); // Added a condition here - if our join info brush handle indicates no brush // then we are adding to a normal line, hence don't use the brush if (m_BrushHandle == BrushHandle_NoBrush || (LineWidth != -1 && LineWidth < 501) || JoinInfo.m_BrushHandle == BrushHandle_NoBrush) { OpFreeHand* pOpFreeHand = new OpFreeHand; if ((pOpFreeHand!=NULL) && (GetNewPaths())) { // Start the drag operation and pass in the Anchor Point to the push operation pOpFreeHand->DoDrag(StartPos, StartSpread, Smoothness, &JoinInfo, TrackData); } else { // Failed to get the memory to do the job ToolInformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK)); } } else { // launch a brush op Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) { ERROR3("No document in FreeHandTool::OnClick"); return; } String_256 CurrentDoc = pDoc->GetDocName(); if (CurrentDoc != m_LastBrushDocument) { m_LastBrushDocument = CurrentDoc; m_UpdateBrushState = UPDATE_NOW; BrushSelected(m_BrushHandle, FALSE); } PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX // This is a bit of a bodge to try to stop the internal error in 8bpp if (m_pGRenderBrush && m_pGRenderBrush->GetRenderDC()->GetSafeHdc() == NULL) { delete m_pGRenderBrush; m_pGRenderBrush = NULL; } #endif if (m_pGRenderBrush == NULL || CurrentDoc != m_LastBrushDocument) { // or don't if we are not ready String_32 ProgString = _T("Preparing brush, please wait.."); Progress Hourglass(&ProgString, -1, FALSE); m_pGRenderBrush = GetBigGRenderBrush(pSpread); PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX if (m_pGRenderBrush == NULL) { ToolInformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK)); return; } #endif m_LastBrushDocument = CurrentDoc; return; } // ensures that if we are over another brush we get the correct info OnMouseMove(PointerPos, pSpread, ClickMods); OpDrawBrush* pOpDrawBrush = new OpDrawBrush(this); //TRACEUSER( "Diccon", _T("About to start new stroke\n")); if ((pOpDrawBrush != NULL)&& (GetNewPaths())) { // turn off background rendering whilst we are in progress // note that we must turn off the selected docview or else we will // screw up background rendering when we have multiple views (as I just found out) DocView* pDocView = DocView::GetCurrent(); //DocView::GetSelected(); //Current(); if (pDocView != NULL) pDocView->SetPreventRenderView(TRUE); // turn off the colour picker, as it munches CPU SetColourEditorProcessing(FALSE); PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX m_pGRenderBrush->SetupMainBitmap(); #endif // find out if our brush definition wants time stamping, and tell the op BrushDefinition* pBrushDef = GetSelectedBrush(); if (pBrushDef != NULL) pOpDrawBrush->SetTimeStamp(pBrushDef->GetTimeStampingPeriod()); pOpDrawBrush->DoDrag(StartPos, StartSpread, Smoothness, m_BrushHandle, &JoinInfo, TrackData, m_pGRenderBrush, ClickMods); m_UpdateBrushState = UPDATE_NEVER; // we REALLY don't want to be updating whilst in the middle of drawing } else { // Failed to get the memory to do the job ToolInformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK)); PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX delete m_pGRenderBrush; m_pGRenderBrush = NULL; #endif } } } }

BOOL FreeHandTool::OnIdle (   )  [virtual]

Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: FALSE always as we need more idles Reimplemented from Tool_v1. Definition at line 2726 of file freehand.cpp. { // just check that we have a document if (Document::GetCurrent() == NULL) { m_UpdateBrushState = UPDATE_NEVER; return FALSE; } if (m_UpdateBrushState == UPDATE_ONIDLE) { #ifdef NEWFASTBRUSHES static Application* pApp = GetApplication (); BOOL doCaptureNow = TRUE; if (pApp) { if (!pApp->IsRenderingComplete ()) { // TEST // there are still regions that are rendering, // we probably should NOT grab the screen yet! doCaptureNow = FALSE; TRACEUSER( "ChrisS", _T("Brush System: Not finished rendering - just ignored screen capture request ....")); } } if (doCaptureNow) { #endif // bodge so that we do not end up with the freehand cursor PORTNOTE("other", "Removed cursor bodge"); #ifndef EXCLUDE_FROM_XARALX HCURSOR Cursor = GetCursor(); #endif m_UpdateBrushState = UPDATE_NOW; BrushSelected(m_BrushHandle, FALSE); PORTNOTE("other", "Removed cursor bodge"); #ifndef EXCLUDE_FROM_XARALX SetCursor(Cursor); #endif #ifdef NEWFASTBRUSHES } #endif } return FALSE; }

void FreeHandTool::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; click modifiers [INPUTS] Over space, no selection - freehand cursor Over selected endpoint - add freehand to line Reimplemented from Tool_v1. Definition at line 914 of file freehand.cpp. { // Assume that we are not going to find anything of interest, so set the params to good values JoinInfo.pJoinPath = NULL; StartPos = Coord; StartSpread = pSpread; JoinInfo.FirstBrushSpacing = 25; // make sure the join info always reflects the brush that we should draw with JoinInfo.m_BrushHandle = m_BrushHandle; JoinInfo.pAttrBrush = NULL; JoinInfo.BrushDistance = 0; // We are interested in any selected paths that the cursor is over // we will also be needing the current docview SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); // Check to see if the selection is on the same spread as the mouse if (pNode!=NULL) { // Get the spread and return if it is different from the one with the cursor Spread* pNodeSpread = pNode->FindParentSpread(); if (pNodeSpread!=pSpread) return; } // Find the Blob manager, so we can find out how big a rect to use BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr==NULL) return; // Find the Rect round the mouse pos that counts as a hit DocRect BlobRect; pBlobMgr->GetBlobRect(Coord, &BlobRect); // Work out the square of the distance that we will count as 'close' to the line INT32 Range = BlobRect.Width() / 2; Range *= Range; // loop through the selection while (pNode!=NULL) { // We are only interested in NodePaths // Diccon 9/99 now we are also interested in NodeBlends, as long // as they are blended on a path.. if (pNode->IsNodePath()) { // get the node as a NodePath NodePath* pPath = (NodePath*) pNode; // Go and see if we are near any of the endpoints of this path // (and stop looking if it is) if (IsCursorNearEndPoint(pPath, BlobRect)) return; // We were not near the open ends of the selected path, so test // to see if we are anywhere near any point along the path if (IsCursorNearPath(pPath, Range, Coord)) return; } // Diccon added 9/99 else if (pNode->IS_KIND_OF(NodeBlend)) { UINT32 NBPCounter = 0; NodeBlendPath* pNodeBlendPath = ((NodeBlend*)pNode)->GetNodeBlendPath(NBPCounter++); while (pNodeBlendPath != NULL) { NodePath* pPath = (NodePath*)pNodeBlendPath; // Go and see if we are near any of the endpoints of this path // (and stop looking if it is) if (IsCursorNearEndPoint(pPath, BlobRect)) return; // We were not near the open ends of the selected path, so test // to see if we are anywhere near any point along the path if (IsCursorNearPath(pPath, Range, Coord)) return; pNodeBlendPath = ((NodeBlend*)pNode)->GetNodeBlendPath(NBPCounter++); } } // Now find the next selected node pNode = Selected->FindNext(pNode); } // if we are in brush mode then check to see if the document we are over is // the same as the last document we drew on. If it is different we will need to update if (m_BrushHandle != BrushHandle_NoBrush) { Document* pDoc = Document::GetCurrent(); if (pDoc != NULL) { String_256 CurrentDoc = pDoc->GetDocName(); if (CurrentDoc != m_LastBrushDocument) { m_LastBrushDocument = CurrentDoc; m_UpdateBrushState = UPDATE_NOW; BrushSelected(m_BrushHandle, FALSE); } } } // We did not find anything good, so set the cursor to the normal one ChangeCursor(pNormalCursor); // And set the status bar text StatusMsg.Load(_R(IDS_FREEHANDSTART), Tool::GetModuleID(GetID())); GetApplication()->UpdateStatusBarText(&StatusMsg); }

void FreeHandTool::PreviousPathInvalid (   )

Marks the previous path as invalid. After calling this function, attempts to re-fit a path by changing the smoothing values will be ignored. This function should be called when something happens that would make it impossible to re-fit the path (eg the original is translated or rotated or undone). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Definition at line 1262 of file freehand.cpp. { // The previous path is no longer valid, so set all // the flags and vars associated with it IsPreviousPathValid = FALSE; IsRetroPathValid = FALSE; IsSelectBlobsOnScreen = FALSE; PreviousPath = NULL; StartSlot = 0; NumSlots = 0; PathCRC = 0; // Tell the info bar to show that retro fitting is no longer possible if (pInfoBarOp != NULL) pInfoBarOp->SetRetroState(FALSE); }

void FreeHandTool::RemoveCursors (   )  [protected]

Pops the freehand tools cursor off the top of the cursor stack, frees the memory used by all the cursors in the freehand tool and sets all the pointers to NULL. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/94 See also: FreeHandTool::LoadCursors Definition at line 670 of file freehand.cpp. { // If we ever had a cursor if (pActiveCursor!=NULL) { // pop it off the stack CursorStack::GPop(CurrentCursorID); // and free up the cursors we allocated delete pNormalCursor; delete pJoinCursor; delete pModifyCursor; // and set them all to NULL pNormalCursor = NULL; pJoinCursor = NULL; pActiveCursor = NULL; pModifyCursor = NULL; CurrentCursorID = 0; } }

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

Renders the Tools Blobs. This will be used to draw paths as they are retro fitted live, as the accuracy bar is dragged! Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/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 1190 of file freehand.cpp. { // Can only draw the path if there is a path to draw if (IsPreviousPathValid && IsRetroPathValid && RetroPath!=NULL) { RenderRegion* pRegion = DocView::RenderOnTop(pClipRect, pSpread, ClippedEOR); while (pRegion) { // Draw a Cross Hair pRegion->SetLineColour(COLOUR_XOREDIT); pRegion->SetLineWidth(0); pRegion->DrawPath(RetroPath); // Get the next region in the list pRegion = DocView::GetNextOnTop(pClipRect); } } }

void FreeHandTool::RetroFitChanging (   )

Tries to re-fit the previous path with the current smoothness setting. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Definition at line 1455 of file freehand.cpp. { BOOL IsStillValid = IsRetroPathStillValid(); if (IsStillValid) { // Find the spread that the previous path was on Spread* pSpread = PreviousPath->FindParentSpread(); // Find the docview that we are looking at DocView* pDocView = DocView::GetSelected(); // if both of those are ok, carry on if (pSpread!=NULL && pDocView!=NULL) { BlobManager* BlobMgr = GetApplication()->GetBlobManager(); ENSURE(BlobMgr!=NULL, "Blob Manager was not there"); // Translate the original data if the path moved TranslateTrackData(); // Get rid of the Selection blobs if they are still on screen if (IsSelectBlobsOnScreen) { BlobMgr->RenderMyBlobs(NULL, pSpread, PreviousPath); IsSelectBlobsOnScreen = FALSE; } // Erase the old EORed path (if it was there) BlobMgr->RenderToolBlobsOff(this, pSpread, NULL); // Refit the path - First work out the current error factor double ScaleFactor = (pDocView->GetViewScale()).MakeDouble(); double ErrorLevel = (64 + (160*Smoothness)) / ScaleFactor; ErrorLevel = ErrorLevel * ErrorLevel; // and perform all the maths if ((RetroPath!=NULL) && (TrackData!=NULL)) { CurveFitObject CurveFitter(RetroPath, ErrorLevel); if (CurveFitter.Initialise(TrackData, TrackData->GetNumCoords())) CurveFitter.FitCurve(); } // Draw in the new path IsRetroPathValid = TRUE; BlobMgr->RenderToolBlobsOn(this, pSpread, NULL); AreWeRetroFitting = TRUE; } else { IsStillValid = FALSE; } } // If the retro fit is not valid, then invalidate the path properly if (!IsStillValid) { // mark the path as invalid PreviousPathInvalid(); } }

void FreeHandTool::RetroFitFinished (   )

Should be called when any changes to the accuracy slider have been completed. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Definition at line 1529 of file freehand.cpp. { // Start an operation here that will hide the original path and put a new one in // Make sure that we have a path that we are able to change if ((IsPreviousPathValid && AreWeRetroFitting) && (RetroPath!=NULL)) { // Find the spread that the previous path was on Spread* pSpread = PreviousPath->FindParentSpread(); if (pSpread!=NULL) { BlobManager* BlobMgr = GetApplication()->GetBlobManager(); ENSURE(BlobMgr!=NULL, "Blob Manager was not there"); // Draw the selection blobs back on again if (!IsSelectBlobsOnScreen) { BlobMgr->RenderMyBlobs(NULL, pSpread, PreviousPath); IsSelectBlobsOnScreen = TRUE; } // Erase the old EORed path (if it was there) BlobMgr->RenderToolBlobsOff(this, pSpread, NULL); // Build the undo info to change the existing path to the new one if (IsRetroPathValid) { // Make a copy of the node we are joining with Node* pNode; if (PreviousPath->NodeCopy(&pNode)) { // Start a slow job BeginSlowJob(); // Clear out the old data in the path NodePath* pNewPath = (NodePath*) pNode; // Go and replace the section that we have changed BOOL IsOk; if (StartSlot==0) IsOk = pNewPath->InkPath.RetroReplaceSection(StartSlot, NumSlots, RetroPath, TRUE); else IsOk = pNewPath->InkPath.RetroReplaceSection(StartSlot, NumSlots, RetroPath, FALSE); // If it worked, then build a bit of undo if (IsOk) { // Create a new Retro Fit Operation OpRetroFit* pRetroOp = new OpRetroFit; if (pRetroOp!=NULL) { // Make a note of the start slot and length of the section we are // changing as the operation causes this information to be invalidated INT32 OldStartSlot = StartSlot; INT32 OldNumSlots = RetroPath->GetNumCoords(); if (pRetroOp->BuildUndo(PreviousPath, (NodePath*)pNode)) SetPreviousPath(pNewPath, OldStartSlot, OldNumSlots); } else { // Did not get the memory for the operation IsOk = FALSE; } } // End the slow job we started EndSlowJob(); // If things generally did not work, tell the happy user if (!IsOk) ToolInformError(_R(IDS_RETROOUTOFMEM)); } } // Clear out the data in the fitted version of the path, as this is no longer needed // We do keep the Original track data though. RetroPath->ClearPath(); IsRetroPathValid = FALSE; } } // We are no longer retro fitting the path, so reset the flag to indicate this AreWeRetroFitting = FALSE; }

void FreeHandTool::ScreenChanged (  BOOL  WipeRegion = FALSE  )

Called by the infobar to let the tool know that the screen has changed. Essentially this means that if we are in brush drawing mode then we need to blit the contents of the screen into our big render region. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2643 of file freehand.cpp. { //TRACEUSER( "Diccon", _T("FreehandTool::ScreenChanged\n")); if (WipeRegion == TRUE) { PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX if (m_pGRenderBrush != NULL) { delete m_pGRenderBrush; m_pGRenderBrush = NULL; } #endif } m_bBrushReady = FALSE; m_UpdateBrushState = UPDATE_ONIDLE; }

void FreeHandTool::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: IsSelected  - TRUE if the tool is becoming selected, FALSE if it is loosing [INPUTS] the selection Returns: Errors: Sends warning to debugging terminal if creating the cursor fails. Reimplemented from Tool_v1. Definition at line 414 of file freehand.cpp. { if (isSelected) { CCPen *pPen = Camelot.GetPressurePen(); if (pPen != NULL) { PressureMode NewState = (pPen->IsRealPen()) ? PressureMode_Pen : PressureMode_None; pPen->SetPressureMode(NewState); } m_UpdateBrushState = UPDATE_ONIDLE; BOOL ok = BrushSelected(m_BrushHandle, FALSE); // if that didn't work then we won't use a brush if (!ok) m_BrushHandle = BrushHandle_NoBrush; // if we have a brush then default to no smoothness /* if (m_BrushHandle != BrushHandle_NoBrush) Smoothness = 0; else Smoothness = 50; */ m_LastBrushDocument = TEXT("No document"); // Load the cursors if (!LoadCursors()) InformError(); // reset the join path pointer JoinInfo.pJoinPath = NULL; JoinInfo.FirstBrushSpacing = 25; // Find the blob manager ready for later BlobManager* BlobMgr = GetApplication()->GetBlobManager(); // Clear the sub-selection on all the paths in the current selection BOOL IsPathWithSubSelection = FALSE; if (Document::GetSelected() != NULL) { // Get the selection SelRange* Selected = GetApplication()->FindSelection(); Node* pNode = Selected->FindFirst(); while ((pNode!=NULL) && (!IsPathWithSubSelection)) { // clear the sub-selection if this is a path if (pNode->IsNodePath()) { // If this path has a sub-selection, then set the flag if (((NodePath*)pNode)->InkPath.IsSubSelection()) IsPathWithSubSelection = TRUE; } // Now find the next selected node pNode = Selected->FindNext(pNode); } // if there was a sub-selection, then get rid of it if ((IsPathWithSubSelection) && (BlobMgr!=NULL)) { // Get rid of the object blobs while we clear the paths sub-selection BlobStyle ClearBlobs; ClearBlobs.Object = FALSE; BlobMgr->ToolInterest(ClearBlobs); // There are now no object blobs on screen, so we can clear the subselection pNode = Selected->FindFirst(); while (pNode!=NULL) { // clear the sub-selection if this is a path if (pNode->IsNodePath()) ((NodePath*)pNode)->InkPath.ClearSubSelection(); // Now find the next selected node pNode = Selected->FindNext(pNode); } } } // Diccon 9/99 Code copied from Beztool::SelectChange() complete with original comments // 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) 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); } if (IS_A(pNode, NodeBlend)) { NodeBlend* pNodeBlend = (NodeBlend*)pNode; UINT32 NBPCounter = 0; while (pNodeBlend->GetNodeBlendPath(NBPCounter) != NULL) pNodeBlend->GetNodeBlendPath(NBPCounter++)->Select(TRUE); } pNode = SelRng.FindNext(pNode); } // Create and display my info bar please if (pInfoBarOp != NULL) { pInfoBarOp->Create(); pInfoBarOp->SetToolActiveState(TRUE); } // Make sure that Objects blobs are on if (BlobMgr != NULL) { // Decide which blobs to display BlobStyle MyBlobs; MyBlobs.Object = TRUE; // tell the blob manager BlobMgr->ToolInterest(MyBlobs); } // Set the retro field on the info bar if (pInfoBarOp != NULL) { // Find out if we can retro fit and set the field appropriatly BOOL IsStillValid = IsRetroPathStillValid(); pInfoBarOp->SetRetroState(IsStillValid); } } else { // Deselection of the tool // Get rid of all the tools cursors RemoveCursors(); PORTNOTE("other", "Removed m_pGRenderBrush support"); #ifndef EXCLUDE_FROM_XARALX if (m_pGRenderBrush != NULL) { delete m_pGRenderBrush; m_pGRenderBrush = NULL; } #endif // Hide and destroy my info bar please if (pInfoBarOp != NULL) { pInfoBarOp->SetToolActiveState(FALSE); PORTNOTE("other", "Removed brush gadget support"); #ifndef EXCLUDE_FROM_XARALX if (FreeHandInfoBarOp::GetBrushGadget()->IsDialogOpen ()) { FreeHandInfoBarOp::GetBrushGadget()->CloseDialog (); } #endif pInfoBarOp->Delete(); } // ensure that the colour picker is working SetColourEditorProcessing(TRUE); // ensure any tool object blobs are removed. BlobManager* BlobMgr = GetApplication()->GetBlobManager(); if (BlobMgr != NULL) { BlobStyle bsRemoves; bsRemoves.ToolObject = TRUE; BlobMgr->RemoveInterest(bsRemoves); } } }

void FreeHandTool::SetBrushSpacing (  MILLIPOINT  Spacing  )

for setting the freehand tools current brush spacing Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/99 inputs: the spacing value to set Returns: - Definition at line 2209 of file freehand.cpp. { m_BrushSpacing = Spacing; }

BOOL FreeHandTool::SetBrushUpdateState (  UPDATE_STATE  Update  )

Tells us when we should next update the offscreen buffer used by the brush. Often it is wise ot wait until the next idle to update because that gives time for the screen to redraw after the brush combo has closed. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: Update  - when we want the brush to update next upon entering brush selected [INPUTS] UPDATE_NOW: updates immediately UPDATE_ONIDLE: updates on the next idle UPDATE_NEVER: will not update until the flag is changed -  [OUTPUTS] Returns: TRUE if successful, FALSE if Update is invalid Definition at line 2371 of file freehand.cpp. { if (Update < UPDATE_NOW || Update > UPDATE_NEVER) { ERROR3("Invalid update flag"); return FALSE; } m_UpdateBrushState = Update; return TRUE; }

void FreeHandTool::SetColourEditorProcessing (  BOOL  Value  )  [protected]

Tells the colour editor whether or not to do timer processing, we need to turn it off in order to draw a brush stroke. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2790 of file freehand.cpp. { ColourEditDlg* pColourEditor = ColourEditDlg::GetColourEditDlg(); if (pColourEditor != NULL) pColourEditor->SetDoTimerProcessing(Value); }

void FreeHandTool::SetCurrentBrushHandle (   )

Sets the brush handle member to that of the current default brush attribute. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/99 Returns: - Definition at line 1717 of file freehand.cpp. { Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) { ERROR3("No document"); return; } AttributeManager* pAttrMgr = &(pDoc->GetAttributeMgr()); if (pAttrMgr == NULL) { ERROR3("No attribute manager"); return; } AttrBrushType* pAttr = (AttrBrushType*)(pAttrMgr->GetCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), CC_RUNTIME_CLASS(AttrBrushType))); if (pAttr == NULL) { ERROR3("No current brush attribute"); return; } m_BrushHandle = pAttr->GetBrushHandle(); }

void FreeHandTool::SetPreviousPath (  NodePath *  PrevPath, INT32  Start, INT32  Len )

Marks the previously drawn path as valid so that it can be retro fitted. Retro fitting will be allowed until PreviousPathInvalid() is called. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/5/94 Parameters: PrevPath  - The path that has just been added to the tree. ie the one most [INPUTS] recently drawn with the freehand tool Start - The Start slot at which the new section of path begins. Len - The number of slots that the new path section contains. See also: FreeHandTool::PreviousPathInvalid Definition at line 1298 of file freehand.cpp. { // Set all the params associated with the previous path PreviousPath = PrevPath; StartSlot = Start; NumSlots = Len; // Calculate the CRC for the path. PathCRC = BuildPathCRC(PreviousPath); // Set the flags so that we know what is valid and what is not IsPreviousPathValid = TRUE; IsRetroPathValid = FALSE; IsSelectBlobsOnScreen = TRUE; // Tell the info bar to flash up a little indicator that retro fitting is possible if (pInfoBarOp != NULL) pInfoBarOp->SetRetroState(TRUE); // Clear out the retro fit path RetroPath->ClearPath(); }

void FreeHandTool::SetSmoothness (  INT32  Smooth  )

Sets the freehand tools accuracy setting. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Parameters: Smooth  - The new value for the smoothness [INPUTS] Definition at line 1223 of file freehand.cpp. { Smoothness = Smooth; }

void FreeHandTool::TranslateTrackData (   )

If the path in the tree has been translated since it was drawn, we have to translate the original retro fit data to match. This functions checks if a translation is required, and translates all the coords if it is needed. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 15/6/94 Definition at line 1416 of file freehand.cpp. { // if we do not have any track data then stop now if (TrackData==NULL) return; // Get the two coord sections of the paths DocCoord* TrackCoords = TrackData->GetCoordArray(); DocCoord* TreeCoords = PreviousPath->InkPath.GetCoordArray(); // see if the first coord matches if ((TrackCoords[0].x!=TreeCoords[StartSlot].x) || (TrackCoords[0].y!=TreeCoords[StartSlot].y)) { // Nop, so find the offset INT32 Dx = TreeCoords[StartSlot].x - TrackCoords[0].x; INT32 Dy = TreeCoords[StartSlot].y - TrackCoords[0].y; // Loop through all the coords and add on the offset INT32 NumCoords = TrackData->GetNumCoords(); for (INT32 i=0; i<NumCoords; i++) { // Offset the track data TrackCoords[i].x += Dx; TrackCoords[i].y += Dy; } } }

---

Member Data Documentation

BOOL FreeHandTool::AreWeRetroFitting [protected]

Definition at line 296 of file freehand.h.

TCHAR * FreeHandTool::Author = _T("Rik") [static, protected]

Reimplemented from DragTool. Definition at line 276 of file freehand.h.

INT32 FreeHandTool::CurrentCursorID [protected]

Definition at line 306 of file freehand.h.

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

Reimplemented from DragTool. Definition at line 273 of file freehand.h.

BOOL FreeHandTool::FreehandPtrCrosshair = FALSE [static]

Determine whether freehand pointer has crosshairs or not. Preference: FreehandPtrCrosshair Section: Mouse Range: FALSE, TRUE Definition at line 327 of file freehand.h.

BOOL FreeHandTool::IsPreviousPathValid [protected]

Definition at line 297 of file freehand.h.

BOOL FreeHandTool::IsRetroPathValid [protected]

Definition at line 298 of file freehand.h.

BOOL FreeHandTool::IsSelectBlobsOnScreen [protected]

Definition at line 299 of file freehand.h.

FreeHandJoinInfo FreeHandTool::JoinInfo [protected]

Definition at line 309 of file freehand.h.

BOOL FreeHandTool::m_bBrushReady [protected]

Definition at line 321 of file freehand.h.

BrushHandle FreeHandTool::m_BrushHandle [protected]

Definition at line 320 of file freehand.h.

std::vector< NodeRenderableInk * > FreeHandTool::m_BrushInkNodeArray [protected]

Definition at line 314 of file freehand.h.

MILLIPOINT FreeHandTool::m_BrushSpacing [protected]

Definition at line 318 of file freehand.h.

String_256 FreeHandTool::m_LastBrushDocument [protected]

Definition at line 323 of file freehand.h.

UINT32 FreeHandTool::m_NumInkNodes [protected]

Definition at line 319 of file freehand.h.

BlendRef* FreeHandTool::m_pBlendRef [protected]

Definition at line 317 of file freehand.h.

GRenderBrush* FreeHandTool::m_pGRenderBrush [protected]

Definition at line 243 of file freehand.h.

UPDATE_STATE FreeHandTool::m_UpdateBrushState [protected]

Definition at line 248 of file freehand.h.

INT32 FreeHandTool::NumSlots [protected]

Definition at line 293 of file freehand.h.

Cursor* FreeHandTool::pActiveCursor [protected]

Definition at line 304 of file freehand.h.

INT32 FreeHandTool::PathCRC [protected]

Definition at line 294 of file freehand.h.

FreeHandInfoBarOp* FreeHandTool::pInfoBarOp [protected]

Definition at line 312 of file freehand.h.

Cursor* FreeHandTool::pJoinCursor [protected]

Definition at line 303 of file freehand.h.

Cursor* FreeHandTool::pModifyCursor [protected]

Definition at line 305 of file freehand.h.

Cursor* FreeHandTool::pNormalCursor [protected]

Definition at line 302 of file freehand.h.

NodePath* FreeHandTool::PreviousPath [protected]

Definition at line 295 of file freehand.h.

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

Reimplemented from DragTool. Definition at line 275 of file freehand.h.

Path* FreeHandTool::RetroPath [protected]

Definition at line 291 of file freehand.h.

INT32 FreeHandTool::Smoothness [protected]

Definition at line 279 of file freehand.h.

DocCoord FreeHandTool::StartPos [protected]

Definition at line 285 of file freehand.h.

INT32 FreeHandTool::StartSlot [protected]

Definition at line 292 of file freehand.h.

Spread* FreeHandTool::StartSpread [protected]

Definition at line 286 of file freehand.h.

String_256 FreeHandTool::StatusMsg [protected]

Definition at line 282 of file freehand.h.

TCHAR * FreeHandTool::ToolName = _T("Free Hand Tool") [static, protected]

Reimplemented from DragTool. Definition at line 274 of file freehand.h.

Path* FreeHandTool::TrackData [protected]

Definition at line 290 of file freehand.h.

---

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

• tools/freehand.h (r1785/r1282)
• tools/freehand.cpp (r1785/r1750)

---