bmpprefs.cpp

Go to the documentation of this file.

// $Id: bmpprefs.cpp 1530 2006-07-25 15:25:13Z 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============================
 */
// 
// BmpPrefs.cpp
//
// This file implements the dialogue box that allows the user to set the export bitmaps
// preferences.

/*
*/

#include "camtypes.h"
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "page.h"
#include "layer.h"
//#include "ensure.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "dlgtypes.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "resource.h"
#include "bmpprefs.h"
//#include "bmpres.h"       // general bitmap filter based resources
//#include "accures.h"  // general Accusoft dll resources
//#include "simon.h"
//#include "dialogop.h" // DialogOp header - in camtypes.h [AUTOMATICALLY REMOVED]
#include "dlgmgr.h"     // Dialog manager class
//#include "msg.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "rikdlg.h"       // _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)
#include "osrndrgn.h"
#include "grndrgn.h"    // for max bitmap width function
#include "bitfilt.h"    // BaseBitmapFilter 
//#include "justin2.h"
//#include "units.h"        // for pixel units - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "will3.h"
//#include "reshlpid.h"
#include "makebmp.h"
#include "helpuser.h"
//#include "accuflts.h" // PNG and TI-GIFF filter types
//#include "xshelpid.h"
//#include "filtrres.h" // _R(IDS_BMPPREFS_DPITOOSMALL) _R(IDS_BMPPREFS_DPITOOBIG)
#include "exjpeg.h"
#include "bmpfiltr.h"
#include "pngfiltr.h"
#ifndef WEBSTER
//#include "extfilts.h"
#endif //WEBSTER
//#include "simon.h"
#include "impexpop.h"   // BitmapExportParam
#include "fileutil.h"
//#include "bmpsdlg.h"  // BmpDlgParam
//#include "cxfrec.h"       // for CXaraFileRecord - in camtypes.h [AUTOMATICALLY REMOVED]
#include "ngprop.h"     // for the NamedExportProp::m_fApplyNotExport flag.
//#include "bmpreres.h" // for _R(IDS_PREVIEW_APPLY)
//#include "registry.h"
//#include "desnotes.h"
#include "bmpalint.h"   // for BitmapExportPaletteInterface::InvalidateSortedPalette()
//#include "oilfltrs.h" // for the find filter fn - in camtypes.h [AUTOMATICALLY REMOVED]
#include "slicehelper.h"
#include "fillattr2.h"

// This is not compulsory, but you may as well put it in so that the correct version
// of your file can be registered in the .exe
DECLARE_SOURCE("$Revision: 1530 $");

// An implement to match the Declare in the .h file.
// If you have many classes, it is recommended to place them all together, here at the start of the file
PORTNOTE("other","Removed BmpPrefsDlg - derived from DialogOp")
#ifndef EXCLUDE_FROM_XARALX
CC_IMPLEMENT_DYNCREATE(BmpPrefsDlg, DialogOp)
CC_IMPLEMENT_DYNCREATE(JPEGExportPrefsDialog, BmpPrefsDlg)
CC_IMPLEMENT_DYNCREATE(PhotoCDDlg, DialogOp)
#endif

CC_IMPLEMENT_DYNCREATE(BitmapExportOptions, OpParam)
CC_IMPLEMENT_MEMDUMP(PhotoCDDlgParam, OpParam)

// This will get Camelot to display the filename and linenumber of any memory allocations
// that are not released at program exit
#define new CAM_DEBUG_NEW
#define OPTION_ONE 0
#define OPTION_FOUR 4

TCHAR OPTOKEN_JPGPREFSDLG[] = _T("JPGPrefsDlg");

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

    Preference: DefaultExportFilterPath
    Section:    Filters
    Range:      Any old rubbish really
    Purpose:    The path to default to when opening the Export File dialog

********************************************************************************************/ 
// String_256 BitmapExportOptions::g_DefaultPath;

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

    Preference: HTMLToClipboard
    Section:    Filters
    Range:      FALSE, ranging all the way to TRUE
    Purpose:    Whether we should put an HTML tag on the clipboard. FALSE by default.

********************************************************************************************/ 
BOOL BitmapExportOptions::ms_fPutHTMLTagOnClipboard = FALSE;
TCHAR BitmapExportOptions::ms_strPutHTMLTagOnClipboard[]
                                            = _T("Filters\\PutHTMLTagOnClipboard");
BOOL BitmapExportOptions::ms_IsBackGroundTransparent = TRUE;
ANTIALIASING BitmapExportOptions::ms_Antialiasing = MINIMISE_VISIBLE_AA;
BOOL BitmapExportOptions::ms_bSeparateLayerFiles = FALSE;



/********************************************************************************************
>   BitmapExportOptions::BitmapExportOptions()

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Purpose:    Default constructor.
    See Also:   BaseBitmapFilter::CreateBitmapOptions()
********************************************************************************************/

BitmapExportOptions::BitmapExportOptions() :
    m_SelectionType(SELECTION),         // BaseBitmapFilter uses these...
    m_OutputSize(0, 0),                 // And initialise the output size
    m_PixelOutputSize(0, 0),
    m_FilterID(INVALID),
    m_pBmpDlgParam(0),
    m_bSeparateLayerFiles(FALSE),
    m_bTempFileFlag(FALSE),
    m_NumColsInPalette(0),
    m_UseSystemColours(FALSE),
    m_fPutHTMLTagOnClipboard(ms_fPutHTMLTagOnClipboard), // default HTML to clipboard
    m_bValid(FALSE),                    // Always use this...
    m_DPI(0),
    m_Depth(0),
    m_TransparencyIndex(-1),            // WEBSTER - markn 5/2/97 - no transparent colour
    m_DialogID(0),                      // BmpPrefsDlg uses these...
    m_pFilterName(0),
    m_bTempFileExported(FALSE),         // export preview uses this
    m_Antialiasing(MINIMISE_VISIBLE_AA) // Always start with the highest quality option
{
    m_Palette.NumberOfColours = 0;
    memset(&(m_Palette.Data), 0, sizeof(ExtendedPaletteEntry)*256);
PORTNOTE("DesignNotes", "Removed use of DesignNotes")
#if !defined(EXCLUDE_FROM_XARALX)
    m_UseDesignNotes = GetRegistryFlagForDesignNotes();
#else
    m_UseDesignNotes = FALSE;
#endif
    m__pLogicalPalette = NULL;
    m__NumberOfColoursUserRequested = 256;
    m__UseBrowserPalette = FALSE;
    m__UseSystemColoursInPalette = FALSE;
    m__UseWebSnapPalette = 0;
    m__UsePrimarySnapPalette = 1;
    m__PaletteIsValid = FALSE;
    m__BackgroundIsTransparent = TRUE;
    m__pPaletteOptimiser = NULL;
    m__HavePrimedOptimier = FALSE;
    m__TempFileMatchesExportOptions = FALSE;
    m_bCMYK = FALSE;
}



/********************************************************************************************
>   BitmapExportOptions::BitmapExportOptions(const CDlgResID DialogID, 
                                        const FilterType FilterID, StringBase* pFilterName)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Purpose:    Allows options in the bitmap export dialog to be freely passed around
    See Also:   BaseBitmapFilter::CreateBitmapOptions()
********************************************************************************************/

BitmapExportOptions::BitmapExportOptions(
                                const CDlgResID DialogID, 
                                const FilterType FilterID,
                                const StringBase* pFilterName) :
    m_SelectionType(SELECTION),         // BaseBitmapFilter uses these...
    m_OutputSize(0, 0),                 // And initialise the output size
    m_PixelOutputSize(0, 0),
    m_FilterID(FilterID),
    m_pBmpDlgParam(0),
    m_bSeparateLayerFiles(FALSE),
    m_bTempFileFlag(FALSE),
    m_NumColsInPalette(0),
    m_UseSystemColours(FALSE),
    m_fPutHTMLTagOnClipboard(ms_fPutHTMLTagOnClipboard), // default HTML to clipboard
    m_bValid(FALSE),                    // Always use this...
    m_DPI(0),
    m_Depth(0),
    m_TransparencyIndex(-1),            // WEBsTER - markn 5/2/97 - no transparent colour
    m_DialogID(DialogID),               // BmpPrefsDlg uses these...
    m_pFilterName(pFilterName),
    m_bTempFileExported(FALSE),         // export preview uses this
    m_Antialiasing(MINIMISE_VISIBLE_AA) // Always start with the highest quality option
{
    m_Palette.NumberOfColours = 0;
    memset(&(m_Palette.Data), 0, sizeof(ExtendedPaletteEntry)*256);
PORTNOTE("DesignNotes", "Removed use of DesignNotes")
#if !defined(EXCLUDE_FROM_XARALX)
    m_UseDesignNotes = GetRegistryFlagForDesignNotes();
#else
    m_UseDesignNotes = FALSE;
#endif
    m__pLogicalPalette = NULL;
    m__NumberOfColoursUserRequested = 256;
    m__UseBrowserPalette = FALSE;
    m__UseSystemColoursInPalette = FALSE;
    m__UseWebSnapPalette = 0;
    m__UsePrimarySnapPalette = 1;
    m__PaletteIsValid = FALSE;
    m__BackgroundIsTransparent = TRUE;
    m__pPaletteOptimiser = NULL;
    m__HavePrimedOptimier = FALSE;
    m__TempFileMatchesExportOptions = FALSE;
    m_bCMYK = FALSE;
}

// distructor to release any claimed memory
BitmapExportOptions::~BitmapExportOptions()
{
    // the export options manages the logical palette so this is deleted when the export options are deleted
    if (m__pLogicalPalette)
    {
        delete m__pLogicalPalette;
        m__pLogicalPalette = NULL;
    }

    // the cache for the palette optimiser which holds the stats on the image
    if (m__pPaletteOptimiser)
    {
        delete m__pPaletteOptimiser;
        m__pPaletteOptimiser = NULL;
    }
}

/********************************************************************************************
>   BitmapExportOptions* BitmapExportOptions::MakeCopy()

    Author:     Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/05/97
    Purpose:    Makes a copy object of this object
    See Also:   BitmapExportOptions::CopyFrom()
********************************************************************************************/

BitmapExportOptions* BitmapExportOptions::MakeCopy()
{
    // Get the runtime class info on this object
    CCRuntimeClass* pCCRuntimeClass = GetRuntimeClass();

    // Create another object of the same type
    BitmapExportOptions* p = (BitmapExportOptions*) pCCRuntimeClass->CreateObject();
    if (p != 0)
    {
        // clear the exported file flag to prevent attempts to delete any temp files
        p->m_bTempFileExported = FALSE;

        // copy the contents accross
        p->CopyFrom(this);
    }
    
    return p;
}



/********************************************************************************************
>   virtual BOOL BitmapExportOptions::CopyFrom(BitmapExportOptions* pOther) 
    Author:     Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/05/97
    Inputs:     pOther - the other BitmapExportOptions object to copy the data from
    Purpose:    Sets the contents of this object from the passed object
    See Also:   BitmapExportOptions::MakeCopy()
    Returns:    TRUE if pOther is of the same type as 'this' else FALSE (this is
                a silly thing to return but the functions in derived classes kind of
                require this now so it is a bit difficult to change)
********************************************************************************************/
BOOL BitmapExportOptions::CopyFrom(BitmapExportOptions* pOther) 
{
    if (pOther == 0)
        return FALSE;

    // Copy all the data items that can be copied for any type of BitmapExportOptions
    
    m_SelectionType                 = pOther->m_SelectionType;
    m_fPutHTMLTagOnClipboard        = pOther->m_fPutHTMLTagOnClipboard;
    m_Antialiasing                  = pOther->m_Antialiasing;
    m_UseDesignNotes                = pOther->m_UseDesignNotes;
    m_bSeparateLayerFiles           = pOther->m_bSeparateLayerFiles;
    m_bTempFileFlag                 = pOther->m_bTempFileFlag;


    if (IS_SAME_CLASS(pOther, this))
    {
        // Only copy these if we are copying from a class that is of the
        // same type
        
        m_OutputSize                = pOther->m_OutputSize;
        m_PixelOutputSize           = pOther->m_PixelOutputSize;
        m_FilterID                  = pOther->m_FilterID;
        m_pBmpDlgParam              = pOther->m_pBmpDlgParam;       
        m_NumColsInPalette          = pOther->m_NumColsInPalette;
        m_UseSystemColours          = pOther->m_UseSystemColours;
        m_TransparencyIndex         = pOther->m_TransparencyIndex;
        m_DialogID                  = pOther->m_DialogID;
        m_pFilterName               = pOther->m_pFilterName;
        m_bValid                    = pOther->m_bValid;
        m_bTempFileExported         = pOther->m_bTempFileExported;
        m_TempPath                  = pOther->m_TempPath;
        m_Depth                     = pOther->m_Depth; // move to derived classes

        // Added to stop the name gallery killing itself on export
        m_DPI                       = pOther->m_DPI;

        // It should be safe to copy the following for any file type but I have not tested this
        // so I am only copying them if they are of the same type for now - Jonathan.

        // smfix new ones added
        m__NumberOfColoursUserRequested = pOther->m__NumberOfColoursUserRequested;
        m__UseBrowserPalette            = pOther->m__UseBrowserPalette;
        m__UseSystemColoursInPalette    = pOther->m__UseSystemColoursInPalette;
        m__UseWebSnapPalette            = pOther->m__UseWebSnapPalette;
        m__UsePrimarySnapPalette        = pOther->m__UsePrimarySnapPalette;
        m__BackgroundIsTransparent      = pOther->m__BackgroundIsTransparent;

        // Also need to copy all the palette information over.  It should also be safe to copy
        // this but again, I have not tested this so I am going for the safe option - Jonathan.
        CopyPaletteInformationFrom(pOther);
        return TRUE;
    }
    else
    {
        return FALSE;
    }
};



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

>   BOOL BitmapExportOptions::FileTypeChangeCopyFrom(BitmapExportOptions *pOther)

    Author:     Alex_Price (Xara Group Ltd) <camelotdev@xara.com>

    Created:    15/10/99

    Inputs:     pOther - A BitmapExportOptions object we want to make a copy of.

    Returns:    -

    Purpose:    Copies the information from the BitmapExportOptions object
                passed in as the argument to the palette object in this class.

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

BOOL BitmapExportOptions::FileTypeChangeCopyFrom(BitmapExportOptions *pOther)
{
    m_SelectionType     = pOther->m_SelectionType;
    m_OutputSize        = pOther->m_OutputSize;
    m_PixelOutputSize   = pOther->m_PixelOutputSize;
    m_pBmpDlgParam      = pOther->m_pBmpDlgParam;       
    m_NumColsInPalette  = pOther->m_NumColsInPalette;
    m_UseSystemColours  = pOther->m_UseSystemColours;
    m_DPI               = pOther->m_DPI;
    m_Depth             = pOther->m_Depth;
    m_TransparencyIndex = pOther->m_TransparencyIndex;
    m_DialogID          = pOther->m_DialogID;
    m_bValid            = pOther->m_bValid;
    m_bTempFileExported = pOther->m_bTempFileExported;
    m_TempPath          = pOther->m_TempPath;
    m_fPutHTMLTagOnClipboard    = pOther->m_fPutHTMLTagOnClipboard;
    m_Antialiasing      = pOther->m_Antialiasing;
    m_UseDesignNotes    = pOther->m_UseDesignNotes;
    m_bSeparateLayerFiles = pOther->m_bSeparateLayerFiles;
    m_bTempFileFlag     = pOther->m_bTempFileFlag;

    // smfix new ones added
    m__NumberOfColoursUserRequested =   pOther->m__NumberOfColoursUserRequested;
    m__UseBrowserPalette =              pOther->m__UseBrowserPalette;
    m__UseSystemColoursInPalette =      pOther->m__UseSystemColoursInPalette;
    m__UseWebSnapPalette =              pOther->m__UseWebSnapPalette;
    m__UsePrimarySnapPalette =          pOther->m__UsePrimarySnapPalette;
    m__BackgroundIsTransparent =        pOther->m__BackgroundIsTransparent;

    // Also need to copy all the palette information over.
    CopyPaletteInformationFrom( pOther );

    return TRUE;
}


/******************************************************************************************
>   void BitmapExportOptions::CopyPaletteInformationFrom( BitmapExportOptions* pOther )
    Author:     Alex_Price (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/08/99
    Inputs:     pOther - A BitmapExportOptions object we want to make a copy of.
    Purpose:    Copies the palette information from the BitmapExportOptions object
                passed in as the argument to the palette object in this class.
******************************************************************************************/
void BitmapExportOptions::CopyPaletteInformationFrom( BitmapExportOptions* pOther )
{
    //  The first few times that this function is called, the palette passed in
    //  is uninitialised. If this is the case, then just make our palette a default one.
    if( ( pOther->m_Palette.NumberOfColours > 256 ) || ( pOther->m_Palette.NumberOfColours < 0 ) )
    {
        m_Palette.NumberOfColours = 0;

        INT32 i = 0;
        for( i=0; i < 256; i++ )
        {
            m_Palette.Data[ i ].Red                 = 0;
            m_Palette.Data[ i ].Green               = 0;
            m_Palette.Data[ i ].Blue                = 0;
            m_Palette.Data[ i ].Flags               = 0;
        }
        //  Finished here, so return.
        return;
    }

    //  Simply copy the entire palette over from pOther.
    m_Palette.NumberOfColours   = pOther->m_Palette.NumberOfColours;

    INT32 i = 0;
    INT32 Colours = m_Palette.NumberOfColours;
    Colours = max( 256, Colours );
    for( i=0; i < Colours; i++ )
    {
        m_Palette.Data[ i ].Red                 = ( pOther->m_Palette ).Data[ i ].Red;
        m_Palette.Data[ i ].Green               = ( pOther->m_Palette ).Data[ i ].Green;
        m_Palette.Data[ i ].Blue                = ( pOther->m_Palette ).Data[ i ].Blue;
        m_Palette.Data[ i ].Flags               = ( pOther->m_Palette ).Data[ i ].Flags;
    }

    // delete our old logical palette if we had one
    if (m__pLogicalPalette)
    {
        delete m__pLogicalPalette;
        m__pLogicalPalette = NULL;
    }

    // our copy is valid if the original is valid
    m__PaletteIsValid = pOther->IsPaletteValid();

    // copy the logical palette data if it was valid
    if (m__PaletteIsValid)
    {
        m__pLogicalPalette = (LOGPALETTE * ) new BYTE[sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 256 )];

        memcpy(m__pLogicalPalette, pOther->GetLogicalPalette(), sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 256 ));
    }

}



/******************************************************************************************
>   ExtendedPalette& BitmapExportOptions::GetPalette()
    Author:     Alex_Price (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/08/99
    Returns:    The palette object of this class.
    Purpose:    Gives the calling function a copy of this class's palette.
******************************************************************************************/
ExtendedPalette* BitmapExportOptions::GetPalette()
{
    return &m_Palette;
}


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

>   BOOL BitmapExportOptions::IsValid() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Returns:    TRUE if this BitmapExportOptions object is valid for use in a subsequent
                export operation.
                FALSE otherwise
    Purpose:    Determines whether or not the values contained in this object are valid or
                whether the user has cancelled the export: using MarkValid() & MarkInvalid()
                will state the veracity of this fact.

********************************************************************************************/
BOOL BitmapExportOptions::IsValid() const
{
    return m_bValid;
}


void BitmapExportOptions::MarkInvalid()
{
    m_bValid = FALSE;
}


void BitmapExportOptions::MarkValid()
{
    m_bValid = TRUE;
}


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

>   virtual BOOL BitmapExportOptions::RetrieveDefaults()

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Returns:    TRUE if successful
                FALSE otherwise
    Purpose:    Retrieves defaults for accessible members from preferences 
    See Also:   BitmapExportOptions::SetAsDefaults()

********************************************************************************************/
BOOL BitmapExportOptions::RetrieveDefaults()
{
    SetDPI(BMPFilter::GetDefaultExportDPI());
    SetDepth(BMPFilter::GetDefaultExportDepth());

    SetPutHTMLTagOnClipboard(ms_fPutHTMLTagOnClipboard);
    m__BackgroundIsTransparent = ms_IsBackGroundTransparent;
    m_Antialiasing = ms_Antialiasing;
    m_bSeparateLayerFiles = ms_bSeparateLayerFiles;

    return TRUE;
}


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

>   virtual BOOL BitmapExportInfo::SetAsDefaults() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Purpose:    Sets the current options as preferences which may be retrieved by a
                subsequent RetrieveDefaults()
    See Also:   BitmapExportOptions::RetrieveDefaults()

********************************************************************************************/
BOOL BitmapExportOptions::SetAsDefaults() const
{
    BMPFilter::SetDefaultExportDPI(GetDPI());
    BMPFilter::SetDefaultExportDepth(GetDepth());

    ms_fPutHTMLTagOnClipboard=m_fPutHTMLTagOnClipboard;
    ms_IsBackGroundTransparent = m__BackgroundIsTransparent;
    ms_Antialiasing = m_Antialiasing;
    ms_bSeparateLayerFiles = m_bSeparateLayerFiles;

    return TRUE;
}

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

>   static BOOL BitmapExportOptions::Declare()

    Author:     Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/7/97
    Returns:    TRUE if successfully declared preferences
                FALSE otherwise
                Purpose:    Declares our base class preferences

********************************************************************************************/
BOOL BitmapExportOptions::Declare()
{
    if (Camelot.DeclareSection(_T("Filters"), 10))
    {
        Camelot.DeclarePref( NULL, ms_strPutHTMLTagOnClipboard, &ms_fPutHTMLTagOnClipboard, FALSE, TRUE );
    }

    return TRUE;
}



/********************************************************************************************
>   virtual BOOL BitmapExportOptions::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:    BitmapExportOptions::Read
********************************************************************************************/

BOOL BitmapExportOptions::Write(CXaraFileRecord* pRec)
{
    INT16 Packed = 0x0000;

    if (m_Antialiasing) Packed += 1;
    if (m__BackgroundIsTransparent) Packed += 2;
    if (m__UseBrowserPalette) Packed += 4;

    INT16 AmountOfPrimarySnap = (m__UsePrimarySnapPalette & 15) << 4;
    Packed += AmountOfPrimarySnap;

    INT16 AmountOfWebSnap = (m__UseWebSnapPalette & 0xff) << 8;
    Packed += AmountOfWebSnap;

    UINT32 PackedRequestedColours = m__NumberOfColoursUserRequested;

    // Write out every user-definable data member.  Note that as we save only
    // the lowest byte of a bool, we double-not them to ensure they are saved
    // out only as either 0 or 1.
    if (!pRec->WriteINT16((INT16) m_SelectionType) ||
        !pRec->WriteCoord((const DocCoord&) m_OutputSize) ||
        !pRec->WriteCoord((const DocCoord&) m_PixelOutputSize) ||
        !pRec->WriteUINT32((UINT32) m_FilterID) ||
        !pRec->WriteBYTE((BYTE) !!m_UseDesignNotes) ||
        !pRec->WriteUINT32(PackedRequestedColours) ||
        !pRec->WriteBYTE((BYTE) !!m__UseSystemColoursInPalette) ||
        !pRec->WriteBYTE((BYTE) !!m_fPutHTMLTagOnClipboard) ||
        !pRec->WriteDOUBLE((double) m_DPI) ||
        !pRec->WriteUINT32((UINT32) m_Depth) ||
        !pRec->WriteINT32(m_TransparencyIndex) ||
        !pRec->WriteUINT32((UINT32) m_DialogID) ||
        !pRec->WriteINT16(Packed) || // was m_Antialiasing but I have now packed this data to fit in the new stuff
        !pRec->WriteINT32(m_Palette.NumberOfColours) ||
        !pRec->WriteUnicode(m_pFilterName ? ((LPTSTR) (LPCTSTR) *m_pFilterName) : (LPTSTR) _T("")))
            return FALSE;

    // Write out the palette.
    BYTE Dummy = 0;
    ExtendedPaletteEntry* peEnd = &m_Palette.Data[min(m_Palette.NumberOfColours, 256)];
    for (ExtendedPaletteEntry* pe = m_Palette.Data; pe < peEnd; pe++)
    {
        DWORD PackedPreEditedColours = pe->PreEditedRed + (pe->PreEditedGreen << 8) + (pe->PreEditedBlue << 16);
        if (!pRec->WriteBYTE(pe->Red) ||
            !pRec->WriteBYTE(pe->Green) ||
            !pRec->WriteBYTE(pe->Blue) ||
            !pRec->WriteBYTE(Dummy) ||
            !pRec->WriteINT32((INT32)PackedPreEditedColours) || // used to be popularity but there should be no clash
            !pRec->WriteINT32(pe->Flags))
                return FALSE;
    }

    return TRUE;
}



/********************************************************************************************
>   virtual BOOL BitmapExportOptions::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:    BitmapExportOptions::Write
********************************************************************************************/

