OpDrawBrush Class Reference

Draws a freehand stroke, smooths it and applies a nice brush effect. More...

#include <opdrbrsh.h>

Inheritance diagram for OpDrawBrush:

List of all members.

Public Member Functions
	OpDrawBrush ()
	Constructor.
	OpDrawBrush (FreeHandTool *pTool)
	Constructor. This simply sets a few of the operation flags.
	~OpDrawBrush ()
	destructor.
void	DoDrag (DocCoord Anchor, Spread *, INT32, BrushHandle Handle, FreeHandJoinInfo *pJoinInfo, Path *ToolPath, GRenderBrush *pGRndRgn, ClickModifiers ClickMods)
	Starts up the drag operation by storing all start positions and setting up a Path to store the mouse movement in.
virtual void	DragPointerMove (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL bSolidDrag)
	Handles the event of the mouse moving during a drag.
virtual void	DragPointerIdle (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL bSolidDrag)
	Handles the mouse idle events.
virtual void	DragFinished (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL Success, BOOL bSolidDrag)
	Handles the drag finishing by rubbing out an EOR on the screen and adding the path to the tree and building all the undo that will be needed.
void	RenderDragBlobs (DocRect, Spread *, BOOL bSolidDrag)
	EORs the whole path onto the screen a segment at a time. It needs to do it a segment at a time as that is how it is drawn as the path is created. This has to redraw it identically or there will be bits of EORed stuff left all over the place.
virtual BOOL	IsBrushOp ()
BOOL	SetTimeStamp (double TimeStamp)
	to set the timestamp member
Static Public Member Functions
static BOOL	Declare ()
	Adds the operation to the list of all known operations.
static OpState	GetState (String_256 *Description, OpDescriptor *)
	Find out the state of the operation at the specific time.
static CDistanceSampler *	GeneratePressureData (AttrBrushType *pAttrBrush, MILLIPOINT StartDistance, MILLIPOINT EndDistance, MILLIPOINT NewPathLength)
	This function deals with the case when we wish to edit a brush with pressure data but we do not generate a pressure list during the edit for some reason. In this case we must create a new pressure list and fill it with values based upon the values in the existing brush pressure list.
static MILLIPOINT	GetCurrentLineWidthIfNotDefault ()
	In order to determine whether we have to tell the brush to scale to a new line width or not.
Protected Member Functions
void	ResetMembers ()
	Initialises all our member variables to something sensible.
void	AddPointsToPath (DocCoord Pos, Spread *pSpread)
	Adds a new point to the path of mouse moves. When the drag finishes the mouse moves will be smoothed.
virtual void	SetCursorAndStatus (CursorType CurType)
	Overridden version for the brush, basically we do not offer any of the keyboard options so we wish to keep the status line blank during brush operations.
virtual BOOL	ApplyAttributes (NodePath *NewPath, Document *pDocument)
	Applies the current attributes to the Node passed in. It has to find the current document to do this and will ENSURE if it fails to find one. This overridden version also finds the newly applied brush attribute and gives it the cache of points that we have been recording.
void	RenderStepsForTime (double TimeSlice, Spread *pSpread)
	Renders as many steps in the brush as possible in the time available. The reason for having the code here rather than in the processor is twofold: 1) I feel the property of rendering for a certain timeslice is a property of the Op rather than the PPB; 2) In order to make use of the caching ProcessPathDistance, which belongs to the Op rather than the PPB.
BOOL	InitialisePathProcessorBrush (BrushHandle Handle, MILLIPOINT Distance=0)
	To create a new pathprocessorbrush and copy all the data from the brush definitino found using BrushIndex.
BOOL	InitialiseProcessPathDistance ()
	To create a new path processor object.
BOOL	InitialisePressureCache ()
	To allocate the pressure array, if we need it.
AttrBrushType *	CreateNewAttribute ()
	Adds the operation to the list of all known operations.
virtual BOOL	EditBrushLists (NodePath *pNewPath, INT32 FirstChangedIndex, INT32 NumElements)
	When we are editing a brush that contains either timestamping or pressure data and we are editing using a brush we will have generated our own list of TS or pressure info that we need to insert into the existing list. This fn. manages the insertion of these lists and any others that might arise.
