ccolbar.cpp

Go to the documentation of this file.

// $Id: ccolbar.cpp 1528 2006-07-25 13:43:14Z gerry $
/* @@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============================
 */
// CColBar.cpp - implementation of the CColourBar class

/*
*/


    /*  IMPORTANT NOTE!
     *  ===============
     *  
     *  When working on the Colour Bar, it is VITAL that you remember that it
     *  differs from much of Camelot in that it works exclusively on the
     *  SelectedDocument (rather than CurrentDocument).
     *  Thus, you need to be careful to ensure that Current == Selected if you
     *  add any subroutine calls, or else you may shaft everything.
     */



#include "camtypes.h"

//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "camelot.h"
#include "ccolbar.h"
#include "colcontx.h"
#include "coldlog.h"
#include "colmsg.h"
#include "colormgr.h"
#include "colourix.h"
#include "colpick.h"
#include "comattrmsg.h"
//#include "cursor.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ctrlhelp.h"
#include "devcolor.h"
//#include "doccolor.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "dragmgr.h"
//#include "galres.h"           // For drag cursors
//#include "ink.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "jason.h"
#include "keypress.h"
#include "lineattr.h"
#include "linwthop.h"
#include "camframe.h"
#include "opgrad.h"
#include "palman.h"
//#include "range.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "resource.h"     // For push tool cursor
#include "sgcolour.h"       // For AutoScroll preference
#include "statline.h"
#include "cartprov.h"

// define this to disable use of DragManagerOp to drag colours
//#define DISABLE_COLOUR_DRAGS

// --------- ****
// DocColours (doccolor.h) currently provide a special debugging form of MakeRef...
// that trace usage of indexedcolours back to the file/line where they were first
// referenced. However, the colourbar creates many temp. ref.s during redraws,
// so we disable this debugging stuff for this file. This is fairly safe, as we
// are reasonably sure that the colour bar treats IndexedColours with proper respect.
#undef MakeRefToIndexedColour
// ---------


// Default preference styles for the colour bar (size of strip cells and scrollbar)
// Note that the Create function reads the preference and clips it to 0..MAXDEFAULTSIZES range
typedef struct
{
    INT32 Cell;
    INT32 Scrollbar;
} ColBarDefaultSizeInfo;

const INT32 MAXDEFAULTSIZES = 4;
ColBarDefaultSizeInfo ColBarDefaultSize[MAXDEFAULTSIZES] = 
{
    {12, 0},    // Small (no scroll bar)
    {16, 0},    // Medium (no scroll bar)
    {16, 9},    // Medium
    {24, 11}    // Large
};


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

    Preference:     ColourBarMode
    Section:        Displays
    Range:          0..3
    Purpose:        Specifies the 'size' at which the colour bar is displayed, with
                    values of:

                    MonoOn
                        0   Small
                        1   Medium, no scrollbar
                        2   Medium with scrollbar (default)
                        3   Large
                    MonoOff

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

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

static INT32 DefaultSizeIndex = 2;  // User preference 'ColourBarMode'- indexes the above array


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

    Preference:     ColourCellsDivided
    Section:        Displays
    Range:          0 (off) or 1 (on)
    Purpose:        If set to 0, colour cells in the colour line will butt up against each
                    other. If set to 1, a single pixel grey line will be used to divide the
                    cells, to make them easier to distinguish.

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

static INT32 ColourCellsDivided = 0;



// Redraw Constants
const INT32 SCROLLBUTTON_LEFT  = 0; // Scroll button identifiers
const INT32 SCROLLBUTTON_RIGHT = 1;

const INT32 CX_BORDER  = 2;         // Number of pixels of blank space around the edge
const INT32 CY_BORDER  = 0;         // (On top of the default 1 pixel border)

const INT32 InterControlGap = 2;        // The horizontal gap between the bar's 'controls'
const INT32 ButtonWidth   = 11;     // Width of the scrollbar left/right buttons

// The following variables are calculated and filled in by SetSizes(), but
// I've put some reasonable defaults in. Note that on construction, CellSize
// and ScrollHeight are passed to SetSizes in order to calculate the others.

static INT32 BarHeight    = 25;     // Total height of the bar window in pixels
static INT32 CellSize         = 16;     // Each Colour Cell is NxN pixels in size - preference
static INT32 ScrollHeight     = 9;      // The mini scrollbar height in pixels

                                    // The No-Colour 'cell' is a normal cell size
#define NoColourSize (CellSize)

                                    // Width and height of the edit button