BOOL BitmapExportOptions::Read(CXaraFileRecord* pRec)
{
    // Make sure these bools are preset to zero as we only saved their
    // least significant byte.
    m_UseDesignNotes = m_UseSystemColours = m_fPutHTMLTagOnClipboard = FALSE;

    INT16 Packed = 0;
    UINT32 PackedRequestedColours = 0;

    // Read in every user-definable data member.
    String_256 strFilterName;
    if (!pRec->ReadINT16((INT16*) &m_SelectionType) ||
        !pRec->ReadCoord((DocCoord*) &m_OutputSize) ||
        !pRec->ReadCoord((DocCoord*) &m_PixelOutputSize) ||
        !pRec->ReadUINT32((UINT32*) &m_FilterID) ||
        !pRec->ReadBYTEtoBOOL(&m_UseDesignNotes) ||
        !pRec->ReadUINT32((UINT32*) &PackedRequestedColours) ||
        !pRec->ReadBYTEtoBOOL(&m__UseSystemColoursInPalette) ||
        !pRec->ReadBYTEtoBOOL(&m_fPutHTMLTagOnClipboard) ||
        !pRec->ReadDOUBLE((double*) &m_DPI) ||
        !pRec->ReadUINT32((UINT32*) &m_Depth) ||
        !pRec->ReadINT32(&m_TransparencyIndex) ||
        !pRec->ReadUINT32((UINT32*) &m_DialogID) ||
        !pRec->ReadINT16((INT16*) &Packed) ||
        !pRec->ReadINT32((INT32*) &m_Palette.NumberOfColours) ||
        !pRec->ReadUnicode(&strFilterName))
            return FALSE;

    // unpack the packed varibale to get the smfix data
    if (Packed & 1)
        m_Antialiasing = MINIMISE_VISIBLE_AA;
    else
        m_Antialiasing = MAINTAIN_SCREEN_AA;

    m__BackgroundIsTransparent = Packed & 2;
    m__UseBrowserPalette = Packed & 4;
    m__UsePrimarySnapPalette = (Packed >> 4) & 15;
    m__UseWebSnapPalette = (Packed >> 8) & 0xff;

    m__NumberOfColoursUserRequested = PackedRequestedColours;

    // Read in the palette.
    BYTE Dummy = 0;
    INT32 DummyPopularity = 0;
    ExtendedPaletteEntry* peEnd = &m_Palette.Data[min(m_Palette.NumberOfColours, 256)];
    for (ExtendedPaletteEntry* pe = m_Palette.Data; pe < peEnd; pe++)
    {
        if (!pRec->ReadBYTE(&pe->Red) ||
            !pRec->ReadBYTE(&pe->Green) ||
            !pRec->ReadBYTE(&pe->Blue) ||
            !pRec->ReadBYTE(&Dummy) ||
            !pRec->ReadINT32((INT32*) &DummyPopularity) ||
            !pRec->ReadINT32((INT32*) &pe->Flags))
                return FALSE;

        // unpack the pre-edited colours
        DWORD PackedPreEditedColours = DummyPopularity;
        pe->PreEditedRed = (PackedPreEditedColours && 0xff);
        pe->PreEditedGreen = ((PackedPreEditedColours >> 8) && 0xff);
        pe->PreEditedBlue = ((PackedPreEditedColours >> 16) && 0xff);
    }

    if (m_DPI == 0)
    {
        TRACE( _T("DPI not set in export options in the .xar file - setting it to 96.0\n"));
        m_DPI = 96.0;
    }


    // Fix up the filter name string (for some brain-damaged reason this bears
    // little relation to the saved-out filter ID).
    if (strFilterName.IsEmpty())
        strFilterName.Load(GetFilterNameStrID());

    for (Filter* pf = Filter::GetFirst(); pf != 0; pf = Filter::GetNext(pf))
        if (pf->FilterName == strFilterName)
        {
            // Success.
            m_pFilterName = &pf->FilterName;
            return TRUE;
        }
    
    // Couldn't find the filter with the given name.
    TRACE( _T("BitmapExportOptions::Read: can't find %s filter\n"), (LPCTSTR) strFilterName);
    return FALSE;
}



/********************************************************************************************
>   const StringBase* BitmapExportOptions::GetFilterName() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Returns:    The name of the filter associated with this BitmapExportOptions object
    Purpose:    Allows the export dialog to display the filter name in its title bar
********************************************************************************************/

const StringBase* BitmapExportOptions::GetFilterName() const
{
    return m_pFilterName;
}


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

  > void BitmapExportOptions::SetPathName(PathName *pTempPath)

    Author:     Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/7/96
    Inputs:     pTempPath - path name of a temporary file
    Returns:    None
    Purpose:    Allows the export options to keep the path to a temporary file, created 
                during bitmap preview, so the export function can simply rename this to 
                create the final exported file.

********************************************************************************************/
void BitmapExportOptions::SetPathName(PathName *pTempPath)
{
    // set the flag, to indicate that we have a temp file, but only if the path name is not null
    m_bTempFileExported = (pTempPath != NULL);

    if (m_bTempFileExported)
    {
        // remember the new path
        m_TempPath = *pTempPath;
    }
}

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

>   BOOL BitmapExportOptions::SetDPI(const DPI& Dpi)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Inputs:     Dpi : The dpi of the bitmap to be exported
    Returns:    TRUE if the operation was successful
                FALSE otherwise
    Purpose:    Support function to set up information for the ensuing export
    See Also:   GetDpi()

********************************************************************************************/
BOOL BitmapExportOptions::SetDPI(const DPI& Dpi)
{
    if (m_DPI != Dpi)
        BitmapSourceHasChanged(); // flush cache

    m_DPI = Dpi;
    return TRUE;
}


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

>   DPI BitmapExportOptions::GetDPI() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Returns:    The desired dpi of the bitmap to export
    Purpose:    Support function to obtain bitmap info

********************************************************************************************/
DPI BitmapExportOptions::GetDPI() const
{
    return m_DPI;
}


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

>   void BitmapExportOptions::SetSelectionType(const SelectionType& Sel)

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    long while ago - modified sjk 10/12/00
    Purpose:    sets the the item(s) being exported eg selection, page, drawing, etc

********************************************************************************************/
void BitmapExportOptions::SetSelectionType(const SelectionType& Sel)
{
    if (m_SelectionType != Sel)
        BitmapSourceHasChanged(); // flush cache
    m_SelectionType = Sel;
}

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

>   void BitmapExportOptions::SetAntiAliasing( ANTIALIASING aa )

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    long while ago - modified sjk 10/12/00
    Purpose:    Sets the anti-aliasing on the export bitmap

********************************************************************************************/
void BitmapExportOptions::SetAntiAliasing( ANTIALIASING aa )
{
    if (m_Antialiasing != aa)
        BitmapSourceHasChanged(); // flush cache
    m_Antialiasing = aa;
}


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

>   BMP_DEPTH BitmapExportOptions::GetDepth() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Returns:    The desired depth of the bitmap to export
    Purpose:    Support function to obtain bitmap options

********************************************************************************************/
BMP_DEPTH BitmapExportOptions::GetDepth() const
{
    // THIS IS JUST FOR TESTING! WHEN THE BITMAP COPY DIALOG GETS IT`s OWN 32BPP BUTTON
    // THEN THIS MUST BE REMOVED!!!!!!!
    //  I've change '>1' to '>=1' below, otherwise the 2 colour optimised palette
    //  is not available.
    if( m_Depth >= 1 )
    {
        return m_Depth;
    }
    else
    {
        return 32;
    }
}


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

>   BOOL BitmapExportOptions::SetDepth(const BMP_DEPTH& Depth)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/10/96
    Inputs:     Depth : The depth of the bitmap to be exported
    Returns:    TRUE if the operation was successful
                FALSE otherwise
    Purpose:    Support function to set up information for the ensuing export
    See Also:   GetDepth()

********************************************************************************************/
BOOL BitmapExportOptions::SetDepth(const BMP_DEPTH& Depth)
{
    if (m_Depth != Depth)
    {
        InvalidatePalette();

        // sjk bodge if we did have two colours moving up sometimes needs to regather the stats
        if (m_Depth == 1)
            BitmapSourceHasChanged();
    }

    m_Depth = Depth;
    return TRUE;
}


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

>   void BitmapExportOptions::SetBitmapExportParam(BitmapExportParam* pParam)
    Author:     Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/01/96
    Inputs:     PParam - Allows us to to save a reference to a BmpDlgParam, in
                the BitmapExportOptions.
    Returns:    -
    Purpose:    -
    See Also:   -

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

BOOL BitmapExportOptions::SetBitmapExportParam(BitmapExportParam* pParam)
{
    ERROR2IF(pParam == NULL,FALSE,"pParam is NULL");
    m_pBmpDlgParam=pParam->GetBmpDlgParam();

    if(m_pBmpDlgParam == NULL)
        return FALSE;

    return TRUE;
}


BOOL BitmapExportOptions::IsClipToPage()
{
    if( m_SelectionType == PAGE )
        return TRUE;
    else
        return FALSE;
}


BOOL BitmapExportOptions::IsCMYK()
{
    return m_bCMYK;
}

void BitmapExportOptions::SetCMYK(BOOL SetIt)
{
    m_bCMYK = SetIt;
}


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

>   BOOL BitmapExportOptions::CanExportSeparateLayers()

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/04/2004
    Inputs:     -
    Returns:    -
    Purpose:    -
    See Also:   -

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

BOOL BitmapExportOptions::CanExportSeparateLayers()
{
    return (GetSeparateLayerFiles() && GetTempFileFlag()==FALSE && (GetFilterNameStrID()==_R(IDN_FILTERNAME_GIF) || GetFilterNameStrID()==_R(IDS_FILTERNAME_PNG)));
}



PORTNOTE("other", "Removed export dlgs");
#if !defined(EXCLUDE_FROM_XARALX)

/*******************************************************************************************/
PhotoCDDlgParam * PhotoCDDlg::pParams = NULL;   // Data passing class

// Set up the dialog box details stored as statics in the class
CDlgResID BmpPrefsDlg::IDD = _R(IDD_EXPORTBMPOPTS); // default dialog box id
const CDlgMode BmpPrefsDlg::Mode = MODAL;       // This dialog is modal

const CDlgMode PhotoCDDlg::Mode = MODAL;        // This dialog is modal

// Tiff compression types we can cope with. Cannot use the Accusoft types as these are not
// contiguous and hence would not correspond to items in a list
//enum TiffTypes {UNCOMPRESSED_TIFF, LZW_TIFF, HUFFMAN_TIFF, G3FAX_TIFF, G4FAX_TIFF,
//              PACKBITS_TIFF, TWODENCODING_TIFF };

// Andy Hills, 05-09-00
// The above enum is only applicable for 1bpp TIFF export.
// The options are different for 4/8/24 bpp.

// The values correspond to the positions of the respective compression types
// in the drop-down list.
// This will have to make do until someone does a vast re-write of the 
// TIFF export options code!

// Note that LZW_TIFF and HUFFMAN_TIFF are at the same position:
// this is because they don't actually appear at the same time.
// For 1bpp, the options are { uncompressed, huffman, g3 ... }
// For 8ppp, the options are { uncompressed, lzw }

#define UNCOMPRESSED_TIFF 0
#define LZW_TIFF 1
#define HUFFMAN_TIFF 1
#define G3FAX_TIFF 2
#define G4FAX_TIFF 3
#define PACKBITS_TIFF 4
#define TWODENCODING_TIFF 5


// BODGE: We get some bad pixel cropping on some images if we use doubles. So limit the doubles to
// fixed values until these problems are fixed.
// Hence the conversion of GetDoubleGadgetValues into GetLongGadgetValues.
static const double D_MAXDPI = 3000.0;
static const INT32 MAXDPI = 3000;

// Height of extra bit at the bottom of the dialogue with the Animation options
static const INT32 ANIMATION_EXTRABIT  = 76;
static const INT32 NUMCOLS_EXTRABIT   = 56;
static const INT32 NUMCOLS_GROUP_SHIFT = 80;

// WEBSTER - markn 24/1/97
// The number of system colours added when the "Add system colours" switch is on
// (28 because there are 27 Gavin primary colours (which includes most of the windows colour)
// plus one windows colour that isn't a Gavin primary)
static const INT32 NUM_SYS_COLS = 28;


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

>   BmpPrefsDlg::BmpPrefsDlg(): DialogOp(BmpPrefsDlg::IDD, BmpPrefsDlg::Mode) 

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/08/94
    Purpose:    BmpPrefsDlg constructor. Creates a non-undoable operation

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

BmpPrefsDlg::BmpPrefsDlg(): DialogOp(BmpPrefsDlg::IDD, BmpPrefsDlg::Mode) 
{
    m_pOptions = NULL;

    Width       = 0;
    Height      = 0;
    PixelWidth  = 0;
    PixelHeight = 0;
    Dpi         = 96.0;

    LastBppSelected = 0;

    RecalculatingPixels = FALSE;
    RecalculatingXDpi   = FALSE;
    RecalculatingYDpi   = FALSE;

    m_bDpiSupported = FALSE;
    m_bLockAspect   = FALSE;
    IsDelayMany = FALSE;            
    IsDelayDefault = FALSE;     
    HasDelayChanged = FALSE;
    HasRestoreChanged = FALSE;
    IsManyDisplayed = FALSE;
    DisplayMany = FALSE;
    LoopCheckBoxEnabled = TRUE;
}


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

>   SelectionType BmpPrefsDlg::GetSelection(BmpPrefsDlg* pBmpPrefs) 


    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/3/95
    Inputs:     -
    Outputs:    -
    Returns:    Selection, Drawing or Spread.
    Purpose:    Works out what the current selection/spread/drawing state is.
    Errors:     -
    SeeAlso:    -

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

SelectionType BmpPrefsDlg::GetSelection()
{
    // Get the state of the selection, drawing or spread buttons
    BOOL Valid = FALSE;

    // If opening specification was a bitmap then nothing doing
    if (GetOptions()->GetSelectionType() == ABITMAP)
        return ABITMAP;

    if (GetOptions()->GetSelectionType() == SOMEBITMAPS)
        return SOMEBITMAPS;

    SelectionType FoundSelection = DRAWING;
    
    BOOL ExportDrawing = GetLongGadgetValue(_R(IDC_BMPOPTS_DRAWING), 0, 1, 0, &Valid);
    // Use the state on entry to dictate the possible output values.
    if (GetOptions()->GetSelectionType() == SELECTION)
    {
        // If selection present then choose between Selection or Drawing
        if (ExportDrawing)
            FoundSelection = DRAWING;
        else        
            FoundSelection = SELECTION;
    }
    else
    {
        // Graham 24/7/97: If no selection, then set DRAWING automatically
        FoundSelection = DRAWING;       
    }
    
    // return what was found to the caller
    return FoundSelection;
}   

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

>   void    BmpPrefsDlg::RecalculateSize(BmpPrefsDlg* pBmpPrefs)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/3/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Calculates the size of the selection/spread/drawing and fills in the width
                and height fields accordingly. It then calculates the pixel size and/or dpi.
    Errors:     -
    SeeAlso:    -

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

void    BmpPrefsDlg::RecalculateSize()
{    
    // Get the state of the selection, drawing or spread buttons
    SelectionType FoundSelection = GetSelection();

    // Construct our spread/drawing/selection size rectangle
    ClipRect;
    ClipRect.MakeEmpty(); 

    if (FoundSelection == ABITMAP)
    {
        // Show only the PixelWidth of the bitmap, size in units is irrelevent
        BaseBitmapFilter::GetSizeOfBitmap(&PixelWidth, &PixelHeight);

        RecalculatingPixels = TRUE;  // flag no updates to dpi field from RecalculateDpiFromX, Y
        
        SetLongGadgetValue(_R(IDC_BMPOPTS_XPIXELS), PixelWidth);
        SetLongGadgetValue(_R(IDC_BMPOPTS_YPIXELS), PixelHeight);

        // WEBSTER - markn 5/2/97
        // Taken out the X & Y size gadgets
#ifndef WEBSTER
        SetStringGadgetValue(_R(IDC_BMPOPTS_XSIZE), &String_8("-"));
        SetStringGadgetValue(_R(IDC_BMPOPTS_YSIZE), &String_8("-"));
        EnableGadget(_R(IDC_BMPOPTS_XSIZE), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_YSIZE), FALSE);
#endif // WEBSTER
        EnableGadget(_R(IDC_BMPOPTS_XPIXELS), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_YPIXELS), FALSE);

        RecalculatingPixels = FALSE;     // flag no updates to dpi field from RecalculateDpiFromX, Y

        // We need a DPI to work with, so we'll just use the default pixel unit size
        DocUnitList* pDocUnitList = DocUnitList::GetCurrentDocUnitList();
        ERROR3IF(pDocUnitList == NULL, "BmpPrefsDlg::RecalculateSize() - no pDocUnitList!")
        Unit* pPixelUnit = pDocUnitList->FindUnit(PIXELS);
        ERROR3IF(pPixelUnit == NULL, "BmpPrefsDlg::RecalculateSize() - no pixel units!")
        Unit* pInchUnit = pDocUnitList->FindUnit(INCHES);
        ERROR3IF(pInchUnit == NULL, "BmpPrefsDlg::RecalculateSize() - no inch units!")
        double newDpi = (pPixelUnit->GetMillipoints()>0) ? pInchUnit->GetMillipoints() / pPixelUnit->GetMillipoints() : 96.0;
        Dpi = (INT32)newDpi;
        GetOptions()->SetDPI(newDpi);
    
        ClipRect.lo = DocCoord(0,0);
        ClipRect.hi = DocCoord(PixelWidth * (INT32)newDpi, PixelHeight * (INT32)newDpi);

        Width = ClipRect.Width();   
        Height = ClipRect.Height(); 

        // All work is now complete so exit
        return;
    }   

    if (FoundSelection == SOMEBITMAPS)
    {
        // Setup size of animation frames
        ClipRect.lo = DocCoord(0,0);
        ClipRect.hi = DocCoord(GetOptions()->GetOutputSize().x, GetOptions()->GetOutputSize().y);
    }   

    // Find the application and selected document 
    Application* pApplication = GetApplication();
    Document* pDocument = Document::GetSelected();
    Spread* pSpread = NULL;

    // As long as we have an application and a selected document then go and work out
    // the rectangles
    if (pApplication && pDocument && FoundSelection != ABITMAP  && FoundSelection != SOMEBITMAPS)
    {
        // First, check if there is a selection present. ClipRect should be empty if not.
        SelRange* pSelection = pApplication->FindSelection();
        if (pSelection)
        {
            // Get the bounding rectangle for the selection
            ClipRect = pSelection->GetBoundingRect();

            // Work out the parent spread by finding the first node in the selection
            Node* pNode = pSelection->FindFirst();
            // if there is a first node then just find the parent spread
            // otherwise just use the first spread in the document
            if (pNode)
                pSpread = pNode->FindParentSpread();
            else
                pSpread = pDocument->FindFirstSpread();
        }

        if (pSpread)
        {
            switch (FoundSelection)
            {
                case ABITMAP:
                    ERROR3IF(TRUE, "BmpPrefsDlg::RecalculateSize() - This should have already been taken care of")
                    // This should have already been taken care of
                    break;
                case SELECTION:
                    // This should have already been taken care of
                    break;
                case SPREAD:
                {
                    // Work out the size of the rectangle encompassing the spread,
                    // using the same function that the bitmap export code uses.
                    ERROR3("Selection == Spread!");

                    ClipRect = BaseBitmapFilter::GetSizeOfSpread(pSpread);
                    //break;
                }
                
                default:
                {
                    // Work out the size of the rectangle encompassing the drawing, (visible 
                    // layers only), using the same function that the bitmap export code
                    // uses.
                    ClipRect = BaseBitmapFilter::GetSizeOfDrawing(pSpread);
                    break;
                }
            } // End switch
        }
    }

    // Graeme 25/7/00 - If our clip rectangle is less than the minimum export size,
    // resize the clipping rectangle to encompass the entire page.
    if ( ClipRect.IsEmpty() ||
         ClipRect.Width() < BaseBitmapFilter::MinExportSize ||
         ClipRect.Height() < BaseBitmapFilter::MinExportSize )
    {
        // Set the ClipRect to be the size of the spread.
        ClipRect = pSpread->FindFirstPageInSpread ()->GetPageRect ();
    }   

    // Work out the size of this rectangle encompassing the speread/drawing/selection
    // in Millipoints and store these in the class variables for later reuse
    Width = ClipRect.Width();   
    Height = ClipRect.Height(); 

    // Work out what the current units we should be displaying in
    DocUnitList* pDocUnitList = NULL;
    UnitType CurrentPageUnits = MILLIMETRES;
    if (pDocument)
    {
        pDocUnitList = pDocument->GetDocUnitList();
        if (pDocUnitList)
            CurrentPageUnits = pDocUnitList->GetPageUnits();
    }
    
    // WEBSTER - markn 5/2/97
    // Taken out the X & Y size gadgets
    #ifndef WEBSTER
    if (m_bDpiSupported)
    {
        SetUnitGadgetValue(_R(IDC_BMPOPTS_XSIZE), CurrentPageUnits, Width, FALSE, -1);
        SetUnitGadgetValue(_R(IDC_BMPOPTS_YSIZE), CurrentPageUnits, Height, FALSE, -1);
    }
    else
    {
        SetStringGadgetValue(_R(IDC_BMPOPTS_XSIZE), &String_8("-"));
        SetStringGadgetValue(_R(IDC_BMPOPTS_YSIZE), &String_8("-"));
    }
    #endif // WEBSTER
    
    // Work out what this size is in pixels and fill in the editable fields
    RecalculatePixels();
}

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

>   void    BmpPrefsDlg::RecalculatePixels()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/3/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Takes the size of the selection/spread/drawing and calculates the size that
                this will be in pixels given the current dpi field.
    Errors:     -
    SeeAlso:    -

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

void    BmpPrefsDlg::RecalculatePixels()
{    

    // If the RecalculateDpiFromX() or RecalculateDpiFromY() functions are setting the
    // values then make sure we do not update the values as well. 
    if (RecalculatingXDpi || RecalculatingYDpi)
        return;

    // Now work out the pixel sizes which this will correspond to at the current dpi setting
    PixelWidth = 0; 
    PixelHeight = 0;    
    Dpi = 0;
    BOOL Valid = 0;         // Flag for validity of value

    // Get the dpi value from the resolution combo box, with no error reporting
    // Don't change the current values if the dpi is wrong
    if (!m_bDpiSupported)
    {
        Dpi = GetOptions()->GetDPI();
        Valid = TRUE;
    }
    else
    {
        Dpi = (double)GetLongGadgetValue(_R(IDC_BMPOPTS_RES), 5, MAXDPI, NULL ,&Valid);
    }
    
    if ( Valid ) 
    {
        // This is the calculation that we are effectively doing
        // Use 0.5 so that we are forced to round up to the next pixel, if possible
        //PixelWidth = (INT32)(((Width * Dpi)/72000) + 0.5);
        //PixelHeight = (INT32)(((Height * Dpi)/72000) + 0.5);
        // but use the same code that the bitmap code will use so that we are consistent
        Matrix Identity;    // default construction is an identity matrix
        WinRect Rect = OSRenderRegion::BitmapDocRectToWin( Identity, ClipRect, Dpi );
        PixelWidth = Rect.Width();
        PixelHeight = Rect.Height();

        // More of a safety net here.
        if (PixelWidth < 0)
            PixelWidth = 0;
        if (PixelHeight < 0)
            PixelHeight = 0;

        RecalculatingPixels = TRUE;  // flag no updates to dpi field from RecalculateDpiFromX, Y
        
        SetLongGadgetValue(_R(IDC_BMPOPTS_XPIXELS), PixelWidth);
        SetLongGadgetValue(_R(IDC_BMPOPTS_YPIXELS), PixelHeight);
        
        RecalculatingPixels = FALSE;     // flag no updates to dpi field from RecalculateDpiFromX, Y
    }
    else
    {
        RecalculatingPixels = TRUE;  // flag no updates to dpi field from RecalculateDpiFromX, Y

        // There is a problem with the dpi so blank the pixel width/height fields 
        SetStringGadgetValue(_R(IDC_BMPOPTS_XPIXELS), &String_8(""));
        SetStringGadgetValue(_R(IDC_BMPOPTS_YPIXELS), &String_8(""));

        RecalculatingPixels = FALSE;     // flag no updates to dpi field from RecalculateDpiFromX, Y
    }
}

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

>   void    BmpPrefsDlg::RecalculateDpiFromX()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/3/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Takes the size of the selection/spread/drawing and the size in the pixel
                width field and calculates a new current dpi from this.
    Errors:     -
    SeeAlso:    -

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

