colpick.cpp

Go to the documentation of this file.

// $Id: colpick.cpp 1350 2006-06-22 13:20:47Z 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============================
 */

// colpick.cpp - Colour picker dialogue

/*
*/


#include "camtypes.h"

#include "dlgmgr.h"
#include "colcontx.h"
#include "coldlog.h"
#include "collist.h"
#include "colormgr.h"
#include "colourix.h"
#include "colpick.h"
//#include "convert.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "scunit.h"
#include "ctrlhelp.h"
//#include "jason.h"
//#include "reshlpid.h"
//#include "richard3.h"
//#include "ed.h"

wxSize ColourPicker::s_LastSize = wxDefaultSize;
wxSize ColourPicker::s_UserSize = wxSize(245,245);
wxSize ColourPicker::s_MinSize = wxSize(180,100);
BOOL ColourPicker::s_InColourDialogLayout = FALSE;
BOOL ColourPicker::s_JustCreated = FALSE;
INT32 ColourPicker::s_IdleCounter = 0;

CC_IMPLEMENT_MEMDUMP(ColourPicker, CCObject)

#define new CAM_DEBUG_NEW


// The colour picker can supply two types of picker - the standard OS picker
// or a special Camelot picker. The latter allows true editing of colours in
// several colour models, while the former may (does under windows) force the
// colour to RGB or something. The OS picker is included so a) finikity users
// can use a crap picker if they are shy of meeting new dialogues, and b) so
// we can pick new colours/edit existing colours without having to wait for
// a complete picker implementation to roll up...
//static BOOL UseOSPicker = FALSE;


// Static buffer for storing bubble help from the colour editor's picker area
// until the bubble-help callback mechanism is called back.
static String_128 PickerBubbleBuffer("");
static String_256 StatusHelpBuffer("");


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

>   ColourPicker::ColourPicker()

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/5/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Creates a colourpicker object
    Scope:      private
    Errors:     -
    SeeAlso:    -

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

ColourPicker::ColourPicker()
{
}



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

>   ColourPicker::~ColourPicker()

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/5/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Destructor for a Colour Picker
    Scope:      private
    Errors:     -
    SeeAlso:    -

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

ColourPicker::~ColourPicker()
{
}


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

>   static INT32 ColourValueToByte(const ColourValue &Col)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/5/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Converts a ColourValue (0.0 to 1.0) into a byte (0..255) with clipping
                to handle out-of-gamut values.

    Notes:      This function is not as efficient as it could be. If it ever becomes
                critical in any way, it should be optimised. See comments in the function.

    Scope:      private
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
/*
    === This code has been rewritten to use centralised functions. It is UNTESTED ===

static INT32 ColourValueToByte(const ColourValue &Col)
{
    // We want to use the centralised ColourContext::PackColour function to do this for us
    // However, it's protected. The easiest way of accessing the functionality is to
    // create a DocColour containing the value, then read back the 0..255 value.
    // This is more work than strictly necessary, but then again, this function is non critical.

    DocColour Dummy(Col, Col, Col);

    INT32 Red;
    INT32 Green;
    INT32 Blue;
    Dummy.GetRGBValue(&Red, &Green, &Blue);

    return(Red);
}
*/


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

>   BOOL ColourPicker::EditColour(ColourList *ParentList, IndexedColour *SourceAndResult,
                                    BOOL PreferLineColour = FALSE)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/5/94
    Inputs:     ParentList - The list in which the colour resides
                    May be NULL if you want to just show the picker for whatever
                    local colour is appropriate.
                    SourceAndResult must also be NULL in this case

                SourceAndResult - The colour to be edited. If the user changes
                the colour, this will be set to the new definition.
                    May be NULL if you want to just show the picker for whatever
                    local colour is appropriate.
                    ParentList must also be NULL in this case

                PreferLineColour - TRUE if you'd like to edit line colours rather than
                fill colours in local mode, FALSE to edit fill colours. This flag is
                ignored unless ParentList == SourceAndResult == NULL. (Implementation
                note: This calls ColourEditDlg::ForceLineOrFillMode)

    Outputs:    -
    Returns:    -
    Purpose:    The main colour picker function. Given an IndexedColour, sets up
                a colour picker showing that colour, allows the user to edit it,
                and returns the new colour in said IndexedColour. If the colour is
                changed, an appropriate ColourChangingMsg will be broadcast.

    Notes:      The IndexedColour is actually copied into another for editing. The
                change, if OK'd is then applied using the ColourManager::ChangeColour
                function, which provides an undo record of the event.

    Scope:      private
    Errors:     -
    SeeAlso:    ColourEditDlg::InvokeDialog

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

