epsfiltr.cpp

Go to the documentation of this file.

// $Id: epsfiltr.cpp 1668 2006-08-04 11:45:17Z 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============================
 */

// An EPS import/export filter system for Camelot.


#include "camtypes.h"
//#include "epsfiltr.h" - in camtypes.h [AUTOMATICALLY REMOVED]

#include <ctype.h>

//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "bitfilt.h"
#include "ccdc.h"
#include "colcomp.h"
#include "csrstack.h"
//#include "doccomp.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ensure.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "prvwflt.h"
#ifndef WEBSTER
//#include "extfilts.h"
#endif //WEBSTER
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "group.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "layer.h"
#include "lineattr.h"
#include "nativeps.h"   // old native filter based on eps, used for version 1.1  
#include "nodeelip.h"
#include "nodepath.h"
#include "noderect.h"
//#include "oilfltrs.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "page.h"
#include "paper.h"
//#include "pathname.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "paths.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "progress.h"        
//#include "resource.h"
//#include "rik.h"
#include "saveeps.h"
#include "sglayer.h"
#include "sprdmsg.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "tim.h"
//#include "trans2d.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "gclips.h"
#include "nodetxts.h"
#include "nodetxtl.h"
#include "nodershp.h"
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "insertnd.h"
#include "fontman.h"
#include "guides.h"
//#include "nev.h"      // _R(IDN_USER_CANCELLED)
//#include "will2.h"
#include "moldshap.h"
#include "ai_bmp.h"
//#include "epsclist.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "epscdef.h"
#include "nodetext.h"

DECLARE_SOURCE("$Revision: 1668 $");

CC_IMPLEMENT_DYNAMIC(EPSFilter, VectorFilter);
CC_IMPLEMENT_MEMDUMP(RangeList, List);
CC_IMPLEMENT_MEMDUMP(EPSClipContext, List);
CC_IMPLEMENT_MEMDUMP(EPSClipContextItem, ListItem);

#define new CAM_DEBUG_NEW

// Job 10463: remove PS Level bits - default to Level 2
INT32 EPSFilter::XSEPSExportPSType = 2;
INT32 EPSFilter::XSEPSExportDPI  = 200;
BOOL EPSFilter::XSEPSExportTextAsCurves = FALSE;

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

>   class RangeListItem : public ListItem

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/09/94
    Purpose:    Hold a range that
    SeeAlso:    

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

class RangeListItem : public ListItem
{
    CC_DECLARE_MEMDUMP(RangeListItem)

public:
    RangeListItem(Node *pFirst, Node *pLast);
    BOOL IsLayer;
    Range TheRange;
    Layer *TheLayer;
};

CC_IMPLEMENT_MEMDUMP(RangeListItem, ListItem)

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

>   RangeListItem::RangeListItem(Node *pFirst, Node *pLast)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/09/94
    Inputs:     pFirst, pLast - the first and last nodes in the range.
    Purpose:    Create a range list item using the specified node range.
    SeeAlso:    RangeListItem; RangeList

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

RangeListItem::RangeListItem(Node *pFirst, Node *pLast)
{
    // range or layer?
    if(pFirst == pLast && IS_A(pFirst, Layer))
    {
        // just a layer, so make a layer variant
        TheLayer = (Layer *)pFirst;
        IsLayer = TRUE;
    }
    else
    {
        // it's more than one, or not a layer
        
        // We want all nodes to be included in the range
        RangeControl Flags;
        Flags.Selected = TRUE;
        Flags.Unselected = TRUE;

        // Make the range and copy to where we want it (spot slight omission from Range class!)
        Range Tmp(pFirst, pLast, Flags);
        TheRange = Tmp;
        IsLayer = FALSE;
    }
}

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

>   BOOL RangeList::AddRange(Node *pFirst, Node *pLast)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/09/94
    Inputs:     pFirst, pLast - the first and last nodes in the range.
    Returns:    TRUE if the range was added ok;
                FALSE if not.
    Purpose:    Adds another range to the range list.  All nodes from pFirst to pLast
                are inclusively added to the range.
    SeeAlso:    Range

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

