ai_epsrr.cpp

Go to the documentation of this file.

// $Id: ai_epsrr.cpp 1336 2006-06-17 16:18:41Z alex $
// Implementation of Adobe Illustrator EPS filter.
/* @@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============================
 */

#include "camtypes.h"

#include "ai_epsrr.h"

#include <stdio.h>
#include <math.h>

#include "vectrndr.h"
#include "ccdc.h"
//#include "colmodel.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "opbevel.h"
#include "swfexpdc.h"
#include "swfrndr.h"
#include "slicehelper.h"
#include "fillramp.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "nodebmp.h"
//#include "bitmap.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "range.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "rendsel.h"
//#include "dibutil.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "fontman.h"        // for FontManager - for writing font changes to overflow text
#include "colplate.h"       // for ColourPlate - in overflow text functions
#include "colourix.h"       // for Indexed Colour - for writing colour changes to overflow
#include "nodebev.h"
#include "layer.h"
#include "clipattr.h"

CC_IMPLEMENT_DYNAMIC(AIEPSRenderRegion, EPSRenderRegion)

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

>   AIEPSRenderRegion::AIEPSRenderRegion ( DocRect  ClipRect,
                                           Matrix   ConvertMatrix,
                                           FIXED16  ViewScale )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/3/00
    Purpose:    Create and initialise a render region for exporting AI EPS. Sets up the
                string to put in the %%Creator comment.
    SeeAlso:    EPSRenderRegion::EPSRenderRegion ()

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

AIEPSRenderRegion::AIEPSRenderRegion ( DocRect  ClipRect,
                                       Matrix   ConvertMatrix,
                                       FIXED16  ViewScale )
    : EPSRenderRegion ( ClipRect, ConvertMatrix, ViewScale )
{
    // Set up member variables.
    m_a             = 1;
    m_b             = 0;
    m_c             = 0;
    m_d             = 1;
    m_T             = DocCoord ( 0, 0 );
    m_ActiveLayer   = FALSE;
    m_LayerColour   = 0;

    m_fpOverflowText    = NULL;

    m_bInTextGap        = FALSE;
    m_bTextAsShapes     = FALSE;
    
    m_pLinearGradList   = NULL;
    m_pRadialGradList   = NULL;

    // Initialise the creator string to show that it's an AI file.
    CreatorString = _T("Adobe Illustrator(TM) 7.0 by Xara.");
}

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

>   AIEPSRenderRegion::~AIEPSRenderRegion 
    Author:     Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/3/2001
    Purpose:    Destructor for an AI render region. All this really does is dispose of the 
                gradient fill cache (if there is one)
    SeeAlso:    EPSRenderRegion::EPSRenderRegion ()

********************************************************************************************/
AIEPSRenderRegion::~AIEPSRenderRegion ()
{
    ClearGradientCache ();
}

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

>   BOOL AIEPSRenderRegion::ExportBitmap ( NodeBitmap   *pNodeBMP )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/3/00
    Inputs:     pNodeBMP    - A pointer to the NodeBitmap being exported.
    Returns:    TRUE        - If successful.
                FALSE       - If an error is encountered.
    Purpose:    Kicks off the NodeBitmap export process..
    SeeAlso:    NodeBitmap::ExportRender ()

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

BOOL AIEPSRenderRegion::ExportBitmap ( NodeBitmap   *pNodeBMP )
{
    // Set up the local variables.
    KernelBitmap    *pBitmap    = pNodeBMP->GetBitmap ();

    // Set up the bitmap's transformation matrix.
    LoadBitmapMatrix ( pNodeBMP );

    // Write out the bitmap record.
    WriteBitmapRecord ( pBitmap->GetActualBitmap () );

    return TRUE;
}

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

>   BOOL AIEPSRenderRegion::ExportBevel ( NodeBevel *pBevel )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/4/00
    Inputs:     pBevel  - A pointer to a bevel node.
    Returns:    TRUE    - Success.
                FALSE   - An error occured.
    Purpose:    Renders a bevel into a DIB, and exports this as a bitmap to the AI file.
    SeeAlso:    NodeBevel::ExportRender

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