void ColourPicker::EditColour(ColourList *ParentList, IndexedColour *SourceAndResult,
                                BOOL PreferLineColour)
{
#if FALSE
/*
// **** DEBUG - use Windows Picker if SHIFT NOT held down on entry,
//              else use the Camelot Picker
    if (ForceNativePicker)
        UseOSPicker = TRUE;
    else
        UseOSPicker = (::GetAsyncKeyState(CAMKEY(SHIFT)) & 0x8000) ? TRUE : FALSE;
// ****
    if (UseOSPicker)
    {
        IndexedColour *UndoBuffer = new IndexedColour(*SourceAndResult);
        if (UndoBuffer == NULL)     // Fail gracefully. Well... Don't crash, anyway
            return;

        ColourGeneric *TheColour = UndoBuffer->SourceColourPtr();

        Document *ScopeDoc = Document::GetSelected();
        if (ScopeDoc == NULL)
            return;

        ColourContext *ccRGB = ScopeDoc->GetDefaultColourContexts()->Context[COLOURMODEL_RGBT];
        ENSURE(ccRGB != NULL, "Default RGBT context can't be found!");

        ColourContext *ccSource = ScopeDoc->GetDefaultColourContexts()->Context[UndoBuffer->GetColourModel()];
        if (ccSource == NULL)
        {
            ENSURE(FALSE, "Unsupported source colour context - I can't edit that colour");
            return;
        }

        // Convert the given colour into RGB, using 'pure' contexts (logical rather than physica
        // conversion, i.e. no colour correction en-route)
        ColourRGBT TheColourRGB;
        ccRGB->ConvertColour(ccSource, TheColour, (ColourGeneric *) &TheColourRGB);


        // Now set up, and call the Windows colour picker to edit the colour...
        CHOOSECOLOR cc;

        // Set initial colour for the colour picker to use
        cc.rgbResult = RGB( ColourValueToByte(TheColourRGB.Red),
                            ColourValueToByte(TheColourRGB.Green),
                            ColourValueToByte(TheColourRGB.Blue) );


        // Set the default set of available colours (a greyscale for the time being)
        // (it is static so that if the user changes any of the colours they will get
        // the changed palette back next time around)
        static COLORREF acrCustClr[16] =
            {
                RGB(255, 255, 255), RGB(239, 239, 239),
                RGB(223, 223, 223), RGB(207, 207, 207),
                RGB(191, 191, 191), RGB(175, 175, 175),
                RGB(159, 159, 159), RGB(143, 143, 143),
                RGB(127, 127, 127), RGB(111, 111, 111),
                RGB(95, 95, 95),    RGB(79, 79, 79),
                RGB(63, 63, 63),    RGB(47, 47, 47),
                RGB(31, 31, 31),    RGB(15, 15, 15)
            };

        cc.lStructSize = sizeof(CHOOSECOLOR);
        cc.hwndOwner = AfxGetApp()->m_pMainWnd->m_hWnd; // 'owner' window
        cc.lpCustColors = (LPDWORD) acrCustClr;         // List of default colours
        cc.Flags = CC_RGBINIT | CC_FULLOPEN;            // Use cc.rgbResult to init picker...
                                                        // and picker appears fully opened - Geez that
                                                        // 'define wossnames' button is a pain in the butt!!!

        if (ChooseColor(&cc))       // Invoke Windows colour picker (if it qualifies as a colour picker!)
        {
            // User chose a colour and hit OK - read out the return value (always RGB)
            UndoBuffer->SetSourceColourModel(COLOURMODEL_RGBT);
            ((ColourRGBT *)TheColour)->Red   = ((double) GetRValue(cc.rgbResult)) / 256.0;
            ((ColourRGBT *)TheColour)->Green = ((double) GetGValue(cc.rgbResult)) / 256.0;
            ((ColourRGBT *)TheColour)->Blue  = ((double) GetBValue(cc.rgbResult)) / 256.0;
            ((ColourRGBT *)TheColour)->Transparent = 0;

            Document::GetSelected()->SetCurrent();      // Make this document the current one

            // This swallows UndoBuffer into the undo system - we must NOT delete it
            ColourManager::ChangeColour(ParentList, UndoBuffer, SourceAndResult);
        }
        else
            delete UndoBuffer;  // UndoBuffer not used - delete it
    }
    else
*/
#endif
    {
#ifndef STANDALONE
        // If we are asking to edit an appropriate local colour, state our preference
        // for either fill or line colour.
        if (SourceAndResult == NULL)
            ColourEditDlg::ForceLineOrFillMode(PreferLineColour);

        ColourEditDlg::InvokeDialog(ParentList, SourceAndResult);
#endif
    }
}



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

>   static BOOL ColourPicker::GetStatusLineText(ColourEditDlg *Editor, UINT32 GadgetID,
                                                    String_256 *Result)

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

    Inputs:     Editor - points to the current editor
                GadgetID - indicates the gadget for which you desire help

    Outputs:    If return value is TRUE, Result is updated with an appropriate help string

    Returns:    TRUE if it changed Result, FALSE if it can offer no help

    Purpose:    Bodge to get around the fact that DialogOps don't plug into the status
                line help system. Returns help for the colour editor. Must go via the
                winoil, as we have to read the mouse position and find the window it's in.

    SeeAlso:    ColourEditDlg::GetStatusLineText

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