BOOL	EditTimeStampList (NodePath *pNewPath, INT32 FirstChangedIndex, INT32 NumElements)
	When a path is edited that has a timestamping brush applied to it we those points are stored in a list that is generated when the path is drawn. If we subsequently want to edit that path we have to insert or remove points from that list. This function works out what points should be inserted or removed, and performs that action on the applied brush. This is made slightly easier.
BOOL	EditPressureList (NodePath *pNewPath, INT32 FirstChangedIndex, INT32 NumElements)
virtual BOOL	SimpleJoinBrush (NodePath *pNewNodePath, Path *pNewPath)
	Joins a Simple path with the new freehand path and builds all the undo that is needed in the process.
virtual BOOL	ReverseBrushPressure ()
	Calls the attribute function to reverse our pressure list.
BOOL	InitialiseTimeStampList ()
	to create a new timestamp object list and assign it to our member
void	RenderTimeStamp ()
	To be used in timestamp mode, obviously. This fn. determines whether or not enough time has elapsed for us to render a point. If so we render a point and cache it, updating the necessary members.
BOOL	InitialisePressureSampler ()
	to create a new CSampleData object and assign it to our pointer for sampling pressure
BOOL	ApplyRetroSmoother (NodePath *pNodePath, double SmoothAmount)
	Initialises the RetroSmoother object and uses it to smooth the nodepath we have created. The reason for using this smoother rather than the FreeHand smoother is that it does not seem to change the shape of the path in a visible way. It is useful to apply this because otherwise the paths that we draw have too many control points which can obscure the brush objects.
BOOL	RetroSmoothBrush (NodePath *pNewNodePath)
	As above, the base class version does nothing.
Protected Attributes
MILLIPOINT	m_BrushSpacing
MILLIPOINT	m_LastSpacing
MILLIPOINT	m_DistanceSinceLastObject
MILLIPOINT	m_LastDistanceRendered
DocCoord	m_LastPoint
DocCoord	m_StartPoint
DocCoord	m_LastPointRendered
INT32	m_NumBrushObjects
UINT32	m_NumInkObjects
UINT32	m_LastInkObjectRendered
double	m_BrushScaling
GRenderBrush *	m_pGRenderBrush
PathProcessorBrush *	m_pPathProcBrush
BrushDefinition *	m_pBrushDefinition
BOOL	mustClearStatusBar
Application *	pApp
ProcessPathDistance *	m_pProcPathDistance
FreeHandTool *	m_pTool
BOOL	m_bFirstPointRendered
MILLIPOINT	m_FirstSpacing
INT32	m_LastPathIndexRendered
PointsMap *	m_pPointsCache
double	m_TimeStamp
double	m_LastTimeStamp
TimeStampList *	m_pTimeStampList
MonotonicTime	m_Timer
PressureList *	m_pPressureList
CDistanceSampler *	m_pPressureSampler
UINT32	m_NumPressureVals
Private Member Functions
	CC_DECLARE_DYNCREATE (OpDrawBrush)

---

Detailed Description

Draws a freehand stroke, smooths it and applies a nice brush effect.

Author:

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

Date:

2/10/99

Definition at line 139 of file opdrbrsh.h.

---

Constructor & Destructor Documentation

OpDrawBrush::OpDrawBrush (   )

Constructor. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Definition at line 183 of file opdrbrsh.cpp. { ResetMembers(); }

OpDrawBrush::OpDrawBrush (  FreeHandTool *  pTool  )

Constructor. This simply sets a few of the operation flags. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Definition at line 198 of file opdrbrsh.cpp. { ResetMembers(); if (pTool != NULL) m_pTool = pTool; }

OpDrawBrush::~OpDrawBrush (   )

