cmxdcobj.cpp

Go to the documentation of this file.

// $Id: cmxdcobj.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============================
 */
// CMXExportDC object output routines

#include "camtypes.h"
#include "cmxexdc.h"
#include "cmxrendr.h"
#include "cmxform.h"
//#include "docrect.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fillval.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "colcontx.h"
//#include "nev.h"
//#include "cmxres.h"
#include "fillramp.h"


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

>   BOOL CMXExportDC::WriteBlankAttributes(INT32 Tag)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/07/96
    Inputs:     render region
    Returns:    success
    Purpose:    writes a blank attribute tag and contents, which specifies nothing but
                keeps everything happy

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

BOOL CMXExportDC::WriteBlankAttributes(INT32 Tag)
{
    // start the tag
    if(Tag != -1)
        if(!StartTag(Tag))
            return FALSE;

    // write the attribute mask thingy
    WriteByte(0);

    // end the tag
    if(Tag != -1)
        if(!EndTag())
            return FALSE;
    
    return TRUE;
}


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

>   BOOL CMXExportDC::WriteAttributes(CMXRenderRegion *pReg, INT32 Tag, DocCoord *Coords, INT32 NumCoords, BOOL ForceNoFill = FALSE)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    01/07/96
    Inputs:     render region
    Returns:    success
    Purpose:    Writes the attributes to the DC.
                if ForceNoFill == TRUE, the path will not be filled whatever the colour

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

BOOL CMXExportDC::WriteAttributes(CMXRenderRegion *pReg, INT32 Tag, DocCoord *Coords, INT32 NumCoords, BOOL ForceNoFill)
{
    // give lenses a chance
    BOOL WasLens = FALSE;
    if(!WriteAttrCheckLens(pReg, Tag, Coords, NumCoords, &WasLens))
        return FALSE;

    // now did the lens checking bit output something?
    if(WasLens)
        return TRUE;        // yep, so we don't want to output them too

    // start the tag
    if(Tag != -1)
        if(!StartTag(Tag))
            return FALSE;

    // write the attribute mask thingy
    WriteByte((ForceNoFill?0:cmxRENDATTRMASK_FILL) | cmxRENDATTRMASK_OUTLINE);

    // write the fill specification
    if(!ForceNoFill)
        if(!WriteFillSpec(pReg, Coords, NumCoords, ForceNoFill))
            return FALSE;

    // write the outline specification
    if(!WriteOutlineSpec(pReg))
        return FALSE;

    // end the tag
    if(Tag != -1)
        if(!EndTag())
            return FALSE;
    
    return TRUE;
}


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

>   BOOL CMXExportDC::WriteFillType(WORD FillID)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    04/07/96
    Inputs:     fill type
    Returns:    success
    Purpose:    Writes the fill type to the DC

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

BOOL CMXExportDC::WriteFillType(WORD FillID)
{
    ExportFile->write(&FillID, sizeof(FillID));

    return TRUE;
}


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

>   BOOL CMXExportDC::WriteFillSpec(CMXRenderRegion *pReg)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    04/07/96
    Inputs:     render region
    Returns:    success
    Purpose:    Writes the fill specifcation to the DC

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

BOOL CMXExportDC::WriteFillSpec(CMXRenderRegion *pReg, DocCoord *Coords, INT32 NumCoords, BOOL NoFill)
{
    // tag the start
    if(!StartNestedTag(cmxTAG_RenderAttr_FillSpec))
        return FALSE;

    if(NoFill)
    {
        if(!WriteFillType(cmxFILLID_NONE))
            return FALSE;
    }
    else
    {
        // get the attribute
        FillGeometryAttribute *pFillGeometry
                = (FillGeometryAttribute *)pReg->GetCurrentAttribute(ATTR_FILLGEOMETRY);

        // check it out
        ERROR2IF(pFillGeometry == 0, FALSE, "No fill geometry");
        ERROR3IF(!pFillGeometry->IsKindOf(CC_RUNTIME_CLASS(FillGeometryAttribute)), "not one of them there fill geometries");

        // right then, decide what to do with the thingy
        if(pFillGeometry->IsAFlatFill())
        {
            // flat fill -- check to see if it's transparent
            DocColour *pCol = pFillGeometry->GetStartColour();
            ERROR2IF(pCol == NULL, FALSE, "not one of your earth colours");
            if(pCol->IsTransparent())
            {
                // it's transparent, write no fill
                if(!WriteFillType(cmxFILLID_NONE))
                    return FALSE;
            }
            else
            {
                // it's OK, it is. Write it.
                if(!WriteFillType(cmxFILLID_UNIFORM)
                    || !WriteFillSpecFlat(pReg, pFillGeometry))
                    return FALSE;
            }
        }
        else if(pFillGeometry->IsAKindOfBitmapFill())
        {
            // bitmap type fill -- do nothing for now
            if(!WriteFillType(9) //cmxFILLID_COLPATTERN)
                || !WriteFillSpecBitmap(pReg, pFillGeometry, Coords, NumCoords))
                return FALSE;
        }
        else if(pFillGeometry->IsAGradFill())
        {
            // grad fill
            if(!WriteFillType(cmxFILLID_FOUNTAIN)
                || !WriteFillSpecGrad(pReg, pFillGeometry, Coords, NumCoords))
                return FALSE;
        }
        else
        {
            // catch all -- write a no fill thingy
            if(!WriteFillType(cmxFILLID_NONE))
                return FALSE;
        }
    }

    // end the tag
    if(!EndNestedTag())
        return FALSE;
    
    // write the end tag
    if(!WriteMinEndTag())
        return FALSE;

    return TRUE;
}

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