#define EditButtonSizeX (CellSize)
#define EditButtonSizeY (CellSize)


// Click values - this is; nothing, a colour index (0..?), or a scroll bar/arrow
const INT32 CLICKED_NOTHING      = 10000;   // Nothing
const INT32 CLICKED_INDICATORS   = 10001;   // Over the current colour indicators
const INT32 CLICKED_LEFTSCROLL   = 10002;   // Over the left scroll arrow
const INT32 CLICKED_RIGHTSCROLL  = 10003;   // Over the right scroll arrow
const INT32 CLICKED_SCROLLBAR        = 10004;   // Over the scroll sausage
const INT32 CLICKED_SCROLLBARLEFT    = 10005;   // Over the left end of the scrollbar
const INT32 CLICKED_SCROLLBARRIGHT = 10006; // Over the right end of the scrollbar
const INT32 CLICKED_SCROLLSTRIP  = 10007;   // Over the strip, with push modifier key
const INT32 CLICKED_NOCOLOURCELL     = 10008;   // Over the 'No Colour' cell
const INT32 CLICKED_EDITBUTTON   = 10009;   // Over the 'edit colour' button
const INT32 CLICKED_NEWBUTTON        = 10010;   // Over the 'new colour' button


// Cell values for special cell 'indices' (the no-colour cell, and no-cell-at-all-mate)
const INT32 CELLINDEX_NOCOLOURCELL  = -1;
const INT32 CELLINDEX_NOCELL            = -2;


// Static member variables
//ListComparator CColourBar::SortFunction = NULL;       // We have no sort mode by default
CColourBar *CColourBar::TheColourBar = NULL;        // There is no bar currently available
BOOL CColourBar::BarIsVisible = TRUE;               // Bars will default to being visible


IMPLEMENT_DYNAMIC_CLASS(CColourBar, wxWindow)
CC_IMPLEMENT_DYNAMIC(EditButtonDragTarget, OilDragTarget)
CC_IMPLEMENT_DYNAMIC(ColourLineDragTarget, OilDragTarget)

// Declare smart memory handling in Debug builds
#define new CAM_DEBUG_NEW


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

