opdrbrsh.cpp

Go to the documentation of this file.

// $Id: opdrbrsh.cpp 1282 2006-06-09 09:46:49Z alex $
/* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
================================XARAHEADERSTART===========================
 
               Xara LX, a vector drawing and manipulation program.
                    Copyright (C) 1993-2006 Xara Group Ltd.
       Copyright on certain contributions may be held in joint with their
              respective authors. See AUTHORS file for details.

LICENSE TO USE AND MODIFY SOFTWARE
----------------------------------

This file is part of Xara LX.

Xara LX is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as published
by the Free Software Foundation.

Xara LX and its component source files are distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with Xara LX (see the file GPL in the root directory of the
distribution); if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA  02110-1301 USA


ADDITIONAL RIGHTS
-----------------

Conditional upon your continuing compliance with the GNU General Public
License described above, Xara Group Ltd grants to you certain additional
rights. 

The additional rights are to use, modify, and distribute the software
together with the wxWidgets library, the wxXtra library, and the "CDraw"
library and any other such library that any version of Xara LX relased
by Xara Group Ltd requires in order to compile and execute, including
the static linking of that library to XaraLX. In the case of the
"CDraw" library, you may satisfy obligation under the GNU General Public
License to provide source code by providing a binary copy of the library
concerned and a copy of the license accompanying it.

Nothing in this section restricts any of the rights you have under
the GNU General Public License.


SCOPE OF LICENSE
----------------

This license applies to this program (XaraLX) and its constituent source
files only, and does not necessarily apply to other Xara products which may
in part share the same code base, and are subject to their own licensing
terms.

This license does not apply to files in the wxXtra directory, which
are built into a separate library, and are subject to the wxWindows
license contained within that directory in the file "WXXTRA-LICENSE".

This license does not apply to the binary libraries (if any) within
the "libs" directory, which are subject to a separate license contained
within that directory in the file "LIBS-LICENSE".


ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS
----------------------------------------------

Subject to the terms of the GNU Public License (see above), you are
free to do whatever you like with your modifications. However, you may
(at your option) wish contribute them to Xara's source tree. You can
find details of how to do this at:
  http://www.xaraxtreme.org/developers/

Prior to contributing your modifications, you will need to complete our
contributor agreement. This can be found at:
  http://www.xaraxtreme.org/developers/contribute/

Please note that Xara will not accept modifications which modify any of
the text between the start and end of this header (marked
XARAHEADERSTART and XARAHEADEREND).


MARKS
-----

Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara
designs are registered or unregistered trademarks, design-marks, and/or
service marks of Xara Group Ltd. All rights in these marks are reserved.


      Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK.
                        http://www.xara.com/

=================================XARAHEADEREND============================
 */

// Implementation of OpDrawBrush

#include "camtypes.h"
#include "opdrbrsh.h"
//#include "trans2d.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "pen.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "opfree.h"
//#include "resource.h"
#include "freehand.h"
#include "csrstack.h"
//#include "undoop.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "combshps.h"
//#include "rik.h"
//#include "bubbleid.h"
#include "ndbldpth.h"
//#include "mario.h"
#include "progress.h"
//#include "range.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "grndbrsh.h"
#include "objchge.h"
//#include "nodeattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "attrmap.h"
#include "nodershp.h"
#include "opbevel.h"
#include "nodebev.h"
//#include "markn.h"
#include "blndtool.h"
#include "brshattr.h"
#include "brshcomp.h"
#include "pathproc.h"
#include "lineattr.h"
#include "freehand.h"
//#include "freehres.h"
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ccobject.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "rsmooth.h"
#include "camelot.h"
#include "nodeshad.h"
#include "nodecntr.h"
#include "lineattr.h"
#include "samplist.h"
#include "linwthop.h"
//#include "scrcamvw.h"
#include "ophist.h"
#include "ppbrush.h"

#include "qualattr.h"

// Declare the class
CC_IMPLEMENT_DYNCREATE( OpDrawBrush, SelOperation );
CC_IMPLEMENT_DYNCREATE( OpChangeBrush, SelOperation );
CC_IMPLEMENT_DYNAMIC(ChangeBrushOpParam, OpParam);
CC_IMPLEMENT_DYNCREATE(ChangeBrushAction, Action);
CC_IMPLEMENT_DYNCREATE(RemoveTimeStampPointsAction, Action);
CC_IMPLEMENT_DYNCREATE(AddTimeStampPointsAction, Action);
CC_IMPLEMENT_DYNCREATE(UpdateBrushAction, Action);
CC_IMPLEMENT_DYNCREATE(SetTimeStampUpdateTypeAction, Action);
CC_IMPLEMENT_DYNCREATE(RemovePressurePointsAction, Action);
CC_IMPLEMENT_DYNCREATE(AddPressurePointsAction, Action);

#define DELPTR(p) if (p != NULL) { delete p; p = NULL; }
#define SWAP(type,a,b) { type x=a; a=b; b=x; }

// Declare smart memory handling in Debug builds
#define new CAM_DEBUG_NEW

