brshcomp.cpp

Go to the documentation of this file.

// $Id: brshcomp.cpp 1732 2006-09-03 14:08:16Z 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============================
 */

// Brush Component and Brush Definition headers

#include "camtypes.h"
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "camfiltr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "brshcomp.h"
#include "linecomp.h"
//#include "colormgr.h"
//#include "cxfrec.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "cxfrech.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "cxftags.h"
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "layer.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "brushref.h"
#include "freehand.h"
#include "freeinfo.h"
//#include "xlong.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "ppbrush.h"
#include "brshattr.h"
#include "sgline.h"
//#include "loadbrsh.h"
#include "fileutil.h"
#include "clipint.h"
#include "nodebldr.h"
#include "bldbrdef.h"
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fillval.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "lineattr.h"
#include "brshdata.h"
//#include "swfrndr.h"
#include "brshname.h"
//#include "resdll.h"
#include "nodeshad.h"
#include "nodecntr.h"
#include "nodebev.h"
//#include "group.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "opdrbrsh.h"
#include "toollist.h"
//#include "freeinfo.h"
#include "brshbeca.h"
//#include "brdlgres.h"
#include "brushop.h"

DECLARE_SOURCE("$Revision: 1732 $");

CC_IMPLEMENT_DYNAMIC(BrushDefinition, LineDefinition)
CC_IMPLEMENT_DYNAMIC(BrushComponent, LineComponent)
CC_IMPLEMENT_DYNAMIC(BrushComponentClass, DocComponentClass)

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

BOOL BrushComponent::m_bCancelNewBrush = FALSE;
String_32 BrushComponent::m_NewName = TEXT("Unnamed brush");


