coplfilr.cpp

Go to the documentation of this file.

// $Id: coplfilr.cpp 1282 2006-06-09 09:46:49Z alex $
/* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
================================XARAHEADERSTART===========================
 
               Xara LX, a vector drawing and manipulation program.
                    Copyright (C) 1993-2006 Xara Group Ltd.
       Copyright on certain contributions may be held in joint with their
              respective authors. See AUTHORS file for details.

LICENSE TO USE AND MODIFY SOFTWARE
----------------------------------

This file is part of Xara LX.

Xara LX is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as published
by the Free Software Foundation.

Xara LX and its component source files are distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with Xara LX (see the file GPL in the root directory of the
distribution); if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA  02110-1301 USA


ADDITIONAL RIGHTS
-----------------

Conditional upon your continuing compliance with the GNU General Public
License described above, Xara Group Ltd grants to you certain additional
rights. 

The additional rights are to use, modify, and distribute the software
together with the wxWidgets library, the wxXtra library, and the "CDraw"
library and any other such library that any version of Xara LX relased
by Xara Group Ltd requires in order to compile and execute, including
the static linking of that library to XaraLX. In the case of the
"CDraw" library, you may satisfy obligation under the GNU General Public
License to provide source code by providing a binary copy of the library
concerned and a copy of the license accompanying it.

Nothing in this section restricts any of the rights you have under
the GNU General Public License.


SCOPE OF LICENSE
----------------

This license applies to this program (XaraLX) and its constituent source
files only, and does not necessarily apply to other Xara products which may
in part share the same code base, and are subject to their own licensing
terms.

This license does not apply to files in the wxXtra directory, which
are built into a separate library, and are subject to the wxWindows
license contained within that directory in the file "WXXTRA-LICENSE".

This license does not apply to the binary libraries (if any) within
the "libs" directory, which are subject to a separate license contained
within that directory in the file "LIBS-LICENSE".


ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS
----------------------------------------------

Subject to the terms of the GNU Public License (see above), you are
free to do whatever you like with your modifications. However, you may
(at your option) wish contribute them to Xara's source tree. You can
find details of how to do this at:
  http://www.xaraxtreme.org/developers/

Prior to contributing your modifications, you will need to complete our
contributor agreement. This can be found at:
  http://www.xaraxtreme.org/developers/contribute/

Please note that Xara will not accept modifications which modify any of
the text between the start and end of this header (marked
XARAHEADERSTART and XARAHEADEREND).


MARKS
-----

Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara
designs are registered or unregistered trademarks, design-marks, and/or
service marks of Xara Group Ltd. All rights in these marks are reserved.


      Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK.
                        http://www.xara.com/

=================================XARAHEADEREND============================
 */

/*
*/

#include "camtypes.h"
#include "coplfilr.h"

//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ccfile.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "cdrcol.h"
//#include "oilfltrs.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "optsunit.h"
#include "progress.h"
#include "scunit.h"
#include "sgcolour.h"
//#include "isetres.h"

//#include "ben.h"
//#include "filtrres.h"
//#include "peter.h"
//#include "will2.h"

DECLARE_SOURCE("$Revision: 1282 $");

CC_IMPLEMENT_DYNAMIC(PaletteFilter, Filter)
CC_IMPLEMENT_DYNAMIC(CorelPaletteFilter, PaletteFilter)
CC_IMPLEMENT_DYNAMIC(MSPaletteFilter, PaletteFilter)
CC_IMPLEMENT_DYNAMIC(AdobeColourTableFilter, PaletteFilter)
CC_IMPLEMENT_DYNAMIC(AdobeColourSwatchFilter, PaletteFilter)
CC_IMPLEMENT_DYNAMIC(JCWColourFilter, PaletteFilter)
CC_IMPLEMENT_DYNAMIC(PaintShopProPaletteFilter, PaletteFilter)

#define new CAM_DEBUG_NEW

typedef struct {
    WORD Unknown;
    BYTE Entries[2];
} cpl_header;

#define CPL_MIN_ENTRY_SIZE      14      // minimum size of an entry in a cpl file
#define CPL_MAX_ENTRY_SIZE      (13+32) // max size
#define CPL_CHECK_TEXT_START    16      // place to start checking the text
#define CPF_MAX_COLNAME_SIZE 32

#define CPL_FVU     -1      // version unknown
#define CPL_FV4     4       // version 4
#define CPL_FV5     5       // version 5



/********************************************************************************************
>   PaletteFilter::PaletteFilter()

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/4/96
    Inputs:     -
    Returns:    -
    Purpose:    Constructor for a base palette filter
    SeeAlso:    Filter
********************************************************************************************/
PaletteFilter::PaletteFilter()
{
    m_pNewColours = NULL;

    ImportIntoGallery = TRUE;
    CurrentGalleryGroup = NULL;
}


