sgallery.cpp

Go to the documentation of this file.

// $Id: sgallery.cpp 1282 2006-06-09 09:46:49Z alex $
/* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
================================XARAHEADERSTART===========================
 
               Xara LX, a vector drawing and manipulation program.
                    Copyright (C) 1993-2006 Xara Group Ltd.
       Copyright on certain contributions may be held in joint with their
              respective authors. See AUTHORS file for details.

LICENSE TO USE AND MODIFY SOFTWARE
----------------------------------

This file is part of Xara LX.

Xara LX is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as published
by the Free Software Foundation.

Xara LX and its component source files are distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with Xara LX (see the file GPL in the root directory of the
distribution); if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA  02110-1301 USA


ADDITIONAL RIGHTS
-----------------

Conditional upon your continuing compliance with the GNU General Public
License described above, Xara Group Ltd grants to you certain additional
rights. 

The additional rights are to use, modify, and distribute the software
together with the wxWidgets library, the wxXtra library, and the "CDraw"
library and any other such library that any version of Xara LX relased
by Xara Group Ltd requires in order to compile and execute, including
the static linking of that library to XaraLX. In the case of the
"CDraw" library, you may satisfy obligation under the GNU General Public
License to provide source code by providing a binary copy of the library
concerned and a copy of the license accompanying it.

Nothing in this section restricts any of the rights you have under
the GNU General Public License.


SCOPE OF LICENSE
----------------

This license applies to this program (XaraLX) and its constituent source
files only, and does not necessarily apply to other Xara products which may
in part share the same code base, and are subject to their own licensing
terms.

This license does not apply to files in the wxXtra directory, which
are built into a separate library, and are subject to the wxWindows
license contained within that directory in the file "WXXTRA-LICENSE".

This license does not apply to the binary libraries (if any) within
the "libs" directory, which are subject to a separate license contained
within that directory in the file "LIBS-LICENSE".


ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS
----------------------------------------------

Subject to the terms of the GNU Public License (see above), you are
free to do whatever you like with your modifications. However, you may
(at your option) wish contribute them to Xara's source tree. You can
find details of how to do this at:
  http://www.xaraxtreme.org/developers/

Prior to contributing your modifications, you will need to complete our
contributor agreement. This can be found at:
  http://www.xaraxtreme.org/developers/contribute/

Please note that Xara will not accept modifications which modify any of
the text between the start and end of this header (marked
XARAHEADERSTART and XARAHEADEREND).


MARKS
-----

Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara
designs are registered or unregistered trademarks, design-marks, and/or
service marks of Xara Group Ltd. All rights in these marks are reserved.


      Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK.
                        http://www.xara.com/

=================================XARAHEADEREND============================
 */
// SGallery.h - the SuperGallery class

#include "camtypes.h"

//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "camelot.h"
#include "dragmsg.h"
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "galstr.h"
//#include "galres.h"
//#include "jason.h"
#include "keypress.h"
#include "camframe.h"
#include "progress.h"
//#include "resource.h" // For _R(IDS_OK) (dammit!)
//#include "sgallery.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "sgdrag.h"
#include "sgmenu.h"
//#include "sgtree.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "thumbmsg.h"
//#include "sglinepr.h"

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

#include "sgindgen.h"   // For ReplaceCharacters function (which should be in stringbase)
#include "sglib.h"      // For Searching stuff, which will be removed shortly
//#include "sglbase.h"  // For searching stuff
//#include "sglcart.h"  // For searching stuff
//#include "sglfills.h" // For searching stuff

//#include "richard3.h" // Few extra text resources

#include "brushmsg.h"   // for the screen change message

// Implement the dynamic class bits...
CC_IMPLEMENT_DYNCREATE(SuperGallery, DialogOp)
CC_IMPLEMENT_DYNCREATE(SGalleryOptionsDlg, DialogOp)
CC_IMPLEMENT_DYNCREATE(SGallerySortDlg, DialogOp)
CC_IMPLEMENT_DYNCREATE(SGallerySearchDlg, DialogOp)

// OpParam class for opening the options and search dlgs - local to this .cpp file
class GalDlgParam : public OpParam
{
CC_DECLARE_MEMDUMP(GalDlgParam)
public:
    GalDlgParam(SuperGallery *Parent) : OpParam(0, 0) { ParentGal = Parent; };
    SuperGallery *ParentGal;
};

CC_IMPLEMENT_MEMDUMP(GalDlgParam, OpParam)




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


// Static variables
SuperGallery *SuperGallery::CurrentSortGallery = NULL;  // Points at the gallery doing the current sort
                                                        // Used inside the qsort comparator function


// Preferences
INT32 SuperGallery::UseFixedColourSet = FALSE;          // Use Fixed colour set (or read 
                                                        // redraw colours from Windows settings)