const INT32 MAX_TRANSP_VALUE = 255;
/********************************************************************************************

>   BrushDefinition::BrushDefinition(Node *pBrushTree);

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/2/97

    Inputs:     pBrushTree - A pointer to a Spread node which is the root of a clipart
                              subtree which should be used for this Brush definition. It
                              must obey these rules:
                                * It must be a Spread
                                * It must not be linked into any other parent tree structure
                                * It should contain at least one ink node (or else the Brush
                                  will appear "blank"). 
                                * It should be attribute complete, or close thereto

    Purpose:    Constructor

    SeeAlso:    BrushComponent::AddNewBrush

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

BrushDefinition::BrushDefinition(Node* pBrushTree) 
: LineDefinition(pBrushTree)
{
    ResetMembers();
    InitialiseBrushArray(MAX_BRUSH_OBJECTS);
    if (!GenerateBrush())
    {
        // hmm, not sure what to do here, but you can detect if we failed to initialise
        // by calling IsActivated, if that fails you should delete me.
    }
    
}


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

>   BrushDefinition::BrushDefinition()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/2/97

    Purpose:    Default constructor for the purposes of inherited classes, if you just want a
                normal brushdef you should really use the constructor above.  
            
                5/12/2000 Actually I've just read that it is a poor idea to initialise inside
                constructors, so I think that a reorganisation should occur whereby the construcotr
                should simply assign the brush tree and we should GenerateBrush after the constructor
                returns.

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

BrushDefinition::BrushDefinition()
{
    ResetMembers();
}


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

>   BrushDefinition::~BrushDefinition()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/2/97

    Purpose:    Destructor

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

BrushDefinition::~BrushDefinition()  
{ 
    for( size_t i = 0; i < m_BrushRefPtrArray.size(); i++ )
    {
        // ask the brushref to delete the attribute maps it generated
        if (m_BrushRefPtrArray[i] != NULL)
        {
        //  m_BrushRefPtrArray[i]->DeleteAttributeMapsAndAttributes();
            delete m_BrushRefPtrArray[i];
        }
    }
    m_BrushRefPtrArray.clear();

    

}



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

>   void BrushDefinition::ResetMembers()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    6/10/99
    Inputs:     -
    Returns     -
    Purpose:    Initialises the member variables

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

void BrushDefinition::ResetMembers()
{
    m_BrushSpacing          = 10000;
    m_BrushSpacingIncrProp  = 1.0;
    m_BrushSpacingIncrConst = 0;
    m_BrushSpacingMaxRand   = 0;
    m_BrushSpacingRandSeed  = 0;

    m_PathOffsetType      = OFFSET_NONE;
    m_PathOffsetValue     =  0;
    m_PathOffsetIncrProp  = 1.0;
    m_PathOffsetIncrConst = 0;
    m_OffsetTypeRandSeed  = 0;
    m_OffsetValueMaxRand  = 0;
    m_OffsetValueRandSeed = 0;

    m_bRotate             = TRUE;
    m_RotateAngle         = 0;
    m_RotationMaxRand     = 0;
    m_RotationRandSeed    = 0;
    m_RotAngleIncrConst   = 0;
    m_RotAngleIncrProp    = 1.0;
    m_RotationMaxPressure = 0;

    m_bTile               = TRUE;

    m_BrushScaling        = 1.0;
    m_BrushScalingIncr    = 1.0;
    m_BrushScalingIncrConst = 0.0;
    m_BrushScalingMaxRand   = 0;
    m_BrushScalingRandSeed  = 0;
    m_ScalingMaxPressure    = 35;
    
    m_BrushHueIncrement     = 0.0;
    m_BrushHueMaxRand       = 0;
    m_BrushHueRandSeed      = 1234;

    m_BrushSatIncrement     = 0.0;
    m_BrushSatMaxRand       = 0;
    m_BrushSatRandSeed      = 5432; 

    m_SequenceType        = SEQ_FORWARD;
    m_SequenceRandSeed    = 0;

    m_NumBrushObjects     = 0;
    m_bInitOk             = FALSE;

    m_LargestBoundingBox.MakeEmpty();

    m_Name = TEXT("Custom Brush");

    m_TimeStampPeriod = 0;

    m_BrushTransparency  = 100;
    m_TranspMaxPressure  = 0;

    m_DefaultFileID = BRUSHFILE_NONE;

    m_bActivated = FALSE;
}



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

>   BOOL BrushDefinition::GenerateBrush()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    13/12/99
    Inputs:     -
    Returns     TRUE if successful, FALSE otherwise
    Purpose:    goes through the input spread and calls AddNewObject() for each ink object found
                We try to make some intelligent guesses about what to set the starting spacing and
                offset values depending on the nature of the nodes.  The following rules apply:
                - if there are multiple ink objects then the spacing is 1.1 * the largest dimension 
                of the largest bounding box
                - if there is only one object and it contains a positive line width spacing is as above
                - if there is only one object with no line width then spacing is 10000 millipoint
                - defaulf offset is always the largest dimension of the largest BBOX.

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

BOOL BrushDefinition::GenerateBrush()
{
    if (m_pTree == NULL)
        return FALSE;

    // get a node that points at the first child of the layer
    Node* pNode = m_pTree->FindFirstChild();
    pNode       = pNode->FindFirstChild();
    

    AttrLineWidth* pLineWidth = NULL;
    while (pNode != NULL)
    {
        if (pNode->IsAnObject())
        {
            // it has been drawn to my attention that it is possible to end up with a brush object
            // that has no line width attribute, which leads to all kinds of problems.  So here we will
            // search for one and if we don't find one we will add one.
            ((NodeRenderableInk*)pNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrLineWidth), (NodeAttribute**)&pLineWidth);
            if (!pLineWidth)
            {
                pLineWidth = new AttrLineWidth(pNode, LASTCHILD);
                if (pLineWidth)
                {
                    pLineWidth->Value.LineWidth = 501;
                    pLineWidth = NULL;
                }
            }

            // we don't want to make brushes from brushes, instead we want to convert them
            // to shapes first, so use the routine to do that.
            NodeGroup* pGroup = NULL;
            ReplaceBrushWithGroup((NodeRenderableInk*)pNode, &pGroup);
            if (pGroup != NULL)
            {
                // we got a group, so we have to delete the original node
                pGroup->AttachNode(pNode, NEXT);
                pGroup->FactorOutCommonChildAttributes();
                // unhook from the tree
                pNode->CascadeDelete();

                // swap the pointers
                Node* pDelete = pNode;
                pNode = pGroup;
                
                delete pDelete;
            }

            if (!AddNewObject((NodeRenderableInk*)pNode))
                return FALSE;
        }
        pNode = pNode->FindNext();
    }
    CalculateMaxScaling();

    m_bActivated = TRUE;
    return TRUE;

}


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

>   BOOL BrushDefinition::ReplaceBrushWithGroup(NodeRenderableInk* pInk, NodeGroup* pGroup)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    13/12/99
    Inputs:     pInk - the inknode that we are going to generate a brush from
    Outputs:    if pInk has a brush attribute applied to it then we will generate a new group 
                from that brush
    Returns     TRUE if successful, FALSE otherwise
    Purpose:    We are no longer allowed to make brushes from brushes, because of problems
                when saving and loading.  Instead if we have a brush then we will convert
                it to shapes and use those instead.

    Note:       So you actually have to delete pInk yourself if this function outputs a group.
                I had to do that to get the recursion to work.  Still I'm sure you can handle it.
***********************************************************************************************/