>   BOOL CMXExportDC::WriteFillSpecFlat(CMXRenderRegion *pReg, FillGeometryAttribute *pFill)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    04/07/96
    Inputs:     render region
    Returns:    success
    Purpose:    Writes the flat fill specifcation to the DC

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

BOOL CMXExportDC::WriteFillSpecFlat(CMXRenderRegion *pReg, FillGeometryAttribute *pFill)
{
    // get the colour
    DocColour *pFillColour = pFill->GetStartColour();
    ERROR2IF(pFillColour == NULL, FALSE, "Wibble. No fill colour on this here flat fill");

    // find a reference for it
    WORD FillReference = GetColourReference(pFillColour);

    // write some stuff
    struct {
        WORD FillReference;
        WORD ScreenReference;
    } filldef = {FillReference, cmxSCREENREFERENCE};

    if(!WriteNestedTag(cmxTAG_RenderAttr_FillSpec_Uniform, &filldef, sizeof(filldef))
        || !WriteMinEndTag())
        return FALSE;

    return TRUE;
}


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

>   BOOL CMXExportDC::WriteFillSpecGrad ( CMXRenderRegion *pReg,
                                          FillGeometryAttribute *pFill,
                                          DocCoord *Coords,
                                          INT32 NumCoords )

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/07/96
    Inputs:     render region
    Returns:    success
    Purpose:    Writes the grad fill specifcation to the DC

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