BOOL RangeList::AddRange(Node *pFirst, Node *pLast)
{
    // Get a new range
    RangeListItem *pItem = new RangeListItem(pFirst, pLast);
    if (pItem == NULL)
        // Out of memory
        return FALSE;

    // Add it to the list and return success
    AddTail(pItem);
    return TRUE;
}

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

>   DocRect RangeList::GetBoundingRect()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/09/94
    Returns:    The union of the bounding boxes of all nodes in this range list.
    Purpose:    Goes through all nodes in all the ranges in this RangeList, and unions
                all the bounding boxes together.  It uses the simple algorithm, which does
                not take account of the attributes applied to the nodes - i.e. it only
                gives an approximation (hence this function can result in bounding boxes
                being in the tree which are not entirely accurate).
    SeeAlso:    RangeList

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

DocRect RangeList::GetBoundingRect()
{
    // Start off with empty rectangle
    DocRect RangeBBox;

    // Do each range in turn
    RangeListItem *pItem = (RangeListItem *) GetHead();

    while (pItem != NULL)
    {
        // Do each node in turn
        if(pItem->IsLayer)
        {
            // layer based calcuations

            // see long note below
            RangeBBox = RangeBBox.Union(pItem->TheLayer->GetBoundingRect(TRUE));
        }
        else
        {
            // range based calculations
            Node *pNode = pItem->TheRange.FindFirst();

            while (pNode != NULL)
            {
                // Does this node have a bounding rectangle?
                if (pNode->IsBounded())
                {
                    // Yes - add it to our union
                    NodeRenderableBounded *pNodeBounded = (NodeRenderableBounded *) pNode;

                    // Pass in TRUE so that we don't do a 'proper' attribute scan for the
                    // bounding box - we only need an approximate bounding rectangle
                    // for centering it anyway.
                    // NB. this results in inaccurate bounding boxes in the tree, but when
                    //     we call this we're about to transform them anyway, so they'll
                    //     be updated correctly afterwards.
                    RangeBBox = RangeBBox.Union(pNodeBounded->GetBoundingRect(TRUE));
                }
                else
                {
                    ENSURE(FALSE, "Found a non-renderable node in the import range");
                }

                // Try the next node.
                pNode = pItem->TheRange.FindNext(pNode);
            }
        }

        // Try the next range
        pItem = (RangeListItem *) GetNext(pItem);
    }

    // Return the accumulated bounds
    return RangeBBox;
}

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

>   void RangeList::Transform(TransformBase& Trans)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/09/94
    Inputs:     Trans - the transform object to transform all the nodes by.
    Purpose:    Transforms all the nodes in all the ranges of this range list using the
                transform object given.
    SeeAlso:    Range::Transform; TransformBase

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

void RangeList::Transform(TransformBase& Trans)
{
    // Do each range in turn
    RangeListItem *pItem = (RangeListItem *) GetHead();

    while (pItem != NULL)
    {
        if(pItem->IsLayer)
        {
            pItem->TheLayer->Transform(Trans);
        }
        else
        {
            // Transform all nodes in this range
            Node *pNode = pItem->TheRange.FindFirst();

            while (pNode != NULL)
            {
                // Is this node renderable?
                if (pNode->IS_KIND_OF(NodeRenderable))
                {
                    // Yes - transform it.
                    NodeRenderable *pNodeRenderable = (NodeRenderable *) pNode;
                    pNodeRenderable->Transform(Trans);
                }
                else
                {
                    ENSURE(FALSE, "Found a non-renderable node in the import range");
                }

                // Try the next node.
                pNode = pItem->TheRange.FindNext(pNode);
            }
        }

        // Try the next range
        pItem = (RangeListItem *) GetNext(pItem);
    }
}

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

>   EPSClipContextItem::EPSClipContextItem(INT32 TheContextLevel, InkPath *pNewClipPath)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/22/95
    Inputs:     TheContextLevel - the context level for this clip region.
    Purpose:    Initialise the clip region item to sensible values.
    SeeAlso:    EPSClipContext

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

EPSClipContextItem::EPSClipContextItem(INT32 TheContextLevel, Path *pNewClipPath)
{
    ContextLevel = TheContextLevel;
    pClipPath = pNewClipPath;

    // Defaults to not a complex region.
    ComplexRegionLevel = 0;
}

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