>   inline Document *SetCurrentDoc(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/7/94
    Inputs:     -
    Outputs:    -
    Returns:    The old Current Document

    Purpose:    The ColourBar works exclusively on the SELECTED Doc.
                Thus, on entry to any of its routines which call routines
                outside this file (ccolbar.cpp), it must ensure that CurrentDoc
                is equal to SelectedDoc.
                This local macro inline does this, and returns the old setting of
                CurrentDoc so that the caller can restore the previous CurrentDoc
                on exit.

    Scope:      private (to winoil\ccolbar.cpp)
    SeeAlso:    RestoreCurrentDoc

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

inline Document *SetCurrentDoc(void)
{
    Document *OldCurrentDoc = Document::GetCurrent();
    Document *NewCurrentDoc = Document::GetSelected();

    if (NewCurrentDoc != NULL && NewCurrentDoc != OldCurrentDoc)
        NewCurrentDoc->SetCurrent();

    return(OldCurrentDoc);
}



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

>   inline void RestoreCurrentDoc(Document *OldCurrentDoc)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/7/94
    Inputs:     The old current document to restore
    Outputs:    -
    Returns:    -

    Purpose:    The ColourBar works exclusively on the SELECTED Doc.
                After calling SetCurrentDoc on entry to a routine, you should call
                RestoreCurrentDoc on exit to restore the old current document./

    Scope:      private (to winoil\ccolbar.cpp)
    SeeAlso:    SetCurrentDoc

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

inline void RestoreCurrentDoc(Document *OldCurrentDoc)
{
    if (OldCurrentDoc != NULL)
        OldCurrentDoc->SetCurrent();
}


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

>   void EditButtonDragTarget::EditButtonDragTarget() 
     
    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/1/95       
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
EditButtonDragTarget::EditButtonDragTarget(wxWindow* TheWindow, wxRect *ClientArea)
    : OilDragTarget(TheWindow, ClientArea)
{
//  TRACEUSER("Gerry", _T("EditButtonDragTarget created")); 
}



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

>   void EditButtonDragTarget::ProcessEvent(DragEventType Event,
                        DragInformation *pDragInfo,
                        wxPoint *pMousePos, KeyPress* pKeyPress) 
     
    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/1/95       
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Event Handler for Edit Drag 
    Errors:     -
    SeeAlso:    -

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

BOOL EditButtonDragTarget::ProcessEvent(DragEventType Event,
                        DragInformation *pDragInfo,
                        wxPoint *pMousePos, KeyPress* pKeyPress)
{
//  TRACEUSER("Gerry", _T("EditButtonDragTarget::ProcessEvent"));

    // Not a colour drag? That is kindof unexpected, but lets exit before
    // we embarrass ourselves

    if (!pDragInfo->IsKindOf(CC_RUNTIME_CLASS(ColourDragInformation)))
        return(FALSE);

    switch(Event)
    {
        case DRAGEVENT_COMPLETED:
            if (CColourBar::TheColourBar != NULL &&
                CColourBar::TheColourBar->m_pCurrentColourList != NULL)
            {
                if (CanDropHere(pDragInfo))
                {
                    ColourDragInformation *CDI = (ColourDragInformation *) pDragInfo;
                    IndexedColour *Col = NULL;

                    if (CDI->IsLibraryColour())
                    {
                        // We must copy the library colour into the document, but first check with
                        // the user that this is what they intended.
                    #ifndef WEBSTER
                        // Camelot builds ask the user to check that this is what they want
                        if (InformError(_R(IDE_CANTEDITLIBCOLOUR), _R(IDS_COPYLIBCOLOUR), _R(IDS_CANCEL)) == 1)
                            Col = CDI->GetColourForDocument(Document::GetSelected());
                    #else
                        // Webster builds just do it. Simplify the UI for the user
                        Col = CDI->GetColourForDocument(Document::GetSelected());
                    #endif
                    }
                    else
                        Col = CDI->GetInitiallyDraggedColour();

                    if (Col != NULL)
                        CColourBar::TheColourBar->EditAColour(CColourBar::TheColourBar->m_pCurrentColourList, Col);
                    return(TRUE);
                }
            }
            break;


        case DRAGEVENT_MOUSESTOPPED:
        case DRAGEVENT_MOUSEMOVED:
        case DRAGEVENT_MOUSEIDLE:
            // Return TRUE to claim the mouse while over our target area, so that
            // our cursor shape is used
            return(TRUE);

        default:
            break;
    }

    // Allow unknown/unwanted events to pass on to other targets
    return(FALSE);
}



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

>   void EditButtonDragTarget::GetCursorID()

    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (Rewritten, Jason)
    Created:    10/1/95 (25/3/96)
    Purpose:    Set cursor over this target

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

UINT32 EditButtonDragTarget::GetCursorID()
{
//  TRACEUSER("Gerry", _T("EditButtonDragTarget::GetCursorID"));

    DragInformation *pDragInfo = DragManagerOp::GetCurrentDragInfo();
    if (CanDropHere(pDragInfo))
        return _R(IDC_CANDROP_EDITBUTTON);

    return 0;
}



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

>   virtual BOOL EditButtonDragTarget::GetStatusLineText(String_256 * TheText)

    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (Rewritten, Jason)
    Created:    15/1/95 (25/3/96)
    Returns:    Whether String is valid
    Purpose:    provide status line text for this target
   
********************************************************************************************/

BOOL EditButtonDragTarget::GetStatusLineText(String_256 *TheText)
{
//  TRACEUSER("Gerry", _T("EditButtonDragTarget::GetStatusLineText"));

    ERROR2IF(TheText==NULL,FALSE,_T("NULL string in GetStatusLineText()"));

    // Call our helper function to find out if this can be dropped here
    DragInformation *pDragInfo = DragManagerOp::GetCurrentDragInfo();
    if (CanDropHere(pDragInfo))
    {
        String_256 DragString(_R(IDS_COLBAR_DRAGDROP));
        *TheText = DragString;
        return TRUE;
    }

    return FALSE;
}



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

>   BOOL EditButtonDragTarget::CanDropHere(DragInformation *pDragInfo)

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

    Returns:    Whether this is something that can be dropped on the edit button

    Purpose:    Internal helper function
   
********************************************************************************************/

BOOL EditButtonDragTarget::CanDropHere(DragInformation *pDragInfo)
{
//  TRACEUSER("Gerry", _T("EditButtonDragTarget::CanDropHere"));

    if (Document::GetSelected() == NULL)        // No selected docuement? can't edit anything then
        return(FALSE);

    if (pDragInfo != NULL && pDragInfo->IsKindOf(CC_RUNTIME_CLASS(ColourDragInformation)))
    {
        ColourDragInformation *CDInfo = (ColourDragInformation *) pDragInfo;

        // We always allow drops of library colours onto us
        if (CDInfo->IsLibraryColour())
            return(TRUE);

        // Get the dragged colour and the current colour list
        IndexedColour *Col  = CDInfo->GetInitiallyDraggedColour();

        if (Col != NULL)    // NULL means "no colour" or a library colour, which can't be edited
        {
            ColourList *ColList = NULL;
            if (CDInfo->GetParentDoc() != NULL)
                ColList = CDInfo->GetParentDoc()->GetIndexedColours();

            return(ColourEditDlg::CanYouEditThis(ColList, Col));
        }
    }

    return(FALSE);
}


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

>   void ColourLineDragTarget::ColourLineDragTarget() 
     
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/11/95          
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
ColourLineDragTarget::ColourLineDragTarget(wxWindow* TheWindow, wxRect *ClientArea)
    : OilDragTarget(TheWindow, ClientArea)
{
//  TRACEUSER("Gerry", _T("ColourLineDragTarget created"));
}



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

>   void ColourLineDragTarget::ProcessEvent(DragEventType Event,
                        DragInformation *pDragInfo,
                        wxPoint *pMousePos, KeyPress* pKeyPress) 
     
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/11/95          

    Purpose:    Event Handler for Edit Drag - see the base class for details

    SeeAlso:    WinoilDragTarget::ProcessEvent

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

BOOL ColourLineDragTarget::ProcessEvent(DragEventType Event,
                        DragInformation *pDragInfo,
                        wxPoint *pMousePos, KeyPress* pKeyPress)
{
//  TRACEUSER("Gerry", _T("ColourLineDragTarget::ProcessEvent"));

    // Not a colour drag? That is kindof unexpected, but lets exit before
    // we embarrass ourselves
    if (!pDragInfo->IsKindOf(CC_RUNTIME_CLASS(ColourDragInformation)))
        return(FALSE);

    CColourBar *pColourLine = CColourBar::TheColourBar;

    switch(Event)
    {
        case DRAGEVENT_COMPLETED:
            if (KeyPress::IsConstrainPressed() &&
                pColourLine != NULL && pColourLine->m_pCurrentColourList != NULL)
            {
                IndexedColour *Col = ((ColourDragInformation *) pDragInfo)->GetInitiallyDraggedColour();

                // Check that the colour being dragged is in the current colour list
                if (Col != NULL && pColourLine->m_pCurrentColourList->FindPosition(Col) < 0)
                    Col = NULL;

                // If it's NULL, then it's "no colour", a library colour, or a colour we couldn't
                // find in the current colour line display, so we ignore it
                if (Col != NULL)
                {
                    // The Colour 'Col' has been dragged and dropped into the colour line
                    // with the 'constrain' key held down. In this case, the user wants
                    // to rearrange the colour line, so we detect which colour the pointer
                    // is over, and insert 'Col' before/after that colour.

                    BOOL ToLeft = FALSE;
                    INT32 CellIndex = pColourLine->WhereIsMouse(*pMousePos, NULL, &ToLeft);

                    if (CellIndex >= 0)
                    {
                        // The colour was dropped onto a legal colour cell - move it
                        ColourList *TheList = pColourLine->m_pCurrentColourList;
                        ERROR3IF(TheList == NULL, _T("No current colour list!"));
                        
                        IndexedColour *Target = (IndexedColour *) TheList->GetUndeletedHead();
                        while (CellIndex > 0 && Target)
                        {
                            Target = (IndexedColour *) TheList->GetUndeletedNext(Target);
                            CellIndex--;
                        }

                        // Now move the item into the appropriate position
                        if (Target != NULL && Target != Col)
                        {
                            if (ToLeft)
                            {
                                if (TheList->GetUndeletedNext(Col) != Target)
                                {
                                    TheList->RemoveItem(Col);
                                    TheList->InsertBefore(Target, Col);

                                    // And inform the world (colour line, gallery, etc) of the change
                                    ColourManager::ColourListHasChanged(TheList);
                                }
                            }
                            else
                            {
                                if (TheList->GetUndeletedNext(Target) != Col)
                                {
                                    TheList->RemoveItem(Col);
                                    TheList->InsertAfter(Target, Col);

                                    // And inform the world (colour line, gallery, etc) of the change
                                    ColourManager::ColourListHasChanged(TheList);
                                }
                            }
                        }
                    }
                }

                return(TRUE);
            }
            break;


        case DRAGEVENT_MOUSESTOPPED:
        case DRAGEVENT_MOUSEMOVED:
        case DRAGEVENT_MOUSEIDLE:
            // Return TRUE to claim the mouse while over our target area, so that
            // our cursor shape is used
            return(TRUE);

        default:
            break;
    }

    // Allow unknown/unwanted events to pass on to other targets
    return(FALSE);
}



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

>   void ColourLineDragTarget::GetCursorID()

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/11/95
    Purpose:    Base Method to set cursor over this target


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

UINT32 ColourLineDragTarget::GetCursorID()
{
//  TRACEUSER("Gerry", _T("ColourLineDragTarget::GetCursorID"));

    DragInformation * pDragInfo = DragManagerOp::GetCurrentDragInfo();
    if (pDragInfo != NULL && KeyPress::IsConstrainPressed())
    {
        if (pDragInfo->IsKindOf(CC_RUNTIME_CLASS(ColourDragInformation)))
        {
            IndexedColour *Col = ((ColourDragInformation *) pDragInfo)->GetInitiallyDraggedColour();

            if (Col != NULL)
            {
                if (CColourBar::TheColourBar != NULL)
                {
                    BOOL CanDrop = FALSE;

                    // Determine if the mouse cursor should be "insert on left" or
                    // insert on right" of the colour under the pointer
                    BOOL ToLeft = FALSE;
                    wxPoint MousePos = wxGetMousePosition();
                    MousePos = CColourBar::TheColourBar->ScreenToClient(MousePos);

                    INT32 CellIndex = CColourBar::TheColourBar->WhereIsMouse(MousePos, NULL, &ToLeft);
                    if (CellIndex >= 0)
                    {
                        // The pointer is over a legal colour cell
                        ColourList *TheList = CColourBar::TheColourBar->m_pCurrentColourList;
                        ERROR3IF(TheList == NULL, _T("No current colour list!"));
                    
                        IndexedColour *Target = (IndexedColour *) TheList->GetUndeletedHead();
                        while (CellIndex > 0 && Target != NULL)
                        {
                            Target = (IndexedColour *) TheList->GetUndeletedNext(Target);
                            CellIndex--;
                        }

                        // Now, check that it is a position in which the colour can be dropped.
                        // We disallow any drop which will leave the colour where it was.
                        if (Target != NULL && Target != Col)
                        {
                            if (ToLeft)
                                CanDrop = (TheList->GetUndeletedNext(Col) != Target);
                            else
                                CanDrop = (TheList->GetUndeletedNext(Target) != Col);
                        }

                        // If we are sure it's OK to drop here, we return the cursor to use
                        if (CanDrop)
                        {
                            if (ToLeft)
                                return _R(IDC_DROPLEFT);

                            return _R(IDC_DROPRIGHT);
                        }

                        // else drop out to "no-drop" cursor
                    }
                }
            }
        }
    }

    // Ask for "can't drop here" cursor. Really ought to rename this resource ID soon!
    return _R(IDC_DRAGGING_COLOUR);
}



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

>   virtual BOOL ColourLineDragTarget::GetStatusLineText(String_256 * TheText)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/11/95
    Returns:    Whether String is valid
    Purpose:    provide status line text for this target
   
********************************************************************************************/

BOOL ColourLineDragTarget::GetStatusLineText(String_256 * TheText)
{
//  TRACEUSER("Gerry", _T("ColourLineDragTarget::GetStatusLineText"));

    ERROR2IF(TheText==NULL,FALSE,_T("NULL string in GetStatusLineText()"));

    DragInformation * pDragInfo = DragManagerOp::GetCurrentDragInfo();

    if (pDragInfo != NULL && CColourBar::TheColourBar != NULL)
    {
        if (pDragInfo->IsKindOf(CC_RUNTIME_CLASS(ColourDragInformation)))
        {
            if (((ColourDragInformation *) pDragInfo)->GetInitiallyDraggedColour() != NULL)
            {
                // If we are sure it's OK to drop here, we return the cursor to use
                String_256 DragString(_R(IDS_COLBAR_REARRANGE));
                *TheText = DragString;
                return TRUE;
            }
        }
    }

    return FALSE;
}



BEGIN_EVENT_TABLE( CColourBar, wxWindow )
    EVT_LEFT_DOWN(      CColourBar::OnLButtonDown)
    EVT_LEFT_DCLICK(    CColourBar::OnLButtonDblClk)
    EVT_LEFT_UP(        CColourBar::OnLButtonUp)
    EVT_RIGHT_DOWN(     CColourBar::OnRButtonDown)
    EVT_RIGHT_DCLICK(   CColourBar::OnRButtonDblClk)
    EVT_RIGHT_UP(       CColourBar::OnRButtonUp)
    EVT_MOTION(         CColourBar::OnMouseMove)
    EVT_TIMER(      2,  CColourBar::OnTimer)
    EVT_PAINT(          CColourBar::OnPaint)
    EVT_SIZE(           CColourBar::OnSize)
END_EVENT_TABLE()


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

>   CColourBar::CColourBar()

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/6/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    CColourBar constructor
    Notes:      The ColourBar works exclusively on the SELECTED Doc. Change with care

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

CColourBar::CColourBar()
{
    m_pCurrentColourList = NULL;

    LeftmostColour = 0;         // Initially, are at left end of the colourstrip

    LastLineCell = CELLINDEX_NOCELL;    // We have not drawn any indicator diamonds anywhere
    LastFillCell = CELLINDEX_NOCELL;
    LastEndCell  = CELLINDEX_NOCELL;
    LastDiamondShape = TRUE;

    IndentedButton = CLICKED_NOTHING;

    m_cxLeftBorder = 1;         // Automatic 1 pixel gap at left end of bar
    m_cyTopBorder = 0;
    m_cxRightBorder = 0;
    m_cyBottomBorder = 0;

    TheColourBar = this;

    MsgHandler = NULL;

    m_DragTimer.SetOwner(this, 2);

    DragInfo.TimerOn = 0;
    DragInfo.MouseCaptured = FALSE;

    PushCursor = NULL;

    OldBarHeight = 0;

    // We have no current colour gallery to access the fixed gallery section colours
    m_pColourGallery = NULL;
}



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

>   BOOL CColourBar::~CColourBar()

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/6/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Destroys the object, as one might expect.
    Notes:      IMPORTANT - After calling the destructor (delete ColourBar) it is
                VITAL that you then call RecalcLayout() for the main frame window in
                which the Colour Bar is appearing (the one you passed in to PB::Create().
                If you don't do this, the bar won't disappear until the next time the main 
                window is resized or a tool is chosen.

                The ColourBar works exclusively on the SELECTED Doc. Change with care

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

CColourBar::~CColourBar()
{
    TheColourBar = NULL;    // There is no longer a colour bar around   

    if (MsgHandler != NULL)
        delete MsgHandler;  // Kill our message handler

    ReleaseAllClaims();     // Ensure all temp. window claims (mouse/timer) released

    if (PushCursor)
        delete PushCursor;
}



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

>   BOOL CColourBar::InitPrefs(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/6/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if the initialisation of the Colour bar prefs was successful.
    Purpose:    Initialisation of ColourBar preference option(s)
    Notes:      The ColourBar works exclusively on the SELECTED Doc. Change with care

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

BOOL CColourBar::InitPrefs(void)
{
    if (MsgHandler == NULL)
        MsgHandler = new ColourBarMsgHandler;

    if (MsgHandler == NULL)
        return(FALSE);

    Camelot.DeclareSection(TEXT("Displays"), 8);
    Camelot.DeclarePref(TEXT("Displays"), TEXT("ColourBarMode"), &DefaultSizeIndex);
    Camelot.DeclarePref(TEXT("Displays"), TEXT("ColourCellsDivided"), &ColourCellsDivided);

    return(TRUE);
}



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

>   BOOL CColourBar::Create(CFrameWnd *ParentWnd,
                            DWORD dwstyle = WS_CHILD | WS_VISIBLE | CBRS_BOTTOM,
                            UINT32 nID = _R(AFX_IDW_STATUS_BAR));

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/6/94
    Inputs:     ParentWnd - The parent frame window (in Camelot, there can be only one)
                dwstyle, nID - you shouldn't have to mess with these (cf CStatusBar)
    Outputs:    -
    Returns:    TRUE if the initialisation of the Colour bar was successful.
    Purpose:    Creates a window and associates it with this CColourBar object. The window
                appears at the bottom of the main frame window, just like the status bar.

    Notes:      The ColourBar works exclusively on the SELECTED Doc. Change with care

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

BOOL CColourBar::Create(wxWindow* pParent, UINT32 id)
{
    if (!wxWindow::Create(pParent, id, wxDefaultPosition, wxSize(BarHeight, BarHeight), wxNO_BORDER))
        return(FALSE);

#if FALSE
    ASSERT_VALID(pParentWnd);   // must have a parent

    // Create a new WndClass- this should be identical to CControlBar's WndClass but
    // we also would kindof like double clicks if it isn't too much trouble, Mr MFC
    CString WndClassName = AfxRegisterWndClass(CS_DBLCLKS, NULL, //Cursor::Arrow->Handle(),
                                    (HBRUSH)(COLOR_BTNFACE + 1));

    // Do we want to show this bar after it's created?
    BOOL Show = dwStyle & WS_VISIBLE;

    // Make sure the style flags only has legal flags set (VC6 change)
    dwStyle &= CBRS_ALL;

#if WIN32
    // this element of CControlBar does not exist in MFC 2.5 16-bit
    m_dwStyle = dwStyle;
#endif

    // create the wxWindow*
    wxRect rect;
    rect.SetRectEmpty();
    if (!CWnd::Create(WndClassName, NULL, dwStyle, rect, pParentWnd, nID))
        return(FALSE);
        // NOTE: Parent must resize itself for control bar to be resized

    if (Show)
        ShowWindow(SW_SHOW);
#endif

    InitPrefs();
    SetDisplayMode();

    InvalidateBestSize();

    IndentedButton = CLICKED_NOTHING;

    return(TRUE);
}



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

>   wxSize CColourBar::DoGetBestSize() const

    Author:     Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/03/06
    Inputs:     -
    Outputs:    -
    Returns:    Best size of this window

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

wxSize CColourBar::DoGetBestSize() const
{
    TRACEUSER("Gerry", _T("CColourBar::DoGetBestSize"));
    wxRect AvailableRect = GetParent()->GetClientRect();
    AvailableRect.height = BarHeight;
    INT32 Height = ((CColourBar*)this)->CalculateNewBarHeight(&AvailableRect);
    INT32 Width = GetParent()->GetClientSize().x;

    return(wxSize(Width, Height));
}

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

>   void CColourBar::SetSizes(INT32 NewCellSize, INT32 NewScrollbarSize)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/6/94
    Inputs:     NewCellSize - The new size in pixels of the square colour cells
                This should be an even number (it is truncated if necessary)

                NewScrollbarSize - The new height of the scroll bar in pixels

    Outputs:    -
    Returns:    -

    Purpose:    Sets the base sizes of the colour strip and colour scroll bar
                in the colour bar window. Other features of the bar are automatically
                resized to fit the new sizing. The bar will be redrawn. If the 
                combined height of the bar elements has now changed, the bar will
                be resized (by calling the parent's RecalcLayout method).

    Notes:      Setting NewScrollBarSize == 0 enters a special mode where the scroll
                sausage is not drawn, and the scroll arrows sit at either end of the
                colour strip. In this size, it is recommended that
                CellSize == ButtonWidth (i.e. about 10 pixels), to make the buttons
                square and therefore not entirely disgusting looking

                The ColourBar works exclusively on the SELECTED Doc. Change with care

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

void CColourBar::SetSizes(INT32 NewCellSize, INT32 NewScrollbarSize)
{
    ENSURE (NewCellSize >= 4 && NewCellSize <= 64,
        "Silly CellSize passed to CColourBar::SetSizes()");

    ENSURE (NewScrollbarSize == 0 ||
            (NewScrollbarSize >= 3 && NewScrollbarSize <= 24),
        "Silly ScrollbarSize passed to CColourBar::SetSizes()");

    NewCellSize &= ~1;      // Force Cellsize to be an even value

//  BOOL ResizeFrame = (NewCellSize + NewScrollbarSize != CellSize + ScrollHeight);

    CellSize = NewCellSize;
    ScrollHeight = NewScrollbarSize;

    BarHeight = CellSize + ScrollHeight + (2 * CY_BORDER) +
                    m_cyTopBorder + m_cyBottomBorder + 1;

//  if (ResizeFrame)
    {
        SetMinSize(wxSize(8, BarHeight));

        InvalidateBestSize();
        GetMainFrame()->UpdateFrameManager();
    }
}



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

>   static void CColourBar::SetDisplayMode(INT32 NewDisplayMode = -1)

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

    Inputs:     NewDisplayMode - The mode (0..3) or -1 to re-read the preference value

    Purpose:    Sets the Colour Bar display mode to the new value.
                Current legal mode values are 0..3 (small, med, med+scroll, large)
                Illegal values will cause it to resort to the default mode, medium+scroll (2)
                The default value of -1 is used to mean 'use the preference setting'.
                This allows the prefs dialogue to cause the ColourBar to sit up and
                take notice of changed preference settings.
                The preference setting ColourBarMode will be set to the new value

    Notes:      This static function may be called at any time. If a colour bar is not
                open when the call is made, the new setting will be used for the next
                colour bar created.

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

void CColourBar::SetDisplayMode(INT32 NewDisplayMode)
{
    if (NewDisplayMode == -1)
        NewDisplayMode = DefaultSizeIndex;

    if (NewDisplayMode < 0 || NewDisplayMode >= MAXDEFAULTSIZES)  
        NewDisplayMode = 2;

    DefaultSizeIndex = NewDisplayMode;      // Remember this as a preference setting

    if (TheColourBar != NULL)               // If there's a bar, set it to the new size
    {
        TheColourBar->SetSizes(ColBarDefaultSize[NewDisplayMode].Cell,
                                ColBarDefaultSize[NewDisplayMode].Scrollbar);
        TheColourBar->Refresh();            // Force a redraw of the bar to ensure it's up to date
    }
}




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

>   INT32 CColourBar::GetNumberOfColours()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/3/97
    Inputs:     -
    Returns:    The number of colours we wish to display on the bar.
    Purpose:    Determines the number of colours that we wish to display on the ColourBar.

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

INT32 CColourBar::GetNumberOfColours()
{
    INT32 total = 0;
    
    // Get the actually colours in the selected document
    INT32 DocColours = 0;

    // If the user has the preference set then include and hence show the document
    // colours
    if (ColourSGallery::ShowDocumentColours)
    {
        if (m_pCurrentColourList == NULL)
            m_pCurrentColourList = ColourManager::GetColourList();

        if (m_pCurrentColourList != NULL)
            DocColours = (INT32) m_pCurrentColourList->GetUndeletedCount();

        total += DocColours;
    }

PORTNOTE("other","Removed ColourSGallery usage")
#if !defined(EXCLUDE_FROM_XARALX)
    // try and add in any fixed sections required
    m_pColourGallery = ColourSGallery::GetInstance();
    if (m_pColourGallery != NULL)
    {
        // This will create the groups if they're not there yet
        m_pColourGallery->MakeSureGroupsHaveBeenCreated();

        // Find the Netscape palette library
        SGDisplayLibColGroup * pLibGroup = m_pColourGallery->GetFirstLibGroup();
        BOOL Found = FALSE;
        while (!Found && pLibGroup)
        {
            // Add in any items that are flagged as being required
            if (pLibGroup->DisplayInColourLine())
            {
                // pLibGroup->DeVirtualise();   // This is dangerous as it may change things like current doc!
                                                // Disabled as it causes problems during start up
                total += pLibGroup->CountChildren();
            }

            pLibGroup = m_pColourGallery->GetNextLibGroup(pLibGroup);
        }
    }
#endif
    return total;
}

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

>   static BOOL CColourBar::EnsureLibraryColoursPresent()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/3/97
    Inputs:     -
    Returns:    True if worked correctly
    Purpose:    Ensures that any colour library sections we require are present.

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

BOOL CColourBar::EnsureLibraryColoursPresent()
{
PORTNOTE("other","Removed ColourSGallery usage")
#if !defined(EXCLUDE_FROM_XARALX)
    // try and ensure all our required colour gallery sections are present and de-virtilised
    ColourSGallery * pColourGallery = ColourSGallery::GetInstance();
    if (pColourGallery != NULL)
    {
        // This will create the groups if they're not there yet
        pColourGallery->MakeSureGroupsHaveBeenCreated();

        // Find the Netscape palette library
        SGDisplayLibColGroup * pLibGroup = pColourGallery->GetFirstLibGroup();
        while (pLibGroup)
        {
            // Add in any items that are flagged as being required
            if (pLibGroup->DisplayInColourLine())
            {
                pLibGroup->DeVirtualise();
            }

            pLibGroup = pColourGallery->GetNextLibGroup(pLibGroup);
        }

        if (TheColourBar != NULL)           // If there's a bar, set it to the new size
        {
            // Force a redraw of the bar to ensure it's up to date
            // This checks that the size is correct
            PaletteHasChanged(NULL);
            //TheColourBar->Invalidate();       
        }
    }
#endif
    return TRUE;
}

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

>   BOOL CColourBar::IsColourPickerOverStripRect (wxWindow* colourPicker, wxPoint mousePt)

    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/10/99
    Inputs:     colourPicker - The wxWindow* of the claimed colour picker control
                mousePt - the current mouse location that the colour picker is supplying
    Returns:    True if mousePt is in StripRect
                False otherwise
                Throws ENSURE error if colourPicker is NOT a colour picker control
    Purpose:    This function helps to determin how colour picker controls should
                behave when they are over the colour bar