BOOL CMXExportDC::WriteFillSpecGrad ( CMXRenderRegion *pReg,
                                      FillGeometryAttribute *pFill,
                                      DocCoord *Coords,
                                      INT32 NumCoords )
{
    DocColour   StartColour;                // The first colour in the fill.
    DocColour   EndColour;                  // The end colour of the fill.
    DocColour   MidColour;                  // Only used to approximate four colour fills.
    BOOL        Radial          = FALSE;    // Is it a radial fill?
    BOOL        FourColour      = FALSE;    // Is it a four colour fill?

    // is this a radial type derivative?
    if ( pFill->IsARadialFill () )
    {
        // We need to swap the colours over as Corel has a different idea
        // of start and finish colours to Camelot.
        StartColour = *( pFill->GetEndColour () );
        EndColour   = *( pFill->GetStartColour () );

        Radial = TRUE;
    }
    else if ( pFill->IsAConicalFill () || pFill->IsASquareFill () )
    {
        // Set up the colour values.
        StartColour = *( pFill->GetStartColour () );
        EndColour   = *( pFill->GetEndColour () );

        Radial = TRUE;
    }
    else if ( pFill->IsAFourColFill () )
    {
        // Set up the start and end colours as usual, but create a third colour value to
        // help fake the four colour fill.
        StartColour = *( pFill->GetStartColour () );
        EndColour   = *( pFill->GetEndColour3 () );
        MidColour.Mix ( pFill->GetEndColour (), pFill->GetEndColour2 (), 0.5f, NULL, FALSE, NULL );

        // Reset the four colour flag.
        FourColour  = TRUE;
    }
    else if ( pFill->IsAThreeColFill () )
    {
        // Set up the colour values. I'm blending the colours of the two endpoints
        // to get a better approximation of a three colour fill.
        StartColour = *( pFill->GetStartColour () );
        EndColour.Mix ( pFill->GetEndColour (), pFill->GetEndColour2 (), 0.5f, NULL, FALSE, NULL );
    }
    else
    {
        // Default behaviour: Store the start and end colours.
        StartColour = *( pFill->GetStartColour () );
        EndColour   = *( pFill->GetEndColour () );
    }

    // Find references for the color, and sort out the fill effect.
    WORD    StartColReference   = GetColourReference ( &StartColour );
    WORD    EndColReference     = GetColourReference ( &EndColour );
    WORD    MidColReference     = 0;
    WORD    FillMode            = cmxFILLMODE_RGB;

    // Get a colour reference to MidColour if it's been declared. (i.e. the fill is a
    // four colour fill.)
    if ( FourColour )
    {
        MidColReference = GetColourReference ( &MidColour );
    }

    // get the fill effect attribute
    FillEffectAttribute *pFillEff =
        (FillEffectAttribute *)pReg->GetCurrentAttribute(ATTR_FILLEFFECT);
    ERROR2IF(pFillEff == NULL || !pFillEff->IsKindOf(CC_RUNTIME_CLASS(FillEffectAttribute)), FALSE, "not a fill effect");
    BOOL Rainbow = FALSE, Alt = FALSE;
    if(IS_A(pFillEff, FillEffectRainbowAttribute))
        Rainbow = TRUE;
    if(IS_A(pFillEff, FillEffectAltRainbowAttribute))
        Rainbow = Alt = TRUE;

    if(Rainbow)
    {
        // right, we need to work out which direction we want the colour to go
        // around the HSV colour wheel. Convert both colours to HSV.
        ColourContext *Conv = ColourContext::GetGlobalDefault(COLOURMODEL_HSVT);

        ColourHSVT StartC;
        ColourHSVT EndC;

        Conv->ConvertColour( &StartColour, (ColourGeneric *)&StartC);
        Conv->ConvertColour( &EndColour, (ColourGeneric *)&EndC);

        // compare the hues and work out a difference
        double Difference = (EndC.Hue.MakeDouble()) - (StartC.Hue.MakeDouble());

        BOOL ClockWise = (Difference < 0);

        if(fabs(Difference) >= 0.5)
            ClockWise = !ClockWise;

        if(Alt = TRUE)
            ClockWise = !ClockWise;
        
        // set the correct thingy attribute
        if(ClockWise)
            FillMode = cmxFILLMODE_HSB_CW;
        else
            FillMode = cmxFILLMODE_HSB_CCW;
    }

    // find the start and end coords of the fill
    DocCoord StartPoint = *( pFill->GetStartPoint() );
    DocCoord EndPoint;

    // Graeme (18-2-00) - Modifications to handle three and four colour fills better.
    if ( pFill->IsAFourColFill () )
    {
        // Use EndPoint3 to get a diagonal across the bounding box.
        EndPoint = *( pFill->GetEndPoint3 () );
    }
    else if ( pFill->IsAThreeColFill () )
    {
        // Merge the existing two endpoints to get the correct endpoint for the fill.
        EndPoint = *( pFill->GetEndPoint () ) +
                   *( pFill->GetEndPoint2 () ) -
                   *( pFill->GetStartPoint () );
    }
    else
    {
        // Default: Use the standard endpoint.
        EndPoint = *( pFill->GetEndPoint () );
    }


    // find the corel bounding box of the path we're about to fiddle with
    DocRect cBBox;
    CalcCorelBBox(Coords, NumCoords, &cBBox);

    // run the chicken out clause for extreme cases I can't be bothered to handle
    if ( StartPoint == EndPoint || cBBox.Width () == 0 || cBBox.Height () == 0 )
        return WriteFillSpecFlat(pReg, pFill);

    // calc the central coord
    DocCoord Centre;
    Centre.x = cBBox.lo.x + cBBox.Width() / 2;
    Centre.y = cBBox.lo.y + cBBox.Height() / 2;

    // calc the fill parameters

    // first work out the distance between the start and end points
    double dx = EndPoint.x - StartPoint.x;
    double dy = EndPoint.y - StartPoint.y;
    double PointDist = sqrt(((dx * dx) + (dy * dy)));

    // now we need to work out the angle of the fill
    double Angle = atan2(dy, dx);
        // atan2 is defined if dx == 0
        // but not at the origin -- however we've filtered out this case

    INT32 StartPercent;
    INT32 EndPercent;

    cmxFillBase1 fb1;
    fb1.Padding = 0;
    cmxFillBase2 fb2;
    fb2.XOffset = 0;
    fb2.YOffset = 0;

    if(Radial)
    {
        //------------------------------------------------- radial type fill calucations

        // ...and for my first trick, I will calculate the X and Y
        // offsets of the centre of this fill
        DocCoord dCentre = StartPoint - Centre;
        fb2.XOffset = (dCentre.x * 100) / cBBox.Width();
        fb2.YOffset = (dCentre.y * 100) / cBBox.Height();
        // get these values within the required range
        if(fb2.XOffset > 100) fb2.XOffset = 100;
        if(fb2.XOffset < -100) fb2.XOffset = -100;
        if(fb2.YOffset > 100) fb2.YOffset = 100;
        if(fb2.YOffset < -100) fb2.YOffset = -100;

        // now this is the scary bit. Corel use a complex method for specifing
        // their radial type fills. 
        double w = cBBox.Width(), h = cBBox.Height();
        double bboxdiagonal = sqrt(w*w + h*h);
        double cdx = dCentre.x, cdy = dCentre.y;
        double cendist = sqrt(cdx*cdx + cdy*cdy);
        double BodgeFactor = 1 + (cendist / (bboxdiagonal / 2));
        double targetradius = PointDist / BodgeFactor;
        double Pad = 50 * (1 - (2 * targetradius) / bboxdiagonal);
        // munge the Pad value to the allowed range
        if(Pad < 0) Pad = 0;
        if(Pad > 44) Pad = 44;
        // and bung in the structure for export
        fb1.Padding = (WORD)Pad;

        // set the percentages to 0
        StartPercent = 0;
        EndPercent = 0;

        // if it's a square fill, swap the colours over
        if(pFill->IsASquareFill())
        {
            WORD t = StartColReference;
            StartColReference = EndColReference;
            EndColReference = t;
        }
    } // if ( Radial )

    else // if ( !Radial )
    {
        //------------------------------------------------- linear type fill calucations

        // now work out the coords of the intersection of a line through the
        // centre of the bbox and the edges of the bbox

        // right then, we want the angle within 0 and PI/2
        double cAngle = Angle;
        INT32 cAR = 0;
        while(cAngle > (PI/2))
        {
            cAngle -= PI/2;
            cAR++;
        }

        // luckily, everything is symmetrical so all we need do is calc the
        // intersect in the top quadrant.
        INT32 qdx = cBBox.Width() / 2;
        INT32 qdy = cBBox.Height() / 2;
        if((cAR & 1) != 0)
        {
            // we rotated by an odd multiple of PI/2 radians. Rotate the box as well.
            INT32 t = qdy;
            qdy = qdx;
            qdx = t;
        }
        DocCoord i;
        if(qdy == 0)
        {
            // special case to avoid division by tan(0) = 0
            i.x = qdx;
            i.y = 0;
        }
        else
        {
            double predqdy = qdx * tan(cAngle);
            if(predqdy > qdy)
            {
                // intersects on the horizontal
                i.x = (INT32)(((double)qdy) / tan(cAngle));
                i.y = qdy;
            }
            else
            {
                // intersects on the vertical
                i.x = qdx;
                i.y = (INT32)(((double)qdx) * tan(cAngle));
            }
        }

        // i is the offset from the centre of the bbox where the line of the
        // grad fill rotated to the top right quadrent intersects with the
        // rectange of the bounding box.

        // now we need to work out the percentages along this line of the start
        // and stop bit.
        INT32 linelength = (INT32)sqrt(((double)(i.x) * (double)(i.x)) + ((double)(i.y) * (double)(i.y)));
        // chicken out clause #2
        if(linelength == 0)
            return WriteFillSpecFlat(pReg, pFill);

        // work out the start and end points as offsets from the centre point
        DocCoord    dStartPoint = StartPoint - Centre;
        DocCoord    dEndPoint   = EndPoint - Centre;

        // rotate these points around the origin
        // TODO: do the rotation myself, instead of going through matrices
        Matrix Mat(((- Angle) * 360.0) / (2*PI));   // why can't people use proper measure? 
        Mat.transform(&dStartPoint);
        Mat.transform(&dEndPoint);

        // find out the smallest distance from the end of the line
        INT32 dStart = dStartPoint.x + linelength;
        INT32 dEnd = linelength - dEndPoint.x;
        if(dStart < 0) dStart = 0;
        if(dEnd < 0) dEnd = 0;
        INT32 dPad;     // smallest of dStart and dEnd
        if(dStart < dEnd)
            dPad = dStart;
        else
            dPad = dEnd;

        INT32 padval = (dPad * 100) / (linelength * 2);
        if(padval < 0) padval = 0;
        if(padval > 44) padval = 44;
        fb1.Padding = (WORD)padval;
        
        // right, now munge the line length value to take account of this padding
        linelength -= dPad;

        // right then, we can now simply compare the x coords of the start and end
        // with the linelength above to find the start and end percentages
        StartPercent = (INT32)((dStartPoint.x + linelength) * 100);
        EndPercent = (INT32)((dEndPoint.x + linelength) * 100);
        StartPercent /= (linelength * 2);
        EndPercent /= (linelength * 2);

        // sanity check the numbers so Corel is happy
        if(StartPercent < 0) StartPercent = 0;
        if(StartPercent > 100) StartPercent = 100;
        if(EndPercent < 0) EndPercent = 0;
        if(EndPercent > 100) EndPercent = 100;
        if(EndPercent < StartPercent)
        {
            INT32 t = StartPercent;
            StartPercent = EndPercent;
            EndPercent = t;
        }
    } // else if ( !Radial )

    // I allege we now know enough to get this thing to the file
    // start the tag
    if(!StartNestedTag(cmxTAG_RenderAttr_FillSpec_Fountain_Base))
        return FALSE;

    if(pFill->IsARadialFill())
        fb1.Type = cmxFOUNTAINTYPE_RADIAL;
    else if(pFill->IsASquareFill())
        fb1.Type = cmxFOUNTAINTYPE_SQUARE;
    else if(pFill->IsAConicalFill())
        fb1.Type = cmxFOUNTAINTYPE_CONICAL;
    else
        fb1.Type = cmxFOUNTAINTYPE_LINEAR;
    fb1.Screen = cmxSCREENREFERENCE;
    // padding set earlier

    // offsets set earlier
    fb2.StepCount = 0;
    fb2.FillMode = FillMode;
    fb2.RateMethod = 0;
    fb2.RateValue = 50;         // 50% is the centre, a commonly held belief

    if(!Radial)
    {
        if(FillMode == cmxFILLMODE_RGB)
        {
            // if it's an RGB mix in a linear fill, we can accurately
            // specify the fill by using a custom fill mode, and specifing
            // the end points presicely.
            fb2.FillMode = cmxFILLMODE_CUSTOM;
        }
        else
        {
            // if it's not an RGB mix, we need to approximate the fill using the
            // padding (set already) as we can't specify where we want the
            // colours to start and finish along the line of the fill
            StartPercent = 0;
            EndPercent = 0;
        }
    }

    // write the data
    ExportFile->write(&fb1, sizeof(fb1));

    WriteAngle(Angle);

    if(ThirtyTwoBit)
    {
        ExportFile->write(&fb2, sizeof(fb2));
    }
    else
    {
        // OK, so this way is a bit of a bodge
        cmxFillBase2_16 b = {0, (SWORD)fb2.XOffset, (SWORD)fb2.YOffset,
            fb2.StepCount, fb2.FillMode};

        ExportFile->write(&b, sizeof(b));
    }

    // end the tag
    if(!EndNestedTag())
        return FALSE;

    // write the colours
    if(!StartNestedTag(cmxTAG_RenderAttr_FillSpec_Fountain_Color))
        return FALSE;

    cmxGradFillColour   col;
    ColourRamp          *pRamp  = pFill->GetColourRamp ();
    WORD                NCol    = 2 + ( ( StartPercent != 0 ) ? 1 : 0 ) +
                                  ( ( EndPercent != 100 ) ? 1 : 0 ) + ( FourColour ? 1 : 0 );

    // If the fill has a colour ramp, calculate the number of entries within it.
    if ( pRamp != NULL )
    {
        UINT32  FirstIndex  = 0;
        UINT32  LastIndex   = 0;

        // Call a member function to get the indices to the first and last elements within
        // the colour ramp.
        pRamp->GetIndexRange ( &FirstIndex, &LastIndex );

        // Add the difference between these to the number of colours to be exported. The +1
        // in this sum is necessary since the index values include the number of the element
        // that they represent. E.g. for a one element ramp, we have 1024 for both the first
        // and last items. Thus, without the +1, we would get 0 colours in the index.
        NCol += 1 + LastIndex - FirstIndex;
    }

    // Write the number of colours.
    ExportFile->write ( &NCol, sizeof ( NCol ) );

    // Write as many colours as necessary to get accurate fills. First the start colour.
    if(StartPercent != 0)
    {
        col.ColRef = StartColReference;
        col.ColPos = 0;
        ExportFile->write(&col, sizeof(col));
    }

    col.ColRef = StartColReference;
    col.ColPos = (WORD)StartPercent;
    ExportFile->write(&col, sizeof(col));

    // If it's a four colour fill, add the middle colour to the mix.
    if ( FourColour )
    {
        col.ColRef  = MidColReference;
        col.ColPos  = ( WORD ) ( ( StartPercent + EndPercent ) / 2 );
        ExportFile->write ( &col, sizeof ( col ) );
    }

    // Process the colour ramp.
    if ( pRamp != NULL )
    {
        ColRampItem *pColour = pRamp->GetFirstCol ();

        // Write in the ramp's colour values.
        while ( pColour != NULL )
        {
            cmxGradFillColour   RampColour;

            // Get the position of the colour in the fill.
            RampColour.ColPos   = ( WORD ) ( 100.0f * pColour->GetPosition () );
            RampColour.ColRef   = GetColourReference ( &( pColour->GetColour () ) );

            // Write the colour.
            ExportFile->write ( &RampColour, sizeof ( RampColour ) );

            // Increment the pointer onto the next item.
            pColour = pRamp->GetNextCol ( pColour );
        }
    }

    // And finally the end colour.
    col.ColRef = EndColReference;
    col.ColPos = (WORD)EndPercent;
    ExportFile->write(&col, sizeof(col));

    if(EndPercent != 100)
    {
        col.ColPos = 100;
        ExportFile->write(&col, sizeof(col));
    }

    if(!EndNestedTag())
        return FALSE;

    // write the ending bit
    if(!WriteMinEndTag())
        return FALSE;

    return TRUE;
}


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