BOOL ColourPicker::GetStatusLineText(ColourEditDlg *Editor, UINT32 GadgetID, String_256 *Result)
{
#ifndef STANDALONE

    IndexedColour *Bob = Editor->EditingColour;
    if (Bob == NULL)
    {
        *Result = String_256(_R(IDS_EDITST_NOCOLOUR));
        return(TRUE);
    }

    ColourContext *cc = ColourContext::GetGlobalDefault(ColourEditDlg::DisplayModel);

    // Set the default help
    *Result = String_256(_R(IDS_EDITST_DEFAULT));

    if (FALSE) {}
//  else if (GadgetID == _R(IDCANCEL))
//  {
//      *Result = String_256(_R(IDS_EDITST_CANCEL));
//  }
    else if (GadgetID == _R(IDC_EDIT_DROPMENU))
    {
        *Result = String_256(_R(IDS_EDITST_MENU));
    }
    else if (GadgetID == _R(IDC_EDIT_COMPONENT1))
    {
        if (ColourEditDlg::DisplayModel == COLOURMODEL_HSVT)
        {
            *Result = String_256(_R(IDS_EDITST_COMP1));
        }
        else
        {
            if (cc != NULL)
            {
                String_64 CompName;
                cc->GetComponentName(1, &CompName, TRUE);
                Result->MakeMsg(_R(IDS_EDITST_COMP234), (TCHAR *)CompName);
            }
        }
    }
    else if (GadgetID == _R(IDC_EDIT_COMPONENT2))
    {
        if (cc != NULL)
        {
            String_64 CompName;
            cc->GetComponentName(2, &CompName, TRUE);
            Result->MakeMsg(_R(IDS_EDITST_COMP234), (TCHAR *)CompName);
        }
    }
    else if (GadgetID == _R(IDC_EDIT_COMPONENT3))
    {
        if (cc != NULL)
        {
            String_64 CompName;
            cc->GetComponentName(3, &CompName, TRUE);
            Result->MakeMsg(_R(IDS_EDITST_COMP234), (TCHAR *)CompName);
        }
    }
// WEBSTER - markn 14/12/96
#ifndef WEBSTER
    else if (GadgetID == _R(IDC_EDIT_COMPONENT4))
    {
        if (cc != NULL)
        {
            String_64 CompName;
            cc->GetComponentName(4, &CompName, TRUE);
            Result->MakeMsg(_R(IDS_EDITST_COMP234), (TCHAR *)CompName);
        }
    }
    else if (GadgetID == _R(IDC_EDIT_COLMODEL))
    {
        *Result = String_256(_R(IDS_EDITST_COLMODEL));
    }
    else if (GadgetID == _R(IDC_EDIT_NAMEMENU))
    {
        *Result = String_256(_R(IDS_EDITST_NAME));
    }
    else if (GadgetID == _R(IDC_EDIT_COLTYPE))
    {
        *Result = String_256(_R(IDS_EDITST_COLTYPE));
    }
    else if ((GadgetID == _R(IDC_EDIT_INHERIT1)) ||
             (GadgetID == _R(IDC_EDIT_INHERIT2)) ||
             (GadgetID == _R(IDC_EDIT_INHERIT3)) ||
             (GadgetID == _R(IDC_EDIT_INHERIT4)))
    {
        *Result = String_256(_R(IDS_EDITST_INHERIT));
    }
//  else if ((GadgetID == _R(IDC_EDIT_PATCH)) ||
//           (GadgetID == _R(IDC_EDIT_PARENTPATCH)))
//  {
//      *Result = String_256(_R(IDS_EDITST_PARENTPATCH));
//  }
    else if ((GadgetID == _R(IDC_EDIT_PARENTCOL)) ||
             (GadgetID == _R(IDC_EDIT_PARENTNAME)))
    {
        *Result = String_256(_R(IDS_EDITST_PARENTCOL));
    }
    else if ((GadgetID == _R(IDC_EDIT_TINT)) ||
             (GadgetID == _R(IDC_EDIT_TINTSLIDER)))
    {
        if (Bob->GetType() == COLOURTYPE_TINT && !Bob->TintIsShade())
            *Result = String_256(_R(IDS_EDITST_TINT1));     // It's a tint
        else
            *Result = String_256(_R(IDS_EDITST_TINT2));     // It's a shade
    }
    else if (GadgetID == _R(IDC_EDIT_SHADE))
    {
        *Result = String_256(_R(IDS_EDITST_TINT2));         // It's a shade
    }
    else if (GadgetID == _R(IDC_EDIT_ADVANCED))
    {
        if (Editor->Folded)
            *Result = String_256(_R(IDS_EDITST_ADVANCED1));
        else
            *Result = String_256(_R(IDS_EDITST_ADVANCED2));
    }
    else if (GadgetID == _R(IDC_EDIT_3D))
    {
        *Result = String_256(_R(IDS_EDITST_3D));
    }
    else if (GadgetID == _R(IDC_EDIT_MAKESTYLE))
    {
        *Result = String_256(_R(IDS_EDITST_MAKESTYLE));
    }
#endif // WEBSTER
    else if (GadgetID == _R(IDC_EDIT_PICKER))
    {
        if (!StatusHelpBuffer.IsEmpty())
            *Result = StatusHelpBuffer;
        else
        {
            switch(Bob->GetType())
            {
            // WEBSTER - markn 14/12/96
            #ifndef WEBSTER
                case COLOURTYPE_TINT:
                    if (Editor->Folded)
                        *Result = String_256(_R(IDS_EDITST_PICKER1));
                    else
                        *Result = String_256(_R(IDS_EDITST_PICKER2));
                    break;

                case COLOURTYPE_LINKED:
                    *Result = String_256(_R(IDS_EDITST_PICKER3));
                    break;
            #endif // WEBSTER

                case COLOURTYPE_NORMAL:
                case COLOURTYPE_SPOT:
                default:
                    *Result = String_256(_R(IDS_EDITST_PICKER4));
                    break;
            }
        }
    }   
    else if (GadgetID == _R(IDC_EDIT_216ONLY))
    {
        *Result = String_256(_R(IDS_EDITST_216ONLY));
    }   
    else if (GadgetID == _R(IDC_COLOURPICKER))
    {
        *Result = String_256(_R(IDS_STATICCOLOURPICKERTOOLHELP));
    }
    else if (GadgetID == _R(IDC_MAKE_LOCAL))
    {
        *Result = String_256(_R(IDS_EDITST_MAKE_LOCAL));
    }
    else if (GadgetID == _R(IDC_EDIT_NOCOLOUR))
    {
        *Result = String_256(_R(IDS_EDITST_SETNOCOLOUR));
    }
    else if (GadgetID == _R(IDC_EDIT_RENAME))
    {
        *Result = String_256(_R(IDS_EDITST_RENAME));
    }
    else if (GadgetID == _R(IDC_EDIT_LINEFILL))
    {
        *Result = String_256(_R(IDS_EDITST_LINEFILL));
    }
#endif
    return(TRUE);
}



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

