sglcart.cpp

Go to the documentation of this file.

// $Id: sglcart.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============================
 */
// SGLibClipart.cpp - LibClipart SuperGallery classes - LibClipartSGallery and SGDisplayLibClipart

#include "camtypes.h"
#include "sglcart.h"
#include <io.h>

//#include "app.h"      // For GetApplication() - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "galstr.h"
//#include "pathname.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "sginit.h"
#include "sglcart.h"    // This .cpp file's corresponding header
#include "sglib.h"
#include "sgmenu.h"
//#include "sgtree.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "thumb.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "sglfills.h"
#include "thumbmsg.h"
#include "grnddib.h"
//#include "galres.h"
//#include "richard.h"
#include "sgliboil.h"
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "selop.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "filedlgs.h"
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "progress.h"
#include "camelot.h"
#include "dragmgr.h"
//#include "viewrc.h"       // FOR _R(IDC_CANDROPONPAGE)
//#include "resource.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "scrcamvw.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "sgscan.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "sgscanf.h"
#include "sglbase.h"
#include "sgrmfile.h"   // For Lib settings
//#include "richard2.h" // For yet more resource strings
#include "keypress.h"   // For adjust checking
#include "fileutil.h"
#include "camdoc.h"
#include "pathnmex.h"
//#include "webster.h"
#include "inetop.h"
#include "camnet.h"
//#include "simon.h"

//#include "richard3.h" // For _R(IDS_GALLERY_FREEING_MEMORY_ON_CLOSE)

#ifdef _BATCHING
#define SAVEASWELL 1
// For batching...
#include <stdio.h>
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "page.h"
#include "pagesize.h"
#include "optspage.h"
//#include "units.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "grid.h"
#include "zoomops.h"
#include "layer.h"
//#include "node.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "collist.h"
#include "colourix.h"
#include "colormgr.h"
#include "webop.h"
#endif

#include "helpuser.h"       //For the help button
//#include "xshelpid.h"     //For the help button
//#include "helppath.h"
//#include "mario.h"            //For _R(IDE_NOMORE_MEMORY)
#include "resdll.h"

using namespace InetUtils;


// Implement the dynamic class bits...
CC_IMPLEMENT_DYNCREATE(LibClipartSGallery, LibraryGallery)
CC_IMPLEMENT_DYNCREATE(OpDisplayLibClipartGallery, Operation)
CC_IMPLEMENT_DYNCREATE(SGClipartItem, SGLibDisplayItem)
CC_IMPLEMENT_DYNCREATE(GalleryClipartDragInfo, BitmapDragInformation)
CC_IMPLEMENT_DYNAMIC(SGClipartDragTarget, SGListDragTarget)
CC_IMPLEMENT_DYNAMIC(SGOilClipartDragTarget, WinoilDragTarget)
CC_IMPLEMENT_DYNCREATE(OpLibGalClipTheme, OpDescriptor);

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

/*
//Static Variables
#ifdef _DEBUG
//String_256 LibClipartSGallery::DefaultLibraryPath = TEXT("\\\\deepthought\\camelotcd\\cd\\clipart");
String_256 LibClipartSGallery::DefaultLibraryPath = TEXT("\\\\jimpc\\corelxra\\clipart");
#else
String_256 LibClipartSGallery::DefaultLibraryPath = TEXT("D:\\clipart");
#endif
*/


// Matt - 03/01/2001
// New statics - we need to remember two directories (one for clipart, one for web themes) + I don't see the need for a debug
// special version of these statics as \\jimpc won't have a '\themes' subdirectory anyway...

// Statics
String_256 LibClipartSGallery::ClipartPath = TEXT("D:\\clipart");
String_256 LibClipartSGallery::WebThemePath = TEXT("D:\\themes");
String_256 LibClipartSGallery::DefaultLibraryPath = ClipartPath;

// For keeping the display modes constant when next loaded
INT32 LibClipartSGallery::DefaultDisplayMode = 0;   // WEBSTER - markn 7/2/97 (changed default display mode)