void    BmpPrefsDlg::RecalculateDpiFromX()
{    
    // If the RecalculatePixels() function is setting the values then make sure we
    // do not update the values as well. 
    if (RecalculatingPixels || RecalculatingYDpi)
        return;

    // Now work out the pixel sizes which this will correspond to at the current dpi setting
    // Get the x and y pixel sizes from the editable fields, with no error reporting
    // Use 9 as minimum so that when deleting, the dpi is not blanked when down to one digit
    BOOL Valid = FALSE; // Flag for validity of value
    PixelWidth = GetLongGadgetValue(_R(IDC_BMPOPTS_XPIXELS), 9, INT32_MAX, NULL ,&Valid);

    if ( Valid ) 
    {
        RecalculatingXDpi = TRUE;

        double Resolution = (Width>0) ? ((double) PixelWidth * 72000.0) / ((double) Width) : 96.0;

        // A bit of a safety net here
        if ((Resolution < 5.0) || (Resolution > D_MAXDPI))
        {
            // There is a problem with the x pixels field so blank the pixel height
            // and dpi fields 
            SetStringGadgetValue(_R(IDC_BMPOPTS_YPIXELS), &String_8(""));
            if (m_bDpiSupported)
            {
                SetStringGadgetValue(_R(IDC_BMPOPTS_RES), &String_8(""), FALSE, -1);
            }
        }
        else
        {
            // Use 0.5 so that we are forced to round up to the next dpi, if possible
            INT32 b_dpi = (INT32)(Resolution + 0.5);
            Dpi = b_dpi; //Resolution;
            if (m_bDpiSupported)
            {
                //SetDoubleGadgetValue(_R(IDC_BMPOPTS_RES), Dpi, FALSE, -1);
                SetLongGadgetValue(_R(IDC_BMPOPTS_RES), (INT32)Dpi, FALSE, -1);
            }

            // Given the new dpi, recalculate the y pixels
            // This is once again the calculation we are doing
            // INT32 PixelHeight = (INT32)(((Height * Dpi)/72000) + 0.5);
            // but using the same code that wil be used for exporting
            Matrix Identity;    // default construction is an identity matrix
            WinRect Rect = OSRenderRegion::BitmapDocRectToWin( Identity, ClipRect, Dpi );
            PixelHeight = Rect.Height();
            SetLongGadgetValue(_R(IDC_BMPOPTS_YPIXELS), PixelHeight);
        }
                
        RecalculatingXDpi = FALSE;
    }
    else
    {
        RecalculatingXDpi = TRUE;

        // There is a problem with the x pixels field so blank the pixel height
        // and dpi fields 
        SetStringGadgetValue(_R(IDC_BMPOPTS_YPIXELS), &String_8(""));
        if (m_bDpiSupported)
        {
            SetStringGadgetValue(_R(IDC_BMPOPTS_RES), &String_8(""), FALSE, -1);
        }

        RecalculatingXDpi = FALSE;
    }
}

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

>   void    BmpPrefsDlg::RecalculateDpiFromY()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/3/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Takes the size of the selection/spread/drawing and the size in the pixel
                height field and calculates a new current dpi from this.
    Errors:     -
    SeeAlso:    -

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

void    BmpPrefsDlg::RecalculateDpiFromY()
{    
    // If the RecalculatePixels() function is setting the values then make sure we
    // do not update the values as well. 
    if (RecalculatingPixels || RecalculatingXDpi)
        return;

    // Now work out the pixel sizes which this will correspond to at the current dpi setting
    // Get the x and y pixel sizes from the editable fields, with no error reporting
    // Use 9 as minimum so that when deleting, the dpi is not blanked when down to one digit
    BOOL Valid = FALSE;     // Flag for validity of value
    PixelHeight = GetLongGadgetValue(_R(IDC_BMPOPTS_YPIXELS), 9, INT32_MAX, NULL ,&Valid);

    if ( Valid ) 
    {
        RecalculatingYDpi = TRUE;
        
        double Resolution = (Height>0) ? ((double) PixelHeight * 72000.0) / ((double) Height) : 96.0;

        // A bit of a safety net here
        if ((Resolution < 5.0) || (Resolution > D_MAXDPI))
        {
            // There is a problem with the y pixels field so blank the pixel width
            // and dpi fields 
            SetStringGadgetValue(_R(IDC_BMPOPTS_XPIXELS), &String_8(""));
            if (m_bDpiSupported)
            {
                SetStringGadgetValue(_R(IDC_BMPOPTS_RES), &String_8(""), FALSE, -1);
            }
        }
        else
        {
            // Use 0.5 so that we are forced to round up to the next dpi, if possible
            INT32 b_dpi = (INT32)(Resolution + 0.5);
            Dpi = b_dpi; //Resolution;
            {
                //SetDoubleGadgetValue(_R(IDC_BMPOPTS_RES), Dpi, FALSE, -1);
                SetLongGadgetValue(_R(IDC_BMPOPTS_RES), (INT32)Dpi, FALSE, -1);
            }
            
            // Given the new dpi, recalculate the y pixels
            // This is once again the calculation we are doing
            // INT32 PixelWidth = (INT32)(((Width * Dpi)/72000) + 0.5);
            // but using the same code that wil be used for exporting
            Matrix Identity;    // default construction is an identity matrix
            WinRect Rect = OSRenderRegion::BitmapDocRectToWin( Identity, ClipRect, Dpi );
            PixelWidth = Rect.Width();
            SetLongGadgetValue(_R(IDC_BMPOPTS_XPIXELS), PixelWidth);
        }

        RecalculatingYDpi = FALSE;
    }
    else
    {
        RecalculatingYDpi = TRUE;

        // There is a problem with the y pixels field so blank the pixel width
        // and dpi fields 
        SetStringGadgetValue(_R(IDC_BMPOPTS_XPIXELS), &String_8(""));
        if (m_bDpiSupported)
        {
            SetStringGadgetValue(_R(IDC_BMPOPTS_RES), &String_8(""), FALSE, -1);
        }

        RecalculatingYDpi = FALSE;
    }
}

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

>   void    BmpPrefsDlg::SetBPPButtons(GadgetID ButtonClicked,BOOL CheckNumColValueRange)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/08/94
    Inputs:     the id of the clicked radio button
                CheckNumColValueRange = TRUE if the value in the num col ed field should be checked. (added for WEBSTER - markn 1/2/97)
    Outputs:    -
    Returns:    -
    Purpose:    Sets all other radio buttons in the group off
    Errors:     -
    SeeAlso:    -

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

void BmpPrefsDlg::SetBPPButtons(CGadgetID ButtonClicked,BOOL CheckNumColValueRange)
{    
    BitmapExportOptions* pOptions = GetOptions();
    if (pOptions == NULL)
    {
        ERROR3("pOptions == NULL");
        return;
    }

    // WEBSTER - markn 23/1/97
    SetLongGadgetValue(ButtonClicked, TRUE);

    BOOL EnablePalette = FALSE;

    // If either 8, 4 or 1 bpp clicked then enable the Palette and Dithering Options
    if ( ButtonClicked == _R(IDC_BMPOPTS_8BPP) || ButtonClicked == _R(IDC_BMPOPTS_4BPP)  || ButtonClicked == _R(IDC_BMPOPTS_1BPP))
        EnablePalette = TRUE;

    EnableGadget(_R(IDC_BMPOPTS_PAL_STD), EnablePalette);
    EnableGadget(_R(IDC_BMPOPTS_PAL_OPT), EnablePalette);
    EnableGadget(_R(IDC_BMPOPTS_NODITHER),  EnablePalette);
    EnableGadget(_R(IDC_BMPOPTS_DIFFUSION), EnablePalette);

    if (EnablePalette)
    {
        BOOL Valid = 0;
        if ( GetLongGadgetValue(_R(IDC_BMPOPTS_PAL_OPT), 0, 1, 0, &Valid) )
            EnableGadget(_R(IDC_BMPOPTS_ORDDITHER), FALSE);
        else
            EnableGadget(_R(IDC_BMPOPTS_ORDDITHER), TRUE);
    }
    else
        EnableGadget(_R(IDC_BMPOPTS_ORDDITHER), FALSE);

    // WEBSTER - markn 17/1/97
    // Only update for relevant filters
    if (pOptions->UseSpecificNumColsInPalette())
        UpdateNumColoursGroup(CheckNumColValueRange);   // New parameter - WEBSTER - markn 1/2/97

    if (pOptions->GetFilterType() == MAKE_BITMAP_FILTER)
    {
        // Disable transparency button in same circustances as
        // the palette buttons are disabled
        EnableGadget(_R(IDC_BMPOPTS_TRANSPARENT), EnablePalette);

        // If we're greying out the button, turn off the transparency flag too
        // so that we take no notice of it when it's grey
        if (!EnablePalette)
        {
            SetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), 0);
        }
        else
        {
            MaskedFilterExportOptions* pMaskOptions = (MaskedFilterExportOptions*)pOptions;
            ERROR3IF(!pMaskOptions->IS_KIND_OF(MaskedFilterExportOptions), "pMaskOptions isn't");

            SetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), pMaskOptions->WantTransparent());
        }
    }

    // Cope with the transparency button on a PNG options dialog box    
    if (pOptions->GetFilterType() == PNG) 
    {
        PNGExportOptions* pPNGOptions = (PNGExportOptions*)pOptions;
        ERROR3IF(!pPNGOptions->IS_KIND_OF(PNGExportOptions), "pPNGOptions isn't");
        // Now enable or disable the transparency if we are in the wrong bpp mode
        // Transparency only available in 8 bpp mode or less
        BOOL Enable = FALSE;
        if ( ButtonClicked == _R(IDC_BMPOPTS_8BPP) || ButtonClicked == _R(IDC_BMPOPTS_4BPP) ||
             ButtonClicked == _R(IDC_BMPOPTS_1BPP) )
            Enable = TRUE;

        // Enable should be True if 8bpp or 4bpp or 1bpp button is On and False if not 
        EnableGadget(_R(IDC_BMPOPTS_TRANSPARENT), Enable);
        if (!Enable)
        {
            SetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), 0);
        }
        else
        {
            SetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), pPNGOptions->WantTransparent());
        }
    }

    // WEBSTER - markn 23/1/97
    // Compression group always hidden in Webster
    #ifndef WEBSTER
    // Cope with the compression buttons on a BMP options dialog box    
    if (pOptions->GetFilterType() == BMP_UNCOMPRESSED) 
    {
        // Now enable or disable the switches that are dependent on the 8 bpp switch 
        // RLE compression switch, only available in 8 bpp mode or 4 bpp
        BOOL Enable = FALSE;
        if ( ButtonClicked == _R(IDC_BMPOPTS_8BPP) || ButtonClicked == _R(IDC_BMPOPTS_4BPP) )
            Enable = TRUE;

        // Enable should be True if 8bpp or 4bpp button is On and False if not 
        // Present only on the BMP export dialog box
        EnableGadget(_R(IDC_BMPOPTS_COMPRESS), Enable);     // main group icon
        EnableGadget(_R(IDC_BMPOPTS_RLE), Enable);
        EnableGadget(_R(IDC_BMPOPTS_RGB), Enable);
    }
    #endif // WEBSTER

    // Cope with the compression buttons on a TIFF options dialog box   
    // Enable should be True if 8bpp or 4bpp button is On and False if not 
    if (pOptions->GetFilterType() == TIFF_UNCOMPRESSED) 
    {
    //WEBSTER-Martin-06/01/97
#ifndef WEBSTER
        TIFFExportOptions* pTIFFOptions = (TIFFExportOptions*)pOptions;
        ERROR3IF(!pTIFFOptions->IS_KIND_OF(TIFFExportOptions), "pTIFFOptions isn't");
    
        // Now enable or disable the compression options depending upon the BPP
        BOOL bEnableLZW = FALSE;
        BOOL bEnableMonoCompression = FALSE;

        if ( ButtonClicked == _R(IDC_BMPOPTS_1BPP))
            bEnableMonoCompression = TRUE;

        if ( ButtonClicked == _R(IDC_BMPOPTS_24BPP) || ButtonClicked == _R(IDC_BMPOPTS_8BPP) || ButtonClicked == _R(IDC_BMPOPTS_CMYK) )
            bEnableLZW = TRUE;


        // Cannot grey items in the list so we need to change the list itself.
        // But only change it if we need to. Check last state and see if we have changed.
        // from 1bpp or to 1bpp.
        if ( /*
            (LastBppSelected == _R(IDC_BMPOPTS_1BPP) && ButtonClicked != _R(IDC_BMPOPTS_1BPP)) ||
            (LastBppSelected != _R(IDC_BMPOPTS_1BPP) && ButtonClicked == _R(IDC_BMPOPTS_1BPP))
           */ TRUE )
        {
            // So, set up the list of available TIFF compressions. Must be the same as the list
            // in TiffTypes.
            //TiffTypes CompressionType = (TiffTypes)GetSelectedValueIndex(_R(IDC_BMPOPTS_TIFF));
            
            // Andy Hills, 05-09-00
            // We can't use TiffTypes to determine the selection.
            // This is because the list of compression types changes between bpp settings.
            // Instead we will call the new function GetTIFFCompressionSelection
            // which works out which compression type is selected.
            // We need to tell it which bpp is selected.

            INT32 nBPP;
            switch( ButtonClicked )
            {
            case _R(IDC_BMPOPTS_1BPP):  nBPP=1;     break;
            case _R(IDC_BMPOPTS_4BPP):  nBPP=4;     break;
            case _R(IDC_BMPOPTS_8BPP):  nBPP=8;     break;
            case _R(IDC_BMPOPTS_24BPP): nBPP=24;    break;
            case _R(IDC_BMPOPTS_CMYK):  nBPP=32;    break;
            default:
                ERROR3( "BmpPrefsDlg::SetBPPButtons - invalid bpp obtained" );
            }
            
            INT32 CompressionType = GetTIFFCompressionSelection(nBPP);

            // First delete all present items
            DeleteAllValues(_R(IDC_BMPOPTS_TIFF));
            // Set up the default value in the editable field
            BOOL ok = SetLongGadgetValue(_R(IDC_BMPOPTS_TIFF), pTIFFOptions->GetCompression(), FALSE, -1);

            // Set all the basic options (i.e. no compression)
            SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_NONE)));

            // Andy Hills, 16-08-00: re-added LZW export
            if (bEnableLZW)
            {
                // 8 / 24-bit, so enable LZW
                SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_LZW)));
            }

            if (bEnableMonoCompression)
            {
                // 1bpp so allow all options (except LZW)
                SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_HUFFMAN)));
                SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_G3FAX)));
                SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_G4FAX)));
                SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_PACKBITS)));
                //SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_2DENCODING)));
            }

            SetComboListLength(_R(IDC_BMPOPTS_TIFF));

            // Select the correct item again

            if( nBPP == 1 && LastBppSelected != _R(IDC_BMPOPTS_1BPP) && LastBppSelected )
            {
                // changing to 1bpp
                // --> set compression to NONE
                ok = SetTIFFCompressionSelection( TIFF_UNCOMPRESSED, nBPP );
                
                // We should ALWAYS be able to select UNCOMPRESSED
                ERROR3IF( (!ok), "BmpPrefsDlg::SetBPPButtons - could not select uncompressed" );
            }
            else if( nBPP >= 8 && 
                (LastBppSelected == _R(IDC_BMPOPTS_1BPP) || LastBppSelected == _R(IDC_BMPOPTS_4BPP)) )
            {
                // changing to 8/24bpp (from 1/4bpp)
                // --> set compression to LZW
                ok = SetTIFFCompressionSelection( TIFF_LZW, nBPP );
                
                // We should ALWAYS be able to select LZW from 8/24 bpp
                ERROR3IF( (!ok), "BmpPrefsDlg::SetBPPButtons - could not select LZW" );
            }
            else
            {
                // otherwise, just leave compression as it is
                ok = SetTIFFCompressionSelection( CompressionType, nBPP );
                
                // if the previously selected compression is now disabled, select NONE
                if( ! ok )
                {
                    //SetSelectedValueIndex(_R(IDC_BMPOPTS_TIFF), _R(IDN_TIFF_NONE));
                    ok = SetTIFFCompressionSelection( TIFF_UNCOMPRESSED, nBPP );
                    
                    // We should ALWAYS be able to select UNCOMPRESSED
                    ERROR3IF( (!ok), "BmpPrefsDlg::SetBPPButtons - could not select uncompressed" );
                }
            }
        }
    
        // Update the last button to be the one just selected
        LastBppSelected = ButtonClicked;
#endif //WEBSTER
    }
}

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

>   void BmpPrefsDlg::SetPaletteButtons(GadgetID ButtonClicked)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/05/96
    Inputs:     the id of the clicked radio button
    Outputs:    -
    Returns:    -
    Purpose:    Sets all other radio buttons in the group off
    Errors:     -
    SeeAlso:    -

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

void BmpPrefsDlg::SetPaletteButtons(CGadgetID ButtonClicked)
{    
    if ( ButtonClicked == _R(IDC_BMPOPTS_PAL_OPT) )
    {
        BOOL Valid = 0;
        if ( GetLongGadgetValue(_R(IDC_BMPOPTS_ORDDITHER), 0, 1, 0, &Valid) )
        {
            SetLongGadgetValue(_R(IDC_BMPOPTS_ORDDITHER), FALSE);
            SetLongGadgetValue(_R(IDC_BMPOPTS_DIFFUSION), TRUE);
        }

        SetLongGadgetValue(_R(IDC_BMPOPTS_PAL_OPT), TRUE);
        
        EnableGadget(_R(IDC_BMPOPTS_ORDDITHER), FALSE);

        // WEBSTER - markn 17/1/97
        // Update num colours group
        UpdateNumColoursGroup(FALSE);
    }
    else
    {
        SetLongGadgetValue(_R(IDC_BMPOPTS_PAL_STD), TRUE);
            
        EnableGadget(_R(IDC_BMPOPTS_ORDDITHER), TRUE);

        // WEBSTER - markn 17/1/97
        UpdateNumColoursGroup(FALSE);
    }
}

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

>   void BmpPrefsDlg::SetDitherButtons(GadgetID ButtonClicked)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/05/96
    Inputs:     the id of the clicked radio button
    Outputs:    -
    Returns:    -
    Purpose:    Sets all other radio buttons in the group off
    Errors:     -
    SeeAlso:    -

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

void BmpPrefsDlg::SetDitherButtons(CGadgetID ButtonClicked)
{    
}


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