BOOL BrushDefinition::ReplaceBrushWithGroup(NodeRenderableInk* pInk, NodeGroup** ppGroup)
{
    ERROR2IF(pInk == NULL, FALSE, "Invalid inputs to BrushDefinition::ReplaceBrushWithGroups");

    BOOL  ok = TRUE;
    // if we're compound then search through all our children first
    if (pInk->IsCompound())
    {
        NodeGroup* pNodeGroup = NULL;
        Node* pChild = pInk->FindFirstChild();
        Node* pDelete = NULL;       
        
        while (pChild)
        {
            if (pChild->IsAnObject())
            {
                if (ok) ok = ReplaceBrushWithGroup((NodeRenderableInk*)pChild, &pNodeGroup);
                if (pNodeGroup)
                {
                    // attach the new group next to the child
                    pNodeGroup->AttachNode(pChild, NEXT);

                    pNodeGroup->FactorOutCommonChildAttributes();

                    // unhook the child
                    pChild->CascadeDelete();
                    
                    // we're ready to delete the original child
                    pDelete =  pChild;

                    // swap the pointer
                    pChild = pNodeGroup;    

                    delete pDelete;
                }
            }
            pChild = pChild->FindNext();
            pNodeGroup = NULL;
        }
    }

    AttrBrushType* pAttrBrush = NULL;
    pInk->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), (NodeAttribute**)&pAttrBrush);

    if (pAttrBrush && pAttrBrush->GetBrushHandle() != BrushHandle_NoBrush && ok)
    {
        //Turn the brush into a group with lots of nodepaths
        BrushBecomeAGroup BecomeA(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL);
        ok = pAttrBrush->DoBecomeA(&BecomeA, pInk);

        // the brush will create a group out of itself and we want to retrieve that
        NodeGroup* pBrushGroup = BecomeA.GetNodeGroup();
        pBrushGroup->FactorOutCommonChildAttributes();
        pBrushGroup->NormaliseAttributes();
        if (pBrushGroup != NULL && ok)
        {
            *ppGroup = pBrushGroup;
        }
    }
    return ok;
}

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

>   BOOL BrushDefinition::RegenerateBrush()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    13/12/99
    Inputs:     -
    Returns     TRUE if successful, FALSE otherwise
    Purpose:    This function deletes the existing brushrefs and recreates them from scratch from 
                m_pTree.

    Notes:      This function is necessary because of the inaccuracies in our matrix transformation
                system which make it impossible to repeatedly scale without either growing our objects.
                Therefore it is recommended that after every render where an object is scaled this function
                should be called to regenerate the brush.
                Obviously the potential for disaster is very high for instance we run out of memory
                in the middle of the operation.

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

BOOL BrushDefinition::RegenerateBrush()
{
    /*  As we now always take copies of the brush objects, this is scheduled for demolition...

    // first we need to transform all the attributes back to where they began
    PreExportSubTree();

    // make a temporary array to hold the existing elements, as we do not wish 
    // to delete them until we are sure regeneration went ok
    CTypedPtrArray <CPtrArray, BrushRef*> TempArray;
    
    TempArray.SetSize(MAX_BRUSH_OBJECTS, -1);

    // fill the array with our existing objects
    BrushRef* pRef = NULL;
    INT32 i = 0;
    for (i = 0; i < TempArray.GetSize(); i++)
    {
        pRef = m_BrushRefPtrArray[i];
        TempArray.SetAt(i, pRef);
        m_BrushRefPtrArray.SetAt(i, NULL); // set existing pointer to null
    }

    m_NumBrushObjects = 0;

    // now remake ourselves
    if  (GenerateBrush() == TRUE)
    {
        // delete the existing brushrefs
        for (i = 0; i < TempArray.GetSize(); i++)
        {
            if (TempArray[i] != NULL)
            {
                delete TempArray[i];
            }
        }
        TempArray.RemoveAll();
        
        return TRUE;
    }

    // ok so something went wrong, not much we can do except for restore the original objects
    // and hope for the best
    ERROR3("Uh oh - Regenerate Brush failed");
    pRef = NULL;
    i= 0;
    for (i = 0; i < TempArray.GetSize(); i++)
    {
        pRef = TempArray[i];
        m_BrushRefPtrArray.SetAt(i, pRef); // set existing pointer to null
        TempArray[i] = NULL;
    }
    */
    return TRUE;
}



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

