giffiltr.cpp

Go to the documentation of this file.

// $Id: giffiltr.cpp 1461 2006-07-18 09:50:40Z luke $
/* @@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============================
 */

// A GIF import/export filter 


#include "camtypes.h"
#include "giffiltr.h"
//#include "andy.h"
//#include "oilfltrs.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "dibutil.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "grndbmp.h"
#include "nodebmp.h"
#include "bmpfiltr.h"
#include "progress.h"
#include "oilbitmap.h"  // Windows specific bitmap information
//#include "docview.h"  // DocView - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]

//#include "richard2.h" // resource strings _R(IDS_GIFFILTR_FAILED_MASK)
//#include "accures.h"  // Accusoft filter ids and messages 
//#include "bmpres.h"       // general bitmap filter based resources (_R(IDE_TIGIFFILTER_MASKFAILED)/MASK)
//#include "will3.h"        // for _R(IDS_GENOPTPALMSGID)

#include "maskfilt.h"   // MaskedFilter class
#include "bmpsdlg.h"
#include "frameops.h"   // GIFAnimationExportParam
//#include "spread.h"       // Pasteboard rect - in camtypes.h [AUTOMATICALLY REMOVED]
#include "bmapprev.h"   // tab preview dialog
#include "palman.h"     // MakePaletteBrowserCompatible
#include "sprdmsg.h"    // SpreadMsg::ANIMATIONPROPERTIESCHANGED
#include "impexpop.h"

#include "exphint.h"

#include "camdoc.h"
#include "menuops.h"

//#include "outptdib.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "cxfrec.h"       // for CXaraFileRecord - in camtypes.h [AUTOMATICALLY REMOVED]

#include "mrhbits.h"    //  For CBMPBits::RenderSelectionToBMP
#include "selall.h"     //  For OPTOKEN_EDITSELECTALL
#include "bmpprefs.h"
//#include "animparams.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "tmplmngr.h"

DECLARE_SOURCE("$Revision: 1461 $");

CC_IMPLEMENT_DYNAMIC(TI_GIFFilter, MaskedFilter)
CC_IMPLEMENT_MEMDUMP(GIFImportOptions, BitmapImportOptions)
CC_IMPLEMENT_DYNCREATE(GIFExportOptions, MaskedFilterExportOptions)

CC_IMPLEMENT_DYNCREATE(AnimatedGIFImage, ListItem)

#define new CAM_DEBUG_NEW

static UINT32 g_DefaultGIFType = 0;

OutputGIF   TI_GIFFilter::DestGIF;
FilterType  TI_GIFFilter::s_FilterType = GIF;   // Type of filter in use (TI_GIF .. TI_GIF_TRANSINTER)

CENTISECONDS        GIFExportOptions::g_AnimationDelay          = 10;           // Delay in CentiSeconds
GIFDisposalMethod   GIFExportOptions::g_AnimationRestoreType    = GDM_LEAVE;    // How to restore after each frame
UINT32              GIFExportOptions::g_AnimationLoopCount      = 1;            // Number of loops
KernelBitmap**      GIFExportOptions::m_pBitmapList             = NULL;
UINT32              GIFExportOptions::m_ListSize                = 0;

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

>   static BOOL GIFExportOptions::Declare()

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> (from Peter)
    Created:    29/10/96
    Returns:    TRUE if successfully declared preferences
                FALSE otherwise
    Purpose:    To declare preferences associated with these export options

********************************************************************************************/
BOOL GIFExportOptions::Declare()
{
    if (Camelot.DeclareSection(_T("Filters"), 10))
    {
        Camelot.DeclarePref( NULL, _T("ExportGIFtype"), &g_DefaultGIFType, 0, 3 );
        Camelot.DeclarePref( NULL, _T("AnimationDelay"), &g_AnimationDelay, 0, 65535 );
        Camelot.DeclarePref( NULL, _T("AnimationRestoreType"), (INT32*)&g_AnimationRestoreType, 0, 3 );
        Camelot.DeclarePref( NULL, _T("AnimationLoopCount"), &g_AnimationLoopCount, 0, 65535 );
    }

    // All ok
    return TRUE;
}



/********************************************************************************************
>   GIFExportOptions::GIFExportOptions()

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Purpose:    Default constructor for a GIFExportOptions object to provide GIF export
                options
********************************************************************************************/

GIFExportOptions::GIFExportOptions() :
    DelayIndex(0),
    RestoreIndex(0),
    m_GlobalPalette(TRUE),
    m_LeftOffset(0),
    m_TopOffset(0),
    m_AnimDelay(g_AnimationDelay),
    m_AnimDispose((GIFDisposalMethod) g_AnimationRestoreType),
    m_AnimLoop(g_AnimationLoopCount),
    m_AnimSize(0, 0),
    DelayValueIsDefault(FALSE)
{
    g_AnimationLoopCount = 1;
}