>   TIFF_COMPRESSION BmpPrefsDlg::GetTIFFCompressionSelection( INT32 nBPP )

    Author:     Andy_Hills (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/09/00
    Inputs:     nBPP        Currently selected bits-per-pixel
    Outputs:    
    Returns:    The currently selected compression type.
    Purpose:    This function has been added because no allowances have been
                made for the fact that the compression options list is
                different for each BPP setting.
    Errors:     Returns -1 on failure.
    SeeAlso:    SetBPPButtons

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

TIFF_COMPRESSION BmpPrefsDlg::GetTIFFCompressionSelection( INT32 nBPP )
{
    // Get the state of the TIFF compression selection combo box
    TIFF_COMPRESSION Compression;
    INT32 nIndex = GetSelectedValueIndex(_R(IDC_BMPOPTS_TIFF));

    if( nBPP == 1 )
    {
        switch ( nIndex )
        {
            case TWODENCODING_TIFF: Compression = TIFF_2D;              break;
            case PACKBITS_TIFF:     Compression = TIFF_PACK;            break;
            case HUFFMAN_TIFF:      Compression = TIFF_HUFFMAN;         break;
            case G3FAX_TIFF:        Compression = TIFF_G3_FAX;          break;
            case G4FAX_TIFF:        Compression = TIFF_G4_FAX;          break;
            default:                
            case UNCOMPRESSED_TIFF: Compression = TIFF_UNCOMPRESSED;    break;
        }
    }
    else if( nBPP==8 || nBPP==24 || nBPP==32 )
    {
        switch ( nIndex )
        {
            case LZW_TIFF:          Compression = TIFF_LZW;             break;
            default:                
            case UNCOMPRESSED_TIFF: Compression = TIFF_UNCOMPRESSED;    break;
        }
    }
    else if( nBPP == 4 )
    {
        Compression = TIFF_UNCOMPRESSED;
    }
    else
    {
        ERROR2( -1, "BmpPrefsDlg::GetTIFFCompressionSelection - invalid nBPP" );
    }
    
    return Compression;
}


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

>   BOOL BmpPrefsDlg::SetTIFFCompressionSelection( TIFF_COMPRESSION Compression, INT32 nBPP )

    Author:     Andy_Hills (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/09/00
    Inputs:     Compression     Desired compression setting
                nBPP            Currently selected bits-per-pixel
    Outputs:    
    Returns:    TRUE on success
    Purpose:    This function has been added because no allowances have been
                made for the fact that the compression options list is
                different for each BPP setting.
    Errors:     Returns FALSE on failure
                e.g. if the specified compression type is not available with the current
                bpp setting.
    SeeAlso:    SetBPPButtons

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

BOOL BmpPrefsDlg::SetTIFFCompressionSelection( TIFF_COMPRESSION Compression, INT32 nBPP )
{
    if( nBPP == 1 )
    {
        if
        (
            Compression != TIFF_2D &&
            Compression != TIFF_PACK &&
            Compression != TIFF_HUFFMAN &&
            Compression != TIFF_G3_FAX &&
            Compression != TIFF_G4_FAX &&
            Compression != TIFF_UNCOMPRESSED
        ) return FALSE;
    }
    else if( nBPP==8 || nBPP==24 || nBPP==32 )
    {
        if
        (
            Compression != TIFF_LZW &&
            Compression != TIFF_UNCOMPRESSED
        ) return FALSE;
    }
    else if( nBPP == 4 )
    {
        if
        (
            Compression != TIFF_UNCOMPRESSED
        ) return FALSE;
    }
    else
    {
        ERROR2( -1, "BmpPrefsDlg::GetTIFFCompressionSelection - invalid nBPP" );
    }
    
    // look up the index of the compression type
    INT32 nIndex;
    switch ( Compression )
    {
        case TIFF_UNCOMPRESSED: nIndex = UNCOMPRESSED_TIFF; break;
        case TIFF_LZW:          nIndex = LZW_TIFF;          break;
        case TIFF_HUFFMAN:      nIndex = HUFFMAN_TIFF;      break;
        case TIFF_G3_FAX:       nIndex = G3FAX_TIFF;        break;
        case TIFF_G4_FAX:       nIndex = G4FAX_TIFF;        break;
        case TIFF_PACK:         nIndex = PACKBITS_TIFF;     break;
        case TIFF_2D:           nIndex = TWODENCODING_TIFF; break;
        default:                nIndex = UNCOMPRESSED_TIFF; break;
    }

    // Actually select the compression type.
    return SetSelectedValueIndex(_R(IDC_BMPOPTS_TIFF), nIndex);
}


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

>   BOOL BmpPrefsDlg::CommitDialogValues(BmpPrefsDlg* pBmpPrefs)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    03/10/94
    Inputs:     pointer to the dialogue box
    Outputs:    -
    Returns:    True if values in dialog box ok, False otherwise.     
    Purpose:    Takes the values in the dialog box and sets the return values accordingly
                Called when ok is pressed on the dialog box.
    Errors:     -
    SeeAlso:    -

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

BOOL BmpPrefsDlg::CommitDialogValues()
{
    BitmapExportOptions* pOptions = GetOptions();
    ERROR2IF(pOptions == NULL, FALSE, "BmpPrefsDlg::CommitDialogValues called after duff initialisation?!");

    // Ok has been pressed so take the values and set up the static values so that the
    // caller can access them

    BOOL Valid = 0; // Flag for validity of value

    //Added by Graham 27/5/97
    //First, let's set the pixel width and height into our OutputSize option
    pOptions->SetPixelOutputSize(PixelWidth, PixelHeight);

    // Although the file format may not support DPI, BaseBitmapFilter::PrepareToExport doesn't support
    // anything else. Since we may want to stretch the selection, we therefore need to supply a bogus dpi
    // based on the desired export size. dpi supporting formats can follow the mess...
    if (m_bDpiSupported)
    {
        // Get the dpi value from the resolution combo box
        // Minimum of 5dpi as anything lower causes major problems.  
        //double Value = GetDoubleGadgetValue(_R(IDC_BMPOPTS_RES), 5.0, D_MAXDPI, _R(IDS_BMPPREFS_INVALIDDPI) ,&Valid);
        double Value = (double)GetLongGadgetValue(_R(IDC_BMPOPTS_RES), 5, MAXDPI, _R(IDS_BMPPREFS_INVALIDDPI) ,&Valid);
        if (Valid) 
        {
            // If returned value in range then set the new default
            pOptions->SetDPI(Value);
        }
        else
            return FALSE;

        RecalculatePixels();
    }
    else
    {
        double Resolution = (Width>0) ? ((double) PixelWidth * 72000.0) / ((double) Width) : 96.0;
        // A bit of a safety net here
        if (Resolution < 5.0)
        {
            // User has set an illegal state so warn them about it.
            InformError(_R(IDS_BMPPREFS_DPITOOSMALL));
            //Dpi = 0;
            return FALSE;
        }
        else if (Resolution > D_MAXDPI)
        {
            // User has set an illegal state so warn them about it.
            InformError(_R(IDS_BMPPREFS_DPITOOBIG));
            //Dpi = 0;
            return FALSE;
        }
        else
        {
            INT32 b_dpi = (INT32)(Resolution + 0.5);
            Dpi = b_dpi; //Resolution;
        }
        pOptions->SetDPI(Dpi);
    }

    // Get the output depth from the bpp radio buttons
    BOOL State = 0;
    UINT32 Depth = 24;
    if ( GetLongGadgetValue(_R(IDC_BMPOPTS_CMYK), 0, 1, 0, &Valid) )
    {
        pOptions->SetCMYK(TRUE);
        Depth = 32;
    }
    else if ( GetLongGadgetValue(_R(IDC_BMPOPTS_24BPP), 0, 1, 0, &Valid) )
        Depth = 24;
    else if ( GetLongGadgetValue(_R(IDC_BMPOPTS_8BPP), 0, 1, 0, &Valid) )
        Depth = 8;
    else if ( GetLongGadgetValue(_R(IDC_BMPOPTS_4BPP), 0, 1, 0, &Valid) )
        Depth = 4;
    else if ( GetLongGadgetValue(_R(IDC_BMPOPTS_1BPP), 0, 1, 0, &Valid) )
        Depth = 1;
    pOptions->SetDepth(Depth);

    // WEBSTER - markn 17/1/97
    // NOTE! This can change the Depth value set earlier in this function
    if (!SetNumColoursInPalette(pOptions))
        return FALSE;

    // Get the Palette setting from the radio buttons
    PALETTE Palette = PAL_STANDARD;
    if ( GetLongGadgetValue(_R(IDC_BMPOPTS_PAL_OPT), 0, 1, 0, &Valid) )
    {
        TRACEUSER( "Will", _T("Optimised Palette selected\n"));
        Palette = PAL_OPTIMISED;
    }

    // Get the dither type from the radio buttons
    DITHER DitherType = XARADITHER_ERROR_DIFFUSION;
    if ( GetLongGadgetValue(_R(IDC_BMPOPTS_NODITHER), 0, 1, 0, &Valid) )
        DitherType = XARADITHER_NONE;
    else if ( GetLongGadgetValue(_R(IDC_BMPOPTS_ORDDITHER), 0, 1, 0, &Valid) )
        DitherType = XARADITHER_ORDERED_GREY;
    else if ( GetLongGadgetValue(_R(IDC_BMPOPTS_DIFFUSION), 0, 1, 0, &Valid) )
        DitherType = XARADITHER_ERROR_DIFFUSION;

    TRACEUSER( "Will", _T("Dither %d selected\n"), DitherType);

    // Check that we have not gone over our GDraw limits for pixel width
    // Pixel height should not be so much of a problem as we will strip the export. 

    // This cast is here because PixelWidth is a signed number (for some odd reason)
    if ((DWORD) PixelWidth > GRenderRegion::GetMaxBitmapWidth() ||
        (DWORD) PixelWidth < 1 || (DWORD) PixelHeight < 1 )
    {
        // There is a problem so warn the user that the value is incorrect
        String_256 WarnMsg;

        WarnMsg.MakeMsg(_R(IDE_BMP_BADPIXELWIDTH), GRenderRegion::GetMaxBitmapWidth());
        Error::SetError(0, WarnMsg, 0);
        InformWarning(0, _R(IDS_OK));
        return FALSE; 
    }

    // Mostly the compression fields change according to the filter type in use
    switch ( pOptions->GetFilterType() ) 
    {
        case TIFF_UNCOMPRESSED:
        {
            //WEBSTER-Martin-03/01/97
#ifndef WEBSTER
            TIFFExportOptions* pTIFFOptions = (TIFFExportOptions*)pOptions;
            ERROR3IF(!pTIFFOptions->IS_KIND_OF(TIFFExportOptions), "pTIFFOptions isn't");

            // Get the state of the TIFF compression selection combo box
            TIFF_COMPRESSION Compression = GetTIFFCompressionSelection(Depth);
            ERROR2IF( (Compression==-1), FALSE, "BmpPrefsDlg::CommitDialogValues - invalid compresion type" );
            pTIFFOptions->SetCompression(Compression);

//Mark Howitt, 27/10/97. We need to setup both the Dither & Palette for the TIFF Options, as well as
//                       the Accusoft DitherToUse variable to ensure proper functionality.
            pTIFFOptions->SetDither(DitherType);
            pTIFFOptions->SetPalette(Palette);
            AccusoftFilters::SetDitherToUse(DitherType);

#endif //WEBSTER
            break;
        }
        case PNG:
        {
            PNGExportOptions* pPNGOptions = (PNGExportOptions*)pOptions;
            ERROR3IF(!pPNGOptions->IS_KIND_OF(PNGExportOptions), "pPNGOptions isn't");

            // GIF radio buttons used to hold the transparent/interlaced settings
            BOOL Interlace = GetLongGadgetValue(_R(IDC_BMPOPTS_INTERLACED), 0, 1, 0, &Valid);
            BOOL Transparent = GetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), 0, 1, 0, &Valid);
            // Transparency is not available at present
            // Only if we are exporting as a 32bpp bitmap.
            if (Valid)
            {
                //pPNGOptions->SetMakeTransparent(Transparent);
                pPNGOptions->SetMakeInterlaced(Interlace);

                // WEBSTER - markn 5/2/97
                // If the user has deselected Transparent, then make sure the cached index is set to -1
                if (!Transparent)
                    pPNGOptions->SetTransparencyIndex(-1);
            }
            pPNGOptions->SetDither(DitherType);
//          pPNGOptions->SetPalette(Palette);
            break;
        }

        case MAKE_BITMAP_FILTER:
        {
            MakeBitmapExportOptions* pMkBOptions = (MakeBitmapExportOptions*)pOptions;
            ERROR3IF(!pMkBOptions->IS_KIND_OF(MakeBitmapExportOptions), "pMkBOptions isn't");

            pMkBOptions->SetDither(DitherType);
//          pMkBOptions->SetPalette(Palette);

            // radio buttons used to hold the transparent/interlaced settings
            BOOL Interlace = GetLongGadgetValue(_R(IDC_BMPOPTS_INTERLACED), 0, 1, 0, &Valid);
            BOOL Transparent = GetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), 0, 1, 0, &Valid);
            //pMkBOptions->SetMakeTransparent(Transparent);
            pMkBOptions->SetMakeInterlaced(Interlace);

            break;
        }
        case TI_GIF:
        case TI_GIF_ANIM:
        {
            GIFExportOptions* pGIFOptions = (GIFExportOptions*)pOptions;
            ERROR3IF(!pGIFOptions->IS_KIND_OF(GIFExportOptions), "pGIFOptions isn't");
                                    
            pGIFOptions->SetDither(DitherType);
//          pGIFOptions->SetPalette(Palette);

            // GIF radio buttons used to hold the transparent/interlaced settings
            BOOL Interlace = GetLongGadgetValue(_R(IDC_BMPOPTS_INTERLACED), 0, 1, 0, &Valid);
            BOOL Transparent = GetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), 0, 1, 0, &Valid);
            //pGIFOptions->SetMakeTransparent(Transparent);
            pGIFOptions->SetMakeInterlaced(Interlace);

            // WEBSTER - markn 5/2/97
            // If the user has deselected Transparent, then make sure the cached index is set to -1
            if (!Transparent)
                pGIFOptions->SetTransparencyIndex(-1);

            if (pOptions->GetFilterType() == TI_GIF)
            {
                HideGadget(_R(IDC_ANIMOPTS_LOOP), TRUE);    
                HideGadget(_R(IDC_ANIMOPTS_DELAY), TRUE);   
                HideGadget(_R(IDC_ANIMOPTS_ITERATIONS), TRUE);
                HideGadget(_R(IDC_ANIMOPTS_REMOVAL), TRUE); 
            }

            if (pOptions->GetFilterType() == TI_GIF_ANIM)
            {
                UINT32 List = 0;
                BmpDlgParam* pBmpDlgParam = pOptions->GetBmpDlgParam();
                                    
                if (pBmpDlgParam != NULL)
                {
                    KernelBitmap** pListOfBitmaps = pBmpDlgParam->GetBitmapList();
                    List = pBmpDlgParam->GetListSize();

                    ERROR3IF(pListOfBitmaps == NULL && List > 0, "Where Have Our Bitmaps Gone?");
                    
                    if(pListOfBitmaps != NULL)
                    {
                        pGIFOptions->SetBitmapList(pListOfBitmaps);
                        pGIFOptions->SetListSize(List);
                    }
                }
                
                // Get the Animation Delay details.
                if (HasDelayChanged)
                {
                     CENTISECONDS Delay = GetLongGadgetValue(_R(IDC_ANIMOPTS_DELAY), 0, 65535, _R(IDS_BMPPREFS_INVALIDDELAY) ,&Valid);
                                     
                    if (Valid)
                    {
                        pBmpDlgParam->SetAnimDelay(Delay);
                        pBmpDlgParam->SetAreDelayValuesSame(TRUE);

                        UINT32 ListSize = pGIFOptions->GetListSize();
                        KernelBitmap** pListOfBitmaps = pGIFOptions->GetBitmapList();

                        ERROR3IF(pListOfBitmaps == NULL && ListSize > 0,"Do what");

                        // A new delay value has been set, store it in the bitmaps.
            
                        if (pListOfBitmaps != NULL)
                        {
                            while (ListSize > 0)
                            {
                                KernelBitmap* pBitmap = pListOfBitmaps[--ListSize] ;    

                                if(pBitmap != NULL)
                                {
                                    pBitmap->SetDelay(pBmpDlgParam->GetAnimDelay());
                                }
                            }
                        }
                    }
                    else
                        return FALSE;   
                }
        
                // Get the Animation Restore details.
                if (HasRestoreChanged)
                {
                    INT32 Restore  = GetSelectedValueIndex(_R(IDC_ANIMOPTS_REMOVAL));
                                
                    if(Restore != OPTION_FOUR)
                    {
                        pBmpDlgParam->SetRestoreType((GIFDisposalMethod) Restore);
                        pBmpDlgParam->SetSameRestoreType(TRUE);
                        UINT32 ListSize = pGIFOptions->GetListSize();

                        KernelBitmap** pListOfBitmaps = pGIFOptions->GetBitmapList();
                        ERROR3IF(pListOfBitmaps == NULL && ListSize > 0,"Do what");

                        // A new Restore type has been entered, store it in the bitmaps.
                        if (pListOfBitmaps != NULL)
                        {
                            while (ListSize > 0)
                            {
                                KernelBitmap* pKernelBitmap = pListOfBitmaps[--ListSize] ;  

                                if (pKernelBitmap != NULL)
                                {
                                    OILBitmap* pOILBitmap = pKernelBitmap->GetActualBitmap();

                                    if (pOILBitmap != NULL)
                                    {
                                        pOILBitmap->SetAnimationRestoreType(pBmpDlgParam->GetRestoreType());
    
                                    }
                                }
                            }
                        }
                    }
                }
                // Get the Animation Loop details.
                BOOL Value = GetBoolGadgetSelected(_R(IDC_ANIMOPTS_LOOP));
                INT32 Loop = GetLongGadgetValue(_R(IDC_ANIMOPTS_ITERATIONS), 0, 65535, _R(IDS_BMPPREFS_INVALIDLOOP) ,&Valid);
                if (Valid)
                {
                    pGIFOptions->SetAnimationLoopCount(Loop, Value);
                }
                else
                    return FALSE;   

            }
            break;
        }

        case BMP_UNCOMPRESSED:
        {
            BMPExportOptions* pBMPOptions = (BMPExportOptions*)pOptions;
            ERROR3IF(!pBMPOptions->IS_KIND_OF(BMPExportOptions), "pBMPOptions isn't");

            // WEBSTER - markn 23/1/97
            // Can't do RLE without Accusoft
            #ifndef WEBSTER
            // Get the state of the compression buttons but only allowed in 4 and 8 bpp modes
            BMP_COMPRESSION Compression;
            State = GetLongGadgetValue(_R(IDC_BMPOPTS_RLE), 0, 1, 0, &Valid);
            if (State && (Depth == 4 || Depth == 8))
                Compression = BMP_RLE;      // button on
            else
                Compression = BMP_RGB;  // button off

            if (Valid)
            {
                pBMPOptions->SetCompression(Compression);
            }
            #endif // WEBSTER

            pBMPOptions->SetCompression(BMP_RGB);

            pBMPOptions->SetDither(DitherType);
            pBMPOptions->SetPalette(Palette);
            break;
        }

        // The remaining AccusoftOnes:
        case WPG:
        case PHOTOCD:
        case IFF_ILBM:
        case XWD:
        case DCX:
        case PCX:
        case PICT:
        case RAST:
        case PHOTOSHOP:
        case TARGA:
        case MACPAINT:
        case MSP:
        {
            //WEBSTER-Martin-03/01/97
#ifndef WEBSTER
            AccusoftExportOptions* pAccyOptions = (AccusoftExportOptions*)pOptions;
            ERROR3IF(!pAccyOptions->IS_KIND_OF(AccusoftExportOptions), "pAccyOptions isn't");
        
            pAccyOptions->SetDither(DitherType);
            pAccyOptions->SetPalette(Palette);
#endif //WEBSTER
            break;
        }
            
        default:
            // At present, only BMP and TIFFs can change the compression type.
            // Just us mice here
            break;
    }

    // Get the state of the selection, drawing or spread buttons
    SelectionType FoundSelection = GetSelection();
    pOptions->SetSelectionType(FoundSelection);

    return TRUE;
}


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

>   MsgResult BmpPrefsDlg::Message(CDlgMessage DlgMsg, CGadgetID Gadget) 


    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/08/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Handles all the bitmap preferences dialog's messages
    Errors:     -
    SeeAlso:    -

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

MsgResult BmpPrefsDlg::Message(Msg* Message)
{
    if (IS_OUR_DIALOG_MSG(Message))
    {
        DialogMsg* Msg = (DialogMsg*) Message;
        MsgResult Result;
        BOOL EndDialog = FALSE;     // TRUE if we should quit the dialog

        BitmapExportOptions* pOptions = GetOptions();
        ERROR3IF(pOptions == NULL, "BmpPrefsDlg::Message - Parameters not been set up");

        // Should now handle the required messages that we respond to
        switch (Msg->DlgMsg)
        {
            case DIM_CREATE:
                {
                    // Make sure the updating variable is set to something sensible
                    RecalculatingPixels = FALSE;
                    RecalculatingXDpi = FALSE;
                    RecalculatingYDpi = FALSE;

                    // As it is a modal dialog box we are sent a message to say the dialog box
                    // is being created, so we have a chance to set the initial control values
                    // JPEG export has a special dialog box, all others use the same one 
                    InitDialog();
                    HasDelayChanged = FALSE;
                    HasRestoreChanged = FALSE;
                }
            break;

            case DIM_COMMIT:
                {
                    // (ok) accept all changes that the user has made to the settings
                    // brackets make the ok local to this case 
                    // JPEG export has a special dialog box, all others use the same one 
                    BOOL ok;
                    ok = CommitDialogValues();
                    if (ok)
                    {
                        // Values found ok so quit dialogue then go ahead and export
                        GetOptions()->MarkValid();          // Flag ok used
                        EndDialog = TRUE;               // Flag to close and end
                    }
                }
            break;

            case DIM_CANCEL:
                // Cancel all changes that the user has made to the settings
                GetOptions()->MarkInvalid();            // Flag cancel used
                EndDialog = TRUE;                       // Flag to close and end
            break;

            case DIM_LISTDROPPED:
                {
                    
                    HasRestoreChanged = TRUE;

                    if(IsManyDisplayed)
                    {
                        DeleteAllValues(_R(IDC_ANIMOPTS_REMOVAL));  
                        SetStringGadgetValue(_R(IDC_ANIMOPTS_REMOVAL), _R(IDS_RESTORE_NOTHING));
                        SetStringGadgetValue(_R(IDC_ANIMOPTS_REMOVAL), _R(IDS_RESTORE_LEAVEASIS));
                        SetStringGadgetValue(_R(IDC_ANIMOPTS_REMOVAL), _R(IDS_RESTORE_BACKGROUND));
                        SetStringGadgetValue(_R(IDC_ANIMOPTS_REMOVAL), _R(IDS_RESTORE_PREVIOUS));
                        SetStringGadgetValue(_R(IDC_ANIMOPTS_REMOVAL), _R(IDS_MANY));
                        SetSelectedValueIndex(_R(IDC_ANIMOPTS_REMOVAL), OPTION_FOUR);
                        SetComboListLength(_R(IDC_ANIMOPTS_REMOVAL));
                        IsManyDisplayed = FALSE;
                    }
                }
            break;

            case DIM_LFT_BN_CLICKED:

                // If they clicked on a "help" button then invoke the help system for this dialog.
                if (Msg->GadgetID == _R(ID_CC_HELP_BUTTON))
                {
                    UINT32 HelpID = GetFilterHelpID(GetOptions()->GetFilterType());

                    if (HelpID > 0)
                    {
                        // Invoke the help system and mark this message as completely processed.
                        HelpUserTopic(HelpID);
                        return DLG_EAT_IF_HUNGRY(Msg);
                    }
                }
                // A control on the dialog box has been clicked...
                switch (Msg->GadgetID)
                {
                    if (pOptions->GetFilterType() != JPEG)
                    {
                        // Uses a generic routine which checks to see if the chosen option means
                        // that other options become greyed or ungreyed
                        // case _R(IDC_BMPOPTS_32BPP): // 32 bpp case no longer exists. Why? Some spappy reason or other.
                        case _R(IDC_BMPOPTS_CMYK):
                        case _R(IDC_BMPOPTS_24BPP):
                        case _R(IDC_BMPOPTS_8BPP):
                        case _R(IDC_BMPOPTS_4BPP):
                        case _R(IDC_BMPOPTS_1BPP):
                            SetBPPButtons(Msg->GadgetID,TRUE);
                        break;

                        case _R(IDC_BMPOPTS_PAL_STD):
                        case _R(IDC_BMPOPTS_PAL_OPT):
                            SetPaletteButtons(Msg->GadgetID);
                        break;

                        case _R(IDC_BMPOPTS_NODITHER):
                        case _R(IDC_BMPOPTS_ORDDITHER):
                        case _R(IDC_BMPOPTS_DIFFUSION):
                            SetDitherButtons(Msg->GadgetID);
                        break;
                        case _R(IDC_ANIMOPTS_LOOP):
                        {
                            BOOL Value = GetBoolGadgetSelected(_R(IDC_ANIMOPTS_LOOP));
                            if (Value)
                            {
                                SetLoopCheckBox(TRUE);
                                SetBmpPrefsDlgState();
                            }
                            else
                            {
                                SetLoopCheckBox(FALSE);
                                SetBmpPrefsDlgState();
                            }
                        }
                        break;
                    }
                    // All other buttons should take care of themselves
                    // Apart from if the user changes the selection/spread/drawing buttons
                    // we must go and recalculate the sizes and resolution on display.  
                    case _R(IDC_BMPOPTS_DRAWING):
                    case _R(IDC_BMPOPTS_SELECT):
                        RecalculateSize();
                    break;
                }
            break; // DIM_LFT_BN_CLICKED        

            case DIM_SELECTION_CHANGED:
                // A control on the dialog box has been typed in...
                switch (Msg->GadgetID)
                {
                    case _R(IDC_BMPOPTS_RES):
                        RecalculatePixels();
                    break;
                }
            break; // DIM_SELECTION_CHANGED     

            case DIM_TEXT_CHANGED:
                // A control on the dialog box has been typed in...
                switch (Msg->GadgetID)
                {
                    case _R(IDC_BMPOPTS_RES):
                        RecalculatePixels();
                    break;
                    case _R(IDC_BMPOPTS_XPIXELS):
                        RecalculateDpiFromX();
                    break;
                    case _R(IDC_BMPOPTS_YPIXELS):
                        RecalculateDpiFromY();
                    break;
                    case _R(IDC_ANIMOPTS_DELAY):
                        HasDelayChanged = TRUE;
                    break;
                }
            break; // DIM_TEXT_CHANGED      

        }

        // Allow the base class access to the message, it will do the
        // DLG_EAT_IF_HUNGRY(Msg) for us
        // Must do this before the Close and End
        Result = DialogOp::Message(Message);

        // End dialog here
        if (EndDialog) 
        {
            Close();                // Hide the dialog box
            End();                  // Finish the operation
        }

        // The message was for our dialog box so return that we have handled it, if necessary
        //return (DLG_EAT_IF_HUNGRY(Msg)); 
        return Result;
    }

    return DialogOp::Message(Message); 
}

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

>   UINT32 BmpPrefsDlg::GetFilterHelpID(UINT32 FilterType)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/7/96
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Gets the Help Topic associated with the specified bitmap filter.
    Errors:     -
    SeeAlso:    -

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

UINT32 BmpPrefsDlg::GetFilterHelpID(UINT32 FilterType)
{
    UINT32 HelpID = 0;

    switch (FilterType)
    {
        case MAKE_BITMAP_FILTER:
            HelpID = _R(IDH_Command_Create_Bitmap_Copy);
            break;

        case JPEG:
            HelpID = _R(IDH_Dialog_Bitmap_Export_JPEG);
            break;

        case GIF:
        case TI_GIF:
            HelpID = _R(IDH_Dialog_Bitmap_Export_GIF);
            break;

        case TI_GIF_ANIM:
            HelpID = _R(IDH_Dialog_Bitmap_Export_Animated_GIF);
            break;

        case BMP_COMPRESSED:
        case BMP_UNCOMPRESSED:
            HelpID = _R(IDH_Dialog_Bitmap_Export_BMP);
            break;
    }

    return HelpID;
}

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

>   OpState BmpPrefsDlg::GetState(String_256*, OpDescriptor*)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/08/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    BmpPrefsDlg GetState method
    Errors:     -
    SeeAlso:    -

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

OpState BmpPrefsDlg::GetState(String_256*, OpDescriptor*)
{    
    OpState OpSt;
    return(OpSt);
}


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

>   BOOL BmpPrefsDlg::Init()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/08/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    BmpPrefsDlg Init method
    Errors:     -
    SeeAlso:    -

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

BOOL BmpPrefsDlg::Init()
{
    BOOL InitOK;

    InitOK = RegisterOpDescriptor(
                                0,                  /* Tool ID */
                                _R(IDS_BMPPREFSDLG),
                                CC_RUNTIME_CLASS(BmpPrefsDlg),
                                OPTOKEN_BMPPREFSDLG,
                                GetState,
                                0,                  /* help ID */
                                0,                  /* bubble help */
                                0,                  /* resource ID */
                                0                   /* control ID */
                                );

    if (InitOK)
    {
        InitOK = RegisterOpDescriptor(
                                0,                  /* Tool ID */
                                _R(IDS_BMPPREFSDLG),
                                CC_RUNTIME_CLASS(JPEGExportPrefsDialog),
                                OPTOKEN_JPGPREFSDLG,
                                GetState,
                                0,                  /* help ID */
                                0,                  /* bubble help */
                                0,                  /* resource ID */
                                0                   /* control ID */
                                );
    }
    return (InitOK);
}



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

>   static BOOL BmpPrefsDlg::InvokeDialog(BitmapExportOptions* pExportOptions)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    07/11/96
    Inputs:     pointer to some export options
    Returns:    True if Ok used or False if Cancel used.
    Purpose:    How to invoke or start a BmpPrefsDlg box.

******************************************************************************************/
BOOL BmpPrefsDlg::InvokeDialog(BitmapExportOptions* pExportOptions)
{
    ERROR2IF(pExportOptions == NULL, FALSE, "pExportOptions NULL");
    ERROR3IF(!pExportOptions->IS_KIND_OF(BitmapExportOptions), "pExportOptions isn't");

    IDD = pExportOptions->GetDialogType();

    OpDescriptor *OpDesc;
    if (IDD == _R(IDD_EXPORTJPEGOPTS))
        OpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_JPGPREFSDLG);
    else
        OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(BmpPrefsDlg));


    if (OpDesc == NULL)
    {
        ERROR3("BmpPrefsDlg::InvokeDialog is unable to find the BmpPrefsDlg OpDescriptor");
        pExportOptions->MarkInvalid();
    }
    else
    {
        OpDesc->Invoke((OpParam *)pExportOptions);
    }

    return pExportOptions->IsValid();
}



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

>   BOOL BmpPrefsDlg::Create()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/08/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if successful, else FALSE
    Purpose:    BmpPrefsDlg create method 
    Errors:     -
    SeeAlso:    -

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

       
BOOL BmpPrefsDlg::Create()
{                            
    if (DialogOp::Create())
    { 
        // Set the initial control values 
        // Dialog now Modal so set up happens in the message handler
        //InitDialog(this);

        return TRUE; 
    }
    else
    {
        return FALSE; 
    }
}




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

>   void BmpPrefsDlg::Do(OpDescriptor*)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/08/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Creates then opens the dialog in response to a request from the user.
    Errors:     -
    SeeAlso:    -

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

void BmpPrefsDlg::Do(OpDescriptor*)
{
    BOOL ok;
    
    // Force the dialog box to be created, as it is modal it will be opened via a message
    ok = Create();

    if ( !ok )
    {
        // Could not create the dialog box so call inform error 
        InformError();
        End();         // End the operation 
    }
}

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

>   void BmpPrefsDlg::DoWithParam(OpDescriptor*)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/08/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Creates then opens the dialog in response to a request from the user and
                allows values to be passed in and returned to the caller via the
                BmpPrefsDlgParam class.
    Errors:     -
    SeeAlso:    -

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

void BmpPrefsDlg::DoWithParam(OpDescriptor*, OpParam* pParam)
{
    if (pParam == NULL)
    {
        ERROR3("BmpPrefsDlg::DoWithParam - NULL Args");
        return;
    }

    // Use the OpParam that has been passed in to us
    ERROR3IF(!pParam->IS_KIND_OF(BitmapExportOptions), "pParam isn't");
    m_pOptions = (BitmapExportOptions*) pParam;

    BOOL ok;
    
    // Force the dialog box to be created, as it is modal it will be opened via a message
    ok = Create();

    if ( !ok )
    {
        // Could not create the dialog box so call inform error 
        InformError();
        End();         // End the operation 
    }
}


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

>   BOOL BmpPrefsDlg::SetUpResolutionList()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/03/95
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if successful, else FALSE
    Purpose:    Sets up the initial values in the resolution/dpi combo box. 
    Errors:     -
    SeeAlso:    -

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