>   BOOL CMXExportDC::WriteFillSpecBitmap(CMXRenderRegion *pReg, FillGeometryAttribute *pFill, DocCoord *Coords, INT32 NumCoords)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/07/96
    Inputs:     render region
    Returns:    success
    Purpose:    Writes the bitmap fill specifcation to the DC (also does fractals)

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

BOOL CMXExportDC::WriteFillSpecBitmap(CMXRenderRegion *pReg, FillGeometryAttribute *pFill, DocCoord *Coords, INT32 NumCoords)
{
    // make up a bitmap fill object -- first find the refer bitmap object necessary
    BitmapFillAttribute *pBFillAttr = (BitmapFillAttribute *)pFill;
    ERROR3IF(!pBFillAttr->IsKindOf(CC_RUNTIME_CLASS(BitmapFillAttribute)), "not a bitmap fill attr");

    // colours
    DocColour *pStartColour = 0;
    DocColour *pEndColour = 0;
    EFFECTTYPE Effect = EFFECT_RGB;

    // get the colours we should use, and the fill effect
    pStartColour = pFill->GetStartColour();
    pEndColour = pFill->GetEndColour();
    if(pStartColour == 0 || pEndColour == 0
        || pStartColour->IsTransparent()
        || pEndColour->IsTransparent())
    {
        pStartColour = 0;
        pEndColour = 0;
    }
    
    if(pStartColour != 0)
    {
        // get the fill effect
        Effect = pReg->GetFillEffect();
    }

    // get the reference for the bitmap
    KernelBitmap *pBitmap = pBFillAttr->BitmapRef.GetBitmap();
    WORD BitmapRef = GetBitmapReference(pBitmap, pStartColour, pEndColour, Effect);

    // make a new bitmap fill object
    CMXReferBitmapFill *pBFill = new CMXReferBitmapFill(this);
    if(pBFill == 0)
        return FALSE;
    pBFill->Set(BitmapRef);

    // add it to the refer list
    ReferList.AddTail(pBFill);

    // get it's reference
    WORD BitmapFillProcReference = GetProcedureReference(pBFill);

    // ready to write...
    if(!StartNestedTag(cmxTAG_RenderAttr_FillSpec_ColorBM))
        return FALSE;
    
    ExportFile->write(&BitmapFillProcReference, sizeof(BitmapFillProcReference));

    // write tiling
    if(!StartNestedTag(cmxTAG_Tiling))
        return FALSE;

    // get points from the attribute
    DocCoord *Start = pFill->GetStartPoint();
    DocCoord *End1 = pFill->GetEndPoint();
    DocCoord *End2 = pFill->GetEndPoint2();

    // get a tiling structure
    cmxTilingEnd tile;

    // Variables for rendering the texture to the file. I've deferred the scaling of
    // the image until it's written. It's slightly ugly doing it this way, but it
    // removes a few multipications, and so should get rid of some rounding errors
    // along the way.
    DocRect cBBox;
    double  TileWidth   = Start->Distance ( *End1 );
    double  TileHeight  = Start->Distance ( *End2 );

    // Calculate the untransformed Corel bounding box.
    CalcCorelBBox(Coords, NumCoords, &cBBox);

    // Graeme (9-5-00) - I've simplified Ben's code a little, and removed the
    // repeated bits in both branches of the if statement.
    if ( ThirtyTwoBit )
    {
        cmxTilingBegin32 Tile32;
        Tile32.Width    = static_cast<DWORD> ( Round ( TileWidth  * ScaleFactor ) );
        Tile32.Height   = static_cast<DWORD> ( Round ( TileHeight * ScaleFactor ) );

        WriteData ( &Tile32, sizeof ( Tile32 ) );
    }
    else
    {
        cmxTilingBegin16 Tile16;
        Tile16.Width    = static_cast<WORD> ( Round ( TileWidth  * ScaleFactor ) );
        Tile16.Height   = static_cast<WORD> ( Round ( TileHeight * ScaleFactor ) );

        WriteData ( &Tile16, sizeof ( Tile16 ) );
    }

    // now work out the offsets to the start of the tile
    double  dX  = static_cast<double> ( Start->x - cBBox.lo.x );
    double  dY  = static_cast<double> ( cBBox.hi.y - Start->y );

    // Graeme (9-5-00) - Round the offset up.
    tile.XOffset = ( static_cast<WORD> ( Round ( ( dX * 100.0 ) / TileWidth  ) ) ) % 100;
    tile.YOffset = ( static_cast<WORD> ( Round ( ( dY * 100.0 ) / TileHeight ) ) ) % 100;

    tile.InterTileOffset = tile.TilingFlags = 0;

    // write the structure to the file
    ExportFile->write(&tile, sizeof(tile));
    if(!EndNestedTag() || !WriteMinEndTag())
        return FALSE;

    // bounding box of bit to use
    DocRect bbox = DocRect(0, 0, cmxBITMAPFILLTILESIZE_X, cmxBITMAPFILLTILESIZE_Y);

    if(!WriteBBox(&bbox, FALSE))
        return FALSE;

    if(!EndNestedTag() || !WriteMinEndTag())
        return FALSE;

    return TRUE;
}


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

