coldlog.cpp

Go to the documentation of this file.

// $Id: coldlog.cpp 1685 2006-08-09 19:25:40Z 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============================
 */

// Implementation of the following classes
//
//  ColourEditDlg   Colour editor dialogue box

/*
*/



//-----------------------------------------------------------------------------------------
// Include files

#include "camtypes.h"

//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "barsdlgs.h"
#include "bubbleid.h" 
#include "camelot.h" 
#include "ccolbar.h"
#include "colcontx.h"
#include "coldlog.h"
#include "coldrop.h"
#include "colmenu.h"
#include "colormgr.h"
#include "colourix.h"
#include "colpick.h"
#include "ctrlhelp.h"
//#include "cursor.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "dlgmgr.h"
//#include "dlgtypes.h"  - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "dragcol.h"
#include "dragmgr.h"
#include "dragpick.h"
//#include "ensure.h"   - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "errors.h"  - in camtypes.h [AUTOMATICALLY REMOVED]
#include "helpuser.h"       // For HelpUser()
//#include "ink.h"          // For NodeRenderableInk - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "jason.h"
#include "keypress.h"       // For constrain, escape, and OnKeyPress stuff
#include "lineattr.h"       // For AttrStrokeColour
//#include "msg.h"  - in camtypes.h [AUTOMATICALLY REMOVED]
#include "newcol.h"         // New colour dlg
#include "nodedoc.h"
#include "oilprog.h"        // For Beep()
//#include "ops.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "optsmsgs.h"       // For OptionsChangingMsg
#include "progress.h"
//#include "resource.h"
#include "scunit.h"         // For colour units
#include "optsunit.h"       // For default colour units
#include "sgcolour.h"       // For ColourNameDlg
//#include "will2.h"            // For string resources (v1.1)

#include "ccdc.h"           // For render-into-dialogue support
#include "dlgcol.h"
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "grnddib.h"
#include "palman.h"

//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "objchge.h"

// include files necessary for correctly supporting camelots CColourPicker custom control
//#include "mainfrm.h"
#include "statline.h"
#include "ophist.h"
#include "layer.h"

const ResourceID ColourEditDlg::IDD = _R(IDD_COLOUREDITDLG);

//-----------------------------------------------------------------------------------------

// The kernel colour picker - called via the winoil ColourPicker class
CC_IMPLEMENT_DYNCREATE(ColourEditDlg, DialogOp)
CC_IMPLEMENT_DYNAMIC(ColEditorDragTarget, KernelDragTarget)
CC_IMPLEMENT_DYNCREATE(ColEditorDragInfo, ColourDragInformation)
CC_IMPLEMENT_DYNCREATE(OpMakeColourLocalToFrame, UndoableOperation)


// CAM_DEBUG_NEW is defined a couple of pages further down...