BOOL BmpPrefsDlg::SetUpResolutionList()
{
    if (!m_bDpiSupported)
    {
        SetStringGadgetValue(_R(IDC_BMPOPTS_RES), &String_8(" -"), FALSE, -1);
        return TRUE;
    }

    // First, set up the resolution combo box
    // Set up the default value in the editable field
    SetLongGadgetValue(_R(IDC_BMPOPTS_RES), (INT32)GetOptions()->GetDPI(), FALSE, -1);
    // Set up the list
    SetLongGadgetValue(_R(IDC_BMPOPTS_RES), 50);
    SetLongGadgetValue(_R(IDC_BMPOPTS_RES), 75);
    SetLongGadgetValue(_R(IDC_BMPOPTS_RES), 96);
    SetLongGadgetValue(_R(IDC_BMPOPTS_RES), 100);
    SetLongGadgetValue(_R(IDC_BMPOPTS_RES), 150);
    SetLongGadgetValue(_R(IDC_BMPOPTS_RES), 200);
    SetLongGadgetValue(_R(IDC_BMPOPTS_RES), 250);
    SetLongGadgetValue(_R(IDC_BMPOPTS_RES), 300);
    SetComboListLength(_R(IDC_BMPOPTS_RES));
    
    return TRUE;
}   

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

>   BOOL BmpPrefsDlg::SetBmpPrefsDlgState()

    Author:     Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> 
    Created:    21/01/97
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if successful, else FALSE.
    Purpose:    This will be called When the "loop continuously" switch is turned off.
                It will grey/ungrey the "Loop" ed field. 
    Errors:     
    SeeAlso:    -

******************************************************************************************/
BOOL BmpPrefsDlg::SetBmpPrefsDlgState()
{
    BitmapExportOptions* pOptions = GetOptions();
    ERROR2IF(pOptions == NULL, FALSE, "pOptions is NULL");
    
    // The "loop continuously" switch is on.
    if (GetLoopCheckBox())
    {
        // Grey the Loop ed field.
        EnableGadget(_R(IDC_ANIMOPTS_ITERATIONS), FALSE);
    }

    // The "loop continuously" switch is off. 
    if (!GetLoopCheckBox())
    {
        GIFExportOptions* pGIFOptions = (GIFExportOptions*)pOptions;
        ERROR3IF(!pGIFOptions->IS_KIND_OF(GIFExportOptions), "pGIFOptions isn't");

        // Ungrey the Loop ed field.    
        EnableGadget(_R(IDC_ANIMOPTS_ITERATIONS), TRUE);
        SetLongGadgetValue(_R(IDC_ANIMOPTS_ITERATIONS), pGIFOptions->GetAnimationLoopCount());
    }
    return TRUE;
}

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

>   BOOL BmpPrefsDlg::InitDialog()

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> (from Neville)
    Created:    23/08/94
    Inputs:     pointer to the dialog box
    Returns:    TRUE if successful, else FALSE
    Purpose:    Sets initial dialog values 

******************************************************************************************/
BOOL BmpPrefsDlg::InitDialog()
{
    BitmapExportOptions* pOptions = GetOptions();
    ERROR2IF(pOptions == NULL, FALSE, "pOptions NULL");

    if (pOptions->GetFilterType() != MAKE_BITMAP_FILTER)
    {
        // Set up the title of the dialog box according to the passed in string which
        // is the name of the filter plus export bitmap options.
        String_256 Temp = *(pOptions->GetFilterName());
        Temp += String_256(_R(IDN_EXPORTBMPOPTS));

        SetTitlebarName(&Temp); 
    }

    // Default to a locked aspect ratio
    m_bLockAspect = TRUE;

    // Now set up the bits per pixel radio buttons
    // The various filters require different controls, most just require bits disabling
    // such as the bpp switches available
    UINT32 Depth = pOptions->GetDepth();
    BOOL bYoDither  = FALSE;
    PALETTE Palette;    // maybe want this pileo'sh'
    DITHER Dither;  // maybe want this pileo'sh'

    // WEBSTER - markn 23/1/97
    // Hide these in Webster
#ifdef WEBSTER
    HideGadget(_R(IDC_BMPOPTS_TIFF), TRUE);     // Hide the TIFF compression selection 
    HideGadget(_R(IDC_BMPOPTS_RLE), TRUE);      // Hide the BMP rgb compression
    HideGadget(_R(IDC_BMPOPTS_RGB), TRUE);      // Hide the BMP rle compression
    HideGadget(_R(IDC_BMPOPTS_COMPRESS), TRUE); // Hide the compression group
#endif // WEBSTER

    // WEBSTER - markn 17/1/97
    // Display the 'number of colours in palette' group and extend the dlg if necessary
    // but only for export options of the correct type
    InitNumColoursGroup(pOptions);

    // oh ye virtuals
    switch ( pOptions->GetFilterType() ) 
    {
        case TIFF_UNCOMPRESSED:
        {
            //WEBSTER-Martin-03/01/97
#ifndef WEBSTER
            BOOL ok;
            TIFFExportOptions* pTIFFOptions = (TIFFExportOptions*)pOptions;
            ERROR3IF(!pTIFFOptions->IS_KIND_OF(TIFFExportOptions), "pTIFFOptions isn't");

            // Make sure we show the correct compression selection field
            HideGadget(_R(IDC_BMPOPTS_TIFF), FALSE);    // Show the TIFF compression selection 
            HideGadget(_R(IDC_BMPOPTS_RLE), TRUE);      // Hide the BMP rgb compression
            HideGadget(_R(IDC_BMPOPTS_RGB), TRUE);      // Hide the BMP rle compression
            HideGadget(_R(IDC_BMPOPTS_COMPRESS), FALSE);// Show the compression group

            // Check for illegal case of the the depth for this filter type
//          if (Depth == 32)
//              Depth = 24;

            HideGadget(_R(IDC_BMPOPTS_32BPP), TRUE);

            // Convert the Accusoft ID's into their equivalent list item numbers
            // If 1bpp then omit the 1bpp compression types to 1bpp images only.
            INT32 TiffCompression = pTIFFOptions->GetCompression();

            // Set up the TIFF compression types list
            // Now the resolution combo box and hence the default value in the editable field
            ok = SetLongGadgetValue(_R(IDC_BMPOPTS_TIFF), pTIFFOptions->GetCompression(), FALSE, -1);
            // Set up the list of available TIFF compressions. Must be the same as the list
            // in TiffTypes.
            // Assusoft seem to imply they support lots of save options but in fact they do not!
            SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_NONE)));
            
            if( Depth==8 || Depth==24 || Depth==32 )
            {
                SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_LZW)));
            }

            // Only allow the next options if 1bpp is selected as otherwise not appropriate
            if (Depth == 1)
            {
                // 1bpp export so enable these 1bpp compression types
                SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_HUFFMAN)));
                SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_G3FAX)));
                SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_G4FAX)));
                SetStringGadgetValue(_R(IDC_BMPOPTS_TIFF), &String_32(_R(IDN_TIFF_PACKBITS)));
            }
            else
            {
                // Anything but 1bpp export.
                // Must ensure that only a valid compression type is allowed
                //if (TiffCompression != UNCOMPRESSED_TIFF && TiffCompression != LZW_TIFF)
                //  TiffCompression = LZW_TIFF;
            }
            SetComboListLength(_R(IDC_BMPOPTS_TIFF));

            ok = SetTIFFCompressionSelection( TiffCompression, Depth );

            // if the previously selected compression is now disabled, select NONE
            if( ! ok )
            {
                ok = SetTIFFCompressionSelection( TIFF_UNCOMPRESSED, Depth );
                
                // We should ALWAYS be able to select UNCOMPRESSED
                ERROR3IF( (!ok), "BmpPrefsDlg::InitDialog - could not select uncompressed" );
            }

            Palette = pTIFFOptions->GetPalette();
            Dither = pTIFFOptions->GetDither();
            bYoDither = TRUE;

            m_bDpiSupported = TRUE;
#endif //WEBSTER
            break;
        }
        case PNG:
        {
            PNGExportOptions* pPNGOptions = (PNGExportOptions*)pOptions;
            ERROR3IF(!pPNGOptions->IS_KIND_OF(PNGExportOptions), "pPNGOptions isn't");
            // 1, 4, 8, 24 and 32 bpp

            // WEBSTER - markn 23/1/97
            // Compression group always hidden in Webster
            #ifndef WEBSTER
            HideGadget(_R(IDC_BMPOPTS_TIFF), TRUE);     // Hide the TIFF compression selection 
            HideGadget(_R(IDC_BMPOPTS_RLE), TRUE);      // Hide the BMP rgb compression
            HideGadget(_R(IDC_BMPOPTS_RGB), TRUE);      // Hide the BMP rle compression
            HideGadget(_R(IDC_BMPOPTS_COMPRESS), TRUE); // Hide the compression group
            #endif // WEBSTER

            HideGadget(_R(IDC_BMPOPTS_CMYK), TRUE);
            EnableGadget(_R(IDC_BMPOPTS_32BPP), FALSE);

            // We will use the special PNG radio buttons for interlaced and transparent.
            // These are hidden by default.
            // Now set up the list
            // Must correspond to the order PNG .. PNG_TRANSINTER defined in accuflts.h
            // Translate the compression type into the transparency and interlace states.
            BOOL Transparent = pPNGOptions->WantTransparent();
            BOOL Interlace   = pPNGOptions->WantInterlaced();
            // If we are at the deeper colour depths then transparency is not allowed
            if (Depth == 24 || Depth == 32)
                Transparent = FALSE;
            HideGadget(_R(IDC_BMPOPTS_GIFTYPE), FALSE);
            HideGadget(_R(IDC_BMPOPTS_TRANSPARENT), FALSE);
            HideGadget(_R(IDC_BMPOPTS_INTERLACED), FALSE);
            EnableGadget(_R(IDC_BMPOPTS_GIFTYPE), TRUE);
            EnableGadget(_R(IDC_BMPOPTS_INTERLACED), TRUE);
            SetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), Transparent);
            SetLongGadgetValue(_R(IDC_BMPOPTS_INTERLACED), Interlace);

//          Palette = pPNGOptions->GetPalette();
            Dither = pPNGOptions->GetDither();
            bYoDither = TRUE;

            m_bDpiSupported = TRUE;
            break;
        }
        case GIF:
        case TI_GIF:
        case TI_GIF_ANIM:
        {
            GIFExportOptions* pGIFOptions = (GIFExportOptions*)pOptions;
            ERROR3IF(!pGIFOptions->IS_KIND_OF(GIFExportOptions), "pGIFOptions isn't");

            // 4 8 bpp only
            // WEBSTER - markn 23/1/97
            // Compression group always hidden in Webster
            #ifndef WEBSTER
            HideGadget(_R(IDC_BMPOPTS_TIFF), TRUE);     // Hide the TIFF compression selection 
            HideGadget(_R(IDC_BMPOPTS_RLE), TRUE);      // Hide the BMP rle compression
            HideGadget(_R(IDC_BMPOPTS_RGB), TRUE);      // Hide the BMP rgb compression
            HideGadget(_R(IDC_BMPOPTS_COMPRESS), TRUE); // Hide the compression group
            #endif // WEBSTER

            m_bDpiSupported = FALSE;

            // Check for illegal case of the the depth for this filter type
            if (Depth == 32 || Depth == 24)
                Depth = 8;
            // Disable all illegal bpp buttons
            HideGadget(_R(IDC_BMPOPTS_CMYK), TRUE);
            EnableGadget(_R(IDC_BMPOPTS_32BPP), FALSE);
            EnableGadget(_R(IDC_BMPOPTS_24BPP), FALSE);

            // We will use the special GIF radio buttons for interlaced and transparent.
            // These are hidden by default.
            // But only if our special GIF filter.
            if (pOptions->GetFilterType() == TI_GIF ||
                pOptions->GetFilterType() == TI_GIF_ANIM)
            {
                // Now set up the list
                // Must correspond to the order TI_GIF .. TI_GIF_TRANSINTER defined in accuflts.h
                // Translate the compression type into the transparency and interlace states.

                BOOL Transparent = pGIFOptions->WantTransparent();
                BOOL Interlace   = pGIFOptions->WantInterlaced();
                HideGadget(_R(IDC_BMPOPTS_GIFTYPE), FALSE);
                HideGadget(_R(IDC_BMPOPTS_TRANSPARENT), FALSE);
                HideGadget(_R(IDC_BMPOPTS_INTERLACED), FALSE);
                EnableGadget(_R(IDC_BMPOPTS_GIFTYPE), TRUE);
                EnableGadget(_R(IDC_BMPOPTS_INTERLACED), TRUE);
                EnableGadget(_R(IDC_BMPOPTS_TRANSPARENT), TRUE);

                SetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), Transparent);
                SetLongGadgetValue(_R(IDC_BMPOPTS_INTERLACED), Interlace);
            }
            if (pOptions->GetFilterType() == TI_GIF_ANIM)
            {
                HideGadget(_R(IDC_ANIMOPTS_ANIMGROUP) , FALSE);     // Un-hide the Animation Group
                HideGadget(_R(IDC_ANIMOPTS_REMOVAL)   , FALSE);
                HideGadget(_R(IDC_ANIMOPTS_DELAYFOR)  , FALSE);
                HideGadget(_R(IDC_ANIMOPTS_CS)        , FALSE);
                HideGadget(_R(IDC_ANIMOPTS_LOOPTEXT)  , FALSE);
                HideGadget(_R(IDC_ANIMOPTS_DELAY)     , FALSE);
                HideGadget(_R(IDC_ANIMOPTS_ITERATIONS), FALSE);
                HideGadget(_R(IDC_ANIMOPTS_TIMES)     , FALSE);
                HideGadget(_R(IDC_ANIMOPTS_LOOP)      , FALSE);
                HideGadget(_R(IDC_ANIMOPTS_RESTORE)   , FALSE);

                // Unlock the aspect ratio
                m_bLockAspect = FALSE;

                // ************************************************
                // This is Oily code.  Should be replaced with Dialogue Manager function call
                // Extend the dialogue height, so we can see the animation options

                WINDOWPLACEMENT Place;
                Place.length = sizeof(WINDOWPLACEMENT);
                if (GetWindowPlacement((HWND)WindowID, &Place))
                {
                    Place.rcNormalPosition.bottom = Place.rcNormalPosition.bottom + (ANIMATION_EXTRABIT);
                    SetWindowPlacement((HWND)WindowID, &Place);
                }

                // Added for Webster RanbirR 11\02\97
                BmpDlgParam* pBmpDlgParam = pOptions->GetBmpDlgParam();
                if (pBmpDlgParam == NULL)
                    return FALSE;

                // Go through our list of bitmaps, to find if any are Transparent.

                // Get a list of our selected bitmaps.
                UINT32 ListSize =  pBmpDlgParam->GetListSize();
                KernelBitmap** pList = pBmpDlgParam->GetBitmapList();
                BOOL Transparent = FALSE;
                INT32 Index=0;

                // Added for Webster - RanbirR 11\02\97
                // Are any of our bitmaps Transparent ?
                while (ListSize > 0)
                {
                    KernelBitmap* pKernelBitmap = pList[--ListSize];

                    if (pKernelBitmap != NULL)
                    {
                        // Is this bitmap Transparent.
                        if(pKernelBitmap->GetTransparencyIndex(&Index))
                            Transparent = TRUE;
                    }
                }

                HideGadget(_R(IDC_BMPOPTS_TRANSPARENT), FALSE);
                EnableGadget(_R(IDC_BMPOPTS_TRANSPARENT), TRUE);
                SetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), Transparent);

                if (pBmpDlgParam->GetAreDelayValuesSame())
                {
                    SetLongGadgetValue(_R(IDC_ANIMOPTS_DELAY), pBmpDlgParam->GetAnimDelay());   
                    IsDelayMany=FALSE;
                }
                else
                {
                    SetStringGadgetValue(_R(IDC_ANIMOPTS_DELAY), _R(IDS_MANY)); 
                    IsDelayMany=TRUE;
                }
                
                if (pBmpDlgParam->GetSameRestoreType())
                {
                    SetStringGadgetValue(_R(IDC_ANIMOPTS_REMOVAL), &String_32(_R(IDS_RESTORE_NOTHING)));
                    SetStringGadgetValue(_R(IDC_ANIMOPTS_REMOVAL), &String_32(_R(IDS_RESTORE_LEAVEASIS)));
                    SetStringGadgetValue(_R(IDC_ANIMOPTS_REMOVAL), &String_32(_R(IDS_RESTORE_BACKGROUND)));
                    SetStringGadgetValue(_R(IDC_ANIMOPTS_REMOVAL), &String_32(_R(IDS_RESTORE_PREVIOUS)));
                    SetComboListLength(_R(IDC_ANIMOPTS_REMOVAL));
                    SetSelectedValueIndex(_R(IDC_ANIMOPTS_REMOVAL), pBmpDlgParam->GetRestoreType());
                }
                else
                {
                    SetStringGadgetValue (_R(IDC_ANIMOPTS_REMOVAL), _R(IDS_MANY));
                    SetSelectedValueIndex(_R(IDC_ANIMOPTS_REMOVAL), OPTION_ONE);
                    IsManyDisplayed = TRUE;
                }
        
                SetLongGadgetValue(_R(IDC_ANIMOPTS_ITERATIONS), pGIFOptions->GetAnimationLoopCount());
                EnableGadget(_R(IDC_ANIMOPTS_ITERATIONS), FALSE);
                SetBoolGadgetSelected(_R(IDC_ANIMOPTS_LOOP), TRUE);

            }

//          Palette = pGIFOptions->GetPalette();
            Dither = pGIFOptions->GetDither();
            bYoDither = TRUE;

            break;
        }
        case MAKE_BITMAP_FILTER:
        {
            MakeBitmapExportOptions* pMkBOptions = (MakeBitmapExportOptions*)pOptions;
            ERROR3IF(!pMkBOptions->IS_KIND_OF(MakeBitmapExportOptions), "pMkBOptions isn't");
            // 1 4 8 24 bpp
            HideGadget(_R(IDC_BMPOPTS_CMYK), TRUE);
            EnableGadget(_R(IDC_BMPOPTS_32BPP), FALSE);
            HideGadget(_R(IDC_BMPOPTS_CREATEOPTS), FALSE);
            HideGadget(_R(IDC_BMPOPTS_GIFTYPE), TRUE);
            // WEBSTER - markn 23/1/97
            // Compression group always hidden in Webster
            #ifndef WEBSTER
            HideGadget(_R(IDC_BMPOPTS_TIFF), TRUE);     // Hide the TIFF compression selection 
            HideGadget(_R(IDC_BMPOPTS_RLE), TRUE);      // Hide the BMP rle compression
            HideGadget(_R(IDC_BMPOPTS_RGB), TRUE);      // Hide the BMP rgb compression
            HideGadget(_R(IDC_BMPOPTS_COMPRESS), TRUE); // Hide the compression group
            #endif // WEBSTER
            
            HideGadget(_R(IDC_ANIMOPTS_LOOP), TRUE);    
            HideGadget(_R(IDC_ANIMOPTS_DELAY), TRUE);   
            HideGadget(_R(IDC_ANIMOPTS_ITERATIONS), TRUE);
            HideGadget(_R(IDC_ANIMOPTS_REMOVAL), TRUE); 

            HideGadget(_R(IDC_TIMES_STATIC),TRUE);  
            HideGadget(_R(IDC_RESTORE_STATIC),TRUE);

            m_bDpiSupported = TRUE;

            // We will use the special GIF radio buttons for interlaced and transparent.
            // These are hidden by default.

            String_256 Temp(_R(IDS_MAKEBMPOPTS));
            SetTitlebarName(&Temp); 

            SetStringGadgetValue(IDOK, &String_32(_R(IDS_CREATEBMP)));
            SetStringGadgetValue(_R(IDC_BMPOPTS_SAVEAREA), &String_32(_R(IDS_CREATEFROM)));

            // Now set up the list
            // Must correspond to the order TI_GIF .. TI_GIF_TRANSINTER defined in outptgif.h
            // Translate the compression type into the transparency and interlace states.
            BOOL Transparent = pMkBOptions->WantTransparent();
            BOOL Interlace   = FALSE;
            HideGadget(_R(IDC_BMPOPTS_TRANSPARENT), FALSE);
            HideGadget(_R(IDC_BMPOPTS_INTERLACED), TRUE);
            EnableGadget(_R(IDC_BMPOPTS_INTERLACED), FALSE);
            EnableGadget(_R(IDC_BMPOPTS_TRANSPARENT), TRUE);

            SetLongGadgetValue(_R(IDC_BMPOPTS_TRANSPARENT), Transparent);

//          Palette = pMkBOptions->GetPalette();
            Dither = pMkBOptions->GetDither();
            bYoDither = TRUE;
            break;
        }
        case WPG:
            // 1 4 8 bpp only
            // WEBSTER - markn 23/1/97
            // Compression group always hidden in Webster
            #ifndef WEBSTER
            HideGadget(_R(IDC_BMPOPTS_TIFF), TRUE);     // Hide the TIFF compression selection 
            HideGadget(_R(IDC_BMPOPTS_RLE), TRUE);      // Hide the BMP rgb compression
            HideGadget(_R(IDC_BMPOPTS_RGB), TRUE);      // Hide the BMP rle compression
            HideGadget(_R(IDC_BMPOPTS_COMPRESS), TRUE); // Hide the compression group
            #endif // WEBSTER

            // Check for illegal case of the the depth for this filter type
            if (Depth == 32 || Depth == 24)
                Depth = 8;
            m_bDpiSupported = FALSE;
            // Disable all illegal bpp buttons
            HideGadget(_R(IDC_BMPOPTS_CMYK), TRUE);
            EnableGadget(_R(IDC_BMPOPTS_32BPP), FALSE);
            EnableGadget(_R(IDC_BMPOPTS_24BPP), FALSE);

            //WEBSTER-Martin-06/01/97
            #ifndef WEBSTER
            Palette = ((AccusoftExportOptions*)pOptions)->GetPalette();
            Dither = ((AccusoftExportOptions*)pOptions)->GetDither();
            #endif //WEBSTER
            bYoDither = TRUE;

            break;
        case PHOTOCD:
            // 24 bpp only
            // WEBSTER - markn 23/1/97
            // Compression group always hidden in Webster
            #ifndef WEBSTER
            HideGadget(_R(IDC_BMPOPTS_TIFF), TRUE);     // Hide the TIFF compression selection 
            HideGadget(_R(IDC_BMPOPTS_RLE), TRUE);      // Hide BMP rgb compression
            HideGadget(_R(IDC_BMPOPTS_RGB), TRUE);      // Hide BMP rle compression
            HideGadget(_R(IDC_BMPOPTS_COMPRESS), TRUE); // Hide compression group
            #endif // WEBSTER

            // Check for illegal case of the the depth for this filter type
            if (Depth != 24)
                Depth = 24;
            // Disable all illegal bpp buttons
            HideGadget(_R(IDC_BMPOPTS_CMYK), TRUE);
            EnableGadget(_R(IDC_BMPOPTS_8BPP), FALSE);
            EnableGadget(_R(IDC_BMPOPTS_4BPP), FALSE);
            EnableGadget(_R(IDC_BMPOPTS_1BPP), FALSE);
            m_bDpiSupported = TRUE;
            break;
        case IFF_ILBM:
        case XWD:
        case DCX:
        case PCX:
        case PICT:
            // 1 4 8 24 bpp
            // WEBSTER - markn 23/1/97
            // Compression group always hidden in Webster
            #ifndef WEBSTER
            HideGadget(_R(IDC_BMPOPTS_TIFF), TRUE);     // Hide the TIFF compression selection 
            HideGadget(_R(IDC_BMPOPTS_RLE), TRUE);      // Hide BMP rgb compression
            HideGadget(_R(IDC_BMPOPTS_RGB), TRUE);      // Hide BMP rle compression
            HideGadget(_R(IDC_BMPOPTS_COMPRESS), TRUE); // Hide compression group
            #endif // WEBSTER

            // Check for illegal case of the the depth for this filter type
            if (Depth == 32)
                Depth = 24;
            // Disable all illegal bpp buttons
            HideGadget(_R(IDC_BMPOPTS_CMYK), TRUE);
            EnableGadget(_R(IDC_BMPOPTS_32BPP), FALSE);
            m_bDpiSupported = FALSE;

            //WEBSTER-Martin-06/01/97
            #ifndef WEBSTER
            Palette = ((AccusoftExportOptions*)pOptions)->GetPalette();
            Dither = ((AccusoftExportOptions*)pOptions)->GetDither();
            #endif // WEBSTER
            bYoDither = TRUE;
            break;

        case RAST:
        case PHOTOSHOP:
            // 1 8 24 bpp
            // WEBSTER - markn 23/1/97
            // Compression group always hidden in Webster
            #ifndef WEBSTER
            HideGadget(_R(IDC_BMPOPTS_TIFF), TRUE);     // Hide the TIFF compression selection 
            HideGadget(_R(IDC_BMPOPTS_RLE), TRUE);      // Hide BMP rgb compression
            HideGadget(_R(IDC_BMPOPTS_RGB), TRUE);      // Hide BMP rle compression
            HideGadget(_R(IDC_BMPOPTS_COMPRESS), TRUE); // Hide compression group
            #endif // WEBSTER

            // Check for illegal case of the the depth for this filter type
            if (Depth == 32 || Depth == 4)
                Depth = 24;
            // Disable all illegal bpp buttons
            HideGadget(_R(IDC_BMPOPTS_CMYK), TRUE);
            EnableGadget(_R(IDC_BMPOPTS_32BPP), FALSE);
            EnableGadget(_R(IDC_BMPOPTS_4BPP), FALSE);
            m_bDpiSupported = FALSE;

            //WEBSTER-Martin-06/01/97
            #ifndef WEBSTER
            Palette = ((AccusoftExportOptions*)pOptions)->GetPalette();
            Dither = ((AccusoftExportOptions*)pOptions)->GetDither();
            #endif // WEBSTER
            bYoDither = TRUE;

            break;
        case TARGA:
            // 8 24 bpp
            // WEBSTER - markn 23/1/97
            // Compression group always hidden in Webster
            #ifndef WEBSTER
            HideGadget(_R(IDC_BMPOPTS_TIFF), TRUE);     // Hide the TIFF compression selection 
            HideGadget(_R(IDC_BMPOPTS_RLE), TRUE);      // Hide BMP rgb compression
            HideGadget(_R(IDC_BMPOPTS_RGB), TRUE);      // Hide BMP rle compression
            HideGadget(_R(IDC_BMPOPTS_COMPRESS), TRUE); // Hide compression group
            #endif // WEBSTER

            // Check for illegal case of the the depth for this filter type
            if (Depth == 32  || Depth == 4 || Depth == 1)
                Depth = 24;
            // Disable all illegal bpp buttons
            HideGadget(_R(IDC_BMPOPTS_CMYK), TRUE);
            EnableGadget(_R(IDC_BMPOPTS_32BPP), FALSE);
            EnableGadget(_R(IDC_BMPOPTS_4BPP), FALSE);
            EnableGadget(_R(IDC_BMPOPTS_1BPP), FALSE);
            m_bDpiSupported = FALSE;

            //WEBSTER-Martin-06/01/97
            #ifndef WEBSTER
            Palette = ((AccusoftExportOptions*)pOptions)->GetPalette();
            Dither = ((AccusoftExportOptions*)pOptions)->GetDither();
            #endif // WEBSTER
            bYoDither = TRUE;
            break;

        case MACPAINT:
        case MSP:
            // 1bpp only
            return FALSE;
            break;
        case BMP_UNCOMPRESSED:
        {
            BMPExportOptions* pBMPOptions = (BMPExportOptions*)pOptions;
            ERROR3IF(!pBMPOptions->IS_KIND_OF(BMPExportOptions), "pBMPOptions isn't");

            // WEBSTER - markn 23/1/97
            // Compression group always hidden in Webster
            #ifndef WEBSTER
            HideGadget(_R(IDC_BMPOPTS_TIFF), TRUE);     // Hide the TIFF compression selection 
            HideGadget(_R(IDC_BMPOPTS_RLE), FALSE);     // Show the BMP rgb compression
            HideGadget(_R(IDC_BMPOPTS_RGB), FALSE);     // Show the BMP rle compression
            HideGadget(_R(IDC_BMPOPTS_COMPRESS), FALSE);// Show the compression group

            // Now set up the other buttons according to the values set in the variables
            if (pBMPOptions->GetCompression())
                SetLongGadgetValue(_R(IDC_BMPOPTS_RLE), TRUE);
            else
                SetLongGadgetValue(_R(IDC_BMPOPTS_RGB), TRUE);
            #endif // WEBSTER

            // Check for illegal case of the the depth for this filter type
            if ( Depth == 16 )
                Depth = 24;
            EnableGadget(_R(IDC_BMPOPTS_32BPP), FALSE);
            HideGadget(_R(IDC_BMPOPTS_CMYK), FALSE);
            Palette = pBMPOptions->GetPalette();
            Dither = pBMPOptions->GetDither();
            bYoDither = TRUE;

            m_bDpiSupported = TRUE;
            break;
        }
        default:
            return FALSE;
    }

    // Override the Export button if being invoked from the Name gallery.
    if (NamedExportProp::m_fApplyNotExport)
        SetStringGadgetValue(IDOK, &String(_R(IDS_PREVIEW_APPLY)));

    // If the default depth's not supported give a sensible one
    if (Depth != pOptions->GetDepth())
    {
        pOptions->SetDepth(Depth);
    }

    if (!m_bDpiSupported)                           // Doesn't support dpi...
    {
        // and ensure that its always the number of dpi as defined by a pixel unit
        DocUnitList* pDocUnitList = DocUnitList::GetCurrentDocUnitList();
        ERROR3IF(pDocUnitList == NULL, "BmpPrefsDlg::InitDialog() - no pDocUnitList!")
        Unit* pPixelUnit = pDocUnitList->FindUnit(PIXELS);
        ERROR3IF(pPixelUnit == NULL, "BmpPrefsDlg::InitDialog() - no pixel units!")
        Unit* pInchUnit = pDocUnitList->FindUnit(INCHES);
        ERROR3IF(pInchUnit == NULL, "BmpPrefsDlg::InitDialog() - no inch units!")
        double newDpi = (pPixelUnit->GetMillipoints()>0) ? pInchUnit->GetMillipoints() / pPixelUnit->GetMillipoints() : 96.0;
        Dpi = (INT32)newDpi;
        pOptions->SetDPI(newDpi);

        // Now, set up the resolution combo box
        SetUpResolutionList();

        // so disallow changes to dpi field
        EnableGadget(_R(IDC_BMPOPTS_RES), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_DPI), FALSE);
    }
    else
    {
        // Now, set up the resolution combo box
        SetUpResolutionList();
    }

    // blooooody classes!!!! foookin virtuals!!!
    InitDepthRadioGroup();
    InitSelectionRadioGroup();
    if (bYoDither)
    {
        InitPaletteRadioGroup(Palette);
        InitDitherRadioGroup(Dither);       // GetDitherGadget()->Init()???
    }

    // Make sure that size fields are displaying the values correctly
    RecalculateSize();

    if (m_bDpiSupported)
    {
        // Start off with input focus in the dpi field
        SetKeyboardFocus(_R(IDC_BMPOPTS_RES));
    }
    else
    {
        // Start off with input focus in the x pixel size
        SetKeyboardFocus(_R(IDC_BMPOPTS_XPIXELS));
    }

    return TRUE;
}

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