// For keeping the sort keys constant when next loaded (default == sort alphabetically)
// 1st sort key = DefaultSortKeys & 0x8f
// 2nd sort key = ((DefaultSortKeys>>8) & 0x8f)
// 1st sort key reversed = ((DefaultSortKeys>>7) & 0x01)==1
// 2nd sort key reversed = ((DefaultSortKeys>>15) & 0x01)==1
// So 0 means no sorting at all
// and 1 means sort the gallery alphabetically
UINT32 LibClipartSGallery::DefaultSortKeys = 1;

// Batching system will use this directory to put its output in
String_256 LibClipartSGallery::BatchSaveLocation = "";

BOOL LibClipartSGallery::DoSounds = TRUE;

// Should always be pointing at a clipart gallery
LibClipartSGallery *LibClipartSGallery::ThisGallery = NULL;

LibClipartSGallery* LibClipartSGallery::m_pInstance = 0;

// Quiet status of gallery
BOOL LibClipartSGallery::QuietStatus = FALSE;



//#define _PROFILE_REDRAW

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

>   LibClipartSGallery::LibClipartSGallery()
                                                 
    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/1/95 (base generated in sgbase.cpp)
    Purpose:    LibClipartSGallery default constructor

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

LibClipartSGallery::LibClipartSGallery()
{
    LibClipartSGallery::ThisGallery = this;
    m_bDiscardWebFolders = FALSE;
    // Default gallery size
    CSize Size(((333 * 2) - 32) - 32, 256);
    SetGallerySize(Size);
    m_pInstance = this;
    m_nClipTheme = 0;
    m_bRedraw = false;
}



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

>   LibClipartSGallery::~LibClipartSGallery()

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/1/95 (base generated in sgbase.cpp)
    Purpose:    LibClipartSGallery destructor.

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

LibClipartSGallery::~LibClipartSGallery()
{
    TRACEUSER( "Matt", _T("~LibClipartSGallery\n"));

    OpenLibFiles.DeleteAll();       // Ensure all open libraries are closed
    LibClipartSGallery::ThisGallery = NULL;
    m_pInstance = 0;
}


/********************************************************************************************
>   static LibClipartSGallery* LibClipartSGallery::Instance()

    Author:     Priestley (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/09/2000
    Returns:    The current LibClipartSGallery object.
********************************************************************************************/

LibClipartSGallery* LibClipartSGallery::Instance()
{
    ERROR3IF(m_pInstance == 0, "LibClipartSGallery::Instance: no gallery");
    return m_pInstance;
}



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

>   static BOOL LibClipartSGallery::Init(void)

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

    Returns:    TRUE if the sgallery initialised successfully
                FALSE if it failed to initialise
    Purpose:

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

BOOL LibClipartSGallery::Init(void)
{
    TRACEUSER( "Matt", _T("Init clipart gallery\n"));
#ifdef _BATCHING
        
    GetApplication()->DeclareSection(TEXT("Batching"), 6);
    GetApplication()->DeclarePref(TEXT("Batching"), TEXT("OutputDirectory"), &LibClipartSGallery::BatchSaveLocation);

#endif

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

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


    return(TRUE);
}



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