>   BOOL BrushDefinition::IsActivated()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    13/12/99
    Inputs:     -
    Returns     the member indicating whether this definition is active
    Purpose:    To see if this definition was initialised ok or if it was subsequently deactivated
                for some reason

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

BOOL BrushDefinition::IsActivated()
{
    return m_bActivated;
}


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

>   void BrushDefinition::SetActivated(BOOL Value)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    13/12/99
    Inputs:     Value - the value to set
    Returns     -
    Purpose:    To set this definition activated or not

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

void BrushDefinition::SetActivated(BOOL Value)
{
    m_bActivated = Value;
}

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

>   BOOL BrushDefinition::AddNewObject(NodeRenderableInk* pInkNode)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    13/12/99
    Inputs:     pInkNode - node to add
    Returns     TRUE if successful, FALSE otherwise
    Purpose:    creates a brushref object from the inknode and its attributes, then adds the
                brushref to the member array

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

BOOL BrushDefinition::AddNewObject(NodeRenderableInk* pInkNode)
{

    if (pInkNode == NULL)
    {
        ERROR3("Ink node is NULL");
        return FALSE;
    }

    if (m_NumBrushObjects >= MAX_BRUSH_OBJECTS)
    {
        ERROR3("Cannot exceed MAX_BRUSH_OBJECTS");
        return FALSE;
    }

    BrushRef *pNewBrushRef = new BrushRef;

    if (pNewBrushRef == NULL)
    {
        ERROR3("Failed to allocate brushref");
        return FALSE;
    }
    

    
    if (!pNewBrushRef->Initialise(pInkNode))
    {
        ERROR3("Failed to initialise brushref");
        return FALSE;
    }

    m_BrushRefPtrArray[m_NumBrushObjects++] = pNewBrushRef;

    return TRUE;

}


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

>   void BrushDefinition::InitialiseBrushArray(UINT32 NumObjects)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    6/10/99
    Inputs:     Number of objects to size the array at
    Returns:    -
    Purpose:    Clears out the m_BrushRefPtrArray if it is not empty, and sets the size 

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

void BrushDefinition::InitialiseBrushArray(UINT32 NumObjects) 
{
    size_t              i = 0;
    while( i < m_BrushRefPtrArray.size() )
    {
        delete m_BrushRefPtrArray[i++];
    }
    m_BrushRefPtrArray.clear();

    m_BrushRefPtrArray.resize( NumObjects );

    // fill the array with NULL objects so that we can check later
    // to see if our allocations have worked
    i = 0;
    while( i < m_BrushRefPtrArray.size() )
    {
        m_BrushRefPtrArray[i++] = NULL;
    }

}


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

>   BOOL BrushDefinition::IsDifferent(BrushDefinition *pOther)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/12/99

    Inputs:     pOther - the Brush to compare this Brush to

    Returns:    TRUE if they're different in any way,
                FALSE if they are identical definitions

    Purpose:    Determine if 2 BrushDefinitions are considered different.
                Used when adding Brushes to the global list, so that like Brushes
                can be merged.

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