//-----------------------------------------------------------------------------------------

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

    Preference:     ColourEditorAutoModel
    Section:        Displays
    Range:          TRUE or FALSE
    Purpose:        If TRUE, the colour editor will automatically switch the display colour
                    model whenever it switches to a new LOCAL colour (to that colour's model)
                    If FALSE, the only time the display colour model will change is when
                    the user explicitly sets a different colour model from the dialogue.
    Notes:          Normal preference, available from the options dialogue.
    SeeAlso:        ColourEditDlg

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

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

    Preference:     ColourEditorAutoModelN
    Section:        Displays
    Range:          TRUE or FALSE
    Purpose:        If TRUE, the colour editor will automatically switch the display colour
                    model whenever it switches to a new NAMED colour (Colour STYLE) (to that
                    colour's model)
                    If FALSE, the only time the display colour model will change is when
                    the user explicitly sets a different colour model from the dialogue.
    Notes:          Normal preference, available from the options dialogue.
    SeeAlso:        ColourEditDlg

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

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

    Preference:     ColourEditorDisplayModel
    Section:        Displays
    Range:          1..15 (COLOURMODEL_XXXX enum). If an invalid setting is chosen,
                    then COLOURMODEL_HSVT will be selected by default
    Purpose:        Retains a 'memory' of the last used Colour Editor display model
                    between sessions in Camelot. Used for LOCAL COLOURS
    Notes:          Internal 'memory' preference, not directly settable by the user
    SeeAlso:        ColourEditDlg; ColourModel

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

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

    Preference:     ColourEditorDisplayModelN
    Section:        Displays
    Range:          1..15 (COLOURMODEL_XXXX enum). If an invalid setting is chosen,
                    then COLOURMODEL_HSVT will be selected by default
    Purpose:        Retains a 'memory' of the last used Colour Editor display model
                    between sessions in Camelot. used for COLOUR STYLES
    Notes:          Internal 'memory' preference, not directly settable by the user
    SeeAlso:        ColourEditDlg; ColourModel

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

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

    Preference:     ColourEditorFolded
    Section:        Displays
    Range:          TRUE or FALSE
    Purpose:        Retains a 'memory' of the colour editor 'folded' state between
                    sessions in Camelot.
    Notes:          Internal 'memory' preference, not directly settable by the user
    SeeAlso:        ColourEditDlg

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

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

    Preference:     ColourEditorSplitLine
    Section:        Displays
    Range:          TRUE or FALSE
    Purpose:        Determines if the sliders in the colour editor show a 'split line'
                    display. If FALSE, a simple display is given where each slider just
                    shows the component being set (e.g. in RGB, the Red slider shades
                    between black and red)
                    If TRUE, the split mode is enabled, where the slider shows the normal
                    grad-fill in the top half (black to red), but fills the bottom half
                    with the range of colours which will result from changing that 
                    component of the edited colour (i.e. at any point on the slider it
                    shows what colour you will get if you click on that spot)
    Notes:          Secret squirrel preference! THis may become available in the options
                    dialogue if it is decided that it is useful.
    SeeAlso:        ColourEditDlg

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

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

    Preference:     ColourEditorUse3D
    Section:        Displays
    Range:          TRUE or FALSE
    Purpose:        If FALSE, the RGB/CMYK colour pickers in the colour editor will be
                    simple sliders. If TRUE, the '3d colour cube' display will be used instead
    SeeAlso:        ColourEditDlg

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

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

    Preference:     ColourEditorHSVHueTop
    Section:        Displays
    Range:          TRUE or FALSE
    Purpose:        If TRUE, the HSV colour picker shows the SV Pane with full hue at the top
                    (as all version did prior to Xara X1)
                    If FALSE, the HSV colour picker shows the SV Pane with full hue at the bottom
    SeeAlso:        ColourEditDlg

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

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

    Preference:     UsePrintCMYK
    Section:        Displays
    Range:          TRUE or FALSE
    Purpose:        If TRUE, use print profile to do RGB-CMYK colour conversion
    SeeAlso:        ColourEditDlg

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


// PREFERENCES
INT32 ColourEditDlg::DefaultDisplayModel  = (INT32) COLOURMODEL_HSVT;
INT32 ColourEditDlg::DefaultDisplayModelN = (INT32) COLOURMODEL_HSVT;
INT32 ColourEditDlg::AutoModelChange    = FALSE;            // When new colour set, change Displaymodel (LOCAL)

// WEBSTER - markn 31/1/97
// Don't autochange named colour display model (i.e. set to FALSE instead of TRUE
#ifndef WEBSTER
INT32 ColourEditDlg::AutoModelChangeN = TRUE;           // When new colour set, change Displaymodel (STYLE)
#else
INT32 ColourEditDlg::AutoModelChangeN = FALSE;          // When new colour set, change Displaymodel (STYLE)
#endif // WEBSTER

INT32 ColourEditDlg::Folded         = TRUE;             // Is the dlg folded?
INT32 ColourEditDlg::SplitLineDisplay   = FALSE;            // Show sliders in split gradfill way
INT32 ColourEditDlg::Use3DDisplay       = FALSE;            // Show sliders rather than colourcube

// If FALSE turns the SV square upside down compared to previous versions
BOOL ColourEditDlg::bHSVHueAtTop = TRUE;

BOOL ColourEditDlg::bUsePrintCMYK = TRUE;

//-----------------------------------------------------------------------------------------

// Statics
BOOL ColourEditDlg::EditingLineColour = FALSE;          // Default to editing local fill colours
BOOL ColourEditDlg::UpdateOnNextIdle  = FALSE;          // Callback - Update the dialogue on the next idle event

BOOL ColourEditDlg::resetColPickPos;                    // by default - we don't need to reset
RECT ColourEditDlg::colPickOrigRect;                    // store the original location of
                                                        // custom colour picker control
BOOL ColourEditDlg::needColPickHidden;
BOOL ColourEditDlg::colPickHidden;

AbortColourState ColourEditDlg::abortColourState;

BOOL ColourEditDlg::EscapeKeyWasPressed = FALSE;        // record the fact of whether the
                                                        // escape key has been pressed.

// NOTE:  the above variable is used as a bodge fix.  For some reason, ColourEditDlg::OnKeyPress ()
//        (which internally calls SetNewValueFromMousePos ()) seems to be failing to detect that
//        the escape key is pressed.  Since OnKeyPress already knows this, lets record this fact
//        and take things from there.  Although this is a bodge fix, this new method actually
//        appears to work better than the original (I can't find the problem) one.

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

>   class ColourEditDlgParam : public OpParam

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

    Purpose:    The OpParam to use when Invoke()ing the ColourEditDlg
                You shouldn't ever need to use this - just call the static function
                ColourEditDlg::InvokeDialog if you want a colour editor

    Scope:      private
    SeeAlso:    ColourEditDlg::InvokeDialog; ColourPicker::EditColour

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

class ColourEditDlgParam : public OpParam
{
CC_DECLARE_MEMDUMP(ColourEditDlgParam)

public:
    ColourEditDlgParam(ColourList *TheParentList, IndexedColour *TheColourToEdit)   \
                    : OpParam(0, 0)                                                 \
            { ParentList = TheParentList; ColourToEdit = TheColourToEdit; };

    ColourList      *ParentList;
    IndexedColour   *ColourToEdit;
};


CC_IMPLEMENT_MEMDUMP(ColourEditDlgParam, OpParam)



//-----------------------------------------------------------------------------------------
// This must be defined AFTER all CC_IMPLEMENT_DYNCREATE calls
#define new CAM_DEBUG_NEW


//-----------------------------------------------------------------------------------------
// Local (file or class scope) constants/statics

const INT32 CROSSRADIUS = 6000;     // Marker cross is 1/6th of an inch across (millipoints)
const INT32 PCROSSRADIUS = 3500;        // Marker cross to indicate parent position is smaller
const INT32 ZSLIDERSIZE = 8000;     // Size of Z slider in 3d mode
const INT32 PATCHSIZE   = 13500;        // Size of original/current colour patch square

const CDlgMode ColourEditDlg::Mode = MODELESS;          // Mode of the dialog  

ColourEditDlg *ColourEditDlg::TheEditor = NULL;         // THE instantiation of this dlg
ColourModel ColourEditDlg::DisplayModel = COLOURMODEL_HSVT; // Default DisplayModel
INT32 ColourEditDlg::ColourPickerMode = 0;              // Default picker axis orientation


static CGadgetID TintGadgetIDs[] =  // NULL terminated list of special tint gadgets
{
    _R(IDC_EDIT_TINTNAME),              // This first item is used to determine positioning
    _R(IDC_EDIT_TINT),
    _R(IDC_EDIT_TINTPERCENT),
//  _R(IDC_EDIT_TINTSLIDER),
    _R(IDC_EDIT_SHADE),
    _R(IDC_EDIT_SHADEPERCENT),
    0
};


static CGadgetID LinkGadgetIDs[] =  // NULL terminated list of special linked-colour gadgets
{
    _R(IDC_EDIT_INHERITNAME),           // This first item is used to determine positioning
    _R(IDC_EDIT_INHERIT1),
    _R(IDC_EDIT_INHERIT2),
    _R(IDC_EDIT_INHERIT3),
    _R(IDC_EDIT_INHERIT4),
    0
};


static CGadgetID OtherGadgetIDs[] = // NULL terminated list of all non tint/link gadgets
{                                   // which should be shaded to shade the dialogue
    _R(IDC_EDIT_NAMEMENU),
    _R(IDC_EDIT_COMPONENT1),
    _R(IDC_EDIT_COMPONENT2),
    _R(IDC_EDIT_COMPONENT3),
    _R(IDC_EDIT_COMPONENT4),
    _R(IDC_EDIT_WEBHEX),
    _R(IDC_NAME_COMPONENT1),
    _R(IDC_NAME_COMPONENT2),
    _R(IDC_NAME_COMPONENT3),
    _R(IDC_NAME_COMPONENT4),
    _R(IDC_NAME_WEBHEX),
    _R(IDC_EDIT_COLMODEL),
    _R(IDC_EDIT_3D),
    _R(IDC_EDIT_COLTYPE),
    _R(IDC_EDIT_MAKESTYLE),
#ifndef WEBSTER
    _R(IDC_EDIT_ADVANCED),  // WEBSTER - markn 11/12/96
#endif // WEBSTER
    _R(IDC_EDIT_DROPMENU),
    _R(IDC_EDIT_PARENTCOL),
    _R(IDC_EDIT_PARENTNAME),
    _R(IDC_EDIT_216ONLY),
//  WEBSTER-ranbirr-27/03/97
    _R(IDC_EDIT_NOCOLOUR),
    _R(IDC_EDIT_LINEFILL),
    _R(IDC_MAKE_LOCAL),
    _R(IDC_EDIT_RENAME),
    _R(IDC_COLOURPICKER),
    0
};

typedef struct
{
    CGadgetID   Gadget;                     // Gadget ID
    UINT32      BubbleID;                   //Bubble help ID for this gadget
} GadgetHelpInfo;

static GadgetHelpInfo GadgetHelp[] = 
{
    { _R(IDC_EDIT_DROPMENU),    _R(IDS_EDITBH_MENU) },
    { _R(IDC_EDIT_COLMODEL),    _R(IDS_EDITBH_COLMODEL) },
    { _R(IDC_EDIT_NAMEMENU),    _R(IDS_EDITBH_NAME) },
    { _R(IDC_EDIT_COLTYPE),     _R(IDS_EDITBH_COLTYPE) },
    { _R(IDC_EDIT_INHERIT1),    _R(IDS_EDITBH_INHERIT) },
    { _R(IDC_EDIT_INHERIT2),    _R(IDS_EDITBH_INHERIT) },
    { _R(IDC_EDIT_INHERIT3),    _R(IDS_EDITBH_INHERIT) },
    { _R(IDC_EDIT_INHERIT4),    _R(IDS_EDITBH_INHERIT) },
    { _R(IDC_EDIT_PARENTCOL),   _R(IDS_EDITBH_PARENTCOL) },
    { _R(IDC_EDIT_3D),          _R(IDS_EDITBH_3D) },
    { _R(IDC_EDIT_MAKESTYLE),   _R(IDS_EDITBH_MAKESTYLE) },
    { _R(IDC_EDIT_NOCOLOUR),    _R(IDS_COLBAR_HNOCOLOUR) },
    { _R(IDC_EDIT_LINEFILL),    _R(IDS_EDITBH_LINEFILL) },
    { _R(IDC_EDIT_216ONLY),     _R(IDS_EDITBH_216ONLY)  },
    { _R(IDC_MAKE_LOCAL),       _R(IDS_EDITBH_MAKE_LOCAL)   },
    { _R(IDC_EDIT_RENAME),      _R(IDS_COLBAR_HNOCOLOUR) },
    { _R(IDC_COLOURPICKER),     _R(IDS_STATICCOLOURPICKERTOOLHELP) },
    { 0, 0 }                            // List terminator
};


// Two utility functions to get slider sizing right

INT32 GetSliderHeight(INT32 RectHeight, INT32 Num)
{
    INT32 AvailableHeight = (RectHeight / Num) - 4000; // subtract the minimum gap size
    if (AvailableHeight<2000)
        AvailableHeight = 2000; // minimum height
    return (AvailableHeight>18000)?18000:AvailableHeight;
}

INT32 GetSliderGap(INT32 RectHeight, INT32 Num)
{
    INT32 SliderGap = (RectHeight / Num) - GetSliderHeight(RectHeight, Num);
    if (SliderGap < 4000)
        SliderGap = 4000;
    return SliderGap;
}


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

>   void ColourEditDlg::LoseKeyboardFocus(void)

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

    Purpose:    Colour Editor focus bodge thingummy
                Returns the input focus back to the selected document (mainframe window)

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

static BOOL TextMayBeWrong = FALSE;                     // Flag indicating that we might need to update
                                                        // a component field when losing the keyboard focus

static BOOL LoseKbdFocusPending = FALSE;                // Flag used to indicate to the OnIdleEvent
                                                        // handler that we wish to lose the kbd focus

static BOOL LockLoseFocus = FALSE;                      // TRUE if focus-losing is locked (we are nto allowed
                                                        // to try to throw away the input focus while it's TRUE)

static BOOL LoseFocusFromEditControls = FALSE;          // TRUE if we should lose the focus if it's inside an
                                                        // edit/writable control. Usually FALSE except on commit.

void ColourEditDlg::LoseKeyboardFocus(void)
{
//  ControlHelper::BubbleHelpDisable();                 // Ensure any open bubble help is killed

    if (!LockLoseFocus)
    {
        // If we don't want to throw away the focus from edit controls, we'll check for that case
        if (!LoseFocusFromEditControls)
        {
            // AWOOGA! NASTY WINOIL CODE HACK NASTINESS YUCK YUCK YUCK !!!! ****
            CWindowID Focus = wxWindow::FindFocus();
            if (Focus != NULL)
            {
                static UINT32 WritableGadgets[] = 
                {
                    _R(IDC_EDIT_COMPONENT1),
                    _R(IDC_EDIT_COMPONENT2),
                    _R(IDC_EDIT_COMPONENT3),
                    _R(IDC_EDIT_COMPONENT4),
                    _R(IDC_EDIT_WEBHEX),
                    _R(IDC_EDIT_TINT),
                    _R(IDC_EDIT_SHADE),
                    _R(IDC_COLOURPICKER),
                    //_R(IDC_EDIT_216ONLY),
                    0
                };

                // Look to see if the input focus belonhgs to an edit control in our window.
                // If it does, then we won't throw the focus away - we'll return immediately.
                INT32 i = 0;
                while (WritableGadgets[i])
                {
                    if (Focus == DialogManager::GetGadget(WindowID, WritableGadgets[i]))
                        return;

                    i++;
                }
            }
        }

        DialogManager::DefaultKeyboardFocus();

        // And ensure that all component gadgets are updated - if the user was editing
        // in one, then we need to chop it back to displaying the value to 1 d.p. with a %, etc
        if (EditingColour != NULL && TextMayBeWrong)
        {
            SetComponentInfo(1, _R(IDC_NAME_COMPONENT1), _R(IDC_EDIT_COMPONENT1), _R(IDC_EDIT_INHERIT1));
            SetComponentInfo(2, _R(IDC_NAME_COMPONENT2), _R(IDC_EDIT_COMPONENT2), _R(IDC_EDIT_INHERIT2));
            SetComponentInfo(3, _R(IDC_NAME_COMPONENT3), _R(IDC_EDIT_COMPONENT3), _R(IDC_EDIT_INHERIT3));
            SetComponentInfo(4, _R(IDC_NAME_COMPONENT4), _R(IDC_EDIT_COMPONENT4), _R(IDC_EDIT_INHERIT4));   

            SetAllHexComponentsInfo ((UINT32)-1, _R(IDC_NAME_WEBHEX), _R(IDC_EDIT_WEBHEX));
        }

        TextMayBeWrong = FALSE;

        LoseKbdFocusPending = FALSE;        // And clear the pending flag
    }
}


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

> BOOL ColourEditDlg::SetUnitGroupDefaults(ColourModel ColModel)

    Author:     Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com>
    Created:    02/05/96
    Imputs:     ColModel = colour model we're editing (for WEBSTER - markn 9/1/97)
    Purpose:    Sets the default ScaleUnits for the Colour Editor (actually sets
                StandardUnit groups.
    Errors:     ERROR3 if unable to initialize defaults
    Scope:      static
    SeeAlso:    class StandardUnit

********************************************************************************************/
BOOL ColourEditDlg::SetUnitGroupDefaults(ColourModel ColModel)
{
// WEBSTER - markn 9/1/97
// Rather than get the unit preference from the units tab (which doesn't exist in Webster)
// it chooses between percent ('%') and 0-255 ('d') unit types dependant on the colour model.
// HSV shows its values in '%' format
// RGB shows its values in 0-255 format
//

#ifdef WEBSTER
// WEBSTER - markn 23/1/97
// We've decided to make both models use percentages as the default unit type
    ScaleUnit* pUnit = StandardUnit::PercentGroup.FindUnitFromIndex(0); // percentage '%'
#else
    ScaleUnit* pUnit = UnitsTab::GetColourUnitPreference();
#endif // WEBSTER

    if (pUnit == NULL || !pUnit->IS_KIND_OF(ScaleUnit))
    {
        ERROR3("Failed to get a default unit");
        return FALSE;
    }
    StandardUnit::PercentGroup.SetDefaultUnit(pUnit);

    StandardUnit::AngleGroup.SetDefaultUnit(&StandardUnit::UnitDegree);
    return TRUE;
}


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

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

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/6/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Default constructor for the colour editor dialogue class
    Notes:      You shouldn't really use this constructor if you can avoid it
    Errors:     -
    SeeAlso:    -

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

ColourEditDlg::ColourEditDlg(): DialogOp(ColourEditDlg::IDD, ColourEditDlg::Mode) 
{
    // If there is no existing editor, make us "the" editor instantiation
    // Otherwise, we'll realise our mistake (in Do/DoWithParam) and kill ourself
    if (TheEditor == NULL)
        TheEditor = this;

    ParentList      = NULL;
    ResultColour    = NULL;
    EditingColour   = NULL;
    ISentTheMessage = FALSE;
    AmShaded        = FALSE;

    DragStartArea     = CEDRAG_NONE;
    DragUpdatedOnIdle = FALSE;
    FirstEdit         = TRUE;

    ResetState();

// WEBSTER - markn 31/1/97
// Bodge - uses the Named default value to keep that model preserved
#ifndef WEBSTER
    DisplayModel    = (ColourModel) DefaultDisplayModel;
#else
    DisplayModel    = (ColourModel) DefaultDisplayModelN;
#endif // WEBSTER

    AbortColour = NULL;

    NameDropDown    = NULL;
    ParentDropDown  = NULL;

    CurrentCursorID = 0;
    CurrentCursor   = NULL;

    m_bDoingSetGadget = FALSE;
    m_NeedsResize = FALSE;
    GetApplication()->RegisterIdleProcessor(IDLEPRIORITY_LOW, this);
}



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

>   ColourEditDlg::~ColourEditDlg()

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/6/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Destructor for the colour editor dialogue class
    Errors:     -
    SeeAlso:    -

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

ColourEditDlg::~ColourEditDlg()
{
    GetApplication()->RemoveIdleProcessor(IDLEPRIORITY_LOW, this);
    EndTimedProcessing();

    if (EditingColour != NULL)
    {
        // Ensure we remember the current model as the preferred default
        if (EditingColour->IsNamed())
            DefaultDisplayModelN = (INT32) DisplayModel;
// But do not overwrite the preference for local colours - this must be set in the options dlg
//      else
//          DefaultDisplayModel = (INT32) DisplayModel;

        delete EditingColour;
    }

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

    // If we were the current active editor instantiation then we indicate there
    // is no longer an editor open.
    if (TheEditor == this)
        TheEditor = NULL;

    // Delete our drop-down colour list support objects
    if (NameDropDown != NULL)
        delete NameDropDown;

    if (ParentDropDown != NULL)
        delete ParentDropDown;

    if (CurrentCursor != NULL)
        delete CurrentCursor;
}



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

>   void ColourEditDlg::SetColourNameList(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/12/94
    Purpose:    Initialises the colour editor dialogue name combo-box list
    Scope:      private

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

void ColourEditDlg::SetColourNameList(void)
{
    if (State.ParentListOK)
        return;

    // Get a description of the current local colour
    SelRange *Selection = GetApplication()->FindSelection();
//
//  String_256 SelDesc = Selection->Describe(MENU);
//  String_256 ColourDesc(TEXT("(No selection colour)"));;
//  if (Selection->Count() != 0)
//      ColourDesc._MakeMsg("Colour of #1%s", (TCHAR *)SelDesc);


    Progress Hourglass;     // Start an hourglass running. On destruction it'll turn it off again

    BOOL OldSentState = ISentTheMessage;
    ISentTheMessage = TRUE;

    if (NameDropDown != NULL)
        delete NameDropDown;
    NameDropDown = new ColourDropDown;

    BOOL ok = TRUE;
    if (NameDropDown == NULL || !NameDropDown->Init(WindowID, _R(IDC_EDIT_NAMEMENU)))
        ok = FALSE;

    if (ok)
    {
        String_256 FillColDesc(_R(IDS_COLEDIT_FILL));
        String_256 LineColDesc(_R(IDS_COLEDIT_LINE));

        if (Selection->Count() == 0)        // No selection, so will use current colours
        {
            FillColDesc = String_256(_R(IDS_COLEDIT_CURFILL));
            LineColDesc = String_256(_R(IDS_COLEDIT_CURLINE));
        }

        // Ensure there are no special entries in the list, then add the 2 we want this time
        NameDropDown->ClearAllSpecialEntries();

        ColourList  *NewParentList  = NULL;
        DocColour   DocColourToEdit;
        ColourManager::FindColourOfInterestToUser(&DocColourToEdit, &NewParentList, FALSE);
        
        ok = NameDropDown->AddSpecialEntry(&FillColDesc, &DocColourToEdit);
        if (ok)
        {
            ColourManager::FindColourOfInterestToUser(&DocColourToEdit, &NewParentList, TRUE);
            ok = NameDropDown->AddSpecialEntry(&LineColDesc, &DocColourToEdit);
        }

        if (ok)
        {
            // Determine if we're editing a named colour, or a current colour
            IndexedColour *Ptr = NULL;
            if (ParentList != NULL)
            {
                Ptr = (IndexedColour *) ParentList->GetHead();
                while (Ptr != NULL)
                {
                    if (!Ptr->IsDeleted() && Ptr->IsNamed())
                    {
                        if (Ptr == ResultColour)
                            break;
                    }
                    Ptr = (IndexedColour *) ParentList->GetNext(Ptr);
                }
            }

            // If we aren't editing a named colour (Ptr == NULL) then we're editing fill (0) or line (1) colour
            INT32 SelIndex = -1;
            if (Ptr == NULL)
                SelIndex = (EditingLineColour) ? 1 : 0;

            // Fill in the list
            ok = NameDropDown->FillInColourList(Ptr, SelIndex);

            // NOTE: We could do a SetComboListLength here, except that this causes awful
            // redraws of everything "behind" the combo-list extent. I can't stop it doing this,
            // other than by not setting the list length... so I don't
        }
    }

    // If we failed, then we shade this control so that some semblance of stability remains
    if (!ok)
        EnableGadget(_R(IDC_EDIT_NAMEMENU), FALSE);

/*
    INT32 Index = 0;
    INT32 SelectedIndex = 0;

    // Compile a list of all editable colours into the colour name combo-list
    GadgetRedraw(_R(IDC_EDIT_NAMEMENU), FALSE);
    DeleteAllValues(_R(IDC_EDIT_NAMEMENU));

    String_256 FillColDesc(TEXT("Fill colour"));
    String_256 LineColDesc(TEXT("Line colour"));
    String_256 DottedLine(TEXT("---------------------------------------"));

    if (Selection->Count() == 0)        // No selection, so will use current colours
    {
        FillColDesc = TEXT("Current fill colour");
        LineColDesc = TEXT("Current line colour");
    }

    SetStringGadgetValue(_R(IDC_EDIT_NAMEMENU), &FillColDesc, TRUE);    
    SetStringGadgetValue(_R(IDC_EDIT_NAMEMENU), &LineColDesc, TRUE);
    SetStringGadgetValue(_R(IDC_EDIT_NAMEMENU), &DottedLine, TRUE);
    Index += 3;
    if (EditingLineColour)
        SelectedIndex++;

    if (ParentList != NULL)
    {
        IndexedColour *Ptr = (IndexedColour *) ParentList->GetHead();
        while (Ptr != NULL)
        {
            if (!Ptr->IsDeleted() && Ptr->IsNamed())
            {
                SetStringGadgetValue(_R(IDC_EDIT_NAMEMENU), Ptr->GetName(), TRUE);
                if (Ptr == ResultColour)
                    SelectedIndex = Index;

                Index++;
            }

            Ptr = (IndexedColour *) ParentList->GetNext(Ptr);
        }
    }

    GadgetRedraw(_R(IDC_EDIT_NAMEMENU), TRUE);

    // Set the writable colour name (combo box editable) field
    SetSelectedValueIndex(_R(IDC_EDIT_NAMEMENU), SelectedIndex);
*/

    ISentTheMessage = OldSentState;

    State.ParentListOK = TRUE;
}



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

>   void ColourEditDlg::RedrawColourNameList(void)

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

    Purpose:    Ensures that the colour splodge in the colour name dropdown list is
                redrawn using the correct new appearance of the colour. Far more
                efficient than rebuilding the colour list from scratch.

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

void ColourEditDlg::RedrawColourNameList(void)
{
    if (NameDropDown == NULL)
        return;

    String_256 FillColDesc(_R(IDS_COLEDIT_FILL));
    String_256 LineColDesc(_R(IDS_COLEDIT_LINE));

    SelRange *Selection = GetApplication()->FindSelection();
    if (Selection->Count() == 0)        // No selection, so will use current colours
    {
        FillColDesc = String_256(_R(IDS_COLEDIT_CURFILL));
        LineColDesc = String_256(_R(IDS_COLEDIT_CURLINE));
    }

    ColourList  *NewParentList  = NULL;
    DocColour   DocColourToEdit;

    ColourManager::FindColourOfInterestToUser(&DocColourToEdit, &NewParentList, FALSE);
    NameDropDown->UpdateSpecialEntry(&FillColDesc, &DocColourToEdit);

    ColourManager::FindColourOfInterestToUser(&DocColourToEdit, &NewParentList, TRUE);
    NameDropDown->UpdateSpecialEntry(&LineColDesc, &DocColourToEdit);

    // And ensure that the dropdown is redrawn
    InvalidateGadget(_R(IDC_EDIT_NAMEMENU));
}



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

>   void ColourEditDlg::ResetState(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/1/95
    Purpose:    Initialises the colour editor dialogue State variable to be 'unknown'.
                The next SetControls() call after this will set all the controls in the
                window, rather than only those which are known to have changed.
    Scope:      private

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

// We fake a special colour type for shades for the State information *only*
#define COLOURTYPE_SHADE ((IndexedColourType) 32)

void ColourEditDlg::ResetState(void)
{
    State.Folded        = 2;
    State.ColType       = (IndexedColourType) 99;   // An invalid value!
    State.DisplayModel  = MAX_COLOURMODELS;
    State.ResultColour  = NULL;
    State.Initialised   = FALSE;
    State.ParentListOK  = FALSE;
}



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

>   void ColourEditDlg::SetExtent(void)

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

    Purpose:    If necessary, changes the size of the editor window and shuffles controls
                around to show folded/unfolded tint/linked information appropriately.
                If the State has not been reset or changed, this may do nothing, to minimise
                unnecessary redraws.

    Scope:      private

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

void ColourEditDlg::SetExtent(void)
{
    // Set size to small (cut off below 'more' button) or large (full-size) as appropriate
    // NOTE that this relies on the gadgets passed to SetWindowExtent being at the
    // bottom of the folded/unfolded layouts of the dialogue respectively.

    if (EditingColour == NULL)
    {
        // WEBSTER - markn 1/2/97
        #ifdef WEBSTER
        ColourPicker::SetWindowExtent(WindowID, _R(IDC_EDIT_PICKER), _R(IDC_EDIT_PICKER));
        #endif // WEBSTER
        HideGadget(_R(IDC_EDIT_ADVANCEDPANEL), TRUE);
        NeedsResize();
        return;
    }

    // If there has been no change in the colour type, we should return.
    // This is compllicated by shades, which internally are a variant of TINTs, but
    // externally are different "types".
    IndexedColourType CurrentColType = EditingColour->GetType();
    if (CurrentColType == COLOURTYPE_TINT && EditingColour->TintIsShade())
        CurrentColType = COLOURTYPE_SHADE;  // Shade is a special "Bodge" colour type

#ifndef WEBSTER
    if (State.Folded == Folded && State.ColType == CurrentColType)
        return;
#else
    // WEBSTER - markn 24/4/97
    // Always unfolded.
    Folded = FALSE; // always unfolded
#endif // WEBSTER

    NeedsResize();

    if (Folded)
    {       
        // WEBSTER - markn 11/12/96
        // Always unfolded.
        // Changed folded to show ed fields
#ifndef WEBSTER
        ColourPicker::SetWindowExtent(WindowID, _R(IDC_EDIT_PICKER), _R(IDC_EDIT_PICKER));
        //      SetStringGadgetValue(_R(IDC_EDIT_ADVANCED), _R(IDS_EDIT_MORE));
        SetBoolGadgetSelected(_R(IDC_EDIT_ADVANCED), FALSE);
#else
        ColourPicker::SetWindowExtent(WindowID, _R(IDC_EDIT_PICKER), _R(IDC_EDIT_COLTYPE));
#endif // WEBSTER
        HideGadget(_R(IDC_EDIT_ADVANCEDPANEL), TRUE);
    }           
    else
    {
        HideGadget(_R(IDC_EDIT_ADVANCEDPANEL), FALSE);
        CGadgetID Gadget = _R(IDC_EDIT_COLTYPE);

        if (EditingColour != NULL)  // If we have an editing colour, set tint/link controls
        {
            switch (EditingColour->GetType())
            {
                case COLOURTYPE_TINT:
                    {
                        Gadget = _R(IDC_EDIT_TINT);
                        HideGadgetList(LinkGadgetIDs, TRUE);
                        HideGadgetList(TintGadgetIDs, FALSE);
                        HideGadget (_R(IDC_EDIT_PARENTNAME), FALSE);
                        HideGadget (_R(IDC_EDIT_PARENTCOL), FALSE);
                        // ColourPicker::SetGadgetPositions(WindowID, LinkGadgetIDs, 0);
                        // ColourPicker::SetGadgetPositions(WindowID, TintGadgetIDs, _R(IDC_EDIT_PARENTCOL));

                        // And if it's not a shade, hide the extra writable field
                        HideGadget(_R(IDC_EDIT_SHADE), !EditingColour->TintIsShade());
                        HideGadget(_R(IDC_EDIT_SHADEPERCENT), !EditingColour->TintIsShade());
                    }
                    break;

                case COLOURTYPE_LINKED:
                    Gadget = _R(IDC_EDIT_INHERIT4);
                    HideGadgetList(LinkGadgetIDs, FALSE);
                    HideGadgetList(TintGadgetIDs, TRUE);
                    HideGadget (_R(IDC_EDIT_PARENTNAME), FALSE);
                    HideGadget (_R(IDC_EDIT_PARENTCOL), FALSE);
                    // ColourPicker::SetGadgetPositions(WindowID, TintGadgetIDs, 0);
                    // ColourPicker::SetGadgetPositions(WindowID, LinkGadgetIDs, _R(IDC_EDIT_PARENTCOL));
                    break;

                default:
                    HideGadget (_R(IDC_EDIT_PARENTNAME), TRUE);
                    HideGadget (_R(IDC_EDIT_PARENTCOL), TRUE);
                    HideGadgetList(LinkGadgetIDs, TRUE);
                    HideGadgetList(TintGadgetIDs, TRUE);
                    break;
            }
        }

        ColourPicker::SetWindowExtent(WindowID, _R(IDC_EDIT_PICKER), Gadget);
#ifndef WEBSTER // not included in Webster
        SetBoolGadgetSelected(_R(IDC_EDIT_ADVANCED), TRUE);
//      SetStringGadgetValue(_R(IDC_EDIT_ADVANCED), _R(IDS_EDIT_LESS));
#endif
    }

}


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

>   void ColourEditDlg::HideGadgetList(CGadgetID * Gadgets, BOOL Hide=TRUE)

    Author:     Alex Bligh
    Created:    30/5/2005

    Inputs:     Gadgets - NULL terminated list of gadgets
                Hide - TRUE to hide else FALSE to show

    Purpose:    Hides / shows the gadgets on the list

    Scope:      Protected

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

void ColourEditDlg::HideGadgetList(CGadgetID * Gadgets, BOOL Hide /*=TRUE*/)
{
    CGadgetID Gadget;
    while ((Gadget=*(Gadgets++))) // assignment
    {
        HideGadget(Gadget, Hide);   
    }
}

/*****************************************************************************
>   BOOL ColourEditDlg::OnIdleEvent()

    Author:     Alex Bligh
    Created:    30/5/2005
    Purpose:    Idle event handler for the colour dialog
                
    Returns:    FALSE (to indicate we want no more idle events)
                The wakeup from the timer will create one for us
    Errors:     -


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

BOOL ColourEditDlg::OnIdleEvent()
{
    return ColourPicker::OnIdleEvent(WindowID);
}

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

>   void ColourEditDlg::HideOrShowColourPicker()

    Author:     Alex Bligh
    Created:    30/5/2005

    Inputs:     -