colormgr.cpp

Go to the documentation of this file.

// $Id: colormgr.cpp 1777 2007-07-04 10:37:58Z luke $
/* @@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============================
 */

// colormgr.cpp - Implementation of the ColourManager class


/*
*/


#include "camtypes.h"

//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "ccolbar.h"
#include "colcomp.h"
#include "colcontx.h"
#include "coldlog.h"
#include "colormgr.h"
//#include "docmsgs.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "jason.h"
#include "lineattr.h"
#include "newcol.h"     // For NewColourDlg
#include "nodeblnd.h"   // For NodeBlend, for Blend bodge
#include "objchge.h"
#include "opimgset.h"
//#include "ops.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "tool.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "fillramp.h"
//#include "bitmapcache.h" - in camtypes.h [AUTOMATICALLY REMOVED]

#include "colmsg.h"

#include "ophist.h"

// "Implement" run-time typing for the classes we're defining here
CC_IMPLEMENT_DYNAMIC(ColourChangingMsg, Msg)

CC_IMPLEMENT_DYNAMIC(ColourManager, MessageHandler)

#if !defined(EXCLUDE_FROM_RALPH)
CC_IMPLEMENT_DYNCREATE(OpHideColours, UndoableOperation)
CC_IMPLEMENT_DYNCREATE(ActionHideColours, Action)

CC_IMPLEMENT_DYNCREATE(OpColourChange, UndoableOperation)
CC_IMPLEMENT_DYNCREATE(ActionColourChange, Action)

CC_IMPLEMENT_DYNCREATE(OpRedrawColours, Operation)
#endif

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


// --- Initialise static member variables
ColourList  *ColourManager::CurrentColourList   = NULL;
Document    *ColourManager::ScopeDocument       = NULL;

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

>   ColourManager::ColourManager()

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/5/94
    Purpose:    Constructs a ColourManager object
    SeeAlso:    ColourManager; MessageHandler

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

ColourManager::ColourManager()
    : MessageHandler(CC_RUNTIME_CLASS(MessageHandler), TRUE)
{
}



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