>   void BmpPrefsDlg::InitNumColoursGroup(BitmapExportOptions* pOptions)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/1/97
    Inputs:     pOptions = The options for this bitmap export
    Returns:    -
    Purpose:    Inits the "number of colour in palette" group in the bitmap export dlg

                NOTE: If the options don't allow a specific number of colours to be show,
                then this function will hide them instead

                Introduced in WEBSTER

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

void BmpPrefsDlg::InitNumColoursGroup(BitmapExportOptions* pOptions)
{
    if (pOptions == NULL)
        return;

    // Don't show these options if we can't support a specific number of colours
    if (!pOptions->UseSpecificNumColsInPalette())
    {
        HideNumColoursGroup();
        return;
    }

    INT32 Gadgets[] = { _R(IDC_BMPOPTS_NUMCOLS_GROUP),
                        _R(IDC_BMPOPTS_NUMCOLS_EDIT),
                        _R(IDC_BMPOPTS_NUMCOLS_SYSCOLS),
                        _R(IDC_BMPOPTS_NUMCOLS_EDITTEXT),
                        0};

    // ************************************************
    // This is Oily code.  Should be replaced with Dialogue Manager function call
    // It moves the numcols gadgets into the correct place on the dialog and
    // extends the dialog so you can see them.  Lovely!

    {
        INT32 Index = 0;
        for (Index = 0;Gadgets[Index] != 0;Index++)
        {
            HWND hGadget = GetDlgItem((HWND)WindowID, (INT32)Gadgets[Index]);
            RECT MoveRect;
            POINT TopLeft;

            if (GetWindowRect(hGadget, &MoveRect))
            {
                TopLeft.x = MoveRect.left;      // Convert TopLeft coord into client coords
                TopLeft.y = MoveRect.top;
                ScreenToClient((HWND)WindowID, &TopLeft);
                TopLeft.y -= NUMCOLS_GROUP_SHIFT;

                SetWindowPos(hGadget, NULL,
                                TopLeft.x, TopLeft.y, 0, 0,
                                SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
            }
        }

        for (Index = 0;Gadgets[Index] != 0;Index++)
            HideGadget(Gadgets[Index],FALSE);

        WINDOWPLACEMENT Place;
        Place.length = sizeof(WINDOWPLACEMENT);
        if (GetWindowPlacement((HWND)WindowID, &Place))
        {
            Place.rcNormalPosition.bottom = Place.rcNormalPosition.bottom + (NUMCOLS_EXTRABIT);
            SetWindowPlacement((HWND)WindowID, &Place);
        }
    }

    // Init the gadgets
    INT32 NumCols = 0;
    BOOL UseSysCols = TRUE;
    NumCols     = pOptions->GetNumColsInPalette();
    UseSysCols  = pOptions->GetUseSystemColours();

    // Adjust in case we added the system colours
    if (UseSysCols)
        NumCols -= NUM_SYS_COLS;
  
    SetLongGadgetValue(_R(IDC_BMPOPTS_NUMCOLS_EDIT),NumCols);
    SetBoolGadgetSelected(_R(IDC_BMPOPTS_NUMCOLS_SYSCOLS),UseSysCols);
}

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

>   void BmpPrefsDlg::HideNumColoursGroup()

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/1/97
    Inputs:     -
    Returns:    -
    Purpose:    Hides the "number of colour in palette" group in the bitmap export dlg

                Introduced in WEBSTER

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

void BmpPrefsDlg::HideNumColoursGroup()
{
    HideGadget(_R(IDC_BMPOPTS_NUMCOLS_EDIT)    ,TRUE);
    HideGadget(_R(IDC_BMPOPTS_NUMCOLS_SYSCOLS) ,TRUE);
    HideGadget(_R(IDC_BMPOPTS_NUMCOLS_GROUP)   ,TRUE);
    HideGadget(_R(IDC_BMPOPTS_NUMCOLS_EDITTEXT),TRUE);
}

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

>   void BmpPrefsDlg::UpdateNumColoursGroup(BOOL CheckValueRange)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/1/97
    Inputs:     CheckNumColValueRange = TRUE if the value in the num col ed field should be range checked.
    Returns:    -
    Purpose:    Enables/disables the "number of colour in palette" group in the bitmap export dlg

                It also makes sure that the number in the ed field is in range

                Introduced in WEBSTER

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

void BmpPrefsDlg::UpdateNumColoursGroup(BOOL CheckValueRange)
{
    BOOL OptPal = GetBoolGadgetSelected(_R(IDC_BMPOPTS_PAL_OPT));
    BOOL Bpp8   = GetBoolGadgetSelected(_R(IDC_BMPOPTS_8BPP));
    BOOL Bpp4   = GetBoolGadgetSelected(_R(IDC_BMPOPTS_4BPP));

    EnableGadget(_R(IDC_BMPOPTS_NUMCOLS_EDIT)    ,OptPal && (Bpp8 || Bpp4));
    EnableGadget(_R(IDC_BMPOPTS_NUMCOLS_EDITTEXT),OptPal && (Bpp8 || Bpp4));
    EnableGadget(_R(IDC_BMPOPTS_NUMCOLS_SYSCOLS) ,OptPal && Bpp8);          // 8 bpp only
    EnableGadget(_R(IDC_BMPOPTS_NUMCOLS_GROUP)   ,TRUE);                    // Always show group

    // Check that the value in the ed string is not out of range
    if ((Bpp8 || Bpp4))
    {
        BOOL SystemColours = (Bpp8 && GetBoolGadgetSelected(_R(IDC_BMPOPTS_NUMCOLS_SYSCOLS)));
        UINT32 Max = 256;
        UINT32 Min = 2;
        if (Bpp4)
            Max = 16;

        // If we are adding system colours, then the smallest number the user can enter is 0
        if (SystemColours)
            Min = 0;

        // Slight bodge fix here - changed so that every time the user changes the bpp, it resets
        // the number of colours to the max colours available
        // Comment this line out if you don't want this functionality
        if (CheckValueRange)
            Min = Max;

        UINT32 NumCols = GetLongGadgetValue(_R(IDC_BMPOPTS_NUMCOLS_EDIT), Min, Max);
        if (NumCols > Max)  NumCols = Max;
        if (NumCols < Min)  NumCols = Min;
        SetLongGadgetValue(_R(IDC_BMPOPTS_NUMCOLS_EDIT),NumCols);
    }
}

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

>   BOOL BmpPrefsDlg::SetNumColoursInPalette(BitmapExportOptions* pOptions)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/1/97
    Inputs:     pOptions = ptr to the export options to use
    Returns:    -
    Purpose:    Extracts the number of colours in palette & the system colours switch data
                from the relevant gadgets, and stuffs the data in pOptions.

                Introduced in WEBSTER

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

BOOL BmpPrefsDlg::SetNumColoursInPalette(BitmapExportOptions* pOptions)
{
    // Don't bother unless the user wants an optimised palette
    if (!GetBoolGadgetSelected(_R(IDC_BMPOPTS_PAL_OPT)))
        return TRUE;

    // Only do this for filters that support this feature
    if (pOptions != NULL && pOptions->UseSpecificNumColsInPalette())
    {
        // Set the default values for an 8bpp bitmap
        UINT32 MaxNumCols = 256;
        UINT32 MinNumCols = 2;
        BOOL SystemColours = GetBoolGadgetSelected(_R(IDC_BMPOPTS_NUMCOLS_SYSCOLS));
        UINT32 Depth = pOptions->GetDepth();
        BOOL Valid;

        // 4bpp has a max num colours of 16, and can't include the system colours
        if (Depth == 4)
        {
            MaxNumCols = 16;
            SystemColours = FALSE;
        }

        // If we are adding system colours, then the smallest number the user can enter is 0
        if (SystemColours)
            MinNumCols = 0;

        UINT32 NumCols = GetLongGadgetValue(_R(IDC_BMPOPTS_NUMCOLS_EDIT), MinNumCols, MaxNumCols, 0, &Valid);

        if (!Valid)
        {
            // Only report an err message in 8bpp & 4bpp modes
            if ((Depth == 8) || (Depth == 4))
            {
                String_256 ErrMsg;
                ErrMsg.MakeMsg(_R(IDS_BMPPREFS_NUMCOLSWRONG),MinNumCols,MaxNumCols);
                Error::SetError(0,ErrMsg,0);
                InformError();
                return FALSE;
            }
            NumCols = MaxNumCols;
        }

        // If the user wants to add the system colours, then we need to increase the number of 
        // total colours to create

        // The number of sys colours is either NUM_SYS_COLS, or 0 if the switch is off
        UINT32 NumSysCols = NUM_SYS_COLS;
        if (!SystemColours)
            NumSysCols = 0;

        NumCols += NumSysCols;
        if (NumCols > MaxNumCols)
            NumCols = MaxNumCols;

        // Are we to include a transparent colour?
        UINT32 NumTransparentCols = 0;
        if (GetBoolGadgetSelected(_R(IDC_BMPOPTS_TRANSPARENT)))
            NumTransparentCols = 1;

        // Can we reduce the number of bpp automatically?
        // Do it only for optimised palettes
        if (Depth == 8)
        {
            // If the total number of colours is 16 or less, choose 4bpp
            if (NumCols <= (16-NumTransparentCols))
                GetOptions()->SetDepth(4);

            // If the total number of colours is 2 or less, choose 1bpp
            if (NumCols <= (2-NumTransparentCols))
                GetOptions()->SetDepth(1);
        }

        pOptions->SetNumColsInPalette(NumCols);
        pOptions->SetUseSystemColours(SystemColours);
    }

    return TRUE;
}

void BmpPrefsDlg::InitDepthRadioGroup()
{
    // Set up the Bits per pixel buttons
    // Filtered above for illegal cases
    switch ( GetOptions()->GetDepth() ) 
    {
        case 1:
            SetBPPButtons(_R(IDC_BMPOPTS_1BPP),FALSE);
            SetLongGadgetValue(_R(IDC_BMPOPTS_1BPP), TRUE);
            LastBppSelected = _R(IDC_BMPOPTS_1BPP);
            break;
        case 4:
            SetBPPButtons(_R(IDC_BMPOPTS_4BPP),FALSE);
            SetLongGadgetValue(_R(IDC_BMPOPTS_4BPP), TRUE);
            LastBppSelected = _R(IDC_BMPOPTS_4BPP);
            break;
        case 8:
            SetBPPButtons(_R(IDC_BMPOPTS_8BPP),FALSE);
            SetLongGadgetValue(_R(IDC_BMPOPTS_8BPP), TRUE);
            LastBppSelected = _R(IDC_BMPOPTS_8BPP);
            break;
        case 24:
            SetBPPButtons(_R(IDC_BMPOPTS_24BPP),FALSE);
            SetLongGadgetValue(_R(IDC_BMPOPTS_24BPP), TRUE);
            LastBppSelected = _R(IDC_BMPOPTS_24BPP);
            break;
        default:
            SetBPPButtons(_R(IDC_BMPOPTS_CMYK),FALSE);
            SetLongGadgetValue(_R(IDC_BMPOPTS_CMYK), TRUE);
            LastBppSelected = _R(IDC_BMPOPTS_CMYK);
            break;
    }
}


void BmpPrefsDlg::InitPaletteRadioGroup(const PALETTE& Palette)
{
// WEBSTER - markn 17/1/97
// Calls SetPaletteButtons() to do the hard work now.

    switch (Palette)
    {
        case PAL_OPTIMISED:
            SetPaletteButtons(_R(IDC_BMPOPTS_PAL_OPT));
            break;

        case PAL_STANDARD:
            SetPaletteButtons(_R(IDC_BMPOPTS_PAL_STD));
            break;

        default:
            TRACE( _T("Non-standard palette set"));
            break;
    }
}


void BmpPrefsDlg::InitDitherRadioGroup(const DITHER& DitherType)
{
    // Set up the dithering selection radio buttons
    switch (DitherType)
    {
        case XARADITHER_NONE:
            SetLongGadgetValue(_R(IDC_BMPOPTS_NODITHER), TRUE);
            break;

        case XARADITHER_ORDERED_GREY:
            SetLongGadgetValue(_R(IDC_BMPOPTS_ORDDITHER), TRUE);
            break;

        case XARADITHER_ERROR_DIFFUSION:
            SetLongGadgetValue(_R(IDC_BMPOPTS_DIFFUSION), TRUE);
            break;

        default:
            SetLongGadgetValue(_R(IDC_BMPOPTS_DIFFUSION), TRUE);
            break;
    }

    if (GetOptions()->GetSelectionType() == ABITMAP)
    {
        // If we are outputing a bitmap directly, then we
        // don't need the palette and dithering options
        EnableGadget(_R(IDC_BMPOPTS_NODITHER), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_ORDDITHER), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_DIFFUSION), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_PAL_STD), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_PAL_OPT), FALSE);
    }
}


    // Set up the save spread/selection radio buttons
    // If selection is True then enable the spread/selection/drawing buttons otherwise
    // disable the selection button and allow choice between spread or drawing, drawing
    // being the default.
void BmpPrefsDlg::InitSelectionRadioGroup()
{
    //  Always disable this button.
    EnableGadget(_R(IDC_BMPOPTS_SPREAD), FALSE);

    // Set up the save spread/selection radio buttons
    if (GetOptions()->GetFilterType() == MAKE_BITMAP_FILTER ||
        GetOptions()->GetFilterType() == TI_GIF_ANIM)
    {
        SetLongGadgetValue(_R(IDC_BMPOPTS_SELECT), TRUE);
        // Disable all buttons
        EnableGadget(_R(IDC_BMPOPTS_SELECT), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_DRAWING), FALSE);
    }
    else
    {
        // The drawing option is always available.
        EnableGadget(_R(IDC_BMPOPTS_DRAWING), TRUE);

        // If selection is True then enable the spread/selection/drawing buttons otherwise
        // disable the selection button and allow choice between spread or drawing, drawing
        // being the default.
        switch (GetOptions()->GetSelectionType())
        {
            case SELECTION:
                // If selection present then choose export selection by default
                SetLongGadgetValue(_R(IDC_BMPOPTS_SELECT), TRUE);

                // Selection present, so enable that button.
                EnableGadget(_R(IDC_BMPOPTS_SELECT), TRUE);
                break;

            default:
                // If no selection present then choose export drawing by default        
                SetLongGadgetValue(_R(IDC_BMPOPTS_DRAWING), TRUE);

                // No selection present, so let all options be used
                EnableGadget(_R(IDC_BMPOPTS_SELECT), FALSE);
                break;
        }
    }

    // Finally, smash it over the head with a bodge to disable the whole
    // group of gadgets when being invoked from the Name gallery.
    if (NamedExportProp::m_fApplyNotExport)
    {
        EnableGadget(_R(IDC_BMPOPTS_SAVEAREA), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_SELECT), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_DRAWING), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_SPREAD), FALSE);
    }
}


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

>   BitmapExportOptions* BmpPrefsDlg::GetOptions() const

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/11/96
    Returns:    A pointer to the BitmapExportOptions to be filled in by this dialog
    Purpose:    Helper function

******************************************************************************************/
BitmapExportOptions* BmpPrefsDlg::GetOptions() const
{
    return m_pOptions;
}

/******************************************************************************************
*** Photo CD import options dialog box
******************************************************************************************/



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

>   BOOL PhotoCDDlg::InvokeDialog(UINT32 * Page) 
    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/11/94
    Inputs:     Number of image pages available in the file
    Outputs:    Chosen page from the selection of pages
    Returns:    True if Ok used or False if Cancel used.
    Purpose:    How to invoke or start a PhotoCDDlg box.
    Errors:     -
    SeeAlso:    -

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

BOOL PhotoCDDlg::InvokeDialog(UINT32 * Page)
{
    // Params is defined to be the PhotoCDDlgParams class to nicely encapsulate
    // all the parameters that we need to pass back and forth.
    PhotoCDDlgParam Params(*Page);
    pParams = &Params;          // Save a reference to the params for use in the dialog code

    Params.ImageNumber = 0;     // Set default page to be zero
    Params.PhotoCDOk = FALSE;   // Ensure ok is False by default

    OpDescriptor *OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(PhotoCDDlg));

    ERROR3IF(OpDesc == NULL,"PhotoCDDlg::InvokeDialog is unable to find the PhotoCDDlg OpDescriptor");

    if (OpDesc != NULL)
        OpDesc->Invoke((OpParam *)&Params);

    // If ok used then alter the page to the one that the user has chosen
    if (Params.PhotoCDOk)
        *Page = Params.ImageNumber;

    return Params.PhotoCDOk;
}

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

>   PhotoCDDlg::PhotoCDDlg(): DialogOp(PhotoCDDlg::IDD, PhotoCDDlg::Mode) 

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/11/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    PhotoCDDlg constructor. Creates a non-undoable operation
    Errors:     -
    SeeAlso:    -

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

PhotoCDDlg::PhotoCDDlg(): DialogOp(PhotoCDDlg::IDD, PhotoCDDlg::Mode) 
{
    // At present, do nothing.
}

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

>   BOOL PhotoCDDlg::CommitDialogValues(BmpPrefsDlg* pBmpPrefs)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/11/94
    Inputs:     pointer to the dialogue box
    Outputs:    -
    Returns:    True if values in dialog box ok, False otherwise.     
    Purpose:    Takes the values in the dialog box and sets the return values accordingly
                Called when ok is pressed on the dialog box.
    Errors:     -
    SeeAlso:    -

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

BOOL PhotoCDDlg::CommitDialogValues(PhotoCDDlg* pPhotoCDPrefs)
{
    ERROR3IF(pParams == NULL, "PhotoCDDlg::CommitDialogValues called after duff initialisation?!");

    // Ok has been pressed so take the values and set up the static values so that the
    // caller can access them

    // Get the image that the user has chosen from the radio buttons
    BOOL Valid = 0;     // Flag for validity of value
    BOOL State = 0;
    UINT32 Page = 0;
    State = GetLongGadgetValue(_R(IDC_PHOTOCD_BASE), 0, 1, 0, &Valid);
    if (State)
        Page = 0;
    State = GetLongGadgetValue(_R(IDC_PHOTOCD_BASEDIV4), 0, 1, 0, &Valid);
    if (State)
        Page = 1;
    State = GetLongGadgetValue(_R(IDC_PHOTOCD_BASEDIV16), 0, 1, 0, &Valid);
    if (State)
        Page = 2;
    State = GetLongGadgetValue(_R(IDC_PHOTOCD_BASE4), 0, 1, 0, &Valid);
    if (State)
        Page = 3;
    State = GetLongGadgetValue(_R(IDC_PHOTOCD_BASE16), 0, 1, 0, &Valid);
    if (State)
        Page = 4;
    pParams->ImageNumber = Page;

    return TRUE;
}


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

>   MsgResult PhotoCDDlg::Message(CDlgMessage DlgMsg, CGadgetID Gadget) 


    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/08/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Handles all the photocd import options dialog's messages
    Errors:     -
    SeeAlso:    -

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

