sgcolour.cpp

Go to the documentation of this file.

// $Id: sgcolour.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============================
 */
// SGColour.cpp - Colour SuperGallery classes - ColourSGallery and SGDisplayColour

#include "camtypes.h"

//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ccfile.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "colcomp.h"
#include "collist.h"
#include "colourix.h"
#include "colormgr.h"
#include "colpick.h"
#include "comattrmsg.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "dragcol.h"
#include "dragmgr.h"
#include "fileutil.h"
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "filters.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "galres.h"
//#include "galstr.h"
//#include "isetres.h"
//#include "jason.h"
#include "lineattr.h"
//#include "markn.h"
//#include "newcol.h"
//#include "resdll.h"
//#include "resource.h" // For _R(IDS_CANCEL)
#include "sgcolour.h"
#include "sgdrag.h"
#include "sginit.h"
#include "sgliboil.h"
#include "sgmenu.h"

#include "ccdc.h"       // For render-into-dialogue support
//#include "fillval.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "grnddib.h"
//#include "richard2.h" // resources to remove naughty inline strings
#include "ccolbar.h"    // EnsureLibraryColoursPresent
#include "backgrnd.h"   // OpBackground

// WEBSTER - markn 31/1/97
#include "helpuser.h"
//#include "xshelpid.h"
//#include "helppath.h"

// Implement the dynamic class bits...
CC_IMPLEMENT_DYNCREATE(ColourSGallery, SuperGallery)
CC_IMPLEMENT_DYNAMIC(SGDisplayColour, SGDisplayItem)
CC_IMPLEMENT_DYNAMIC(SGDisplayLibColour, SGDisplayColour)
CC_IMPLEMENT_DYNAMIC(SGDisplayColourGroup, SGDisplayGroup)
CC_IMPLEMENT_DYNAMIC(SGDisplayLibColGroup, SGDisplayColourGroup)
CC_IMPLEMENT_DYNCREATE(OpDisplayColourGallery, Operation)
CC_IMPLEMENT_DYNCREATE(GalleryColourDragInfo, ColourDragInformation)
CC_IMPLEMENT_DYNAMIC(SGColourDragTarget, SGListDragTarget);
CC_IMPLEMENT_DYNCREATE(ColourNameDlg, DialogOp)
CC_IMPLEMENT_MEMDUMP(ColourNameParam, OpParam)


// This line mustn't go before any CC_IMPLEMENT_... macros
#define new CAM_DEBUG_NEW


// Nasty PANTONE bodge - after any change of ordering in any library, the 
// Pantone library no longer puts line breaks after every 9th item.
static BOOL LibraryHasBeenSorted = FALSE;

const INT32 SG_ColourNameWidth = 127000;        // Width of colour name field (just long enough
                                            // for "Pantone Process Magenta CV"!!)

// This always points to the colour gallery, or NULL if it doesn't exist.
ColourSGallery* ColourSGallery::m_pTheGallery = NULL;

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

    Preference:     AutoScrollColGal
    Section:        Displays
    Range:          TRUE or FALSE
    Purpose:        If TRUE, the colour gallery will automatically scroll its display list
                    to show the currently selected line and fill colours whenever the
                    selection changes. If FALSE, these colours will still become selected,
                    but the gallery will not be scrolled.

                    This is because it can be annoying that the gallery keeps scrolling
                    away from a colour which you were about to apply to the selection (though
                    you'd be better off dragging the colour, rather than selecting different
                    objects in this case)

    Notes:          Normal preference, available from the options dialogue.
    SeeAlso:        ColourSGallery

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

#ifdef WEBSTER
// In Webster don't scroll to the selected colour by default
INT32 ColourSGallery::AutoScrollSelection = FALSE;
#else
// In Camelot do scroll to the selected colour by default
INT32 ColourSGallery::AutoScrollSelection = TRUE;
#endif


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

    Preference:     ColourDisplayMode
    Section:        Displays
    Range:          0..2
    Purpose:        Memory of the current colour gallery display mode, saved between
                    sessions for convenience. Not shown in the options dialogue.
    SeeAlso:        ColourSGallery

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

INT32 ColourSGallery::DefaultDisplayMode = 0;

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

    Preference:     ShowDocumentColours
    Section:        ColourLine
    Range:          TRUE, FALSE (0,1)
    Purpose:        Memory of the current state of showing document colours in the colour
                    line.
    SeeAlso:        ColourSGallery

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