BOOL BrushDefinition::IsDifferent(LineDefinition *pOther)
{
    ERROR3IF(pOther == NULL, "Illegal NULL param");

//  String_32* pName = pOther->GetLineName();
    if (!m_Name.IsIdentical(*pOther->GetLineName()))
        return(TRUE);

    if (pOther->GetLineTree() == NULL || m_pTree == NULL)
    {
        ERROR3("BrushDefinition has not been properly initialised");
        return(TRUE);
    }

    /*
    // --- Check to see if the brush bounds are equal
    DocRect OtherBounds = ((Spread *)(pOther->GetLineTree()))->GetBoundingRect();
    DocRect Bounds = ((Spread *)m_pTree)->GetBoundingRect();
    if (Bounds != OtherBounds)
        return(TRUE);
    */
    // --- Check the subtrees node-for-node to see if they are the same
    Node *pCurNode1 = m_pTree->FindFirstDepthFirst();
    Node *pCurNode2 = pOther->GetLineTree()->FindFirstDepthFirst();

    while (pCurNode1 != NULL && pCurNode2 != NULL)
    {
        // if they are fill attributes then we want to translate both attributes to the origin.
        // This prevents us getting duplication of brushes when we have the 
        // same thing in a different place, note that occasionally this fails due to rounding errors.
        if (pCurNode1->IsAFillAttr() && pCurNode2->IsAFillAttr() && 
            !((AttrFillGeometry*)pCurNode1)->IsAStrokeColour() && 
            !((AttrFillGeometry*)pCurNode1)->IsAStrokeTransp())
        {
            AttrFillGeometry* pFill1 = (AttrFillGeometry*)pCurNode1;
            AttrFillGeometry* pFill2 = (AttrFillGeometry*)pCurNode2;
            DocCoord* pStartPoint1 = pFill1->GetStartPoint();
            DocCoord* pStartPoint2 = pFill2->GetStartPoint();
        
            // translate them both to 0,0
            if (pStartPoint1 && pStartPoint2)
            {
                Trans2DMatrix Trans1(-pStartPoint1->x, -pStartPoint1->y);
                Trans2DMatrix Trans2(-pStartPoint2->x, -pStartPoint2->y);
                pFill1->Transform(Trans1);
                pFill2->Transform(Trans2);
                BOOL Different = FALSE;
                if (pCurNode1->IsDifferent(pCurNode2))
                    Different = TRUE;

                Trans1.Invert();
                Trans2.Invert();
                pFill1->Transform(Trans1);
                pFill2->Transform(Trans2);
                if (Different == TRUE)
                    return TRUE;
            }

        }
        else
            // likewise if they are an object then translate from the centre of the bounding
            // rect to the origin
            if (pCurNode1->IsAnObject() && pCurNode2->IsAnObject())
            {
                NodeRenderableInk* pInk1 = (NodeRenderableInk*)pCurNode1;
                NodeRenderableInk* pInk2 = (NodeRenderableInk*)pCurNode2;
                DocRect BRect1 = ((NodeRenderableInk*)pCurNode1)->GetBoundingRect();
                DocRect BRect2 = ((NodeRenderableInk*)pCurNode2)->GetBoundingRect();
                DocCoord Coord1 = BRect1.Centre();
                DocCoord Coord2 = BRect2.Centre();
                Trans2DMatrix Trans1(-Coord1.x, -Coord1.y);
                Trans2DMatrix Trans2(-Coord2.x, -Coord2.y);
                pInk1->Transform(Trans1);
                pInk2->Transform(Trans2);
                BOOL Different = FALSE;
                if (pCurNode1->IsDifferent(pCurNode2))
                    Different = TRUE;
                
                Trans1.Invert();
                Trans2.Invert();
                pInk1->Transform(Trans1);
                pInk2->Transform(Trans2);
                if (Different ==TRUE)
                    return TRUE;
            }
        else 
        {
            // otherwise just use the regular == operator
            if (pCurNode1->IsDifferent(pCurNode2))
                return(TRUE);
        }

        // And go to the next node in both brushes
        pCurNode1 = pCurNode1->FindNextDepthFirst(m_pTree);
        pCurNode2 = pCurNode2->FindNextDepthFirst(pOther->GetLineTree());
    }

    if (!AreBrushParametersIdentical((BrushDefinition*)pOther))
        return TRUE;

    // If we did the entire search and both pointers ended up NULL simultaneously, then
    // we have an exact match
    if (pCurNode1 == NULL && pCurNode2 == NULL)
        return(FALSE);

    return(TRUE);
}


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

>   BOOL BrushDefinition::IsDifferent(BrushDefinition *pOther)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/12/99

    Inputs:     pOther - the Brush to compare this Brush to

    Returns:    TRUE if they're different 
                FALSE if they are identical 

    Purpose:    Compares the member variables of the two brushes

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

