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; } } #endif } // if (pJoinInfo->BrushHandle != BrushHandle_NoBrush) // RenderLine(m_pGRenderBrush, TrackData, TrackData->GetNumCoords()-1); // Render brush objects for the specified period RenderStepsForTime(50, pSpread); // if we are editing then render the path too /* if (pJoinInfo->BrushHandle != BrushHandle_NoBrush) { RenderLine(NULL, pSpread, TrackData, TrackData->GetNumCoords() - 1); RenderLine(m_pGRenderBrush, TrackData, TrackData->GetNumCoords()-1); }*/ }

BOOL OpDrawBrush::EditBrushLists (  NodePath *  pNewPath, INT32  FirstChangedIndex, INT32  NumElements )  [protected, virtual]

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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 19/3/2000 Parameters: pNewPath  - The New curve that has just been draw [INPUTS] FirstChangedIndex - The first coord in the path that is to be replaced NumElements - The number of elements in the path that need replacing Returns: TRUE if it worked, FALSE if not Reimplemented from OpFreeHand. Definition at line 1321 of file opdrbrsh.cpp. { ERROR2IF(pNewPath == NULL, FALSE, "pNewPath is NULL in OpDrawBrush::EditBrushLists"); BOOL ok = TRUE; // if we have a timestamp list then attempt to insert it if (m_pTimeStampList != NULL) ok = EditTimeStampList(pNewPath, FirstChangedIndex, NumElements); // edit the pressure list (if there is one) if (ok) ok = EditPressureList(pNewPath, FirstChangedIndex, NumElements); return ok; }

BOOL OpDrawBrush::EditPressureList (  NodePath *  pNewPath, INT32  FirstChangedIndex, INT32  NumElements )  [protected]

Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 19/3/2000 Parameters: pNewPath  - The New curve that has just been draw [INPUTS] FirstChangedIndex - The first coord in the path that is to be replaced NumElements - The number of elements in the path that need replacing Returns: TRUE if it worked, FALSE if not Definition at line 1455 of file opdrbrsh.cpp. { ERROR2IF(pNewPath == NULL, FALSE, "pNewPath is NULL in OpDrawBrush::EditPressureList"); /* First up, find the nearest applied brush attribute. If there isn't one or it has no pressure list then we don't have to bother with all this */ AttrBrushType* pAttrBrush = NULL; pAttrBrush = EndPath->GetAppliedBrushAttribute(); if (pAttrBrush == NULL) return TRUE; // if we are attempting to edit an existing brush that does not have an existing pressure // cache then leave now if (!pAttrBrush->ContainsPressureCache()) return TRUE; // most of the action takes place in the attribute value so get that also BrushAttrValue* pVal = (BrushAttrValue*)pAttrBrush->GetAttributeValue(); if (pVal == NULL) return TRUE; /* next, record the following distances: - original path length; - distance to first changed point; - distance to last changed point; */ // double OriginalLength = EndPath->InkPath.GetPathLength(); MILLIPOINT DistToFirstPoint = -1; MILLIPOINT DistToLastPoint = -1; DocCoord* pCoords = EndPath->InkPath.GetCoordArray(); DocCoord FirstChangedPoint; DocCoord LastChangedPoint; if (pCoords == NULL) return FALSE; if (FirstChangedIndex + NumElements > EndPath->InkPath.GetNumCoords()) { ERROR3("Illegal number of coordinates"); return FALSE; } // get the coordinates from the array FirstChangedPoint = pCoords[FirstChangedIndex]; LastChangedPoint = pCoords[FirstChangedIndex + NumElements]; EndPath->InkPath.GetDistanceToPoint(FirstChangedPoint, &DistToFirstPoint); EndPath->InkPath.GetDistanceToPoint(LastChangedPoint, &DistToLastPoint); // Now find the indices into the pressure list that correspond to those distances INT32 StartPressureIndex = pVal->GetPressureListIndexAtDistance(DistToFirstPoint); if (StartPressureIndex == -1) { ERROR3("StartPressureIndex is -1 in OpDrawBrush::EditPressureList"); return FALSE; } INT32 EndPressureIndex = pVal->GetPressureListIndexAtDistance(DistToLastPoint); if (EndPressureIndex == -1 || EndPressureIndex <= StartPressureIndex) { ERROR3("EndPressureIndex is invalid in OpDrawBrush::EditPressureList"); return FALSE; } UINT32 NumObjects = EndPressureIndex - StartPressureIndex; // MILLIPOINT Spacing = pAttrBrush->GetSpacing(); UINT32 NumIndexes = 0; //Spacing / MIN_BRUSH_SPACING; StartPressureIndex -= NumIndexes; if (StartPressureIndex < 0) StartPressureIndex = 0; // if (m_pPressureList == NULL) // m_pPressureList = GeneratePressureList(pAttrBrush, StartPressureIndex, EndPressureIndex, // (MILLIPOINT)pNewPath->InkPath.GetPathLength()); // if (m_pPressureList == NULL) // did it fail, of so we must quit // return FALSE; /* now get the pressure points list and ask the attribute to clear all the points between the edited distances*/ pAttrBrush->ClearCachedRect(); DocRect Rect = pAttrBrush->GetAttrBoundingRect(EndPath); Spread* pSpread = Document::GetSelectedSpread(); if (!DoInvalidateRegion(pSpread, Rect)) return FALSE; // Invalidate it as it was if (!DoInvalidateNodeRegion(EndPath, TRUE)) return FALSE; // now make a removepoints action RemovePressurePointsAction* pAction; if (m_pPressureSampler) { // only remove items if m_pPressureSampler is non-NULL! if (RemovePressurePointsAction::Init(this, &UndoActions, pAttrBrush, (UINT32)StartPressureIndex, NumObjects, NULL, &pAction) == AC_FAIL) return FALSE; } // now insert our new points into the attribute AddPressurePointsAction* pAddAction; if (m_pPressureSampler) { // find out how many points we're inserting UINT32 NumAddPoints = m_pPressureSampler->GetNumItems(); if (AddPressurePointsAction::Init(this, &UndoActions, pAttrBrush, m_pPressureSampler, (UINT32)StartPressureIndex, NumAddPoints, &pAddAction) == AC_FAIL) return FALSE; } else { // YUCK, this means that somebodies trying to 'glue' a non-pressure sensititive path in with the pressure // sensitive one .... // I think the most sensible thing to do is just to leave current pressure data intact. Otherwise we get // bogged down in bodging default pressure values (which might not be what the user wants/go wrong), and trouble // with undo/redo by replacing these values on the fly. } m_pPressureSampler = NULL; // otherwise we end up deleting it whilst we still need it // invalidate the whole thing pAttrBrush->ClearCachedRect(); Rect = pAttrBrush->GetAttrBoundingRect(EndPath); EndPath->ReleaseCached(); if (!DoInvalidateRegion(pSpread, Rect)) return FALSE; return TRUE; }

BOOL OpDrawBrush::EditTimeStampList (  NodePath *  pNewPath, INT32  FirstChangedIndex, INT32  NumElements )  [protected]

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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 19/3/2000 Parameters: pNewPath  - The New curve that has just been draw [INPUTS] FirstChangedIndex - The first coord in the path that is to be replaced NumElements - The number of elements in the path that need replacing Returns: TRUE if it worked, FALSE if not Definition at line 1356 of file opdrbrsh.cpp. { ERROR2IF(pNewPath == NULL, FALSE, "pNewPath is NULL in OpDrawBrush::EditTimeStampingBrush"); // if we're not timestamping then just return now if (m_pTimeStampList == NULL) return TRUE; /* First up, find the nearest applied brush attribute. If there isn't one or it is not timestamping then we don't have to bother with all this */ AttrBrushType* pAttrBrush = NULL; pAttrBrush = EndPath->GetAppliedBrushAttribute(); if (pAttrBrush == NULL) return TRUE; // if we are attempting to edit an existing brush that does not use the timestamping // system then also give up if (!pAttrBrush->IsTimeStamping()) return TRUE; // most of the action takes place in the attribute value so get that also BrushAttrValue* pVal = (BrushAttrValue*)pAttrBrush->GetAttributeValue(); if (pVal == NULL) return TRUE; /* next, record the following distances: - original path length; - distance to first changed point; - distance to last changed point; */ // double OriginalLength = EndPath->InkPath.GetPathLength(); MILLIPOINT DistToFirstPoint = -1; MILLIPOINT DistToLastPoint = -1; DocCoord* pCoords = EndPath->InkPath.GetCoordArray(); DocCoord FirstChangedPoint; DocCoord LastChangedPoint; if (pCoords == NULL) return FALSE; if (FirstChangedIndex + NumElements > EndPath->InkPath.GetNumCoords()) { ERROR3("Illegal number of coordinates"); return FALSE; } // get the coordinates from the array FirstChangedPoint = pCoords[FirstChangedIndex]; LastChangedPoint = pCoords[FirstChangedIndex + NumElements]; EndPath->InkPath.GetDistanceToPoint(FirstChangedPoint, &DistToFirstPoint); EndPath->InkPath.GetDistanceToPoint(LastChangedPoint, &DistToLastPoint); /* now get the timestamping points list and ask the attribute to clear all the points between the edited distances*/ // first make a removepoints action RemoveTimeStampPointsAction* pAction; if (RemoveTimeStampPointsAction::Init(this, &UndoActions, pAttrBrush, DistToFirstPoint, DistToLastPoint, NULL, &pAction) == AC_FAIL) return FALSE; // now insert our new points into the attribute AddTimeStampPointsAction* pAddAction; // find out the distance of the new points to be inserted TimeStampBrushPoint StartPoint = m_pTimeStampList->front(); TimeStampBrushPoint EndPoint = m_pTimeStampList->back(); INT32 NewPointsDistance = EndPoint.m_Distance - StartPoint.m_Distance; if (AddTimeStampPointsAction::Init(this, &UndoActions, pAttrBrush, m_pTimeStampList, DistToFirstPoint, DistToFirstPoint + NewPointsDistance, 0, &pAddAction) == AC_FAIL) return FALSE; // invalidate the whole thing3 if (!DoInvalidateNodeRegion(EndPath, TRUE)) return FALSE; return TRUE; }

CDistanceSampler * OpDrawBrush::GeneratePressureData (  AttrBrushType *  pAttrBrush, MILLIPOINT  Start, MILLIPOINT  End, MILLIPOINT  NewPathLength )  [static]

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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/3/2000 Parameters: pAttrBrush  - the brush that we are joining to [INPUTS] Start - the distance along the original path where we want to start the insert, set this to -1 to indicate we are inserting at the beginning of the path End - the distance along the original path where we wish to end the insert, set this to -1 to indicate that we are inserting at the end of the path NewPathLength - the length of the path that we wish to insert Returns: a newly generated pressure sampler, complete with values (or NULL if we fail) Definition at line 1777 of file opdrbrsh.cpp. { if (pAttrBrush == NULL) { ERROR3("Entry pointer is NULL in OpDrawBrush::GeneratePressureList"); return NULL; } if (NewPathLength < 0 ) { ERROR3("Negative path length in OpDrawBrush::GeneratePressureList"); return NULL; } // just make sure we actually have a pressure list CDistanceSampler* pSampler = pAttrBrush->GetPressureCache(); if (pSampler == NULL) { ERROR3("Why are you trying to do a pressure edit when this brush doesn't use pressure!??"); return NULL; } /* there are two possibilities here: 1) we are inserting in the middle, in which case get the two insert values and interpolate, or 2) we are inserting at the beginning or end, in which case just repeat the first/last value */ // get the pressure values at StartIndex and EndIndex INT32 StartIndex = -1; INT32 EndIndex = -1; // case 1 if (Start != -1 && End != -1) { StartIndex = pSampler->GetInternalIndexFromDistance(Start); EndIndex = pSampler->GetInternalIndexFromDistance(End); } // case 2 else if (Start == -1) StartIndex = EndIndex = 0; else if (End == -1) StartIndex = EndIndex = pSampler->GetInternalIndexFromDistance(Start); // just make sure we got valid indexes if (StartIndex == -1 || EndIndex == -1) { ERROR3("Start or end index off the end of the array in OpDrawBrush::GeneratePressureData"); return NULL; } // we are using internal indexes so set the sample rate to 1.0 pSampler->SetRetrievalSampleRate(1.0); // get the starting pressure, make it a double as we're going to be doing lots of fp ops. CSampleItem StartItem; BOOL ok = pSampler->GetAt(StartIndex, &StartItem); double StartNewValue = (double)StartItem.m_Pressure; // same for the end CSampleItem EndItem; if (ok) ok = pSampler->GetAt(EndIndex, &EndItem); double EndNewValue = (double)EndItem.m_Pressure; // now we have our start and end values, we also need to know how many items to make // Given that we sample at the rate of MIN_BRUSH_SPACING this is fairly straightforward UINT32 NumObjects = NewPathLength / MIN_BRUSH_SPACING; // find out by how much we must increase/decrease by each time double Incr = (EndNewValue - StartNewValue)/NumObjects; // lets make our new sampler here CDistanceSampler* pNewSampler = new CDistanceSampler; if (pNewSampler == NULL) return NULL; if (!pNewSampler->InitialiseData(NumObjects)) { delete pNewSampler; return NULL; } // now just loop through, adding items to the sampler CSampleItem NewItem; NewItem.m_Pressure = (UINT32)StartNewValue; ok = pNewSampler->SetAt(0, NewItem); while (NumObjects > 0 && ok) { NewItem.m_Pressure += (UINT32)Incr; ok = pNewSampler->SetNext(NewItem); NumObjects--; } return pNewSampler; }

MILLIPOINT OpDrawBrush::GetCurrentLineWidthIfNotDefault (   )  [static]

In order to determine whether we have to tell the brush to scale to a new line width or not. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 25/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The current line width, UNLESS the current line width is the Default attribute, in which case it returns -1 Definition at line 2329 of file opdrbrsh.cpp. { MILLIPOINT Retval = -1; Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) { ERROR3("No document"); return Retval; } AttributeManager* pAttrMgr = &(pDoc->GetAttributeMgr()); if (pAttrMgr == NULL) { ERROR3("No attribute manager"); return Retval; } AttrLineWidth* pAttr = (AttrLineWidth*)(pAttrMgr->GetCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), CC_RUNTIME_CLASS(AttrLineWidth))); if (pAttr != NULL) { AttrLineWidth* pDefault = (AttrLineWidth*)(AttributeManager::GetDefaultAttribute(ATTR_LINEWIDTH)); if (pDefault == NULL) { ERROR3("Unable to get default line width, theres no way this can happen Jim!"); return Retval; } MILLIPOINT CurrentLineWidth = pAttr->Value.LineWidth; MILLIPOINT DefaultLineWidth = pDefault->Value.LineWidth; if (CurrentLineWidth != DefaultLineWidth -1) // for some reason the default is 501 Retval = CurrentLineWidth; // it turns out that GetDefault returns a copy of the default, so we must delete it here delete pDefault; } return Retval; }

OpState OpDrawBrush::GetState (  String_256 *  Description, OpDescriptor *  )  [static]

Find out the state of the operation at the specific time. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Description  - GetState fills this string with an approriate description [OUTPUTS] of the current state of the push tool Returns: The state of the operation, so that menu items (ticks and greying can be done properly Reimplemented from OpFreeHand. Definition at line 1910 of file opdrbrsh.cpp. { OpState Blobby; return Blobby; }

BOOL OpDrawBrush::InitialisePathProcessorBrush (  BrushHandle  Handle, MILLIPOINT  Distance = 0 )  [protected]

To create a new pathprocessorbrush and copy all the data from the brush definitino found using BrushIndex. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/99 Parameters: BrushIndex  - index into the array of brush definitions stored in the brush component [INPUTS] Distance - the distance along the path that we are starting at Retruns: TRUE if successful, FALSE otherwise See also: - Definition at line 2095 of file opdrbrsh.cpp. { // find the brush definition corresponding to the Handle Document* pDoc = Document::GetCurrent(); ERROR2IF(pDoc == NULL, FALSE, "er, wheres the document gone"); BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent((CC_RUNTIME_CLASS(BrushComponent))); ERROR2IF(pBrushComp == NULL, FALSE, "No brush component"); BrushDefinition* pBrushDef = pBrushComp->FindBrushDefinition(Handle); ERROR2IF(pBrushDef == NULL, FALSE, "Couldn't find brush definition"); // ask the definition to prepare for rendering if (!pBrushDef->StartRender()) return FALSE; // check we haven't already allocated this member if (m_pPathProcBrush != NULL) { delete m_pPathProcBrush; m_pPathProcBrush = NULL; } // allocate the new path processor m_pPathProcBrush = new PathProcessorBrush; if (m_pPathProcBrush == NULL) { InformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK)); return FALSE; } // everything is ok so far, so transfer the data m_pPathProcBrush->SetBrushDefinition(Handle); pBrushDef->CopyDataToProcessor(m_pPathProcBrush); PORTNOTE("other", "Removed m_pGRenderBrush support") #ifndef EXCLUDE_FROM_XARALX // if our screen depth is < 24 BPP then we need to ensure that the scaling and offset // variations are turned off. if (m_pGRenderBrush->GetScreenDepth() < 24) { m_pPathProcBrush->SetBrushScalingIncr(1); m_pPathProcBrush->SetBrushScalingIncrConst(0); // m_pPathProcBrush->SetScalingMaxPressure(0); m_pPathProcBrush->SetPathOffsetIncrConst(0); m_pPathProcBrush->SetPathOffsetIncrProp(1); // m_pPathProcBrush->SetScalingMaxRand(0); } #endif // if we're not using pressure then turn it off if (!AddPressureToPath) { m_pPathProcBrush->SetScalingMaxPressure(0); m_pPathProcBrush->SetTransparencyPressure(0); } // do we need to scale to line width MILLIPOINT LineWidth = GetCurrentLineWidthIfNotDefault(); if (LineWidth != -1) { if (LineWidth < 501) // make sure we don't go too small LineWidth = 501; m_pPathProcBrush->ScaleToValue(LineWidth, !AddPressureToPath); } m_BrushScaling = m_pPathProcBrush->GetBrushScaling(); m_pPathProcBrush->Reset(); m_pPathProcBrush->SetCalculateBoundingBox(TRUE); // we want the bounding box // set up the arrays to hold cached transformation data if (!m_pPathProcBrush->PrepareForRenderingLoop(m_pPathProcBrush->GetNumBrushObjects())) { delete m_pPathProcBrush; return FALSE; } // if we are starting at some point along the path then advance our data to what it should be if (Distance) m_pPathProcBrush->AdvanceBrushToDistance(Distance); m_LastInkObjectRendered = m_pPathProcBrush->GetLastObject(); // finally if this brush does not require pressure then turn it off if (!pBrushDef->UsesPressure()) AddPressureToPath = FALSE; //#ifdef NEWFASTBRUSHES m_pBrushDefinition = m_pPathProcBrush->GetOurBrushDefinition (); // store this off here // old RenderBrushAtPoint would grab this for each iteration! //#endif return TRUE; }

BOOL OpDrawBrush::InitialisePressureCache (   )  [protected]

To allocate the pressure array, if we need it. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/99 Parameters: -  [INPUTS] See also: - Definition at line 2202 of file opdrbrsh.cpp. { // do we actually need to do this? if (!AddPressureToPath) return TRUE; /* m_pPressureVals = new PressureArray; if (m_pPressureVals == NULL) return FALSE; // make it pretty big so we don't have to keep reallocating m_pPressureVals->SetSize(200, 10); */ m_pPressureList = new PressureList; if (m_pPressureList == NULL) return FALSE; return TRUE; }

BOOL OpDrawBrush::InitialisePressureSampler (   )  [protected]

to create a new CSampleData object and assign it to our pointer for sampling pressure Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/99 Parameters: -  [INPUTS] Returns: TRUE if successful, FALSE if our allocation failed. See also: - Definition at line 2287 of file opdrbrsh.cpp. { if (m_pPressureSampler != NULL) { delete m_pPressureSampler; m_pPressureSampler = NULL; } if (!AddPressureToPath) return TRUE; m_pPressureSampler = new CDistanceSampler; if (m_pPressureSampler == NULL) return FALSE; // set the max pressure value from our device CCPen *pPen = pApp->GetPressurePen(); UINT32 MaxPressure = MAXPRESSURE; if (pPen != NULL) MaxPressure = pPen->GetPressureMax(); m_pPressureSampler->SetMaxPressure(MaxPressure); return m_pPressureSampler->InitialiseData(5000); }

BOOL OpDrawBrush::InitialiseProcessPathDistance (   )  [protected]

To create a new path processor object. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/99 Parameters: -  [INPUTS] See also: - Definition at line 2063 of file opdrbrsh.cpp. { if (m_pProcPathDistance != NULL) { delete m_pProcPathDistance; m_pProcPathDistance = NULL; } m_pProcPathDistance = new ProcessPathDistance(750/2); if (m_pProcPathDistance == NULL) { InformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK)); return FALSE; } return TRUE; }

BOOL OpDrawBrush::InitialiseTimeStampList (   )  [protected]

to create a new timestamp object list and assign it to our member Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/99 Parameters: -  [INPUTS] See also: - Definition at line 2235 of file opdrbrsh.cpp. { // if we've already got one then delete it if (m_pTimeStampList != NULL) { delete m_pTimeStampList; m_pTimeStampList = NULL; } m_pTimeStampList = new TimeStampList; if (m_pTimeStampList == NULL) return FALSE; return TRUE; }

virtual BOOL OpDrawBrush::IsBrushOp (   )  [inline, virtual]

Reimplemented from OpFreeHand. Definition at line 174 of file opdrbrsh.h. { return TRUE;}

void OpDrawBrush::RenderDragBlobs (  DocRect  , Spread *  , BOOL  bSolidDrag )  [inline, virtual]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/93 Parameters: Rect  - The Rectangle that needs to be re-rendered [INPUTS] pSpread - The spread on which the rendering is to take place See also: OpFreeHand::RenderLineSegment() Reimplemented from OpFreeHand. Definition at line 168 of file opdrbrsh.h. {}

void OpDrawBrush::RenderStepsForTime (  double  TimeSlice, Spread *  pSpread )  [protected]

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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/99 Parameters: TimeSlice  - the length of time to render for [INPUTS] pSpread - the spread to render on to Returns: - Definition at line 739 of file opdrbrsh.cpp. { if ( (m_pProcPathDistance == NULL) || (m_pPathProcBrush == NULL) || (m_pGRenderBrush == NULL) || (TrackData == NULL)) { ERROR3("One or more members are NULL"); return; } MonotonicTime timer; // declare locals outside the loop DocCoord Point; double Angle; UINT32 Pressure = 0; CSampleItem TheItem; BrushPointInfo PathPoint; // records how far along the path we are MILLIPOINT DistanceToGetPoint = m_LastDistanceRendered; // spacing records the spacing between objects (duh) // this little hack is here to make sure our first object is a few millipoints in from the // start of the path, otherwise we will always have a tangetial angle of zero MILLIPOINT Spacing = m_LastSpacing; if (!m_bFirstPointRendered) { Spacing = m_FirstSpacing; if (m_pPressureSampler != NULL) { if (m_pPressureSampler->GetAt(0, &TheItem)) Pressure = TheItem.m_Pressure; else Pressure =127; m_pPathProcBrush->SetCurrentPressure(Pressure); } } BOOL Found; //m_BrushScaling = m_pPathProcBrush->GetLastScaling(); #ifdef SCALESPACING double ActualSpacing = (double)Spacing * m_BrushScaling; #else double ActualSpacing = (double)Spacing * m_pPathProcBrush->GetBrushScaling(); #endif // if (TrackData->GetNumCoords() > 2) // RenderLine(m_pGRenderBrush, TrackData, TrackData->GetNumCoords() - 1); UINT32 Dummy = 0; // render objects at m_BrushSpacing intervals starting at the last point rendered while (m_DistanceSinceLastObject >= (MILLIPOINT)ActualSpacing) { // the path processor needs to set up some variables to deal with offsets // before we come to actually render m_pPathProcBrush->SetNextOffsetType(); //TRACEUSER( "Diccon", _T("Scaled Spacing = %f\n"), double(Spacing * m_BrushScaling)); DistanceToGetPoint += (MILLIPOINT)ActualSpacing; // get the point from the nodebrushpath m_pProcPathDistance->GetCoordAndTangentWithCache(&Point, &Angle, &Found, DistanceToGetPoint, TrackData, &Dummy); if (Found) { //TRACEUSER( "Diccon", _T("Point found at: %d, %d\n"), Point.x, Point.y); PathPoint.m_Point = Point; PathPoint.m_Tangent = Angle; PathPoint.m_Pressure = Dummy; // pass to the pathprocessor which does the work of rendering, but not if our object is zero-sized PORTNOTE("other", "Removed m_pRenderGBrush"); #ifndef EXCLUDE_FROM_XARALX if (m_BrushScaling > 0) { m_pPathProcBrush->RenderBrushAtPoint(Point, Angle, m_LastInkObjectRendered, m_NumBrushObjects, m_pGRenderBrush, NULL, TRUE, m_pBrushDefinition); } #endif // get the next pressure value if (m_pPressureSampler != NULL && m_bFirstPointRendered) { m_pPressureSampler->SetSampleRateFromSpacing((MILLIPOINT)ActualSpacing); if (m_pPressureSampler->GetNext(&TheItem)) Pressure = TheItem.m_Pressure; else Pressure = 127; m_pPathProcBrush->SetCurrentPressure(Pressure); //TRACEUSER( "Diccon", _T("SETTING PRESSURE %d = %d\n"), m_NumBrushObjects, Pressure); } PORTNOTE("other", "Removed m_pRenderGBrush"); #ifndef EXCLUDE_FROM_XARALX // get it to the screen ASAP m_pGRenderBrush->DrawToScreenNow(); #endif m_DistanceSinceLastObject -= (MILLIPOINT)(ActualSpacing); //m_BrushSpacing; m_LastDistanceRendered = DistanceToGetPoint; // get the next spacing (spacing only changes once we have drawn an object) Spacing = m_pPathProcBrush->GetNextSpacing(); m_BrushScaling = m_pPathProcBrush->GetLastScaling(); #ifdef SCALESPACING ActualSpacing = Spacing * m_BrushScaling; #else ActualSpacing = (double)Spacing * m_pPathProcBrush->GetBrushScaling(); //m_BrushSpacing; //Spacing * m_BrushScaling; #endif // switch our alternating offset m_pPathProcBrush->SwitchAlternateValue(); #ifdef OPBRUSHPOINTSCACHE // stash this point in the cache if (m_pPointsCache != NULL) (*m_pPointsCache)[DistanceToGetPoint]=PathPoint; #endif // get the next object in the sequence m_LastInkObjectRendered = m_pPathProcBrush->GetNextInkObject(m_LastInkObjectRendered, m_NumInkObjects); m_pPathProcBrush->DecideWhetherToUseActualScaling(m_LastInkObjectRendered); // increment our counter m_NumBrushObjects++; m_bFirstPointRendered = TRUE; // TRACEUSER( "Diccon", _T("Pressure at end of loop = %d\n"), Pressure); } // if we hit the time constraint then just get out now if (timer.Elapsed(UINT32(TimeSlice * 1000.0))) break; } // TRACEUSER( "Diccon", _T("Exit RenderStepsForTime\n")); // remember the spacing for next time m_LastSpacing = Spacing; }

void OpDrawBrush::RenderTimeStamp (   )  [protected]

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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/99 Parameters: -  [INPUTS] Returns: - Definition at line 892 of file opdrbrsh.cpp. { if (m_TimeStamp <=0) { ERROR3("Invalid timestamp value"); return; } if (m_Timer.Elapsed((UINT32)(m_TimeStamp * 1000.0))) { m_Timer.Sample(); // find out how far along the path we are MILLIPOINT DistanceAlongPath = m_LastDistanceRendered + m_DistanceSinceLastObject; DocCoord Point; double Angle = 0; BOOL Found = FALSE; // get the point from the path m_pProcPathDistance->GetCoordAndTangentWithCache(&Point, &Angle, &Found, DistanceAlongPath, TrackData); if (Found) { TimeStampBrushPoint TSP(Point, Angle, DistanceAlongPath); // get the next object in the sequence m_LastInkObjectRendered = m_pPathProcBrush->GetNextInkObject(m_LastInkObjectRendered, m_NumInkObjects); PORTNOTE("other", "Removed m_pRenderGBrush"); #ifndef EXCLUDE_FROM_XARALX // pass to the pathprocessor which does the work of rendering if (m_pGRenderBrush != NULL) { m_pPathProcBrush->RenderBrushAtPoint(Point, Angle, m_LastInkObjectRendered++, 1, m_pGRenderBrush, NULL, TRUE); // get it to the screen ASAP m_pGRenderBrush->DrawToScreenNow(); TRACEUSER( "Diccon", _T("OpDrawBrush Rendered TimeStamp")); } #endif // update our member variables m_DistanceSinceLastObject = 0; m_LastDistanceRendered = DistanceAlongPath; // cache the point if (m_pTimeStampList != NULL) m_pTimeStampList->push_back(TSP); } } }

void OpDrawBrush::ResetMembers (   )  [protected]

Initialises all our member variables to something sensible. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Definition at line 248 of file opdrbrsh.cpp. { // Set all our cursors to NULL to start with pFreeHandCursor = NULL; pJoinCursor = NULL; pStraightCursor = NULL; pRubOutCursor = NULL; pModifyCursor = NULL; // Set other default values TrackData = NULL; StartSpread = NULL; PreviousSpread = NULL; Smoothness = 512; LineSegmentCount = 0; CanLineJoin = FALSE; IsStraightLineMode = FALSE; AddPressureToPath = FALSE; FreeHandPressure = 0; // The paths that we are joined to, or NULL if we are joined to none pJoinInfo = NULL; StartPath = NULL; EndPath = NULL; CloseTo = 0; Mu = 0.0; IsEndNearEndpoint = FALSE; CurrentCursorID = 0; m_pGRenderBrush = NULL; m_pPathProcBrush = NULL; //#ifdef NEWFASTBRUSHES m_pBrushDefinition = NULL; mustClearStatusBar = TRUE; pApp = GetApplication (); ERROR3IF (!pApp, "Could not find the application!"); //#endif m_pProcPathDistance = NULL; m_BrushScaling = 1.0; #ifdef OPBRUSHPOINTSCACHE m_pPointsCache = NULL; #endif m_pTimeStampList = NULL; m_TimeStamp = 0; m_LastTimeStamp = -1; m_pPressureList = NULL; m_LastPathIndexRendered = 1; m_FirstSpacing = 25; m_pPressureSampler = NULL; m_NumPressureVals = 0; }

BOOL OpDrawBrush::RetroSmoothBrush (  NodePath *  pNewNodePath  )  [protected, virtual]

As above, the base class version does nothing. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 19/3/2000 Parameters: pNewPath  - The New curve that has just been drawn [INPUTS] Returns: TRUE Reimplemented from OpFreeHand. Definition at line 1726 of file opdrbrsh.cpp. { return ApplyRetroSmoother(pNewNodePath, 85); }

BOOL OpDrawBrush::ReverseBrushPressure (   )  [protected, virtual]

Calls the attribute function to reverse our pressure list. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/3/2000 Parameters: [INPUTS]  Returns: TRUE if it worked, FALSE if it failed, or if we aren't using pressure Reimplemented from OpFreeHand. Definition at line 1744 of file opdrbrsh.cpp. { if (m_pPressureSampler == NULL) return FALSE; return m_pPressureSampler->ReverseData(); }

void OpDrawBrush::SetCursorAndStatus (  CursorType  CurType  )  [protected, virtual]

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. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 4/7/2000 Parameters: CurType  - The type of cursor to change to [INPUTS] Reimplemented from OpFreeHand. Definition at line 1986 of file opdrbrsh.cpp. { // Now, if FlipCursor = TRUE, we flip it! static Cursor* WhichCursor; WhichCursor = NULL; switch (CurType) { case NORMAL_CURSOR: WhichCursor = pFreeHandCursor; break; case JOIN_CURSOR: WhichCursor = pJoinCursor; break; case MODIFY_CURSOR: WhichCursor = pModifyCursor; break; default: break; } if (mustClearStatusBar) // got to execute the following at least once so that we clear the status bar .... { String_256 StatusMsg(""); // Change Status bar message and the cursor pApp->UpdateStatusBarText(&StatusMsg); mustClearStatusBar = FALSE; } if (WhichCursor != MyCurrentCursor) { String_256 StatusMsg(_T("")); switch (CurType) { case NORMAL_CURSOR: break; case JOIN_CURSOR: StatusMsg.Load(_R(IDS_FREEHANDDRAGJOIN)); break; case MODIFY_CURSOR: StatusMsg.Load(_R(IDS_FREEHANDMODIFY)); break; default: break; } // Change Status bar message and the cursor pApp->UpdateStatusBarText(&StatusMsg); // set this cursor as the current cursor and immediately display it CursorStack::GSetTop(WhichCursor, CurrentCursorID); // remember this is our current cursor MyCurrentCursor = WhichCursor; } }

BOOL OpDrawBrush::SetTimeStamp (  double  TimeStamp  )

to set the timestamp member Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 28/11/99 Parameters: Value  of timestamp to use in ms. [INPUTS] Returns: TRUE unless Timestamp is outside the specified bounds See also: - Definition at line 2264 of file opdrbrsh.cpp. { if (TimeStamp < MIN_TIMESTAMP || TimeStamp > MAX_TIMESTAMP) return FALSE; m_TimeStamp = TimeStamp; return TRUE; }

BOOL OpDrawBrush::SimpleJoinBrush (  NodePath *  pInsertedNode, Path *  pNewPath )  [protected, virtual]

Joins a Simple path with the new freehand path and builds all the undo that is needed in the process. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 20/3/2000 Parameters: pInsertedNode  - the node that we have just inserted [INPUTS] pPath - the new section of path that we have just drawn Returns: TRUE if it worked, FALSE if it failed This version also incorporates code to insert timestamping or pressure data if we are editing such a brush Reimplemented from OpFreeHand. Definition at line 1605 of file opdrbrsh.cpp. { if (pInsertedNode == NULL || pNewPath == NULL) { ERROR3("Null inputs to OpDrawBrush::SimpleJoinBrush"); return FALSE; } // first check to see if the edited path has a brush applied to it, // if it doesn't then we'll leave NodeAttribute* pAttr; AttrBrushType* pAttrBrush; pInsertedNode->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), &pAttr); if (pAttr == NULL) return TRUE; pAttrBrush = (AttrBrushType*)pAttr; // if our brush has a 'no brush' handle then likewise if (pAttrBrush->GetBrushHandle() == BrushHandle_NoBrush) return TRUE; // if our brush is not either timestamping or has a pressure list then we will leave aswell CDistanceSampler* pPressData = pAttrBrush->GetPressureCache(); if (pPressData == NULL) return TRUE; // Do we have a pressure cache?? if (m_pPressureSampler == NULL) return TRUE; // find out what type of join we have SimpleJoinType JoinType = GetSimpleJoinType(pNewPath, &(pInsertedNode->InkPath)); if (JoinType == JOINTYPE_NONE) { ERROR3("No join type in OpDrawBrush::SimpleJoinBrush"); return TRUE; } // we need to know the distance along the original path where we want to insert the // new points. As this is a simple join it will either be at the beginning or the end. // we also need to know the distance to the end of the new points, as this is required // for the undo. MILLIPOINT NewPathLength = (MILLIPOINT)pNewPath->GetPathLength(); MILLIPOINT OldPathLength = -1; if (StartPath != NULL) { OldPathLength = (MILLIPOINT)StartPath->InkPath.GetPathLength(); } else { if (EndPath != NULL) OldPathLength = (MILLIPOINT)EndPath->InkPath.GetPathLength(); } MILLIPOINT InsertDistance = -1; MILLIPOINT EndInsertDistance = -1; INT32 StartIndex = 0; //where we will begin our insert // according to the type of join we will want to insert our new data at the beginning or the // end, we may also want to reverse it switch (JoinType) { case JOINTYPE_NEWSTART_TO_OLDSTART: InsertDistance = 0; EndInsertDistance = NewPathLength; StartIndex = 0; // in this instance we reversed the new path section so also reverse the pressure data m_pPressureSampler->ReverseData(); break; case JOINTYPE_NEWSTART_TO_OLDEND: InsertDistance = OldPathLength; EndInsertDistance = OldPathLength + NewPathLength; StartIndex = pPressData->GetInternalIndexFromDistance(OldPathLength); if (StartIndex==-1) StartIndex = pPressData->GetNumItems(); break; case JOINTYPE_NEWEND_TO_OLDSTART: InsertDistance = 0; EndInsertDistance = NewPathLength; StartIndex = 0; break; case JOINTYPE_NEWEND_TO_OLDEND: InsertDistance = OldPathLength; EndInsertDistance = OldPathLength + NewPathLength; StartIndex = pPressData->GetInternalIndexFromDistance(OldPathLength); if (StartIndex==-1) StartIndex = pPressData->GetNumItems(); m_pPressureSampler->ReverseData(); break; default: ERROR3("Unknown join type in OpDrawBrush::SimpleJoinBrush"); return FALSE; } // make the action to insert the pressure list if (m_pPressureSampler != NULL) { AddPressurePointsAction* pAction; UINT32 NumPoints = m_pPressureSampler->GetNumItems(); if (AddPressurePointsAction::Init(this, &UndoActions, pAttrBrush, m_pPressureSampler, StartIndex, NumPoints, &pAction) == AC_FAIL) return FALSE; m_pPressureSampler = NULL; // so we don't delete it } return TRUE; }

---

Member Data Documentation

BOOL OpDrawBrush::m_bFirstPointRendered [protected]

Definition at line 257 of file opdrbrsh.h.

double OpDrawBrush::m_BrushScaling [protected]

Definition at line 242 of file opdrbrsh.h.

MILLIPOINT OpDrawBrush::m_BrushSpacing [protected]

Definition at line 230 of file opdrbrsh.h.

MILLIPOINT OpDrawBrush::m_DistanceSinceLastObject [protected]

Definition at line 232 of file opdrbrsh.h.

MILLIPOINT OpDrawBrush::m_FirstSpacing [protected]

Definition at line 259 of file opdrbrsh.h.

MILLIPOINT OpDrawBrush::m_LastDistanceRendered [protected]

Definition at line 233 of file opdrbrsh.h.

UINT32 OpDrawBrush::m_LastInkObjectRendered [protected]

Definition at line 240 of file opdrbrsh.h.

INT32 OpDrawBrush::m_LastPathIndexRendered [protected]

Definition at line 261 of file opdrbrsh.h.

DocCoord OpDrawBrush::m_LastPoint [protected]

Definition at line 234 of file opdrbrsh.h.

DocCoord OpDrawBrush::m_LastPointRendered [protected]

Definition at line 236 of file opdrbrsh.h.

MILLIPOINT OpDrawBrush::m_LastSpacing [protected]

Definition at line 231 of file opdrbrsh.h.

double OpDrawBrush::m_LastTimeStamp [protected]

Definition at line 270 of file opdrbrsh.h.

INT32 OpDrawBrush::m_NumBrushObjects [protected]

Definition at line 237 of file opdrbrsh.h.

UINT32 OpDrawBrush::m_NumInkObjects [protected]

Definition at line 239 of file opdrbrsh.h.

UINT32 OpDrawBrush::m_NumPressureVals [protected]

Definition at line 282 of file opdrbrsh.h.

BrushDefinition* OpDrawBrush::m_pBrushDefinition [protected]

Definition at line 248 of file opdrbrsh.h.

GRenderBrush* OpDrawBrush::m_pGRenderBrush [protected]

Definition at line 244 of file opdrbrsh.h.

PathProcessorBrush* OpDrawBrush::m_pPathProcBrush [protected]

Definition at line 245 of file opdrbrsh.h.

PointsMap* OpDrawBrush::m_pPointsCache [protected]

Definition at line 264 of file opdrbrsh.h.

PressureList* OpDrawBrush::m_pPressureList [protected]

Definition at line 277 of file opdrbrsh.h.

CDistanceSampler* OpDrawBrush::m_pPressureSampler [protected]

Definition at line 280 of file opdrbrsh.h.

ProcessPathDistance* OpDrawBrush::m_pProcPathDistance [protected]

Definition at line 254 of file opdrbrsh.h.

TimeStampList* OpDrawBrush::m_pTimeStampList [protected]

Definition at line 271 of file opdrbrsh.h.

FreeHandTool* OpDrawBrush::m_pTool [protected]

Definition at line 255 of file opdrbrsh.h.

DocCoord OpDrawBrush::m_StartPoint [protected]

Definition at line 235 of file opdrbrsh.h.

MonotonicTime OpDrawBrush::m_Timer [protected]

Definition at line 272 of file opdrbrsh.h.

double OpDrawBrush::m_TimeStamp [protected]

Definition at line 269 of file opdrbrsh.h.

BOOL OpDrawBrush::mustClearStatusBar [protected]

Definition at line 250 of file opdrbrsh.h.

Application* OpDrawBrush::pApp [protected]

Definition at line 251 of file opdrbrsh.h.

---

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

• tools/opdrbrsh.h (r1785/r1273)
• tools/opdrbrsh.cpp (r1785/r1282)

---