>   static BOOL ColourPicker::GetStatusLineText(String_256 *Result)

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

    Outputs:    If return value is TRUE, Result is updated with an appropriate help string

    Returns:    TRUE if it changed Result, FALSE if it can offer no help

    Purpose:    Bodge to get around the fact that DialogOps don't plug into the status
                line help system. Returns help for the colour editor. Must go via the
                winoil, as we have to read the mouse position and find the window it's in.

    Notes:      This is a huge bodge:
                    1) DialogOp should do this for us
                    2) I'm on holiday in a day's time, I don't have time to do it properly
                    3) It only gives help for the picker control because I can't work out
                        a quick & easy way ofgetting WindowID and GadgetID

    SeeAlso:    ColourEditDlg::GetStatusLineText

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

#ifndef STANDALONE
static UINT32 GadgetList[] = 
    {
//      IDCANCEL,
        _R(IDC_EDIT_DROPMENU),
        _R(IDC_EDIT_COMPONENT1),
        _R(IDC_EDIT_COMPONENT2),
        _R(IDC_EDIT_COMPONENT3),
        _R(IDC_EDIT_COMPONENT4),
        _R(IDC_EDIT_COLMODEL),
        _R(IDC_EDIT_NAMEMENU),
        _R(IDC_EDIT_COLTYPE),
        _R(IDC_EDIT_INHERIT1),
        _R(IDC_EDIT_INHERIT2),
        _R(IDC_EDIT_INHERIT3),
        _R(IDC_EDIT_INHERIT4),
        _R(IDC_EDIT_PICKER),
        _R(IDC_EDIT_PATCH),
        _R(IDC_EDIT_PARENTPATCH),
        _R(IDC_EDIT_PARENTCOL),
        _R(IDC_EDIT_TINT),
        _R(IDC_EDIT_SHADE),
        _R(IDC_EDIT_ADVANCED),
        _R(IDC_EDIT_PARENTNAME),
//      _R(IDC_EDIT_TINTSLIDER),
//      _R(IDC_EDIT_PICKERBORDER),
        _R(IDC_EDIT_3D),
        _R(IDC_EDIT_MAKESTYLE),

        _R(IDC_EDIT_NOCOLOUR),
        _R(IDC_EDIT_LINEFILL),
        _R(IDC_EDIT_216ONLY),
        _R(IDC_MAKE_LOCAL),
        _R(IDC_EDIT_RENAME),
        _R(IDC_COLOURPICKER),
        0
    };
#endif


BOOL ColourPicker::GetStatusLineText(String_256 *Result)
{
#ifndef STANDALONE

    ERROR3IF(Result == NULL, "Illegal NULL param");
    
    ColourEditDlg *Editor = ColourEditDlg::TheEditor;
    if (Editor == NULL)
        return(FALSE);

    // Find the main editor window
    CWindowID TheWindow = (CWindowID)Editor->WindowID;
    if (TheWindow == NULL)
        return(FALSE);

    wxPoint mousepos = ::wxGetMousePosition();
    wxWindow * window=::wxChildWindowFromPoint(TheWindow, mousepos, FALSE, -1);
    if ((!window) || (window!=::wxChildWindowFromPoint(mousepos, FALSE, -1))) // second check to ensure it is not obscured
        return FALSE;

    return GetStatusLineText(Editor, window->GetId(), Result);
#else
    return(TRUE);
#endif
}



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