/********************************************************************************************
>   GIFExportOptions::GIFExportOptions(const FilterType FilterID, const StringBase* pFilterName)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Purpose:    Constructor for a GIFExportOptions object to provide GIF export
                options
********************************************************************************************/

GIFExportOptions::GIFExportOptions(const FilterType FilterID, const StringBase* pFilterName)
  : MaskedFilterExportOptions(_R(IDD_EXPORTBMPOPTS), FilterID, pFilterName),
    DelayIndex(0),
    RestoreIndex(0),
    m_GlobalPalette(TRUE),
    m_LeftOffset(0),
    m_TopOffset(0),
    m_AnimDelay(g_AnimationDelay),
    m_AnimDispose((GIFDisposalMethod) g_AnimationRestoreType),
    m_AnimLoop(g_AnimationLoopCount),
    m_AnimSize(0, 0),
    DelayValueIsDefault(FALSE)
{
    g_AnimationLoopCount = 1;
}



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

>   virtual BOOL GIFExportOptions::CopyFrom(BitmapExportOptions *pSource) 

    Author:     Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/05/97
    Inputs:     pSource - the other BitmapExportOptions object to copy the data from
    Purpose:    Sets the contents of this object from the passed object
    See Also:   BitmapExportOptions::MakeCopy()

********************************************************************************************/
BOOL GIFExportOptions::CopyFrom(BitmapExportOptions *pSource) 
{
    // copy the base class first
    if (!MaskedFilterExportOptions::CopyFrom(pSource))
        return FALSE;

    // must be the same class, otherwise the base class  function above returns FALSE
    GIFExportOptions *pOther = (GIFExportOptions *)pSource;

    m_AnimDelay         = pOther->m_AnimDelay;
    m_AnimDispose       = pOther->m_AnimDispose;
    m_AnimLoop          = pOther->m_AnimLoop;
    DelayValueIsDefault = pOther->DelayValueIsDefault;
    DelayIndex          = pOther->DelayIndex;
    RestoreIndex        = pOther->RestoreIndex;
    m_GlobalPalette     = pOther->m_GlobalPalette;
    m_LeftOffset        = pOther->m_LeftOffset;
    m_TopOffset         = pOther->m_TopOffset;
    m_AnimSize          = pOther->m_AnimSize;

    return TRUE;
};


BOOL GIFExportOptions::FileTypeChangeCopyFrom(BitmapExportOptions *pOther)
{
    if( !MaskedFilterExportOptions::FileTypeChangeCopyFrom(pOther) )
        return FALSE;

    //  Since we are not copying from another GIFOptions-based object, then the variables
    //  in this object must be assigned some default values.
    m_AnimDelay             = g_AnimationDelay;
    m_AnimDispose           = (GIFDisposalMethod)g_AnimationRestoreType;
    m_AnimLoop              = g_AnimationLoopCount;

    g_AnimationLoopCount    = 1;
    DelayValueIsDefault     = FALSE;
    DelayIndex              = 0;
    RestoreIndex            = 0;

    m_GlobalPalette         = TRUE;
    m_LeftOffset            = 0;
    m_TopOffset             = 0;

    // Graeme (14-9-00) - Limit the colour depth to be no more than 8bpp. Otherwise we get
    // problems with changing file types in the export dialogue.
    if ( GetDepth () > 8 )
    {
        SetDepth ( 8 );
    }

    return TRUE;
}


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

>   virtual BOOL GIFExportOptions::Equal(BitmapExportOptions *pSource) 

    Author:     Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/05/97
    Inputs:     pSource - the other BitmapExportOptions object to copy the data from
    Purpose:    Compares the contents of this and pOther objects
    Returns:    TRUE, if objects are equal, FALSE otherwise
    See Also:   BitmapExportOptions::MakeCopy()

********************************************************************************************/
/*
BOOL GIFExportOptions::Equal(BitmapExportOptions *pSource) 
{
    BOOL ok = TRUE;

    // compare the base classes first
    ok = MaskedFilterExportOptions::Equal(pSource);

    // must be the same class, otherwise the base class  function above returns FALSE
    GIFExportOptions *pOther = (GIFExportOptions *)pSource;

    if (ok) ok = (m_AnimDelay   == pOther->m_AnimDelay);
    if (ok) ok = (m_AnimDispose == pOther->m_AnimDispose);
    if (ok) ok = (m_AnimLoop== pOther->m_AnimLoop);
    if (ok) ok = (g_AnimationLoopCount  == pOther->g_AnimationLoopCount);
    if (ok) ok = (DelayValueIsDefault   == pOther->DelayValueIsDefault);
    if (ok) ok = (DelayIndex== pOther->DelayIndex);
    if (ok) ok = (RestoreIndex  == pOther->RestoreIndex);
    return ok;
};
*/

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