/********************************************************************************************
>   PaletteFilter::~PaletteFilter()

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/4/96
    Inputs:     -
    Returns:    -
    Purpose:    Destructor for a base palette filter
    SeeAlso:    Filter
********************************************************************************************/
PaletteFilter::~PaletteFilter()
{
    if (m_pNewColours != NULL)
    {
        m_pNewColours->DestroyColours();
        delete m_pNewColours;
        m_pNewColours = NULL;
    }
}


/********************************************************************************************
>   virtual BOOL PaletteFilter::IsDefaultDocRequired(const TCHAR* pcszPathName)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/4/96
    Inputs:     pcszPathName - pointer to the name of the file that is about to be imported
    Returns:    TRUE if a document is required to import this file into,
                FALSE if file supplies the document
    Purpose:    For determining wether this filter needs a document to be created to import
                into.
********************************************************************************************/
BOOL PaletteFilter::IsDefaultDocRequired(const TCHAR* pcszPathName)
{
    // Since palette files are unlikely to supply a document we will return TRUE.
    // Derived classes can still virtually override this function and return FALSE if required.

    return TRUE;
}


/********************************************************************************************
>   virtual BOOL PaletteFilter::DoImport(SelOperation* pOp, CCLexFile* pFile, Document* pDoc, BOOL AutoChosen, ImportPosition *Pos,
                             KernelBitmap** ppImportedBitmap, DocCoord* pPosTranslate, String_256* URL)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/4/96
    Inputs:     pOp     - The operation this import is running under
                pFile   - The file to import from
                pDoc    - The document to import into
                AutoChosen  - TRUE if this filter was chosen by the system, FALSE if chosen by the user
                ImportPos   - The position to import the file data at
                Pos -
                ppImportedBitmap - this is used mainly in the bitfltr.cpp for the HTML
                import filter. HTMLFilter::DoImport() needs a pointer to a kernel bitmap
                to set the background bitmap up into Camelot.
                pPosTranslate - This is used too by the HTMLFilter in order to do a formatting.
                URL - original URL of the imported file
    Returns:    TRUE for successful import, FALSE if an error occured.
    Purpose:    Base class for handling palette import

    Notes:      **** IMPORTANT **************************************************************
                Palette filters can be called directly from the colour gallery (sgcolour.cpp)
                library groups to import palette files directly into the gallery.
                In this case, pOp and pDoc are NULL, and the member vars CurrentGalleryGroup
                and ImportIntoGallery are set up suitably. It is this important that these
                filters continue to be happy about not importing into a document!
                *****************************************************************************

    SeeAlso:    Filter::DoImport
********************************************************************************************/
BOOL PaletteFilter::DoImport(SelOperation* pOp, CCLexFile* pFile, Document* pDoc, BOOL AutoChosen, ImportPosition *Pos,
                             KernelBitmap** ppImportedBitmap, DocCoord* pPosTranslate, String_256* URL)
{
    BOOL ok = TRUE;

    // Copy parameters into member vars.
    // NOTE that we allow pOp and pDoc to be NULL, when we are importing into a gallery!
    ERROR2IF(pFile==NULL, FALSE, "NULL parameter passed");
    m_pImportOp = pOp;
    m_pImportFile = pFile;
    m_pImportDoc = pDoc;

    // Determine if this is really a huge bodge and we're importing directly into the colour gallery
#if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX)
    //ColourSGallery *ParentGal = (ColourSGallery *) OpDisplayColourGallery::FindGallery();
    ColourSGallery *ParentGal = ColourSGallery::GetInstance();
    if (ParentGal != NULL)
        CurrentGalleryGroup = ParentGal->GetCurrentImportGroup();
    else
#endif
        CurrentGalleryGroup = NULL;

    ImportIntoGallery = (CurrentGalleryGroup != NULL);
    ERROR2IF(!ImportIntoGallery && (pDoc == NULL || pOp == NULL), FALSE, "NULL doc/op when not importing into gallery");

    // Initialise base class services
    if (ok)
        ok = PrepareForImport();

    // Call derived loading functions                                                                                   
    if (ok)
        ok = PreImport();
    if (ok)
        ok = ImportPalette();
    if (ok)
        ok = PostImport();

    // Finialise base class importation
    if (ok)
        ok = FinishImport(TRUE);
    else
        FinishImport(FALSE);

    CurrentGalleryGroup = NULL;
    ImportIntoGallery = FALSE;

    return ok;
}