>   TCHAR *ColourPicker::HelpCallbackHandler(CWindowID Window, UINT32 Item, void *UserData)

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

    Inputs:     Window - identifies the window to get help for
                Item   - identifies the control to get help for
                UserData - User-supplied data (not used)

    Returns:    The bubble help string to use, or NULL if no help is available

    Purpose:    Help callback handler to provide bubble help for the colour editor

    SeeAlso:    ColourPicker::UpdateBubbleHelpAndPointer

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

TCHAR *ColourPicker::HelpCallbackHandler(CWindowID Window, UINT32 Item, void *UserData)
{
#ifndef STANDALONE
    static String_256 HelpStringStore;
    BOOL ReturnVal = FALSE;

    ColourEditDlg *Editor = ColourEditDlg::TheEditor;
    if (Editor == NULL)
        return(NULL);

    IndexedColour *Bob = Editor->EditingColour;

    ColourContext *cc = NULL;
    if (Bob != NULL)
        cc = ColourContext::GetGlobalDefault(ColourEditDlg::DisplayModel);

    if (FALSE) {}
    else if (Item == _R(IDC_EDIT_DROPMENU))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_MENU));
        ReturnVal = TRUE;
    }
    else if ((Item == _R(IDC_EDIT_PATCH1))  ||  // Fake ID for current colour patch to give it a unique ID
             (Item == _R(IDC_EDIT_PATCH2)) ||   // Fake ID for current colour patch to give it a unique ID
             (Item == _R(IDC_EDIT_PATCH)) ||
             (Item == _R(IDC_EDIT_PICKER)))
    {
        // NOTE: This gives help for "Original/Current colour" patch
        // We will only get called for this if it is necessary (pointer in correct region of control)
        HelpStringStore = PickerBubbleBuffer; //String_256(_R(IDS_EDITBH_PARENTPATCH));
        ReturnVal = TRUE;
    }   

    else if (Item == _R(IDC_EDIT_COMPONENT1))
    {
        if (cc)
            ReturnVal = GetComponentHelp(cc, 1, HelpStringStore);
    }
    else if (Item == _R(IDC_EDIT_COMPONENT2))
    {
        if (cc)
            ReturnVal = GetComponentHelp(cc, 2, HelpStringStore);
    }
    else if (Item == _R(IDC_EDIT_COMPONENT3))
    {
        if (cc)
            ReturnVal = GetComponentHelp(cc, 3, HelpStringStore);
    }
    else if (Item == _R(IDC_EDIT_COMPONENT4))
    {
        if (cc)
            ReturnVal = GetComponentHelp(cc, 4, HelpStringStore);
    }
#if 0
    {
        if (ColourEditDlg::DisplayModel == COLOURMODEL_HSVT)
        {
            HelpStringStore = String_256(_R(IDS_EDITBH_COMP1));
            ReturnVal = TRUE;
        }
        else
        {
            if (cc != NULL)
            {
                String_64 CompName;
                cc->GetComponentName(1, &CompName, TRUE);
                HelpStringStore.MakeMsg(_R(IDS_EDITBH_COMP234), (TCHAR *)CompName);
                ReturnVal = TRUE;
            }
        }
    }

    else if (Item == _R(IDC_EDIT_COMPONENT2))
    {
        if (cc != NULL)
        {
            String_64 CompName;
            cc->GetComponentName(2, &CompName, TRUE);
            HelpStringStore.MakeMsg(_R(IDS_EDITBH_COMP234), (TCHAR *)CompName);
            ReturnVal = TRUE;
        }
    }   

    else if (Item == _R(IDC_EDIT_COMPONENT3))
    {
        if (cc != NULL)
        {
            String_64 CompName;
            cc->GetComponentName(3, &CompName, TRUE);
            HelpStringStore.MakeMsg(_R(IDS_EDITBH_COMP234), (TCHAR *)CompName);
            ReturnVal = TRUE;
        }
    }   

    else if (Item == _R(IDC_EDIT_COMPONENT4))
    {
        if (cc != NULL)
        {
            String_64 CompName;
            cc->GetComponentName(4, &CompName, TRUE);
            HelpStringStore.MakeMsg(_R(IDS_EDITBH_COMP234), (TCHAR *)CompName);
            ReturnVal = TRUE;
        }
    }   