>   virtual BOOL GIFExportOptions::RetrieveDefaults()

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Purpose:    See BitmapExportOptions for interface details
    Notes:      Gets GIF specific preferences

********************************************************************************************/
BOOL GIFExportOptions::RetrieveDefaults()
{
    if (!MaskedFilterExportOptions::RetrieveDefaults())
    {
        return FALSE;
    }

    ERROR2IF(g_AnimationRestoreType != GDM_NONE && g_AnimationRestoreType != GDM_LEAVE &&
            g_AnimationRestoreType != GDM_BACKTOBACK && g_AnimationRestoreType != GDM_PREVIOUS,
            FALSE, "Invalid g_AnimationRestoreType");

    // Ensure that the depth is no more than 8 bits.
    if ( GetDepth () > 8 )
    {
        this->SetDepth ( 8 );
    }

    m_AnimDelay     = g_AnimationDelay;
    m_AnimDispose   = g_AnimationRestoreType;
    m_AnimLoop      = g_AnimationLoopCount;

//  SetMakeTransparent((g_DefaultGIFType >> 1) & 1);
    SetMakeInterlaced(g_DefaultGIFType & 1);

    return TRUE;
}


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

>   virtual BOOL GIFExportOptions::SetAsDefaults() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Purpose:    Provides additional implementation to set GIF specific info as defaults
    See Also:   BitmapExportOptions::SetAsDefaults()

********************************************************************************************/
BOOL GIFExportOptions::SetAsDefaults() const
{
    if (!MaskedFilterExportOptions::SetAsDefaults())
    {
        return FALSE;
    }

    g_AnimationDelay        = m_AnimDelay;
    
    g_AnimationRestoreType  = m_AnimDispose;
    g_AnimationLoopCount    = m_AnimLoop;

    g_DefaultGIFType = WantTransparent() ? 2 : 0;
    g_DefaultGIFType |= WantInterlaced() ? 1 : 0;

    return TRUE;
}



/********************************************************************************************
>   virtual BOOL GIFExportOptions::Write(CXaraFileRecord* pRec)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/2/00
    Inputs:     pRec    ---     record to write
    Returns:    TRUE if successful.
    Purpose:    Writes this object to the given record.
    SeeAlso:    GIFExportOptions::Read
********************************************************************************************/

BOOL GIFExportOptions::Write(CXaraFileRecord* pRec)
{
    return MaskedFilterExportOptions::Write(pRec) &&
           pRec->WriteUINT32(DelayIndex) &&
           pRec->WriteUINT32(RestoreIndex) &&
           pRec->WriteBYTE((BYTE) !!m_GlobalPalette) &&
           pRec->WriteUINT32(m_LeftOffset) &&
           pRec->WriteUINT32(m_TopOffset) &&
           pRec->WriteUINT32((UINT32) m_AnimDelay) &&
           pRec->WriteINT16((INT16) m_AnimDispose) &&
           pRec->WriteUINT32(m_AnimLoop) &&
           pRec->WriteCoord((const DocCoord&) m_AnimSize) &&
           pRec->WriteBYTE((BYTE) !!DelayValueIsDefault);
}



/********************************************************************************************
>   virtual BOOL GIFExportOptions::Read(CXaraFileRecord* pRec)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/2/00
    Inputs:     pRec    ---     record to read
    Returns:    TRUE if successful.
    Purpose:    Reads this object from the given record.
    SeeAlso:    GIFExportOptions::Write
********************************************************************************************/

BOOL GIFExportOptions::Read(CXaraFileRecord* pRec)
{
    m_GlobalPalette = DelayValueIsDefault = FALSE;
    return MaskedFilterExportOptions::Read(pRec) &&
           pRec->ReadUINT32((UINT32*) &DelayIndex) &&
           pRec->ReadUINT32((UINT32*) &RestoreIndex) &&
           pRec->ReadBYTE((BYTE*) &m_GlobalPalette) &&
           pRec->ReadUINT32((UINT32*) &m_LeftOffset) &&
           pRec->ReadUINT32((UINT32*) &m_TopOffset) &&
           pRec->ReadUINT32((UINT32*) &m_AnimDelay) &&
           pRec->ReadINT16((INT16*) &m_AnimDispose) &&
           pRec->ReadUINT32((UINT32*) &m_AnimLoop) &&
           pRec->ReadCoord((DocCoord*) &m_AnimSize) &&
           pRec->ReadBYTE((BYTE*) &DelayValueIsDefault);
}



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

>   CENTISECONDS GIFExportOptions::GetAnimationDelay() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Returns:    The delay desired for animated GIFs
    Purpose:    Support function to obtain export options

********************************************************************************************/
CENTISECONDS GIFExportOptions::GetAnimationDelay() 
{
    //  return m_AnimDelay;
    UINT32 Delay = m_pBitmapList[DelayIndex]->GetDelay();
    DelayIndex++;
    return Delay;
}


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

