bmpcomp.cpp

Go to the documentation of this file.

// $Id: bmpcomp.cpp 1708 2006-08-17 17:13:38Z gerry $
/* @@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============================
 */

// Kernel level parts of bitmap lists

/*
*/

#include "camtypes.h"
#include "bmpcomp.h"
//#include "bmplist.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "bitmap.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "bitmpinf.h"
#include "bmpsrc.h"
#include "ccbuffil.h"
//#include "list.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "will.h"
#include "nativeps.h"       // The old style EPS native filter, used in v1.1

#include "clipint.h"
#include "nodebmp.h"
//#include "progress.h"

#include "toollist.h"
#include "objchge.h"
#include "csrstack.h"

#include "clipint.h"
#include "ophist.h"
#include "sgliboil.h"
//#include "will2.h"

#include "expbmp.h"     // ExportedBitmaps handling class
#include "impbmp.h"     // ImportedBitmaps handling class
//#include "camfiltr.h" // BaseCamelotFilter - version 2 native filter - in camtypes.h [AUTOMATICALLY REMOVED]
#include "cxftags.h"    // TAG_DEFINEBITMAP_****
#include "cxfile.h"     // CXF_UNKNOWN_SIZE
//#include "cxfrech.h"  // CXaraFileRecordHandler - in camtypes.h [AUTOMATICALLY REMOVED]
#include "expcol.h"     // ExportedColours handling class
//#include "cxfrec.h"       // CXaraFileRecord handler - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "tim.h"      // _R(IDT_CANT_FIND_FILTER)
//#include "filtrres.h" // _R(IDS_DONT_SUPPORT_BITMAP_TYPE) _R(IDS_NATIVE_BITMAPWARNING)
#include "bitfilt.h"    // BaseBitmapFlter
//#include "fixmem.h"       // CCMalloc, CCFree - in camtypes.h [AUTOMATICALLY REMOVED]

CC_IMPLEMENT_MEMDUMP( BitmapList, List )
CC_IMPLEMENT_DYNAMIC( BitmapListComponentClass, DocComponentClass )
CC_IMPLEMENT_DYNAMIC( BitmapListComponent, DocComponent )

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

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

>   BitmapList::BitmapList()

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    BitmapList constructor

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

BitmapList::BitmapList()
{
    ParentDoc = NULL;               // Document containing this list
}

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

>   BitmapList::~BitmapList()

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    BitmapList destructor

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

BitmapList::~BitmapList()
{
    ListItem* pItem = GetHead();
    ListItem* pNextItem;

    while (pItem)
    {
        pNextItem = GetNext(pItem);

        KernelBitmap* pBmp = (KernelBitmap*)pItem;

        ERROR3IF(pBmp->GetParentBitmapList() != this, "Bad ParentList ptr found in bitmap (during BitmapList destructor)");
        
        // if this bitmap is used by a brush we don't want to delete it here.
        if (!pBmp->IsUsedByBrush())
            delete pBmp;    // This should remove it from the list first
        else
        {
            pBmp->Detach();
            RemoveItem(pBmp);
        }

        pItem = pNextItem;
    }

    // Tidy up the global bitmap list
    Camelot.GetGlobalBitmapList()->DeleteAllUnusedBitmaps();
}

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

>   void BitmapList::Init(BaseDocument *ParentDocument)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     ParentDocument - the parent document of this Bitmap list
    Purpose:    BitmapList initialiser. MUST be called after constructing a BitmapList
                in order to correctly initialise it. Note that if ParentDocument is not
                set to a useful value, some operations on Bitmap lists will fail.

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

void BitmapList::Init(BaseDocument *ParentDocument)
{
    ERROR3IF(ParentDocument == NULL, "NULL ParentDoc in BitmapList::Init!\n");

    // Ensure the default bitmap is always in the list.
    KernelBitmap* Default = new KernelBitmap();
    Default->Attach(this);

    ParentDoc = ParentDocument;
}

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

>   BOOL BitmapList::AddItem(KernelBitmap *Item)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Returns:    TRUE
    Purpose:    Adds an item to the tail of the Bitmaplist, and incremeants it's usage count.
                (Unless it's already in the list, in which case it's usage count is just
                bumped up).

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