BOOL BrushDefinition::AreBrushParametersIdentical(BrushDefinition* pOther)
{
    if (m_BrushSpacing          != pOther->m_BrushSpacing           ||
        m_BrushSpacingIncrProp  != pOther->m_BrushSpacingIncrProp   ||
        m_BrushSpacingIncrConst != pOther->m_BrushSpacingIncrConst  ||
        m_BrushSpacingMaxRand   != pOther->m_BrushSpacingMaxRand    ||
        m_BrushSpacingRandSeed  != pOther->m_BrushSpacingRandSeed   ||
        m_SpacingMaxPressure    != pOther->m_SpacingMaxPressure     ||
        
        m_bTile                 != pOther->m_bTile                  ||
        m_bRotate               != pOther->m_bRotate                ||
        
        m_RotateAngle           != pOther->m_RotateAngle            ||
        m_RotAngleIncrProp      != pOther->m_RotAngleIncrProp       ||
        m_RotAngleIncrConst     != pOther->m_RotAngleIncrConst      ||
        m_RotationMaxRand       != pOther->m_RotationMaxRand        ||
        m_RotationRandSeed      != pOther->m_RotationRandSeed       ||
        m_RotationMaxPressure   != pOther->m_RotationMaxPressure    ||

        m_PathOffsetType        != pOther->m_PathOffsetType         ||
        m_PathOffsetValue       != pOther->m_PathOffsetValue        ||
        m_PathOffsetIncrProp    != pOther->m_PathOffsetIncrProp     ||
        m_PathOffsetIncrConst   != pOther->m_PathOffsetIncrConst    ||
        m_OffsetTypeRandSeed    != pOther->m_OffsetTypeRandSeed     ||
        m_OffsetValueMaxRand    != pOther->m_OffsetValueMaxRand     ||
        m_OffsetValueRandSeed   != pOther->m_OffsetValueRandSeed    ||
        
        m_BrushScaling          != pOther->m_BrushScaling           ||
        m_BrushScalingIncr      != pOther->m_BrushScalingIncr       ||
        m_BrushScalingIncrConst != pOther->m_BrushScalingIncrConst  ||
        m_BrushScalingMaxRand   != pOther->m_BrushScalingMaxRand    ||
        m_BrushScalingRandSeed  != pOther->m_BrushScalingRandSeed   ||
        m_ScalingMaxPressure    != pOther->m_ScalingMaxPressure     ||

        m_BrushHueIncrement     != pOther->m_BrushHueIncrement      ||
        m_BrushHueMaxRand       != pOther->m_BrushHueMaxRand        ||
        m_BrushHueRandSeed      != pOther->m_BrushHueRandSeed       ||
        m_HueMaxPressure        != pOther->m_HueMaxPressure         ||

        m_BrushSatIncrement     != pOther->m_BrushSatIncrement      ||
        m_BrushSatMaxRand       != pOther->m_BrushSatMaxRand        ||
        m_BrushSatRandSeed      != pOther->m_BrushSatRandSeed       ||
        m_SatMaxPressure        != pOther->m_SatMaxPressure         ||

        m_SequenceType          != pOther->m_SequenceType           ||
        m_SequenceRandSeed      != pOther->m_SequenceRandSeed       ||

        m_TimeStampPeriod       != pOther->m_TimeStampPeriod)
        return FALSE;
    else
        return TRUE;
}


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

>   BrushDefinition* BrushDefinition::Copy()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/5/2000

    Inputs:     -

    Returns:    Pointer to new brush definition if succesful, NULL if it fails
    Purpose:    Makes a copy of this definition, inknodes and all.
    
********************************************************************************************/