// Webster and Camelot's default should be the same (True).
BOOL ColourSGallery::ShowDocumentColours = TRUE;


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

    Preference:     ShowNetscapeColours
    Section:        ColourLine
    Range:          TRUE, FALSE (0,1)
    Purpose:        Memory of the current state of showing Netscape colours in the colour
                    line.
                    Webster needs to default to True.
    SeeAlso:        ColourSGallery

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

// True if want Netscape colours being shown in colour line
// Webster only at present
BOOL ColourSGallery::ShowNetscapeColours = TRUE;

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

    Preference:     Path
    Section:        Palette
    Range:          0 .. 256 characters
    Purpose:        The path to load the palettes from. Defaults to blank which means alongside
                    the exe.
    SeeAlso:        ColourSGallery

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

String_256 ColourSGallery::PalettePath = TEXT("");


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

>   SGColourDragTarget::SGColourDragTarget(DialogOp *TheDialog, CGadgetID TheGadget = NULL)
     
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Inputs:     TheDialog - The kernel dialog in which the target exists
                TheGadget - The gadget within that dialogue which is the target

    Purpose:    Constructor

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

SGColourDragTarget::SGColourDragTarget(DialogOp *TheDialog, CGadgetID TheGadget)
                    : SGListDragTarget(TheDialog, TheGadget)
{
    ERROR3IF(!TheDialog->IsKindOf(CC_RUNTIME_CLASS(ColourSGallery)),
            "You can only use SGColourDragTargets with ColourSGallery dialogues!");
}



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

    BOOL SGColourDragTarget::ProcessEvent(DragEventType Event, DragInformation *pDragInfo,
                                        OilCoord *pMousePos, KeyPress* pKeyPress)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/3/95
    Inputs:     Event - Indicates what has happened
                pDragInfo - points to drag information describing this drag. This
                should be a ColourDragInformation or derivation thereof
                pMousePos - points to information on the current mouse position, in OIL coords
                pKeyPress - NULL, or if for a keypress event, keypress information

    Returns:    TRUE to claim the event, FALSE to let it through to other targets

    Purpose:    Event Handler for SuperGallery listitem drag events. Overrides the
                base class handler to enable it to sort out the node being dragged
                for colour drags.

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

BOOL SGColourDragTarget::ProcessEvent(DragEventType Event, DragInformation *pDragInfo,
                                    OilCoord *pMousePos, KeyPress* pKeyPress)
{
    if (!pDragInfo->IsKindOf(CC_RUNTIME_CLASS(ColourDragInformation)))
        return(FALSE);

    SGDisplayNode *DraggedNode = NULL;
    BOOL IsSimpleColourDrag = FALSE;

    if (IS_A(pDragInfo, ColourDragInformation))
    {
        ColourDragInformation *ColourDragInfo = (ColourDragInformation *) pDragInfo;

        SuperGallery *ParentGallery = (SuperGallery *)TargetDialog;

        IsSimpleColourDrag = TRUE;

        // Search the display tree for an item which displays the dragged IndexedColour
        IndexedColour *DraggedColour = ColourDragInfo->GetInitiallyDraggedColour();

        // If the colour is NULL, it's "no colour" (or possibly some weird library colour which
        // we didn't start the drag of, because we'd use a GalleryColourDragInfo), so ignore it
        if (DraggedColour == NULL)
            return(FALSE);

        SGDisplayRoot *DisplayTree = ParentGallery->GetDisplayTree();
        if (DisplayTree == NULL)        // No tree?!
            return(FALSE);

        // Scan the display tree for the document in which the colour resides, to find
        // the display item that references the colour. If we weren't given a parent
        // document, then we'll scan the entire thing.
        // If we find it, we exit this bit with DraggedNode pointing at the relevant
        // SGDisplayNode item for it, and drop through to the regular handler
        BOOL Found = FALSE;

        SGDisplayNode *TheGroup = NULL;     // Find an appropriate group to start searching
        if (ColourDragInfo->GetParentDoc() != NULL)
        {
            TheGroup = DisplayTree->FindSubtree(ParentGallery,
                                ((ColourDragInformation *) pDragInfo)->GetParentDoc(), NULL);
        }
        else
            TheGroup = DisplayTree->GetChild();

        DocColour *TheDocCol;
        while (TheGroup != NULL && !Found)
        {
            DraggedNode = TheGroup->GetChild();
            while (DraggedNode != NULL)
            {
                TheDocCol = ((SGDisplayColour *)DraggedNode)->GetDisplayedColour();
                if (TheDocCol != NULL && TheDocCol->FindParentIndexedColour() == DraggedColour)
                {
                    Found = TRUE;
                    break;
                }

                DraggedNode = DraggedNode->GetNext();
            }

            TheGroup = TheGroup->GetNext();
        }

        if (!Found)         // No colour matching that description is in the gallery
            return(FALSE);
    }
    else if (IS_A(pDragInfo, GalleryColourDragInfo))
    {
        DraggedNode = ((GalleryColourDragInfo *)pDragInfo)->GetDraggedColour();
    }
    // else ignore the drag (as DraggedNode will still be NULL)

    if (DraggedNode != NULL)
    {
        switch(Event)
        {
            case DRAGEVENT_COMPLETED:
                HandleDragCompleted((SuperGallery *) TargetDialog,
                                    DraggedNode, pMousePos, IsSimpleColourDrag);
                return(TRUE);


            case DRAGEVENT_MOUSESTOPPED:
            case DRAGEVENT_MOUSEMOVED:
            case DRAGEVENT_MOUSEIDLE:
                // Call a subroutine to work out and set our current cursor shape
                return(DetermineCursorShape((SuperGallery *) TargetDialog,
                                            DraggedNode, pMousePos));
            default:
                break;
        }
    }

    // Otherwise, we aren't interested in the event, so we don't claim it
    return(FALSE);
}









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