/********************************************************************************************
>   virtual BOOL PaletteFilter::DoExport(Operation* pOp, CCLexFile* pFile,
                                         PathName* pPath, Document* pDoc,
                                         BOOL ShowOptions)
    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/4/96
    Inputs:     pOp         - The operation this import is running under
                pFile       - The file to import from
                pPath       - Importing path
                pDoc        - The document to import into
                ShowOptions - Show the export options dialogue.
    Outputs:    -
    Returns:    TRUE for successful export, FALSE if an error occured.
    Purpose:    Base class for handling palette export
    SeeAlso:    Filter::DoImport
********************************************************************************************/
BOOL PaletteFilter::DoExport(Operation* pOp, CCLexFile* pFile,
                             PathName* pPath, Document* pDoc,
                             BOOL ShowOptions)
{
    // For the moment palettes are not exported.
    return FALSE;
}


/********************************************************************************************
>   BOOL PaletteFilter::PrepareForImport()

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/5/96
    Inputs:     -
    Outputs:    -
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Initialises the base class before import
********************************************************************************************/
BOOL PaletteFilter::PrepareForImport()
{
    if (!ImportIntoGallery)
    {
        ERROR2IF(m_pImportDoc==NULL, FALSE, "NULL pointer");

        // Find the colour list document component
        ColourListComponent* pColours = NULL;
        DocComponent *pComponent = m_pImportDoc->EnumerateDocComponents(NULL);
        while (pComponent != NULL)
        {
            // If this is the colour component, remember it
            if (IS_A(pComponent, ColourListComponent))
                pColours = (ColourListComponent*) pComponent;

            // Look for next doc component
            pComponent = m_pImportDoc->EnumerateDocComponents(pComponent);
        }
        ERROR2IF(pColours==NULL, FALSE, "Import document had no colour list");

        // Create a new imported colours manager
        ERROR3IF(m_pNewColours != NULL, "ColourImport manager already present\n");
        if (m_pNewColours != NULL)
        {
            m_pNewColours->DestroyColours();
            delete m_pNewColours;
        }

        m_pNewColours = new ImportedColours(pColours, FALSE);
        if ((m_pNewColours == NULL) || !m_pNewColours->Init())
            return FALSE;
    }

    return TRUE;
}


/********************************************************************************************
>   BOOL PaletteFilter::FinishImport(BOOL Success)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/5/96
    Inputs:     Success - TRUE if import has been successful
    Outputs:    -
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Finialises colour import
********************************************************************************************/
BOOL PaletteFilter::FinishImport(BOOL Success)
{
    BOOL ok = TRUE;

    if (!ImportIntoGallery)
    {
        // If we didn't even get to initialise, then return quietly.
        if (m_pNewColours == NULL)
            return FALSE;

        EndSlowJob();
        BeginSlowJob(-1, FALSE);

        // Import is finished, so add any outstanding colours to the document (if the
        // import was successful), and delete the colour table
        if (Success)
            ok = m_pNewColours->AddColoursToDocument();
        else
            m_pNewColours->DestroyColours();

        // Clean up claimed memory
        delete m_pNewColours;
        m_pNewColours = NULL;
    }

    return ok;
}


/********************************************************************************************
>   BOOL PaletteFilter::ProcessRGBColour(double Red, double Green, double Blue, const StringBase* pColName = NULL)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/5/96
    Inputs:     Red - red value 0..1
                Green - green value 0..1
                Blue - blue value 0..1
                pColName - name to give the colour (NULL if no name)
    Outputs:    -
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Generates a Camelot RGB colour and adds it to the imported colours list
********************************************************************************************/
BOOL PaletteFilter::ProcessRGBColour(double Red, double Green, double Blue, const StringBase* pColName)
{
    // Ensure colour components are in range
    ERROR3IF(Red<0, "Red component less than 0");
    ERROR3IF(Red>1, "Red component greater than 1");
    ERROR3IF(Green<0, "Green component less than 0");
    ERROR3IF(Green>1, "Green component greater than 1");
    ERROR3IF(Blue<0, "Blue component less than 0");
    ERROR3IF(Blue>1, "Blue component greater than 1");
    Red = ClampZeroToOne(Red);
    Green = ClampZeroToOne(Green);
    Blue = ClampZeroToOne(Blue);

    // Make a Camelot RGB colour
    ColourRGBT NewColour;
    NewColour.Red = Red;
    NewColour.Green = Green;
    NewColour.Blue = Blue;
    NewColour.Transparent = 0;

    // Name the colour
    String_64 NewColourName;
    BOOL ok = TRUE;
    if (pColName==NULL || pColName->IsEmpty())
        ok = NameRGBColour(&NewColour, &NewColourName);
    else
        NewColourName = *pColName;      

    if (ok)
    {
        if (ImportIntoGallery)
            ok = AddColourToGallery(PalettePrefix_None, &NewColourName, (ColourGeneric *)&NewColour, COLOURMODEL_RGBT);
        else
            ok = m_pNewColours->AddColour(&NewColourName, &NewColour);
    }

    return ok;
}