BOOL AIEPSRenderRegion::ExportBevel ( NodeBevel *pBevel )
{
    // Set up the local variables.
    KernelDC                *pDC            = static_cast<KernelDC *> ( CCDC::ConvertFromNativeDC(RenderDC) );
    RangeControl            ControlFlags    ( TRUE, TRUE );
    Range                   ToRender        ( pBevel, pBevel, ControlFlags );
    KernelBitmap            *pBitmap        = NULL;
    Path                    *pSourcePath    = &( pBevel->InkPath );
    DocRect                 Bounds          = pBevel->GetBoundingRect ();
    DocCoord                Position        ( Bounds.lo.x, Bounds.hi.y );
    double                  Width           = static_cast<double> ( Bounds.Width () );
    double                  Height          = static_cast<double> ( Bounds.Height () );

    // Create and render the bitmap.
    pBitmap = pBevel->CreateBitmapCopy(-1.0,FALSE);

    if(!pBitmap)
        return FALSE;

    // Get the width and height of the bitmap.
    double                  BMPWidth        = static_cast<double> ( pBitmap->GetWidth () );
    double                  BMPHeight       = static_cast<double> ( pBitmap->GetHeight () );

    // Write the path. (ChrisG 16/01/01) If we have one.
    if (pSourcePath->GetNumCoords () != 0)
    {
        WriteMask ( pSourcePath, TRUE );
    }

    // Set up the bitmap translation matrix.
    LoadTranslationMatrix ( Position );

    // Scale width and height to be valid value for AI co-ordinates.
    Width   /= 1000;
    Height  /= 1000;
    
    // And calcuate the scale values for placing the bitmap.
    m_a = Width  / BMPWidth;
    m_d = Height / BMPHeight;

    // Write the bitmap record.
    WriteBitmapRecord ( pBitmap->ActualBitmap );

    // Write the end of mask operator. (ChrisG 16/01/01) If we've written a mask.
    if (pSourcePath->GetNumCoords () != 0)
    {
        pDC->OutputToken    ( _T("Q") );
        pDC->OutputNewLine  ();
    }

    if(pBitmap)
    {
        pBitmap->DestroyGreyscaleVersion();
        delete pBitmap;
    }

    // Success!
    return TRUE;
}

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

>   BOOL AIEPSRenderRegion::ExportShadow ( OILBitmap    *pBitmap,
                                           UINT32           Darkness,
                                           DocRect      &Bounds )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/00
    Inputs:     pShadow - A pointer to a shadow node.
    Returns:    TRUE    - Success.
                FALSE   - An error occured.
    Purpose:    Renders a shadow into a DIB, and exports this as a bitmap to the AI file.
    SeeAlso:    NodeBevel::ExportRender

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

BOOL AIEPSRenderRegion::ExportShadow ( OILBitmap    *pBitmap,
                                       UINT32           Darkness,
                                       DocRect      &Bounds )
{
    // Set up the local variables.
//  KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC);
    DocCoord    Position        ( Bounds.lo.x, Bounds.hi.y );
    double      Width           = static_cast<double> ( Bounds.Width () ) / 1000;
    double      Height          = static_cast<double> ( Bounds.Height () ) / 1000;
    double      BMPWidth        = static_cast<double> ( pBitmap->GetWidth () );
    double      BMPHeight       = static_cast<double> ( pBitmap->GetHeight () );
    DocColour   ShadowColour    = *( static_cast<FillGeometryAttribute*>
                                     ( GetCurrentAttribute ( ATTR_FILLGEOMETRY ) )
                                     ->GetStartColour () );
    DocColour   BlendedShadow   = AlphaBlend ( ShadowColour, mBackgroundColour, Darkness );

    // And use the shadow colour to build a contone bitmap palette.
    pBitmap->BuildContonePalette ( BlendedShadow, mBackgroundColour, EFFECT_RGB,
                                   RenderView );

    // Set up the bitmap translation matrix.
    LoadTranslationMatrix ( Position );
    
    // And calcuate the scale values for placing the bitmap.
    m_a = Width  / BMPWidth;
    m_d = Height / BMPHeight;

    // Write out the bitmap header.
    WriteBitmapHeader ( (INT32)BMPWidth, (INT32)BMPHeight );

    // Export the bitmap.
    WriteContoneBody ( pBitmap );

    // Finish off the bitmap record.
    WriteBitmapTail ();

    return TRUE;
}

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

>   BOOL AIEPSRenderRegion::ExportLayer ( Layer *pLayer )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/00
    Inputs:     pLayer  - A pointer to a layer object.
    Returns:    TRUE    - Success.
                FALSE   - An error occured.
    Purpose:    If there is an existing layer, it writes the end of layer tags, before
                creating a new layer record.
    SeeAlso:    AIEPSRenderRegion::EndLayer ()

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

BOOL AIEPSRenderRegion::ExportLayer ( Layer *pLayer )
{
    // Tidy up the existing layer, if it exists.
    EndLayer ();

    // And write out the next layer.
    return StartLayer ( static_cast<Layer*> ( pLayer->FindNext
                                              ( CC_RUNTIME_CLASS ( Layer ) ) ) );
}

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

>   BOOL AIEPSRenderRegion::StartLayer ( Layer  *pLayer )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/00
    Inputs:     pLayer  - A pointer to a layer object.
    Returns:    TRUE    - Success.
                FALSE   - An error occured.
    Purpose:    Writes a layer record to the file.
    SeeAlso:    AIEPSRenderRegion::EndLayer ()

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