>   BOOL LibClipartSGallery::PreCreate(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/1/95 (base generated in sgbase.cpp)

    Returns:    TRUE if the Gallery initialised successfully
                FALSE if it should not be opened due to a failure to initialise

    Purpose:    The LibClipartSGallery PreCreate handler. This overrides the base class
                PreCreate function. It is called at the very beginning of the
                SuperGallery::Create method, before the window has been created.

    Notes:      As this is called before the window is open, it must not attempt to touch
                any of the button gadgets in the window, or force redraws, etc. Also,
                events cannot be passed to the tree, as the tree formatting relies on
                knowing the window size - however, the tree will be reformatted and
                redrawn automatically when the window is opened - this will happen shortly.

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

BOOL LibClipartSGallery::PreCreate(void)
{
    TRACEUSER( "Matt", _T("Precreating clipart window\n"));
    // If there isn't already one, create a DisplayTree
    if (DisplayTree == NULL)
    {
        DisplayTree = new SGDisplayRootScroll(this);    // New root node, with a scrollbar
        if (DisplayTree == NULL)
            return(FALSE);
    }

    // Add the library groups to the gallery if they're not there already
    if(OpenLibFiles.IsEmpty())
    {
        if(!AddGRMGroups(SGLib_ClipArt))
        {
            String_256 sLoc = ClipartPath;
            String_256 sLoc2 = WebThemePath;
            // Set DefaultLibraryPath to <ExeLocation>\Fills - the user might have installed
            // the fills to his hard disk:
            String_256 sExePath;
            if(CResDll::GetExecutablePath((TCHAR*)sExePath))
            {
                INT32 oldi = GetClipTheme();

                String_256 LibDirName;
                LibDirName.MakeMsg(_R(IDS_LIBRARIES_CLIPART_DIRNAME));
                ClipartPath = sExePath;
                ClipartPath += "\\";
                ClipartPath += LibDirName;

                PathName ThisPath(ClipartPath);
                if(!SGLibOil::FileExists(&ThisPath))    // will also work for paths (not just paths with a filename on the end)
                {
                    SetClipTheme(0);
                    // Fills not on hard disk. Try the CD location
                    if(!ScanForLocation(SGLib_ClipArt, NULL))
                    {
                        // hard drive and CD location not found
                        // put the original path back
                        ClipartPath = sLoc;
                    }
                }

                String_256 LibDirName2;
                LibDirName2.MakeMsg(_R(IDS_LIBRARIES_WEBTHEMES_DIRNAME));
                WebThemePath = sExePath;
                WebThemePath += "\\";
                WebThemePath += LibDirName2;

                PathName ThisPath2(WebThemePath);
                if(!SGLibOil::FileExists(&ThisPath2))   // will also work for paths (not just paths with a filename on the end)
                {
                    SetClipTheme(0);
                    // Fills not on hard disk. Try the CD location
                    if(!ScanForLocation(SGLib_ClipArt_WebThemes, NULL))
                    {
                        // hard drive and CD location not found
                        // put the original path back
                        WebThemePath = sLoc;
                    }
                }
                // reset the ClipTheme value
                SetClipTheme(oldi);
            }

            LibraryGallery::AddLibraryGroups(SGLib_ClipArt, &ClipartPath);
            LibraryGallery::AddLibraryGroups(SGLib_ClipArt_WebThemes, &WebThemePath);
        }
    }

    // Use last time's display mode
    DisplayMode = LibClipartSGallery::DefaultDisplayMode;

    return(TRUE);
}



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

>   void LibClipartSGallery::SortGallery(void)

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

    Inputs:     
    Returns:

    Purpose:    Sorts the contents of the gallery in an alphabetical fashion, whilst keeping
                the old sort key status...
    Notes:      
    SeeAlso:

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

void LibClipartSGallery::SortGallery(void)
{
    // Matt - 03/01/2001
    // Special case fix ('bodgeus horriblus')- when we are in the clipart gallery we need to remember the default paths for either the web themes or clipart
    // - this method is called just after the defaultlibrarypath is set in the base class, so now's a good time to remember them...
    if (GetClipTheme() == 0)
    {
        LibClipartSGallery::ClipartPath = LibClipartSGallery::DefaultLibraryPath;
    }
    else
    {
        LibClipartSGallery::WebThemePath = LibClipartSGallery::DefaultLibraryPath;
    }

    LibraryGallery::SortGallery();
}


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

>   virtual BOOL LibClipartSGallery::ApplyAction(SGActionType Action)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/1/95 (base generated in sgbase.cpp)

    Inputs:     Action - Indicates what action to apply

    Returns:    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)

    SeeAlso:    SGActionType

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