/********************************************************************************************
>   BOOL PaletteFilter::ProcessCMYKColour(double Cyan, double Magenta, double Yellow, double Key, const StringBase* pColName = NULL)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    2/5/96
    Inputs:     Cyan - cyan value 0..1
                Magenta - green value 0..1
                Yellow - blue value 0..1
                Key - black value 0..1
                pColName - name to give the colour (NULL if no name)
    Outputs:    -
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Generates a Camelot CMYK colour and adds it to the imported colours list
********************************************************************************************/
BOOL PaletteFilter::ProcessCMYKColour(double Cyan, double Magenta, double Yellow, double Key, const StringBase* pColName)
{
    // Ensure colour components are in range
    ERROR3IF(Cyan<0, "Cyan component less than 0");
    ERROR3IF(Cyan>1, "Cyan component greater than 1");
    ERROR3IF(Magenta<0, "Magenta component less than 0");
    ERROR3IF(Magenta>1, "Magenta component greater than 1");
    ERROR3IF(Yellow<0, "Yellow component less than 0");
    ERROR3IF(Yellow>1, "Yellow component greater than 1");
    ERROR3IF(Key<0, "Key component less than 0");
    ERROR3IF(Key>1, "Key component greater than 1");
    Cyan = ClampZeroToOne(Cyan);
    Magenta = ClampZeroToOne(Magenta);
    Yellow = ClampZeroToOne(Yellow);
    Key = ClampZeroToOne(Key);

    // Make a Camelot CMYK colour
    ColourCMYK NewColour;
    NewColour.Cyan = Cyan;
    NewColour.Magenta = Magenta;
    NewColour.Yellow = Yellow;
    NewColour.Key = Key;

    // Name the colour
    String_64 NewColourName;
    BOOL ok = TRUE;
    if (pColName==NULL || pColName->IsEmpty())
        ok = NameCMYKColour(&NewColour, &NewColourName);
    else
        NewColourName = *pColName;      

    if (ok)
    {
        if (ImportIntoGallery)
            ok = AddColourToGallery(PalettePrefix_None, &NewColourName, (ColourGeneric *)&NewColour, COLOURMODEL_CMYK);
        else
            ok = m_pNewColours->AddColour(&NewColourName, &NewColour);
    }

    return ok;
}


/********************************************************************************************
>   BOOL PaletteFilter::ProcessHSVColour(double Hue, double Sat, double Value, const StringBase* pColName = NULL)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    2/5/96
    Inputs:     Hue - Hue value 0..1
                Sat - Saturation value 0..1
                Value - Brightness value 0..1
                pColName - name to give the colour (NULL if no name)
    Outputs:    -
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Generates a Camelot HSV colour and adds it to the imported colours list
********************************************************************************************/
BOOL PaletteFilter::ProcessHSVColour(double Hue, double Sat, double Value, const StringBase* pColName)
{
    // Ensure colour components are in range
    ERROR3IF(Hue<0, "Hue component less than 0");
    ERROR3IF(Hue>1, "Hue component greater than 1");
    ERROR3IF(Sat<0, "Saturation component less than 0");
    ERROR3IF(Sat>1, "Saturation component greater than 1");
    ERROR3IF(Value<0, "Value component less than 0");
    ERROR3IF(Value>1, "Value component greater than 1");
    Hue = ClampZeroToOne(Hue);
    Sat = ClampZeroToOne(Sat);
    Value = ClampZeroToOne(Value);

    // Make a Camelot HSV colour
    ColourHSVT NewColour;
    NewColour.Hue = Hue;
    NewColour.Saturation = Sat;
    NewColour.Value = Value;
    NewColour.Transparent = 0;

    // Name the colour
    String_64 NewColourName;
    BOOL ok = TRUE;
    if (pColName==NULL || pColName->IsEmpty())
        ok = NameHSVColour(&NewColour, &NewColourName);
    else
        NewColourName = *pColName;      

    if (ok)
    {
        if (ImportIntoGallery)
            ok = AddColourToGallery(PalettePrefix_None, &NewColourName, (ColourGeneric *)&NewColour, COLOURMODEL_HSVT);
        else
            ok = m_pNewColours->AddColour(&NewColourName, &NewColour);
    }

    return ok;
}