>   EPSClipContextItem::~EPSClipContextItem()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/22/95
    Purpose:    Clean up the context item - this includes deleting the clipping path held
                in the region item.
    SeeAlso:    EPSClipContext

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

EPSClipContextItem::~EPSClipContextItem()
{
    delete pClipPath;
}

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

>   EPSClipContext::EPSClipContext()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/22/95
    Purpose:    Initialise the context to a sensible state, i.e. a zero context level.

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

EPSClipContext::EPSClipContext()
{
    ContextLevel = 0;
    ComplexRegionLevel = 0;

    // Initially there is no clip region.
    pCachedClipPath = NULL;
    CacheIsValid = TRUE;

    // set default clipping flags
    ClippingFlags = 2 | CLIPPING_CLIP_WINDING;
}

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

>   void EPSClipContext::SaveContext()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/22/95
    Purpose:    Save the current clipping state for future use - no matter how many
                clip regions are added to the current context, the exact state of the
                current clipping context can be restore with a (balanced) call to
                EPSClipContext::RestoreContext().
    SeeAlso:    EPSClipContext::RestoreContext

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

void EPSClipContext::SaveContext()
{
    ContextLevel++;
}

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

>   BOOL EPSClipContext::RestoreContext()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/22/95
    Purpose:    Restores the clipping context to the state it was in the last time
                SaveContext() was called on this clip context.
    Errors:     No call to SaveContext() has been made => ERROR2
    SeeAlso:    EPSClipContext::SaveContext

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

BOOL EPSClipContext::RestoreContext()
{
    // Invalidate cache
    CacheIsValid = FALSE;

    // Sanity check
    ERROR2IF(ContextLevel == 0, FALSE, "Unbalanced call to EPSClipContext::RestoreContext()");

    // Decrement context level
    ContextLevel--;

    // Delete all items added since save context was last called...
    EPSClipContextItem *pItem = (EPSClipContextItem *) GetTail();

    while ((pItem != NULL) && (pItem->ContextLevel > ContextLevel))
    {
        delete RemoveTail();
        
        // Get the next item
        pItem = (EPSClipContextItem *) GetTail();
    }

    // If we get here then it's ok
    return TRUE;
}


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

>   BOOL EPSClipContext::StartComplexClipRegion()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/22/95
    Returns:    TRUE if ok;
                FALSE if out of memory.
    Purpose:    Indicates that we are about to start constructing a complex clipping region.
                All future calls to AddNewClippingPath() will be joined into the current
                clipping region until EndComplexRegion is called.
                Note that you cannot interleave these calls with Save/Restore context calls;
                complex regions cannot be unbalanced across context levels.
    Errors:     Out of memory => ERROR1
    SeeAlso:    EPSClipContext::EndComplexClipRegion()

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

BOOL EPSClipContext::StartComplexClipRegion()
{
    // Update complex region count
    ComplexRegionLevel++;

    // We need to create a record to hold this complex region
    // (it has a NULL clipping region initially)
    EPSClipContextItem *pItem = new EPSClipContextItem(ContextLevel, NULL);
    if (pItem == NULL)
        // Out of memory
        return FALSE;

    // It's a complex region so save the level
    pItem->ComplexRegionLevel = ComplexRegionLevel;

    // Add to end of list
    AddTail(pItem);

    // All ok
    return TRUE;
}

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

>   BOOL EPSClipContext::EndComplexClipRegion()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/22/95
    Returns:    TRUE if ok;
                FALSE if no corresponding call to StartComplexClipRegion() has been 
                encountered => ERROR2
    Purpose:    See StartComplexClipRegion().
    Errors:     If unbalanced call is made => ERROR2
    SeeAlso:    EPSClipContext::StartComplexClipRegion

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

BOOL EPSClipContext::EndComplexClipRegion()
{
    ERROR2IF(ComplexRegionLevel == 0, FALSE, 
             "Unbalanced call to EPSClipContext::EndComplexClipRegion()");

    // Adjust complex region level.
    ComplexRegionLevel--;

    // All ok
    return TRUE;
}


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

>   BOOL EPSClipContext::AddNewClippingPath(Path *pNewClipPath)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/22/95
    Inputs:     The path to augment the current clipping region with.
    Returns:    TRUE if clipping region updated ok;
                FALSE if not, i.e. out of memory => ERROR1
    Purpose:    Takes a copy of the path passed in and merges it with the current clipping
                context.
    Errors:     Out of memory => ERROR1

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