BOOL LibClipartSGallery::ApplyAction(SGActionType Action)
{
    // No display tree? Better forget about it then!
    if (DisplayTree == NULL)
        return(FALSE);

    switch(Action)
    {
        case SGACTION_REDEFINE:
            break;

        case SGACTION_APPLY:
            ImportClipart(TRUE, this);
            break;
        
/*      case SGACTION_APPLYADJUST:
            ImportClipart(FALSE);
            break;*/

        case SGACTION_EDIT:
            // Ignored - libraries are currently read-only
            break;

        case SGACTION_DELETE:
            // Ignored - libraries are currently read-only
            break;

        case SGACTION_SETOPTIONS:   // Set values in the options dialogue as it is opened
            {
                if (CurrentOptionsDlg == NULL)
                    return(FALSE);
            
                CurrentOptionsDlg->AddDisplayModeName(_R(IDS_GALLERYDM_LARGE));     // 0
                CurrentOptionsDlg->AddDisplayModeName(_R(IDS_GALLERYDM_FULLINFO));  // 1
                CurrentOptionsDlg->AddDisplayModeName(_R(IDS_GALLERYDM_SMALL));     // 2
            }
            break;

        case SGACTION_SETSORTMODE:
            {
                if (CurrentSortDlg == NULL)
                    return(FALSE);

                CurrentSortDlg->AddSortKeyName(_R(IDS_SORTBY_NAME));
                CurrentSortDlg->AddSortKeyName(_R(IDS_SORTBY_MEMORY));
                CurrentSortDlg->AddSortKeyName(_R(IDS_SORTBY_NAMELENGTH));
                CurrentSortDlg->AddSortKeyName(_R(IDS_SORTBY_FILETYPE));
            }
                                    
            break;


        case SGACTION_DISPLAYMODECHANGED:
            if(DisplayMode >= 3) DisplayMode = 0;
            LibClipartSGallery::DefaultDisplayMode = DisplayMode;
            InvalidateCachedFormat();
            ReformatAndRedrawIfNecessary();
            //ForceRedrawOfList();
            break;
    
        default:
            return(SuperGallery::ApplyAction(Action));
            break;
    }

    return(TRUE);
}



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

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

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/1/95 (base generated in sgbase.cpp)
    Inputs:     Message - The message to handle

    Purpose:    A standard message handler, really.

    Notes:      Any messages that this does not handle must be passed down to the
                SuperGallery base class message handler.

                NOTE WELL that the SuperGallery base class handler does some funky things
                for us - see SuperGallery::Message - such as deleting our display subtree
                for any document which dies (which, uncannily, would explain why they go
                away like that when you close documents ;-), and shading the gallery when
                there are no documents present. [To override this behaviour in these cases,
                you should respond to the message, and return OK rather than calling the
                base class message handler]

    SeeAlso:    SuperGallery::Message

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