destructor. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Definition at line 216 of file opdrbrsh.cpp. { // if (m_pGRenderBrush != NULL) // delete m_pGRenderBrush; if (m_pProcPathDistance != NULL) delete m_pProcPathDistance; if (m_pPathProcBrush != NULL) delete m_pPathProcBrush; if (m_pPressureList != NULL) delete m_pPressureList; if (m_pPointsCache != NULL) delete m_pPointsCache; if (m_pPressureSampler != NULL) delete m_pPressureSampler; }

---

Member Function Documentation

void OpDrawBrush::AddPointsToPath (  DocCoord  PointerPos, Spread *  pSpread )  [protected]

Adds a new point to the path of mouse moves. When the drag finishes the mouse moves will be smoothed. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/10/99 Parameters: Pos  - The position of the mouse [INPUTS] pSpread - Pointer to the spread that we are drawing on Reimplemented from OpFreeHand. Definition at line 1932 of file opdrbrsh.cpp. { // If this coord is the same as the last one, then do not bother adding to the track data if (PreviousPoint == PointerPos) return; // Insert the move if (TrackData->InsertLineTo(PointerPos)) { // and add pressure info if needed if (AddPressureToPath) { TrackData->AddExtraInfo(CI_PRESSURE, FreeHandPressure); } } else { // Oh no, we ran out of mem in the middle of making a new path // Tidy up and report back to HQ EndDrag(); // Tell the World that it all went horribly wrong InformError(); // Remove it from the tree and delete it TrackData->ClearPath(); // End this operation and return FailAndExecute(); End(); return; } // RenderLine(m_pGRenderBrush, TrackData, TrackData->GetNumCoords()-1); // Make a note of the coord, inc the line count and mark joining to the start as active. PreviousPoint = PointerPos; LineSegmentCount++; CanLineJoin = TRUE; }

BOOL OpDrawBrush::ApplyAttributes (  NodePath *  pNewPath, Document *  pDocument )  [protected, virtual]

Applies the current attributes to the Node passed in. It has to find the current document to do this and will ENSURE if it fails to find one. This overridden version also finds the newly applied brush attribute and gives it the cache of points that we have been recording. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/1/2000 Parameters: NewPath  - The NodePath to apply the current attributes to [INPUTS] pDocument - the document this path will be placed into. Returns: TRUE if it worked, FALSE if it did not This fn. has changed slightly as we now have to comply with the "most recently applied attributes" option. In order to do this both the line width and the brush attribute have to be applied via the attribute manager. Andy Hills, 18-09-00 Note - I have temporarily reverted this function to the 24-08-00 version. This fixes the problem where, if the above-mentioned option is disabled, an access violation occurs. Reimplemented from OpFreeHand. Definition at line 1084 of file opdrbrsh.cpp. { ERROR2IF(pNewPath == NULL, FALSE, "pNewNodePath is NULL in OpDrawBrush::ApplyAttributes"); ERROR2IF(pDocument == NULL, FALSE, "pDocument is NULL in OpDrawBrush::ApplyAttributes"); //ApplyRetroSmoother(pNewPath, 50); // Find the current document to get the current attributes from ENSURE(pDocument!=NULL, "Null Document while setting attributes for new NodePath"); if (pDocument!=NULL) { // we make out own attributes here AttrBrushType* pNewAttr = CreateNewAttribute(); if (pNewAttr == NULL) return FALSE; #ifdef NEWFASTBRUSHES BrushAttrValue* pAttrVal = (BrushAttrValue*) pNewAttr->GetAttributeValue(); pAttrVal->SetBoundsParent (pNewPath); #endif // now make the line the correct width, if someone has selected a line width then we will make it // that size, otherwise we will use the default provided by the brush MILLIPOINT LineWidth = GetCurrentLineWidthIfNotDefault(); if (LineWidth == -1) LineWidth = pNewAttr->GetDefaultLineWidth(!AddPressureToPath); // Apply the current attributes to the path, changing the line width if necessary if (!pDocument->GetAttributeMgr().ApplyCurrentAttribsToNode((NodeRenderableInk*)pNewPath)) ERROR3("Failed to apply current attributes in OpDrawBrush::ApplyAttributes"); // change the line width value AttrLineWidth* pLineWidth = (AttrLineWidth*)pNewPath->FindFirstChild(CC_RUNTIME_CLASS(AttrLineWidth)); if (pLineWidth != NULL) pLineWidth->Value.LineWidth = LineWidth; else ERROR3("Unable to find line width in OpDrawBrush::ApplyAttributes"); // if the document inserted a brush then get rid of it Node* pDocBrush = pNewPath->FindFirstChild(CC_RUNTIME_CLASS(AttrBrushType)); if (pDocBrush) { pDocBrush->CascadeDelete(); delete pDocBrush; pDocBrush = NULL; } // apply our brush attribute here, in case the document already applied a default pNewPath->ApplyAttributeToObject(pNewAttr, FALSE); // tell it about the freehand tool pNewAttr->SetFreeHandTool(m_pTool); if (pNewAttr->GetBrushHandle() != BrushHandle_NoBrush) { #ifdef OPBRUSHPOINTSCACHE if (m_TimeStamp <= 0) pNewAttr->SetCache(m_pPointsCache); // make sure we don't try to use the cache, the attribute is now responsible for // deleting it m_pPointsCache = NULL; #endif BrushAttrValue* pVal = (BrushAttrValue*)pNewAttr->GetAttributeValue(); // if we're timestamping then set the timestamp cache instead if (m_TimeStamp > 0) { if (pVal != NULL) { pVal->SetTimeStampList(m_pTimeStampList); pVal->CalculateProportionalDistances((MILLIPOINT)pNewPath->InkPath.GetPathLength()); } } // add the pressure cache, if we need to if (AddPressureToPath) { //m_pPressureVals->SetSize(m_NumPressureVals, 1); //m_pPressureVals->FreeExtra(); m_pPressureSampler->FinishSampling(); m_pPressureSampler->FreeExtra(); pNewAttr->SetPressureCache(m_pPressureSampler); // set our pointer to null so we don't end up deleting it m_pPressureSampler = NULL; // ask the attribute to calculate the proportional distances //if (pVal != NULL) // pVal->CalculatePressureArrayProportions((MILLIPOINT)pNewPath->InkPath.GetPathLength()); } } return TRUE; } // We failed to apply the attributes, so fail return FALSE; }

BOOL OpDrawBrush::ApplyRetroSmoother (  NodePath *  pNodePath, double  SmoothAmount )  [protected]

Initialises the RetroSmoother object and uses it to smooth the nodepath we have created. The reason for using this smoother rather than the FreeHand smoother is that it does not seem to change the shape of the path in a visible way. It is useful to apply this because otherwise the paths that we draw have too many control points which can obscure the brush objects. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 31/1/2000 Parameters: NewPath  - The NodePath that we have created [INPUTS] SmoothAmount - the amount that we wish to smooth (0 -100) Returns: TRUE if it worked, FALSE if it did not Definition at line 1201 of file opdrbrsh.cpp. { ERROR2IF(pNodePath == NULL, FALSE, "NodePath is NULL in OpDrawBrush::ApplyRetroSmoother"); // make a smoothing object RetroSmooth Smoother; if (!Smoother.Initialise()) return FALSE; // tell the smoother we don't want EOR rendering Smoother.SetRenderFlag(FALSE); // we need to set all our path elements selected for the smoother pNodePath->InkPath.SetAllSubSelection(); // we need the spread for the smoothing operation Spread* pSpread = Document::GetSelectedSpread(); if (pSpread == NULL) { ERROR3("Spread is NULL in OpDrawBrush::ApplyRetroSmoother"); return FALSE; } Smoother.Changing(pNodePath, pSpread, SmoothAmount); Smoother.FinishedNoUndo(pNodePath); // unselect our path elements pNodePath->InkPath.ClearSubSelection(); return TRUE; }

OpDrawBrush::CC_DECLARE_DYNCREATE (  OpDrawBrush   )  [private]

AttrBrushType * OpDrawBrush::CreateNewAttribute (   )  [protected]

Adds the operation to the list of all known operations. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: TRUE if all went OK, False otherwise Definition at line 1247 of file opdrbrsh.cpp. { AttrBrushType* pNewAttr = new AttrBrushType; if (pNewAttr == NULL) { ERROR3("Couldn't make attribute node"); return NULL; } BrushAttrValue* pVal = (BrushAttrValue*)pNewAttr->GetAttributeValue(); if (pVal == NULL) { ERROR3("No attribute value"); return NULL; } if (m_pPathProcBrush == NULL) { ERROR3("Path Processor Brush is NULL already"); return NULL; } pVal->SetPathProcessor(m_pPathProcBrush); m_pPathProcBrush->SetParentAttribute(pNewAttr); // make sure our processor has all the correct data Document* pDoc = Document::GetCurrent(); ERROR2IF(pDoc == NULL, pNewAttr, "No document in OpDrawBrush::CreateNewAttribute"); BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent)); ERROR2IF(pBrushComp == NULL, pNewAttr, "No brush component in OpDrawBrush::CreateNewAttribute"); BrushDefinition* pBrushDef = pBrushComp->FindBrushDefinition(m_pPathProcBrush->GetBrushDefinitionHandle()); ERROR2IF(pBrushDef == NULL, pNewAttr, "Unable to retrieve brush definition, invalid handle"); // copy the data from the definition pBrushDef->CopyDataToProcessor(m_pPathProcBrush); // scale to the appropriate line width (or not) MILLIPOINT LineWidth = GetCurrentLineWidthIfNotDefault(); if (LineWidth != -1) { m_pPathProcBrush->ScaleToValue(LineWidth, !AddPressureToPath); } else { MILLIPOINT Size = pBrushDef->GetDefaultLineWidth(!AddPressureToPath); m_pPathProcBrush->ScaleToValue(Size, !AddPressureToPath); } // make sure we don't delete it now m_pPathProcBrush = NULL; return pNewAttr; }

BOOL OpDrawBrush::Declare (   )  [static]

Adds the operation to the list of all known operations. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Returns: TRUE if all went OK, False otherwise Reimplemented from OpFreeHand. Definition at line 1882 of file opdrbrsh.cpp. { return (RegisterOpDescriptor( 0, _R(IDS_FREE_HAND_TOOL), CC_RUNTIME_CLASS(OpDrawBrush), OPTOKEN_DRAWBRUSH, OpDrawBrush::GetState, 0, /* help ID */ _R(IDBBL_FREEHANDTOOLOP), 0 /* bitmap ID */)); }

void OpDrawBrush::DoDrag (  DocCoord  Anchor, Spread *  pSpread, INT32  Smooth, BrushHandle  Handle, FreeHandJoinInfo *  pFreeHandInfo, Path *  ToolPath, GRenderBrush *  pGRndRgn, ClickModifiers  ClickMods )

Starts up the drag operation by storing all start positions and setting up a Path to store the mouse movement in. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Anchor  - The position of the mouse at the start of the Drag [INPUTS] pSpread - The spread that the drag started on Smooth - Closeness of fit value Handle - the handle of the brush we want to use pFreeHandInfo - Pointer to the info about the Joining set up by the freehand tool ToolPath - The path to store the mouse tracking info in pGRndBMP - pointer to the big bitmap used to store the view Definition at line 329 of file opdrbrsh.cpp. { TRACEUSER( "Diccon", _T("Drag started\n")); if (pSpread == NULL) { ERROR3("No spread"); FailAndExecute(); End(); return; } if (ToolPath == NULL) { ERROR3("Tool path is NULL"); FailAndExecute(); End(); return; } // WEBSTER - markn 25/4/97 // No pen stuff required in Webster // Taken out by vector stroking code Neville 2/10/97 #ifdef VECTOR_STROKING // Tell the pressure pen that we're starting a new stroke CCPen *pPen = pApp->GetPressurePen(); if (pPen != NULL) pPen->StartStroke(); #endif // VECTOR_STROKING // Snap the starting coord if we are not joining to something else if ((pFreeHandInfo==NULL) || (pFreeHandInfo->pJoinPath==NULL)) DocView::SnapCurrent(pSpread, &Anchor, FALSE, TRUE); // Make a note of various starting conditions TrackData = ToolPath; Smoothness = Smooth; pJoinInfo = pFreeHandInfo; StartPath = pJoinInfo->pJoinPath; EndPath = NULL; // Make a mental note of the start point StartPoint = Anchor; StartSpread = pSpread; PreviousSpread= pSpread; PreviousPoint = Anchor; LineSegmentCount = 0; IsStraightLineMode = FALSE; CanLineJoin = FALSE; // Prepare the Track data path and add in the initial click point to the path if (!PrepareTrackDataPath()) { // We failed to get the memory to initialise the track data InformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK)); FailAndExecute(); End(); return; } // Create some cursors that I might need if (!LoadCursors()) { // The cursors did not load, so fail? FailAndExecute(); End(); return; } // Push my new cursor onto the stack CurrentCursorID = CursorStack::GPush(pFreeHandCursor, TRUE); MyCurrentCursor = pFreeHandCursor; // Diccon new brush stuff TRACEUSER( "Diccon", _T("DRAG STARTED\n")); if (pGRndRgn == NULL) { ERROR3("No GRenderBrush"); FailAndExecute(); End(); return; } else m_pGRenderBrush = pGRndRgn; // if we are joining a brush then make sure we know that handle if (pFreeHandInfo->m_BrushHandle != BrushHandle_NoBrush) Handle = pFreeHandInfo->m_BrushHandle; if (!InitialisePathProcessorBrush(Handle, pFreeHandInfo->BrushDistance)) { FailAndExecute(); End(); return; } // if out freehand info indicates that we are joining to an existing brush then // copy out the data from that brush if (pFreeHandInfo->m_BrushHandle != BrushHandle_NoBrush && pFreeHandInfo->pAttrBrush != NULL) { // MILLIPOINT Spacing = 0; m_pPathProcBrush->GetSpacingAndScalingAtDistance(pFreeHandInfo->BrushDistance, &m_FirstSpacing, &m_BrushScaling); m_pPathProcBrush->CopyDataFromObject(&(pFreeHandInfo->m_BrushData)); m_LastSpacing = m_pPathProcBrush->GetSpacing(); // set the scaling, this can vary as we may be adding to a line // of any width m_BrushScaling = pFreeHandInfo->m_BrushData.m_BrushScaling; m_pPathProcBrush->AdvanceBrushToDistance(pFreeHandInfo->BrushDistance); m_LastInkObjectRendered = m_pPathProcBrush->GetLastObject(); // if we're overriding colours then tell the ppb what colour to use m_pPathProcBrush->SetUseLocalFillColour(pFreeHandInfo->UseLocalColour); m_pPathProcBrush->SetUseNamedColours(pFreeHandInfo->UseNamedColour); if (pFreeHandInfo->UseLocalColour || !pFreeHandInfo->UseNamedColour) m_pPathProcBrush->SetStrokeColour(pFreeHandInfo->StrokeColour); // m_FirstSpacing = m_pPathProcBrush->GetLastSpacing() - pFreeHandInfo->FirstBrushSpacing; // TRACEUSER( "Diccon", _T("JOINING EXISTING BRUSH\n")); } if (!InitialiseProcessPathDistance()) { FailAndExecute(); End(); return; } if (!InitialisePressureSampler()) { FailAndExecute(); End(); return; } if (AddPressureToPath == TRUE) { // TRACEUSER( "Diccon", _T("Pressure = %d\n"), ClickMods.Pressure); // m_pPressureSampler->CollectData(Anchor, ClickMods.Pressure); //?? not sure this is right } if (m_pPathProcBrush != NULL) { m_NumInkObjects = m_pPathProcBrush->GetNumBrushObjects(); m_BrushSpacing = m_pPathProcBrush->GetSpacing(); m_pPathProcBrush->SetParentAttribute(pFreeHandInfo->pAttrBrush); } else { FailAndExecute(); End(); return; } if (m_NumInkObjects < 1) { ERROR3("No brush ink objects"); FailAndExecute(); End(); return; } // if we are not timestamping then we want a regular point-at-distance map to // use as a cache, so long as we are not joining an existing brush #ifdef OPBRUSHPOINTSCACHE if (m_TimeStamp <= 0 && pFreeHandInfo->m_BrushHandle == BrushHandle_NoBrush) { // allocate the map for caching m_pPointsCache = new PointsMap; //m_pPointsList = new List; // not a disaster if we don't get it // if (m_pPointsCache != NULL) // m_pPointsCache->InitHashTable(1277); // else // ERROR3("Failed to allocate cache"); } #endif // if we are timestamping then we want a list if (m_TimeStamp > 0) { if (!InitialiseTimeStampList()) { // can't do anything if we don't get our cache FailAndExecute(); End(); return; } } // initialise needs to have correct start point m_StartPoint = Anchor; // set up the member variables m_LastPoint = Anchor; m_LastPointRendered = Anchor; m_LastDistanceRendered = 0; m_DistanceSinceLastObject = 0; m_LastSpacing = m_BrushSpacing; m_NumBrushObjects = 0; AddPointsToPath(Anchor, pSpread); m_bFirstPointRendered = FALSE; StartDrag( DRAGTYPE_NOSCROLL ); // TRACEUSER( "Diccon", _T("Drag initialised")); PORTNOTE("other", "Removed m_pRenderGBrush"); #ifndef EXCLUDE_FROM_XARALX //#ifdef NEWFASTBRUSHES View* pView = View::GetCurrent(); CCamView* pCCamView = pView->GetConnectionToOilView(); CDC* pDevContext = pCCamView->GetRenderDC(); HDC DeviceHdc = pDevContext->GetSafeHdc(); m_pGRenderBrush->SetView (pView); m_pGRenderBrush->SetCamView (pView->GetConnectionToOilView()); m_pGRenderBrush->SetCDC (pCCamView->GetRenderDC()); m_pGRenderBrush->SetHDC (pDevContext->GetSafeHdc()); //#endif #endif }

void OpDrawBrush::DragFinished (  DocCoord  PointerPos, ClickModifiers  ClickMods, Spread *  pSpread, BOOL  Success, BOOL  bSolidDrag )  [virtual]

Handles the drag finishing by rubbing out an EOR on the screen and adding the path to the tree and building all the undo that will be needed. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/10/99 Parameters: PointerPos  - The position of the mouse at the end of the drag [INPUTS] ClickMods - the key modifiers being pressed pSpread - The spread that the drag finished on Success - TRUE if the drag was terminated properly, FALSE if it was ended with the escape key being pressed See also: ClickModifiers Reimplemented from OpFreeHand. Definition at line 966 of file opdrbrsh.cpp. { TRACEUSER( "Diccon", _T("Drag finished\n")); // Erase the whole EORed line DocRect ClipRect(0,0,0,0); RenderDragBlobs(ClipRect, StartSpread, bSolidDrag); // Get rid of all the cursors RemoveCursors(); // Put the hour glass up as we have to and end the drag //BeginSlowJob(); String_32 ProgString = _T("Calculating brush, please wait.."); Progress Hourglass(&ProgString, -1, FALSE); EndDrag(); // Add the new path to the tree if it was valid BOOL Worked = FALSE; if (Success) { // were we in the middle of drawing a straight line if (IsStraightLineMode) { // we were so add it in to the track data AddStraightLine(); PreviousPoint = StraightLinePos; IsStraightLineMode = FALSE; } BeginSlowJob(-1, TRUE, NULL); // invalidate the rect that we calculated (this may be different to the bounding // rect of the node due to smoothing) DocRect BRect = m_pPathProcBrush->GetCachedRect(); // Get rid of cached bitmaps here! Node* pANode = NULL; if (m_pPathProcBrush->GetParentAttribute()) { pANode = m_pPathProcBrush->GetParentAttribute()->FindParent(); if (pANode->IsBounded()) { ((NodeRenderableBounded*)pANode)->ReleaseCached(); } } DoInvalidateRegion(pSpread, BRect); // clean up some memory we used m_pPathProcBrush->CleanUpAfterRender(); BrushDefinition* pDef = BrushComponent::FindBrushDefinition(m_pPathProcBrush->GetBrushDefinitionHandle()); if (pDef) pDef->StopRender(); else ERROR3("Unable to get brush definition in OpDrawBrush::DragFinished"); // try and smooth the path and insert it into the tree Worked = CompleteOperation(); EndSlowJob(); } // WEBSTER - markn 25/4/97 // No pen stuff required in Webster // Taken out by vector stroking code Neville 2/10/97 #ifdef VECTOR_STROKING // Inform the pressure pen that we've finished the stroke CCPen *pPen = pApp->GetPressurePen(); if (pPen != NULL) pPen->EndStroke(); #endif // VECTOR_STROKING if (m_pTool != NULL) m_pTool->BrushFinished(); // point the pointer away from the render region (the tool still needs it so we don't delete) m_pGRenderBrush = NULL; // If the operation failed, then tidy up if (Worked==FALSE) FailAndExecute(); else { // Update all the parents of the effected paths. ObjChangeFlags cFlags; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this); ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL,this); UpdateChangedNodes(&ObjChange); } // End the operation properly End(); }

void OpDrawBrush::DragPointerIdle (  DocCoord  PointerPos, ClickModifiers  ClickMods, Spread *  pSpread, BOOL  bSolidDrag )  [virtual]

Handles the mouse idle events. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/10/99 Parameters: PointerPos  - The current position of the mouse in Doc Coords [INPUTS] ClickMods - Which key modifiers are being pressed pSpread - The spread that the mouse is moving over See also: ClickModifiers Reimplemented from OpFreeHand. Definition at line 678 of file opdrbrsh.cpp. { BOOL bAllowRender = TRUE; // --- If the quality is set low enough, strokes are just rendered as centrelines // "low enough" is defined as the same point that Blends show their middle parts // BLOCK { PORTNOTE("other", "Removed m_pRenderGBrush"); #ifndef EXCLUDE_FROM_XARALX if(m_pGRenderBrush != NULL) { QualityAttribute *pQuality = (QualityAttribute *) m_pGRenderBrush->GetCurrentAttribute(ATTR_QUALITY); if (pQuality != NULL && pQuality->QualityValue.GetBlendQuality() != Quality::FullBlend) { bAllowRender = FALSE; // return; } } #endif } // because we are throwing away the first few pressure values we want to make sure we have // got enough before we render here if (AddPressureToPath) { if (m_NumPressureVals > PressureValsThreshold && bAllowRender) RenderStepsForTime(75, pSpread); // 75 is the time to render for in ms, as determined by trial and error } else { if(bAllowRender) RenderStepsForTime(75, pSpread); } //TRACEUSER( "Diccon", _T("Drag pointer idle\n")); }

void OpDrawBrush::DragPointerMove (  DocCoord  PointerPos, ClickModifiers  ClickMods, Spread *  pSpread, BOOL  bSolidDrag )  [virtual]

Handles the event of the mouse moving during a drag. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/10/99 Parameters: PointerPos  - The current position of the mouse in Doc Coords [INPUTS] ClickMods - Which key modifiers are being pressed pSpread - The spread that the mouse is moving over See also: ClickModifiers Reimplemented from OpFreeHand. Definition at line 572 of file opdrbrsh.cpp. { // Lets whip out the current pressure value if (AddPressureToPath) FreeHandPressure = ClickMods.Pressure; // If drag has moved onto a different spread, convert the coord to be relative to the // original spread. if (pSpread != StartSpread) #ifdef NEWFASTBRUSHES PointerPos = MakeRelativeToSpreadNoOverhead(StartSpread, pSpread, PointerPos); // min variable allocation overhead version #else PointerPos = MakeRelativeToSpread(StartSpread, pSpread, PointerPos); // min variable allocation overhead version #endif // I'm not allowing rubbing out or straightlines whilst drawing a brush ClickMods.Alternative1 = FALSE; ClickMods.Adjust = FALSE; // Change the Cursor to display the appropriate thing. SetCursorOnMove(ClickMods, StartSpread, &PointerPos); AddPointsToPath(PointerPos, StartSpread); // Set the last spread to something appropriate PreviousSpread = pSpread; // brush specific code double Distance = (PointerPos.Distance(m_LastPoint)); m_DistanceSinceLastObject += (MILLIPOINT)Distance; // cache the point for this brush object m_LastPoint = PointerPos; // pass the data to our pressure sampler if (m_pPressureSampler != NULL) { m_NumPressureVals++; if (m_NumPressureVals > PressureValsThreshold) { TRACEUSER( "Diccon", _T("Pressure = %d\n"), ClickMods.Pressure); if (!m_pPressureSampler->CollectData(PointerPos, FreeHandPressure)) { ERROR3("Error in Pressure sampler, aborting.."); FailAndExecute(); End(); return; } } else return; } // --- If the quality is set low enough, strokes are just rendered as centrelines // "low enough" is defined as the same point that Blends show their middle parts // BLOCK { PORTNOTE("other", "Removed m_pRenderGBrush"); #ifndef EXCLUDE_FROM_XARALX if(m_pGRenderBrush != NULL) { QualityAttribute *pQuality = (QualityAttribute *) m_pGRenderBrush->GetCurrentAttribute(ATTR_QUALITY); if (pQuality != NULL && pQuality->QualityValue.GetBlendQuality() != Quality::FullBlend) { RenderRegion* pRegion = DocView::RenderOnTop(NULL, pSpread, UnclippedEOR ); while ( pRegion ) { RenderLine(pRegion, TrackData, TrackData->GetNumCoords()-1, FALSE); // get the next region to draw in pRegion = DocView::GetNextOnTop(NULL); } return<