BrushDefinition* BrushDefinition::Copy()
{   
    // we need to make a range in order to copy the nodes to the new brush definition
    // so we need the start and end nodes of the range
    Node* pStart = NULL;
    Node* pNext = NULL;
    Node* pLast = NULL;

    // don't forget we start on a spread
    Node* pTree = GetLineTree();
    if (pTree != NULL)
        pTree = pTree->FindFirstChild();  // get the layer
    if (pTree != NULL)
            pTree = pTree->FindFirstChild();  // get the first ink object
    
    if (pTree == NULL)
    {
        ERROR3("Tree node is NULL in BrushDefinition::Copy()");
        return NULL;
    }
    
    pNext = pStart = pTree;
    while (pNext != NULL)
    {
        pNext->SetSelected(FALSE);  // we need to do this so that Range::FindFirst doesn't return NULL
        pLast = pNext;
        pNext = pLast->FindNext();
    }


    // make a range out of our subtree as thats the easiest way to copy all the nodes
    RangeControl rc;
    rc.Unselected = TRUE;
    rc.Selected = FALSE;
    Range BrushRange(pStart, pLast, rc);
    
    // make a new spread to attach our copy tree to
    Spread* pSpread = new Spread;
    if (pSpread == NULL)
    {
        ERROR3("Failed to allocate spread in BrushDefinition::Copy");
        return NULL;
    }

    Layer              *pLayer = new Layer( pSpread, FIRSTCHILD, String_256( TEXT("Diccon did this") ) );
    if (pLayer == NULL)
    {
        ERROR3("Failed to allocate layer in BrushDefinition::Copy");
        delete pSpread;
        return NULL;
    }

    // we need to reset our attributes in the same way that we need to with exporting.
    // If we don't do this then attributes with control points end up vanishing
    PreExportSubTree();

    if (!pLayer->CopyComplexRange(BrushRange))
    {
        ERROR3("Failed to copy range in BrushDefinition::Copy");
        delete pSpread;
        delete pLayer;
        return NULL;
    }

    PostExportSubTree();

    // lets allocate ourselves a new empty definition
    BrushDefinition* pNewBrushDef = new BrushDefinition(pSpread);

    if (pNewBrushDef == NULL)
    {
        ERROR3("Failed to allocate brush definition in BrushDefinition* BrushDefinition::Copy");
        delete pSpread;
        delete pLayer;
        return NULL;
    }

    if (!pNewBrushDef->IsActivated())
    {
        ERROR3("Brush definition failed to initialise");
        delete pNewBrushDef;
        delete pSpread;
        delete pLayer;
        return NULL;
    }

    return pNewBrushDef;
}

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

>   BOOL BrushDefinition::UsesPressure()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    16/6/2000
    Inputs:     -
    Returns     TRUE if this brush has one of its pressure variables set
    Purpose:    as above
***********************************************************************************************/

BOOL BrushDefinition::UsesPressure()
{
    if (m_ScalingMaxPressure != 0  ||
        m_RotationMaxPressure != 0 ||
        m_TranspMaxPressure != 0)
        return TRUE;

    return FALSE;
}


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

>   static BOOL BrushDefinition::ObjectCanCreateBrush(NodeRenderableInk* pObject)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    16/6/2000
    Inputs:     pObject - the object to test
    Returns     TRUE if we are allowed to make a brush out of this object, FALSE otherwise
    Purpose:    To determine if this ink node can be made into a brush, currently returns TRUE for
                except for bevels, shadows, and contours, which are too damn awkward.
***********************************************************************************************/

BOOL BrushDefinition::ObjectCanCreateBrush(NodeRenderableInk* pObject)
{
    ERROR2IF(pObject == NULL, FALSE, "Object is NULL in BrushDefinition::ObjectCanCreateBrush");

    // only way to do it is some ugly IKO's
    if (pObject->IS_KIND_OF(NodeShadow))
        return FALSE;
    if (pObject->IS_KIND_OF(NodeContour))
        return FALSE;
    if (pObject->IS_KIND_OF(NodeBevel))
        return FALSE;

    // if its compound then check all the children
    if (pObject->IsCompound())
    {
        Node* pChild = pObject->FindFirstChild();
        while (pChild)
        {
            if (pChild->IsAnObject())
            {
                if (!ObjectCanCreateBrush((NodeRenderableInk*)pChild))
                    return FALSE;
            }
            pChild = pChild->FindNext();
        }
    }

    return TRUE;

}


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

>    BOOL BrushDefinition::StartRender()

     Author:    Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
     Created:   4/9/2000
     Inputs:    -
     Outputs:   -
     Returns:   TRUE if successful, FALSE if not.  If we return FALSE then don't even think
                about rendering with this brush.

     Purpose:   Basically due to imprecision in the arithmetic system we ended up corrupting the
                brush data if we used it too much.  So to get around this we never transform
                the original brush data, instead we make copies of it each time we want to render
                a version of this brush.
                This function generates the data copies that we need to render this brush, make 
                sure you call StopRender() to get rid of them.
**********************************************************************************************/
       