MsgResult LibClipartSGallery::Message(Msg* Message)
{
    // Added by Craig Hamilton 18/1/01.
    static HANDLE   handle = NULL;
    CString         mutexName = "autorunMutex";
    // End added.

    // If we have no displaytree, then we have not been shown, or something terrible has
    // happened, so we don't bother handling any of these messages.
    if (DisplayTree == NULL)
        return(LibraryGallery::Message(Message));

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

        switch (Msg->DlgMsg)
        {
            case DIM_CREATE:
                // Added by Craig Hamilton 18/1/01.
                // This and the section of code of the same date in the DIM_CANCEL handler below
                // deal with the creation and destruction of a kernel object that is recognised by
                // the autorun. If this object exists then the autorun does not run. This is so
                // that the user can enter their resources cd while the gallery is open and not be
                // annoyed by the autorun appearing.
                handle = CreateMutex(NULL,TRUE,mutexName);
                // End added.

                SGInit::UpdateGalleryButton(OPTOKEN_DISPLAYCLIPARTGALLERY, TRUE);
                GalleryAboutToReOpen();
                break;

            case DIM_CANCEL:
                // Added by Craig Hamilton 18/1/01.
                if(handle != NULL)
                {
                    CloseHandle(handle);
                }
                // End added.

                SGInit::UpdateGalleryButton(OPTOKEN_DISPLAYCLIPARTGALLERY, FALSE);

                // Flush the thumbnail cache
                BROADCAST_TO_CLASS(ThumbMessage(ThumbMessage::ThumbState::KILLCACHE, SGLib_ClipArt), DialogOp);
                BROADCAST_TO_CLASS(ThumbMessage(ThumbMessage::ThumbState::KILLCACHE, SGLib_ClipArt_WebThemes), DialogOp);
                BROADCAST_TO_CLASS(ThumbMessage(ThumbMessage::ThumbState::KILLCACHE, SGLib_Bitmap), DialogOp);

                GalleryAboutToClose();
                
                break;

            case DIM_LFT_BN_CLICKED:
                switch (Msg->GadgetID)
                {
                    case _R(IDC_LIBGAL_OPEN):
                        ImportClipart(TRUE, this);
                        break;

                    case _R(IDC_GALLERY_HELP):      // Show help page
                        HelpUserTopic(_R(IDS_HELPPATH_Gallery_Clipart));
                        break;


                    case _R(IDC_LIBGAL_UPDATE):
#ifdef _BATCHING     
                        LoadAndSave();
#endif
                        break;
                    
                    case _R(IDC_LIBGAL_IMPORT):
                        ImportClipart(FALSE, this);
                        break;

                    case _R(IDC_LIBGAL_BROWSE):
                    case _R(IDC_LIBGAL_ADD_CLIPART):
                        BrowseClicked();
                        break;

                    case _R(IDC_BMPGAL_SAVE):
#ifdef _DEBUG
                        {
                            SGDisplayNode *Item = DisplayTree->FindNextSelectedItem(NULL);
                            if(Item != NULL && Item->IsKindOf(CC_RUNTIME_CLASS(SGLibDisplayItem)))
                            {
                                SGLibDisplayItem *LibItem = (SGLibDisplayItem *)Item;

                                Library *Parent = LibItem->GetParentLibrary();
                                if(Parent != NULL)
                                {
                                    Error::SetError(0, TEXT("Renumber ID's ? (Doing this will mess external thumbnails up in a major way !)"), 0); // Debug
                                    INT32 ButtonPressed = InformWarning(0, _R(IDS_OK), _R(IDS_KEEP), _R(IDS_CANCEL), NULL);

                                    if(ButtonPressed != 3)
                                    {
                                        PathName *Source = Parent->ReturnIndexLocation();
                                        PathName Dest(*Source);
                                        Dest.SetType((String_256)"BAK");
                                        SGLibOil::FileCopy(Source, &Dest);
                                        Parent->SaveIndexInDisplayedOrder(Source, (ButtonPressed == 1));
                                    }
                                }
                            }
                        }
#endif
                        break;
                    
                    default:
                        break;
                }

#ifdef _PROFILE_REDRAW
            case DIM_REDRAW:
                if (Msg->GadgetID == GetListGadgetID())
                {
                    ProfileRedraw((ReDrawInfoType*) Msg->DlgMsgParam);
                    return(DialogBarOp::Message(Message));
                    break;
                }
                break;
#endif
        }
    }
    else if (MESSAGE_IS_A(Message, DocChangingMsg))
    {
        DocChangingMsg *Msg = (DocChangingMsg *) Message;
        switch (Msg->State)
        {
            case DocChangingMsg::DocState::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
                    SuperGallery::ShadeGallery(TRUE);
                }
                else
                {
                    // Possibly a new document
                    SuperGallery::ShadeGallery(FALSE);
                    SelectionHasChanged();
                }
                break;
        }
    }
    else if (MESSAGE_IS_A(Message, ThumbMessage) && DisplayTree != NULL)
    {
        ThumbMessage *Msg = (ThumbMessage *) Message;

        // If a library Thumb message comes around, flush the redraw stuff, etc
        if(Msg->State == ThumbMessage::ThumbState::CACHESIZECHANGED)
        {
            FlushBackgroundRedraws();
            ForceRedrawOfList();
        }
    }

    return(LibraryGallery::Message(Message));
}    





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

>   BOOL LibClipartSGallery::BrowseClicked(void)

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

    Inputs:     
    Returns:    TRUE if the gallery has new stuff in it (FALSE if cancel clicked, etc)...

    Purpose:    Pops up the browse box and lets a new location be set for the clipart
                directory

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

BOOL LibClipartSGallery::BrowseClicked(void)
{
    if (GetClipTheme() == 0)
    {
        return (LibraryGallery::BrowseClicked(&DefaultLibraryPath, SGLib_ClipArt, _R(IDS_REMOVE_OLD_GOUPS_CLIPART)));
    }
    else
    {
        return (LibraryGallery::BrowseClicked(&DefaultLibraryPath, SGLib_ClipArt_WebThemes, _R(IDS_REMOVE_OLD_GOUPS_CLIPART)));
    }
}


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

>   virtual BOOL LibClipartSGallery::CanCreateIndexes(void)

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

    Returns:    TRUE to if index generation is possible

    Purpose:    To determine if this gallery can generate indexes or not

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