BOOL AIEPSRenderRegion::StartLayer ( Layer  *pLayer )
{
    // Catch null pointers to layers.
    if ( pLayer != NULL )
    {
        KernelDC    *pDC            = static_cast<KernelDC *> ( CCDC::ConvertFromNativeDC(RenderDC) );
        TCHAR       LayerName [258];

        // Set up the layer's name.
        camSprintf ( LayerName, _T("(%s)"), ( TCHAR* ) pLayer->GetLayerID () );

        // Start a layer definition.
        pDC->OutputToken    ( _T("%AI5_BeginLayer") );
        pDC->OutputNewLine  ();

        // Set the layer's properties.
        pDC->OutputValue    ( ( UINT32 ) pLayer->IsVisible () );    // Is the layer visible?
        pDC->OutputValue    ( ( UINT32 ) 1 );                   // Is the layer previewed?
        pDC->OutputValue    ( ( UINT32 ) !pLayer->IsLocked () );    // Is the layer enabled?
        pDC->OutputValue    ( ( UINT32 ) pLayer->IsPrintable () );//Is the layer printable?
        pDC->OutputValue    ( ( UINT32 ) 0 );                   // Is the layer dimmed?
        pDC->OutputValue    ( ( UINT32 ) 0 );                   // No multilayer masks.

        // The ID colour.
        pDC->OutputValue    ( ( UINT32 ) m_LayerColour % 27 );  // Set the layer's ID colour.
        m_LayerColour ++;                                       // Increment colour ID.

        // Colour values - I don't know what they're used for.
        pDC->OutputValue    ( ( UINT32 ) 0 );                   // Red intensity.
        pDC->OutputValue    ( ( UINT32 ) 0 );                   // Blue intensity.
        pDC->OutputValue    ( ( UINT32 ) 0 );                   // Green intensity.

        // Write out the Lb tag.
        pDC->OutputToken    ( _T("Lb") );
        pDC->OutputNewLine  ();

        // Set the layer's name.
        pDC->OutputToken    ( LayerName );
        pDC->OutputToken    ( _T("Ln") );
        pDC->OutputNewLine  ();

        // Tell Camelot that there is an active layer.
        m_ActiveLayer = TRUE;
    }

    // Success!
    return TRUE;
}

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

>   void AIEPSRenderRegion::RenderChar (WCHAR ch, Matrix * pMatrix)

    Author:     Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/11/00
    Purpose:    Overrides the default behaviour for rendering a single character. Used to 
                store additional information on text blocks needed for AI text. i.e. the
                overflow text block ((xxxxxxxxx) TX) which occurs after the unjustified 
                ((x) Tx\n (x) Tx\n) block. Both of these are needed for correct Illustrator
                export of text.
    SeeAlso:    EPSRenderRegion::RenderChar

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

BOOL AIEPSRenderRegion::RenderChar(WCHAR ch, Matrix* pMatrix)
{
    TCHAR buf[20];
    BOOL result = FALSE;        // assume failure if nothing given.

    if (m_bTextAsShapes)
    {
        result = RenderCharAsShape (ch, pMatrix);
    }
    else
    {
        // Output matrix (a b c d e f Tm\n) - a,b,c and d are in the range 1.0 to -1.0
        // Only do this for text on paths
        if (ExportingOnPath ())
        {
            KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC);

            pDC->OutputMatrix(pMatrix);
            pDC->OutputToken(_T("Tm"));
            pDC->OutputNewLine();
        }

        // call the base class first, so that the attributes are exported BEFORE the character
        result = EPSRenderRegion::RenderChar (ch, pMatrix);;
        
            // store any extra information, closing an attribute gap if one is open.
        if (ExportingOnPath ())
        {
            OverflowTextFinishGap ();
            camSprintf (buf,_T("%c"),ch);
            OverflowTextWrite (buf);
        }
    }
        // Call the base class' function to do the standard export.
    return result;
}


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

>   void AIEPSRenderRegion::RenderCharAsShape (WCHAR ch, Matrix * pMatrix)

    Author:     Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/11/00
    Purpose:    Allows text to be drawn as shapes, not characters, so that AI can cope
                with gradient filled text.
    SeeAlso:    AIEPSRenderRegion::RenderChar, EPSRenderRegion::RenderChar

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

BOOL AIEPSRenderRegion::RenderCharAsShape (WCHAR ch, Matrix* pMatrix)
{
    BOOL result = FALSE;

    // create the char's path
    Path* pCharPath=CreateCharPath(ch,pMatrix);

    // if the path got created correctly, then we done good...
    if (pCharPath!=NULL)
    {
        // if at least one point, draw path using current attibutes in render region
        if (pCharPath->GetNumCoords()!=0)
            DrawPath(pCharPath);

        // clean up
        delete pCharPath;

        result = TRUE;
    }

    return result;
}

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