MsgResult PhotoCDDlg::Message(Msg* Message)
{
    ERROR3IF(pParams == NULL, "PhotoCDDlg::Message - Parameters not been set up");

    if (IS_OUR_DIALOG_MSG(Message))
    {
        DialogMsg* Msg = (DialogMsg*)Message;

        MsgResult Result;

        // Main handler for dialog type messages
        BOOL EndDialog = FALSE;                     // TRUE if we should quit the dialog

        // Should now handle the required messages that we respond to
        switch (Msg->DlgMsg)
        {
            case DIM_CREATE:
                // As it is a modal dialog box we are sent a message to say the dialog box
                // is being created, so we have a chance to set the initial control values.
                InitDialog(this);
            break;

            case DIM_COMMIT:
                // (ok) accept all changes that the user has made to the settings
                // brackets make the ok local to this case 
                {
                    BOOL ok;
                    ok = CommitDialogValues(this);
                    if (ok)
                    {
                        // Values found ok so quit dialogue then go ahead and export
                        pParams->PhotoCDOk = TRUE;          // Flag ok used
                        EndDialog = TRUE;
                    }
                }
            break;

            case DIM_CANCEL:
                // Cancel all changes that the user has made to the settings
                pParams->PhotoCDOk = FALSE;             // Flag cancel used
                EndDialog = TRUE;
            break;
        }

        // Allow the base class access to the message, it will do the
        // DLG_EAT_IF_HUNGRY(Msg) for us
        // Must do this before the Close and End
        Result = DialogOp::Message(Message);

        // End dialog here
        if (EndDialog) 
        {
            Close();                // Hide the dialog box
            End();                  // Finish the operation
        }

        // The message was for our dialog box so return that we have handled it, if necessary
        return Result;
    }
    return DialogOp::Message(Message); 
}

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

>   OpState PhotoCDDlg::GetState(String_256*, OpDescriptor*)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/11/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    PhotoCDDlg GetState method
    Errors:     -
    SeeAlso:    -

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

OpState PhotoCDDlg::GetState(String_256*, OpDescriptor*)
{    
    OpState OpSt;
    return(OpSt);
}


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

>   BOOL PhotoCDDlg::Init()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/11/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    PhotoCDDlg Init method
    Errors:     -
    SeeAlso:    -

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

BOOL PhotoCDDlg::Init()
{
    BOOL InitOK;

    InitOK = RegisterOpDescriptor(
                                0,                  /* Tool ID */
                                _R(IDS_PHOTOCDDLG),
                                CC_RUNTIME_CLASS(PhotoCDDlg),
                                OPTOKEN_PHOTOCDDLG,
                                GetState,
                                0,                  /* help ID */
                                0,                  /* bubble help */
                                0,                  /* resource ID */
                                0                   /* control ID */
                                );

    return (InitOK);
}


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

>   BOOL PhotoCDDlg::Create()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/11/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if successful, else FALSE
    Purpose:    PhotoCDDlg create method 
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
       
BOOL PhotoCDDlg::Create()
{                            
    if (DialogOp::Create())
    { 
        // Set the initial control values 
        // Dialog now Modal so set up happens in the message handler
        //InitDialog(this);

        return TRUE; 
    }
    else
    {
        return FALSE; 
    }
}

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

>   void PhotoCDDlg::Do(OpDescriptor*)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/11/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Creates then opens the dialog in response to a request from the user.
    Errors:     -
    SeeAlso:    -

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

void PhotoCDDlg::Do(OpDescriptor*)
{
    ERROR3("PhotoCDDlg::Do called when should be using DoWithParam!");
    End();         // End the operation 
}

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

>   void PhotoCDDlg::DoWithParam(OpDescriptor*)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/11/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Creates then opens the dialog in response to a request from the user and
                allows values to be passed in and returned to the caller via the
                PhotoCDDlgParam class.
    Errors:     -
    SeeAlso:    -

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

void PhotoCDDlg::DoWithParam(OpDescriptor*, OpParam* Param)
{
    ERROR3IF(Param == NULL, "PhotoCDDlg::DoWithParam - NULL Param passed in");

    // Use the OpParam that has been passed in to us
    PhotoCDDlgParam * BmpDlgParam = (PhotoCDDlgParam *) Param;

    BOOL ok;
    
    // Force the dialog box to be created, as it is modal it will be opened via a message
    ok = Create();

    if ( !ok )
    {
        // Could not create the dialog box so call inform error 
        InformError();
        End();         // End the operation 
    }
}


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

>   BOOL PhotoCDDlg::InitDialog(PhotoCDDlg* pBmpPrefs)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/11/94
    Inputs:     pointer to the dialog box
    Outputs:    -
    Returns:    TRUE if successful, else FALSE
    Purpose:    Sets initial dialog values 
    Errors:     -
    SeeAlso:    -

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

BOOL PhotoCDDlg::InitDialog(PhotoCDDlg* pBmpPrefs)
{
    ERROR3IF(pParams == NULL, "PhotoCDDlg::InitDialog called after duff initialisation?!");

    // Check how many pages were found and if necessary whether to grey some of the
    // buttons
    // Bodge the Base16 so that ungreys using same condition as the Base4 as once again
    // Accusoft are lying and tell us 4 images instead of 5.
    EnableGadget(_R(IDC_PHOTOCD_BASE16),    (pParams->NumberOfPages > 3)); //4));
    EnableGadget(_R(IDC_PHOTOCD_BASE4),     (pParams->NumberOfPages > 3));
    EnableGadget(_R(IDC_PHOTOCD_BASEDIV16), (pParams->NumberOfPages > 2));
    EnableGadget(_R(IDC_PHOTOCD_BASEDIV4),  (pParams->NumberOfPages > 1));
    EnableGadget(_R(IDC_PHOTOCD_BASE),      (pParams->NumberOfPages > 0));

    switch (pParams->ImageNumber)
    {
        case 4:
            SetLongGadgetValue(_R(IDC_PHOTOCD_BASE16), TRUE);    
            break;
        case 3:
            SetLongGadgetValue(_R(IDC_PHOTOCD_BASE4), TRUE);    
            break;
        case 2:
            SetLongGadgetValue(_R(IDC_PHOTOCD_BASEDIV16), TRUE);
            break;
        case 1:
            SetLongGadgetValue(_R(IDC_PHOTOCD_BASEDIV4), TRUE); 
            break;
        case 0:
        default:
            SetLongGadgetValue(_R(IDC_PHOTOCD_BASE), TRUE);     
            break;
    }

    return TRUE;
}


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

>   JPEGExportPrefsDialog::JPEGExportPrefsDialog()

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/11/96
    Purpose:    JPEGExportPrefsDialog constructor.

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

JPEGExportPrefsDialog::JPEGExportPrefsDialog(): BmpPrefsDlg() 
{
    m_OriginalSourcePresent = FALSE;
}


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

>   virtual BOOL JPEGExportPrefsDialog::InitDialog()

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> (from Neville)
    Created:    23/08/94
    Inputs:     pointer to the BmpPrefs
    Outputs:    
    Returns:    TRUE if successful, else FALSE
    Purpose:    Sets initial dialog values 
    Errors:     -
    SeeAlso:    -

******************************************************************************************/
BOOL JPEGExportPrefsDialog::InitDialog()
{
    JPEGExportOptions* pOptions = (JPEGExportOptions*)GetOptions();
    ERROR2IF(pOptions == NULL,FALSE, "BmpPrefsDlg::InitJPEGDialog called after duff initialisation?!");

    // Set up the title of the dialog box according to the passed in string which
    // is the name of the filter plus export bitmap options.
    String_256 Temp = *(pOptions->GetFilterName());
    Temp += String_256(_R(IDN_EXPORTBMPOPTS));

    SetTitlebarName(&Temp); 

    // Is this already a compressed JPEG? 
    
    pOptions->SetJPEGPresentAndSelected(FALSE);

    KernelBitmap* pKernelBitmap = pOptions->GetKernelBitmap();

    if (pKernelBitmap != NULL)
    {
        BitmapSource* pSource = NULL;
        BaseBitmapFilter* pDummyFilter;

        pOptions->SetJPEGPresentAndSelected(pKernelBitmap->GetOriginalSource(&pSource, &pDummyFilter));
    }

    if (pOptions->GetJPEGPresentAndSelected())
    {
        SetBoolGadgetSelected(_R(IDC_JPEG_ORIGINAL), TRUE);

        // Disable the other gadgets/
//      EnableGadget(_R(IDC_BMPOPTS_SPREAD), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_DRAWING), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_SELECT), FALSE);
        EnableGadget(_R(IDC_JPGOPTS_PROGRESSIVE), FALSE);

        // Set the range of the slider control plus a step value of 1
        SetGadgetRange(_R(IDC_BMPOPTS_QUALITY), 0, 100, 1);
        SetGadgetBitmaps(_R(IDC_BMPOPTS_QUALITY), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER));
        SetLongGadgetValue(_R(IDC_BMPOPTS_QUALITY), 0);
        EnableGadget(_R(IDC_BMPOPTS_QUALITY), FALSE);

        EnableGadget(_R(IDC_BMPOPTS_RES), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_XPIXELS), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_YPIXELS), FALSE);
        // WEBSTER - markn 5/2/97
        // Taken out the X & Y size gadgets
#ifndef WEBSTER
        SetStringGadgetValue(_R(IDC_BMPOPTS_XSIZE), &String_8("-"));
        SetStringGadgetValue(_R(IDC_BMPOPTS_YSIZE), &String_8("-"));
        EnableGadget(_R(IDC_BMPOPTS_XSIZE), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_YSIZE), FALSE);
#endif // WEBSTER
        EnableGadget(_R(IDC_BMPOPTS_PERCENT), FALSE);
    }
    else
    {
        // Disable the "Use Original Source" control.
        EnableGadget(_R(IDC_JPEG_ORIGINAL), FALSE);

        // Flag that DPI is supported by JPEGs
        m_bDpiSupported = TRUE;

        // First, set up the resolution combo box
        SetUpResolutionList();
    
        // Set up the quality slider and percentage display
        INT32 Quality = pOptions->GetQuality(); // Default Quality
        // Check that value is not bigger than maximum allowed
        if (Quality > 100)
            Quality = 100;

        // Set the range of the slider control plus a step value of 1
        SetGadgetRange(_R(IDC_BMPOPTS_QUALITY), 0, 100, 1);
        SetGadgetBitmaps(_R(IDC_BMPOPTS_QUALITY), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER));
        SetLongGadgetValue(_R(IDC_BMPOPTS_QUALITY), 100 - Quality);
        SetBoolGadgetSelected(_R(IDC_JPGOPTS_PROGRESSIVE), pOptions->DoAsProgressive());
    
        // Set the percentage string
        TCHAR Str[32];
        String_32 jcf(_R(IDS_PERCENT_FORMAT));
        camSprintf(Str, jcf, Quality);
        String_32 PercentStr(Str);
        SetStringGadgetValue(_R(IDC_BMPOPTS_PERCENT), &PercentStr);

        InitSelectionRadioGroup();
    
        // Make sure that size fields are displaying the values correctly
        RecalculateSize();
    }

        return TRUE;
}


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

>   void JPEGExportPrefsDialog::SetJPEGDlgState()

    Author:     Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> (from Neville)
    Created:    21/01/97
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    This will be called to set JPEG dlg controls if the user decides 
                not to export using the the Origianl JPEG image.
    Errors:     -
    SeeAlso:    -

******************************************************************************************/
void JPEGExportPrefsDialog::SetJPEGDlgState()
{
    JPEGExportOptions* pOptions = (JPEGExportOptions*)GetOptions();
    ERROR3IF(pOptions == NULL, "pOptions is NULL");

    if (pOptions->GetJPEGPresentAndSelected())
    {
        SetBoolGadgetSelected(_R(IDC_JPEG_ORIGINAL), TRUE);

        // Disable the other gadgets.
//      EnableGadget(_R(IDC_BMPOPTS_SPREAD), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_DRAWING), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_SELECT), FALSE);
        EnableGadget(_R(IDC_JPGOPTS_PROGRESSIVE), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_QUALITY), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_RES), FALSE);

        EnableGadget(_R(IDC_BMPOPTS_XPIXELS), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_YPIXELS), FALSE);
        // WEBSTER - markn 5/2/97
        // Taken out the X & Y size gadgets
#ifndef WEBSTER
        SetStringGadgetValue(_R(IDC_BMPOPTS_XSIZE), &String_8("-"));
        SetStringGadgetValue(_R(IDC_BMPOPTS_YSIZE), &String_8("-"));
        EnableGadget(_R(IDC_BMPOPTS_XSIZE), FALSE);
        EnableGadget(_R(IDC_BMPOPTS_YSIZE), FALSE);
#endif // WEBSTER
        EnableGadget(_R(IDC_BMPOPTS_PERCENT), FALSE);
    }
    else
    {
        // Enbale the quality & progress controls.
        EnableGadget(_R(IDC_BMPOPTS_QUALITY), TRUE);
        EnableGadget(_R(IDC_JPGOPTS_PROGRESSIVE), TRUE);
        EnableGadget(_R(IDC_BMPOPTS_PERCENT), TRUE);

        // Flag that DPI is supported by JPEGs
        m_bDpiSupported = TRUE;

        // First, set up the resolution combo box
        SetUpResolutionList();
    
        // Set up the quality slider and percentage display
        INT32 Quality = pOptions->GetQuality(); // Default Quality
        // Check that value is not bigger than maximum allowed
        if (Quality > 100)
            Quality = 100;

        // Set the range of the slider control plus a step value of 1
        SetGadgetRange(_R(IDC_BMPOPTS_QUALITY), 0, 100, 1);
        SetGadgetBitmaps(_R(IDC_BMPOPTS_QUALITY), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER));
        SetLongGadgetValue(_R(IDC_BMPOPTS_QUALITY), 100 - Quality);
        SetBoolGadgetSelected(_R(IDC_JPGOPTS_PROGRESSIVE), pOptions->DoAsProgressive());
    
        // Set the percentage string
        TCHAR Str[32];
        String_32 jcf(_R(IDS_PERCENT_FORMAT));
        camSprintf(Str, jcf, Quality);
        String_32 PercentStr(Str);
        SetStringGadgetValue(_R(IDC_BMPOPTS_PERCENT), &PercentStr);

        InitSelectionRadioGroup();
    
        // Make sure that size fields are displaying the values correctly
        RecalculateSize();
    }
};

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

>   virtual MsgResult JPEGExportPrefsDialog::Message(Msg* Message)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/11/96
    Inputs:     See DialogOp for interface details
    Purpose:    Handles JPEG dialog specific messages

******************************************************************************************/
MsgResult JPEGExportPrefsDialog::Message(Msg* pMessage)
{
    ERROR3IF(GetOptions() == NULL, "BmpPrefsDlg::Message - GetOptions() NULL");

    if (IS_OUR_DIALOG_MSG(pMessage))
    {
        DialogMsg* pMsg = (DialogMsg*)pMessage;
        ERROR3IF(!pMsg->IS_KIND_OF(DialogMsg), "pMsg isn't");

        // Should now handle the required messages that we respond to
        switch (pMsg->DlgMsg)
        {
            case DIM_SLIDER_POS_CHANGING:
                // special message for the JPEG qualty control
                // Messages to all the controls, handled individually
                switch (pMsg->GadgetID)
                {
                    case _R(IDC_BMPOPTS_QUALITY):
                    {
                        // Find the current quality scroller's position
                        TCHAR Str[32];
                        BOOL Valid;
                        INT32 Result = GetLongGadgetValue(_R(IDC_BMPOPTS_QUALITY), 0, 100, 0, &Valid);
                        Result = 100 - Result;

                        // Build the Percentage string and set it
                        String_32 jcf(_R(IDS_PERCENT_FORMAT));
                        wsprintf(Str, jcf, (INT32) Result);
                        String_32 PercentStr(Str);
                        SetStringGadgetValue(_R(IDC_BMPOPTS_PERCENT), &PercentStr);
                    }
                    break;
                }
            break; // DIM_SLIDER_POS_CHANGING       
            
            case DIM_LFT_BN_CLICKED:
                {
                    switch (pMsg->GadgetID)
                    {
                        case _R(IDC_JPEG_ORIGINAL):
                        {
                            BOOL Value = GetBoolGadgetSelected(_R(IDC_JPEG_ORIGINAL));
                            if (Value)
                            {
                                JPEGExportOptions::SetJPEGPresentAndSelected(TRUE);
                                SetJPEGDlgState();
                            }
                            else
                            {
                                JPEGExportOptions::SetJPEGPresentAndSelected(FALSE);
                                SetJPEGDlgState();
                            }
                        }
                        break;
                    }
                    break;
                }
                break; //DIM_LFT_BN_CLICKED

                case DIM_CANCEL:
                {
                    // The Export has been cancelled, 
                    // set our KernelBitmap pointer to NULL.
                    JPEGExportOptions::SetKernelBitmap(NULL);
                }
                break;  // DIM_CANCEL
        }
    }
    return BmpPrefsDlg::Message(pMessage);
}


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

>   virtual BOOL JPEGExportPrefsDialog::CommitDialogValues()

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> (from Neville)
    Created:    03/10/94
    Inputs:     pointer to the options to commit
    Outputs:    -
    Returns:    True if values in dialog box ok, False otherwise.     
    Purpose:    Takes the values in the dialog box and sets the return values accordingly
                Called when ok is pressed on the dialog box.
    Errors:     -
    SeeAlso:    BmpPrefsDlg::CommitDialogValues;

********************************************************************************************/
BOOL JPEGExportPrefsDialog::CommitDialogValues()
{
    JPEGExportOptions* pOptions = (JPEGExportOptions*)GetOptions();
    ERROR3IF(pOptions == NULL, "JPEGExportPrefsDialog::CommitDialogValues called after duff initialisation?!");

    //Added by Graham 27/5/97
    //First, let's set the pixel width and height into our OutputSize option
    pOptions->SetPixelOutputSize(PixelWidth, PixelHeight);

    // We only want new values, if the "Use Origianl JPEG image" switvh is OFF.
    if (!pOptions->GetJPEGPresentAndSelected())
    {
        // Ok has been pressed so take the values and set up the static values so that the
        // caller can access them

        BOOL Valid = 0; // Flag for validity of value
        BOOL State = 0; // Flag for reading the state of gadgets

        // Get the dpi value from the resolution combo box 
        // Minimum of 5dpi as anything lower causes major problems.  
        INT32 Value = GetLongGadgetValue(_R(IDC_BMPOPTS_RES), 5, MAXDPI, _R(IDS_BMPPREFS_INVALIDDPI) ,&Valid);
        if ( Valid) 
        {
            // If returned value in range then set the new default
            pOptions->SetDPI(Value);
        }
        else
            return FALSE; 

        // Check that we have not gone over our GDraw limit for pixel width
        // Pixel height should not be so much of a problem as we will strip the export. 
        RecalculatePixels();
        if ((DWORD) PixelWidth > GRenderRegion::GetMaxBitmapWidth() ||
            (DWORD) PixelWidth < 1 || (DWORD) PixelHeight < 1 )
        {
            // There is a problem so warn the user that the value is incorrect
            String_256 WarnMsg;

            WarnMsg.MakeMsg(_R(IDE_BMP_BADPIXELWIDTH), GRenderRegion::GetMaxBitmapWidth());
            Error::SetError(0, WarnMsg, 0);
            InformWarning(0, _R(IDS_OK));
            return FALSE; 
        }

        // Get quality slider value
        State = GetLongGadgetValue(_R(IDC_BMPOPTS_QUALITY), 0, 100, 0, &Valid);
        if (Valid)
        {
            // Return compression to caller
            pOptions->SetQuality(100 - State);
        }
            
        // Work out what is currently selected
        SelectionType FoundSelection = GetSelection();
        pOptions->SetSelectionType(FoundSelection);

        // Get whether a progressive file is wanted or not
        State = GetBoolGadgetSelected(_R(IDC_JPGOPTS_PROGRESSIVE), 0, &Valid);
        if (Valid)
        {
            pOptions->SetMakeProgressive(State);
        }
    }
        return TRUE;
}


DocRect RandomSelection::GetSize()          { return DocRect(0,0,0,0); }
DocRect SingleBitmapSelection::GetSize()    { return DocRect(0,0,0,0); }
DocRect MultipleBitmapSelection::GetSize()  { return DocRect(0,0,0,0); }
DocRect SpreadSelection::GetSize()          { return BaseBitmapFilter::GetSizeOfSpread(m_pSpread); }
DocRect DrawingSelection::GetSize()         { return BaseBitmapFilter::GetSizeOfDrawing(m_pSpread); }

#endif



/**************************************************************************************************
Access functions add on 20/10/00 for use by the palette optimiser sjk
// SMFIX

  All added in the cpp file so we can breakpoint on them nicely
**************************************************************************************************/
 // is the palette in this export object completely valid and perfect?
BOOL BitmapExportOptions::IsPaletteValid()
{
    return m__PaletteIsValid;
}

void BitmapExportOptions::InvalidatePalette()
{
    m__PaletteIsValid = FALSE;
    SetTempFileMatchesExportOptions(FALSE);
    BitmapExportPaletteInterface::InvalidateSortedPalette();
}

void BitmapExportOptions::SetTransparencyIndex(INT32 TransparencyIndex)
{
    if (m_TransparencyIndex != TransparencyIndex)
        SetTempFileMatchesExportOptions(FALSE);
    m_TransparencyIndex = TransparencyIndex; 
}

void BitmapExportOptions::SetBackgroundTransparency(BOOL t)
{
    if (m__BackgroundIsTransparent != t)
        InvalidatePalette();
    m__BackgroundIsTransparent = t;
}


INT32   BitmapExportOptions::GetNumberOfUserRequestedColours()
{
    return m__NumberOfColoursUserRequested;
}

void BitmapExportOptions::SetNumberOfUserRequestedColours(INT32 n)
{
    if (m__NumberOfColoursUserRequested != n)
        InvalidatePalette();
    m__NumberOfColoursUserRequested = n;
}

BOOL BitmapExportOptions::IsUsingBrowserPalette()
{
    return m__UseBrowserPalette;
}

void BitmapExportOptions::SetToUseBrowserPalette(BOOL SetIt)
{
    if (m__UseBrowserPalette != SetIt)
    {
        m__UseBrowserPalette = SetIt;
        InvalidatePalette();
    }
}

BOOL BitmapExportOptions::IsUsingSystemPalette()
{
    return m__UseSystemColoursInPalette;
}

void BitmapExportOptions::SetToUseSystemPalette(BOOL SetIt)
{
    if (m__UseSystemColoursInPalette != SetIt)
    {
        m__UseSystemColoursInPalette = SetIt;
        InvalidatePalette();
    }
}

INT32 BitmapExportOptions::GetWebSnapPaletteAmount()
{
    return m__UseWebSnapPalette;
}

void BitmapExportOptions::SetWebSnapPaletteAmount(INT32 SetIt)
{
    if (m__UseWebSnapPalette != SetIt)
    {
        m__UseWebSnapPalette = SetIt;
        InvalidatePalette();
    }
}

INT32 BitmapExportOptions::GetPrimarySnapPaletteAmount()
{
    return m__UsePrimarySnapPalette;
}

void BitmapExportOptions::SetPrimarySnapPaletteAmount(INT32 SetIt)
{
    if (m__UsePrimarySnapPalette != SetIt)
    {
        m__UsePrimarySnapPalette = SetIt;
        InvalidatePalette();
    }
}


// create palette Optimiser
BOOL BitmapExportOptions::CreatePaletteOptimiser()
{
    if (m__pPaletteOptimiser == NULL)
    {
        m__HavePrimedOptimier = FALSE;
        m__pPaletteOptimiser = new PaletteOptimiser();

        ERROR2IF(m__pPaletteOptimiser == NULL, FALSE, "Low on memory, couldn't create palette optimiser");

        m__pPaletteOptimiser->Initialise();

        return TRUE; // we created a new one
    }

    return FALSE; // we kept the old one
}

// flush the palette optimiser if the bitmap source pixels have changed
// since this will affect the stats that were fed into it
void BitmapExportOptions::BitmapSourceHasChanged()
{
    m__HavePrimedOptimier = FALSE;
    if (m__pPaletteOptimiser != NULL)
        delete m__pPaletteOptimiser;

    m__pPaletteOptimiser = NULL;
    InvalidatePalette(); // the palette we are holding will be wrong too
}

// feed the optimiser with stats from the image
void BitmapExportOptions::GatherPaletteStats(const RGBQUAD* pBitmap, UINT32 nSize )
{
    if (m__pPaletteOptimiser)
    {
        m__pPaletteOptimiser->AddStats(pBitmap, nSize);
    }
}


// fills in a logical palette from the stored extended palette
LOGPALETTE * BitmapExportOptions::GetLogicalPalette()
{
    ERROR3IF(!m__PaletteIsValid, "Palette not validated");

    // the logical palette is valid and current
    if (m__pLogicalPalette)
        return m__pLogicalPalette;

    // build a logical palette based on the extended palette
    // calling functions can read and use this data, but they should not delete it
    // the logical palette is managed by the export options
    m__pLogicalPalette = (LOGPALETTE * ) new BYTE[sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 256 )];
    if (m__pLogicalPalette == NULL)
        return NULL;

    // pick a colour to duplicate for deleted colours to be