BOOL LibClipartSGallery::CanCreateIndexes(void)
{
    return TRUE;
}


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

>   virtual BOOL LibClipartSGallery::GetDefaults(String_256 *DefaultIndex, String_256 *IndexDesc, SGLibType *Type)

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

    Outputs:    DefaultIndex    - The filename for the default index file (Xaraclip.txt)
                IndexDesc       - Description of the index / gallery (Clipart)
                Type            - Default library type associated with this gallery

    Returns:    TRUE if this was overridden successfully 

    Purpose:    To determine various library gallery default properties

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

BOOL LibClipartSGallery::GetDefaults(String_256 *DefaultIndex, String_256 *IndexDesc, SGLibType *Type)
{
    TRACEUSER( "Matt", _T("Getting defaults for clipart gallery\n"));
    if(DefaultIndex != NULL)
    {
        //Set the correct info filename for the current gallery style
        if (GetClipTheme() == 0)
        {
            *DefaultIndex = _R(IDS_LIBRARIES_CLIPART_FILENAME); // "XaraClip.txt";
        }
        else
        {
            *DefaultIndex = _R(IDS_LIBRARIES_WEBTHEMES_FILENAME);   // "XaraThem.txt";
        }
    }

    if(IndexDesc != NULL)
        *IndexDesc = _R(IDS_LIBRARIES_CLIPART_DESC);        // "Clipart";

    if(Type != NULL)
    {
        //Set the type of the gallery to be 'Clipart' or 'Web Themes'
        //so that the base classes attempt to load file info from the
        //correct URL - real handy...
        if (GetClipTheme() == 0)
        {
            *Type = SGLib_ClipArt;
        }
        else
        {
            *Type = SGLib_ClipArt_WebThemes;
        }
    }

    return TRUE;
}

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

>   virtual BOOL LibClipartSGallery::GetLibraryDirectoryName(String_256 *LibDirName)

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

    Outputs:    LibDirName  - Returns the Default directory (on the clipart CD) for the gallery
    Returns:    TRUE if overridden and directory obtained...

    Purpose:    Get the default CD directory name for the gallery

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

BOOL LibClipartSGallery::GetLibraryDirectoryName(String_256 *LibDirName)
{
    TRACEUSER( "Matt", _T("Getting library directory name for clipart gallery\n"));
    if (GetClipTheme() == 0)
    {
        LibDirName->MakeMsg(_R(IDS_LIBRARIES_CLIPART_DIRNAME));
    }
    else
    {
        LibDirName->MakeMsg(_R(IDS_LIBRARIES_WEBTHEMES_DIRNAME));
    }
    return TRUE;
}

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

>   virtual BOOL LibClipartSGallery::CheckForIndexMatch(StringBase *Txt)

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

    Inputs:     Txt     - Last column entry in the index.txt file (" A")
    Returns:    TRUE if this signifies the gallery in question...

    Purpose:    To see whether we should add this line of the index.txt file to this gallery

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

BOOL LibClipartSGallery::CheckForIndexMatch(StringBase *Txt)
{
    BOOL Match = FALSE;

    // Artwork, and Bitmaps...
    if(((Txt->Sub(String_8("A"))!=-1) || (Txt->Sub(String_8("a"))!=-1)) ) Match = TRUE;
    if(((Txt->Sub(String_8("B"))!=-1) || (Txt->Sub(String_8("b"))!=-1)) ) Match = TRUE;             

    return Match;
}


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

>   virtual BOOL LibClipartSGallery::GetQuietStatus(void)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/12/95
    Returns:    TRUE if Quiet has been pressed (SetQuiet status called with TRUE)
    Purpose:    Get the Quiet status of the gallery

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

BOOL LibClipartSGallery::GetQuietStatus(void)
{
    return LibClipartSGallery::QuietStatus;
}

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

>   virtual void LibClipartSGallery::SetQuietStatus(BOOL Status)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/12/95
    Inputs:     Status - Set to TRUE and call if Quiet has just been pressed on an 'adding
                         indexes' dialog
    Purpose:    Set the Quiet status of the gallery

********************************************************************************************/
        
void LibClipartSGallery::SetQuietStatus(BOOL Status)
{
    LibClipartSGallery::QuietStatus = Status;
}


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