BOOL BitmapList::AddItem(KernelBitmap *Item)
{
    ERROR3IF(Item == NULL, "Trying to add NULL item to Bitmap List");
    
    if (Item == NULL)
        return FALSE;

    // Is this Bitmap already in the list ?
    LISTPOS pos = FindPosition((ListItem*)Item);

    if (pos == NOT_IN_LIST || pos == EMPTY_LIST)
    {
        // It's not in the list yet, so add it on the end
        AddTail((ListItem*)Item);

        if (ParentDoc != NULL)
        {
            BROADCAST_TO_ALL(BitmapListChangedMsg(this)); 
        }

        return TRUE;
    }
    else
    {
        // It's already in the list, so just return
        // (It's usage count has already been incremeanted)
        return FALSE;
    }
}

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

>   BOOL BitmapList::RemoveItem(KernelBitmap *Item)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Returns:    TRUE
    Purpose:    Removes an item from the list.

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

BOOL BitmapList::RemoveItem(KernelBitmap *Item)
{
    ERROR3IF(Item == NULL, "Trying to remove NULL item from Bitmap List");
    
    if (Item == NULL)
        return FALSE;

    // Is this Bitmap in the list ?
    LISTPOS pos = FindPosition((ListItem*)Item);

    if (pos != NOT_IN_LIST || pos == EMPTY_LIST)
    {
        // It's not in the list yet, so add it on the end
        List::RemoveItem((ListItem*)Item);
        Item->m_pParentList = NULL;

        if (ParentDoc != NULL)
        {
            BROADCAST_TO_ALL(BitmapListChangedMsg(this)); 
        }

        return TRUE;
    }
    else
    {
        // It's not in the list, so just return
        return FALSE;
    }
}

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

>   BOOL BitmapList::MoveBefore(KernelBitmap *InsertPoint, KernelBitmap *ItemToMove)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Returns:    TRUE
    Purpose:    Re-arranges the bitmaps in the list.

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

BOOL BitmapList::MoveBefore(KernelBitmap *InsertPoint, KernelBitmap *ItemToMove)
{
    List::RemoveItem((ListItem*)ItemToMove);
    List::InsertBefore((ListItem*)InsertPoint, (ListItem*)ItemToMove);

    if (ParentDoc != NULL)
    {
        BROADCAST_TO_ALL(BitmapListChangedMsg(this)); 
    }

    return TRUE;
}

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

>   BOOL BitmapList::MoveAfter(KernelBitmap *InsertPoint, KernelBitmap *ItemToMove)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Returns:    TRUE
    Purpose:    Re-arranges the bitmaps in the list.

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

BOOL BitmapList::MoveAfter(KernelBitmap *InsertPoint, KernelBitmap *ItemToMove)
{
    List::RemoveItem((ListItem*)ItemToMove);
    List::InsertAfter((ListItem*)InsertPoint, (ListItem*)ItemToMove);

    if (ParentDoc != NULL)
    {
        BROADCAST_TO_ALL(BitmapListChangedMsg(this)); 
    }

    return TRUE;
}

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

>   BaseDocument *BitmapList::GetParentDocument(void)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Returns:    The document in which this Bitmap list resides
    Purpose:    To find the parent document of this Bitmap list

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

BaseDocument *BitmapList::GetParentDocument(void)
{
    ERROR3IF(ParentDoc == NULL, "Uninitialised BitmapList detected!");
    return(ParentDoc);
}

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

>   KernelBitmap* BitmapList::FindDuplicateBitmap(OILBitmap* pBitmap)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    14/8/96
    Purpose:    Looks to see if an identical bitmap is already in the bitmap list

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

KernelBitmap* BitmapList::FindDuplicateBitmap(OILBitmap* pOILBitmap)
{
    ListItem* pItem = GetHead();
    while (pItem != NULL)
    {
        KernelBitmap* pBmp = (KernelBitmap*)pItem;

        if (pBmp->ActualBitmap &&
            pBmp->ActualBitmap != pOILBitmap &&
            *pBmp->ActualBitmap == *pOILBitmap)
        {
            return pBmp;
        }

        pItem = GetNext(pItem);
    }

    return NULL;
}

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