/********************************************************************************************
>   BOOL PaletteFilter::ProcessLabColour(double Luminance, double A, double B, const StringBase* pColName = NULL)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/5/96
    Inputs:     Luminance - Luminance value 0..100 (black to white)
                A - a value +127..-128 (green to red)
                B - b value +127..-128 (blue to yellow)
                pColName - name to give the colour (NULL if no name)
    Outputs:    -
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Generates a name for this colour and adds it to the imported colours list
                N.B. Camelot does not support Lab colours so the colour is converted to 
                     RGB or greyscale.
********************************************************************************************/
BOOL PaletteFilter::ProcessLabColour(double Luminance, double A, double B, const StringBase* pColName)
{
    // Ensure colour components are in range
    ERROR3IF(Luminance<0, "Luminance component less than 0");
    ERROR3IF(Luminance>100, "Luminance component greater than 100");
    ERROR3IF(A<-128, "A component less than -128");
    ERROR3IF(A> 127, "A component greater than 127");
    ERROR3IF(B<-128, "B component less than -128");
    ERROR3IF(B> 127, "B component greater than 127");
    Luminance = __min(100, __max(0, Luminance));
    A = __min(127, __max(-128, A));
    B = __min(127, __max(-128, B));

    // Convert to RGB values
    Vector3D Lab(Luminance, A, B);
    Vector3D RGBResult;
    PaletteFilter::ConvertLABToRGB(Lab, &RGBResult);

    return ProcessRGBColour(RGBResult.x, RGBResult.y, RGBResult.z, pColName );
}


/********************************************************************************************
>   BOOL PaletteFilter::ProcessGreyColour(double Intensity, const StringBase* pColName = NULL)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/5/96
    Inputs:     Intensity - 0..1 (black to white)
                pColName - name to give the colour (NULL if no name)
    Outputs:    -
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Generates a Camelot greyscale colour and adds it to the imported colours list
********************************************************************************************/
BOOL PaletteFilter::ProcessGreyColour(double Intensity, const StringBase* pColName)
{
    // Ensure colour components are in range
    ERROR3IF(Intensity<0, "Intensity component less than 0");
    ERROR3IF(Intensity>1, "Intensity component greater than 1");
    Intensity = ClampZeroToOne(Intensity);

    // Make a Camelot greyscale colour
    ColourGreyT NewColour;
    NewColour.Intensity = Intensity;
    NewColour.Reserved1 = 0;
    NewColour.Reserved2 = 0;
    NewColour.Transparent = 0;

    // Name the colour
    String_64 NewColourName;
    BOOL ok = TRUE;
    if (pColName==NULL || pColName->IsEmpty())
        ok = NameGreyColour(&NewColour, &NewColourName);
    else
        NewColourName = *pColName;      

    if (ok)
    {
        if (ImportIntoGallery)
            ok = AddColourToGallery(PalettePrefix_None, &NewColourName, (ColourGeneric *)&NewColour, COLOURMODEL_GREYT);
        else
            ok = m_pNewColours->AddColour(&NewColourName, &NewColour);
    }

    return ok;
}
 

/********************************************************************************************
>   BOOL PaletteFilter::NameRGBColour(ColourRGBT* pColour, StringBase* pName)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    3/5/96
    Inputs:     pColour - the Camelot colour to name
    Outputs:    pName holds the generated name
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Generates a name for this RGB colour
********************************************************************************************/
BOOL PaletteFilter::NameRGBColour(ColourRGBT* pColour, StringBase* pName)
{
    ERROR2IF(pColour==NULL || pName==NULL, FALSE, "NULL Pointer");

    if (UsePercentageColour())
    {
        pName->MakeMsg(_R(IDS_PALETTEIMPORT_RGBPERCENT),
                                (INT32)(pColour->Red.MakeDouble()*100+0.4999),
                                (INT32)(pColour->Green.MakeDouble()*100+0.4999),
                                (INT32)(pColour->Blue.MakeDouble()*100+0.4999) );
    }
    else
    {
        pName->MakeMsg(_R(IDS_PALETTEIMPORT_RGBVALUE),
                                (INT32)(pColour->Red.MakeDouble()*255+0.4999),
                                (INT32)(pColour->Green.MakeDouble()*255+0.4999),
                                (INT32)(pColour->Blue.MakeDouble()*255+0.4999) );
    }

    return TRUE;
}


/********************************************************************************************
>   BOOL PaletteFilter::NameCMYKColour(ColourCMYK* pColour, StringBase* pName)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    3/5/96
    Inputs:     pColour - the Camelot colour to name
    Outputs:    pName holds the generated name
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Generates a name for this CMYK colour
********************************************************************************************/
BOOL PaletteFilter::NameCMYKColour(ColourCMYK* pColour, StringBase* pName)
{
    ERROR2IF(pColour==NULL || pName==NULL, FALSE, "NULL Pointer");
    
    if (UsePercentageColour())
    {
        pName->MakeMsg(_R(IDS_PALETTEIMPORT_CMYKPERCENT),
                                (INT32)(pColour->Cyan.MakeDouble()*100+0.4999),
                                (INT32)(pColour->Magenta.MakeDouble()*100+0.4999),
                                (INT32)(pColour->Yellow.MakeDouble()*100+0.4999),
                                (INT32)(pColour->Key.MakeDouble()*100+0.4999) );
    }
    else
    {
        pName->MakeMsg(_R(IDS_PALETTEIMPORT_CMYKVALUE),
                                (INT32)(pColour->Cyan.MakeDouble()*255+0.4999),
                                (INT32)(pColour->Magenta.MakeDouble()*255+0.4999),
                                (INT32)(pColour->Yellow.MakeDouble()*255+0.4999),
                                (INT32)(pColour->Key.MakeDouble()*255+0.4999) );
    }

    return TRUE;
}