>   virtual BOOL LibClipartSGallery::ScanForLocation(SGLibType Type, StringBase *Result = NULL);

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

    Inputs:     Type of library to scan for
    Outputs:    (We assume the library static strings exist and use them - bit yucky)
                If a Result pointer if given then we copy this into there as well..
    Returns:    FALSE if it fails; TRUE if we got a path

    Purpose:    Searches all the drives for a CDROM drive. If it finds the Camelot CD
                mount here at Xara HQ, we point to that instead.
    Notes:

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

BOOL LibClipartSGallery::ScanForLocation(SGLibType Type, StringBase *Result)
{
    // Search for a CD ROM drive
    String_256 DriveName;
    BOOL AreWeXara = FALSE;
    String_256 XaraDrive;

    BOOL Adjust = KeyPress::IsAdjustPressed();
#ifndef _DEBUG
    Adjust = FALSE;
#endif

    if(SGLibOil::LocateCDROMDrive(this, Type, &DriveName, &AreWeXara, &XaraDrive, Adjust))
    {
        if(AreWeXara)
            DriveName = XaraDrive;

        switch(Type)
        {
            case SGLib_ClipArt:
            case SGLib_ClipArt_WebThemes:
            case SGLib_Bitmap:
            {
                LibClipartSGallery::DefaultLibraryPath = DriveName;
#ifdef _DEBUG
                if(Adjust)
                {
                    LibClipartSGallery::DefaultLibraryPath += TEXT("Graphics\\XaraSt~1");
                }
                else
#endif
                {
                    String_256 LibDirName;
                    GetLibraryDirectoryName(&LibDirName);
                    LibClipartSGallery::DefaultLibraryPath += LibDirName;
                }

                if(Result)
                    *Result = LibClipartSGallery::DefaultLibraryPath;

                if (GetClipTheme() == 0)
                {
                    LibClipartSGallery::ClipartPath = LibClipartSGallery::DefaultLibraryPath;
                }
                else
                {
                    LibClipartSGallery::WebThemePath = LibClipartSGallery::DefaultLibraryPath;
                }

                return TRUE;
            }

        }
    }
    return FALSE;
}



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

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

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

    Inputs:     DragMsg - The DRAGSTARTED message that we've just recieved, indicating
                the type of drag being started

    Purpose:    Checks a DragMessage to see if it is a colour drag.
                If it is, then it creates a drag target for this gallerys listbox.

    Notes:      Overrides the default base-class action. Calls down to the base class
                if it is not a colour drag, so that dragging of gallery groups is allowed

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

void LibClipartSGallery::HandleDragStart(DragMessage *DragMsg)
{
    // If it's a bitmap drag, add a target for our window. If not, let the base class
    // have a look at it (to see if it is a gallery item being dragged)
    if (DragMsg->pInfo->IsKindOf(CC_RUNTIME_CLASS(GalleryClipartDragInfo)))
        SGClipartDragTarget *NewTarget = new SGClipartDragTarget(this, GetListGadgetID());
    else
        SuperGallery::HandleDragStart(DragMsg);
}


/* for profiling reasons */

void LibClipartSGallery::ProfileRedraw(ReDrawInfoType *Param)
{
#ifdef _PROFILE_REDRAW
    RenderListBox(Param);
#endif
}

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

>   BOOL LibClipartSGallery::ImportClipart(BOOL NewDocument)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/3/95
                    Asynchronous import code added by Adrian, 12/96
    Inputs:     NewDocument - Set to TRUE if you don't want the import to be added ontopof
                the currently selected document.
    Outputs:
    Returns:    TRUE if things went OK, false otherwise

    Purpose:    To load/import all the selected clipart items one by one into camelot.              
    Notes:
    SeeAlso:

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