>   KernelBitmap* BitmapList::FindDefaultBitmap()

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/8/96
    Purpose:    Finds the default bitmap in this bitmap list

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

KernelBitmap* BitmapList::FindDefaultBitmap()
{
    ListItem* pItem = GetHead();
    while (pItem != NULL)
    {
        KernelBitmap* pBmp = (KernelBitmap*)pItem;

        if (pBmp->ActualBitmap &&
            pBmp->ActualBitmap == OILBitmap::Default)
        {
            return pBmp;
        }

        pItem = GetNext(pItem);
    }

    return NULL;
}


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

>   BOOL BitmapListComponentClass::Init()

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Returns:    TRUE if all went well;
                FALSE if not.
    Purpose:    Register the Bitmap list document component with the main application.
    Errors:     Out of memory.
    SeeAlso:    DocComponent

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

BOOL BitmapListComponentClass::Init()
{
    // Instantiate a component class to register with the application.
    BitmapListComponentClass *pClass = new BitmapListComponentClass;
    if (pClass == NULL)
        return FALSE;

    // Register it
    GetApplication()->RegisterDocComponent(pClass);

    // All ok
    return TRUE;
}


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

>   BOOL BitmapListComponentClass::AddComponent(BaseDocument *pDocument)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     pDocument - the document to add the Bitmap list to.
    Returns:    TRUE if the Bitmap list was added ok;
                FALSE if not.
    Purpose:    Add a Bitmap list component to the specified document.
    Errors:     Out of memory
    SeeAlso:    BitmapListComponentClass

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

BOOL BitmapListComponentClass::AddComponent(BaseDocument *pDocument)
{
    // Check to see if this document already has a Bitmap list; if so, leave it alone.
    if (pDocument->GetDocComponent(CC_RUNTIME_CLASS(BitmapListComponent)) != NULL)
        return TRUE;

    // No Bitmap list - try to create a new one for this document.
    BitmapList *pList = new BitmapList;
    if(pList == NULL)
        return FALSE;

    pList->Init(pDocument);     // Let the BitmapList know what its parent document is

    // Ok - create the Bitmap list component using this list.
    BitmapListComponent *pComponent = new BitmapListComponent(pList);
    if (pComponent == NULL)
    {
        // Out of memory...
        delete pList;
        return FALSE;
    }

    // All ok - add the component to the document.
    pDocument->AddDocComponent(pComponent);
    return TRUE;
}



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

>   BitmapListComponent::BitmapListComponent()

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Purpose:    Construct a Bitmap list component. DO NOT use this constructor. It gives
                and ERROR3 (and sets up this in a semi-safe default state)
    SeeAlso:    BitmapListComponent

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

BitmapListComponent::BitmapListComponent()
{
    ERROR3("BitmapListComponent constructed with default constructor!?\n");
}



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

>   BitmapListComponent::BitmapListComponent(BitmapList *pBmpList)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     pColList - the Bitmap list to use for this Bitmap list componet.
    Purpose:    Construct a Bitmap list component using the given Bitmap list.
    Errors:     ENSURE if pColList is NULL.
    SeeAlso:    BitmapListComponent

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

BitmapListComponent::BitmapListComponent(BitmapList *pBmpList)
{
    ENSURE(pBmpList != NULL, "NULL Bitmap list in Bitmap list component constructor!");

    // Install this Bitmap list.
    pBitmaps = pBmpList;

    // Initialise Exporter bitmap list
    pExportedBitmaps = NULL;

    // Initialise Importer bitmap list
    pImportedBitmaps = NULL;

    // Our link to the BaseCamelotFilter
    pCamFilter = NULL;
    // Set our variable so that we warn about a possible replacement only once
    WarnedBefore = FALSE;

    // Initialise Exporter bitmap list (used for EPS only)
    pBitmapsToExport = NULL;
}

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

>   BitmapListComponent::~BitmapListComponent()

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Purpose:    Clean up a Bitmap list component's data structures - deletes the Bitmap
                list.
    Errors:     -
    SeeAlso:    BitmapListComponent

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