BOOL EPSClipContext::AddNewClippingPath(Path *pNewClipPath)
{
    // Invalidate cache
    CacheIsValid = FALSE;

    // Flag to indicate if we just do a straightforward copy
    BOOL SimpleCopy = FALSE;

    EPSClipContextItem *pItem = NULL;

    if (ComplexRegionLevel > 0)
    {
        // We are building a complex region, so join the new path with the existing one.

        // First, make sure we have a clip path already?
        pItem = (EPSClipContextItem *) GetTail();
        if (pItem->pClipPath == NULL)
        {
            // No clip path - just copy the new path and use that.
            SimpleCopy = TRUE;
        }
        else
        {
            // Already have a clip path - join with new one to form a complex path.
            if (!pItem->pClipPath->MergeTwoPaths(*pNewClipPath))
                // Error occured (i.e. out of memory)
                return FALSE;
        }
    }
    else
    {
        // Just a simple clipping region
        pItem = new EPSClipContextItem(ContextLevel, NULL);

        if (pItem == NULL)
            // Out of memory
            return FALSE;

        // Add to end of list
        AddTail(pItem);

        // Just copy the path passed in
        SimpleCopy = TRUE;
    }

    // Should we just copy the path into the list item?
    if (SimpleCopy)
    {
        // Sanity check
        ERROR2IF(pItem == NULL, FALSE, "No clipping item found!");

        // (yes, this code is pretty tedious!)
        pItem->pClipPath = new Path;

        if (pItem->pClipPath == NULL)
            // Out of memory
            return FALSE;

        // Graeme (26/7/00) - Added a test for a NULL pointer to prevent access violations.
        if ( pNewClipPath != NULL &&
             !pItem->pClipPath->Initialise ( pNewClipPath->GetNumCoords () + 3, 12 ) )
        {
            // Failed to initialise - out of memory
            return FALSE;
        }

        if (!pItem->pClipPath->CopyPathDataFrom(pNewClipPath))
            // Failed to copy - out of memory - but this shouldn't happen as
            // we made sure we had enough space with the initialise call!
            ERROR2(FALSE, "Unexpected out-of-space error when copying clipping path");
    }

    // If we've got here, it must have worked...
    return TRUE;
}


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

>   BOOL EPSClipContext::ClipPathToRegion(Path *pPathToClip)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/22/95
    Inputs:     pPathToClip - the path object that we want to clip
    Outputs:    pPathToClip - the clipped version of the path
    Returns:    TRUE if clipped ok;
                FALSE if not.
    Purpose:    Given a path, clip it to the current clipping region specified by this
                object.
    SeeAlso:    EPSClipContext::GetClipRegion

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

BOOL EPSClipContext::ClipPathToRegion(Path *pPathToClip)
{
    // Cope with NULL clip region first
    if (GetClipRegion() == NULL)
        // Path is already 'clipped'
        return TRUE;

    // Ensure GetClipRegion validated the cache
    ERROR2IF(!CacheIsValid, FALSE, 
             "Could not get valid clipping path in EPSClipContext::ClipPathToRegion()");

    // We now have a valid region, so use it to clip the given path
    // NB. we do an intersection using the cliping path's winding, with a tolerance of 0,
    //     and flatness of 128 millipoints (arbitrary).
    if (pCachedClipPath->ClipPathToPath(*pPathToClip, pPathToClip, ClippingFlags, 
                                        128, 256, 256) == -1)
    {
        // An error occured...
        return FALSE;
    }

    // Initialise flags so the bezier tool is happy 
    // [see comment for Path::ClipPathToPath()].
    pPathToClip->InitialiseFlags();

    // If we get this far, it worked!
    return TRUE;
}

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

>   Path *EPSClipContext::GetClipRegion()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/22/95
    Returns:    Pointer to the clipping path, or
                NULL if no clipping region is specified by this object.
    Purpose:    Get the path which defines the current clipping region ofheld by this
                object.
    SeeAlso:    EPSClipContext::ClipPathToRegion

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