>   void GalleryColourDragInfo::GalleryColourDragInfo() 
     
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/2/95       

    Purpose:    Default constructor - do not call this constructor

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

GalleryColourDragInfo::GalleryColourDragInfo()
{
    ERROR3("Default GalleryColourDragInfo constructor called"); 
}



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

>   GalleryColourDragInfo::GalleryColourDragInfo(Document *pDocument, SGDisplayColour *pSourceItem,
                                            SGMouseInfo *pMouseInfo, SGMiscInfo *pMiscInfo,
                                            BOOL IsAdjust = FALSE)
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/2/95       

    Inputs:     pDocument   - The document in which the colour lives
                pSourceItem - The gallery item from which the drag originated
                pMouseInfo  - The mouse info which made the item start the drag
                pMiscInfo   - The MiscInfo which accompanied the mouse event
                IsAdjust    - TRUE if this is an adjust drag

    Purpose:    Constructor - use this one for "document colours" - ones that already live
                in a document. The Display item's colour MUST reference an IndexedColour.

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

GalleryColourDragInfo::GalleryColourDragInfo(Document *pDocument, SGDisplayColour *pSourceItem,
                                            SGMouseInfo *pMouseInfo, SGMiscInfo *pMiscInfo,
                                            BOOL IsAdjust)
                      : ColourDragInformation(pSourceItem->GetDisplayedColour()->FindParentIndexedColour(),
                                                IsAdjust, pDocument)
{
    ERROR3IF(pSourceItem == NULL || pMouseInfo == NULL || pMiscInfo == NULL,
                "GalleryColourDragInfo constructor: Illegal NULL param");

    SourceItem  = pSourceItem;  // Copy the source item pointer

    MouseInfo   = *pMouseInfo;  // Duplicate the structures (they may cease to exist
    MiscInfo    = *pMiscInfo;   // soon after the drag is started)
}



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

>   GalleryColourDragInfo::GalleryColourDragInfo(SGDisplayColour *pSourceItem,
                                            SGMouseInfo *pMouseInfo, SGMiscInfo *pMiscInfo,
                                            BOOL IsAdjust = FALSE)
     
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/2/95       

    Inputs:     pSourceItem - The gallery item from which the drag originated
                pMouseInfo  - The mouse info which made the item start the drag
                pMiscInfo   - The MiscInfo which accompanied the mouse event
                IsAdjust    - TRUE if this is an adjust drag

    Purpose:    Constructor - use this for drags of "library colours" (ones with
                no parent document)

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

GalleryColourDragInfo::GalleryColourDragInfo(SGDisplayColour *pSourceItem,
                                            SGMouseInfo *pMouseInfo, SGMiscInfo *pMiscInfo,
                                            BOOL IsAdjust)
                      : ColourDragInformation(pSourceItem->GetDisplayedColour(), IsAdjust,
                                                NULL, pSourceItem->IsASpotColour())
{
    ERROR3IF(pSourceItem == NULL || pMouseInfo == NULL || pMiscInfo == NULL,
                "GalleryColourDragInfo constructor: Illegal NULL param");

    // Fill in the base class' name member, which we passed NULL for in the construction above
    String_256 Bob;
    pSourceItem->GetNameText(&Bob);
    Bob.Left(&ColourName, 63);

    SourceItem  = pSourceItem;  // Copy the source item pointer

    MouseInfo   = *pMouseInfo;  // Duplicate the structures (they may cease to exist
    MiscInfo    = *pMiscInfo;   // soon after the drag is started)
}



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