BitmapListComponent::~BitmapListComponent()
{
    // Delete our Bitmap list.
    delete pBitmaps;

    // As we have finished with it now, destroy the list of imported bitmaps
    if (pImportedBitmaps)
    {
        delete pImportedBitmaps;
        pImportedBitmaps = NULL;
    }

    // As we have finished with it now, destroy the list of exported bitmaps
    if (pExportedBitmaps)
    {
        delete pExportedBitmaps;
        pExportedBitmaps = NULL;
    }

    if (pBitmapsToExport)
    {
        delete pBitmapsToExport;
        pBitmapsToExport = NULL;
    }
}



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

>   BOOL BitmapListComponent::EPSStartImport(EPSFilter *pFilter)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     pFilter - the EPS filter that is being used to import a file.
    Purpose:    Inform the Bitmap list document component that an EPS import is about to 
                start.
    SeeAlso:    DocComponent

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

BOOL BitmapListComponent::EPSStartImport(EPSFilter *pFilter)
{
    return FALSE;
}

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

>   void BitmapListComponent::EPSEndImport(EPSFilter *pFilter, BOOL Success)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     pFilter - the EPS filter that is being used to import a file.
                Success - TRUE => The import was successful;
                         FALSE => The import failed - abandon any changes.
    Purpose:    Inform the Bitmap list document component that an EPS import has just 
                finished.
    SeeAlso:    DocComponent

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

void BitmapListComponent::EPSEndImport(EPSFilter *pFilter, BOOL Success)
{
}

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

>   BOOL BitmapListComponent::EPSStartExport(EPSFilter *pFilter)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     pFilter - the EPS filter that is being used to import a file.
    Purpose:    Inform the Bitmap list document component that an EPS export is about to 
                start.
    SeeAlso:    DocComponent

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

BOOL BitmapListComponent::EPSStartExport(EPSFilter *pFilter)
{
#ifdef DO_EXPORT
    ERROR3IF(pBitmapsToExport != NULL, "Why is there an export bitmap list already ?");
    
    // Build the list of bitmaps to export here ...
    pBitmapsToExport = new ExportedBitmaps();

    ERROR3IF(pBitmapsToExport == NULL, "Couldn't create bitmap export list !!");
    if (pBitmapsToExport == NULL)
        return FALSE;

    Document* ParentDoc = (Document*)pBitmaps->GetParentDocument();
    ERROR3IF(ParentDoc == NULL, "Bitmap list has no parent document !!");
    if (ParentDoc == NULL)
    {
        delete pBitmapsToExport;
        pBitmapsToExport = NULL;
        return FALSE;
    }

    UINT32 BitmapNumber = 0;

    // Scan the document's tree for bitmap references
    Node* pNode = Node::DocFindFirstDepthFirst(ParentDoc);
    while (pNode != NULL)
    {
        // Ignore hidden nodes
        if (!pNode->IsNodeHidden())
        {
            INT32 Count = 0;

            // Does this node have any bitmaps in it ?
            KernelBitmap* pBitmap = pNode->EnumerateBitmaps(Count++);

            while (pBitmap != NULL)
            {
                // Check for a deleted bitmap
                if (pBitmap->HasBeenDeleted())
                {
                    ERROR2IF(pBitmap->GetParentBitmapList() == NULL, 0L, "Deleted bitmap has no parent list");
                    
                    // Use the default bitmap instead
                    pBitmap = pBitmap->GetParentBitmapList()->FindDefaultBitmap();

                    // There should always be a default bitmap at the start of the list
                    ERROR2IF(pBitmap == NULL, 0L, "Couldn't find the default bitmap");
                }

                // Found a bitmap reference, so ...
                // .. if this bitmap is not in the export list, add it
                if (pBitmapsToExport->GetBitmap(pBitmap) == NULL)
                    pBitmapsToExport->AddBitmap(pBitmap, BitmapNumber++);
                
                pBitmap = pNode->EnumerateBitmaps(Count++);             
            }
        }

        // Move onto the next node in the tree
        pNode = pNode->DocFindNextDepthFirst(); 
    }
#endif
    return TRUE;
}

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