>   BOOL GIFExportOptions::SetAnimationDelay(CENTISECONDS Delay)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Inputs:     Delay : The desired delay to be set in the animated GIF
    Returns:    TRUE if set successfully
                FALSE otherwise
    Purpose:    Support function to set up information for the ensuing export
    See Also:   GetAnimationDelay()

********************************************************************************************/
BOOL GIFExportOptions::SetAnimationDelay(CENTISECONDS Delay)
{
    m_AnimDelay = Delay;
    return TRUE;
}


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

>   GIFDisposalMethod GIFExportOptions::GetAnimationRestore() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Returns:    The disposal method to be used in animated GIFs
    Purpose:    Support function to obtain export options

********************************************************************************************/
GIFDisposalMethod GIFExportOptions::GetAnimationRestore()
{
    // return m_AnimDispose;
    GIFDisposalMethod Restore = m_pBitmapList[RestoreIndex]->GetActualBitmap()->GetAnimationRestoreType();
    RestoreIndex++;
    return Restore;
}


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

>   BOOL GIFExportOptions::SetAnimationRestore(const GIFDisposalMethod& DisposalMethod)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Inputs:     DisposalMethod : The desired DisposalMethod to be set in the animated GIF
    Returns:    TRUE if set successfully
                FALSE otherwise
    Purpose:    Support function to set up information for the ensuing export
    See Also:   GetAnimationRestore(), enum GIFDisposalMethod

********************************************************************************************/
BOOL GIFExportOptions::SetAnimationRestore(const GIFDisposalMethod& DisposalMethod)
{
    m_AnimDispose = DisposalMethod;
    return TRUE;
}


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

>   UINT32 GIFExportOptions::GetAnimationLoopCount() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Returns:    How loopy our animated GIF will be
    Purpose:    Support function to obtain export options
    See Also:   SetAnimationLoopCount()

********************************************************************************************/
UINT32 GIFExportOptions::GetAnimationLoopCount() const
{
    return m_AnimLoop;
}


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

>   BOOL GIFExportOptions::SetAnimationLoopCount(UINT32 LoopCount)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Inputs:     LoopCount : For Animated GIFs: 0 = Repeat forever, 1 = One shot animation.
                n = Plays animation n times.
    Returns:    TRUE if set successfully
                FALSE otherwise
    Purpose:    Support function to set up information for the ensuing export
    See Also:   GetAnimationLoopCount()

********************************************************************************************/
BOOL GIFExportOptions::SetAnimationLoopCount(UINT32 LoopCount, BOOL Value)
{
    if(Value)
    {
        m_AnimLoop = ZERO;
        return TRUE;
    }
    else
    {
        m_AnimLoop = LoopCount;
        return TRUE;
    }
}





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

    Preference:     ExportGIFtype
    Section:        Filters
    Range:          0 to 3
    Purpose:        Allows a default GIF type to be remembered for the next export GIF
                    operation.
    SeeAlso:        -

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


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

>   TI_GIFFilter::TI_GIFFilter()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/4/95
    Purpose:    Constructor for an TI_GIFFilter object.  The object should be initialised
                before use.
    SeeAlso:    TI_GIFFilter::Init

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

TI_GIFFilter::TI_GIFFilter() : MaskedFilter()
{
    ImportMsgID = _R(IDN_IMPORTMSG_GIF);
    Flags.CanImport = TRUE;
#ifndef STANDALONE
    Flags.CanExport = TRUE;
    Flags.CanExportMultipleImages = TRUE;
#else
    Flags.CanExport = FALSE;
    Flags.CanExportMultipleImages = FALSE;
#endif
    FilterID = FILTERID_TI_GIF;

    ExportMsgID = _R(IDN_EXPORTMSG_GIF);            // "Preparing GIF file..."

    ExportingMsgID = _R(IDN_EXPORTINGMSG_GIF);      // "Exporting GIF file..."

    // Special Mask prepartion stage ID
    Export2ndStageMsgID = _R(IDN_MASKINGMSG_GIF);   // "Preparing mask for GIF file..."

    ExportRegion = NULL;

    // Initalise flags
    m_DoingAnimation = FALSE;
    m_AnimationFrame = 0;
    m_LeftOffset = 0;
    m_TopOffset = 0;

    m_PreviousMethod = GDM_BACKTOBACK;
}

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

>   BOOL TI_GIFFilter::Init()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/4/95
    Returns:    TRUE if the filter was initialised ok, FALSE otherwise.
    Purpose:    Initialise an TI_GIFFilter object.
    Errors:     Will fail if not enough memory to initialise.
    SeeAlso:    EPSStack

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