>   virtual void GalleryColourDragInfo::OnClick(INT32 Flags, POINT Point) 
     
    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/1/95       
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    This is called if a drag was attempted but never started because it was a 
                click all along. It calls back the SourceItem SGDisplayColour, to get it
                to handle the click. 
    Errors:     -
    SeeAlso:    -

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

void GalleryColourDragInfo::OnClick(INT32 Flags, POINT Point)
{
    if (SourceItem != NULL)
        SourceItem->DragWasReallyAClick(&MouseInfo, &MiscInfo);
}









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

>   SGDisplayColour::SGDisplayColour()

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

    Purpose:    SGDisplayColour constructor
                DON'T call this constructor. Call the other constructor

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

SGDisplayColour::SGDisplayColour()
{
    // We don't like people calling this constructor, but we have to put up with it
    // now that we have a derived class.
}



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

>   SGDisplayColour::SGDisplayColour(IndexedColour *ColourToDisplay)

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

    Inputs:     ColourToDisplay - The colour this item will display

    Purpose:    SGDisplayColour constructor

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

SGDisplayColour::SGDisplayColour(IndexedColour *ColourToDisplay)
{
    TheColour.MakeRefToIndexedColour(ColourToDisplay);
}



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

>   virtual INT32 SGDisplayColour::CompareTo(SGDisplayNode *Other, INT32 SortKey)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/4/95

    Inputs:     Other - the Colour to compare this Colour to
                SortKey - An integer identifying how to compare the items
                    0 = No sorting (always returns 0)
                    1 = Sort-by-name
                    2 = Sort-by-hue
                    3 = Sort-by-intensity
                    4 = Sort-by-model

    Returns:    negative (I am lesser), 0 (we are equal), or positive (I am greater)

    Purpose:    Compares this Colour to the 'other' Colour, to determine their relative positions
                in the display tree. Returns a value which usually indicates that the other
                Colour should be inserted before (-1, or 0) or after (+1) this item.

    SeeAlso:    SGDisplayNode::CompareTo

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

const INT32 SGSORTKEY_BYHUE = 2;
const INT32 SGSORTKEY_BYINTENSITY = 3;
const INT32 SGSORTKEY_BYMODEL = 4;

INT32 SGDisplayColour::CompareTo(SGDisplayNode *Other, INT32 SortKey)
{
    ERROR3IF(Other == NULL, "Illegal NULL parameter");

    ERROR3IF(!Other->IsKindOf(CC_RUNTIME_CLASS(SGDisplayColour)),
                "SGDisplayColour::CompareTo - The other item's not a colour!");

    DocColour *OtherCol = ((SGDisplayColour *)Other)->GetDisplayedColour();
    DocColour *ThisCol  = GetDisplayedColour();

    switch (SortKey)
    {
        case SGSORTKEY_BYNAME:
            {
                IndexedColour *OtherColIx = OtherCol->FindParentIndexedColour();
                IndexedColour *ThisColIx  = ThisCol->FindParentIndexedColour();

                // Safety check - if either colour is NULL, then return "equal"
                if (OtherColIx == NULL || ThisColIx == NULL)
                    return(0);

                // We override the base class name comparison, because it is forced to
                // actually copy the names first! This one just compares them in-place
                return(ThisColIx->GetName()->CompareTo( (TCHAR *) (*(OtherColIx->GetName())) ) );
            }
            break;


        case SGSORTKEY_BYHUE:
        {
            ColourContextHSVT   *ColContext;
            ColourHSVT  ResultCol;
            ColourValue Hue1;

            Document *ParentDoc = ((SGDisplayGroup *)GetParent())->GetParentDocument();

            // Get a default context, or if ParentDoc != NULL, the current context for the doc.
            ColContext = (ColourContextHSVT *) ColourManager::GetColourContext(COLOURMODEL_HSVT, ParentDoc);
            if (ColContext == NULL)
                return(0);

            // Convert the 2 colours to HSV and compare their Hue values
            ColContext->ConvertColour(ThisCol, (ColourGeneric *) &ResultCol);
            Hue1 = ResultCol.Hue;

            ColContext->ConvertColour(OtherCol, (ColourGeneric *) &ResultCol);

            if (Hue1 < ResultCol.Hue)
                return(-1);

            return((Hue1 == ResultCol.Hue) ? 0 : 1);
        }


        case SGSORTKEY_BYINTENSITY:
        {
            ColourContextGreyT  *ColContext;
            ColourGreyT         ResultCol;
            ColourValue         Intensity1;

            Document *ParentDoc = ((SGDisplayGroup *)GetParent())->GetParentDocument();

            // Get a default context, or if ParentDoc != NULL, the current context for the doc.
            ColContext = (ColourContextGreyT *) ColourManager::GetColourContext(COLOURMODEL_GREYT, ParentDoc);
            if (ColContext == NULL)
                return(0);

            // Convert the 2 colours to Greyscale and compare their intensity values
            ColContext->ConvertColour(ThisCol, (ColourGeneric *) &ResultCol);
            Intensity1 = ResultCol.Intensity;

            ColContext->ConvertColour(OtherCol, (ColourGeneric *) &ResultCol);

            if (Intensity1 < ResultCol.Intensity)
                return(-1);

            return((Intensity1 == ResultCol.Intensity) ? 0 : 1);
        }


        case SGSORTKEY_BYMODEL:
            return((INT32)ThisCol->GetColourModel() - (INT32)OtherCol->GetColourModel());
    }

    // No sorting (SGSORTKEY_NONE - 0), or unknown
    return(SGDisplayItem::CompareTo(Other, SortKey));
}



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