Path *EPSClipContext::GetClipRegion()
{
    if (!CacheIsValid)
    {
        // Cache is invalid - if there is no path in the cache, get a new one, otherwise
        // empty the one in the cache and use that.
        if (pCachedClipPath == NULL)
        {
            pCachedClipPath = new Path;

            if (pCachedClipPath == NULL)
                // Out of memory
                return NULL;

            if (!pCachedClipPath->Initialise(12, 12))
                // Failed to initialise - out of memory
                return NULL;
        }
        else
        {
            // Just clear this path out so we can use it to build a clipping region.
            pCachedClipPath->ClearPath();
        }

        // Calculate the current clipping path - we do this by going along the region
        // list and combining the clip regions.
        EPSClipContextItem *pItem = (EPSClipContextItem *) GetHead();

        while (pItem != NULL)
        {
            if (pItem->pClipPath != NULL)
            {
                // Do we already have a clipping region?
                if (pCachedClipPath->GetNumCoords() > 0)
                {
                    // Combine this clipping region with the region being constructed...
                    if (pItem->pClipPath->ClipPathToPath(*pCachedClipPath, pCachedClipPath, 
                                                         2 | CLIPPING_CLIP_WINDING, 
                                                         128, 256, 256) == -1)
                    {
                        // An error occured...
                        return FALSE;
                    }
                }
                else
                {
                    // No clipping region yet - just copy the data from this path
                    if (!pCachedClipPath->MakeSpaceInPath(pItem->pClipPath->GetNumCoords() + 3))
                        // Failed to initialise - out of memory
                        return FALSE;

                    if (!pCachedClipPath->CopyPathDataFrom(pItem->pClipPath))
                        // Failed to copy - out of memory - but this shouldn't happen as
                        // we made sure we had enough space with the initialise call!
                        ERROR2(FALSE, "Unexpected out-of-space error when copying clipping path");
                }
            }

            // Get the next item
            pItem = (EPSClipContextItem *) GetNext(pItem);
        }

        // Did we get any clipping at all?
        if (pCachedClipPath->GetNumCoords() == 0)
        {
            // No clip region - delete and use NULL to indicate this.
            delete pCachedClipPath;
            pCachedClipPath = NULL;
        }

        // Validate cache
        CacheIsValid = TRUE;
    }

    // Cache must be valid, so return the contents of the cache.
    return pCachedClipPath;
}