>   void BitmapListComponent::EPSEndExport(EPSFilter *pFilter, BOOL Success)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     pFilter - the EPS filter that is being used to import a file.
                Success - TRUE => The import was successful;
                         FALSE => The import failed - abandon any changes.
    Purpose:    Inform the Bitmap list document component that an EPS export has just 
                finished.
    SeeAlso:    DocComponent

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

void BitmapListComponent::EPSEndExport(EPSFilter *pFilter)
{
#ifdef DO_EXPORT
    if (pBitmapsToExport)
    {
        delete pBitmapsToExport;
        pBitmapsToExport = NULL;
    }
#endif
}

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

>   BOOL BitmapListComponent::WriteEPSComments(EPSFilter *pFilter)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     pFilter - the filter being used to import the EPS file.
    Returns:    TRUE if the Bitmap table was written successfully;
                FALSE if not.
    Purpose:    Writes out the Bitmap table in the form of EPS comments in the 'header'
                comments of the EPS file.
    Errors:     Out of disk space, and similar disk errors.
    SeeAlso:    DocComponent::WriteEPSComments;
                DocComponent

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

BOOL BitmapListComponent::WriteEPSComments(EPSFilter *pFilter)
{
    return TRUE;
}


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

>   BOOL BitmapListComponent::WriteScript(EPSFilter* pFilter)

    Author:     Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/1/95
    Inputs:     pFilter - the EPS filter that is being used to export a file.
    Returns:    TRUE if the Script for this component was written out successfully;
                FALSE if not (e.g. out of disk space etc)
    Purpose:    This is called after all the Comments, Prolog etc have been output so that
                DocComponents get a chance to do something right at the start of the real
                EPS data, but before the tree starts to be exported.
                (The base class does nothing)
    SeeAlso:    DocComponent::WriteEPSSetup; 
                DocComponent::WriteEPSProlog;
                DocComponent::ProcessEPSComment; 
                DocComponent; 
                EPSFIlter

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

BOOL BitmapListComponent::WriteScript(EPSFilter* pFilter)
{
#ifdef DO_EXPORT
    // This only happens in Native EPS
    if (pFilter->IS_KIND_OF(CamelotNativeEPSFilter))
    {
        // Find out the context to save to
        EPSExportDC *pDC = pFilter->GetExportDC();

        // Make sure that there's a bitmap list to export.
        if (pBitmapsToExport == NULL)
        {
            ERROR3 ( "Why isn't there an export bitmap list (in WriteScript) ?" );
            return FALSE;
        }

        // Something to mark the start of the bitmap pool
        pDC->OutputToken(_T("%%BeginCamelotBitmapPool"));
        pDC->OutputNewLine();

        // Tell the filter we are starting to save the bitmap pool
        ((CamelotNativeEPSFilter*)pFilter)->IsSavingBitmapPool = TRUE;

        // Find the number of Bitmaps
        INT32 TotalBitmaps = pBitmapsToExport->GetCount();

        // Output a comment saying how many bitmaps we have
        pDC->OutputToken(_T("%%BitmapPoolCount"));
        pDC->OutputValue(TotalBitmaps);
        pDC->OutputNewLine();

        INT32 BitmapNum = 0;

        // Find the first bitmap in the list again
        ExportBitmap* pExportBitmap = pBitmapsToExport->EnumerateBitmaps();

        while (pExportBitmap != NULL)
        {
            ERROR3IF(pExportBitmap->RecordNumber != BitmapNum, "Bad bitmap number found when saving bitmap pool");
                
            // Save the bitmap out
            ExportBitmapPoolItem(BitmapNum, pFilter, pDC, pExportBitmap->pBmp);

            BitmapNum++;

            // Find the next one
            pExportBitmap = pBitmapsToExport->EnumerateBitmaps(pExportBitmap);
        }

        // Tell the filter we are starting to save the bitmap pool
        ((CamelotNativeEPSFilter*)pFilter)->IsSavingBitmapPool = FALSE;

        // Something to mark the start of the bitmap pool
        pDC->OutputToken(_T("%%EndCamelotBitmapPool"));
        pDC->OutputNewLine();
    }

#endif
    return TRUE;
}



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