>   virtual void SGDisplayColour::GetNameText(String_256 *Result)

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

    Outputs:    On exit, the string pointed at by Result will contain either a blank
                string, or the name text associated with this item (if any)

    Purpose:    To determine a name string for this node. Generally, this is used for
                a simple mechanism which searches for display items whose names match
                given search parameters in some way. It is also used in libraries to
                provide default redraw methods.

    SeeAlso:    SGDisplayColour::GetFullInfoText

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

void SGDisplayColour::GetNameText(String_256 *Result)
{
    ERROR3IF(Result == NULL, "Illegal NULL param");

    IndexedColour *ParentCol = TheColour.FindParentIndexedColour();
    if (ParentCol != NULL)
        *Result = *(ParentCol->GetName());
    else
        Result->MakeMsg(_R(IDS_UNNAMEDCOLOUR));
}



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

>   virtual void SGDisplayColour::GetFullInfoText(String_256 *Result)

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

    Outputs:    On exit, the string pointed at by Result will contain either a blank
                string, or the full-information text associated with this item (if any)

    Purpose:    To determine a full-info string for this node. Generally, this is used for
                a simple mechanism which searches for display items whose info matches
                given search parameters in some way. It is also used in libraries to
                provide default redraw methods.

    SeeAlso:    SGDisplayColour::GetNameText

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