// This is the array of ArtWorks EPS command/keyword names.
CommandMap EPSFilter::Commands[] =
{
    // Path Construction operators
    { EPSC_l,       _T("l") },
    { EPSC_c,       _T("c") },
    { EPSC_m,       _T("m") },
    { EPSC_L,       _T("L") },
    { EPSC_C,       _T("C") },
    { EPSC_v,       _T("v") },
    { EPSC_V,       _T("V") },
    { EPSC_y,       _T("y") },
    { EPSC_Y,       _T("Y") },

    // Colour operators
    { EPSC_g,       _T("g") },
    { EPSC_G,       _T("G") },
    { EPSC_k,       _T("k") },
    { EPSC_K,       _T("K") },
    { EPSC_x,       _T("x") },
    { EPSC_X,       _T("X") },
    { EPSC_p,       _T("p") },
    { EPSC_P,       _T("P") },
    
    // Path Painting operators
    { EPSC_N,       _T("N") },
    { EPSC_n,       _T("n") },
    { EPSC_F,       _T("F") },
    { EPSC_f,       _T("f") },
    { EPSC_S,       _T("S") },
    { EPSC_s,       _T("s") },
    { EPSC_B,       _T("B") },
    { EPSC_b,       _T("b") },
    { EPSC__u,      _T("*u") },
    { EPSC__U,      _T("*U") },

    // Group operators
    { EPSC_u,       _T("u") },
    { EPSC_U,       _T("U") },
    
    // Graphics state operators
    { EPSC_A,       _T("A") },
    { EPSC_d,       _T("d") },
    { EPSC_i,       _T("i") },
    { EPSC_D,       _T("D") },
    { EPSC_j,       _T("j") },
    { EPSC_J,       _T("J") },
    { EPSC_M,       _T("M") },
    { EPSC_w,       _T("w") },

    // Special operators
    { EPSC_ArrayStart,_T("[") },
    { EPSC_ArrayEnd,_T("]") },
    { EPSC_Slash,   _T("/") },

    // Overprint operators
    { EPSC_O,       _T("O") },
    { EPSC_R,       _T("R") },

    // Clipping operators
    { EPSC_q,       _T("q") },
    { EPSC_Q,       _T("Q") },
    { EPSC_H,       _T("H") },
    { EPSC_h,       _T("h") },
    { EPSC_W,       _T("W") },
    
    // Text operators
    { EPSC_To,      _T("To") },
    { EPSC_TO,      _T("TO") },
    { EPSC_Tp,      _T("Tp") },
    { EPSC_TP,      _T("TP") },

    // Matrix operators
    { EPSC_Tm,      _T("Tm") },
    { EPSC_Td,      _T("Td") },
    { EPSC_T_,      _T("T*") },
    { EPSC_TR,      _T("TR") },

    // Text Attribute operators
    { EPSC_Tr,      _T("Tr") },
    { EPSC_Tf,      _T("Tf") },
    { EPSC_Ta,      _T("Ta") },
    { EPSC_Tl,      _T("Tl") },
    { EPSC_Tt,      _T("Tt") },
    { EPSC_TW,      _T("TW") },
    { EPSC_Tw,      _T("Tw") },
    { EPSC_TC,      _T("TC") },
    { EPSC_Tc,      _T("Tc") },
    { EPSC_Ts,      _T("Ts") },
    { EPSC_Ti,      _T("Ti") },
    { EPSC_Tz,      _T("Tz") },
    { EPSC_TA,      _T("TA") },
    { EPSC_Tq,      _T("Tq") },

    // Text Body operators
    { EPSC_Tx,      _T("Tx") },
    { EPSC_Tj,      _T("Tj") },
    { EPSC_TX,      _T("TX") },
    { EPSC_Tk,      _T("Tk") },
    { EPSC_TK,      _T("TK") },
    { EPSC_Tplus,   _T("T+") },
    { EPSC_Tminus,  _T("T-") },

    // Misc
    { EPSC_showpage,_T("showpage") },
    { EPSC_end,     _T("end") },
    { EPSC_ctx,     _T("ctx") },
    { EPSC_ctex,    _T("ctex") },

    { EPSC_Invalid, _T("Invalid") },

    { EPSC_Name,    _T("Name") },
    { EPSC_Integer, _T("Integer") },
    { EPSC_Double,  _T("Double") },
    { EPSC_FixedPoint,_T("FixedPt") },
    { EPSC_String,  _T("String") },
    { EPSC_Comment, _T("Comment") },
    { EPSC_EOL,     _T("EOL") },
    { EPSC_EOF,     _T("EOF") }
};


RangeList EPSFilter::ImportRange;

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

>   EPSFilter::EPSFilter()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/10/93
    Purpose:    Constructor for an EPSFilter object.  The object should be initialised
                before use.
    SeeAlso:    EPSFilter::Init

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