BOOL TI_GIFFilter::Init()
{
    // Get the OILFilter object
    pOILFilter = new GIFOILFilter(this);
    if (pOILFilter==NULL)
        return FALSE;

    // Load the description strings
    FilterName.Load(_R(IDN_FILTERNAME_GIF));
    FilterInfo.Load(_R(IDN_GIF_FILTERINFO));

    if (!GIFExportOptions::Declare())
    {
        return FALSE;
    }

    // All ok
    return TRUE;
}


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

>   virtual BitmapImportOptions* TI_GIFFilter::CreateImportOptions() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Purpose:    Overrides base class to provide GIF specific options

********************************************************************************************/
BitmapImportOptions* TI_GIFFilter::CreateImportOptions() const
{
    GIFImportOptions* pOptions = new GIFImportOptions;
    return (BitmapImportOptions*)pOptions;
}



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

>   virtual BOOL TI_GIFFilter::BOOL ReadFromFile(OILBitmap* pOilBitmap,
                                                 BaseCamelotFilter* pFilter,
                                                 CCLexFile* pFile, BOOL IsCompressed);


    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/6/96
    Inputs:     pOilBitmap  pointer to the oil bitmap data to be filled in
                pFilter         - the BaseCamelotFilter which provides functions like progress update
                                  (not used at the moment 20/01/97)
                pFile           - the CCFile class to use to read the data from
                IsCompressed    - Flag to say the bitmap is compressed or not.  
    Outputs:    Will have filled in BMInfo  pointer to the bitmap header to fill in
                                    BMBytes pointer to the bitmap data to fill in
    Purpose:    Actually does the process of reading a bitmap from a file.
                Inherited classes override this to read in different file formats.
                It is used by the web/native filters to pull out a bitmap definition from
                inside a bitmap definition record.
                It is also used for extracting previews.
                IsCompressed is only used for BMP/BMPZIP type bitmaps at present.
                Assumes:
                    pFile has already been opened up for reading
                    pFilter has been set up for reading the data e.g. progress bar 
    Returns:    TRUE if worked, FALSE if failed.

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

BOOL TI_GIFFilter::ReadFromFile( OILBitmap* pOilBitmap, BaseCamelotFilter* pFilter,
                                 CCLexFile* pFile, BOOL IsCompressed)
{
    ERROR2IF(pOilBitmap == NULL,FALSE,"TI_GIFFilter::ReadFromFile null OilBitmap pointer");
    // no pFilter means we don't get a progress WEBSTER-Martin-20/01/97
    // as we are calling this from BaseFileDialog::GetPreviewBitmapFromFile we don't have
    // a BaseCamelotFilter. However GIFUtil::ReadImage expects a 100% progress bar.
    // ERROR2IF(pFilter == NULL,FALSE,"TI_GIFFilter::ReadFromFile null pFilter pointer");
    ERROR2IF(pFile == NULL,FALSE,"TI_GIFFilter::ReadFromFile null pFile pointer");

    if (!pFilter)
        BeginSlowJob(-1);   // GIFUtil::ReadImage expects a progress bar.

    // Try to import bitmap as usual binary BMP file.
    CWxBitmap* pWBitmap = (CWxBitmap*) pOilBitmap;
    
    LPBITMAPINFO *pInfo = &(pWBitmap->BMInfo);
    LPBYTE *pBytes = &(pWBitmap->BMBytes);

    // Set a default transparent colour
    INT32 TransColour = -1;
    SetTransColour(TransColour);

    // Blank the offsets just in case
    m_LeftOffset = 0;
    m_TopOffset = 0;

    // Read from file, no header and using pFilter for progress bar updates
    // 20/01/97 In fact pFilter is not used so NULL ptr ok
    if (!GIFUtil::ReadFromFile(pFile, pInfo, pBytes, &TransColour, NULL, pFilter))
    {
        if (!pFilter)
            EndSlowJob();
        return FALSE;
    }

    SetTransColour(TransColour);
    UINT32 Bpp = pWBitmap->GetBPP();
    if (TransColour != -1 && Bpp <= 8)
        pOilBitmap->SetTransparencyIndex(TransColour);

    SetLastBitmap();        // can only import one bitmap at the moment

    if (!pFilter)
        EndSlowJob();

    // Everything went ok and we imported the bitmap ok
    return TRUE;
}

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

>   BOOL TI_GIFFilter::ReadFromFile(OILBitmap* pOilBitmap)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/8/95
    Inputs:     pOilBitmap  pointer to the oil bitmap data to be filled in
    Outputs:    Will have filled in BMInfo  pointer to the bitmap header to fill in
                                    BMBytes pointer to the bitmap data to fill in
    Purpose:    Actually does the process of reading a bitmap from a file.
                Inherited classes override this to read in different file formats.
                
    Returns:    TRUE if worked, FALSE if failed.

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