void SGDisplayColour::GetFullInfoText(String_256 *Result)
{
    ERROR3IF(Result == NULL, "Illegal NULL param");

    *Result = TEXT("");     // Set a safe default

    // Generate an info string of the form:
    // <ColModel> (<components>) [, <tint/link/spot information>] [, not in use]
    // e.g.     "HSV(324, 80, 75), Linked to Red"

    String_256 Info(TEXT(""));

    ColourContext *cc = ColourContext::GetGlobalDefault(TheColour.GetColourModel());
    ERROR3IF(cc == NULL, "Default colour context is NULL!?");

    ColourGeneric col;
    TheColour.GetSourceColour(&col);
    cc->GetModelName(&Info);

    String_128  TempStr(TEXT("("));
    String_16   CompStr;
    if (cc->GetComponentName(1, NULL))
    {
        double CompVal;
        if (TheColour.GetColourModel() == COLOURMODEL_HSVT)
            CompVal = (col.Component1.MakeDouble()) * 360.0;
        else
            CompVal = (col.Component1.MakeDouble()) * 100.0;

        // Convert it to a string rounded to 1 decimal place accuracy
        Convert::DoubleToString(CompVal, &CompStr, 1);

        TempStr += CompStr;
    }

    if (cc->GetComponentName(2, NULL))
    {
        Convert::DoubleToString(col.Component2.MakeDouble() * 100.0, &CompStr, 1);
        TempStr += TEXT(", ");
        TempStr += CompStr;
    }

    if (cc->GetComponentName(3, NULL))
    {
        Convert::DoubleToString(col.Component3.MakeDouble() * 100.0, &CompStr, 1);
        TempStr += TEXT(", ");
        TempStr += CompStr;
    }

    if (cc->GetComponentName(4, NULL))
    {
        Convert::DoubleToString(col.Component4.MakeDouble() * 100.0, &CompStr, 1);
        TempStr += TEXT(", ");
        TempStr += CompStr;
    }

    TempStr += TEXT(")");
    Info    += TempStr;

    IndexedColour *ParentCol = TheColour.FindParentIndexedColour();     // If this refs an IndexedColour...
    if (ParentCol != NULL)
    {
        switch(ParentCol->GetType())
        {
            case COLOURTYPE_SPOT:
                TempStr.MakeMsg(_R(IDS_COLGAL_ISPOT));
                Info += TempStr;
                break;

            case COLOURTYPE_TINT:
                {
                    ERROR3IF(ParentCol->FindLinkedParent() == NULL,
                            "A tint without a parent colour? Oh bums!");

                    if (ParentCol->TintIsShade())
                    {
                        TempStr.MakeMsg(_R(IDS_COLGAL_ISHADE),
                                        (TCHAR *) *(ParentCol->FindLinkedParent()->GetName()));
                    }
                    else
                    {
                        TempStr.MakeMsg(_R(IDS_COLGAL_ITINT),
                                        (INT32) ((ParentCol->GetTintValue().MakeDouble() + 0.005)*100),
                                        (TCHAR *) *(ParentCol->FindLinkedParent()->GetName()));
                    }
                    Info += TempStr;
                }
                break;

            case COLOURTYPE_LINKED:
                {
                    ERROR3IF(ParentCol->FindLinkedParent() == NULL,
                            "A linked colour without a parent colour? Oh bums!");

                    TempStr.MakeMsg(_R(IDS_COLGAL_ILINKED),
                        (TCHAR *) *(ParentCol->FindLinkedParent()->GetName()));
                    Info += TempStr;
                }
                break;

            default:
                break;
        }


        SGDisplayGroup *DocumentGroup = (SGDisplayGroup *) GetParent();
        ERROR3IF(DocumentGroup == NULL, "SGallery DisplayTree linkage corruption detected");

        Document *ScopeDoc = DocumentGroup->GetParentDocument();
        ERROR3IF(ScopeDoc == NULL, "SGallery group is not for a document! Unimplemented! Eek!");

        ColourList *ParentColList = ScopeDoc->GetIndexedColours();
        ERROR3IF(ParentColList == NULL, "A document with no colour list? Now I've seen it all");

        if (!ParentColList->IsColourInUseInDoc(ParentCol, TRUE))
        {
            // Add ' (not in use)' for any colour not currently used in the
            // document, or as a linked-colour parent
            TempStr.MakeMsg(_R(IDS_COLGAL_INOTUSED));
            Info += TempStr;
        }
    }

    *Result = Info;
}



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

>   virtual BOOL SGDisplayColour::IsALibraryColour(void) const

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

    Inputs:     -
    Returns:    FALSE if this is a base-class SGDisplayColour (IndexedColour)
                TRUE  if this is a derived class SGDisplayLibColour (library DocColour)

    Purpose:    Proper virtual-function method for differentiating between IndexedColour
                and library DocColour gallery display items.

    Notes:      Always returns FALSE

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

BOOL SGDisplayColour::IsALibraryColour(void) const
{
    return(FALSE);
}



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

>   virtual BOOL SGDisplayColour::IsASpotColour(void)

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

    Inputs:     -
    Returns:    FALSE if this is a normal colour
                TRUE  if this is a spot colour

    Purpose:    Determine if the displayed colour is a normal or spot colour

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

BOOL SGDisplayColour::IsASpotColour(void)
{
    if (TheColour.FindParentIndexedColour() != NULL)
    {
        if (TheColour.FindParentIndexedColour()->IsSpotOrTintOfSpot())
            return(TRUE);
    }

    return(FALSE);
}



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

>   void SGDisplayColour::CalculateMyRect(SGFormatInfo *FormatInfo, SGMiscInfo *MiscInfo)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/1/95

    Inputs:     FormatInfo - The formatting info from which to calculate my position/size
                MiscInfo    - The MiscInfo, as usual

    Outputs:    member variable FormatRect - is returned filled in with the size/position of
                this colour item's display area. This is dependent upon the current display
                mode and format state

    Purpose:    Shared code for colour items to calculate where they will appear in the
                grand scheme of things

    Scope:      private (to sgcolour.cpp, for use of SGDisplayColour class only)

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