/********************************************************************************************
>   BOOL PaletteFilter::NameHSVColour(ColourHSVT* pColour, StringBase* pName)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    3/5/96
    Inputs:     pColour - the Camelot colour to name
    Outputs:    pName holds the generated name
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Generates a name for this CMYK colour
********************************************************************************************/
BOOL PaletteFilter::NameHSVColour(ColourHSVT* pColour, StringBase* pName)
{
    ERROR2IF(pColour==NULL || pName==NULL, FALSE, "NULL Pointer");
    
    if (UsePercentageColour())
    {
        pName->MakeMsg(_R(IDS_PALETTEIMPORT_HSVPERCENT),
                                (INT32)(pColour->Hue.MakeDouble()*360+0.4999),
                                (INT32)(pColour->Saturation.MakeDouble()*100+0.4999),
                                (INT32)(pColour->Value.MakeDouble()*100+0.4999) );
    }
    else
    {
        pName->MakeMsg(_R(IDS_PALETTEIMPORT_HSVVALUE),
                                (INT32)(pColour->Hue.MakeDouble()*360+0.4999),
                                (INT32)(pColour->Saturation.MakeDouble()*255+0.4999),
                                (INT32)(pColour->Value.MakeDouble()*255+0.4999) );
    }

    return TRUE;
}


/********************************************************************************************
>   BOOL PaletteFilter::NameGreyColour(ColourGreyT* pColour, StringBase* pName)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/5/96
    Inputs:     pColour - the Camelot colour to name
    Outputs:    pName holds the generated name
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Generates a name for this greyscale colour
********************************************************************************************/
BOOL PaletteFilter::NameGreyColour(ColourGreyT* pColour, StringBase* pName)
{
    ERROR2IF(pColour==NULL || pName==NULL, FALSE, "NULL Pointer");

    if (pColour->Intensity.MakeDouble() <= 0.0)
        *pName = String_32(_R(IDS_PALETTEIMPORT_GREYBLACK));
    else if (pColour->Intensity.MakeDouble() >= 1.0)
            *pName = String_32(_R(IDS_PALETTEIMPORT_GREYWHITE));
        else
            pName->MakeMsg(_R(IDS_PALETTEIMPORT_GREYPERCENT), (INT32)(pColour->Intensity.MakeDouble()*100+0.4999));

    return TRUE;
}


/********************************************************************************************
>   BOOL PaletteFilter::UsePercentageColour()

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/5/96
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if the colour editor preference is for percentages, FALSE if not
    Purpose:    To  see wether or not to use the precentage colour naming scheme
********************************************************************************************/
BOOL PaletteFilter::UsePercentageColour()
{
// WEBSTER - markn 24/4/97
#ifdef WEBSTER
    // Always use percentages for colour units in Webster
    return TRUE;
#else
    #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX)
        // Read what the colour editors preference is
        ScaleUnit* pUnit = UnitsTab::GetColourUnitPreference();

        return (pUnit == &StandardUnit::UnitPercent);
    #else
        return FALSE;
    #endif
#endif // WEBSTER
}


/********************************************************************************************
>   BOOL PaletteFilter::StartPercentage(INT32 UpTo = -1)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/5/96
    Inputs:     UpTo - the 100% value
    Outputs:    -
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Starts a percentage delay indicator that runs from 0 to 100.  If you don't
                know how many colours you are importing pass -1 and the length of the file
                is used
********************************************************************************************/
BOOL PaletteFilter::StartPercentage(INT32 UpTo)
{
#if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX)
    if (UpTo == -1)
    {
        if (m_pImportFile != NULL)
            BeginSlowJob(m_pImportFile->Size());
        else
            BeginSlowJob();
    }
    else
        BeginSlowJob(UpTo);
#endif
    return TRUE;
}


/********************************************************************************************
>   BOOL PaletteFilter::SetPercentage(INT32 GotTo)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/5/96
    Inputs:     GotTo - the current position
    Outputs:    -
    Returns:    TRUE for success, FALSE if an error occured.
    Purpose:    Continues a percentage delay indicator.  Pass -1 to use the current import
                file position as a progress indicator.
********************************************************************************************/
BOOL PaletteFilter::SetPercentage(INT32 GotTo)
{
#if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX)
    if (GotTo == -1)
    {
        if (m_pImportFile != NULL)
            ContinueSlowJob(m_pImportFile->tell());
        else
            ContinueSlowJob();
    }
    else
        ContinueSlowJob(GotTo);
#endif
    return TRUE;
}