EPSFilter::EPSFilter()
{
    ImportMsgID = _R(IDT_IMPORTMSG_AI);
    Flags.CanImport = TRUE;
    //WEBSTER-Martin-27/01/97
#ifdef WEBSTER
    Flags.CanExport = FALSE;
#else
    Flags.CanExport = TRUE;
#endif //WEBSTER
    FilterID = FILTERID_AIEPS;

#ifndef DO_EXPORT
    Flags.CanExport = FALSE;
#endif

    EPSFile = NULL;
    TokenBuf = NULL;
    pColours = NULL;

    ExportDCPtr = NULL;
    ExportRegion = NULL;
    ExportMsgID = _R(IDT_EXPORTMSG_AI);

    AdjustOrigin = TRUE;
    SupportsLayers = TRUE;

    // The offsets into the file for the Preview thing
    EPSStart = 0;
    EPSEnd = 0;
    PreviewStart = 0;
    PreviewEnd = 0;

    TextComment[0] = 0;
    TextComment[1] = 0;
    TextComment[2] = 1;

    // set the font extras block vars. These indicate to the
    // filter to do something special with the next set of font attributes
    FontFlags.Bold = FALSE;
    FontFlags.Italic = FALSE;

    // Set the font type to assume we are loading true type fonts unless
    // told otherwise.
    ClassOfFont = FC_TRUETYPE;
    
    // Define the mould threshold default value.
    NewMouldThreshold = MOULD_V1THRESHOLD;

    //  We're not in a group at first.
    EPS_Group   =   FALSE;

    // Clear the length of the file to the end of the EPS code.
    EndOfEPS    = 0;

    // Set up the comment list. These are the known DSC comments, and how to handle them.
    EPSComments.Add ( _T("%%BeginProlog"),          _T("%%EndProlog"),          TRUE,   0 );
    EPSComments.Add ( _T("%%BeginSetup"),           _T("%%EndSetup"),           TRUE,   0 );
    EPSComments.Add ( _T("%%BeginDocument"),        _T("%%EndDocument"),        FALSE,  0 );
    EPSComments.Add ( _T("%%BeginPageSetup"),       _T("%%EndPageSetup"),       FALSE,  0 );
    EPSComments.Add ( _T("%%BeginDefaults"),        _T("%%EndDefaults"),        FALSE,  0 );
    EPSComments.Add ( _T("%%BeginEmulation"),       _T("%%EndEmulation"),       FALSE,  0 );
    EPSComments.Add ( _T("%%BeginPreview"),         _T("%%EndPreview"),         FALSE,  0 );
    EPSComments.Add ( _T("%%BeginFeature"),         _T("%%EndFeature"),         FALSE,  0 );
    EPSComments.Add ( _T("%%BeginFile"),            _T("%%EndFile"),            FALSE,  0 );
    EPSComments.Add ( _T("%%BeginFont"),            _T("%%EndFont"),            FALSE,  0 );
    EPSComments.Add ( _T("%%BeginProcSet"),         _T("%%EndProcSet"),         FALSE,  0 );
    EPSComments.Add ( _T("%%BeginResource"),        _T("%%EndResource"),        FALSE,  0 );
    EPSComments.Add ( _T("%%BeginCustomColor"),     _T("%%EndCustomColor"),     FALSE,  0 );
    EPSComments.Add ( _T("%%BeginProcessColor"),    _T("%%EndProcessColor"),    FALSE,  0 );
}

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

>   virtual BOOL EPSFilter::Init()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/10/93
    Returns:    FALSE => don't use this class for real filters!
    Purpose:    Initialise an EPSFilter object.  This is a base class and so should
                never actually be initialised so this function will always return FALSE,
                and also ENSURE in debug builds.

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

BOOL EPSFilter::Init()
{
    // This class is now used only as basis for deriving EPS filters - it should not
    // actually be used as a real filter.
    ENSURE(FALSE, "Base EPSFilter class called! Do not use this!");
    return FALSE;
}

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

>   BOOL EPSFilter::InitPrefs()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    06/01/95
    Purpose:    Initialise preferences for EPS formats.  This is used by the Camelot
                EPS export filter, and includes font mappings, DPI, PostScript language
                level control, and exporting text as curves.

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