void SGDisplayColour::CalculateMyRect(SGFormatInfo *FormatInfo, SGMiscInfo *MiscInfo)
{
    const INT32 SGC_FullInfoWidth = SG_InfiniteWidth; //300000;

    INT32 XSize;
    INT32 YSize;

    // Note: The text is usually something like 9 point, so a minimum Y size to fit text
    // in is going to be around 12 point (12000 millipoints)

    switch (MiscInfo->DisplayMode)
    {
        case 1:                     // 1 - Full Info
            XSize = GridLock(MiscInfo, SGC_FullInfoWidth);
            YSize = GridLock(MiscInfo, SG_DefaultSmallIcon);
            break;

        case 2:                     // 2 - Icon only, no text at all
            XSize = YSize = GridLock(MiscInfo, SG_DefaultLargeIcon);
            break;

        default:                    // 0 (Default) - Small icon with name
            XSize = GridLock(MiscInfo, SG_ColourNameWidth);
            YSize = GridLock(MiscInfo, SG_DefaultSmallIcon);
            break;
    }

    CalculateFormatRect(FormatInfo, MiscInfo, XSize, YSize);
}


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

>   void DrawCircle(RenderRegion *Renderer, DocRect &BoundRect)

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

    Inputs:     Renderer - The render region to render into
                BoundRect - The bounding rectangle to draw the circle into

    Purpose:    Draws a circle filling the width of the given rectangle,
                using the current render region attributes.

    Scope:      private

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

void DrawCircle(RenderRegion *Renderer, DocRect &BoundRect)
{
    // WEBSTER - markn 23/1/97
    // No Circles required.
    //
#ifndef WEBSTER
    const INT32 CircleSize = BoundRect.Width() / 2;
    const INT32 CPDist = (const INT32) ( ((double)CircleSize) * 0.552 );

    Path Circle;
    Circle.Initialise(12, 12);
    Circle.FindStartOfPath();

    DocCoord Center(BoundRect.lo.x + BoundRect.Width()/2,
                    BoundRect.lo.y + BoundRect.Height()/2);

    Circle.InsertMoveTo(DocCoord(Center.x+CircleSize, Center.y));
    Circle.InsertCurveTo(DocCoord(Center.x+CircleSize, Center.y+CPDist),
                            DocCoord(Center.x+CPDist, Center.y+CircleSize),
                            DocCoord(Center.x, Center.y+CircleSize));
    Circle.InsertCurveTo(DocCoord(Center.x-CPDist, Center.y+CircleSize),
                            DocCoord(Center.x-CircleSize, Center.y+CPDist),
                            DocCoord(Center.x-CircleSize, Center.y));
    Circle.InsertCurveTo(DocCoord(Center.x-CircleSize, Center.y-CPDist),
                            DocCoord(Center.x-CPDist, Center.y-CircleSize),
                            DocCoord(Center.x, Center.y-CircleSize));
    Circle.InsertCurveTo(DocCoord(Center.x+CPDist, Center.y-CircleSize),
                            DocCoord(Center.x+CircleSize, Center.y-CPDist),
                            DocCoord(Center.x+CircleSize, Center.y));

    Circle.IsFilled = TRUE;

    Renderer->DrawPath(&Circle);                // and draw it
#endif // WEBSTER
}



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

>   virtual void SGDisplayColour::HandleRedraw(SGRedrawInfo *RedrawInfo,
                                                SGFormatInfo *FormatInfo)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/1/95

    Inputs:     RedrawInfo  - The information on the kernel-rendered redraw area
                FormatInfo  - The formatting information structure

                member variable FormatRect should be set up (before calling this method)
                to be the rectangle in which to draw this item

    Purpose:    SGDisplayColour item redraw method - removed from the main HandleEvent
                method merely to make the code tidier.

    Scope:      private

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

