colcontx.cpp

Go to the documentation of this file.

// $Id: colcontx.cpp 1402 2006-07-04 09:26:38Z 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============================
 */
// colcontx.cpp - ColourContext and derived classes

/*
*/


#include "camtypes.h"

//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "colcontx.h"
#include "colormgr.h"
#include "colourix.h"
#include "colplate.h"
//#include "doccolor.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ensure.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "jason.h"
//#include "view.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "scunit.h"

#if defined(EXCLUDE_FROM_RALPH) || defined(EXCLUDE_FROM_XARALX)
#undef  NO_XARACMS
#define NO_XARACMS
#endif

#ifndef NO_XARACMS
#include "xaracms.h"
#endif

CC_IMPLEMENT_MEMDUMP(ColourContext,         ListItem)
CC_IMPLEMENT_MEMDUMP(ColourContextRGBT,     ColourContext)
CC_IMPLEMENT_MEMDUMP(ColourContextWebRGBT,  ColourContextRGBT)
CC_IMPLEMENT_MEMDUMP(ColourContextCMYK,     ColourContext)
CC_IMPLEMENT_MEMDUMP(ColourContextHSVT,     ColourContext)
CC_IMPLEMENT_MEMDUMP(ColourContextGreyT,    ColourContext)

#define new CAM_DEBUG_NEW

/*  NOTE WELL ALL YE WHO ENTER HERE
 *
 *  If you are implementing a new context class, have a look at the implementation
 *  of RGBT, which is a simple base model. Note that you may also find it useful
 *  to look at CMYK, as it overrides the ConvertColourInternal to do special stuff.
 */



/*  DefaultColourContexts
 *
 *  This is a 'global' array of default colour contexts for each of the
 *  possible 16 colour models Camelot can support. When defining/converting 
 *  colours, a default colour context is implicitly specified, if no colour
 *  context is given.
 *  Access is via the static function ColourContext::GetDefault()
 */

ColourContextArray ColourContext::GlobalDefaultContext = 
{
    { NULL, NULL, NULL, NULL,
    NULL, NULL, NULL, NULL,
    NULL, NULL, NULL, NULL,
    NULL, NULL, NULL, NULL }
};



/* NextColourContextHandle 
 *
 * This variable keeps track of the current handle - each colour context must have a 
 * unique handle - this is used in colour caches to identify the context in which
 * they are currently cached, so that they know when the cache is invalid.
 */

ColourContextHandle ColourContext::NextColourContextHandle = 1;




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

>   void ColourContext::ColourContext(View *Scope)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Inputs:     Scope - The view within which this context is to be used, or NULL
                for a global (non-view-specific) context
    Outputs:    -
    Returns:    -
    Purpose:    Constructor for a Colour context. This is shared code used by
                all derived ColourContextXXXX classes. You cannot create
                vanilla ColourContext objects (virtual functions abound)

    Notes:      The usage count for a colour context defaults to 0
                ("not in use"). When using colour contexts, you should always
                register them with the global ColContextList object (see
                ColourContextList::AddContext for details)

                When created, relevant conversion parameters (gamma correction
                etc) are passed in to the constructor.The context stores these
                parameters so it can quickly compare itself to another context,
                but it may defer creation of tables and other essential stuff 
                until the Init() function is called (when it is added to the
                list of available colour contexts). Nobody but the context list
                can call the Init() function.

                The passed-in Scope may be NULL, in which case global scope is
                used. However, if you're using this within the scope of any
                view, note that you must set up ScopeView properly or colour
                separated output of some colour models will be incorrect.

    Errors:     -
    SeeAlso:    ColourContextRGBT::ColourContextRGBT;
                ColourContextCMYK::ColourContextCMYK;
                ColourContextHSVT::ColourContextHSVT;
                ColourContextList::AddContext

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

ColourContext::ColourContext(View *Scope)
{
    MyHandle = NextColourContextHandle++;

    ScopeView = Scope;

    UsageCount = 0;

    ColPlate = NULL;

PORTNOTE("other","Removed HCMTRANSFORM usage")
#ifndef EXCLUDE_FROM_XARALX
    CMSTransform = NULL;
#endif
    // ColourModel and Model-specific data must be dealt with in the 
    // constructor/Init() for the derived ColourContextXXXX class
}



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