BOOL EPSFilter::InitPrefs()
{
#ifndef STANDALONE

    // Register preferences for EPS output.
    Camelot.DeclareSection(_T("EPS"), 5);
    Camelot.DeclarePref(NULL, _T("ExportPSType"), &XSEPSExportPSType, 0, 2); 
    Camelot.DeclarePref(NULL, _T("ExportDPI"), &XSEPSExportDPI, 10, 600); 
    Camelot.DeclarePref(NULL, _T("ExportTextAsCurves"), &XSEPSExportTextAsCurves); 

    // Register preferences for font mappings from TrueType to PostScript names.
    // This is used by Camelot EPS (or any other filter or class that wants to use it).
    Camelot.DeclareSection( _T("EPSFontMapping"), 50);

    static const TCHAR FontMappings[][2][30] = 
    {
        // Standard PostScript font mappings

        //
        // TrueType name          =>    PostScript name
        //
        { _T("Times-New-Roman"),            _T("Times-Roman")                   },
        { _T("Times-New-Roman-Bold"),       _T("Times-Bold")                    },
        { _T("Times-New-Roman-Italic"),     _T("Times-Italic")                  },
        { _T("Times-New-Roman-BoldItalic"), _T("Times-BoldItalic")              },
        { _T("Arial"),                      _T("Helvetica")                     },
        { _T("Arial-Bold"),                 _T("Helvetica-Bold")                },
        { _T("Arial-Italic"),               _T("Helvetica-Oblique")             },
        { _T("Arial-BoldItalic"),           _T("Helvetica-BoldOblique")         },
        { _T("Courier-New"),                _T("Courier")                       },
        { _T("Courier-New-Bold"),           _T("Courier-Bold")                  },
        { _T("Courier-New-Italic"),         _T("Courier-Oblique")               },
        { _T("Courier-New-BoldItalic"),     _T("Courier-BoldOblique")           },
        { _T("Michael"),                    _T("Palatino-Roman")                },
        { _T("Michael-Bold"),               _T("Palatino-Bold")                 },
        { _T("Michael-Italic"),             _T("Palatino-Italic")               },
        { _T("Michael-BoldItalic"),         _T("Palatino-BoldItalic")           },
        { _T("NewSchbook"),                 _T("NewCenturySchlbk-Roman")        },
        { _T("NewSchbook-Bold"),            _T("NewCenturySchlbk-Bold")         },
        { _T("NewSchbook-Italic"),          _T("NewCenturySchlbk-Italic")       },
        { _T("NewSchbook-BoldItalic"),      _T("NewCenturySchlbk-BoldItalic")   },
        { _T("ZapfDingbatsBT"),             _T("ZapfDingbats")                  },
        { _T("Symbol"),                     _T("Symbol")                        },

#if 0
        // Currently we have no TrueType equivalents for these fonts.
        { _T(""),                           _T("AvantGarde-Book")               },
        { _T(""),                           _T("AvantGarde-Demi")               },
        { _T(""),                           _T("AvantGarde-BookOblique")        },
        { _T(""),                           _T("AvantGarde-DemiOblique")        },
        { _T(""),                           _T("Bookman-Light")                 },
        { _T(""),                           _T("Bookman-Demi")                  },
        { _T(""),                           _T("Bookman-LightItalic")           },
        { _T(""),                           _T("Bookman-DemiItalic")            },
        { _T(""),                           _T("ZapfChancery-MediumItalic")     },
#endif

        // Terminator
        { _T(""),                           _T("")                              }
    };

    // Loop to declare all of these font mappings...
    INT32 i = 0;
    while (camStrclen(FontMappings[i][0]) > 0)
    {
        Camelot.SetPrefDirect( _T("EPSFontMapping"), 
                              (TCHAR *) &FontMappings[i][0][0], 
                              &FontMappings[i][1][0]); 
        i++;
    }

#endif

    // All ok
    return TRUE;
}

// The size of the buffer used to hold tokens
const INT32 TokenBufSize = 256;

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

>   BOOL EPSFilter::PrepareToImport()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/02/94
    Returns:    TRUE if succeeded, FALSE if not (e.g. no memory for EPS stack)
    Purpose:    Prepare to import EPS data using this filter.  This sets up the filter
                to a sensible state for reading.
    Errors:     Out of memory.
    SeeAlso:    EPSFilter::DoImport; EPSFilter::CleanUpAfterImport
    Scope:      Private

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

BOOL EPSFilter::PrepareToImport()
{
    if (!SetUpCurrentAttrs())
        return FALSE;

    // Start the selection operation.
    if (!ImportInfo.pOp->DoStartSelOp(FALSE))
        return FALSE;

    // Error if no file object.
    if (EPSFile == NULL)
        return FALSE;

    // Get ready to parse EPS tokens.
    EPSFile->InitLexer();
    EPSFile->SetDelimiters("()<>[]{}/%");
    EPSFile->SetCommentMarker('%');
    EPSFile->SetStringDelimiters("()");

    TokenBuf = EPSFile->GetTokenBuf();
    Token = EPSC_Invalid;

    EPSFlags.ComplexPath = 0;//FALSE;
    EPSFlags.StrokeComplexPath = FALSE;
    EPSFlags.NoAttributes = FALSE;
    EPSFlags.EPSErrorEncountered = FALSE;
    EPSFlags.AddToNewLayer = FALSE;
    EPSFlags.PathIsHidden = FALSE;

    ThePathType = PATH_NORMAL;


    // Decide whether we need to use layers or not
    // Neville 7/8/97 - Layers are bad in Webster as they conflict with frames
    // Now the same is true in Camelot
#ifndef WEBSTER