BOOL LibClipartSGallery::ImportClipart(BOOL NewDocument, LibraryGallery* pSourceGallery)
{
    TRACEUSER( "Matt", _T("Importing clipart in clipart gallery\n"));
    if (pSourceGallery->DisplayTree == NULL)
    {
        ERROR3("LibClipartSGallery::ImportClipart No display tree - bad !");
        return FALSE;
    }

    if(Document::GetSelected() == NULL && !NewDocument)
    {
        return FALSE;
    }
                                      
    BOOL ok = TRUE;


    // Find the first selected item (if any) and get the next item to start searching from
    // If there is no selection, then get the first item
    SGDisplayNode *Item = pSourceGallery->DisplayTree->FindNextSelectedItem(NULL);
    String_256 ItemText;

    while (Item != NULL)
    {
        if(Item->IsKindOf(CC_RUNTIME_CLASS(SGClipartItem)) || Item->IsKindOf(CC_RUNTIME_CLASS(SGFillsItem)))
        {
            Item->GetNameText(&ItemText);

            if(Item->Flags.Selected)
            {
                PathName FileName;      
                SGLibDisplayItem *ClipItem = (SGLibDisplayItem *) Item;
            
                //if (Lib != NULL)
                ok = ClipItem->GetFileName(&FileName);

                if(ok)
                {
                    // Bodge for clipart CD - 'Cow' in LScape should point to "Moo.tif", not just "Moo"
                    if(FileName.GetFileName(FALSE) == (String_256)"Moo")
                    {
                        INT32 Size = ClipItem->GetFileSize(NULL);
                        if(Size == 1080904)
                            FileName.SetType("TIF");
                    }

                    if(!FileName.IsValid(FileName.GetPath()))
                    {
                        ERROR3("LibClipartSGallery::ImportClipart - Filename is invalid");
                        return FALSE;
                    }

                    // Check if file has a long filename, and use that if it does...
                    String_256 FilePath((const TCHAR *)FileName.GetPath());
                    String_256 LongFileName;
                    BOOL LongPath = FileUtil::GetLongFileName((LPTSTR)FilePath, (LPTSTR)LongFileName, 255);
                    if(LongPath)
                    {
                        FilePath = FileName.GetLocation(TRUE);
                        FilePath += LongFileName;
                    }

                    // Check if the file really exists on the local drive
                    Library* pLibrary = ClipItem->GetParentLibrary();
                    if (!pLibrary)
                    {
                        ERROR3("Illegal NULL pointer");
                        return FALSE;
                    }
                    BOOL bIsLocalFile;
                    if (!pLibrary->IsWebLibrary())
                        bIsLocalFile = TRUE;
                    else 
                        bIsLocalFile = (_access((TCHAR*) FilePath, 0) != -1);
                        
                    if(NewDocument)
                    {
                        if (bIsLocalFile)
                        {
                            CWinApp* pApp = AfxGetApp();
                            BaseFileDialog::SelectedFilter = 0;
            
                            // Open a document
                            CCamDoc* pDoc = (CCamDoc*) pApp->OpenDocumentFile((TCHAR *)FilePath);

                            // And redraw the imported document
                            if(pDoc) pDoc->GetKernelDoc()->ForceRedraw();
                        }
                        else // do an asynch import
                        {
                            goto ASYNCH_IMPORT;
                        }
                    }
                    else
                    {
                        // Invoke the clipart import operation so that we get Undo.
                        if (bIsLocalFile) // if the file is local we do a normal import Op
                        {

                            OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpClipartImport));

                            if (pOpDesc != NULL)
                            {
                                ClipartImportParam Param;

                                PathName FullPathName(FilePath);

                                // Set up the parameters which we require to do the import operation
                                Param.File = &FullPathName;
                                Param.Import = !NewDocument;
                                Param.Result = TRUE;

                                // Import the specified file
                                pOpDesc->Invoke((OpParam *) &Param);

                                ok = Param.Result;
                                if(!ok)
                                {
                                    ERROR3("LibClipartSGallery::ImportClipart - Problem importing file");
                                    return FALSE;
                                }
                            }
                        }
                        else // try an asynch import
                        {
ASYNCH_IMPORT:
                            String_256 strFileURL = FilePath;
                            pLibrary->LocalPath2URL(&strFileURL);
                            OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpAsynchClipartImport));

                            if (pOpDesc != NULL)
                            {
                                AsynchClipartImportParam* Param = new AsynchClipartImportParam;
                                ERROR2IF(!Param, FALSE, "Memory allocation error");
                                // Set up the parameters which we require to import the clipart
                                Param->File.SetPathName((TCHAR *)FilePath);
                                String_256 strDescription;
                                ClipItem->GetNameText(&strDescription);
                                Param->