>   void ColourContext::~ColourContext(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94

    Purpose:    Colour context destructor

    Notes:      This destroys any attached ColourPlate descriptor

    SeeAlso:    ColourContextList::AddContext

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

ColourContext::~ColourContext()
{
    ENSURE(UsageCount == 0, "ColourContext deleted while still in use!");

    if (ColPlate != NULL)
    {
        delete ColPlate;
        ColPlate = NULL;
    }

#ifndef NO_XARACMS
    if (CMSTransform != NULL)
    {
        if (GetApplication()->GetCMSManager() != NULL)
            GetApplication()->GetCMSManager()->DestroyTransform(CMSTransform);
        CMSTransform = NULL;
    }
#endif
}



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

>   BOOL ColourContext::Init(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/04/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if it succeeds
                FALSE if it fails (and it'll set an error description)
    Purpose:    Colour context initialiser. This is called by the ColourContextList
                when it wishes to add a context to the list, and makes the context
                ready for use. This allows the list to compare contexts, and only
                initialise a given context when it knows the initialisation is
                absolutely necessary (e.g. allocating a large chunk of memory or 
                calculating a complex table is avoided until we are sure there are
                no equivalent contexts already available)
                This function is overridden by colour contexts which actually need to
                do some initialisation other than just storing a few values away.
    Errors:     -
    SeeAlso:    ColourContextList::AddContext

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

BOOL ColourContext::Init(void)
{
    ENSURE(UsageCount == 0, "ColourContext initialised when in use?!?!");

    IncrementUsage();   // We are now in use. UsageCount is now 1
    return(TRUE);       // Initialisation succeeded
}



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

>   void ColourContext::DecrementUsage(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if the object is still in use
    Purpose:    Decrements usage-count for a colour context. This count allows us to
                determine when we can delete unused contexts.

    Notes:      The usage count for a colour context defaults to 0
                ("not in use"). When using colour contexts, you should always
                register them with the global ColContextList object (see
                ColourContextList::AddContext for details)

    Errors:     ENSURE fails if the usage count goes negative, indicating the context
                is being 'released' more times than it is 'claimed'.
    SeeAlso:    ColourContext::IncrementUsage; ColourContextList::AddContext

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

BOOL ColourContext::DecrementUsage(void)
{
    ENSURE(UsageCount > 0, "ColourContext::DecrementUsage - Usage count is negative!");
    return((--UsageCount) != 0);
}



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

>   virtual void ColourContext::PackColour(ColourGeneric *Source, ColourPacked *Result)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Inputs:     Source - A ColourGeneric structure defining the colour in the model
                pertaining to this colour context.
                Result - A Packed colour structure in the same model, into which the result
                is copied.

    Outputs:    -
    Returns:    -
    Purpose:    Converts 128-bit colour representation to 32-bit packed form

    Notes:      This function operates on the colour using a generic component pattern
                Colours such as ColourHSVT do not conform to this pattern and thus must
                be unpacked with derived methods (ColourContextHSVT::UnpackColour)
                However, this function will work on any 4-component model which uses 8bits
                and 32-bits respectively for all 4 components, and the same 8.24 fixedpoint
                32-bit representation. 

    Scope:      Private (used internally by friend class DocColour)
    Errors:     -
    SeeAlso:    ColourContext::UnpackColour

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

void ColourContext::PackColour(ColourGeneric *Source, ColourPacked *Result)
{
    PColourGeneric *bob = (PColourGeneric *) Result;

    bob->Component1 = PackColour256(Source->Component1);
    bob->Component2 = PackColour256(Source->Component2);
    bob->Component3 = PackColour256(Source->Component3);
    bob->Component4 = PackColour256(Source->Component4);
}




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

>   virtual void ColourContext::UnpackColour(ColourPacked *Source, ColourGeneric *Result)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Inputs:     Source - A Packed Colour structure defining the colour in the model
                pertaining to this colour context.
                Result - A ColourGeneric structure in the same model, into which the 
                result is copied.
    Outputs:    -
    Returns:    -
    Purpose:    Converts 32-bit packed colour representation to 128-bit form

    Notes:      This function operates on the colour using a generic component pattern
                Colours such as ColourHSVT do not conform to this pattern and thus must
                be unpacked with derived methods (ColourContextHSVT::UnpackColour)
                However, this function will work on any 4-component model which uses 8bits
                and 32-bits respectively for all 4 components, and the same 8.24 fixedpoint
                32-bit representation. 

    Scope:      Private (used internally by friend class DocColour)
    Errors:     -
    SeeAlso:    ColourContext::PackColour

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

void ColourContext::UnpackColour(ColourPacked *Source, ColourGeneric *Result)
{
    PColourGeneric *bob = (PColourGeneric *) Source;

    UnpackColour256(bob->Component1, &Result->Component1);
    UnpackColour256(bob->Component2, &Result->Component2);
    UnpackColour256(bob->Component3, &Result->Component3);
    UnpackColour256(bob->Component4, &Result->Component4);
}



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

>   virtual BOOL ColourContext::IsDifferent(ColourContext *Other) const

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/04/94
    Inputs:     Other - a colour context to compare ourselves to
    Outputs:    -
    Returns:    TRUE if the other colour context object is different from
                ourself, or FALSE if it is an exactly equivalent context.
    Purpose:    Determine if two colour contexts are not exactly equivalent
    Errors:     -
    SeeAlso:    -

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


BOOL ColourContext::IsDifferent(ColourContext *Other) const
{
    if (Other == this)
        return(FALSE);                      // Different object? (Nope)

    if (Other->ScopeView != ScopeView)
        return(TRUE);                       // Different Scope Views?

    return(Other->ColModel != ColModel);    // Different Colour Model?
}




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

>   virtual void ColourContext::ConvertColourBase(ColourContext *SourceContext,
                                            ColourGeneric *Source, ColourGeneric *Result
                                            IndexedColour *SourceIxCol = NULL)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Inputs:     SourceContext - The context in which the source is defined 

                Source - A ColourGeneric to convert

                Result - A ColourGeneric structure to recieve the resulting converted colour,
                as defined in this ColourContext.

                SourceIxCol - NULL, or a pointer to the IndexedColour we are converting.
                This is used only for handling spot colour separations, to determine if
                the colour is a given spot colour or tint thereof.

    Outputs:    Result - will be returned with the converted colour

    Purpose:    Converts a Colour into this colour context, from the default colour context
                implied by the given colour model
                Post-processing (as described by the attached ColourPlate object) will
                be applied to generate colour separations (etc) as required.

                The converted colour will be supplied from a cache where possible

    Notes:      It is up to the caller to update caches etc if necessary
                This is used as a base on which ConvertColourInternal methods are built

                ColourContextCMYK overrides this base class method to provide direct
                passthrough of CMYK colours into a CMYK output context. (passthrough
                otherwise only occurs if the source & destination contexts are the
                same object)

    Scope:      private to colcontx.cpp
    Errors:     -
    SeeAlso:    ColourContext::ConvertColour

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

void ColourContext::ConvertColourBase(ColourContext *SourceContext,
                                        ColourGeneric *Source, ColourGeneric *Result,
                                        IndexedColour *SourceIxCol)
{
#ifndef NO_XARACMS
    // Last minute bodge for Composite preview of CMYK colours in RGB space
    // This is done here cos it's much faster, and gets around pre/post filter problems
    // with CMYK colours which aren't IndexedColours (like intermediate blend/gradfill DocColours)
    if (ColPlate != NULL && ColPlate->GetType() == COLOURPLATE_COMPOSITE &&
        GetColourModel() == COLOURMODEL_RGBT &&
        SourceContext->GetColourModel() == COLOURMODEL_CMYK)
    {
        // If it's a CMYK colour, then it's already in printer gamut, so we only apply
        // the backward colour correction factor to it.
        // Note that this means we chuck away the normal colour conversion system!
        XaraCMS* lpCMSMan = GetApplication()->GetCMSManager();
        if (lpCMSMan != NULL)
        {
            ColourCMYK Def;
            memcpy(&Def, Source, sizeof(ColourGeneric));

            lpCMSMan->ConvertColourForPaperView(&Def, (ColourRGBT *) Result);
            return;
        }
    }
#endif

    // Copy the source colour into a temporary variable
    ColourGeneric FilteredSource;
    memcpy(&FilteredSource, Source, sizeof(ColourGeneric));

    // Call the SourceContext to allow it to pre-filter the colour. This is used to
    // provide colour separations and other doody features when converting CMYK colours
    // - when converting non-CMYK colours, this is usually done in the OutputFilter (below)
    if (ColPlate != NULL && !ColPlate->IsDisabled())
        SourceContext->ApplyInputFilter(ColPlate, this, &FilteredSource, SourceIxCol);

    // -----
    // Call levels expected:
    //  1 inline ConvertColour checks if can satisfy from cache
    //  2 function ConvertColourInternal does any short cuts it can, such
    //    as CMYK->CMYK passthrough
    //  3 Call ConvertColourBase, which
    //      a) Checks if in same colour model, and implements passthrough, or
    //      b) Converts colour properly via CIET space

    if (SourceContext == this)
    {
        // The SourceContext and Destination context are identical, so we can
        // just copy the definition directly across.
        memcpy(Result, &FilteredSource, sizeof(ColourGeneric));
    }
    else
    {
        DColourCIET IntermediateResult;

        SourceContext->ConvertToCIET(&FilteredSource, &IntermediateResult);
        ConvertFromCIET(&IntermediateResult, Result);
    }


    // Call the DestinationContext (derived class of this) to apply any output filtering -
    // non-CMYK colour conversions will separate the colour (as appropriate) here
    if (ColPlate != NULL && !ColPlate->IsDisabled())
        ApplyOutputFilter(ColPlate, SourceContext, Result, SourceIxCol);
}




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

>   void ColourContext::ConvertColourInternal(DocColour *Source, ColourGeneric *Result)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Inputs:     Source - A Colour to convert
                Result - A ColourGeneric structure to recieve the resulting converted colour,
                as defined in this ColourContext.
    Outputs:    -
    Returns:    -
    Purpose:    Converts a Colour into this colour context.
                The converted colour will be supplied from a cache where possible

    Notes:      This is used internally. It is only called by the inlined conversion
                functions if they fail to return a cached result
    Errors:     -
    SeeAlso:    ColourContext::ConvertColour

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

void ColourContext::ConvertColourInternal(DocColour *Source, ColourGeneric *Result)
{
    if (Source->Info.SourceColourModel == COLOURMODEL_INDEXED)
    {
        IndexedColour *SrcIndexed = Source->SourceColour.Indexed.Colour;

        // Convert the indexed colour to our context
        ConvertColour(SrcIndexed, Result);

        // If IndexedColour, we do NOT want the colour cached at the DocColour
        // level (else if the IxCol changes, we'd have to search for all related
        // DocCols to fix their caches... erg!)
        return;
    }

    // Unpack the 32-bit colour into a 128-bit structure, and then invoke the
    // shared internal conversion routine.
    ColourGeneric SourceDefn;

    // If this DocColour should not be separated (it's a UI colour), then disable
    // any active colour plate to stop it separating the output - we'll save and restore
    // its previous state around the call to ConvertColourBase
    BOOL WasDisabled = TRUE;
    if (ColPlate != NULL)
    {
        WasDisabled = ColPlate->IsDisabled();
        ColPlate->SetDisabled(!Source->IsSeparable());
    }

        // Check if we're doing a spot colour plate. We either get the colour's source colour,
        // or if it shouldn't appear on the plate, we get White.
        if (ColPlate != NULL && !ColPlate->IsDisabled() && ColPlate->GetType() == COLOURPLATE_SPOT)
        {
            // We're doing a SPOT colour plate, but this colour is a local DocColour, so
            // it cannot possibly be a tint on this plate, so we just return white.
            GetGlobalDefault(Source->GetColourModel())->GetWhite(&SourceDefn);
        }
        else
        {
            // Unpack the colour
            GetGlobalDefault(Source->GetColourModel())->UnpackColour(&Source->SourceColour, &SourceDefn);
        }

        // Assume that the source context is a global default. Generally, this should be true,
        // as all source colours should be defined in terms of logical colour models.
        ConvertColourBase(GetGlobalDefault(Source->GetColourModel()),
                            &SourceDefn, Result);

    // And restore the previous ColourPlate "disabled" state
    if (ColPlate != NULL)
        ColPlate->SetDisabled(WasDisabled);

    PackColour(Result, &Source->CachedColour);  // And update the cache

    // Update cache flags - I am the context in which the cache is defined
    Source->Info.OCContextHandle  = MyHandle;
    Source->Info.CacheColourModel = ColModel;
}



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

>   void ColourContext::ConvertColourInternal(DocColour *Source, ColourPacked *Result)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    14/04/94
    Inputs:     Source - A Colour to convert
                Result - A PColourGeneric structure to recieve the resulting converted colour,
                as defined in this ColourContext.
    Outputs:    -
    Returns:    -
    Purpose:    Converts a Colour into this colour context.
                The converted colour will be supplied from a cache where possible (this check
                is made by the caller function ConvertColour)
    Scope:      PRIVATE - for use only by 'friend' rendering classes:
                    OSRenderRegion, GRenderRegion
    Errors:     -
    SeeAlso:    ColourContext::ConvertColour

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

void ColourContext::ConvertColourInternal(DocColour *Source, ColourPacked *Result)
{
    ColourGeneric NewResult;
    ConvertColourInternal(Source, &NewResult);  // Convert

    PackColour(&NewResult, Result);             // Pack the colour into Result...

    if (Source->Info.SourceColourModel != COLOURMODEL_INDEXED)
    {
        // And (if not an IndexedColour) update the cache
        Source->Info.OCContextHandle  = MyHandle;
        Source->Info.CacheColourModel = ColModel;
        memcpy(&Source->CachedColour, Result, sizeof(ColourPacked));
    }
}



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

>   void ColourContext::ConvertColour(IndexedColour *Source, ColourGeneric *Result)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Inputs:     Source - An IndexedColour to convert
                Result - A ColourGeneric structure to recieve the resulting converted colour,
                as defined in this ColourContext.
    Outputs:    -
    Returns:    -
    Purpose:    Converts an indexed colour into this colour context.
                The converted colour will be supplied from a cache where possible
    Errors:     -
    SeeAlso:    -

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

void ColourContext::ConvertColour(IndexedColour *Source, ColourGeneric *Result)
{
    ENSURE(UsageCount > 0, "Colour context being used when not initialised!");

    if (Source->Info.OCContextHandle != MyHandle)   // Uncached so convert it into the cache
    {
        // Ask the colour to get its source colour for us. If this is a Linked/Tint colour,
        // this could well involve getting another colour's definition, converting it, and
        // generally giving us an extended tour of stack city.
        ColourGeneric SourceColour;
        Source->GetSourceColour(&SourceColour);

        // Check if we're doing a spot colour plate. We either get the colour's source colour,
        // or if it shouldn't appear on the plate, we get White.
        if (ColPlate != NULL && !ColPlate->IsDisabled())
        {
            switch(ColPlate->GetType())
            {
                case COLOURPLATE_SPOT:
                    // If we're doing a spot plate and this isn't a descendant of the spot colour
                    // then we must eliminate it from this plate. We must also check that it's a "true"
                    // spot/tint, as opposed to a tint which is really a process colour.
                    if ((!Source->IsADescendantOf(ColPlate->GetSpotColour())) ||
                        (!Source->IsSpotOrTintOfSpot()))
                    {
                        // Fill it with whatever White is defined as in the source context
                        GetGlobalDefault(Source->GetColourModel())->GetWhite(&SourceColour);
                    }
                    break;

                case COLOURPLATE_CYAN:
                case COLOURPLATE_MAGENTA:
                case COLOURPLATE_YELLOW:
                case COLOURPLATE_KEY:
                    // If we're doing a process plate, eliminate any spot colours (or tints) from it
                    if (Source->IsSpotOrTintOfSpot())
                    {
                        // Fill it with whatever White is defined as in the source context
                        GetGlobalDefault(Source->GetColourModel())->GetWhite(&SourceColour);
                    }
                    break;
                default:
                    break;
            }
        }

        ConvertColourBase(GetGlobalDefault(Source->GetColourModel()),
                            &SourceColour, &Source->CachedColour,
                            Source);

        Source->Info.OCContextHandle  = MyHandle;
        Source->Info.CacheColourModel = ColModel;
    }

    // Copy the result from our cache
    memcpy(Result, &Source->CachedColour, sizeof(ColourGeneric));
}



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

>   void ColourContext::ConvertColour(ColourContext *SourceContext,
                                        ColourGeneric *SourceColour,
                                        ColourGeneric *Result)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Inputs:     SourceContext - The colour context in which the Source Colour is defined
                Source - A ColourGeneric structure defining a colour to convert, in the
                given SourceContext
                Result - A ColourGeneric structure to recieve the resulting converted colour,
                as defined in this ColourContext.
    Outputs:    -
    Returns:    -
    Purpose:    Converts a colour in any arbitrary colour context into this colour context.
                The converted colour will be supplied from a cache where possible
    Errors:     -
    SeeAlso:    -

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

void ColourContext::ConvertColour(ColourContext *SourceContext,
                                    ColourGeneric *SourceColour,
                                    ColourGeneric *Result)
{
    ENSURE(UsageCount > 0, "Colour context being used when not initialised!");

    // This may look like an opportunity for optimisation, but
    // ConvertColourBase is actually an inline function
    ConvertColourBase(SourceContext, SourceColour, Result);
}



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

>   virtual void ColourContext::CreateExternalTransform(void)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/05/96
    Inputs:     -
    Returns:    -
    Purpose:    Create an external transform to be used during colour conversions from
                RGB to the current RCS space. This function uses the Winoil CMS Manager
                to create the transform. Both forward and backward transforms use logical
                RGB descriptions.

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

void ColourContext::CreateExternalTransform()
{
    // We do nothing here. If no one creates an external transform, the default
    // internal one will be used. To create an external transform, call the derived class
    // function, not this one as you can see it does nothing.
}


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

>   virtual void ColourContext::ApplyInputFilter(ColourPlate *FilterDescription,
                                                    ColourContext *DestContext,
                                                    ColourGeneric *OutputColour,
                                                    IndexedColour *SourceIxCol);

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/1/96
    Inputs:     FilterDescription - A ColourPlate describing how the colour is to be filtered
    
                DestContext - Points to the context to which the OutputColour will be
                converted after we return it.

                OutputColour - The colour to be filtered

                SourceIxCol - NULL, or the original IndexedColour which is being converted.
                This is used for handling spot colour separation correctly.

    Outputs:    OutputColour - Will be modified as appropriate to the current colour
                filtering options (see Purpose)

    Purpose:    All colour conversions call this function for the SOURCE context
                immediately before converting the colour. This gives the input colour
                context the chance to apply a filtering process to the colour.

                This is usually used to provide colour separations. Often, this function
                will do nothing to the output colour - generally it is only used by CMYK
                contexts in order to colour-separate the colour in CMYK space.

    SeeAlso:    ColourContext::ConvertColourBase

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

void ColourContext::ApplyInputFilter(ColourPlate *FilterDescription, ColourContext *DestContext,
                                            ColourGeneric *OutputColour, IndexedColour *SourceIxCol)
{
//  ERROR3IF(FilterDescription == NULL || DestContext == NULL || OutputColour == NULL, "Illegal NULL params");
//
//  if (FilterDescription == NULL)
//      return;
//
}



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

>   virtual void ColourContext::ApplyOutputFilter(ColourPlate *FilterDescription,
                                                    ColourContext *SourceContext,
                                                    ColourGeneric *OutputColour,
                                                    IndexedColour *SourceIxCol);

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/1/96
    Inputs:     FilterDescription - A ColourPlate describing how the colour is to be filtered
    
                SourceContext - Points to the context from which the OutputColour has just
                been converted. 

                OutputColour - The colour to be filtered

                SourceIxCol - NULL, or the IndexedColour which was the source of the colour
                being converted. This is only used for information when preparing spot colour
                separations.

    Outputs:    OutputColour - Will be modified as appropriate to the current colour
                filtering options (see Purpose)

    Purpose:    All colour conversions call this function for the DEST context immediately
                prior to returning the converted colour to the caller. This gives the output
                colour context the chance to apply an output filtering process to the output
                colour.

                This is usually used to provide colour separations, and may also be used
                to apply some colour corrections. Often, this function will do nothing
                to the output colour.

    SeeAlso:    ColourContext::ConvertColourBase

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

void ColourContext::ApplyOutputFilter(ColourPlate *FilterDescription, ColourContext *SourceContext,
                                            ColourGeneric *OutputColour, IndexedColour *SourceIxCol)
{
//  ERROR3IF(FilterDescription == NULL || SourceContext == NULL || OutputColour == NULL, "Illegal NULL params");
//
//  if (FilterDescription == NULL)
//      return;
}



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

>   void ColourContext::SetColourPlate(ColourPlate *NewColourPlate)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/01/96
    Inputs:     NULL (to disable colour seps), or points to the new ColourPlate descriptor object
                NOTE that the ColourPlate object now belongs to the ColourContext, and will be
                deleted by the context when it is finished with it.

    Purpose:    Sets a colour separation/plate for this context

    Notes:      The ColourPlate object now belongs to the ColourContext, and will be
                deleted by the context when it is finished with it.

                (To remove the ColourPlate again in a way that does not delete the ColourPlate,
                call ColourContext::DetachColourPlate rather than SetColourPlate(NULL))

                The Context's cache handle will be changed so that all cached colours
                in this output context are effectively 'flushed'.

    SeeAlso:    ColourPlate; ColourContext::ApplyOutputFilter; ColourContext::GetColourPlate;
                ColourContext::DetachColourPlate

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

void ColourContext::SetColourPlate(ColourPlate *NewColourPlate)
{
    // Trying to set ColourPlate to the one we're already using - ignore them!
    if (ColPlate == NewColourPlate)
        return;

    // Delete our current ColourPlate
    if (ColPlate != NULL)
    {
        delete ColPlate;
        ColPlate = NULL;
    }

    // Remember our new ColourPlate filter descriptor
    ColPlate = NewColourPlate;

    // Change our context handle so that all cached colours in this context
    // are effectively "flushed"
    ColourPlateHasChanged();
}



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

>   ColourPlate *ColourContext::DetachColourPlate(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/6/96

    Returns:    The pointer to the previously attached ColourPlate (may be NULL)

    Purpose:    Detaches the ColourPlate (if any) currently attached to this ColourContext.
                The context will no longer use the colour plate descriptor, and will return
                to default colour separation/correction actions.
                
                ** The caller is now responsible for deleting the returned object **

    Notes:      The Context's cache handle will be changed so that all cached colours
                in this output context are effectively 'flushed'.

    SeeAlso:    ColourPlate; ColourContext::GetColourPlate; ColourContext::SetColourPlate

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

ColourPlate *ColourContext::DetachColourPlate(void)
{
    ColourPlate *OldColourPlate = ColPlate;

    if (ColPlate != NULL)
    {
        ColPlate = NULL;

        // Change our context handle so that all cached colours in this context
        // are effectively "flushed"
        ColourPlateHasChanged();
    }

    return(OldColourPlate);
}



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

>   ColourPlate *ColourContext::GetColourPlate(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/01/96

    Returns:    NULL if Colour separation is disabled on this context, else a pointer
                to a ColourPlate descriptor object which describes the current colour
                separation/filtering options.

    Purpose:    Reads the colour separation/plate for this context

    SeeAlso:    ColourPlate; ColourContext::ApplyOutputFilter; ColourContext::SetColourPlate

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

ColourPlate *ColourContext::GetColourPlate(void)
{
    return(ColPlate);
}



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

>   void ColourContext::ColourPlateHasChanged(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    9/5/96

    Purpose:    Effectively flushes the caches of all colours currently cached in this
                ColourContext, so that on the next redraw they will re-convert. 

    Notes:      This is achieved by generating a new unique handle for this Context.
                Note that after 65536 handles, we will start re-using handles, and
                things will look bad if we inadvertently use the same handle for 2
                contexts. This is an extremely unlikely occurrence, but please do
                not call this function unless it is absolutely necessary, to minimise
                the number of handle changes that occur.

                This function is automatically called whenever you change the
                ColourPlate attached to this context in any way.

    Scope:      Intended as an internal routine; also called by ColourPlate class
                Should not be called by anyone else

    SeeAlso:    ColourContext::SetColourPlate; IndexedColour; DocColour

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

void ColourContext::ColourPlateHasChanged(void)
{
    // We need to change this context's "MyHandle" so that all cached colours for this
    // context are treated as non-cached again, and will be converted correctly for
    // the new output filter.
    MyHandle = NextColourContextHandle++;
}



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

>   virtual BOOL ColourContext::SetComponentUnitGroup(UINT32 ComponentID,
                                                        UnitGroup* pComponentUnitGroup)
    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    02/05/96          
    Inputs:     ComponentIndex : the number of the component (1..GetComponentCount())
                ComponentUnitGroup : pointer to the required UnitGroup for the component 
    Outputs:    -
    Returns:    TRUE if set OK
                FALSE otherwise
    Purpose:    Allows the UnitGroup of the given component in the ColourModel to be set
    Errors:     ERROR2IF ComponentIndex < 1 or greater than number of components in model

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

BOOL ColourContext::SetComponentUnitGroup(UINT32 ComponentID, UnitGroup* pComponentUnitGroup)
{
    ERROR2IF(ComponentID < 1 || ComponentID > GetComponentCount(), FALSE, "Invalid Index");
    ERROR2IF(pComponentUnitGroup == NULL, FALSE, "Invalid UnitGroup");

    ERROR3IF(!pComponentUnitGroup->IS_KIND_OF(UnitGroup), "Invalid UnitGroup");

    UnitGroup** pUnitGroupArray = GetComponentUnitGroups();
    ERROR3IF(!(pUnitGroupArray[ComponentID - 1]->IS_KIND_OF(UnitGroup)), 
                "ColourContext::GetComponentUnitGroup - Not UnitGroup array");

    pUnitGroupArray[ComponentID - 1] = pComponentUnitGroup;
    return TRUE;
}



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

>   virtual UnitGroup *ColourContext::GetComponentUnitGroup(UINT32 ComponentID)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    02/05/96          
    Inputs:     ComponentID - the number of the component (1..GetComponentCount())
    Outputs:    -
    Returns:    A pointer to the desired UnitGroup
    Purpose:    Provides the UnitGroup of the given component in the ColourModel
    Errors:     ERROR2IF ComponentIndex < 1 or greater than number of components in model
    See Also:   ColourContextCMYK::GetComponentUnitGroups()
                ColourContextGreyT::GetComponentUnitGroups()
                ColourContextHSVT::GetComponentUnitGroups()
                ColourContextRGBT::GetComponentUnitGroups()

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

UnitGroup *ColourContext::GetComponentUnitGroup(UINT32 ComponentID)
{
    ERROR2IF(ComponentID < 1 || ComponentID > GetComponentCount(), FALSE, "Invalid ID");
    UnitGroup** pUnitGroupArray = GetComponentUnitGroups();
    ERROR3IF(!(pUnitGroupArray[ComponentID - 1]->IS_KIND_OF(UnitGroup)), 
                "ColourContext::GetComponentUnitGroup - Not UnitGroup array");

    return pUnitGroupArray[ComponentID - 1];
}


















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

>   void ColourContextRGBT::ColourContextRGBT(View *Scope, double GammaValue = 1.0)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Inputs:     Scope - The view in which this context is to be used, or NULL
                GammaValue - A gamma-correction gamma factor. You know... Gamma.
                Heck, if you don't know what a gamma value is, then don't pass
                anything in, because it has a good default value.
    Outputs:    -
    Returns:    -
    Purpose:    Constructor for an RGBT Colour context

    Notes:      Colour Contexts should not be created and used directly. See the
                notes in the SeeAlso's for instructions on proper care and use.

    Errors:     -
    SeeAlso:    ColourContext::ColourContext; ColourContextList::AddContext

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

ColourContextRGBT::ColourContextRGBT(View *Scope, double GammaValue)
                  : ColourContext(Scope)
{
    ColModel = COLOURMODEL_RGBT;
    Gamma = GammaValue;

    CreateExternalTransform();
}



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

>   ColourContextWebRGBT::ColourContextWebRGBT(View *Scope, double GammaValue)
                  : ColourContextRGBT(Scope, GammaValue)

    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com>
    Created:    ??/11/99
    Inputs:     Scope - The view in which this context is to be used, or NULL
                GammaValue - A gamma-correction gamma factor. You know... Gamma.
                Heck, if you don't know what a gamma value is, then don't pass
                anything in, because it has a good default value.
    Outputs:    -
    Returns:    -
    Purpose:    Constructor for an RGBT Web Colour context

    Notes:      Colour Contexts should not be created and used directly. See the
                notes in the SeeAlso's for instructions on proper care and use.

    Errors:     -
    SeeAlso:    ColourContext::ColourContext; ColourContextList::AddContext

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

ColourContextWebRGBT::ColourContextWebRGBT(View *Scope, double GammaValue)
                  : ColourContextRGBT(Scope, GammaValue)
{
    ColModel = COLOURMODEL_RGBT;
}



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

>   void ColourContextRGBT::CreateExternalTransform(void)

    Author:     Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/05/96
    Inputs:     -
    Returns:    -
    Purpose:    Create an external transform to be used during colour conversions from
                RGB to the current RCS space. This function uses the Winoil CMS Manager
                to create the transform. Both forward and backward transforms use logical
                RGB descriptions.

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

void ColourContextRGBT::CreateExternalTransform()
{
#ifndef NO_XARACMS
    CMSColourSpace cmsSpace;
    XaraCMS* lpCMSMan = GetApplication()->GetCMSManager();

    if (lpCMSMan != NULL)
    {
        // first read our internal colour calibration space
        lpCMSMan->GetLogicalProfile(&cmsSpace);

        // set this as the active colour profile
        UINT32 err = lpCMSMan->SetProfile(cmsSpace);

        // if we haven't got an error, create that transform
        if (err==0)
            CMSTransform = lpCMSMan->CreateTransform(DISPLAY_RCS);
    }
#endif
}


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

>   void ColourContextRGBT::ConvertToCIET(ColourGeneric *Source, DColourCIET *Result)

    Author:     Jason_