#endif
    else if (Item == _R(IDC_EDIT_COLMODEL))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_COLMODEL));
        ReturnVal = TRUE;
    }   
    else if (Item == _R(IDC_EDIT_NAMEMENU))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_NAME));
        ReturnVal = TRUE;
    }
    else if (Item == _R(IDC_EDIT_WEBHEX))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_WEBHEX));
        ReturnVal = TRUE;
    }
    else if (Item == _R(IDC_EDIT_COLTYPE))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_COLTYPE));
        ReturnVal = TRUE;
    }
    else if ((Item == _R(IDC_EDIT_INHERIT1)) ||
             (Item == _R(IDC_EDIT_INHERIT2)) ||
             (Item == _R(IDC_EDIT_INHERIT3)) ||
             (Item == _R(IDC_EDIT_INHERIT4)) )
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_INHERIT));
        ReturnVal = TRUE;
    }
    else if ((Item == _R(IDC_EDIT_PARENTCOL)) ||
             (Item == _R(IDC_EDIT_PARENTNAME)))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_PARENTCOL));
        ReturnVal = TRUE;
    }
    else if ((Item == _R(IDC_EDIT_TINT)) ||
             (Item == _R(IDC_EDIT_TINTSLIDER)))
    {
        if (Bob != NULL && Bob->GetType() == COLOURTYPE_TINT && !Bob->TintIsShade())
            HelpStringStore = String_256(_R(IDS_EDITBH_TINT1));     // It's a tint
        else
            HelpStringStore = String_256(_R(IDS_EDITBH_TINT2));     // It's a shade
        ReturnVal = TRUE;
    }   
    else if (Item == _R(IDC_EDIT_SHADE))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_TINT2));         // It's a shade
        ReturnVal = TRUE;
    }   
    else if (Item == _R(IDC_EDIT_ADVANCED))
    {
        if (Editor->Folded)
            HelpStringStore = String_256(_R(IDS_EDITBH_ADVANCED1));
        else
            HelpStringStore = String_256(_R(IDS_EDITBH_ADVANCED2));
        ReturnVal = TRUE;
    }
    else if (Item == _R(IDC_EDIT_3D))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_3D));
        ReturnVal = TRUE;
    }
    else if (Item == _R(IDC_EDIT_MAKESTYLE))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_MAKESTYLE));
        ReturnVal = TRUE;
    }
    else if (Item == _R(IDC_EDIT_NOCOLOUR))
    {
        HelpStringStore = String_256(_R(IDS_COLBAR_HNOCOLOUR));
        ReturnVal = TRUE;
    }
    else if (Item == _R(IDC_MAKE_LOCAL))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_MAKE_LOCAL));
        ReturnVal = TRUE;
    }
    else if (Item == _R(IDC_EDIT_RENAME))   
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_RENAME));
        ReturnVal = TRUE;
    }
    else if (Item == _R(IDC_EDIT_LINEFILL))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_LINEFILL));
        ReturnVal = TRUE;
    }
    else if (Item == _R(IDC_EDIT_216ONLY))
    {
        HelpStringStore = String_256(_R(IDS_EDITBH_216ONLY));
        ReturnVal = TRUE;
    }   
    else if (Item == _R(IDC_COLOURPICKER))
    {
        HelpStringStore = String_256(_R(IDS_STATICCOLOURPICKERTOOLHELP));
        ReturnVal = TRUE;
    }

    if (ReturnVal)
        return((TCHAR *) HelpStringStore);

#endif

    return(NULL);
}

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

>   void ColourPicker::SetBubbleHelp(CGadgetID * GadgetList)

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    31/5/2006

    Inputs:     GadgetList - NULL terminated list of gadgets

    Returns:    -

    Purpose:    Set all the bubble help up for the colour picker

    SeeAlso:    -

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

void ColourPicker::SetBubbleHelp(CGadgetID * GadgetList)
{
    ColourEditDlg *Editor = ColourEditDlg::TheEditor;
    if (Editor == NULL)
        return;

    CGadgetID i;
    while ((i=*(GadgetList++))) // assignment
    {
        wxWindow * pGadget = DialogManager::GetGadget(Editor->WindowID, i);
        wxString s;
        if (pGadget)
        {
            if (pGadget->IsEnabled() && pGadget->IsShown())
            {
                // This is OK because HelpCallbackHandler uses a disgusting static. Not my doing
                TCHAR * pHelp = HelpCallbackHandler(Editor->WindowID, i, NULL);
                if (pHelp)
                    s=wxString(pHelp);
            }
            if (!s.IsEmpty())
                pGadget->SetToolTip(s);
            else
                pGadget->SetToolTip(NULL);
        }
    }
}

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

>   BOOL ColourPicker::GetComponentHelp(ColourContext* const pSourceContext, 
                const UINT32 ComponentIndex, StringBase& HelpString)

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

    Inputs:     pSourceContext - the ColourContext in which the component is
                ComponentIndex - the index of the component in the colour context
                (1..GetComponentCount())
    Outputs:    HelpString - a string to be displayed as help for the given component
    Returns:    TRUE : If help string constructed correctly
                FALSE : otherwise
    Purpose:    Subprocedure for HelpCallbackHandler providing help for each of the colour
                components.
    Errors:     ERROR2IF's if invalid paramters given
                ERROR3IF's for corrupt data structures
    SeeAlso:    ColourPicker::HelpCallbackHandler