>   static BOOL ColourManager::Init(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/5/94
    Returns:    FALSE if initialisation failed
    Purpose:    Initialises the entire colour system. This includes the colour manager,
                colour contexts, and colour dialogues, etc.
    Notes:      Should only be called once ever. Called by Application::Init()
    SeeAlso:    ColourManager; MessageHandler

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

BOOL ColourManager::Init(void)
{
#if !defined(EXCLUDE_FROM_RALPH)
    // Init (register) all our operations
#if !defined(EXCLUDE_FROM_XARALX)
    if (!::InitImagesettingOps())
        return(FALSE);
#endif

    if (!OpHideColours::Init())
        return(FALSE);

    if (!OpColourChange::Init())
        return(FALSE);

    if (!OpRedrawColours::Init())
        return(FALSE);

    if (!OpMakeColourLocalToFrame::Init())
        return(FALSE);
#endif

    // Init the global list of active colour contexts
    if (!ColourContextList::InitColourContexts())
        return(FALSE);

    return(TRUE);
}



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

>   static void ColourManager::Deinit(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/6/94
    Purpose:    De-Initlialises the entire colour system. This includes the colour manager,
                colour contexts, and colour dialogues, etc.
    Notes:      Should only be called once ever. Called by Application::Deinit()
    SeeAlso:    ColourManager; MessageHandler

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

void ColourManager::Deinit(void)
{
    // shut down the colour contexts
    ColourContextList::DeinitColourContexts();
}



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

>   void ColourManager::ForceRedrawOfChangedColours(Document *ScopeDoc,
                                                    IndexedColour **Colours)
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/9/94
    Inputs:     ScopeDoc - The document in which to cause redraw
                Colours  - A NULL terminated list of pointers to IndexedColours

    Purpose:    Scans the document tree of the given scope document, and causes
                a redraw of all objects which are affected by any attributes which
                contain references to any of the colours in the given NULL-terminated
                list of colours. If none of the colours are in use in the document
                tree, nothing should result.
                (i.e. it force redraws any areas of the document containing any of
                the given colours)
    SeeAlso:    RecursivelyForceRedraw

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

void ColourManager::ForceRedrawOfChangedColours(Document *ScopeDoc, IndexedColour **Colours)
{
#if !defined(EXCLUDE_FROM_RALPH)
    // Sanity check
    if (ScopeDoc == NULL)
    {
        ERROR3("Illegal NULL param");
        return;
    }

    OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_REDRAWCOLOURS);

    if (OpDesc != NULL)
    {
        OpRedrawColoursInfo Info;
        Info.ScopeDoc = ScopeDoc;
        Info.Colours  = Colours;

        OpDesc->Invoke((OpParam *) &Info);
    }
#endif
}



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

>   virtual MsgResult ColourManager::Message(Msg* Message)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/5/94
    Inputs:     Message: The message
    Outputs:    -
    Returns:    -
    Purpose:    Process messages sent to the ColourManager
                Some messages (DocChanging) will cause new broadcasts indicating
                that the colour system has changed (new colour list has been paged in, etc)
    Errors:     -
    SeeAlso:    ColourManager; MessageHandler; ColourChangingMsg 

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

MsgResult ColourManager::Message(Msg* Message)
{
    if (MESSAGE_IS_A(Message, DocChangingMsg))
    {
        DocChangingMsg *TheMsg = (DocChangingMsg *) Message;

        switch ( TheMsg->State )
        {
            case DocChangingMsg::SELCHANGED:
                if (TheMsg->pNewDoc == NULL)            // No document selected any more
                {
                    // Send PaletteChangingMsg - DESELECTED
                    CurrentColourList = NULL;           // No document present
                    ScopeDocument = NULL;

                    BROADCAST_TO_ALL(ColourChangingMsg(ScopeDocument, CurrentColourList, NULL,
                                            ColourChangingMsg::LISTDESELECTED));
                }
                else if (TheMsg->pOldDoc != TheMsg->pNewDoc)
                {
                    // Send PaletteChangingMsg - PAGED
                    CurrentColourList = NULL;           // Cause re-caching of this info
                    ScopeDocument = NULL;

                    GetColourList(TRUE);                // Find the new colour list

                    BROADCAST_TO_ALL(ColourChangingMsg(ScopeDocument, CurrentColourList, NULL,
                                            ColourChangingMsg::LISTPAGED));
                }
                break;


            case DocChangingMsg::ABOUTTODIE:
                // Pass this around as a ColourList killed message
                if (TheMsg->pChangingDoc != NULL)
                    BROADCAST_TO_ALL(ColourChangingMsg(TheMsg->pChangingDoc,
                                        TheMsg->pChangingDoc->GetIndexedColours(), NULL,
                                        ColourChangingMsg::LISTDELETED));

                if (TheMsg->pChangingDoc == ScopeDocument)
                {
                    // We can't keep a cached value around, as soon after this point the
                    // colour list will cease to exist
                    CurrentColourList = NULL;
                    ScopeDocument = NULL;
                }
                break;
            default:
                break;
        }
    }
    else if (MESSAGE_IS_A(Message, ColourChangingMsg))
    {
        ColourChangingMsg *TheMsg = (ColourChangingMsg *) Message;

        switch ( TheMsg->State )
        {
            case ColourChangingMsg::LISTUPDATED:
                // The list has changed- may involve a colour having been deleted.
                // We check if the attribute manager is using any colours which are
                // now deleted, and if so, set it to use safer ones!                
                if (TheMsg->ScopeDoc == NULL || TheMsg->NewColourList == NULL)
                {
                    ERROR3("ColChangingMsg::LISTUPDATED broadcast with NULL colour list");
                }
                else
                    TheMsg->ScopeDoc->GetAttributeMgr().UpdateForDeletedColours(
                                                            TheMsg->NewColourList);
                break;


            case ColourChangingMsg::COLOURUPDATED:
                {
                    // An IndexedColour has been edited.
                    // We need to force an update on all colours Linked to this one, and
                    // then redraw all DocViews on this document.

                    if (TheMsg->ScopeDoc != NULL &&
                        TheMsg->NewColourList != NULL &&
                        TheMsg->ChangedColour != NULL)
                    {
                        IndexedColour **AffectedColours = TheMsg->NewColourList->
                                        CompileInheritanceArray(TheMsg->ChangedColour);

                        if (AffectedColours == NULL)
                        {
                            // Memory error means we can't get the array                            
                            // Tell *all* linked colours in the list they may have changed
                            List *TheList = TheMsg->NewColourList;

                            IndexedColour *Ptr = (IndexedColour *) (TheList->GetHead());
                            while (Ptr != NULL)
                            {
                                if (Ptr->FindLinkedParent() != NULL)    // If is linked
                                    Ptr->LinkedAncestorHasChanged();    // Warn it of the change
                                Ptr = (IndexedColour *) TheList->GetNext(Ptr);
                            }

                            // And all unnamed colours too
                            TheList = TheMsg->NewColourList->GetUnnamedColours();

                            Ptr = (IndexedColour *) (TheList->GetHead());
                            while (Ptr != NULL)
                            {
                                if (Ptr->FindLinkedParent() != NULL)    // If is linked
                                    Ptr->LinkedAncestorHasChanged();    // Warn it of the change
                                Ptr = (IndexedColour *) TheList->GetNext(Ptr);
                            }

                            // And force-redraw the entire document - all views
                            CBitmapCache *pBC = Camelot.GetBitmapCache();
                            if( NULL != pBC )
                                pBC->DeInitialise();                // Brute force cache management!
                            TheMsg->ScopeDoc->ForceRedraw();
                        }
                        else
                        {
                            // Inform all the linked colours (except the first, which is the
                            // actual colour which has changed) that they may have changed
                            INT32 Index = 1;
                            while (AffectedColours[Index] != NULL)
                            {
                                AffectedColours[Index]->LinkedAncestorHasChanged();
                                Index++;
                            }

                            // And redraw all affected areas of the document
                            ForceRedrawOfChangedColours(TheMsg->ScopeDoc, AffectedColours);
                        }
                    }
                }
                break;
            default:
                break;
        }
    }

    return OK;
}      



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

>   ColourList *ColourManager::GetColourList(BOOL InvalidateCache = FALSE)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/5/94
    Inputs:     InvalidateCache - TRUE if you want to force it to re-cache the 
                list pointer (generally only used internally; the default setting
                of FALSE is all external clients should ever need to use)
    Outputs:    -
    Returns:    NULL, or a pointer to the current colour list

    Purpose:    To obtain the ColourList of IndexedColours in the SelectedDocument (the
                colours which the user can use within the document; this is the set of
                colours displayed by the colour bar and edited by the ColourMgrDlg)
                Note that an ordered list is used so that multiple display orders can
                be used (e.g. for the ColourMgrDlg and ColourBar, etc)

    Notes:      This returns the list of colours from the SELECTED document, i.e.
                the colours displayed in the colour bar etc. Use GetCurrentColourList
                if you wish to get the colours for the CURRENT doc.

                The list is cached so this call is generally pretty efficient

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

ColourList *ColourManager::GetColourList(BOOL InvalidateCache)
{
    Document *ParentDoc = Document::GetSelected();

    if (ParentDoc != NULL)
    {
        if (InvalidateCache || ParentDoc != ScopeDocument)
        {
            CurrentColourList = ParentDoc->GetIndexedColours();
            ScopeDocument = ParentDoc;
        }
        // else
        //    Cache is up to date, so quit messing about
    }
    else
    {
        ScopeDocument = NULL;       // ParentDocument is NULL - no colour list
        CurrentColourList = NULL;       
    }

    return(CurrentColourList);
}




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

>   ColourList *ColourManager::GetCurrentColourList(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/6/94
    Inputs:     -
    Outputs:    -
    Returns:    NULL, or a pointer to the current colour list

    Purpose:    To obtain the ColourList of IndexedColours in the CurrentDocument

    Notes:      This returns the colours for the CURRENT document, NOT the Selected
                one - that is, these may not be the colours displayed in the colour
                bar/input-focus document.

    SeeAlso:    ColourManager::GetColourList

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

ColourList *ColourManager::GetCurrentColourList(void)
{
    Document *ParentDoc = Document::GetCurrent();

    if (ParentDoc != NULL)
        return(ParentDoc->GetIndexedColours());

    return(NULL);
}



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

>   static ColourContext *ColourManager::GetColourContext(ColourModel Model,
                                                            Document *ScopeDocument = NULL)

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

    Inputs:     Model - The colour model of the desired ColourContext
                ScopeDocument - NULL (to retrieve a global context) or a pointer to 
                the document for which you want the colour context.

    Returns:    NULL if it failed to find an appropriate colour context, else
                a pointer to the context

    Purpose:    To easily find an appropriate colour context to use when converting
                colours. There are global contexts, but in order to supply special
                document-specific colour corrections etc, each document actually
                has its own private set of contexts. Thus, you should call this function
                to determine the most appropriate context to use.

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

ColourContext *ColourManager::GetColourContext(ColourModel Model, Document *ScopeDocument)
{
    if (ScopeDocument == NULL)
        return(ColourContext::GetGlobalDefault(Model));

    return(ScopeDocument->GetDefaultColourContexts()->Context[Model]);
}



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

>   static ColourContext *ColourManager::GetColourContext(ColourModel Model,
                                                            View *ScopeView)

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

    Inputs:     Model - The colour model of the desired ColourContext
                ScopeView - A pointer to the view for which you want the colour context.
                            This should not be NULL, but if it is, a global default
                            context will be returned

    Returns:    NULL if it failed to find an appropriate colour context, else
                a pointer to the context

    Purpose:    To easily find an appropriate colour context to use when converting
                colours. There are global contexts, but in order to supply special
                view-specific colour corrections etc, each document view actually
                has its own private set of contexts. Thus, you should call this function
                to determine the most appropriate context to use.

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

ColourContext *ColourManager::GetColourContext(ColourModel Model, View *ScopeView)
{
    if (ScopeView != NULL)
        return(ScopeView->GetColourContext(Model));

    return(ColourContext::GetGlobalDefault(Model));
}



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

>   static void ColourManager::SelViewContextHasChanged(void)

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

    Purpose:    To redraw all windows which depend upon the Selected View's colour context.
                i.e. The selected view, and also the colour editor, gallery, & line.
                (and maybe other windows in the future, e.g. object properties, grad
                fill editors, etc)

                This redraws the selected view, then broadcasts a ColourChangingMsg message
                with a state of SELVIEWCONTEXTCHANGE to inform other interested parties.

    Notes:      This should only be called when the selected view's RGB (screen) colour
                context is changed, which really shouldn't happen terribly often.

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

void ColourManager::SelViewContextHasChanged(void)
{
    View *SelView = DocView::GetSelected();

    if (SelView != NULL && SelView->IsKindOf(CC_RUNTIME_CLASS(DocView)))
    {
        CBitmapCache* pBC = Camelot.GetBitmapCache();
        if( NULL != pBC )
            pBC->DeInitialise();                    // Brute force cache management

        ((DocView *)SelView)->ForceRedraw();
    }

    BROADCAST_TO_ALL(ColourChangingMsg(NULL, NULL, NULL,
                                ColourChangingMsg::SELVIEWCONTEXTCHANGE));
}



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

>   inline Document *SetCurrentDoc(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/7/94 (Copied from ccolbar.cpp, 25/11/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 kernel\colormgr.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 (Copied from ccolbar.cpp, 25/11/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 kernel\colormgr.cpp)
    SeeAlso:    SetCurrentDoc

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

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



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

>   static BOOL ColourManager::GetCurrentLineAndFillAttrs(AttrStrokeColour **LineAttr,
                                                          AttrFillGeometry **FillAttr)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/7/94 (Moved from ccolbar.cpp, 25/11/94)
    Inputs:     -
    Outputs:    LineAttr - will be filled in with NULL, or pointer to the attribute
                FillAttr - will be filled in with NULL, or pointer to the attribute
    Returns:    TRUE if these are default attributes; FALSE if the attributes are
                those common to the current selection.

    Purpose:    Determines the current line and fill colour attributes.
                These are the default ones, or if there is a selection, the attrs
                which are common to all selected objects. If there are many different
                attributes of the same type associated with the selection, NULL is
                returned.
    Notes:      The ColourBar works exclusively on the SELECTED Doc. Change with care
                This function ensures that Current == Selected during its operation

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

BOOL ColourManager::GetCurrentLineAndFillAttrs(AttrStrokeColour **LineAttr,
                                            AttrFillGeometry **FillAttr)
{
    ENSURE(LineAttr != NULL &&  FillAttr != NULL, 
            "ColourManager::GetCurrentLineAndFillAttrs - NULL pointers passed in!");

    *LineAttr = NULL;   // Ensure safe exit if we fail
    *FillAttr = NULL;

    // I don't think it is the colour bar's responsibility to check this, but
    // this is the only way that *I* can fix the problem of an ENSURE failure 
    // on exit (we ask for info when no tools are current... I believe this is
    // because some slurphead has thrown away the tools BEFORE the document,
    // because the Document::GetSelected still does not return NULL in this case!)
    if (Tool::GetCurrent() == NULL)
        return(TRUE);

    Document *SelectedDoc = Document::GetSelected();
    if (SelectedDoc == NULL)
        return(TRUE);

    // Save the current CurrentDoc, and set (CurrentDoc = SelectedDoc)
    Document *OldCurrentDoc = SetCurrentDoc();

    SelRange *Selection = Camelot.FindSelection();
    ENSURE(Selection != NULL, "No Selection SelRange!?!");

    SelRange::CommonAttribResult result =
        Selection->FindCommonAttribute(CC_RUNTIME_CLASS(AttrStrokeColour),
                                        (NodeAttribute **)LineAttr);
    if (result == SelRange::ATTR_MANY)
        *LineAttr = NULL;

    result = Selection->FindCommonAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),
                                            (NodeAttribute **)FillAttr);
    if (result == SelRange::ATTR_MANY)
        *FillAttr = NULL;

    RestoreCurrentDoc(OldCurrentDoc);

    return(result == SelRange::ATTR_NONE);
}



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

>   static BOOL ColourManager::GetCurrentLineAndFillColours(DocColour **LineCol,
                                                            DocColour **FillCol,
                                                            DocColour **EndGradFill = NULL,
                                                            DocColour **EndGradFill2 = NULL,
                                                            DocColour **EndGradFill3 = NULL)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (changed by Gerry 21/8/96)
    Created:    9/9/94 (Moved from ccolbar.cpp, 25/11/94)
    Inputs:     -

    Outputs:    LineCol - NULL, or will be filled in with a pointer to the current line colour
                FillCol - NULL, or will be filled in with a pointer to the current fill colour
                EndGradFill - NULL, or will be filled in with NULL or the grad-fill end colour
                (see below)
                EndGradFill2 - NULL, or will be filled in with NULL or the second end colour
                EndGradFill3 - NULL, or will be filled in with NULL or the third end colour

    Returns:    TRUE if these are default attributes; FALSE if the attributes are
                those common to the current selection.

    Purpose:    Finds the current line and fill attributes, and dereferences them to find
                the current line and fill DocColours. These may be returned NULL if there
                are no current attributes (no document/many colours selected)

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

                LineCol and/or FillCol may be passed in NULL if you are not interested in
                having these results returned to you.

                If EndGradFill is NULL and a grad fill is selected then FillColour will
                be filled in with the selected fill blob's colour (or NULL if there are
                zero or more than one selected blob).  EndGradFill2 and EndGradFill3
                will be filled in with NULL (if they are non NULL)
  
                If EndGradFill is non-NULL and a grad-fill is selected, instead of
                returning only the selected endpoint colour, it returns the start 
                and end colours in FillCol (start) and EndGradFill (end).  If the fill
                has more than two colours (ie GetEndColour2() != NULL) then both 
                FillCol and EndGradFill will bet filled in with NULL (to indicate many).

                MULTIFILL: This system needs to be changed to support multistage fills.

    SeeAlso:    CColourBar::GetCurrentLineAndFillAttrs

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

BOOL ColourManager::GetCurrentLineAndFillColours(DocColour **LineCol, DocColour **FillCol,
                                                    DocColour **EndGradFill)
{
    if (LineCol != NULL)            // Ensure return NULL if we fail
        *LineCol = NULL;

    if (FillCol != NULL)
        *FillCol = NULL;

    if (EndGradFill != NULL)
        *EndGradFill = NULL;

    AttrStrokeColour *LineAttr = NULL;
    AttrFillGeometry *FillAttr = NULL;

    BOOL result = GetCurrentLineAndFillAttrs(&LineAttr, &FillAttr);

    if (LineAttr != NULL && LineCol != NULL)
        *LineCol = LineAttr->GetStartColour();

    if (FillAttr != NULL && FillCol != NULL)
    {
        // New bit added by will (3/11/94) to make colour bar show
        // the selected fill control point's colour.
        // Note this assumes there are only start and end colours,
        // and so will NOT work with multi-stage fills.

        if (FillAttr->GetRuntimeClass() == CC_RUNTIME_CLASS(AttrFlatColourFill))
        {
            *FillCol = FillAttr->GetStartColour();
        }
        else
        {           
            if (EndGradFill == NULL)
            {
                // The caller wants the selected point's colour or NULL (already set)
                
                if (FillAttr->GetSelectionCount() == 1)                     // If there is only 1 selected blob
                {
                    // Get the colour of the selected blob
                    
                    if (FillAttr->IsSelected(FILLCONTROL_STARTPOINT))       // Show Start Colour
                        *FillCol = FillAttr->GetStartColour();
                    else if (FillAttr->IsSelected(FILLCONTROL_ENDPOINT))    // Show End Colour
                        *FillCol = FillAttr->GetEndColour();
                    else if (FillAttr->IsSelected(FILLCONTROL_ENDPOINT2))   // Show End2 Colour
                        *FillCol = FillAttr->GetEndColour2();
                    else if (FillAttr->IsSelected(FILLCONTROL_ENDPOINT3))   // Show End3 Colour
                        *FillCol = FillAttr->GetEndColour3();
                }
            }
            else
            {
                // User wants two colours

                if (FillAttr->GetEndColour2() == NULL)      // If the fill doesn't have a third colour
                {                   
                    // We know FillCol is non-NULL
                    *FillCol = FillAttr->GetStartColour();

                    // We know EndGradFill is non-NULL
                    *EndGradFill = FillAttr->GetEndColour();
                }
            }
        }
    }

    return(result);
}



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

>   static void ColourManager::FindColourOfInterestToUser(IndexedColour **ResultCol,
                                                        ColourList **ResultList = NULL)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/1/95
    Inputs:     -
    Outputs:    ResultCol  - NULL, or a pointer to the colour to use
                ResultList - NULL, or a pointer to the ColourList that colour resides in
    Returns:    -

    Purpose:    Several things (Colour editor whenever the selection changes, generation
                of a new colour) need to know a 'useful' colour to display/copy. 
                Rather than just showing the current default colour or something, they
                need to interactively update to show an appropriate colour from the
                selection and suchlike.

                NOTE that there is another overloaded form of this method, which returns
                a DocColour istead. This method returns a pointer to a NAMED IndexedColour,
                so may return an entirely different colour to the other function.

                The exact colour returned will be NULL (in dire emergency, usually only
                occurs if there are no documents open), or will be chosen from this
                priority list of possible contenders:
                MonoOn
                    (1) Colour of first selected fill-blob found,
                    (2) Fill-Colour of selection,
                    (3) current/default fill colour,
                    (4) line-Colour of selection,
                    (5) current/default line colour,
                    (6) the first active named colour in the document's colour list,
                    (7) NULL
                MonoOff

    Notes:      'Colour of selection' is determined by using (if possible) the last
                object selected, or the frontmost selected object if this fails.

                If you are not interested in the ResultList return value, pass in NULL
                (use the default) for this parameter.

                In debug builds only, extra checks are made which can cause an ERROR3
                if the colour found was not in the selected document's ColourList.

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

void ColourManager::FindColourOfInterestToUser(IndexedColour **ResultCol, ColourList **ResultList)
{
    ERROR3IF(ResultCol == NULL, "ColourManager::FindColourOfInterestToUser - ResultCol is NULL!");

    // Ensure safe return values
    *ResultCol = NULL;
    if (ResultList != NULL)
        *ResultList = NULL;

    // If there are no documents available, then we can't find a colour - Return NULLs
    if (Document::GetSelected() == NULL)
        return;

    // Ensure CurrentDoc == SelectedDoc
    Document *OldCurrentDoc = SetCurrentDoc();

    // Get the colour list. Just in case, we invalidate the cache (as this method is
    // called on document chnages and suchlike, so it is best to make sure we don't use
    // cached values for a no-longer-present document!)
    ColourList *ColList = ColourManager::GetColourList(TRUE);
    IndexedColour *UsefulColour = NULL;

    // First, check if there is a VISIBLE selected fill blob, and use the colour of
    // the first one that we find, if we are lucky enough to find one.
    if (AttrFillGeometry::CountSelectionControlPoints() > 0)
    {
        // Yep. There is at least 1 visible selected fill blob...
        AttrFillGeometry* Fill = AttrFillGeometry::FindFirstSelectedAttr();
        while (Fill != NULL && UsefulColour == NULL)
        {
            if (Fill->GetSelectionCount() > 0)
            {
                if (Fill->IsSelected(FILLCONTROL_STARTPOINT) && Fill->GetStartColour() != NULL)
                {
                    // Use Fill Start Colour
                    UsefulColour = Fill->GetStartColour()->FindParentIndexedColour();
                    break;
                }

                if (Fill->IsSelected(FILLCONTROL_ENDPOINT) && Fill->GetEndColour() != NULL)
                {
                    // Use Fill End Colour
                    UsefulColour = Fill->GetEndColour()->FindParentIndexedColour();
                    break;
                }

                if (Fill->IsSelected(FILLCONTROL_ENDPOINT2) && Fill->GetEndColour2() != NULL)
                {
                    // Use Fill End Colour
                    UsefulColour = Fill->GetEndColour2()->FindParentIndexedColour();
                    break;
                }

                if (Fill->IsSelected(FILLCONTROL_ENDPOINT3) && Fill->GetEndColour3() != NULL)
                {
                    // Use Fill End Colour
                    UsefulColour = Fill->GetEndColour3()->FindParentIndexedColour();
                    break;
                }
            }               

            Fill = AttrFillGeometry::FindNextSelectedAttr();
        }
    }

    if (UsefulColour == NULL)
    {
        // Find the last node which was made selected (if any)
        // Scan back from this to find the nearest previous NodeAttribute which contains
        // colour(s), and make UsefulColour the first IndexedColour which we find in this search.
        SelRange *Selection = GetApplication()->FindSelection();

        if (Selection != NULL)
        {
            Node *pNode = Selection->GetLastSelectedNode();
            // If the SelRange doesn't know what was last made selected, then see if anything
            // is selected, and if so, grab the last (topmost) selected object instead
            if (pNode == NULL)
                pNode = Selection->FindLast();

            // Now search through the attributes applied to this node, to see if we can
            // find an IndexedColour FILL (i.e. we ignore stroke colours for now) - we
            // will use the first one that we find
            NodeAttribute *pAttr = NULL;
            if (pNode != NULL)
                pAttr = NodeAttribute::FindFirstAppliedAttr(pNode);

            while (pAttr != NULL && UsefulColour == NULL)
            {
                // Scan each NodeAttribute in turn to see if any of them contain any colours
                DocColour *pColour;
                UINT32 Context = 0;

                // Only check non-line-colour attributes
                if (!(IS_A(pAttr, AttrStrokeColour)))
                {
                    do
                    {
                        // Get the next colour field (if any) from the attribute, and find the
                        // IndexedColour (if any) to which it refers
                        pColour = pAttr->EnumerateColourFields(Context++);
                        if (pColour != NULL)
                            UsefulColour = pColour->FindParentIndexedColour();

                    } while (pColour != NULL && UsefulColour == NULL);
                }
            
                pAttr = NodeAttribute::FindPrevAppliedAttr(pAttr);
            }


            // If we still haven't found a colour, try for a line/stroke colour instead
            if (pNode != NULL && UsefulColour == NULL)
                pAttr = NodeAttribute::FindFirstAppliedAttr(pNode);

            while (pAttr != NULL && UsefulColour == NULL)
            {
                // Scan each NodeAttribute in turn to see if any of them contain any colours
                DocColour *pColour;
                UINT32 Context = 0;

                // Only check line-colour attributes
                if (IS_A(pAttr, AttrStrokeColour))
                {
                    do
                    {
                        // Get the next colour field (if any) from the attribute, and find the
                        // IndexedColour (if any) to which it refers
                        pColour = pAttr->EnumerateColourFields(Context++);
                        if (pColour != NULL)
                            UsefulColour = pColour->FindParentIndexedColour();

                    } while (pColour != NULL && UsefulColour == NULL);
                }

                pAttr = NodeAttribute::FindPrevAppliedAttr(pAttr);
            }

        }
    }

    if (UsefulColour == NULL)
    {
        // OK, then. let's see if there is a default fill colour, or failing that
        // (eg it could be 'no colour') a default line colour, which we can edit.
        AttributeManager &AttrMgr = Document::GetSelected()->GetAttributeMgr();

        DocColour LineCol;
        DocColour FillCol;
            
        AttrMgr.GetCurrentLineAndFillColour(CC_RUNTIME_CLASS(NodeRenderableInk),
                                                &LineCol, &FillCol);

        UsefulColour = FillCol.FindParentIndexedColour();
        if (UsefulColour == NULL)
            UsefulColour = LineCol.FindParentIndexedColour();
    }

    if (UsefulColour == NULL)
    {
        // Ok, we're rapidly approaching a moment of panic. Try the first non-deleted named
        // colour in the selected document's colour list. If nothing else, there should
        // always be a default Black that we can use

        if (ColList != NULL)
        {
            IndexedColour *Ptr = (IndexedColour *) ColList->GetHead();
            while (Ptr != NULL && UsefulColour == NULL)
            {
                if (Ptr->IsNamed() && !Ptr->IsDeleted())
                    UsefulColour = Ptr;
                
                Ptr = (IndexedColour *) ColList->GetNext(Ptr);
            }
        }
    }

    // Sanity check. Should never ever ever be the case, ever.
    if (UsefulColour != NULL)
        ERROR3IF(UsefulColour->IsDeleted(),
                "ColourManager::FindColourOfInterestToUser - Colour found is DELETED!");

    // Fill in the return results
    *ResultCol = UsefulColour;
    if (UsefulColour != NULL && ResultList != NULL)
        *ResultList = ColList;

#ifdef _DEBUG
    // In debug builds, verify that the returned colour is in the list we
    // expect it to be in!

    if (ColList != NULL && UsefulColour != NULL)
    {
        IndexedColour *Ptr = (IndexedColour *) ColList->GetHead();
        while (Ptr != NULL && Ptr != UsefulColour)
            Ptr = (IndexedColour *) ColList->GetNext(Ptr);

        if (Ptr == NULL)
        {
            Ptr = (IndexedColour *) ColList->GetUnnamedColours()->GetHead();
            while (Ptr != NULL && Ptr != UsefulColour)
                Ptr = (IndexedColour *) ColList->GetUnnamedColours()->GetNext(Ptr);
        }

        ERROR3IF(Ptr != UsefulColour,
                "ColourManager::FindColourOfInterestToUser"
                " - Colour found is not in the current colour list!");
    }
#endif

    // And restore the previous CurrentDocument state
    RestoreCurrentDoc(OldCurrentDoc);
}



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

>   static void ColourManager::FindColourOfInterestToUser(DocColour *ResultCol,
                                                        ColourList **ResultList = NULL,
                                                        BOOL WantLineColour = FALSE)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/1/95
    Inputs:     -
    Outputs:    ResultCol  - will be returned filled in with details of the colour to use
                ResultList - NULL, or a pointer to the ColourList of the relevant document
                WantLinecolour - TRUE if you'd rather get a line colour, FALSE if you want
                a fill colour.
    Returns:    -

    Purpose:    Several things (Colour editor whenever the selection changes, generation
                of a new colour) need to know a 'useful' colour to display/copy. 
                Rather than just showing the current default colour or something, they
                need to interactively update to show an appropriate colour from the
                selection and suchlike.

                This is very similar to the other overloaded method, but returns a DocColour.
                NOTE however, that the returned colour may not match the IndexedColour
                returned by the other method - a DocColour (which does not reference
                a NAMED IndexedColour) may be returned before a suitable IndexedColour
                would have been found.

                This is used to determine the colour definition for a colour to use when
                editing "local colours" in the colour editor.

                The exact colour returned will be NULL (in dire emergency, usually only
                occurs if there are no documents open), or will be chosen from this
                priority list of possible contenders:
                MonoOn
                    (1) Colour of first selected fill-blob found (if !WantLineColour),
                    (2) Fill-Colour of selection (if !WantLineColour),
                    (3) current/default fill colour (if !WantLineColour),
                    (4) line-Colour of selection (If WantLineColour),
                    (5) current/default line colour (if WantLineColour),
                    (6) COLOUR_BLACK
                MonoOff

    Notes:      'Colour of selection' is determined by using (if possible) the last
                object selected, or the frontmost selected object if this fails.

                If you are not interested in the ResultList return value, pass in NULL
                (use the default) for this parameter.

                Camelot will not return a 'no fill' default colour (condit