void SGDisplayColour::HandleRedraw(SGRedrawInfo *RedrawInfo, SGMiscInfo *MiscInfo)
{
    StartRendering(RedrawInfo, MiscInfo);

    DocRect MyRect(FormatRect);

    RenderRegion *Renderer = RedrawInfo->Renderer;

    INT32 OnePixel  = (INT32) DevicePixels(MiscInfo, 1);
    INT32 TwoPixels = (INT32) DevicePixels(MiscInfo, 2);

    DocRect IconRect(MyRect);       // Create a square icon at the left end of our rectangle
    IconRect.hi.x = IconRect.lo.x + IconRect.Height();
    MyRect.lo.x = IconRect.hi.x + TwoPixels;

    // Redraw the icon
    GridLockRect(MiscInfo, &IconRect);  

    Renderer->SetLineWidth(0);
    Renderer->SetLineColour(RedrawInfo->Transparent);

    // If selected, we have a 3-pixel-thick selection border
    // Otherwise (as is now the case) we have a single-pixel black border
    // We draw border "lines" using rectangle fills, else it screws pixel alignment
    if (!Flags.Selected)
        IconRect.Inflate(-TwoPixels);

    IndexedColour *IxCol = TheColour.FindParentIndexedColour();

    // Draw (selection border and) border
    // The patch is normally a square (process colour), but for spot colours
    // is drawn as a circle, in order to make the distinction more obvious
    //
    // WEBSTER - markn 23/1/97
    // No Circles required.
    //
    DocColour black(COLOUR_BLACK);
    Renderer->SetFillColour(black);
#ifndef WEBSTER
    if (IsASpotColour())
    {
        IconRect.Inflate(-OnePixel);
        DrawCircle(Renderer, IconRect);
    }
    else
#endif // WEBSTER
        Renderer->DrawRect(&IconRect);              // And draw it

    // Now deflate further, to get inside the selection & border...
    IconRect.Inflate((Flags.Selected)  ? -(TwoPixels+OnePixel) : -OnePixel);

    // Draw the colour patch (icon)
    // Save and restore the context while using TheColour to fill with. This is so that
    // the renderer no longer references the IndexedColour, so that GetFullInfoText will
    // put the text '(not in use)' on the end of colours which aren't used in the document!
    Renderer->SaveContext();
    Renderer->SetFillColour(TheColour);         // Fill with colour to display

    // The patch is normally a square (process colour), but for spot colours
    // is drawn as a circle, in order to make the distinction more obvious
    //
    // WEBSTER - markn 23/1/97
    // No Circles required.
    //
#ifndef WEBSTER
    if (IsASpotColour())
        DrawCircle(Renderer, IconRect);
    else
#endif // WEBSTER
        Renderer->DrawRect(&IconRect);              // And draw it
    Renderer->RestoreContext();

    // Redraw the name text, if there is room to the right of the icon
    if (MyRect.lo.x < MyRect.hi.x)
    {
        GridLockRect(MiscInfo, &MyRect);

//      IndexedColour *ParentCol = TheColour.FindParentIndexedColour();

        if (Flags.Selected)
        {
            // Fill the entire background with the 'selected' colour, so we don't
            // get gaps between bits of text or uneven rectangles in multiple selections
            Renderer->SetFillColour(RedrawInfo->SelBackground);
            Renderer->DrawRect(&MyRect);

            Renderer->SetFixedSystemTextColours(&RedrawInfo->SelForeground, &RedrawInfo->SelBackground);

            if (IxCol != NULL)  // Only do this for IndexedColours (i.e. not derived class Library colours)
            {
                // If this item represents the current line colour, then place a vertical line between the icon
                // and the text to indicate this fact.
                DocColour *LineCol;
                ColourManager::GetCurrentLineAndFillColours(&LineCol, NULL);

                if (LineCol != NULL && LineCol->FindParentIndexedColour() == TheColour.FindParentIndexedColour())
                {
                    // This item is selected and is the current line colour. Put a mark in to indicate this
                    DocColour black(COLOUR_BLACK);
                    Renderer->SetLineColour(black);
                    Renderer->SetLineWidth(TwoPixels);
                    Renderer->DrawLine(MyRect.lo, DocCoord(MyRect.lo.x, MyRect.hi.y));
                }
            }
        }
        else
            Renderer->SetFixedSystemTextColours(&RedrawInfo->Foreground, &RedrawInfo->Background);

        MyRect.lo.x += SG_GapBeforeText;    // Leave a small gap before text begins

        String_256 Name;
        GetNameText(&Name);                 // Get the name string

        if (MiscInfo->DisplayMode == 1)     // If in Full Info mode...
        {
            DocRect TextRect(MyRect);

            // Reserve space for the name (clip it if it won't fit)
            if (TextRect.hi.x - TextRect.lo.x > SG_ColourNameWidth)
                TextRect.hi.x = TextRect.lo.x + SG_ColourNameWidth;

            // Draw the name text next to the icon
            Renderer->DrawFixedSystemText(&Name, TextRect);
            
            // Move to the right, to fill the remaining space with information
            // (Leave a 6-pixel gap in case the name didn't all fit in the available space)
            TextRect.lo.x = TextRect.hi.x + DevicePixels(MiscInfo, 6);
            TextRect.hi.x = MyRect.hi.x;
            if (TextRect.lo.x < TextRect.hi.x)      // If any room left for info...
            {
                // Get the full info description, and render it