/********************************************************************************************
>   void PaletteFilter::ConvertXYZToRGB(const Vector3D& icol, Vector3D& ocol)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/04/96
    Inputs:     icon = The (Xn, Yn, Zn) coordinates of the white colour in CIE XYZ space.
    Outputs:    ocol  = RGB colour (0..1)
    Returns:    -
    Purpose:    To convert colours from CIE XYZ to RGB
********************************************************************************************/
void PaletteFilter::ConvertXYZToRGB(const Vector3D& icol, Vector3D& ocol)
{
    // Convert from HDTV Rec709 to RGB
    ocol.x = ( 3.240479*icol.x) + (-1.537150*icol.y) + (-0.498535*icol.z);
    ocol.y = (-0.969256*icol.x) + ( 1.875992*icol.y) + ( 0.041556*icol.z);
    ocol.z = ( 0.055648*icol.x) + (-0.204043*icol.y) + ( 1.057311*icol.z);
    
    ClampZeroToOne(ocol.x);
    ClampZeroToOne(ocol.y);
    ClampZeroToOne(ocol.z);
}



/********************************************************************************************
>   void PaletteFilter::ConvertLABtoXYZ(const Vector3D& white, const Vector3D& icol, Vector3D& ocol)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/04/96
    Inputs:     white = The (Xn, Yn, Zn) coordinates of the white colour in CIE XYZ space.
                icol  = CIE LAB colour
    Outputs:    ocol  = CIE XYZ colour
    Returns:    -
    Purpose:    To convert colours from CIE LUV to CIE XYZ  
********************************************************************************************/
void PaletteFilter::ConvertLABtoXYZ(const Vector3D& white, const Vector3D& icol, Vector3D& ocol)
{
    double d,e;
    static double third = 1.0/3.0;

    if (icol.x < 7.9996248) 
        ocol.y = icol.x * white.y / 903.3;
    else 
        ocol.y = pow((double)((icol.x + 16.0) / 116.0), (double)3.0) * white.y;

    e = pow((double)(ocol.y / white.y), third);
    d = e + (double)(icol.y / 500);
    
    ocol.x = pow(d, (double)3.0) * white.x;

    d = e - (double)(icol.z / 200);
    
    ocol.z = pow(d, (double)3.0) * white.z;
}


/********************************************************************************************
>   void PaletteFilter::ConvertCIEtoXYZ(const Vector3D icol, Vector3D& ocol)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/04/96
    Inputs:     icol = (x,y) is the chromaticity value
                          YY is the corresponding luminance value
    Outputs:    ocol = (X,Y,Z) coordinates in the CIE XYZ space
                        
    Returns:    -
    Purpose:    To convert the given x, y and Y to X, Y and Z in CIE XYZ space
********************************************************************************************/
void PaletteFilter::ConvertCIEtoXYZ(const Vector3D& icol, Vector3D& ocol)
{
    double d = icol.z / icol.y;

    ocol.x = icol.x * d;
    ocol.y = icol.z;
    ocol.z = (1.0 - icol.x - icol.y) * d;
}


/********************************************************************************************
>   void PaletteFilter::ConvertLABToRGB(const Vector3D& icol, Vector3D* ocol)

    Author:     Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/5/96
    Inputs:     icol = (x, y, z) - Lab colour (0..100, -128..127, -128..127)
    Outputs:    ocol = (x, y, z) - RGB colour (0..1, 0..1, 0..1)
    Returns:    -
    Purpose:    To convert the given Lab colour to a (near) equivelent RGB colour
                This uses the above conversion functions from Mike.  They are *not* accurate
                but do give a reasonable approximation of the colour.
********************************************************************************************/
void PaletteFilter::ConvertLABToRGB(const Vector3D& icol, Vector3D* ocol)
{
    // First calculate a XYZ white point
    Vector3D CIEWhite = Vector3D(0.3127, 0.3290, 1.0 );
    Vector3D XYZWhite;
    PaletteFilter::ConvertCIEtoXYZ(CIEWhite, XYZWhite);

    Vector3D LabAsXYZ;
    PaletteFilter::ConvertLABtoXYZ(XYZWhite, icol, LabAsXYZ);

    // Finally convert XYZ to RGB
    Vector3D RGB;
    PaletteFilter::ConvertXYZToRGB(LabAsXYZ, RGB);

    ocol->x = ClampZeroToOne( pow(RGB.x, 1.0/2.5) );
    ocol->y = ClampZeroToOne( pow(RGB.y, 1.0/2.5) );
    ocol->z = ClampZeroToOne( pow(RGB.z, 1.0/2.5) );
}



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