>   BOOL CMXExportDC::WritePath ( DocCoord *Coords,
                                  PathVerb *Verbs,
                                  INT32 NumCoords,
                                  BOOL Filled )

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    01/07/96
    Inputs:     render region, coords, verbs and number of coords
    Returns:    success
    Purpose:    Writes a path instruction -- transformed by matrix

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

BOOL CMXExportDC::WritePath ( DocCoord *Coords,
                              PathVerb *Verbs,
                              INT32 NumCoords,
                              BOOL Filled )
{
    // if this is one of those nasty 16 bit files, sort out a transform matrix

    // scan the verbs to see if there's a close path in it
    // as if there isn't, we need to force no fill on the thingy
    BOOL ForceNoFill = TRUE;
    for(INT32 p = 0; p < NumCoords; p++)
    {
        if((Verbs[p] & PT_CLOSEFIGURE) != 0)
            ForceNoFill = FALSE;
    }
    if(!Filled)
        ForceNoFill = TRUE;

    // begin the command
    if(!StartCommand(cmxINSTR_PolyCurve))
        return FALSE;

    // output the rendering attributes
    if(!WriteAttributes(pRenderRegion, cmxTAG_PolyCurve_RenderingAttr, Coords, NumCoords, ForceNoFill))
        return FALSE;

    // write the point list, transformed of course. Start by tagging it
    if(!StartTag(cmxTAG_PolyCurve_PointList))
        return FALSE;

    // we have to collect a bounding box as we go through as Corel use a
    // naff bbox which is simply the union of all points
    DocRect bb;             // which is written as a corel one
    DocCoord fc = Coords[0];
    pMatrix->transform(&fc);
    bb.lo = fc;             // start with sensible coords to begin with
    bb.hi = fc;

    // write the point count
    WORD Count = (WORD)NumCoords;
    ExportFile->write(&Count, sizeof(Count));

    // run through the coords writing and transforming
    INT32 l;
TRACEUSER( "Ben", _T("\nPath\n"));
    for(l = 0; l < NumCoords; l++)
    {
        DocCoord Coord = Coords[l];
        pMatrix->transform(&Coord);

        // write it...
        if(ThirtyTwoBit)
        {
            cmxPoint32 p = {Coord.x, Coord.y};
            ExportFile->write(&p, sizeof(p));
        }
        else
        {
TRACEUSER( "Ben", _T("Coord %d %d\n"), Coord.x, Coord.y);
            cmxPoint16 p = {(SWORD)Coord.x, (SWORD)Coord.y};
            ExportFile->write(&p, sizeof(p));
        }

        // flibble the bounding box with those lovely new coords
        if(Coord.x < bb.lo.x) bb.lo.x = Coord.x;
        if(Coord.y < bb.lo.y) bb.lo.y = Coord.y;
        if(Coord.x > bb.hi.x) bb.hi.x = Coord.x;
        if(Coord.y > bb.hi.y) bb.hi.y = Coord.y;
    }

    // run through the verbs writing point types
    INT32 BezCount = 0;     // for counting Bez
    for(l = 0; l < NumCoords; l++)
    {
        BYTE Type;

        switch(Verbs[l] & (PT_LINETO | PT_MOVETO | PT_BEZIERTO))
        {
        case PT_MOVETO:
            {
                Type = CMXNODETYPE_TYPE_MOVE | CMXNODETYPE_USER;
            
                // wibble forwards through the verbs to see if the correspondingness is closed
                for(INT32 lp = l + 1; lp < NumCoords; lp++)
                {
                    // OK, is this a move?
                    if((Verbs[lp] & (PT_LINETO | PT_MOVETO | PT_BEZIERTO)) == PT_MOVETO)
                        break;

                    // is closefigure set?
                    if((Verbs[lp] & PT_CLOSEFIGURE) != 0)
                    {
                        Type |= CMXNODETYPE_CLOSED;
                        break;
                    }
                }
            }
            BezCount = 0;
            break;

        case PT_LINETO:
            Type = CMXNODETYPE_TYPE_LINE | CMXNODETYPE_USER;
            BezCount = 0;
            break;

        case PT_BEZIERTO:
            // in CMX, the control points have type ARC, and the end points
            // have type CURVE. This code does the trickery.
            if(BezCount == 2)
            {
                Type = CMXNODETYPE_TYPE_CURVE | CMXNODETYPE_USER;
            }
            else
            {
                Type = CMXNODETYPE_TYPE_ARC;
            }
            BezCount++;
            if(BezCount > 2)
                BezCount = 0;       // so that only the end points of beziers get user flag
            break;

        default:
            ERROR3("Unknown node type");
            break;
        }

        if((Verbs[l] & PT_CLOSEFIGURE) != 0)
        {
            Type |= CMXNODETYPE_CLOSED;
        }

        ExportFile->write(&Type, sizeof(Type));
    }

    // end the point list
    if(!EndTag())
        return FALSE;

    // write bbox we've collected
    if(!StartTag(cmxTAG_PolyCurve_BoundingBox)
        || !WriteBBox(&bb, FALSE)
        || !EndTag())
        return FALSE;

    // end the command
    if(!WriteMinEndTag()
        || !EndCommand())
        return FALSE;

    // if necessary, get rid of the horrid transform matrix

    return TRUE;
}


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