********************************************************************************************/
BOOL ColourPicker::GetComponentHelp(ColourContext* const pSourceContext, const UINT32 ComponentIndex, StringBase& HelpString)
{
    ERROR2IF(pSourceContext == NULL, FALSE, "NULL parameters not allowed");
    ERROR3IF(!pSourceContext->IS_KIND_OF(ColourContext), "ColourPicker::GetComponentHelp() - pSourceContext isn't");
    ERROR2IF((ComponentIndex < 1) || (ComponentIndex > pSourceContext->GetComponentCount()), FALSE,
                "Component index out of bounds");

    // Create a string of the form "Red (0..100%)" using the colour component's name and the limits defined for
    // the component's unit
    UnitGroup* pUnitGroup = pSourceContext->GetComponentUnitGroup(ComponentIndex);
    if (pUnitGroup == NULL)
    {
        ERROR3("ColourPicker::GetComponentHelp - Model has no units");
        return FALSE;
    }
    ERROR3IF(!pUnitGroup->IS_KIND_OF(UnitGroup), "ColourPicker::GetComponentHelp() - pUnitGroup isn't");
    ScaleUnit* pUnit = pUnitGroup->GetDefaultUnit();
    if (pUnit == NULL)
    {
        ERROR3("ColourPicker::GetComponentHelp - No default units");
        return FALSE;
    }
    ERROR3IF(!pUnit->IS_KIND_OF(ScaleUnit), "ColourPicker::GetComponentHelp() - pUnit isn't");

    String_64 CompName;
    pSourceContext->GetComponentName(ComponentIndex, &CompName, TRUE);

    String_32 LowerLimit;
    Convert::DoubleToString(pUnit->GetMin(), (StringBase*)&LowerLimit, pUnit->GetDPtoShow());

    String_32 UpperLimit;
    Convert::DoubleToString(pUnit->GetMax(), (StringBase*)&UpperLimit, pUnit->GetDPtoShow());

    String_32 QualifierToken;
    const Qualifier* pQualifier = pUnit->GetQualifier();
    if (pQualifier == NULL)
    {
        ERROR3("ColourPicker::GetComponentHelp - No qualifier");
        return FALSE;
    }
    ERROR3IF(!pQualifier->IS_KIND_OF(Qualifier), "ColourPicker::GetComponentHelp - Qualifier isn't");

    if (pQualifier->IsShown())
    {
        QualifierToken = pQualifier->GetToken();
    }

    HelpString.MakeMsg(_R(IDS_EDITBH_COMP234), (TCHAR *)CompName, (TCHAR *)LowerLimit, (TCHAR *)UpperLimit, 
                        (TCHAR *)QualifierToken);

    return TRUE;
}


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

>   static void ColourPicker::UpdateBubbleHelpAndPointer(void)

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

    Purpose:    Called on Idle (or MouseMove) events to provide bubble help and update
                the mouse pointer while it is over the colour editor dialogue.

    Notes:      This is basically a bodge until a proper dialogue bubblehelp system is
                available to do everything I need to do in the colour editor.

    SeeAlso:    ColourEditDlg::GetStatusLineText

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