BOOL TI_GIFFilter::ReadFromFile(OILBitmap* pOilBitmap)
{
    ERROR2IF(pOilBitmap == NULL,FALSE,"TI_GIFFilter::ReadFromFile null OilBitmap pointer");
    
    // Try to import the bitmap as a GIF file.
        
    CCLexFile* pImportFile = GetImportFile();
    ERROR2IF(pImportFile==NULL,FALSE,"TI_GIFFilter::ReadFromFile - No import file");

    UINT32 ImportMsgId = GetImportMsgID();      
    String_64 ProgressString(ImportMsgId);
    ProgressString = GetImportProgressString(pImportFile, ImportMsgId);

    // Set a default transparent colour
    INT32 TransColour = -1;
    SetTransColour(TransColour);
    INT32 nBitmapToRead = GetBitmapNumber();

    CWxBitmap* pWBitmap = (CWxBitmap*)pOilBitmap;
    
    LPBITMAPINFO *pInfo = &(pWBitmap->BMInfo);
    LPBYTE *pBytes = &(pWBitmap->BMBytes);
    // Receives the Bitmap delay/Restore value from the Import.
    UINT32 Delay=0;
    GIFDisposalMethod Restore = GDM_LEAVE;

    // Blank the offsets just in case
    m_LeftOffset = 0;
    m_TopOffset = 0;

    // The GIF filter liked it very much and so use it, showing progress bar
    if (GIFUtil::ReadFromFile(pImportFile, pInfo, pBytes, &TransColour,nBitmapToRead, &ProgressString, NULL,
                              &Delay, &Restore, &m_LeftOffset, &m_TopOffset))
    {
        // Set the Delay\Restore value of the OILBitmap.
        pOilBitmap->SetBitmapAnimDelay(Delay);
        pOilBitmap->SetAnimationRestoreType(Restore);

        // Set the offset positions
        pOilBitmap->SetLeftOffset(m_LeftOffset);
        pOilBitmap->SetTopOffset(m_TopOffset);

        // Pass on the transparent colour that we found in the loading process
        // -1 if none found.  
        SetTransColour(TransColour);
        pOilBitmap->SetTransparencyIndex(TransColour);
        if (nBitmapToRead == -1)
            SetLastBitmap();
        else
            SetBitmapNumber(nBitmapToRead);
        return TRUE;
    }
    
    return FALSE;
}

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

>   BOOL TI_GIFFilter::GetDragAndDropTranslation(ImportPosition *pPos, DocRect BoundsRect, 
                                                 Coord* Offset)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> based on Tim function
    Created:    15/5/97
    Inputs:     pSpread - the spread to check against.
                BoundsRect - the bounding rectangle to check (in spread coordinates).
    Outputs:    Offset -
    Returns:    TRUE if the bounding rectangle is smaller than the spread => Offset now
                     contains the translation necessary to position the objects correctly.
                FALSE if bounding rectangle is bigger than the spread, or pPos was NULL.
                      In either case, a FALSE return results in Offset containing (0,0).
    Purpose:    Given an drag'n'drop point (in pPos), calculate the translation necessary
                to position the imported objects at this position on the spread.  It ensures
                that bounding rectangles smaller than the spread are wholly contained within
                the spread.  i.e. if you drag a file right to the edge of a spread, the 
                translation will move it closer to the centre of the spread so that it is
                wholly contained within the spread.

                Used by the import filters for drag'n'drop to ensure that after the
                imported objects are translated to the drop point, they are all still
                on the spread.
    SeeAlso:    Filter::DoImport

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