>   WORD CMXExportDC::GetColourReference(DocColour *pTheLovelyColour)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    04/07/96
    Inputs:     colour
    Returns:    refernce number of a colour
    Purpose:    to find a reference number for the colour when writing a CMX file

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

WORD CMXExportDC::GetColourReference(DocColour *pTheLovelyColour)
{
    // algorithm:
    // scan the refer list to see if the colour is already there.
    // if it is, return it's index.
    // if it isn't add the colour to the refer list, and return the new index.

    // the reference we need -- references count up from 1
    INT32 Ref = 0;

    // scan that list!
    CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead();
    while(pEn != 0)
    {
        ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list");

        if(pEn->IsInWhichDesc() == cmxDESC_COLOUR)
        {
            Ref++;

            CMXReferColour *pLC = (CMXReferColour *)pEn;
            ERROR3IF(!pLC->IsKindOf(CC_RUNTIME_CLASS(CMXReferColour)), "not a refer colour, when it said it was");
            
            // is it this colour?
            if(pLC->AreYouThisColour(pTheLovelyColour))
            {
                // yep. return the reference number
                return Ref;
            }
        }

        pEn = (CMXReferListItem *)ReferList.GetNext(pEn);
    }

    // we haven't got one... make a new one, set it up and add it to the list
    CMXReferColour *pNewRefCol = new CMXReferColour(this);
    if(pNewRefCol == 0)
        return 0;

    pNewRefCol->SetColour(pTheLovelyColour);

    ReferList.AddTail(pNewRefCol);

    // return the next reference number, Ref is the ref of the last one in the list
    return (WORD)Ref + 1;
}


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