//  INT32 OptimisedCommonColour = m_Palette.NumberOfColours-1;

    m__pLogicalPalette->palNumEntries = m_Palette.NumberOfColours;
    m__pLogicalPalette->palVersion = 0x300;
    INT32 i = 0;
    for( ; i < m__pLogicalPalette->palNumEntries; i++ )
    {
        m__pLogicalPalette->palPalEntry[ i ].peRed = m_Palette.Data[ i ].Red;
        m__pLogicalPalette->palPalEntry[ i ].peGreen = m_Palette.Data[ i ].Green;           
        m__pLogicalPalette->palPalEntry[ i ].peBlue = m_Palette.Data[ i ].Blue;
        BOOL NonRenderable = (m_Palette.Data[i].Flags & (DELETED_COLOUR | TRANSPARENT_COLOUR));
        m__pLogicalPalette->palPalEntry[ i ].peFlags = NonRenderable ? 255 : 0;
    }

    return m__pLogicalPalette;
}

// swap the current colours in the palette for the 
BOOL BitmapExportOptions::SwapEditedColoursInLogicalPalette()
{
    if (!m__pLogicalPalette)
        return FALSE;

    BOOL DidASwap = FALSE;
    for( INT32 i = 0; i < m__pLogicalPalette->palNumEntries; i++ )
    {
        if (m_Palette.Data[ i ].Flags & LOCKED_COLOUR)
        {
            BYTE t;
            t = m_Palette.Data[ i ].Red;
            m_Palette.Data[ i ].Red = m_Palette.Data[ i ].PreEditedRed;
            m_Palette.Data[ i ].PreEditedRed = t;
            m__pLogicalPalette->palPalEntry[ i ].peRed = m_Palette.Data[ i ].Red;

            t = m_Palette.Data[ i ].Green;
            m_Palette.Data[ i ].Green = m_Palette.Data[ i ].PreEditedGreen;
            m_Palette.Data[ i ].PreEditedGreen = t;
            m__pLogicalPalette->palPalEntry[ i ].peGreen = m_Palette.Data[ i ].Green;

            t = m_Palette.Data[ i ].Blue;
            m_Palette.Data[ i ].Blue = m_Palette.Data[ i ].PreEditedBlue;
            m_Palette.Data[ i ].PreEditedBlue = t;
            m__pLogicalPalette->palPalEntry[ i ].peBlue = m_Palette.Data[ i ].Blue;

            DidASwap = TRUE;
        }
    }

    return DidASwap;
}

// find the next locked colour in the extended palette
// returns the index of the palette entry or -1 if not found
// starts looking from entry pos+1
INT32 BitmapExportOptions::FindNextLockedColour(INT32 pos)
{
    pos++;
    while (pos < m_Palette.NumberOfColours)
    {
        if (m_Palette.Data[pos].Flags & LOCKED_COLOUR || m_Palette.Data[pos].Flags & DELETED_COLOUR)
            return pos;

        pos++;
    }
    return -1;
}


// This is the function which creates the optimal palette
// It is passed in a ptr to the palette optimiser which has been initiallised and has gathered stats
// on each strip of the bitmap.
// This function then looks at what locked colours the user has set and the other palette
// options the user wants and gives all these to the optimiser.
// It then tries to recreate the options extended palette (including locked colours) from the
// logical palette that the optimiser returns.
// It sets its internal logical palette up and sets the ValidPalette flag to being valid.
void BitmapExportOptions::CreateValidPalette()
{
    ASSERT(m__pPaletteOptimiser);

    // tell the export dlg palette ctrl that a new palette is on the horizon
    BitmapExportPaletteInterface::InvalidateSortedPalette();

    // delete our old logical palette if we had one
    if (m__pLogicalPalette)
    {
        delete m__pLogicalPalette;
        m__pLogicalPalette = NULL;
    }

    // allocate space for a logical palette
    m__pLogicalPalette = (LOGPALETTE * ) new BYTE[sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 256 )];
    if (m__pLogicalPalette == NULL)
        return;
    INT32 NewFlags[256];
    BYTE EditedColours[256][3];
    INT32 BackGroundTransp = m__BackgroundIsTransparent? 1: 0;

    // init the flags for the new palette
    memset(&NewFlags, 0, sizeof(INT32)*256);
    // init the edited colours for the new palette
    memset(&EditedColours, 0, 3*256);

    INT32 i = 0;
    // count the locked colours that we had in the last palette,
    // these are still the same locked colours for the new palette 
    // as the flags would have been removed if they were no longer required
    m__pPaletteOptimiser->RemoveLockedColours();
    INT32 LockedColours = 0;
    for (i = 0; i < m_Palette.NumberOfColours; i++)
    {
        if (m_Palette.Data[i].Flags & LOCKED_COLOUR || m_Palette.Data[i].Flags & DELETED_COLOUR) // found a locked colour?
        {
            // add it as a locked colour to the palette
            m__pPaletteOptimiser->AddLockedColour(m_Palette.Data[i].Red, m_Palette.Data[i].Green, m_Palette.Data[i].Blue);
            // count the locked colours so far
            LockedColours++;
        }
    }
    // how many colours can we fit in the palette
    INT32 MaxColoursInPalette = 256;
    if (m_Depth == 4)
        MaxColoursInPalette = 16;
    else if (m_Depth == 1)
        MaxColoursInPalette = 2;

    MaxColoursInPalette = max(2, min(MaxColoursInPalette, m__NumberOfColoursUserRequested));

    // work out how many spare colours we have within the user defined restraint
    // once we have kept these locked colours and have account for the transparency
//  INT32 NoOfColoursToOptimise = MaxColoursInPalette - LockedColours - BackGroundTransp;

    m__pPaletteOptimiser->SnapToBrowserPalette(m__UseWebSnapPalette);
    m__pPaletteOptimiser->SnapToPrimaries(m__UsePrimarySnapPalette);
    m__pPaletteOptimiser->AddSystemColours((m__UseSystemColoursInPalette == TRUE));
    m__pPaletteOptimiser->UseBrowserPalette((m__UseBrowserPalette == TRUE));

    // tell the optimiser that we have finished gathering the stats
    //if (!m__HavePrimedOptimier) // can I get away with putting this optimisation back gav?
    {
        m__pPaletteOptimiser->GenPalette(max(2,MaxColoursInPalette - BackGroundTransp));
        m__HavePrimedOptimier = TRUE;
    }

    m__pLogicalPalette->palNumEntries = MaxColoursInPalette;
    m__pLogicalPalette->palVersion = 0x300;

    // get the optimised palette from the optimser
    /*BOOL JustBmpColours =*/ m__pPaletteOptimiser->GetPalette( m__pLogicalPalette, max(2,MaxColoursInPalette - BackGroundTransp));

//  if (JustBmpColours)
//      TRACE( _T("Just bmp colours\n"));
//  else
//      TRACE( _T("fully optimised colours\n"));

    // reset the flags in the new palette from the locked/deleted colours we had in the old palette
    // they may not be in the new palette, but they are LIKELY to be there
    INT32 index = -1;
    while ((index = FindNextLockedColour(index)) != -1) // find the next locked colour
    {
        // does this match in the palette
        for (i = 0; i < m__pLogicalPalette->palNumEntries; i++)
            if (NewFlags[i] == 0 &&
                m_Palette.Data[index].Red   == m__pLogicalPalette->palPalEntry[ i ].peRed &&
                m_Palette.Data[index].Green == m__pLogicalPalette->palPalEntry[ i ].peGreen &&
                m_Palette.Data[index].Blue  == m__pLogicalPalette->palPalEntry[ i ].peBlue
                )
            {
                NewFlags[i] = m_Palette.Data[index].Flags;
                EditedColours[i][0] = m_Palette.Data[index].PreEditedRed;
                EditedColours[i][1] = m_Palette.Data[index].PreEditedGreen;
                EditedColours[i][2] = m_Palette.Data[index].PreEditedBlue;
                break;
            }
    }

    // special case for 1 colour - dont mix them up
    if (MaxColoursInPalette - BackGroundTransp == 1)
    {
        m_Palette.NumberOfColours = m__pLogicalPalette->palNumEntries = 2;
        // bias against the background colour and use the other colour if 
        // the background colour is more predominant
        DocColour dcol = Page::GetPageColour();
        INT32 bgr = 255, bgg = 255, bgb = 255;

        // the above call the GetPageColour doesn't work very well
        // this code gets it better if the spread and the layer exist
        Spread* pSelSpread = Document::GetSelectedSpread();
        if (pSelSpread)
        {
            Layer * pLayer = pSelSpread->FindFirstPageBackgroundLayer();
            if (pLayer)
            {
                Node * pNode = SliceHelper::FindNextOfClass(pLayer, pLayer, CC_RUNTIME_CLASS(AttrFlatColourFill));
                if (pNode)
                    dcol = *(((AttrFlatFill *)pNode)->GetStartColour());
            }
        }

        dcol.GetRGBValue(&bgr,&bgg,&bgb);

        // pick which of the two colours to use
        if (BackGroundTransp && 
            (m__pLogicalPalette->palPalEntry[ 0 ].peRed == (BYTE)bgr || m__pLogicalPalette->palPalEntry[ 0 ].peRed == (BYTE)bgr-1) &&
            (m__pLogicalPalette->palPalEntry[ 0 ].peGreen == (BYTE)bgg || m__pLogicalPalette->palPalEntry[ 0 ].peGreen == (BYTE)bgg-1) &&
            (m__pLogicalPalette->palPalEntry[ 0 ].peBlue == (BYTE)bgb || m__pLogicalPalette->palPalEntry[ 0 ].peBlue == (BYTE)bgb-1))
        {
            m__pLogicalPalette->palPalEntry[ 0 ].peRed = m__pLogicalPalette->palPalEntry[ 1 ].peRed;
            m__pLogicalPalette->palPalEntry[ 0 ].peGreen = m__pLogicalPalette->palPalEntry[ 1 ].peGreen;
            m__pLogicalPalette->palPalEntry[ 0 ].peBlue = m__pLogicalPalette->palPalEntry[ 1 ].peBlue;
        }
    }
    else if (MaxColoursInPalette == 2) // special case for two colour none transp
    {
        // make it black and white
        m__pLogicalPalette->palPalEntry[ 0 ].peRed = 0;
        m__pLogicalPalette->palPalEntry[ 0 ].peGreen = 0;
        m__pLogicalPalette->palPalEntry[ 0 ].peBlue = 0;
        m__pLogicalPalette->palPalEntry[ 0 ].peFlags = 0;
        m__pLogicalPalette->palPalEntry[ 1 ].peRed = 255;
        m__pLogicalPalette->palPalEntry[ 1 ].peGreen = 255;
        m__pLogicalPalette->palPalEntry[ 1 ].peBlue = 255;
        m__pLogicalPalette->palPalEntry[ 1 ].peFlags = 0;
    }

    // make room for transp as the first colour
    // by moving the other colours up
    if (BackGroundTransp)
    {
        // add the background colour to the palette which is one more colour in there
        if (m__pLogicalPalette->palNumEntries <  MaxColoursInPalette)
            m__pLogicalPalette->palNumEntries++;

        // move all the colours up a place
        for (INT32 i = m__pLogicalPalette->palNumEntries-1; i > 0; i--)
        {
            m__pLogicalPalette->palPalEntry[ i ].peRed = m__pLogicalPalette->palPalEntry[ i-1 ].peRed;
            m__pLogicalPalette->palPalEntry[ i ].peGreen = m__pLogicalPalette->palPalEntry[ i-1 ].peGreen;
            m__pLogicalPalette->palPalEntry[ i ].peBlue = m__pLogicalPalette->palPalEntry[ i-1 ].peBlue;
            NewFlags[i] = NewFlags[i-1];
            EditedColours[i][0] = EditedColours[i-1][0];
            EditedColours[i][1] = EditedColours[i-1][1];
            EditedColours[i][2] = EditedColours[i-1][2];
        }

        // the transp coluor is white 255,255,255
        m__pLogicalPalette->palPalEntry[ 0 ].peRed = 255;
        m__pLogicalPalette->palPalEntry[ 0 ].peGreen = 255;
        m__pLogicalPalette->palPalEntry[ 0 ].peBlue = 255;

        NewFlags[0] = TRANSPARENT_COLOUR;
        SetTransparencyIndex(0);
    }
    else
    {
        // we dont have background transparancy but do we have any other colour that is
        // set to being transparent?
        INT32 TranspIndex = -1; // the default no transp
        // find a transp marker in the new flags
        for (i = 0; i < m__pLogicalPalette->palNumEntries && TranspIndex == -1; i++)
        {
            if (NewFlags[i] & TRANSPARENT_COLOUR)
                TranspIndex = i;

        }
        // set the transp index
        SetTransparencyIndex(TranspIndex);
    }

    // the palette is now valid
    m__PaletteIsValid = TRUE;

    // set the number of colours in the extended palette to match those in the new palette that
    // the optimiser returned to us
    m_Palette.NumberOfColours = m__pLogicalPalette->palNumEntries;

    // fill in the extended palette from the logical palette that is now optimal for this export
    for (i = 0; i < 256; i++)
    {
        m_Palette.Data[i].Red = m__pLogicalPalette->palPalEntry[ i ].peRed;
        m_Palette.Data[i].Green = m__pLogicalPalette->palPalEntry[ i ].peGreen;
        m_Palette.Data[i].Blue = m__pLogicalPalette->palPalEntry[ i ].peBlue;
        m_Palette.Data[i].Flags = NewFlags[i];
        m_Palette.Data[i].PreEditedRed = EditedColours[i][0];
        m_Palette.Data[i].PreEditedGreen = EditedColours[i][1];
        m_Palette.Data[i].PreEditedBlue = EditedColours[i][2];

        if (i >= m__pLogicalPalette->palNumEntries || 
            (m_Palette.Data[i].Flags & (DELETED_COLOUR | TRANSPARENT_COLOUR)))
            m__pLogicalPalette->palPalEntry[ i ].peFlags = 255; // meaning dont display this colour
        else
            m__pLogicalPalette->palPalEntry[ i ].peFlags = 0; // meaning do display this colour
    }

}


// This pairs with the function above and creates a valid palette from a known
// logical palette where one colour can be marked as transparent
void BitmapExportOptions::CreateValidPalette(LOGPALETTE * pPal, INT32 TranspIndex)
{
    // tell the export dlg palette ctrl that a new palette is on the horizon
    BitmapExportPaletteInterface::InvalidateSortedPalette();
    // delete our old logical palette if we had one
    if (m__pLogicalPalette)
    {
        delete m__pLogicalPalette;
        m__pLogicalPalette = NULL;
    }

    m__PaletteIsValid = (pPal != NULL);

    if (!m__PaletteIsValid)
        return;

    // copy the logical palette data if it was valid
    m__pLogicalPalette = (LOGPALETTE * ) new BYTE[sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 256 )];

    if (m__pLogicalPalette == NULL)
    {
        InvalidatePalette();
        return;
    }

    m__pLogicalPalette->palVersion = 0x300;

    // set the number of colours in the extended palette to match those in the new palette passed in
    m_Palette.NumberOfColours = m__pLogicalPalette->palNumEntries = pPal->palNumEntries;
    // fill in the extended palette from the new logical palette from the logical palette passed in
    for (INT32 i = 0; i < pPal->palNumEntries; i++)
    {
        m_Palette.Data[i].Red = pPal->palPalEntry[ i ].peRed;
        m_Palette.Data[i].Green = pPal->palPalEntry[ i ].peGreen;
        m_Palette.Data[i].Blue = pPal->palPalEntry[ i ].peBlue;
        m_Palette.Data[i].Flags = 0; // no flags set this will loose any locked colours etc as these are not part of a logical palette

        m__pLogicalPalette->palPalEntry[ i ].peRed = m_Palette.Data[i].Red;
        m__pLogicalPalette->palPalEntry[ i ].peGreen = m_Palette.Data[i].Green;
        m__pLogicalPalette->palPalEntry[ i ].peBlue = m_Palette.Data[i].Blue;
        m__pLogicalPalette->palPalEntry[ i ].peFlags = 0;
    }

    if (TranspIndex >= 0 && TranspIndex < pPal->palNumEntries)
    {
        m_Palette.Data[TranspIndex].Flags = TRANSPARENT_COLOUR;
        m__pLogicalPalette->palPalEntry[ TranspIndex ].peFlags = 255;
        SetTransparencyIndex(TranspIndex);
    }
}

// this likewise sets the extended palette to a preset browser palette
// which is only used in the creation of a global palette for all animated frames
void BitmapExportOptions::CreateValidBrowserPalette(BOOL WantTransp)
{
    // tell the export dlg palette ctrl that a new palette is on the horizon
    BitmapExportPaletteInterface::InvalidateSortedPalette();
    // delete our old logical palette if we had one
    if (m__pLogicalPalette)
    {
        delete m__pLogicalPalette;
        m__pLogicalPalette = NULL;
    }

    m__PaletteIsValid = TRUE;

    // copy the logical palette data if it was valid
    m__pLogicalPalette = (LOGPALETTE * ) new BYTE[sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 256 )];

    if (m__pLogicalPalette == NULL)
    {
        InvalidatePalette();
        return;
    }

    m__pLogicalPalette->palVersion = 0x300;

    // set the number of colours in the extended palette to match those in the new palette passed in
    m_Palette.NumberOfColours = m__pLogicalPalette->palNumEntries = WantTransp ? 217 : 216;
    // fill in the extended palette from the new logical palette from the logical palette passed in

    m_Palette.Data[0].Red = 255 ;
    m_Palette.Data[0].Green = 255;
    m_Palette.Data[0].Blue = 255;
    m_Palette.Data[0].Flags = WantTransp ? TRANSPARENT_COLOUR : 0;
    m__pLogicalPalette->palPalEntry[ 0 ].peRed = m_Palette.Data[0].Red;
    m__pLogicalPalette->palPalEntry[ 0 ].peGreen = m_Palette.Data[0].Green;
    m__pLogicalPalette->palPalEntry[ 0 ].peBlue = m_Palette.Data[0].Blue;
    m__pLogicalPalette->palPalEntry[ 0 ].peFlags = WantTransp ? 255 : 0;

    SetTransparencyIndex(WantTransp ? 0 : -1);
    
    INT32 i = 1;
    for (INT32 r = 0; r < 256; r += 51)
        for (INT32 g = 0; g < 256; g += 51)
            for (INT32 b = 0; b < 256; b += 51)
            {
                m_Palette.Data[i].Red = r ;
                m_Palette.Data[i].Green = g;
                m_Palette.Data[i].Blue = b;
                m_Palette.Data[i].Flags = 0; // no flags set this will loose any locked colours etc as these are not part of a logical palette

                m__pLogicalPalette->palPalEntry[ i ].peRed = m_Palette.Data[i].Red;
                m__pLogicalPalette->palPalEntry[ i ].peGreen = m_Palette.Data[i].Green;
                m__pLogicalPalette->palPalEntry[ i ].peBlue = m_Palette.Data[i].Blue;
                m__pLogicalPalette->palPalEntry[ i ].peFlags = 0;
                i++;
            }
}

/***************************************************************************************
    Author:     Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/11/00
    Returns:    TRUE if supported or FALSE if not!
    Purpose:    Return true if the current filter allows palette info

******************************************************************************************/
BOOL BitmapExportOptions::GetSupportsPalette()
{
    // Set up the return variable
    BOOL Supported = FALSE;
    UINT32 FilterStrID = GetFilterNameStrID();

    // We can only use palettes with Bitmaps of 8 BPP or less, so quick check first!
    if(m_Depth <= 8)
    {
        // Find out what Filter Type we are
        Supported = (FilterStrID == _R(IDN_FILTERNAME_GIF) || FilterStrID == _R(IDT_FILTERNAME_BMP) || FilterStrID == _R(IDS_FILTERNAME_PNG));
    }

    return Supported;
}

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

  > DWORD BitmapExportOptions::GetSupportedDithers()

    Author:     Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/11/00
    Returns:    ENUM of the avaliable dither types, 0 if dithering not supported
    Purpose:    Returns the allowed dither types the current filter supports.

******************************************************************************************/
DWORD BitmapExportOptions::GetSupportedDithers()
{
    // Set up the return variable
    DWORD Supported = 0;
    UINT32 FilterStrID = GetFilterNameStrID();

    // We can only use palettes with Bitmaps of 8 BPP or less, so quick check first!
    if(m_Depth <= 8)
    {
        // Find out what Filter Type we are
//      switch (FilterStrID)
//      {
//      case _R(IDN_FILTERNAME_GIF):
//      case _R(IDS_FILTERNAME_PNG):
//      case _R(IDT_FILTERNAME_BMP):
        if (FilterStrID==_R(IDN_FILTERNAME_GIF) || FilterStrID==_R(IDS_FILTERNAME_PNG) || FilterStrID==_R(IDT_FILTERNAME_BMP))
            {
                Supported |= ERROR_DITHER;

                if (m__UseBrowserPalette && m_Depth != 4)
                    Supported |= ORDERED_DITHER;

//              break;
            }
//      case _R(IDS_JPG_EXP_FILTERNAME):
//      default:
//          break; // Not supported so don`t do anything!
//      }
    }

    return Supported;
}

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

  > DWORD BitmapExportOptions::GetSupportedColourDepths()

    Author:     Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/11/00
    Returns:    BitField value of the avaliable colours allowed
    Purpose:    Returns the all the colour depths the current filter supports.

******************************************************************************************/
DWORD BitmapExportOptions::GetSupportedColourDepths()
{
    // Set up the return variable
    DWORD Supported = 0;
    UINT32 FilterStrID = GetFilterNameStrID();

    if(FilterStrID == _R(IDN_FILTERNAME_GIF))
        Supported = (COLOUR_2 | COLOUR_16 | COLOUR_256 );
    else if(FilterStrID == _R(IDT_FILTERNAME_BMP))
        Supported = (COLOUR_2 | COLOUR_16 | COLOUR_256 | COLOUR_24BIT);
    else if(FilterStrID == _R(IDS_FILTERNAME_PNG))
        Supported = (COLOUR_2 | COLOUR_16 | COLOUR_256 | COLOUR_24BIT | COLOUR_32BIT);
    else if (FilterStrID == _R(IDS_JPG_EXP_FILTERNAME))
        Supported = COLOUR_24BIT;
    else
        // Anything else gets a choice of all types
        Supported = (COLOUR_2 | COLOUR_16 | COLOUR_256 | COLOUR_24BIT | COLOUR_32BIT);

    return Supported;
}

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

  > BOOL BitmapExportOptions::SupportsTransparency()

    Author:     Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/11/00
    Returns:    TRUE if Supported else FALSE!
    Purpose:    Used to see if the current filter allows transparencies.

******************************************************************************************/
BOOL BitmapExportOptions::GetSupportsTransparency()
{
    // Set up the return variable
    BOOL Supported = FALSE;
    UINT32 FilterStrID = GetFilterNameStrID();

    // We can only use Transparency with Bitmaps of 8 BPP or less, so quick check first!
    if(m_Depth <= 8)
    {
        Supported = (FilterStrID == _R(IDN_FILTERNAME_GIF) || FilterStrID == _R(IDS_FILTERNAME_PNG));
    }

    return Supported;
}

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

  > DWORD BitmapExportOptions::GetInterlaceType()

    Author:     Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/11/00
    Returns:    TRUE if supported or FALSE if not!
    Purpose:    Return true if the current filter allows palette info

******************************************************************************************/
DWORD BitmapExportOptions::GetInterlaceType()
{
    // Set up the return variable
    DWORD Supported = 0;
    UINT32 FilterStrID = GetFilterNameStrID();

    if(FilterStrID == _R(IDN_FILTERNAME_GIF))
        Supported = GIF_INTERLACE;
    else if(FilterStrID == _R(IDS_FILTERNAME_PNG))
        Supported = PNG_INTERLACE;
    else if(FilterStrID == _R(IDS_JPG_EXP_FILTERNAME))
        Supported = JPG_PROGRESSIVE;

    return Supported;
}


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

  > BaseBitmapFilter * BitmapExportOptions::FindBitmapFilterForTheseExportOptions()

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    4/12/00
    Returns:    ptr to a filter that can be used to export using these export options

******************************************************************************************/
BaseBitmapFilter * BitmapExportOptions::FindBitmapFilterForTheseExportOptions()
{
    // get the name this filter thinks it is
    const StringBase * pFilterName = GetFilterName();
    String_256 PreferedFiltersName = "";
    
    // check this ptr can be NULL
    if (pFilterName)
        PreferedFiltersName = *(GetFilterName());

    // fill it with the name that the export options thinks should be using the options
    // if the filters name hasn't been put in
    if (PreferedFiltersName.IsEmpty() || GetFilterNameStrID() == _R(IDT_FILTERNAME_BMP)) // bodge for _R(IDT_FILTERNAME_BMP) since the program is using multiple strings for this filter BMP/Windows bitmaps
    {
        PreferedFiltersName.Load(GetFilterNameStrID());
    }


    Filter *pFilter = Filter::GetFirst();
    while (pFilter != NULL)
    {
        // If we are filtering for bitmap filters then check that if a Bpp has been
        // specified that the bitmap filter can cope with that.
        FilterFlags Flags = pFilter->GetFlags();
        if (Flags.CanExport && pFilter->IsKindOf(CC_RUNTIME_CLASS(BaseBitmapFilter)))
        {
            BaseBitmapFilter* pBitmapFilter = (BaseBitmapFilter*)pFilter;
            if (PreferedFiltersName.CompareTo(pFilter->pOILFilter->FilterName, FALSE) == 0)
                return pBitmapFilter;
        }
        // Try the next filter
        pFilter = Filter::GetNext(pFilter);
    }

    return NULL;
}

/**************************************************************************************************
End of Access functions add on 20/10/00 for use by the palette optimiser sjk
**************************************************************************************************/

---