>   BOOL BitmapListComponent::ExportBitmapPoolItem(INT32 BitmapNum, EPSFilter* pFilter,
                                                   EPSExportDC* pDC, KernelBitmap* pBitmap)

    Author:     Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/1/95
    Inputs:     BitmapNum - The number of the Kernel bitmap in the pool
                pFilter - The filter that things are being saved in
                pDC - The DC that the saving is happening in
                pBitmap - The Kernel Bitmap to be saved
    Returns:    TRUE if it worked, FALSE if not
    Purpose:    Does the actual saving for a bitmap pool item. This uses the cbmp token to
                represent the Camelot BitMap Pool object.

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

BOOL BitmapListComponent::ExportBitmapPoolItem(INT32 BitmapNum, EPSFilter* pFilter, EPSExportDC* pDC, KernelBitmap* pBitmap)
{
#ifdef DO_EXPORT
    ERROR2IF(pBitmap->HasBeenDeleted(), FALSE, "Trying to export a deleted bitmap");
    
    if (pFilter->IS_KIND_OF(CamelotNativeEPSFilter))
    {
        // ...then the bitmap object token.
        pDC->OutputValue(BitmapNum);            // Output the number of the bitmap
        pDC->OutputValue(INT32(0));             // Bitmap pool type (ready for expansion)
        pDC->OutputToken(_T("cbmp"));               // Bitmap pool token
        pDC->OutputNewLine();
        
        // ...and then the bitmap data itself.
        pFilter->ExportBitmap(*pBitmap);

        // Tell caller we rendered ourselves ok
        return TRUE;
    }
#endif
    return FALSE;
}


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

>   ProcessEPSResult BitmapListComponent::ProcessEPSComment(EPSFilter *pFilter, 
                                                            const char *pComment)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     pFilter - the EPS filter that is being used to import a file.
                pComment - pointer to the comment to process.
    Returns:    EPSCommentUnknown    - This EPS comment is not recognised by the document
                                       component.
                EPSCommentError      - This EPS comment was recognised by this document
                                       component, but it contained an error.
                EPSCommentOK         - This EPS comment was recognised as a legal comment by 
                                       this document component, and was processed
                                       successfully.
    Purpose:    Process an EPS comment - if this is a Bitmap table comment, this component
                will claim it and try to decode it.
    Errors:     Badly formed EPS comment.
    SeeAlso:    DocComponent::ProcessEPSComment

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

ProcessEPSResult BitmapListComponent::ProcessEPSComment(EPSFilter *pFilter, 
                                                        const char *pComment)
{
    // Ignore all comments
    return EPSCommentUnknown;
}




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

>   void BitmapListComponent::EndOfEPSComment(EPSFilter *pFilter)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     pFilter - the EPS filter that is being used to import a file.
    Purpose:    Informs the document component that the comment it has been decoding has
                now finished, and it should take whatever action required to act on
                the comment.
    SeeAlso:    DocComponent::EndOfPESComment

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

void BitmapListComponent::EndOfEPSComment(EPSFilter *pFilter)
{
    // Do any cleanup we need to here after loading in a Bitmap table...
}



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

>   INT32 BitmapListComponent::GetSizeOfExport(Filter *pFilter)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/01/95
    Inputs:     pFilter - the export filter that will be used.
    Returns:    An approximation of the size of data that will be exported by this
                bitmap list, in terms of nodes. (see NodeRenderable::GetSizeOfExport).
    Purpose:    Find out how many nodes will be exported when this bitmap list is exported.
                The node can use the filter to find out how it will be exported, e.g.
                bitmap lists should return a value that reflects whether or not bitmap
                indirection is possible with this filter and so on.
                NB. This is virtual - the default implementation just returns 1 - only
                    override if this is not accurate.
    SeeAlso:    Node::NeedsToExport; Node::ExportRender; NodeRenderable::GetSizeOfExport

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