BOOL BrushDefinition::StartRender()
{
    BrushRef* pBrushRef = GetFirstBrushRef();
    BOOL ok = TRUE;
    while (pBrushRef != NULL)
    {
        if (ok)
            ok = pBrushRef->MakeCopiesForRendering();
        pBrushRef = GetNextBrushRef();
    }

    return ok;
    
}



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

>    void BrushDefinition::StopRender()

     Author:    Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
     Created:   4/9/2000
     Inputs:    -
     Outputs:   -
     Returns:   -

     Purpose:   Call this when you have finished rendering a node with this brush, it deletes
                the copied data that we used for rendering
**********************************************************************************************/
       
void BrushDefinition::StopRender()
{
    BrushRef* pBrushRef = GetFirstBrushRef();
    while (pBrushRef != NULL)
    {
        pBrushRef->DeleteRenderCopies();
        pBrushRef = GetNextBrushRef();
    }

    return;

}

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

>   void BrushDefinition::CalculateMaxScaling()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    13/12/99
    Inputs:     -
    Returns     -
    Purpose:    Calculates the maximum scaling value possible by dividing the maximum size value by
                the longest side of the bounding rect of the largest object
***********************************************************************************************/

void BrushDefinition::CalculateMaxScaling()
{
    DocRect BRect = GetLargestBoundingBox();
    if (BRect.IsEmpty())
    {
        //ERROR3("Bounding rect is empty in BrushDefinition::CalculateMaxScaling");
        return;
    }
    MILLIPOINT LongestSide = BRect.Height() > BRect.Width() ? BRect.Height() : BRect.Width();
    m_MaxScaling = MAX_BRUSH_SIZE  / LongestSide;

}


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

>   double BrushDefinition::GetMaxScaling()

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    13/12/99
    Inputs:     -
    Returns     the maximum scaling value
    Purpose:    as above
***********************************************************************************************/

double BrushDefinition::GetMaxScaling()
{
    return m_MaxScaling;
}

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

>   BOOL BrushDefinition::SetBrushSpacing(double Spacing) 

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/10/99
    Inputs:     the spacing value to set
    Returns:    TRUE if successful, FALSE if the spacing is invalid 
    Purpose:    To set the spacing between brush objects
    SeeAlso:    -

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

BOOL BrushDefinition::SetSpacing(MILLIPOINT Spacing)
{
    if (Spacing < MIN_BRUSH_SPACING || Spacing > MAX_BRUSH_SPACING)
        return FALSE;
    
    m_BrushSpacing = Spacing;

    return TRUE;

}



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

>   MILLIPOINT BrushDefinition::GetBrushSpacing() 

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/10/99
    Returns:    the spacing between the brush objects 
    Purpose:    As above

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

MILLIPOINT BrushDefinition::GetSpacing()
{
    return m_BrushSpacing;
}



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

>   BOOL PathProcessorBrush::SetSpacingIncrProp(double Incr) 

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/10/99
    Inputs:     the spacing increment value to set
    Returns:    TRUE if we can draw 10 objects, FALSE if the spacing is invalid 
    Purpose:    To set the proportional spacing increment between brush objects
    SeeAlso:    -

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

BOOL BrushDefinition::SetSpacingIncrProp(double Incr)
{
    if (Incr <= 0)
        return FALSE;
    
    if (Incr != 1.0)
    {
        double TenIncr = pow(Incr, 10.0);
        double TenthSpacing = m_BrushSpacing * TenIncr;
        if (TenthSpacing >= MAX_BRUSH_SPACING || TenthSpacing < MIN_BRUSH_SPACING)
        {
            ERROR3("Illegal increment value");
            return FALSE;
        }
    }
    m_BrushSpacingIncrProp = Incr;
    return TRUE;
}



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

>   MILLIPOINT BrushDefinition::GetSpacingIncrProp() 

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/10/99
    Returns:    the proportional spacing increment between the brush objects 
    Purpose:    As above

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

double BrushDefinition::GetSpacingIncrProp()
{
    return m_BrushSpacingIncrProp;
}


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

>   BOOL PathProcessorBrush::SetSpacingIncrConst(MILLIPOINT Incr) 

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/10/99
    Inputs:     the constant spacing increment value to set
    Returns:    TRUE if we can draw 10 objects, FALSE if the spacing is invalid 
    Purpose:    To set the proportional spacing increment between brush objects
    SeeAlso:    -

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

BOOL BrushDefinition::SetSpacingIncrConst(MILLIPOIN