BOOL TI_GIFFilter::GetDragAndDropTranslation(ImportPosition *pPos, DocRect BoundsRect, 
                                             Coord* Offset)
{
    // First check to se if we actually have a drag and drop point.
    if (pPos == NULL || pPos->pSpread == NULL)
    {
        // No - set offset to 0 and return FALSE to indicate we can't cope with this.
        Offset->x = 0;
        Offset->y = 0;
        return FALSE;
    }

    // Get the spread's bounding rectangle and convert it to spread coords.
    DocRect SpreadRect = pPos->pSpread->GetPasteboardRect();
    pPos->pSpread->DocCoordToSpreadCoord(&SpreadRect);

    // Now check that the bounding rectangle is small enough to fit on the spread...
    if ((BoundsRect.Width() > SpreadRect.Width()) ||
        (BoundsRect.Height() > SpreadRect.Height()))
    {
        // No - set offset to 0 and return FALSE to indicate we can't cope with this.
        Offset->x = 0;
        Offset->y = 0;
        return FALSE;
    }

    // Bounding box should be centred on drop point
    // This is the default way of doing it. We actually want the bounding box of the animation
    // centered on the drop point with the inidividual frames positioned inside this.
    // The x and y offsets are handled latter so we must just position the rectangle to the left
    // of the main animations' bounding box
    UINT32 GIFWidth = GIFUtil::GetGlobalWidth();
    UINT32 GIFHeight = GIFUtil::GetGlobalHeight();
    if (GIFWidth > 0 && GIFHeight > 0)
    {
        // GIFs have no concept of DPI so assume 96
        const double dpi = 96.0;
        const INT32 PixelSize = (INT32) ((72000.0 / dpi) + 0.5);    // Size of output pixel in millipoints

        // We have been told how many pixels the animation is in size so we should just
        // multiply by 72000 millipoints per inch and then divide by the pixels per inch or dpi.
        MILLIPOINT AnimationWidth = (INT32) (((GIFWidth * 72000.0) / dpi) + 0.5);
        MILLIPOINT AnimationHeight = (INT32) (((GIFHeight * 72000.0) / dpi) + 0.5);
        // Add these offsets onto the one that is passed in
        DocCoord Centre;
        Centre.x = (AnimationWidth) / 2;
        Centre.y = (AnimationHeight) / 2;

        // If the height or width is an odd number then we may be positioning on half pixel
        // boundaries. So snap to the nearest whole pixel boundary.
        Centre.x -= Centre.x % PixelSize;
        Centre.y -= Centre.y % PixelSize;

        Offset->x = -Centre.x;
        Offset->y = -Centre.y;

        // The bitmaps will now be so that their bottom left hand corner is at the corner
        // of the animation. So we need to move it up so that its top left hand corner is
        // at the top left of the animation.
        Offset->y += AnimationHeight - (BoundsRect.hi.y - BoundsRect.lo.y);
    }
    else
    {
        // No - set offset to 0 and return FALSE to indicate we can't cope with this.
        Offset->x = 0;
        Offset->y = 0;
    }

    // Transform the bounding rect to see if it's off the spread.
    BoundsRect.Translate(Offset->x, Offset->y);

    // If it's off the spread - limit it to the edge of the spread:

    // (a) Horizontal adjustment
    if (BoundsRect.lo.x < SpreadRect.lo.x)
        Offset->x += (SpreadRect.lo.x - BoundsRect.lo.x);
    else if (BoundsRect.hi.x > SpreadRect.hi.x)
        Offset->x -= (BoundsRect.hi.x - SpreadRect.hi.x);

    // (b) Vertical adjustment
    if (BoundsRect.lo.y < SpreadRect.lo.y)
        Offset->y += (SpreadRect.lo.y - BoundsRect.lo.y);
    else if (BoundsRect.hi.y > SpreadRect.hi.y)
        Offset->y -= (BoundsRect.hi.y - SpreadRect.hi.y);

    // Whatever happened, we can fit it on the spread.
    return TRUE;
}

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

>   virtual BOOL TI_GIFFilter::SetFlagsFromBitmap(Layer * pLayer, KernelBitmap * pBitmap,
                                                  UINT32 nBitmapToRead)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/5/97
    Inputs:     pLayer          the layer that the bitmap is being put on
                pBitmap         the bitmap being placed on the layer
                nBitmapToRead   the number of the bitmap in the sequence
    Returns:    TRUE if was ok, FALSE otherwise.
    Purpose:    When loading in multiple bitmaps and placing them on new layers, we should
                give the filter an opportunity to set the layer flags from the bitmap. In the
                case of a GIF filter this would allow it to set the solid and overlay flags.

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

BOOL TI_GIFFilter::SetFlagsFromBitmap(Layer * pLayer, KernelBitmap * pBitmap,
                                      UINT32 nBitmapToRead)
{
    if (pBitmap && pLayer)
    {
        // transfer the disposal method from the bitmap to the layer
        GIFDisposalMethod method = pBitmap->GetAnimationRestoreType();
        // First frame is always restore background
        if (nBitmapToRead == 1)
            m_PreviousMethod = GDM_BACKTOBACK;
        
        // REM use the previous frame's restore method, not this one!
        switch (m_PreviousMethod)
        {
            case GDM_NONE:
            case GDM_LEAVE:
                // Always set frame overlay
                pLayer->SetOverlay(TRUE);
                // As we are setting overlay, solid is not required
                pLayer->SetSolid(FALSE);
                // This seems to work but may need some extra clauses....
                //if (nBitmapToRead == 1)
                //  pLayer->SetSolid(TRUE);
                //else
                //  pLayer->SetSolid(FALSE);
                break;
            case GDM_PREVIOUS:
            case GDM_BACKTOBACK:
                // Always set frame overlay false and solid false
                pLayer->SetOverlay(FALSE);
                pLayer->SetSolid(FALSE);
                break;
        }

        // Note the new restore method for the next frame
        m_PreviousMethod = method;

        // transfer the delay from the bitmap to the layer
        UINT32 delay = pBitmap->GetDelay();
        pLayer->SetFrameDelay(delay);
    }

    return TRUE;
}

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