#define MyIdlePriority (IDLEPRIORITY_LOW)


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

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

    Purpose:    Internal method to initialise data mambers. Shared code for constructors.

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

void SuperGallery::InitData(void)
{
    GallerySize         = wxSize(0,0);

    DisplayTree         = NULL;
    DisplayMode         = 0;

    FormatIsCached      = FALSE;

    LastWindowDX = LastWindowDY = 0;

    AmShaded            = FALSE;
    AmRedrawing         = FALSE;

    LastSelectedNode    = NULL;

    CurrentOptionsDlg           = NULL;
    CurrentSortDlg              = NULL;
    CurrentSearchDlg            = NULL;
    CurrentLinePropertiesDlg    = NULL;

    DblClickPending     = FALSE;        // We aren't in the middle of a double click

    PendingRedraws      = 0;
    LastBGNode          = NULL;

    for (INT32 i = 0; i < MaxSGSortKeys; i++)
    {
        SortKeys[i].SortKey  = 0;
        SortKeys[i].Reversed = FALSE;
    }
}



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

>   SuperGallery::SuperGallery(CCRuntimeClass *Class = CC_RUNTIME_CLASS(DialogOp)): DialogOp(_R(IDD_BLANKBAR), MODELESS,0,GSAFECLASS(Class))
                                                 
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/10/94
    Purpose:    SuperGallery constructor (Identical to DialogOp)

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

SuperGallery::SuperGallery(CCRuntimeClass *Class): DialogOp(_R(IDD_BLANKBAR), MODELESS,0,GSAFECLASS(Class)) 
{
    String_32 str = String_32(_R(IDS_K_BARS_NONAME));
    Name=str;
    InitData();
} 



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