>   BOOL PaletteFilter::AddColourToGallery(PalettePrefix Prefix, String_64 *Name,
                                            ColourGeneric *Definition, ColourModel Model,
                                            BOOL NewlineAfter = FALSE, IsSpotColour = FALSE)
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/8/96
    Inputs:     Prefix - Indicates a standard library prefix which should be prepended
                            to the name (remembering the prefix ID is much better than
                            storing a great long string in every colour)
                Name - the name
                Definition - the colour definition
                Model - The colour model that Definition is given in
                NewlineAfter - TRUE to hint to the colour gallery that it should divide
                the colour items (by starting a new line in the display) in order to
                display them more usefully.

    Returns:    TRUE if it succeeeds

    Purpose:    Sticks the given colour into the colour gallery

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

BOOL PaletteFilter::AddColourToGallery(PalettePrefix Prefix, String_64 *Name,
                                        ColourGeneric *Definition, ColourModel Model,
                                        BOOL NewlineAfter, BOOL IsSpotColour)
{
#if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX)
    if (CurrentGalleryGroup == NULL)
        return(FALSE);

    // Create a new DocColour for this colour
    DocColour NewCol(Model, Definition);
    
    if (Prefix == PalettePrefix_Pantone || Prefix == PalettePrefix_PantoneSpot)
    {
        // Set the "PANTONE bodge" flag which rounds the colour components to the nearest half percent.
        // This gets around errors introduced by storing the 200 possible half-percent values in a 0-255 BYTE
        NewCol.ForceRounding(TRUE);
    }

    SGDisplayLibColour *NewItem = new SGDisplayLibColour(&NewCol, Name, Prefix, NewlineAfter, IsSpotColour);
    if (NewItem == NULL)
        return(FALSE);

    CurrentGalleryGroup->AddItem(NewItem);
#endif
    return(TRUE);
}






/********************************************************************************************
>   CorelPaletteFilter::CorelPaletteFilter()

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15 03 95
    Inputs:     As for the Filter class
    Returns:    As for the Filter class
    Purpose:    Constructor
    SeeAlso:    Filter
********************************************************************************************/
CorelPaletteFilter::CorelPaletteFilter()
{
    // Set up filter descriptions.
    FilterName.Load(_R(IDT_CORELPALETTEFILTER_FILTERNAME));
    FilterInfo.Load(_R(IDT_CORELPALETTEFILTER_FILTERINFO));
    FilterID = FILTERID_CORELPALETTEFILE;

#ifndef STANDALONE
    Flags.CanImport = TRUE;
    Flags.CanExport = FALSE;
#else
    Flags.CanImport = FALSE;
    Flags.CanExport = FALSE;
#endif

#ifndef DO_EXPORT
    Flags.CanExport = FALSE;
#endif

    m_FileVersion = CPL_FVU;
}


/********************************************************************************************
>   BOOL CorelPaletteFilter::Init(void)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15 03 95
    Inputs:     As for the Filter class
    Returns:    As for the Filter class
    Purpose:    Initialisation
    SeeAlso:    Filter
********************************************************************************************/
BOOL CorelPaletteFilter::Init(void)
{
    // Get the OILFilter object
    pOILFilter = new CorelPaletteFileOILFilter(this);
    if (pOILFilter == NULL)
        return FALSE;

    // All ok
    return TRUE;
}


/********************************************************************************************
>   INT32 CorelPaletteFilter::HowCompatible(PathName& Filename, ADDR  HeaderStart,
                                                            UINT32 HeaderSize, UINT32 FileSize)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15 03 95
    Inputs:     As for the Filter class
    Returns:    As for the Filter class
    Purpose:    Examines a file to see how compatable it is with this filter.
    SeeAlso:    Filter
********************************************************************************************/
INT32 CorelPaletteFilter::HowCompatible(PathName& Filename, ADDR  HeaderStart, UINT32 HeaderSize, UINT32 FileSize)
{
PORTNOTE("byteorder", "TODO: Check byte ordering")
    // Check the filetype matches
    if (!pOILFilter->DoesExtensionOfPathNameMatch(&Filename))
        return 0;

    m_FileVersion = CPL_FVU;
    
    // is it a .pal file (textualally based)?
    INT32 result = 0;
    if ((result = HowCompatible4(Filename, HeaderStart, HeaderSize, FileSize)) != 0)
        return result;

    // is it a .cpl file (binary)?
    if ((result = HowCompatible5(Filename, HeaderStart, HeaderSize, FileSize)) != 0)
        return result;

    // it's not a palette file.
    return 0;
}


/********************************************************************************************
>   INT32 CorelPaletteFilter::HowCompatible4(PathName& Filename, ADDR  HeaderStart,
        UINT32 HeaderSize, UINT32 FileSize)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17 03 95
    Inputs:     As for the Filter class
    Returns:    As for the Filter class
    Purpose:    Examines a file to see how compatable it is with this filter - checks for
                version 3 and 4 .pal files (textual CMYK only)
    SeeAlso:    Filter
***************