>   BOOL TI_GIFFilter::AddOffsetFromBitmap(DocCoord * pOffset)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/5/97
    Inputs:     pOffset         the present offset in the bitmap
    Returns:    TRUE if was ok, FALSE otherwise.
    Purpose:    When loading in a bitmap, the bitmap definition may conatin an offset. We need
                to add this to the offset that we are given so that the bitmap is loaded at
                the correct position.
                This uses the class variables that were set up during the GIF loading process
                to add the offset onto the import position.

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

BOOL TI_GIFFilter::AddOffsetFromBitmap(DocCoord * pOffset)
{
    if (pOffset && m_LeftOffset >= 0 && m_TopOffset >= 0)
    {
        // GIFs have no concept of DPI so assume 96
        const UINT32 dpi = 96;
        // We have been told how many pixels to offset by so we should just
        // multiply by 72000 millipoints per inch and then divide by the pixels per inch or dpi.
        MILLIPOINT ExtraOffsetX = (m_LeftOffset * 72000) / dpi;
        MILLIPOINT ExtraOffsetY = (m_TopOffset * 72000) / dpi;
        // Add these offsets onto the one that is passed in
        pOffset->x += ExtraOffsetX;
        // Remember, we have been told the offset from the top, so we need to move downwards
        pOffset->y -= ExtraOffsetY;
    }

    return TRUE;
}

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

>   virtual BOOL TI_GIFFilter::SetAnimationPropertiesFromLoaded(Spread * pSpread)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/7/97
    Inputs:     pSpread     the spread that the bitmaps have been put on
    Returns:    TRUE if was ok, FALSE otherwise.
    Purpose:    When loading in multiple bitmaps and placing them on new layers, we should
                give the filter an opportunity after all the bitmaps have been loaded, to go
                and look at the bitmaps and set the animation properties accordingly.
                In the case of a GIF filter this would allow it to set the dithering to none
                and the palette to something closer to what has been loaded.
                Assumes that each bitmap has been added to a separate layer and that the
                referenced bitmap in the layer is set to this loaded bitmap.

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

BOOL TI_GIFFilter::SetAnimationPropertiesFromLoaded(Spread * pSpread)
{
    ERROR2IF(pSpread == NULL,FALSE,"SetAnimationPropertiesFromLoaded pSpread = NULL");
    
    // Find out about the palettes that the bitmaps have
    BOOL SamePalettes       = FALSE;
    BOOL OurBrowserPalette  = FALSE;
    BOOL AllHaveBitmaps     = FALSE;
    BOOL AllWithinCount     = FALSE;
    UINT32 PaletteEntries       = 0;
    CheckSingleBitmapsOnSpread(pSpread, &SamePalettes, &OurBrowserPalette, &AllHaveBitmaps,
                               &AllWithinCount, &PaletteEntries);

    // Grab the present animation properties from the spread
    AnimPropertiesParam *pProperties = &pSpread->GetSpreadAnimPropertiesParam();
    if (pProperties != NULL)
    {
        // Make any changes that we require
        pProperties->SetDither(XARADITHER_NONE);
        
        if (SamePalettes && OurBrowserPalette)
        {
            // Set ourselves a global browser palette
            pProperties->SetPaletteCols(PALCOL_BROWSER);
            pProperties->SetPalette(PAL_GLOBAL);
        }
        else if (SamePalettes)
        {
            // Set ourselves a global optimised palette
            pProperties->SetPaletteCols(PALCOL_OPTIMIZED);
            pProperties->SetPalette(PAL_GLOBAL);
            if (PaletteEntries > 0)
                pProperties->SetNumColsInPalette(PaletteEntries);
        }
        else
        {
            // Set ourselves a local optimised palette
            pProperties->SetPaletteCols(PALCOL_OPTIMIZED);
            pProperties->SetPalette(PAL_LOCAL);
            // Ensure that the optimised palette contains
            if (PaletteEntries > 0)
                pProperties->SetNumColsInPalette(PaletteEntries);
        }

        // Put back the new animation properties
        pSpread->SetSpreadAnimPropertiesParam(*pProperties);

        // Tell anybody that is interested about the changes    
        BROADCAST_TO_ALL(SpreadMsg(pSpread, SpreadMsg::ANIMATIONPROPERTIESCHANGED));
    }

    return TRUE;
}

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

>   virtual void TI_GIFFilter::CleanUpAfterExport()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    25/9/95
    Purpose:    Cleans up the memory allocated at the end of Exporting or when exporting has
                been aborted for some reason. Does its cleaning up and then calls the
                baseclass version to do its stuff,  - used
                when the import process ends, either normally or abnormally. Override if
                extra things are required.
    SeeAlso:    BaseBitmapFilter::PrepareToExport(); BaseBitmapFilter::CleanUpAfterExport();
    Scope:      Protected

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

void TI_GIFFilter::CleanUpAfterExport()
{
    // Called right at the end of th