>   SuperGallery::SuperGallery(String_32 &NewName,CCRuntimeClass *Class = CC_RUNTIME_CLASS(DialogOp): 
    DialogOp(NewName, Class) 

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/10/94
    Purpose:    SuperGallery constructor (Identical to DialogOp)

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

SuperGallery::SuperGallery(String_32 &NewName,CCRuntimeClass *Class)
        : DialogOp(_R(IDD_BLANKBAR), MODELESS,0,GSAFECLASS(Class))
{
    String_32 str = String_32(_R(IDS_K_BARS_NONAME));
    Name=str;
    InitData();
} 



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

>   SuperGallery::~SuperGallery()

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/10/94
    Purpose:    SuperGallery destructor.

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

SuperGallery::~SuperGallery()
{
    if (DisplayTree != NULL)
    {
        DisplayTree->DestroySubtree();  // Destroy the tree, destructing all nodes except root
        delete DisplayTree;             // And delete the root as well
        DisplayTree = NULL;
    }

    CloseOwnedDialogs();

    // Remove any idle event processor we had registered for BG redraws
    GetApplication()->RemoveIdleProcessor(MyIdlePriority, this);
}



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

>   void SuperGallery::FillInMiscInfo(SGMiscInfo *MiscInfo,
                                        ReDrawInfoType *DlgRedrawInfo = NULL)

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

    Inputs:     DlgRedrawInfo - If you happen to have one of these lying around, pass
                it in to save me having to find this out again.

    Outputs:    MiscInfo  - will be filled in, ready to be passed to SG event handlers

    Purpose:    Sets up a MiscInfo structure, ready for use.

    Scope:      private (Internal shared code for SuperGallery)

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

void SuperGallery::FillInMiscInfo(SGMiscInfo *MiscInfo, ReDrawInfoType *DlgRedrawInfo)
{
    // If the RedrawInfo was not passed in for us, go and get it for ourselves
    ReDrawInfoType TempDlgRedrawInfo;
    if (DlgRedrawInfo == NULL)
    {
        DlgRedrawInfo = &TempDlgRedrawInfo;
        GetKernelRenderedGadgetInfo(GetListGadgetID(), DlgRedrawInfo);
    }

    // Fill in the MiscInfo
    MiscInfo->DisplayMode   = DisplayMode;
    MiscInfo->PixelSize     = 72000 / DlgRedrawInfo->Dpi;
    MiscInfo->MaxWidth      = DlgRedrawInfo->dx;        // Window/virtualsize width
    MiscInfo->WindowHeight  = DlgRedrawInfo->dy;        // Window height
}



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

>   void SuperGallery::BroadcastEvent(SGEventType EventType, void *EventInfo,
                                        SGMiscInfo *MiscInfo = NULL)

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

    Inputs:     EventType - the type of the event to broadcast
                EventInfo - the information to pass in 'EventInfo' to all event handlers
                            (FormatInfo/RedrawInfo/MouseInfo, etc, depending upon EventType)
                MiscInfo  - the MiscInfo to pass to the event handlers. If this is passed in
                            as NULL, a MiscInfo structure will be set up automatically and
                            passed in (as MiscInfo must *always* be supplied)

    Purpose:    Passes the given event through the DisplayTree.

    SeeAlso:    SGDisplayNode::HandleEvent

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

void SuperGallery::BroadcastEvent(SGEventType EventType, void *EventInfo,
                                    SGMiscInfo *MiscInfo)
{
    if (DisplayTree == NULL)
        return;

    SGMiscInfo TheMiscInfo;

    if (MiscInfo == NULL && IsVisible())
    {
        FillInMiscInfo(&TheMiscInfo);
        MiscInfo = &TheMiscInfo;
    }

    ERROR3IF(MiscInfo == NULL && (EventType != SGEVENT_THUMBMSG && EventType != SGEVENT_BGFLUSH), 
            "Attempt to broadcast an event when the gallery is closed could be dangerous. Tell Jason");

    DisplayTree->HandleEvent(EventType, EventInfo, MiscInfo);
}



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

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

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/10/94
    Inputs:     Message - The message to handle

    Purpose:    A standard message handler, really. If you override this in a derived
                class, you must pass any unhandled event on to this base class method
                after handling the messages you are interested in.

    SeeAlso:    DialogOp::Message

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

MsgResult SuperGallery::Message(Msg* Message)
{
    if (MESSAGE_IS_A(Message,DeathMsg))     // We must destroy the dialog if the application is dying
    {
        // Destroy the entire DisplayList (which should be empty by now),
        // just to be on the safe side, in case a derived gallery forgot to do it
        if (DisplayTree != NULL)
        {
            DisplayTree->DestroySubtree();  // Destroy the display tree, destructing all nodes
            delete DisplayTree;
            DisplayTree = NULL;
        }

        // Ensure that all doc/view pointers for this Op are NULL to stop
        // 'FlushRedraw' access violations occurring.
        pOurDoc = NULL;
        pOurView = NULL;

        End();
        return(OK);
    }

        
    if ( Message->IsKindOf(CC_RUNTIME_CLASS(DialogMsg)) &&
            ((DialogMsg*)Message)->DlgMsg == DIM_BAR_DEATH )
    {
        DialogOp::Message(Message);
        return(OK);
    }

    if (IS_OUR_DIALOG_MSG(Message))
    {
        DialogMsg* Msg = (DialogMsg*)Message;

        BOOL WasRightButton = FALSE;        // What type of click was it (if any)
                                        // (allows code-sharing in the case statement)

        switch (Msg->DlgMsg)
        {
            case DIM_CREATE:
                {
                    String_32 name(CamResource::GetObjectName(DlgResID));
                    SetGalName(name);
                }
                break;

            case DIM_CANCEL:            // We're closing - close our owned dlgs
                CloseOwnedDialogs();

                // Ensure all items pending background redraws are flushed
                FlushBackgroundRedraws();
                
                // tell everyone the screen will be changing
                TRACEUSER( "Diccon", _T("Gallery closing\n"));
                BROADCAST_TO_ALL(ScreenChangeMsg());
                break;

            case DIM_MOUSEWHEEL_UP:
                {
                    //MouseWheel Scrolled Upwards...
                    TRACEUSER( "Matt", _T("SuperGallery::Message() Received MouseWheel UPWARDS Message!\n"));

                    ReDrawInfoType DlgRedrawInfo;
                    GetKernelRenderedGadgetInfo(GetListGadgetID(), &DlgRedrawInfo);

                    // Make a SGMiscInfo with, well, MiscInfo in it...
                    SGMiscInfo MiscInfo;
                    FillInMiscInfo(&MiscInfo, &DlgRedrawInfo);

                    //Get the old scroll offset, adjust it accordingly and set it to be the current one...
                    INT32 newScrollOffset = DisplayTree->GetScrollOffset() - (750 * 30);
                    DisplayTree->SetScrollOffset(newScrollOffset, &MiscInfo);
                }
                break;

            case DIM_MOUSEWHEEL_DOWN:
                {
                    //MouseWheel Scrolled Downwards...
                    TRACEUSER( "Matt", _T("SuperGallery::Message() Received MouseWheel DOWNWARDS Message!\n"));

                    ReDrawInfoType DlgRedrawInfo;
                    GetKernelRenderedGadgetInfo(GetListGadgetID(), &DlgRedrawInfo);

                    // Make a SGMiscInfo with, well, MiscInfo in it...
                    SGMiscInfo MiscInfo;
                    FillInMiscInfo(&MiscInfo, &DlgRedrawInfo);

                    //Get the old scroll offset, adjust it accordingly and set it to be the current one...
                    INT32 newScrollOffset = DisplayTree->GetScrollOffset() + (750 * 30);
                    DisplayTree->SetScrollOffset(newScrollOffset, &MiscInfo);
                }
                break;

            case DIM_RGT_BN_DOWN:
                WasRightButton = TRUE;
                // (Note: We treat a right click like a left click now. DIM_RGT_BN_UP is used
                // to pop up the menu when the button is released)

                // Drop through to LFT_BN_DOWN handler...

            case DIM_LFT_BN_DOWN:
                if ((Msg->GadgetID == GetListGadgetID()) && Msg->DlgMsgParam)
                {
                    // Get our kernel-rendered-dlg info, and calculate our virtual coord space
                    ReDrawInfoType *DlgRedrawInfo = (ReDrawInfoType*) Msg->DlgMsgParam;

                    // Determine where the mouse was clicked, within the virtual coord space
                    SGMouseInfo ClickInfo;

                    // Was it a ctrl-click? (Adjust/right clicks now pop up the menu)
                    ClickInfo.Adjust = KeyPress::IsGalleryCtrlPressed();

                    // Was it a click to extend the selection? (shift-click)
                    ClickInfo.Extend = KeyPress::IsGalleryShiftPressed();

                    // Was it a pop-up-menu (right button) click?
                    ClickInfo.MenuClick = WasRightButton;

                    // Is it the second installment in a double-click?
                    ClickInfo.DoubleClick = FALSE;
                    if (DblClickPending && !WasRightButton)
                    {
                        // Double-click Distance (millipoints). If the second click is more than this
                        // distance away from the forst click point, it is not regarded as a dble click.
                        const INT32 DblClickDist = 12000;       // **** !!!! Read dbl-click-dist preference
                        INT32 ClickDistX = ABS(LastClickPos.x - DlgRedrawInfo->pMousePos->x);
                        INT32 ClickDistY = ABS(LastClickPos.y - DlgRedrawInfo->pMousePos->y);
                        
                        if (ClickDistX <= DblClickDist && ClickDistY <= DblClickDist)
                        {
                            const INT32 DblClickTime = 400;     // **** !!!! Read OS dbl-click time!

                            if (!LastClickTime.Elapsed(DblClickTime))
                                ClickInfo.DoubleClick= TRUE;
                        }
                    }
                    LastClickPos = *(DlgRedrawInfo->pMousePos); // Remember last click position

                    if (ClickInfo.DoubleClick)
                        DblClickPending = FALSE;    // No longer pending double click
                    else
                    {
                        DblClickPending = TRUE;     // Double click is now pending
                        LastClickTime.Sample();     // Start the "double-click timeout" timer
                    }

                    ClickInfo.Position = *(DlgRedrawInfo->pMousePos);
                    ConvertToVirtualCoords(DlgRedrawInfo, &ClickInfo.Position);

                    // And request that the tree decides what to do with the event
                    BroadcastEvent(SGEVENT_MOUSECLICK, &ClickInfo);
                }
                break;


            case DIM_RGT_BN_UP:
                {
                    // Give the gallery a chance to do something before popping up the context menu
                    // At present, used by the bitmap gallery to ensure that the plug-ins have all
                    // been parsed.
                    PreContextMenu();
                    // Right button has been released - pop up a context-sensitive menu
                    GalleryContextMenu *TheMenu = new GalleryContextMenu(SGMENU_OVERITEM, this);
                    if (TheMenu != NULL)
                        TheMenu->Show();
                }
                break;


            case DIM_LFT_BN_CLICKED:
            {
                if (Msg->GadgetID == _R(IDC_GALLERY_NEW))
                {
                    ApplyAction(SGACTION_CREATE);
                }
                else if (Msg->GadgetID == _R(IDC_GALLERY_APPLY))
                {
                    // NB. changed to use Control key here, to be consistent with the
                    // way Adjust works when clicking on items.
                    if (KeyPress::IsGalleryCtrlPressed())
                    {
                        // If the gallery doesn't respond to Adjust-click then try a plain
                        // click instead.
                        if (!ApplyAction(SGACTION_APPLYADJUST)) ApplyAction(SGACTION_APPLY);
                    }
                    else
                    {
                        ApplyAction(SGACTION_APPLY);
                    }
                }
                else if (Msg->GadgetID == _R(IDC_GALLERY_REDEFINE))
                {
                    ApplyAction(SGACTION_REDEFINE);
                }
                else if (Msg->GadgetID == _R(IDC_GALLERY_EDIT))
                {
                    ApplyAction(SGACTION_EDIT);
                }
                else if (Msg->GadgetID == _R(IDC_GALLERY_DELETE))
                {
                    ApplyAction(SGACTION_DELETE);
                }
                else if (Msg->GadgetID == _R(IDC_GALLERY_MENU))
                {
                    // Pop up the options menu/dialogue
//                  SGalleryOptionsDlg::InvokeDialog(this);
                    GalleryContextMenu *TheMenu = new GalleryContextMenu(SGMENU_OPTIONS, this);
                    if (TheMenu != NULL)
                        TheMenu->Show();
                }
                break;
            }
            case DIM_RGT_BN_CLICKED:
                if (Msg->GadgetID == _R(IDC_GALLERY_APPLY))
                {
                    if (!ApplyAction(SGACTION_APPLYADJUST))
                        ApplyAction(SGACTION_APPLY);
                }
                break;


            case DIM_REDRAW:
                if (Msg->GadgetID == _R(IDC_GALLERY_LISTBOX))       // Render the list box
                {
                    RenderListBox((ReDrawInfoType*) Msg->DlgMsgParam);
                }
                break;
            
            default:
                break;
        }
    }
    else if (MESSAGE_IS_A(Message, DocChangingMsg))
    {
        DocChangingMsg *Msg = (DocChangingMsg *) Message;
        switch (Msg->State)
        {
            case DocChangingMsg::TITLECHANGED:
                if (DisplayTree != NULL && IsVisible())
                {
                    // If we have any 'categories' which represent this document,
                    // ask them to redraw themselves to update their titles.
                    SGDisplayNode *Category =
                        DisplayTree->FindSubtree(this, Msg->pChangingDoc, NULL);

                    if (Category != NULL)
                        Category->ForceRedrawOfMyself();
                }
                break;


            case DocChangingMsg::ABOUTTODIE:        // Document dying - remove from tree
                if (DisplayTree != NULL)
                {
                    // If the gallery has a subtree for this document, we'll scrap it for 'em
                    SGDisplayNode *Ptr = DisplayTree->FindSubtree(this, Msg->pChangingDoc, NULL);
                    if (Ptr != NULL)
                    {
                        Ptr->DestroySubtree();
                        ForceRedrawOfList();
                    }
                }
                break;


            case DocChangingMsg::SELCHANGED:
                if (Msg->pNewDoc == NULL)
                {
                    // There is no selected doc - this can only mean there are no docs
                    // at all, so we had better shade the gallery
                    ShadeGallery(TRUE);
                }
                break;

            default:
                break;
        }
    }

    else if (MESSAGE_IS_A(Message, DragMessage) && IsVisible() && DisplayTree != NULL)
    {
        // If a drag starting message comes around, pass it on to the tree
        DragMessage *Msg = (DragMessage *) Message;
        if (Msg->State == DragMessage::DRAGSTARTED)
        {
            BroadcastEvent(SGEVENT_DRAGSTARTED, (SGEventInfo *) Msg);

            // And then call our virtual function to add a drag target (if appropriate)
            // for the entire gallery listbox.
            HandleDragStart(Msg);
        }
    }

    else if (MESSAGE_IS_A(Message, ThumbMessage) && DisplayTree != NULL)
    {
        // If a library Thumb message comes around, pass it on to the tree
        // (do this even if the gallery is closed, as libraries may cache stuff even when closed)
        BroadcastEvent(SGEVENT_THUMBMSG, (SGEventInfo *) Message);
    }
    
    // Pass the call down to the base class
    return(DialogOp::Message(Message));

    return OK;
}    



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

>   BOOL SuperGallery::Create(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/10/94
    Returns:    TRUE if the window was successfully created
                FALSE => ERROR2
    Purpose:    The SuperGallery Create method
                This method has been overridden to de-specialize the DialogOp. 

    Notes:      Before doing anything else, the PreCreate handler is called.
                Secondly, the InitMenuCommands() method is called to init any
                required gallery menu items.
                Then, the gallery window is created and initialised
                The last thing done is to invoke the PostCreate method
                (these upcalls should be overridden by derived classes to do stuff)

                This finally calls SelectionHasChanged() to ensure the buttons etc
                are updated appropriately to the selection state.

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

BOOL SuperGallery::Create(void)
{
    if (!DialogOp::Create())
        return(FALSE);

    // Call derived class PreCreate handler (to create display tree, usually)
    if (!PreCreate())
        return(FALSE);

    // Call the derived class Menu creation handler, to create any needed menu items
    if (!InitMenuCommands())
        return(FALSE);

    // Ensure any items pending background-redraws are 'flushed'
    FlushBackgroundRedraws();

#ifndef EXCLUDE_FROM_XARALX
PORTNOTE("galleries", "Removed docking stuff")
    // Bar initialisation and creation
    SetDockBarType(Dock);
    SetSlot(Slot);
    SetOffset(Offset);
    SetFloatingCPoint(FloatPos);
#endif

//  if (!DialogOp::Create())
//      return(FALSE);

    AmShaded = FALSE;

    // Call derived class PostCreate handler
    if (!PostCreate())
        return(FALSE);

    SelectionHasChanged();      // Ensure we update appropriately for the selection state

    return(TRUE);
}



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

>   virtual void SuperGallery::SetVisibility(BOOL Open)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/1/96
    Inputs:     Open -  if TRUE then open SuperGallery in its last pos if it is
                        currently closed.
                        if FALSE, it is closed

    Purpose:    Used by the tool bar customize system to open and close a tool bar.

                SuperGallery overrides this virtual function so that it can be aware
                of when its window is closed/hidden, so that it may remove its owned
                dialogues (sort/search/properties).

                It always calls the base class in order to show/hide the gallery

                NOTE THAT THIS CAN DELETE THE OBJECT CONCERNED!

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

void SuperGallery::SetVisibility(BOOL Open)
{
    if (!Open)
    {
        // If we're being hidden, make sure that any owned dialogues are closed
        CloseOwnedDialogs();
    }   

    // Now call the base class to show/hide ourselves
    DialogOp::SetVisibility(Open);
    if (!Open)
        End(); // Return quick, this deletes the super gallery
}


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

>   virtual void SuperGallery::CloseOwnedDialogs(void)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/03/97

    Purpose:    Checks and closes the various dialogs which can be owned by galleries.

    SeeAlso:    SuperGallery::SetVisibility, SuperGallery::~SuperGallery()
                SuperGallery::Message(Msg* Message)

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

void SuperGallery::CloseOwnedDialogs(void)
{
    if (CurrentOptionsDlg != NULL)
    {
        CurrentOptionsDlg->Close();
        CurrentOptionsDlg->End();
    }

    if (CurrentSortDlg != NULL)
    {
        CurrentSortDlg->Close();
        CurrentSortDlg->End();
    }

    if (CurrentSearchDlg != NULL)
    {
        CurrentSearchDlg->Close();
        CurrentSearchDlg->End();
    }

PORTNOTE("dialogs", "Removed CurrentLinePropertiesDlg from SuperGallery::CloseOwnedDialogs(void)")
#ifndef EXCLUDE_FROM_XARALX
    if (CurrentLinePropertiesDlg != NULL)
    {
        CurrentLinePropertiesDlg->Close();
        CurrentLinePropertiesDlg->End();
    }
#endif
}

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

>   virtual BOOL SuperGallery::PreCreate(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/10/94
    Returns:    TRUE if the gallery was successfully initialised

    Purpose:    A call to be overridden by the derived class.
                This is called BEFORE the SuperGallery::Create function tries to create
                the gallery window.
                Derived galleries then initialise any unintialised data, and return
                TRUE if it is safe to continue creating the gallery window.

    Notes:      Generally speaking, most initialisation code should go into the post create
                handler method. Override this method with care.

    SeeAlso:    SuperGallery::PostCreate

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

BOOL SuperGallery::PreCreate(void)
{
    return(TRUE);
}



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

>   virtual BOOL SuperGallery::PostCreate(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/10/94
    Returns:    TRUE if the gallery was successfully initialised
    Purpose:    A call to be overridden by the derived class.
                This is called AFTER the SuperGallery::Create function has succeeded.
                Derived galleries can then initialise any unintialised data, and return
                TRUE if it is safe to open the gallery window.

    SeeAlso:    SuperGallery::PreCreate

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

BOOL SuperGallery::PostCreate(void)
{
    return(TRUE);
}



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

>   void SuperGallery::ShadeGallery(BOOL ShadeIt)

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

    Inputs:     ShadeIt - TRUE to shade, FALSE to un-shade, the gallery

    Purpose:    Shades (disables) the SuperGallery window.
                This calls the DoShadeGallery upcall to allow derived classes to take
                special action for any extra controls they may own, etc.

                If un-shading the gallery, it also calls SelectionHasChanged method to
                ensure that the buttons are in an appropriate state for the selection.

    Notes:      If the gallery is already in the requested state, or if it is closed
                (not visible on screen) then nothing happens (other than that the shaded
                flag is updated to reflect the desired state)

    SeeAlso:    SuperGallery::DoShadeGallery; SuperGallery::SelectionHasChanged

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

void SuperGallery::ShadeGallery(BOOL ShadeIt)
{
    if (AmShaded != ShadeIt && IsVisible())
    {
        EnableGadget(_R(IDC_GALLERY_APPLY),     !ShadeIt);
        EnableGadget(_R(IDC_GALLERY_NEW),       !ShadeIt);
        EnableGadget(_R(IDC_GALLERY_DELETE),    !ShadeIt);
        EnableGadget(_R(IDC_GALLERY_REDEFINE),  !ShadeIt);
        EnableGadget(_R(IDC_GALLERY_EDIT),      !ShadeIt);
//      EnableGadget(_R(IDC_GALLERY_UNDO),      !ShadeIt);
        EnableGadget(_R(IDC_GALLERY_MENU),      !ShadeIt);
        EnableGadget(_R(IDC_GALLERY_NAME),      !ShadeIt);

        DoShadeGallery(ShadeIt);
    }

    AmShaded = ShadeIt;

    if (!AmShaded)                  // If unshading, ensure the buttons are updated
        SelectionHasChanged();      // to reflect the new selection state
}



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

>   virtual void SuperGallery::DoShadeGallery(BOOL ShadeIt);

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

    Inputs:     ShadeIt - TRUE to shade, FALSE to un-shade, the gallery

    Purpose:    Shades (disables) the SuperGallery window.
                This calls the DoShadeGallery upcall to allow derived classes to take
                special action for any extra controls they may own, etc.

    Notes:      This base class method does nothing - it is expected to be overridden if
                derived classes need to do anything when shading state changes

    SeeAlso:    SuperGallery::DoShadeGallery

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

void SuperGallery::DoShadeGallery(BOOL ShadeIt)
{
    // The base class does nothing
}



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

>   virtual void SuperGallery::HandleDragStart(DragMessage *DragMsg)

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

    Inputs:     DragMsg - The DRAGSTARTED message that we've just recieved, indicating
                the type of drag which is just starting.

    Purpose:    Checks a DragMessage to see if it is a gallery list-drag. If so, it
                adds a new drag target to handle drops on the gallery list box.

    Notes:      This method should be overridden by derived galleries to:
                a) Stop the gallery from allowing recieving of these drags, or
                b) Add handlers for specific drag types you're interested in - e.g.
                the colour gallery will use less generic colour drags to handle
                gallery reorganisation, so that you can also drag colours out of the
                gallery.

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

void SuperGallery::HandleDragStart(DragMessage *DragMsg)
{
    // If this is a gallery list-reorganising drag which originated from this gallery,
    // then create a target for the gallery listbox.
    if (DragMsg->pInfo->IsKindOf(CC_RUNTIME_CLASS(SGListDragInfo)) &&
        ((SGListDragInfo *)DragMsg->pInfo)->GetParentGallery() == this)
    {
        // Note this sort of auto-attaches it seems - AMB
        /*SGListDragTarget *NewTarget = */new SGListDragTarget(this, GetListGadgetID());
    }
}



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

>   virtual BOOL SuperGallery::ApplyAction(SGActionType Action)

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

    Inputs:     Action - Indicates what action to apply

    Returns     FALSE (Derived classes will return TRUE to indicate successful handling
                of the action, or FALSE to indicate failure)

    Purpose:    Applies certain conventional gallery actions (usually associated with
                gallery buttons, for new, edit, delete, etc)

    Notes:      This base-class method should be overridden by derived classes. It
                does nothing by default, and returns FALSE.

    SeeAlso:    SGActionType

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

BOOL SuperGallery::ApplyAction(SGActionType Action)
{
    return(FALSE);
}



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

>   static INT32 __cdecl SuperGallery::SortComparator(const void *Item1, const void *Item2)

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

    Inputs:     Item1, Item2 - the display nodes to be compared

    Returns:    a negative, zero, or positive result of comparing the items with the
                current gallery multi-key sort mode.

    Purpose:    'qsort' comparator function, used when quicksorting the display list

    Notes:      Relies on the static var. 'CurrentSortGallery' to contain a pointer to
                the gallery which requested this sort.

    SeeAlso:    SuperGallery::ApplySortNow

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

INT32 __cdecl SuperGallery::SortComparator(const void *Item1, const void *Item2)
{
    SGDisplayNode *Node1 = *((SGDisplayNode **)Item1);
    SGDisplayNode *Node2 = *((SGDisplayNode **)Item2);

    INT32 Result = Node1->CompareTo(Node2, CurrentSortGallery->SortKeys[0].SortKey);
    if (CurrentSortGallery->SortKeys[0].Reversed)
        Result = -Result;

    if (Result == 0)
    {
        Result = Node1->CompareTo(Node2, CurrentSortGallery->SortKeys[1].SortKey);
        if (CurrentSortGallery->SortKeys[1].Reversed)
            Result = -Result;
    }

    return(Result);
}



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

>   virtual void SuperGallery::ApplySortNow(BOOL ApplyToEntireList)

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

    Inputs:     ApplyToEntireList - TRUE to sort the entire DisplayList,
                FALSE to sort only groups which contain a selection

    Purpose:    Applies the current gallery sort mode (member array SortKeys) to the
                display list.

    SeeAlso:    SuperGallery::SortComparator; ::qsort

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

void SuperGallery::ApplySortNow(BOOL ApplyToEntireList)
{
    if (SortKeys[0].SortKey == 0 || DisplayTree == NULL)
        return;
    
    CurrentSortGallery = this;

    SGDisplayNode *CurrentGroup = DisplayTree->GetChild();
    if (CurrentGroup == NULL)   // Nothing to sort
        return;

    SGDisplayNode *Ptr = CurrentGroup;

    // Pre-run progress indicator
    String_64 ProgMsg(_R(IDS_GALLERY_PREPARE_FOR_SORT));
    BeginSlowJob(-1, FALSE, &ProgMsg);

    // For library galleries we need to set the Quiet button status ready to un-supress errors
    SetQuietStatus(FALSE);

    // Count the number of available items to sort
    BOOL HasSelection = FALSE;
    INT32 NumItemsToSort = 0;
    while (Ptr != NULL)
    {
        if(ApplyToEntireList || ((SGDisplayGroup *)Ptr)->IsSelected())
            if(((SGDisplayGroup *)Ptr)->IsVirtualised())
                ((SGDisplayGroup *)Ptr)->DeVirtualise();

        if (ApplyToEntireList || ((SGDisplayGroup *)Ptr)->FindNextSelectedItem(NULL) != NULL)
        {
            SGDisplayNode *Item = Ptr->GetChild();  // Count number of items to sort in this group
            INT32 ItemsInThisGroup = 0;
            while (Item != NULL)
            {
                ItemsInThisGroup++;
                if (Item->Flags.Selected)
                    HasSelection = TRUE;
                Item = Item->GetNext();
            }

            if (ItemsInThisGroup > 1 && (ApplyToEntireList || HasSelection))
                NumItemsToSort += ItemsInThisGroup;
        }
        Ptr = Ptr->GetNext();
    }

    EndSlowJob();

    // If there is no point in trying to sort, abort now
    if (NumItemsToSort < 2)
        return;

    // Start progress indicators, with a percentage based upon the number of items.
    // We will update twice for each group (after qsort and shuffle-items stages)
    String_64 Description(_R(IDS_SGOPTS_SORTING));
    BeginSlowJob(NumItemsToSort * 2, FALSE, &Description);
    NumItemsToSort = 0;

    INT32 NumItems;
    INT32 i;
    BOOL GroupHasChanged = FALSE;

    while (CurrentGroup != NULL)
    {
        // Don't sort virtualised-out groups ! (they should have all been devirtualised before)
        if(!((SGDisplayGroup *)CurrentGroup)->IsVirtualised())
        {
            HasSelection = FALSE;
            Ptr = CurrentGroup->GetChild();
            ERROR3IF(Ptr != NULL && !Ptr->IsKindOf(CC_RUNTIME_CLASS(SGDisplayItem)),
                        "Sort hasn't found items! Heinous failure imminent!" );
            // Count the number of items we have to sort
            NumItems = 0;
            while (Ptr != NULL)
            {
                NumItems++;
                if (Ptr->Flags.Selected)
                    HasSelection = TRUE;
                Ptr = Ptr->GetNext();
            }

            // If there are 2 or more items, and we are either applying to all groups, or this
            // group contains selected item(s), then we will sort it..
            if (NumItems > 1 && (ApplyToEntireList || HasSelection))
            {
                // Get memory for an array of pointers to these items
                SGDisplayNode **SortArray = (SGDisplayNode **)CCMalloc(NumItems * sizeof(SGDisplayNode *));
                if (SortArray == NULL)
                {
                    CurrentSortGallery = NULL;
                    InvalidateCachedFormat();
                    EndSlowJob();
                    InformError();
                    return;
                }

                // Fill in the array with pointers to display items to sort
                i = 0;
                Ptr = CurrentGroup->GetChild();
                while (Ptr != NULL)
                {
                    SortArray[i++] = Ptr;
                    Ptr = Ptr->GetNext();
                }

                // Sort the array of pointers
                qsort(SortArray, NumItems, sizeof(SGDisplayNode *), SuperGallery::SortComparator);

                NumItemsToSort += NumItems;
                if (!ContinueSlowJob(NumItemsToSort)) // Update percentage complete for the number of items processed
                {
                    // User has cancelled by pressing escape
                    CCFree(SortArray);
                    break;
                }


                GroupHasChanged = FALSE;

                // Now, take the sorted array, and rearrange the display items to be in that order      
                // Special case the first item
                if (SortArray[0]->GetPrevious() != NULL)
                {
                    SortArray[1]->MoveBefore(SortArray[0]);
                    GroupHasChanged =