const UINT32 PressureValsThreshold = 3; //basically the first 3 or so values coming out of the 

                                      // pressure pen are always zero, so we must ignore them



/********************************************************************************************

>   OpDrawBrush::OpDrawBrush()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/10/99
    Purpose:    Constructor.    
********************************************************************************************/

OpDrawBrush::OpDrawBrush()
{
    ResetMembers();
}

/********************************************************************************************

>   OpDrawBrush::OpDrawBrush()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/10/99
    Purpose:    Constructor. This simply sets a few of the operation flags.

********************************************************************************************/

OpDrawBrush::OpDrawBrush(FreeHandTool *pTool)
{
    ResetMembers();
    if (pTool != NULL)
        m_pTool = pTool;
}


/********************************************************************************************

>   OpDrawBrush::~OpDrawBrush()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/10/99
    Purpose:    destructor.

********************************************************************************************/

OpDrawBrush::~OpDrawBrush()
{
//  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;
}


/********************************************************************************************

>   void OpDrawBrush::ResetMembers()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/10/99
    Purpose:    Initialises all our member variables to something sensible

********************************************************************************************/

void OpDrawBrush::ResetMembers()
{
    // 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;


}

/********************************************************************************************

>   void OpDrawBrush::DoDrag( DocCoord Anchor, Spread *pSpread, INT32 Smooth, BrushHandle Handle, 
                            NodePath* pPath, Path* ToolPath, GRenderBitmap* pGRndBMP )

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/10/99
    Inputs:     Anchor  - The position of the mouse at the start of the Drag
                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
                
    Purpose:    Starts up the drag operation by storing all start positions and setting
                up a Path to store the mouse movement in

********************************************************************************************/

void OpDrawBrush::DoDrag(DocCoord Anchor, Spread *pSpread, INT32 Smooth, BrushHandle Handle,
                        FreeHandJoinInfo* pFreeHandInfo, Path* ToolPath,
                        GRenderBrush* pGRndRgn, ClickModifiers ClickMods)
{
    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::DragPointerMove( DocCoord PointerPos, ClickModifiers ClickMods, 
                                  Spread *pSpread, BOOL bSolidDrag)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/10/99
    Inputs:     PointerPos - The current position of the mouse in Doc Coords
                ClickMods - Which key modifiers are being pressed
                pSpread - The spread that the mouse is moving over
    Purpose:    Handles the event of the mouse moving during a drag
    SeeAlso:    ClickModifiers

********************************************************************************************/

void OpDrawBrush::DragPointerMove( DocCoord PointerPos, ClickModifiers ClickMods, 
                                  Spread *pSpread, BOOL bSolidDrag)
{
    // 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);
    }*/
}   



/********************************************************************************************

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

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/10/99
    Inputs:     PointerPos - The current position of the mouse in Doc Coords
                ClickMods - Which key modifiers are being pressed
                pSpread - The spread that the mouse is moving over
    Purpose:    Handles the mouse idle events
    SeeAlso:    ClickModifiers

********************************************************************************************/

void OpDrawBrush::DragPointerIdle(DocCoord PointerPos, ClickModifiers ClickMods, Spread* pSpread, BOOL bSolidDrag)
{
    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::RenderStepsForTime(double TimeSlice, Spread* pSpread)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/10/99
    Inputs:     TimeSlice - the length of time to render for
                pSpread - the spread to render on to
    Returns:    -
    Purpose:    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.
********************************************************************************************/

/* Notes: In case its not clear from the code what is happening here we go: the member variable
m_DistanceSinceLastObject records how far the mouse has travelled since we last rendered an object.
So long as this distance is greater than our spacing value then we wish to keep rendering points, and
reducing m_DistanceSinceLastObject until it becomes less than our spacing value.
*/

void OpDrawBrush::RenderStepsForTime(double TimeSlice, Spread* pSpread)
{
    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()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/10/99
    Inputs:     -
    Returns:    -
    Purpose:    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.
********************************************************************************************/

void OpDrawBrush::RenderTimeStamp()
{
    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::DragFinished( DocCoord PointerPos, ClickModifiers ClickMods,
                               Spread *pSpread, BOOL Success, BOOL bSolidDrag)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/10/99
    Inputs:     PointerPos - The position of the mouse at the end of the drag
                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
    Purpose:    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
    SeeAlso:    ClickModifiers

********************************************************************************************/

void OpDrawBrush::DragFinished( DocCoord PointerPos, ClickModifiers ClickMods,
                               Spread *pSpread, BOOL Success, BOOL bSolidDrag)
{   
    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();
}


/********************************************************************************************

>   BOOL OpDrawBrush::ApplyAttributes(NodePath* NewPath, Document *pDocument)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/1/2000
    Inputs:     NewPath - The NodePath to apply the current attributes to
                pDocument - the document this path will be placed into.
    Returns:    TRUE if it worked, FALSE if it did not
    Purpose:    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

                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.
********************************************************************************************/

BOOL OpDrawBrush::ApplyAttributes(NodePath* pNewPath, Document *pDocument)
{
    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 !=