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