>   void AIEPSRenderRegion::Initialise()

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/3/00
    Purpose:    Sets up render region - it outputs the AIEPS file header comments, and
                intialises the rendering attributes.
    SeeAlso:    EPSRenderRegion::Initialise, EPSRenderRegion::InitAttributes

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

void AIEPSRenderRegion::Initialise()
{
    // Set up member variables.
    m_a             = 1;
    m_b             = 0;
    m_c             = 0;
    m_d             = 1;
    m_T             = DocCoord ( 0, 0 );
    m_ActiveLayer   = FALSE;
    m_LayerColour   = 0;

    ClearGradientCache ();

    // Call the EPSRenderRegion method to re-enter the export loop.
    EPSRenderRegion::InitAttributes ();
}

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

>   BOOL AIEPSRenderRegion::WriteEPSVersion ( void )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/3/000
    Inputs:     pDC - The device context to output to.
    Returns:    TRUE if ok;
                FALSE if error (e.g. file/disk error or printer driver error)
    Purpose:    Writes the relevant EPS version declaration.
    SeeAlso:    EPSRenderRegion::WriteEPSVersion

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

BOOL AIEPSRenderRegion::WriteEPSVersion ( void )
{
    // Cast the pointer to an appropriate DC.
    KernelDC *pDC = static_cast<KernelDC *> ( CCDC::ConvertFromNativeDC(RenderDC) );

    // Output the special AIEPS header start token.
    pDC->OutputToken    ( _T("%!PS-Adobe-3.0") );
    pDC->OutputNewLine  ();

    return TRUE;
}

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

>   BOOL AIEPSRenderRegion::WriteEPSProcessColours ( void )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/3/000
    Inputs:     pDC - The device context to output to.
    Returns:    TRUE if ok;
                FALSE if error (e.g. file/disk error or printer driver error)
    Purpose:    Writes the colour type used to disk.
    SeeAlso:    EPSRenderRegion::WriteEPSProcessColours

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

BOOL AIEPSRenderRegion::WriteEPSProcessColours ( void )
{
    // Cast a pointer to the appropriate DC.
    KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC);

    // Output the process colours
    pDC->OutputToken    ( _T("%%DocumentProcessColors: Cyan Magenta Yellow Black") );
    pDC->OutputNewLine  ();

    return TRUE;
}

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

>   BOOL AIEPSRenderRegion::WriteEPSResources ( EPSFilter   *pFilter,
                                                Document    *pDocument )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/3/00
    Inputs:     pDC - The device context to output to.
    Returns:    TRUE if ok;
                FALSE if error (e.g. file/disk error or printer driver error)
    Purpose:    This function writes out the resource inclusion string required for the AI
                file.
    SeeAlso:    EPSRenderRegion::WriteSetup

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

BOOL AIEPSRenderRegion::WriteEPSResources ( EPSFilter   *pFilter,
                                            Document    *pDocument )
{
    // Cast a pointer to the appropriate DC.
    KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC);
    
    // Call the export method in the document.
    pDocument->WriteEPSResources ( pFilter );

    // Add a few things necessary for the AI file format.
    pDC->OutputToken    ( _T("%AI3_ColorUsage: Color") );
    pDC->OutputNewLine  ();
    pDC->OutputToken    ( _T("%AI5_FileFormat 2.0") );
    pDC->OutputNewLine  ();

    // All done.
    return TRUE;
}

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

>   BOOL AIEPSRenderRegion::WriteEPSProlog ( EPSFilter  *pFilter,
                                             Document   *pDocument )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/3/00
    Inputs:     pDC - The device context to output to.
    Returns:    TRUE if ok;
                FALSE if error (e.g. file/disk error or printer driver error)
    Purpose:    This method writes out the initialisation code for the included resources.
    SeeAlso:    EPSRenderRegion::WriteSetup

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

BOOL AIEPSRenderRegion::WriteEPSProlog ( EPSFilter  *pFilter,
                                         Document   *pDocument )
{
    // Call the export method in the document.
    pDocument->WriteEPSProlog ( pFilter );

    // All done.
    return TRUE;
}

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

>   virtual BOOL AIEPSRenderRegion::WriteGradientFills ( Document *pDocument )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/3/00
    Inputs:     pDocument - The document to be written.
    Outputs:    -
    Returns:    TRUE if successful.
                FALSE if error (e.g. file/disk error)
    Purpose:    Parses through the tree, identifies any gradient fills, and writes them to
                the export DC's file.

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

BOOL AIEPSRenderRegion::WriteGradientFills ( Document *pDocument )
{
    // Get the spread from the document.
    Spread      *pSpread        = pDocument->FindFirstSpread ();

    // Build the gradient cache up from all the fills under the spread, after cleaning any 
    //  junk out of it (there shouldn't be any there, but that ain't the point)
    ClearGradientCache ();
    BuildGradientCache (pSpread);

    // Write out the number of fills and their definition.
    WriteGradientCount ();
    WriteGradientDefinitions ();

    // The fill has been successfully saved, so return TRUE.
    return TRUE;
}

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