void ColourPicker::UpdateBubbleHelpAndPointer(void)
{
PORTNOTE("other", "Disabled ColourPicker::UpdateBubbleHelpAndPointer()")
#ifndef EXCLUDE_FROM_XARALX
#ifndef STANDALONE
    ColourEditDlg *Editor = ColourEditDlg::TheEditor;
    if (Editor == NULL)
        return;

    static CWindowID TheWindow = NULL;
    
    if (TheWindow == NULL)
        TheWindow = (CWindowID)Editor->WindowID;

    if (TheWindow == NULL)
        return;

    // We will update the bubble help every time we are called. However, we will only
    // bother checking through all the gadgets in the window a maximum of 10 times
    // per second. This stops the colour editor making a CPU interference buzzing noise
    // in my headphones while the pointer is idling over it!!
    static MonotonicTime LastUpdate;
    static UINT32 MousePos = 0;

    if (LastUpdate.Elapsed(100))
    {
        // Remember when we last checked
        LastUpdate.Sample();

        // Default to the mouse being "nowhere special" again
        TheWindow = (CWindowID)Editor->WindowID;
        MousePos = 0;

        POINT MouseScreenPos;
        if (::GetCursorPos(&MouseScreenPos))
        {
            // Only continue processing if the window under the pointer is the colour editor
            // or a child thereof. My machine makes a funny CPU buzz in my earphones when the
            // pointer is in the editor window, and it was doing this even when I had another
            // application maximised in front of camelot! ChildWindowFromPoint does not
            // determine if the child window is actually *visible*!

            CWindowID WindowUnder = ::WindowFromPoint(MouseScreenPos);

            if (WindowUnder != NULL &&
                (WindowUnder == TheWindow || ::GetParent(WindowUnder) == TheWindow))
            {
                POINT TempPos;
                TempPos.x = MouseScreenPos.x;
                TempPos.y = MouseScreenPos.y;

                // Convert to client coords in the main window
                ::ScreenToClient(TheWindow, &TempPos);

                CPoint Pos(TempPos);
                CWindowID WindowUnderPointer = ::ChildWindowFromPoint(TheWindow, Pos);
                if (WindowUnderPointer != NULL && IsWindowVisible(WindowUnderPointer))
                {
                    // Make sure that hidden windows do not provide status help!
                    INT32 WindowStyle = ::GetWindowLong(WindowUnderPointer, GWL_STYLE);
                    if ((WindowStyle & WS_VISIBLE) != 0)
                    {
                        CWindowID hGadget;
                        INT32 i = 0;
                        while (GadgetList[i] && MousePos)
                        {
                            hGadget = DialogManager::GetGadget(TheWindow, GadgetList[i]);
                            if (WindowUnderPointer == hGadget)
                            {
                                MousePos = (UINT32)GadgetList[i];
                                TheWindow = hGadget;
                            }
                            i++;
                        }
                    }
                }

                // Special check for Picker control (BODGE is a more accurate term!)
                // We look to see if the pointer is vaguely over the area of the picker used
                // to display the current/original colour patch, and only give help for that
                // region!

                if (MousePos == _R(IDC_EDIT_PICKER))
                {
                    MousePos =0;    // Default to no help if anything goes wrong

                    // Set up a ReDrawInfoType containing the click position info, and information
                    // that will come in handy (size of the gadget, and screen DPI)
                    ReDrawInfoType ExtraInfo;

                    ExtraInfo.pDC = NULL;       // No redraw info for mouse events
                    ExtraInfo.pClipRect = NULL;

                    // Get the screen DPI
                    HDC ScreenDC = CreateCompatibleDC(NULL);
                    if (ScreenDC == NULL)
                    {
                        ERROR3("ColourPicker: Unable to create screen DC");
                        return;
                    }
                    ExtraInfo.Dpi = GetDeviceCaps(ScreenDC, LOGPIXELSY);
                    DeleteDC(ScreenDC);

                    // Calculate how big the window is, in MILLIPOINTS
                    RECT WindowSize;
                    if (!GetClientRect(TheWindow, &WindowSize))
                    {
                        ERROR3("GetClientRect failed in ColourPicker");
                        return;
                    }

                    ExtraInfo.dx = (((INT32)WindowSize.right)*72000) / ExtraInfo.Dpi;
                    ExtraInfo.dy = (((INT32)WindowSize.bottom)*72000) / ExtraInfo.Dpi;

                    // Work out the MILLIPOINT coordinates of the mouse position
                    // Note that the Y value is flipped, as the kernel-origin is at the bottom left
                    // and we have to first convert the screen mouse position into client coords
                    ScreenToClient(TheWindow, &MouseScreenPos);

                    INT32 XPos = (INT32) MouseScreenPos.x;
                    INT32 YPos = (INT32) MouseScreenPos.y;

                    DocCoord MouseInfo;
                    MouseInfo.x = (XPos * 72000) / ExtraInfo.Dpi;
                    MouseInfo.y = ExtraInfo.dy - ((YPos * 72000) / ExtraInfo.Dpi);
                    ExtraInfo.pMousePos = &MouseInfo;

                    // Now call the colour editor to handle the mouse position - it will
                    // set the pointer shape as appropriate and also return us some bubble help.
                    PickerBubbleBuffer = String_128("");
                    StatusHelpBuffer = String_256("");
                    Editor->HandleIdlePointer(&ExtraInfo, &PickerBubbleBuffer, &StatusHelpBuffer, &MousePos);

                    if (MousePos)
                        ControlHelper::BubbleHelpDisable();     // On non-helpful bit of picker - cancel bubble help
                }
            }
        }
    }

    // Finally, tell the bubble help system what help we want, if any
    if (MousePos)
    {
        // Set up our callback handler to show the help if/when necessary
        ControlHelper::DoBubbleHelpOn(TheWindow, MousePos, ColourPicker::HelpCallbackHandler, NULL);
    }
#endif
#endif
}






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

>   static BOOL ColourPicker::GetComponentAsString(IndexedColour *Source,
                                                ColourContext *DestContext, INT32 ComponentIndex,
                                                String_8 *Result)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/11/94
    Inputs:     Source - The colour from which you wish to extract the component
                DestContext - The colour context in which you want the resulting component
                ComponentIndex - The component you wish to extract (1..4)
                
    Outputs:    Result - returns containing a decimal (0.0 .. 100.0) string representing
                the value of the given component of the colour as it is defined in the
                given colour model (Note: HSV Hue is done as 0..360).

    Returns:    TRUE if the value converted was out of gamut.

    Purpose:    Retrieves the colour definition of the given colour, converts it to the
                given colour model, and returns the desired component of the definition
                in that model as a decimal string appropriate for placing into a colour
                editor dialogue gadget.

    Notes:      At present, this function clips the value to lie within the legal 0.0 to 1.0
                gamut range.

    Scope:      private

    SeeAlso:    ColourPicker::SetComponentFromDouble;
                ColourPicker::SetComponentFromString

**************************