>   WORD CMXExportDC::GetArrowReference(ArrowRec *pArrow)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/07/96
    Inputs:     colour
    Returns:    reference number of a colour
    Purpose:    to find a reference number for the arrow when writing a CMX file
                will return 0 (ie no arrowhead) if it isn't one

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

WORD CMXExportDC::GetArrowReference(ArrowRec *pArrow)
{
    // check to see if the arrowrec is in fact an arrowhead
    if(pArrow->IsNullArrow())
        return 0;       // ie no arrow on here mate

    // the reference we need -- references count up from 1
    INT32 Ref = 0;

    // scan that list!
    CMXReferListItem *pEn = (CMXReferListItem *)ReferList.GetHead();
    while(pEn != 0)
    {
        ERROR3IF(!pEn->IsKindOf(CC_RUNTIME_CLASS(CMXReferListItem)), "unexpected type of entry in refer list");

        if(pEn->IsInWhichDesc() == cmxDESC_ARROW)
        {
            Ref++;

            CMXReferArrow *pAr = (CMXReferArrow *)pEn;
            ERROR3IF(!pAr->IsKindOf(CC_RUNTIME_CLASS(CMXReferArrow)), "not an arrow, when it said it was");
            
            // is it this colour?
            if(pAr->AreYouThisArrow(pArrow))
            {
                // yep. return the reference number
                return Ref;
            }
        }

        pEn = (CMXReferListItem *)ReferList.GetNext(pEn);
    }

    // we haven't got one... make a new one, set it up and add it to the list
    CMXReferArrow *pNewArrow = new CMXReferArrow(this);
    if(pNewArrow == 0)
        return 0;

    pNewArrow->Set(pArrow);

    ReferList.AddTail(pNewArrow);

    // return the next reference number, Ref is the ref of the last one in the list
    return (WORD)Ref + 1;
}


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

>   WORD CMXExportDC::GetBitmapReference(KernelBitmap *pTheLovelyBitmap, DocColour *pStartCol, DocColour *pEndCol, CMXReferBitmap **ppRB = 0)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/07/96
    Inputs:     bitmap
    Returns:    refernce number of a bitmap
    Purpose:    to find a reference number for the bitmap when writing a CMX file.
                *ppRB is set to a pointer to the CMXReferBitmap object if ppRB != 0

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

WORD CMXExportDC::GetBitmapReference(KernelBitmap *pTheLovelyBitmap, DocColour *pStartCol,
    DocColour *pEndCol, EFFECTTYPE Effect, CMXReferBitmap **ppRB)
{