INT32 BitmapListComponent::GetSizeOfExport(Filter *pFilter)
{
#ifdef DO_EXPORT
    // Check if this filter supports bitmap pools
    if (pFilter->GetBitmapSupportLevel() != IndirectedBitmapSupport)
        // No - just return 1.
        return 1;

    ERROR3IF(pBitmapsToExport == NULL, "Why isn't there an export bitmap list (in GetSizeOfExport) ?");
    if (pBitmapsToExport == NULL)
        return 1;

    INT32 TotalScanlines = 0;

    // Find the first bitmap in the list again
    ExportBitmap* pExportBitmap = pBitmapsToExport->EnumerateBitmaps();

    while (pExportBitmap != NULL)
    {
        KernelBitmap* pBitmap = pExportBitmap->pBmp;

        // Get information on this bitmap.
        BitmapInfo Info;
        if (!pBitmap->ActualBitmap->GetInfo(&Info))
            // Failed for some reason - bodge the answer.
            return 1;

        // Add the number of scanlines to our total
        TotalScanlines += Info.PixelHeight;

        // Find the next one
        pExportBitmap = pBitmapsToExport->EnumerateBitmaps(pExportBitmap);
    }
    
    // Return size to caller.
    if (TotalScanlines == 0)
        return 1;
    else
        return TotalScanlines;
#else
    return 0;
#endif
}



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

>   virtual BOOL BitmapListComponent::StartComponentCopy();

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if it succeeded. FALSE if the copy must be aborted
    Purpose:    This function gets called to prepare for a copy of Bitmaps into
                the document. It sets up the various arrays and other thangs which the
                Bitmap copy will need.
    Errors:     ENSURE failure if called when a component copy is already under way.
                Errors will be reported if memory is unavailable
    SeeAlso:    BitmapListComponent::EndComponentCopy;
                BitmapListComponent::AbortComponentCopy;
                BitmapListComponent::CopyBitmapAcross

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

BOOL BitmapListComponent::StartComponentCopy()
{
    return(TRUE);
}



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

>   virtual BOOL BitmapListComponent::EndComponentCopy();

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if it succeeded
    Purpose:    Will commit all changes made by doing the component copy, returning TRUE.
    Errors:     -
    Notes:      May be called multiple times - subsequent calls will be ignored

    SeeAlso:    BitmapListComponent::StartComponentCopy;
                BitmapListComponent::AbortComponentCopy;
                BitmapListComponent::CopyBitmapAcross

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

BOOL BitmapListComponent::EndComponentCopy()
{
    return(TRUE);
}


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

>   virtual void BitmapListComponent::AbortComponentCopy();

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Will abort all changes made for component copies.
                This means that things such as the Bitmaps referenced by the nodes
                you have just copied do not exist, so you must clean up to the state
                the document was in before you strated copying.
    Errors:     -
    Notes:      May be called even if StartComponentCopy has not been called.
                May be called multiple times
    SeeAlso:    BitmapListComponent::EndComponentCopy;
                BitmapListComponent::AbortComponentCopy;
                BitmapListComponent::CopyBitmapAcross

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

void BitmapListComponent::AbortComponentCopy()
{
}


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

// Remove the following code on all builds but those who want it

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

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

>   BOOL BitmapListComponent::StartImport(BaseCamelotFilter *pFilter)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/6/96
    Inputs:     pFilter - the BaseCamelotFilter filter that is being used to import a file.
    Returns:    TRUE if the component was able to prepare for importing;
                FALSE if not (e.g. out of memory)
    Purpose:    Inform the bitmap list document component that a Native or Web import is
                about to start.
    SeeAlso:    DocComponent

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

BOOL BitmapListComponent::StartImport(BaseCamelotFilter *pFilter)
{
TRACEUSER( "Neville", _T("BitmapListComponent::StartImport\n") );
    if (pFilter == NULL)
    {
        ERROR3("BitmapListComponent::StartExport filter is null!");
        return TRUE;
    }

    // Save this in our link to the BaseCamelotFilter
    pCamFilter = pFilter;
    // Set our variable so that we warn about a possible replacement only once
    WarnedBefore = FALSE;

    // Set up and start the imported bitmap list
    pImportedBitmaps = new ImportedBitmaps();
    if (pImportedBitmaps == NULL)
        return FALSE;

    return TRUE;
}

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