>   BOOL AIEPSRenderRegion::WriteLinearFill ( FillGeometryAttribute *pFill, INT32 id )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/3/00
    Inputs:     pFill   - A pointer to the fill attribute record.
                id      - the id number for the fill
    Returns:    TRUE    - If successful.
                FALSE   - The was an error (e.g. file/disk error).
    Purpose:    Writes a linear fill to the disk file.

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

BOOL AIEPSRenderRegion::WriteLinearFill ( FillGeometryAttribute * pFill, EFFECTTYPE effect, INT32 id )
{
    // Extract the fill attribute - this is necessary for processing the fill type.
    KernelDC                *pDC                = static_cast<KernelDC *> ( CCDC::ConvertFromNativeDC(RenderDC) );
    INT32                       Colours             = 2;
    TCHAR                   GradientName [32];
    DocColour               StartColour         = *( pFill->GetStartColour () );
    DocColour               EndColour;
    ColourRamp              *pRamp              = pFill->GetColourRamp ();

    // The fill is, or can be approximated by, a linear fill.
    camSprintf ( GradientName, _T("(%s %d)"), LinearGradient, id );

    // (ChrisG 16/01/01) Four colour fill MUST come first, as it's derived from Three
    //  colour fill, and returns valid for IsThreeColFill().
    if ( pFill->IsAFourColFill () )
    {
        // I'm going to use a version of the below here, but for now I'll just
        // set up the end colour as the most distant end colour.
        EndColour   = *( pFill->GetEndColour3 () );
    }
    else if ( pFill->IsAThreeColFill () )
    {
        // AI doesn't support three colour fills, so I'm going to fake it. This
        // code merges the two end colours to approximate the fill with a two
        // colour linear fill.
        EndColour.Mix ( pFill->GetEndColour (), pFill->GetEndColour2(),
                        0.5f, NULL, FALSE, NULL );
    }
    else
    {
        // Set up the end colour value appropriately.
        EndColour   = *( pFill->GetEndColour () );
    }

    // Count the number of colours.
    if ( pRamp != NULL )
    {
        UINT32  First   = 0;
        UINT32  Last    = 0;

        // Extract the indices from the colour ramp.
        pRamp->GetIndexRange ( &First, &Last );

        // And add their difference to the colour count. Note, you need to add one
        // to the result so that you don't register having no colours. There really
        // should be a count number of elements method in the ramp code, though.
        Colours += 1 + Last - First;
    }

    // (ChrisG 15/01/01) If this is a four colour fill, since we will be adding a mid-colour
    //  below, then we need to include it in the definition
    if (pFill->IsAFourColFill ())
    {
        Colours ++;
    }

    // (ChrisG 4/4/2001) Add in the extra colours given from the HSV fill effect emulation
    if (effect == EFFECT_HSV_SHORT || effect == EFFECT_HSV_LONG)
    {
        Colours += (Colours - 1) * NumFillEmulationSteps;
    }

    // Write the gradient's header.
    pDC->OutputToken    ( _T("%AI5_BeginGradient:") );
    pDC->OutputToken    ( GradientName );
    pDC->OutputNewLine  ();

    // Then the type definition.
    pDC->OutputToken    ( GradientName );
    pDC->OutputValue    ( static_cast<INT32> ( LinearFill ) );
    pDC->OutputValue    ( static_cast<INT32> ( Colours ) );
    pDC->OutputToken    ( _T("Bd") );
    pDC->OutputNewLine  ();
    pDC->OutputToken    ( _T("[") );
    pDC->OutputNewLine  ();

    // (ChrisG 3/4/2001) Get bias and convert to 0-100 range (from -1 to +1)
    //  This will be used later on to offset the positions
    CProfileBiasGain profile = pFill->GetProfile ();
    INT32 bias = (INT32) ((1 - (double) profile.GetBias ()) * 50);

    // Write out the last colour.
    WriteGradientEntry ( &EndColour, 100, 50 );

    // set up the last colour and position (for the fill effect emulation.
    DocColour * pLastColour = &EndColour;
    INT32 lastPos = 100;

    // Mid colour for four colour fills - this needs to be stored longer so that it can be
    //  re-used in the case of HSV fill effects.
    DocColour   MidColour;

    // If the fill is a four colour fill, add a mid-colour that's a blend of the
    // second and third colours.
    if ( pFill->IsAFourColFill () )
    {

        MidColour.Mix ( pFill->GetEndColour (), pFill->GetEndColour2 (),
                        0.5f, NULL, FALSE, NULL );

        // Write out the extra fill steps, if there are any.
        if (effect != EFFECT_RGB)
        {
            WriteFillEffectSteps (pLastColour, lastPos, &MidColour, 50, bias, effect);
            pLastColour = &MidColour;
        }

        // And set the value.
        WriteGradientEntry ( &MidColour, 50, bias);
    }

    // Otherwise, process the colour ramp.
    else if ( pRamp != NULL )
    {
        ColRampItem *pItem = pRamp->GetLastCol ();

        // Write in the ramp's colour values.
        while ( pItem != NULL )
        {
            // Get the position of the colour in the fill.
            INT32       Ratio   = static_cast <INT32> ( 100 * pItem->GetPosition () );
            DocColour   *pCol   = pItem->GetColourAddr ();

            // Write out the extra fill steps, if there are any.
            if (effect != EFFECT_RGB)
            {
                WriteFillEffectSteps (pLastColour, lastPos, pCol, Ratio, bias, effect);
                pLastColour = pCol;
                lastPos = Ratio;
            }

            // And set the value.
            WriteGradientEntry ( pCol, Ratio, 50 );

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

    // Write out the extra fill steps, if there are any.
    if (effect != EFFECT_RGB)
    {
        WriteFillEffectSteps (pLastColour, lastPos, &StartColour, 0, bias, effect);
    }

    // Write out the start colour.
    WriteGradientEntry ( &StartColour, 0, bias );

    // Write out the end of gradient tokens.
    pDC->OutputToken    ( _T("BD") );
    pDC->OutputNewLine  ();
    pDC->OutputToken    ( _T("%AI5_EndGradient") );
    pDC->OutputNewLine  ();

    // It worked!
    return TRUE;
}


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

>   BOOL AIEPSRenderRegion::WriteRadialFill ( AttrFillGeometry  *pFill, INT32 id )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/3/00
    Inputs:     pFill   - A pointer to the fill attribute record.
                id      - The fill's id number
    Returns:    TRUE    - If successful.
                FALSE   - The was an error (e.g. file/disk error).
    Purpose:    Writes a Radial fill to the disk file.

********************************************************************************************/
BOOL AIEPSRenderRegion::WriteRadialFill (FillGeometryAttribute * pFill, EFFECTTYPE effect, INT32 id)
{
    // Extract the fill attribute - this is necessary for processing the fill type.
    KernelDC                *pDC                = static_cast<KernelDC *> ( CCDC::ConvertFromNativeDC(RenderDC) );
    INT32                       Colours             = 2;
    TCHAR                   GradientName [32];
    DocColour               StartColour         = *( pFill->GetStartColour () );
    DocColour               EndColour           = *( pFill->GetEndColour () );
    ColourRamp              *pRamp              = pFill->GetColourRamp ();

    // The fill is, or can be approximated by, a Radial fill.
    camSprintf ( GradientName, _T("(%s %d)"), RadialGradient, id );

    // Count the number of colours.
    if ( pRamp != NULL )
    {
        UINT32  First   = 0;
        UINT32  Last    = 0;

        // Extract the indices from the colour ramp.
        pRamp->GetIndexRange ( &First, &Last );

        // And add their difference to the colour count. Note, you need to add one
        // to the result so that you don't register having no colours. There really
        // should be a count number of elements method in the ramp code, though.
        Colours += 1 + Last - First;

        if (effect != EFFECT_RGB)
        {
            // Add in the extra steps for the fill effect (Five extra steps between each 
            //  pair of colours).
            Colours += (Colours - 1) * NumFillEmulationSteps;
        }
    }

    // Write the gradient's header.
    pDC->OutputToken    ( _T("%AI5_BeginGradient:") );
    pDC->OutputToken    ( GradientName );
    pDC->OutputNewLine  ();

    // Then the type definition.
    pDC->OutputToken    ( GradientName );
    pDC->OutputValue    ( static_cast<INT32> ( RadialFill ) );
    pDC->OutputValue    ( static_cast<INT32> ( Colours ) );
    pDC->OutputToken    ( _T("Bd") );
    pDC->OutputNewLine  ();
    pDC->OutputToken    ( _T("[") );
    pDC->OutputNewLine  ();

    // (ChrisG 3/4/2001) Get bias and convert to 0-100 range (from -1 to +1)
    CProfileBiasGain profile = pFill->GetProfile ();
    INT32 bias = (INT32) ((1 - (double) profile.GetBias ()) * 50);
        
    // Write out the start colour.
    WriteGradientEntry ( &StartColour, 0, bias );

    DocColour * pLastCol = &StartColour;
    INT32 lastPos = 0;

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

        // Write in the ramp's colour values.
        while ( pItem != NULL )
        {
            // Get the position of the colour in the fill.
            INT32       Ratio   = static_cast <INT32> ( 100 * pItem->GetPosition () );
            DocColour   *pCol   = pItem->GetColourAddr ();

            // Write out the intermediate fill steps (if there are any).
            if (effect != EFFECT_RGB)
            {
                WriteFillEffectSteps (pLastCol, lastPos, pCol, Ratio, bias, effect);
                pLastCol = pCol;
                lastPos = Ratio;
            }

            // And set the value.
            WriteGradientEntry ( pCol, Ratio, 50 );

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

    // Write out the intermediate fill steps (if there are any).
    if (effect != EFFECT_RGB)
    {
        WriteFillEffectSteps (pLastCol, lastPos, &EndColour, 100, bias, effect);
    }

    // Write out the last colour.
    WriteGradientEntry ( &EndColour, 100, 50 );

    // Write out the end of gradient tokens.
    pDC->OutputToken    ( _T("BD") );
    pDC->OutputNewLine  ();
    pDC->OutputToken    ( _T("%AI5_EndGradient") );
    pDC->OutputNewLine  ();

    // It worked!
    return TRUE;
}

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

>   virtual BOOL AIEPSRenderRegion::WriteGradientEntry ( DocColour  *pColour,
                                                         INT32      Position,
                                                         INT32      Midpoint )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/3/00
    Inputs:     pColour     - A pointer to a Camelot colour.
                Position    - The position of the colour within the fill.
                Midpoint    - The midpoint of the fill.
    Returns:    TRUE if successful.
                FALSE if error (e.g. file/disk error)
    Purpose:    Writes a line into the definition of a gradient fill.

********************************************************************************************/
BOOL AIEPSRenderRegion::WriteGradientEntry ( DocColour  *pColour,
                                             INT32      Position,
                                             INT32      Midpoint )
{
    INT32 red;                                          //
    INT32 green;                                            // RGB colour values
    INT32 blue;                                         //
    PColourCMYK CMYKColour;                             // The colour to be stored.

    KernelDC *pDC = (KernelDC*)CCDC::ConvertFromNativeDC(RenderDC);
    TCHAR       Line [80];                              // Contains the string to be stored.

    // (ChrisG 3/4/2001) 
    if (Midpoint < 13)
        Midpoint = 13;
    else if (Midpoint > 87)
        Midpoint = 87;

    pColour->GetCMYKValue ( &CMYKColour );              // Extract the CMYK value.

    if (pColour->GetColourModel () == COLOURMODEL_RGBT ||
        pColour->GetColourModel () == COLOURMODEL_HSVT)
    {
        // Use RGB syntax.
        pColour->GetRGBValue ( &red, &green, &blue );

        camSprintf ( Line, _T("2 %d %d%%_Bs"), Midpoint, Position );
        pDC->OutputColour       ( &CMYKColour );
        pDC->OutputColourValue  ( red );
        pDC->OutputColourValue  ( green );
        pDC->OutputColourValue  ( blue );
        pDC->OutputToken        ( Line );
        pDC->OutputNewLine      ();
    }
    else
    {

        // It is necessary to build the output line like this, so that there isn't a space
        // between the position of the colour, and the %_Bs operator.
        camSprintf ( Line, _T("1 %d %d%%_Bs"), Midpoint, Position );    // Build the output string.

        pDC->OutputColour   ( &CMYKColour );                // Write the colour to the file.
        pDC->OutputToken    ( Line );                       // Write the output string out.
        pDC->OutputNewLine  ();                             // And write a new-line tag.
    }

    return TRUE;                                        // All done successfully.
}

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

>   virtual BOOL AIEPSRenderRegion::WriteFillEffectSteps (  DocColour * pColour1,
                                                            INT32       pos1,
                                                            DocColour * pColour2,
                                                            INT32       pos2,
                                                            INT32       bias,
                                                            EFFECTTYPE  effect)

    Author:     Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com>
    Created:    4/4/2001
    Inputs:     pColour1    - The colour to start from.
                pos1        - The position of the start colour within the fill (0-100%).
                pColour2    - The colour to end at.
                pos2        - The position of the end colour within the entire fill (0-100%)
                bias        - The fill's bias part of any profile (0-100%).
                effect      - The type of fill effect (EFFECT_HSV_SHORT or EFFECT_HSV_LONG)
    Returns:    TRUE if successful.
                FALSE if error (e.g. file/disk error)
    Purpose:    Writes the additional entries required for a special fill effect (rainbow or
                alt-rainbow) to the gradient definition, as a series of steps.
    See Also:   AIEPSRenderRegion::WriteGradientEntry
                AIEPSRenderRegion::WriteLinearFill
                AIEPSRenderRegion::WriteRadialFill

********************************************************************************************/
BOOL AIEPSRenderRegion::WriteFillEffectSteps (  DocColour *pColour1,
                                                INT32 pos1, 
                                                DocColour *pColour2, 
                                                INT32 pos2, 
                                                INT32 bias, 
                                                EFFECTTYPE effect)
{
    ERROR3IF (effect == EFFECT_RGB, "AIEPSRenderRegion::WriteFillEffectSteps, an attempt was made to write HSV fill effect steps on an RGB fade fill");

    // RGB fades are the 'standard' fill, so we don't want to do any special processing on them
    if (effect != EFFECT_RGB)
    {
        // Start and end colour values
        INT32 h1 = 0;
        INT32 h2 = 0;
        INT32 s1 = 0;
        INT32 s2 = 0;
        INT32 v1 = 0;
        INT32 v2 = 0;

        // intermediate colour values / increments
        DocColour midColour;
        double hAdd = 0;
        double sAdd = 0;
        double vAdd = 0;
        double posAdd = 0;

        // First get the start and end colour components
        pColour1->GetHSVValue (&h1, &s1, &v1);
        pColour2->GetHSVValue (&h2, &s2, &v2);

        // Calculate the increments  
        //
        //  NOTE: if the hue changes by more than 180 deg. in a short HSV (rainbow) fill
        //  (or not more than 180 deg. in a long HSV (alt-rainbow) fill), then the direction
        //  must be reversed. This is done by changing the hue increment value.
        hAdd = h2-h1;
        if (effect == EFFECT_HSV_SHORT)
        {
            if (hAdd > 180)
                hAdd -= 360;
            else if (hAdd < -180)
                hAdd += 360;
        }
        else
        {
            if ((hAdd > 0) && (hAdd <= 180))
                hAdd -= 360;
            else if ((hAdd <= 0) && (hAdd >= -180))
                hAdd += 360;
        }
        hAdd = hAdd / (NumFillEmulationSteps + 1);
        sAdd = (s2-s1) / (NumFillEmulationSteps + 1);
        vAdd = (v2-v1) / (NumFillEmulationSteps + 1);
        posAdd = ((double) pos2-pos1) / (NumFillEmulationSteps + 1);

        // Cycle through the stops calcuating each stop's colour and position, before 
        //  writing them out.
        for (INT32 i=1; i<NumFillEmulationSteps + 1; i++)
        {
            // increment each colour value and the position
            h2 = (INT32)(h1 + (i * hAdd));
            s2 = (INT32)(s1 + (i * sAdd));
            v2 = (INT32)(v1 + (i * vAdd));
            pos2 = (INT32)(pos1 + (i * posAdd));

            // wrap the hue around if it's gone past 360 deg or 0 deg.
            if (h2>=360)
                h2 -= 360;
            else if (h2<0)
                h2 += 360;

            // create the colour and export.
            midColour.SetHSVValue (h2, s2, v2);
            WriteGradientEntry (&midColour, pos2, 50);
        }
    }   // End of is fill effect not an RGB fade.

    return TRUE;
}

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

>   virtual BOOL AIEPSRenderRegion::WriteDocumentSetup ( Document   *pDocument,
                                                         EPSFilter  *pFilter )

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/3/00
    Inputs:     pDocument   - The document being outputted.
                pFilter     - A pointer to the export filter.
    Outputs:    -
    Returns:    TRUE if successful.
                FALSE if error (e.g. file/disk error)
    Purpose:    Browse through the tree, and if a text story is found invoke the document
                setup function. By only exporting the font setup when necessary, the file
                size produced is smaller (which makes it easier for me to interpret :) ),
                and it should hopefully make the filter run a bit faster too.

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

BOOL AIEPSRenderRegion::WriteDocumentSetup ( Document   *pDocument,
                                             EPSFilter  *pFilter )
{
    // Get the spread from the document.
    Spread      *pSpread    = pDocument->FindFirstSpread ();
    Node        *pTextStory = NULL;

    // Try to find a single instance of the TextStory node.
    pTextStory = SliceHelper::FindNextOfClass ( pSpread, pSpread,
                                                CC_RUNTIME_CLASS ( TextStory ) );

    // If something was found...
    if ( pTextStory != NULL )
    {
        // ... write out the font set-up.
        pDocument->WriteEPSSetup ( pFilter );
    }
    else
    {
        // Otherwise just get the relevant bits.
        pDocument->AIExportExtras ( pFilter->GetExportDC () );
    }

    // It worked!
    return TRUE;
}

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

>   BOOL AIEPSRenderRegion::EndLayer ()

    Author:     Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/00
    Inputs:     -
    Returns:    TRUE    - Success.
                FALSE   - An error occured.
    Purpose:    If there is an existing layer, it writes the end of layer tags, before
                creating a new layer record.
    SeeAlso:    AIEPSRenderRegion::ExportLayer ()

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

BOOL AIEPSRenderRegion::EndLayer ()
{
    // Only act if there's an active layer.
    if ( m_ActiveLayer )
    {
        // Cast the RenderDC pointer into a useful form.
        KernelDC    *pDC    = static_cast<KernelDC *> ( CCDC::ConvertFromNativeDC(RenderDC) );

        // Write out the end of layer tag.
        pDC->OutputToken    ( _T("LB") );
        pDC->OutputNewLine</