>   BOOL BitmapListComponent::EndImport(BaseCamelotFilter *pFilter, BOOL Success)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/6/96
    Inputs:     pFilter - the BaseCamelotFilter filter that is being used to import a file.
                Success - TRUE => The import was successful;
                         FALSE => The import failed - abandon any changes.
    Returns:    TRUE if the component was able to end the importing;
                FALSE if not (e.g. out of memory)
    Purpose:    Inform the bitmap list document component that a Native or Web import has
                just finished.
    SeeAlso:    DocComponent

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

BOOL BitmapListComponent::EndImport(BaseCamelotFilter *pFilter, BOOL Success)
{
TRACEUSER( "Neville", _T("BitmapListComponent::EndImport\n") );
    if (pFilter == NULL)
    {
        ERROR3("BitmapListComponent::EndImport filter is null!");
        return TRUE;
    }

    // As we have finished with it now, destroy the list of imported bitmaps
    if (pImportedBitmaps)
    {
        delete pImportedBitmaps;
        pImportedBitmaps = NULL;
    }

    // Null our link to the BaseCamelotFilter
    pCamFilter = NULL;
    // Set our variable so that we warn about a possible replacement only once
    WarnedBefore = FALSE;

    return TRUE;
}

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

>   KernelBitmap* BitmapListComponent::GetReadBitmapReference(INT32 BitmapRef)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/6/96
    Inputs:     BitmapRef   - The bitmap reference or record number that the record handler has loaded
                            from the record.
    Outputs:    -
    Returns:    pBitmap - A pointer to return the required kernel bitmap
    Purpose:    Try and convert a bitmap reference i.e. record number into a previously
                imported bitmap definition which should now be an kernel bitmap in the document.
    SeeAlso:    - 

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

KernelBitmap* BitmapListComponent::GetReadBitmapReference(INT32 BitmapRef)
{
TRACEUSER( "Neville", _T("GetReadBitmapReference for ref %d\n"), BitmapRef );

    // First check to see if the bitmap refers to any of the built in bitmaps.
    // These will have negative record numbers
    KernelBitmap* pBitmap = NULL;
    if (BitmapRef <= 0)
    {
        // The only one that exists at present is the default bitmap
        if (REF_DEFAULTBITMAP_BUILTIN)
        {
            // Its the default one so just construct a new kernel bitmap which
            // refers to this and return this to the caller
            pBitmap = KernelBitmap::MakeKernelBitmap(NULL, NULL);
        }
        else
        {
            // If we have a pFilter then ask the default warning handle to append our message
            if (pCamFilter)
            {
                if (!WarnedBefore)
                {
                    pCamFilter->AppendWarning(_R(IDS_NATIVE_BITMAPWARNING));
                    WarnedBefore = TRUE;
                }

                // We have warned the user about problems so just construct a new kernel bitmap which
                // is the default one and return this to the caller
                pBitmap = KernelBitmap::MakeKernelBitmap(NULL, NULL);
            }
            else
                ERROR2(NULL,"BitmapListComponent::GetReadBitmapReference negative BitmapRef is unknown");
        }
    }
    else
    {
        // Try and find the specified record number in our colour list
        pBitmap = pImportedBitmaps->GetBitmap(BitmapRef);
        // If not found then this is a problem as a bitmap must have been defined before its being
        // referenced 
        if (pBitmap == NULL)
        {
            // If we have a pFilter then ask the default warning handle to append our message
            if (pCamFilter)
            {
                if (!WarnedBefore)
                {
                    pCamFilter->AppendWarning(_R(IDS_NATIVE_BITMAPWARNING));
                    WarnedBefore = TRUE;
                }

                // We have warned the user about problems so just construct a new kernel bitmap which
                // is the default one and return this to the caller
                pBitmap = KernelBitmap::MakeKernelBitmap(NULL, NULL);
            }
            else
                ERROR2(NULL,"BitmapListComponent::GetReadBitmapReference BitmapRef cannot be found");
        }
    }

    return pBitmap;
}

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