dlgmgr.cpp

Go to the documentation of this file.

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

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

This file is part of Xara LX.

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


MARKS
-----

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


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

=================================XARAHEADEREND============================
 */

// Implementation of the DialogManager class (bodge central)

// Include files
#include "camtypes.h"

#include "dlgmgr.h"
//#include "dialogop.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "simon.h"
//#include "fixst256.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fixstr8.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "list.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "ensure.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "infobar.h"
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "msg.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "bars.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "dlgbar.h"
//#include "cheklist.h"
//#include "custmsg.h"
//#include "sgallery.h"
//#include "galbar.h"
//#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "ccdc.h"
//#include "bitbutn.h"
//#include "bitc1ded.h"
//#include "fonts.h"
//#include "oilprog.h"  // beep()
//#include "ctrlhelp.h"
#include "camelot.h"
#include "camframe.h"
//#include "palman.h"
#include "stack.h"
#include "dropdown.h"   // Colour/Font dropdown combo box support
#include "griddropdown.h"
#include "unicdman.h"
#include "appprefs.h"
#include "helpuser.h"
//#include "textres.h"  // required so we know what an _R(IDC_FONT_COMBO) is.
//#include "fontdrop.h" // required so we know what a FontDropItem is.
//#include "brdlgres.h"
//#include "dlgcthlp.h"
//#include "customlist.h"
//#include "customedit.h"
#include "dlgevt.h"
#include "cartprov.h"
#include "cartctl.h"
#include "osrndrgn.h"
//#include "dlgtypes.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "statline.h"
#include <wx/imaglist.h>

DECLARE_SOURCE("$Revision: 1770 $");

CC_IMPLEMENT_DYNAMIC(CGadgetImageList, CCObject);

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

// Place all statics here please, ordered by class
// Statics

// DialogManager statics
List DialogManager::DiscardStrList;
List DialogManager::ScrollPageIncList;
List DialogManager::DialogPositionList;

IdToSerializedPaneInfo * DialogManager::s_pPaneInfoHash = NULL;

wxWindow   *DialogManager::pDlgCurrent = NULL;   // Required for IsDialogMessage handling

// The ActiveDialogStack is used to restore previously active dialogs after a Modal dialog
// is closed.
ActiveDlgStateStack DialogManager::ActiveDlgStack;

// When the user clicks with the right mouse button on a dual function button BN_RGT_CLICKED
// is returned as the notification code.
#define BN_RGT_CLICKED 6


class Node;

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

>   DialogManager::DialogManager()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/12/93
    Purpose:    DialogManager constructor. It allocates our special Property atom.

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

DialogManager::DialogManager()
{
    // we must use a unique string so we don't clash with anyone else
}

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

>   BOOL        DialogManager::Create(DialogOp* DlgOp,
                                    HINSTANCE MainInstance, CDlgResID MainDlgID,
                                    HINSTANCE SubInstance,  CDlgResID SubDlgID,
                                    CDlgMode Mode, INT32 OpeningPage, CWindowID ParentWnd)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/8/93

    Inputs:     DlgOp:          The DialogOp we are creating a window for

                The following inputs may soon become defunct

                MainInstance:   Instance handle of the module that contains the dialog
                                defined by MainDlgID.
                MainDlgID:      Resource identifier of the main dialog box
                SubInstance:    Instance handle of the module that contains the dialog
                                defined by SubDlgID.
                SubDlgID:       Resource identifier of the secondary dialog box to merge
                                with the main one (0 if none).
                Mode:           Dialog mode (Modal, Modeless)
                OpeningPage:    Index of the tabbed page which we need to open (0 if none).

    Returns:    TRUE if the Dialog/Bar could be created, else FALSE

    Purpose:    The create method creates a Dialog box and positions it

                If the Dialog is Modal then the dialog is displayed, to initialise the dialog
                you must respond to the DIM_CREATE message.

                If the Dialog is Modeless then the Open method needs to be called to make the
                dialog visible.

                If the dialog has not been created before then it is positioned centrally on
                the screen. Otherwise the dialog's position is restored to the position it
                was at the last time it was deleted.

                If SubDlgID is non-0, then this dialog is merged with the main one during
                the creation of the dialog.  If it is 0, then no merging is done (the
                DialogOp() function should take care of all this), and SubInstance
                is ignored.

                If it is a tabbed dialog that is being created then we can now specify the
                opening tab. Usually, this will be the first one if this box has not been
                opened before or the one selected when it was closed. This parameter allows
                this to be overriden.

                Note that this function sets the DialogOps window ID


                Note: It is important that all dialogs do not have the Visible property set.

    Errors:     An Error will be set if this function fails

    SeeAlso:    DialogOp::Create

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

// First a private class definition
// as this is missing two-stage create we have to use a static variable. Yuck.
class wxDynamicPropertySheetDialog : public wxPropertySheetDialog
{
public:
    wxDynamicPropertySheetDialog() {m_TabType=TABTYPE_TABS;}
    ~wxDynamicPropertySheetDialog() {}
    void SetTabType(TabType t) {m_TabType=t;}
protected:
    TabType m_TabType;
    virtual wxBookCtrlBase* CreateBookCtrl()
    {
        INT32 style = wxCLIP_CHILDREN | wxBC_DEFAULT;
        wxBookCtrlBase* pBook = NULL;

        switch (m_TabType)
        {
#if wxUSE_LISTBOOK
            case TABTYPE_LIST:
                return new wxListbook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, style );
                break;
#endif
#if wxUSE_CHOICEBOOK
            case TABTYPE_CHOICE:
                return new wxChoicebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, style );
                break;
#endif
#if wxUSE_TREEBOOK || wxXTRA_TREEBOOK
            case TABTYPE_TREE:
                {
                    wxTreebook * t = new wxTreebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, style );
                    if (t)
                        t->GetTreeCtrl()->SetIndent(0);
                    return t;
                }
                break;
#else
            // Default to a ListBook if there is no treebook availables
            case TABTYPE_TREE:
                return new wxListbook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, style );
                break;
#endif
#if wxUSE_TOOLBOOK
            case TABTYPE_TOOLBAR:
                return new wxToolbook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, style );
                break;
#endif
            case TABTYPE_TABS:
            default:
                pBook = new wxNotebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, style );
                    
PORTNOTE("dialog", "This should probably be applied to all controls eventually")
                // Fabricate a Xara standard font and associate it with notebook control
                wxFont  fontDefault = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
                fontDefault.SetPointSize( 8 );
                pBook->SetFont( fontDefault );
                
                break;
        }

        return pBook;
    }
};

BOOL DialogManager::Create(DialogOp* DlgOp,
                        /* HINSTANCE MainInstance, */ CDlgResID MainDlgID,
                        /* HINSTANCE SubInstance, */  CDlgResID SubDlgID,
                        CDlgMode Mode, INT32 OpeningPage, CWindowID ParentWnd)
{
    ERROR2IF(!DlgOp, FALSE, _T("Create Passed Null DialogOp"));
    ERROR2IF(DlgOp->pEvtHandler, FALSE, _T("Window has already been created. Having two is greedy"));

    DlgOp->pEvtHandler = new DialogEventHandler(DlgOp);
    ERRORIF(!DlgOp->pEvtHandler || !DlgOp->pEvtHandler->pDialogOp, FALSE, _R(IDE_CANNOT_CREATE_DIALOG));

    BOOL wxAUImanaged = FALSE;
    if ( DlgOp->IsABar() || DlgOp->IsAGallery() )
    {
        BOOL modal = DlgOp->IsModal();
        ERROR2IF(modal, FALSE, "Attempting to create a wxAUImanaged Dialog that is modal");
        // They wanted a bar. Well, the main difference to us is we let wxAUI manage it.
        wxAUImanaged = TRUE;
    }

//  ERROR2IF( DlgOp->IS_KIND_OF(DialogBarOp), FALSE, _T("Bar creation not yet supported"));
//  ERROR2IF( DlgOp->IS_KIND_OF(DialogTabOp), FALSE, _T("Tabbed dialogs not yet supported"));
    ERROR2IF( SubDlgID !=0, FALSE, _T("Merging of dialogs not yet supported"));

    // if no parent dialog window specified use the main frame window
    if ((ParentWnd == NULL) || wxAUImanaged)
        ParentWnd = GetMainFrame();

    const TCHAR*    pDialogName = NULL;
    wxWindow*       pDialogWnd = NULL;

    if( DlgOp->IS_KIND_OF(DialogTabOp) && !(((DialogTabOp*)DlgOp)->LoadFrameFromResources()))
    {
        // ok first try and create the property sheet
        wxDynamicPropertySheetDialog* pPropertySheet;

        // error handling done later
        pPropertySheet = new wxDynamicPropertySheetDialog();
        if (pPropertySheet)
        {
            pPropertySheet->SetTabType(((DialogTabOp*)DlgOp)->GetTabType());
            if (!pPropertySheet->Create((wxWindow *)ParentWnd, wxID_ANY, (TCHAR*) (*((DialogTabOp*)DlgOp)->GetName()) ))
            {
                delete pPropertySheet;
                pPropertySheet=NULL; // error handling done below
            }
            else
            {
                wxStdDialogButtonSizer *sizer = new wxStdDialogButtonSizer();
                wxButton * ok=new wxButton(pPropertySheet, wxID_OK);
                sizer->AddButton(ok); // Add an OK button
                sizer->AddButton(new wxButton(pPropertySheet, wxID_CANCEL)); // Add a Cancel button
                sizer->AddButton(new wxButton(pPropertySheet, wxID_APPLY)); // Add an Apply button
                sizer->AddButton(new wxButton(pPropertySheet, wxID_HELP)); // Add a Help button
                ok->SetDefault();
                ok->SetFocus();
                pPropertySheet->SetAffirmativeId(wxID_OK);
                sizer->Realize();
                pPropertySheet->GetInnerSizer()->Add( sizer, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxLEFT|wxRIGHT, 2);
                pPropertySheet->GetInnerSizer()->AddSpacer(2);
            }
        }
        pDialogWnd=pPropertySheet;
    }
    else
    {
        pDialogName=CamResource::GetObjectNameFail(MainDlgID);
        ERROR1IF(pDialogName == NULL, FALSE, _R(IDE_CANNOT_CREATE_DIALOG));

PORTNOTE("dialog","A more general scheme is needed to allow creation of a panel for non-toolbar type dialog")
        if (wxAUImanaged || _R(IDD_BITMAPPREVIEWDIALOG) == MainDlgID )
            pDialogWnd = wxXmlResource::Get()->LoadPanel((wxWindow *)ParentWnd, pDialogName);
        else
            pDialogWnd = wxXmlResource::Get()->LoadDialog((wxWindow *)ParentWnd, pDialogName);
    }

    ERROR1IF(pDialogWnd == NULL, FALSE, _R(IDE_CANNOT_CREATE_DIALOG));

    pDialogWnd->Hide();
    CamArtProvider::Get()->EnsureChildBitmapsLoaded(pDialogWnd);

    // On the Mac, panels etc. are by default transparent; fix them up
#ifdef __WXMAC__
    pDialogWnd->SetBackgroundStyle(wxBG_STYLE_COLOUR);
    pDialogWnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
#endif

    // Note that we might one day want to create (say) wxPanels, or wxToolbars instead above
    // It deosn't matter to us, we just want a wxWindow

    DlgOp->pEvtHandler->pwxWindow = pDialogWnd;
    DlgOp->pEvtHandler->wxAUImanaged = wxAUImanaged;
    DlgOp->pEvtHandler->ID =MainDlgID;
    // Set the DialogOp's WindowID
    DlgOp->WindowID = (CWindowID)pDialogWnd;
    pDialogWnd->PushEventHandler(DlgOp->pEvtHandler);

    if (DlgOp->IS_KIND_OF(DialogTabOp))
    {
        // on balance we might be best ignoring errors here - we are really now past
        // the point of no return, and the dialog can be closed cleanly by the user
        // but let's try anyway
        if (!CreateTabbedDialog( (DialogTabOp*)DlgOp, Mode, OpeningPage, MainDlgID ))
        {
            // try using our own tolerant delete mechanism
            Delete(pDialogWnd, DlgOp);
            ERROR1(FALSE, _R(IDE_CANNOT_CREATE_DIALOG));
        }
    }

    CreateRecursor(pDialogWnd);

    // Register all the child controls
    ControlList::Get()->RegisterWindowAndChildren(pDialogWnd, DlgOp);

    ControlList::Get()->ReflectAllStates(); // might as well do the processing before the bar / dialog appears

    // we call this directly now
    BOOL ok = PostCreate(DlgOp, OpeningPage);

    if( ok && 
        Mode == MODAL && 
        pDialogWnd->IsKindOf( CLASSINFO(wxDialog) ) )
    {
        ((wxDialog *) pDialogWnd)->ShowModal();
    }

#ifdef USE_WXAUI
    if (wxAUImanaged)
    {
        wxString Title = wxEmptyString;
        if (pDialogWnd->IsKindOf(CLASSINFO(wxDialog)))
            Title=((wxDialog *)pDialogWnd)->GetTitle();
        if (Title.IsEmpty()) Title = pDialogWnd->GetLabel(); // because wxPanel doesn't seem to support a title
        if (Title.IsEmpty())
        {
            const TCHAR * ResString=CamResource::GetTextFail(pDialogWnd->GetId());
            if (ResString)
                Title=wxString(ResString);
        }
        if (Title.IsEmpty())
        {
            // Finally, in desperation, we (mis-)use the tooltip string because now the wx folks have removed
            // the label, even though it's needed for accessibility. Aarrghh
            wxToolTip* pTip = pDialogWnd->GetToolTip();
            if (pTip) Title=pTip->GetTip();
        }
        if (Title.IsEmpty())
            Title = wxString(CamResource::GetText(_R(IDS_ANONYMOUSBARTITLE)));


        // We really should take a wxPaneInfo() as an additional parameter to this function to allow this sort
        // of stuff to be specified. Or try and retrieve it from the DialogBarOp or similar. Anyway, for now
        // give it some default parameters
        wxAuiPaneInfo paneinfo;
        if (!DlgOp->IsABar())
        {
            // default galleries to 300 deep. Specifying -1 as a width doesn't seem to work
            paneinfo.FloatingSize(100,300);
        }
        LoadPaneInfo(wxString(CamResource::GetObjectName(pDialogWnd->GetId())), paneinfo);
        paneinfo.DestroyOnClose(FALSE);
        if (DlgOp->IsABar())
        {           
            if (DlgOp->IsKindOf(CC_RUNTIME_CLASS(StatusLine)))
                paneinfo.Bottom().Layer(1).Row(2).LeftDockable(FALSE).RightDockable(FALSE).Floatable(FALSE).Movable(FALSE).Gripper(FALSE).CaptionVisible(FALSE).PaneBorder(FALSE);
            else    
            {
                paneinfo.ToolbarPane().Fixed();
                if (DlgOp->IsVertical())
                {
                    paneinfo.Left().Layer(0).GripperTop().TopDockable(FALSE).BottomDockable(FALSE);
                }
                else
                {
                    paneinfo.Top().Layer(1).Row(2).LeftDockable(FALSE).RightDockable(FALSE);
                }
            }
        }
        else
        {
            // Gallery
            paneinfo.Layer(3).GripperTop().TopDockable(FALSE).BottomDockable(FALSE).Float().Dockable(FALSE); // temporarilly stop galleries from docking
        }

        if (DlgOp->IsKindOf(CC_RUNTIME_CLASS(InformationBarOp)))
        {
            paneinfo.Floatable(FALSE);  // temporarilly do not allow Info Bars to float as they can be closed
                                        // which means they can't be reopened (no UI), and wxAUI rightly objects to the
                                        // tool switch that deletes them deleting the window.
        }

        paneinfo.Name(pDialogName).Caption(Title).PinButton(TRUE);

        wxSizer * pSizer = pDialogWnd->GetSizer();
        if (pSizer)
        {
            pSizer->SetSizeHints(pDialogWnd);
            pDialogWnd->SetSizerAndFit(pSizer);
        }

        // Ensure the main frame is shown if the pane is floating, or it can get "behind"
        // the main frame on wxGTK
        if (paneinfo.IsFloating() && !CCamFrame::GetFrameManager()->GetManagedWindow()->IsShown())
            CCamFrame::GetFrameManager()->GetManagedWindow()->Show();

        CCamFrame::GetFrameManager()->AddPane(pDialogWnd, paneinfo);

        CCamFrame::GetMainFrame()->UpdateFrameManager();

        // Make sure newly created floating panes are at the top in an attempt to fix
        // Bugzilla bug 1393 (can't duplicate here...)
        wxWindow * pTLW = pDialogWnd;
        while (pTLW->GetParent())
            pTLW=pTLW->GetParent();
        if (pTLW->IsKindOf(CLASSINFO(wxAuiFloatingFrame)))
            pTLW->Raise();

    }
#endif

    return ok;
}

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

>   static void DialogManager::CreateRecursor(wxWindow * pwxWindow)


    Author:     Alex_Bligh <alex@alex.org.uk>
    Created:    02/12/2005
    Inputs:     pWindow - pointer to window to process
    Outputs:    None
    Returns:    None
    Purpose:    Initialize platform dependent resources
    Errors:     -
    SeeAlso:    -

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

void DialogManager::CreateRecursor(wxWindow * pwxWindow)
{
    // Process this one
    wxPlatformDependent::Get()->InitWindow(pwxWindow);

    // bodge OD combo boxes not to have scroll bars so often
    if (pwxWindow->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
    {
        ((wxOwnerDrawnComboBox*)pwxWindow)->SetPopupMaxHeight(600);
        ((wxOwnerDrawnComboBox*)pwxWindow)->SetPopupAnchor(wxLEFT);
    }

    // Now process children if any
    wxWindowList::Node * pNode = pwxWindow->GetChildren().GetFirst();
    while (pNode)
    {
        CreateRecursor(pNode->GetData());
        pNode = pNode->GetNext();
    }
    return;
}


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

>   BOOL DialogManager::PostCreate(DialogOp * pDialogOp);

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    6/9/94
    Inputs:     DialogWnd: The dialogs window ID, NULL if dialog failed to be created
    Returns:    -
    Purpose:    This function will get called after a dialog has been created. If a modeless
                dialog has been created then it gets called directly from the Create method.
                For a modal dialog however it gets called after receiving a WM_INIT_DIALOG
                message. It completes the creation process.

                (for now on wxWindows we are simply calling it from Create)

    Scope:      private

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

BOOL DialogManager::PostCreate(DialogOp * pDialogOp, INT32 OpeningPage)
{
    ERROR2IF( !pDialogOp || !pDialogOp->pEvtHandler || !pDialogOp->pEvtHandler->pwxWindow,
            FALSE, _T("Bad DialogOp / EvtHandler in DialogManager::PostCreate()"));

    wxWindow * pDialogWnd = pDialogOp->pEvtHandler->pwxWindow;

    // If the dialog has been created before then its position will have to be reset
    INT32 DlgX=0; // Dialog box X position
    INT32 DlgY=0; // Dialog box Y position
    CDlgResID ActivePage=0; // Active page for tabbed dialogs
    UINT32 ActivePageIndex=0;

    BOOL CreatedBefore = FALSE; // TRUE if the dialog has been created before

    wxBookCtrlBase * pBook=NULL;
    // Only do special processing for DialogTabOp
    if (pDialogOp->IS_KIND_OF(DialogTabOp))
        pBook=GetBookControl(pDialogWnd);

    ResourceID BookGadget=pBook?pBook->GetId():0;

    if (pBook && (OpeningPage>=0))
    {
        ActivePage = pBook->GetPage(OpeningPage)->GetId();
        ActivePageIndex = OpeningPage;
    }

    // Search the DialogPositionList to see if the dialog has been created before
    DialogPosition* DlgPos = FindDialogPositionRecord(pDialogOp->pEvtHandler->ID);
    if (DlgPos != NULL)
    {
        DlgX = DlgPos->LastX;
        DlgY = DlgPos->LastY;

        // Find the last active page if there was one
        if (OpeningPage<0)
        {
            ActivePage = DlgPos->ActivePage;
            ActivePageIndex = DlgPos->ActivePageIndex;
        }
        CreatedBefore = TRUE;
    }

    if (pBook && ((ActivePageIndex<0) ||
                    (ActivePageIndex >= pBook->GetPageCount()) ||
                    ((UINT32)(pBook->GetPage(ActivePageIndex)->GetId()) != ActivePage)
                ))
    {
        ActivePageIndex=0;
        ActivePage = pBook->GetPage(0)->GetId();
    }

    // Get the size of the dialog box (Required for the SetWindowPos function)
    wxRect  DialogRect( pDialogWnd->GetRect() );
    INT32   DialogWidth  = DialogRect.GetWidth();
    INT32   DialogHeight = DialogRect.GetHeight();

    // Create the WindowIDItem which will be stored in the DialogPosition.
    CWindowIDItem *pWinID = new CWindowIDItem;
    if( NULL == pWinID )
    {
        // We need to destroy the dialog window
        pDialogWnd->PopEventHandler(FALSE);
        pDialogOp->pEvtHandler->Destroy();
        pDialogWnd->Destroy();
        ERROR1(FALSE, _R(IDS_OUT_OF_MEMORY));
    }


    if (!CreatedBefore) // If this is the first time the dialog has been created then position
                        // it centrally on the screen
    {
        // Get the size of the screen
        INT32           ScreenWidth  = wxSystemSettings::GetMetric( wxSYS_SCREEN_X );
        INT32           ScreenHeight = wxSystemSettings::GetMetric( wxSYS_SCREEN_Y );

        // Centre the dialog box
        DlgX = (ScreenWidth - DialogWidth) / 2;
        DlgY = (ScreenHeight - DialogHeight) / 2;

        // Create a DialogPosition record
        DlgPos = new DialogPosition;
        if (DlgPos == NULL)
        {
            // We need to destroy the dialog window
            pDialogWnd->PopEventHandler(FALSE);
            pDialogOp->pEvtHandler->Destroy();
            pDialogWnd->Destroy();
            return FALSE; // Failed to created DialogPosition record
        }
        DlgPos->DlgResourceID = pDialogOp->pEvtHandler->ID;

        // Even though the position is recorded when the dialog is deleted. It is neccessary
        // to record it here also because another dialog with the same resource ID could be
        // created before this dialog is deleted.
        DlgPos->LastX = DlgX;
        DlgPos->LastY = DlgY;

        DlgPos->ActivePage = 0;
        DlgPos->ActivePageIndex=0;

        if (pBook)
        {
            // Record the active page.
            DlgPos->ActivePage = ActivePage;
            DlgPos->ActivePageIndex = ActivePageIndex;
        }
        // Add the position record to the DialogPositionList
        DialogPositionList.AddHead((ListItem*)DlgPos);
    }

    // Store the Dialog window handle in the position record.
    pWinID->DlgWin = pDialogWnd;
    DlgPos->DlgWinList.AddTail( pWinID );

        // Position the dialog
    pDialogWnd->SetSize(DlgX, DlgY, DialogWidth, DialogHeight);

        // In japan we need to set the font so it dosen't use the default ANSI MS San Serif
PORTNOTE("dialog","Removed FontFactory usage")
#ifndef EXCLUDE_FROM_XARALX
    if( UnicodeManager::IsDBCSOS() )
        FontFactory::ApplyFontToWindow( DialogWnd, STOCKFONT_DIALOG ); */
#endif

    // Inform the Dialog that it has been created so that it can be initialised
    // Note that for DialogTabOp's seperate Create messages are sent for each page
    // from the wxNotebookPage OnCreate handler.
    // Alex moved this inside the if statement
    BROADCAST_TO_CLASS( DialogMsg( pDialogOp->WindowID, DIM_CREATE, 0 ), DialogOp );

    if (pBook)
    {
        // BROADCAST a create message to each page
        UINT32 i;
        for (i=0; i<pBook->GetPageCount(); i++)
        {
            BROADCAST_TO_CLASS(DialogMsg(pDialogOp->WindowID, DIM_CREATE, BookGadget, 0, pBook->GetPage(i)->GetId()) ,DialogOp);
        }

        // And tell the active page which is active
        BROADCAST_TO_CLASS( DialogMsg( pDialogOp->WindowID, DIM_SET_ACTIVE, BookGadget, 0, ActivePage ), DialogOp );
        pBook->SetSelection(ActivePageIndex);
    }

    // If the dialog which has just been created is modal then disable all other
    // dialogs.

    if( !GetMainFrame()->IsEnabled() )
    {
        EnableAllDialogs(FALSE, pDialogWnd);
    }

    return TRUE; // Success
}

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

>   void DialogManager::InitPaneInfoHash

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    25/07/06
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Initializes the pane info hash if it has not been previously initialized
    Scope:      protected

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

void DialogManager::InitPaneInfoHash()
{
    if (s_pPaneInfoHash)
        return;

    s_pPaneInfoHash = new IdToSerializedPaneInfo;
}

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

>   void DialogManager::FreePaneInfoHash

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    25/07/06
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Free the pane info hash if it exists
    Scope:      protected

This function MUST be called ONLY after the preference system has been de-inited. This
may be after dialogmanager deinit.

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

void DialogManager::FreePaneInfoHash()
{
    if (s_pPaneInfoHash)
    {
        delete s_pPaneInfoHash;
        s_pPaneInfoHash = NULL;
    }
}

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

>   void DialogManager::EnsurePanePreferenceDeclared(key)

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    25/07/06
    Inputs:     key - the key the pane info will be stored under
    Outputs:    None
    Returns:    None
    Purpose:    Ensures the relevant preference has been declared
    Scope:      protected

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

void DialogManager::EnsurePanePreferenceDeclared(wxString key)
{
    if (!s_pPaneInfoHash)
        InitPaneInfoHash();

    if (!s_pPaneInfoHash)
        return;

    IdToSerializedPaneInfo::iterator i=s_pPaneInfoHash->find(key);
    if (i==s_pPaneInfoHash->end())
    {
        // ok, it's not in the hash, so it can't have been declared as a preference
        // yet. So we will declare it as a preference now
        (*s_pPaneInfoHash)[key]=_T("");
        i=s_pPaneInfoHash->find(key);
        if (i==s_pPaneInfoHash->end())
        {
            ERROR3("This hash leaks like a seive");
            return;
        }
        // --------------------------------------------------------------------------
        // Detect first-time run and make Open File dialog default to Examples folder
        if (Camelot.DeclareSection(_T("BarPositions"), 10))
        {
            Camelot.DeclarePref( NULL, (TCHAR *)(key.c_str()), &(i->second) );
        }
    }
}



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

>   void DialogManager::LoadPaneInfo(wxString key, wxPaneInfo &paneinfo)

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    25/07/06
    Inputs:     key - the key the pane info will be stored under
    Outputs:    paneinfo - the wxAUI pane info structure
    Returns:    None
    Purpose:    Loads the pane info structure from the hash
    Scope:      protected

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

void DialogManager::LoadPaneInfo(wxString key, wxAuiPaneInfo &paneinfo)
{
    if (!s_pPaneInfoHash)
        InitPaneInfoHash();

    if (!s_pPaneInfoHash)
        return;

    EnsurePanePreferenceDeclared(key);

    IdToSerializedPaneInfo::iterator i=s_pPaneInfoHash->find(key);
    if (i==s_pPaneInfoHash->end())
        return;

    // do not bother trying to process empty strings
    if (i->second.IsEmpty())
        return;

    TRACEUSER("amb", _T("key=%s"), (const TCHAR *)key);
    TRACEUSER("amb", _T("val=%s"), (const TCHAR *)(i->second));

    wxString name = (wxString)((const TCHAR *)(i->second));
    CCamFrame::GetFrameManager()->LoadPaneInfo(name, paneinfo);
}

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

>   void DialogManager::SavePaneInfo(wxPaneInfo &paneinfo)

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    25/07/06
    Inputs:     key - the key the pane info will be stored under
                paneinfo - the wxAUI pane info structure
    Returns:    None
    Purpose:    Saves the pane info structure to the hash
    Scope:      protected

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

void DialogManager::SavePaneInfo(wxString key, wxAuiPaneInfo &paneinfo)
{
    // work around mysterious wxGTK sizing bug
    if ((paneinfo.IsOk()) && (paneinfo.IsFloating()))
    {
        paneinfo.FloatingSize(paneinfo.window->GetParent()->GetSize());
    }

    if (!s_pPaneInfoHash)
        InitPaneInfoHash();

    if (!s_pPaneInfoHash)
        return;

    EnsurePanePreferenceDeclared(key);

    (*s_pPaneInfoHash)[key]=CCamFrame::GetFrameManager()->SavePaneInfo(paneinfo);
}

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

>   static DialogPosition* DialogManager::FindDialogPositionRecord(CDlgResID DialogID)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    5/12/94
    Inputs:     DialogID: The dialog's resource id
    Returns:    The DialogPosition record for the dialog, or NULL if the dialog has not been
                created before
    Purpose:    Searches the DialogPositionList to see if this dialog has been created before
                if it has then a pointer to its DialogPosition record is returned,
                else NULL is retuned.
    Scope:      private

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

DialogPosition* DialogManager::FindDialogPositionRecord(CDlgResID DialogID)
{
    // Search the DialogPositionList to see if the dialog has been created before
    DialogPosition* DlgPos = (DialogPosition*)(DialogPositionList.GetHead());
    while (DlgPos != NULL)
    {
        if (DlgPos->DlgResourceID == DialogID) // The dialog has been created before
        {
            return DlgPos;
            break;
        }
        // Get the next DialogPosition record
        DlgPos = (DialogPosition*)(DialogPositionList.GetNext((ListItem*)DlgPos));
    }
    return NULL; // Dialog has not been created before
}



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

>   void DialogManager::Open(CWindowID WindowID, DialogOp* pDlgOp)
    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/8/93
    Inputs:     WindowID: Dialog's window identifier
                pDlgOp:   The DialogOp
    Purpose:    The Open method displays a modeless dialog box.
                If the dialog is modal then it will have already been opened in the Create
                method.
    SeeAlso:    DialogOp::Open

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

void DialogManager::Open(CWindowID WindowID, DialogOp* pDlgOp)
{
    // Determine if we are opening a bar
PORTNOTE("dialog","Removed DialogBarOp usage")
#ifndef EXCLUDE_FROM_XARALX
    if (pDlgOp->IsKindOf(CC_RUNTIME_CLASS(DialogBarOp)))
    {
        // Find the BaseBar object
        BaseBar         *pCWnd = (wxWindow *)WindowID;
        ENSURE( pCWnd != NULL, "Could not find bar object" );
        // Show the bar window
        if( pCWnd != NULL )
        {
            pCWnd->Show( (DialogBarOp *)pDlgOp );
        }
    }
    else
#endif
    if( !pDlgOp->IsModal() ) // The create method opens a modal dialog
    {
        ( (wxWindow *)WindowID )->Show( true ); // Show the hidden dialog
    }

    if (pDlgOp->pEvtHandler->wxAUImanaged)
        CCamFrame::GetMainFrame()->UpdateFrameManager();

}


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

>   void DialogManager::Close(CWindowID WindowID, DialogOp* pDlgOp)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/8/93
    Inputs:     WindowID: Dialog's window identifier
                pDlgOp:   The DialogOp
    Purpose:    The close method removes a modeless dialog from the display but keeps all system
                resources associated with it. It hides the dialog.
                It can be called on a modal dialog but it does nothing.
    SeeAlso:    DialogOp::Close

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

void DialogManager::Close(CWindowID WindowID, DialogOp* pDlgOp)
{
    // Hide the dialog

    // Determine if we are hiding a bar
PORTNOTE("dialog","Removed DialogBarOp usage")
#ifndef EXCLUDE_FROM_XARALX
    if (pDlgOp->IsKindOf(CC_RUNTIME_CLASS(DialogBarOp)))
    {
        // Find the BaseBar object
        wxWindow* pCWnd = CWnd::FromHandlePermanent(WindowID);
        ENSURE(pCWnd != NULL, "Could not find bar object");
        // Show the bar window
        if (pCWnd != NULL)
        {
            ((BaseBar*)pCWnd)->Hide((DialogBarOp*)pDlgOp);
        }
    }
    else
#endif
    if (!(pDlgOp->IsModal())) // The delete method closes a modal dialog
    {
        ENSURE(WindowID != NULL,"NULL WindowID");
        ( (wxWindow *)WindowID )->Show( false );
    }

    if (pDlgOp->pEvtHandler->wxAUImanaged)
        CCamFrame::GetMainFrame()->UpdateFrameManager();
}


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

>   static BOOL MergeDialogs( CWindowID Dialog, CWindowID Mergee, bool fAbove )

    Author:     Luke_Hart (Xara Group Ltd) <lukeh@xara.com>
    Created:    21/07/2006
    Inputs:     -
    Returns:    FALSE if the function failed.
    Purpose:    This function places the contents of a dialog above or below the
                contents of an existing dialog

********************************************************************************************/
BOOL DialogManager::MergeDialogs( CWindowID Dialog, CWindowID Mergee, bool fAbove )
{
    wxSizer*            pMainSizer = Dialog->GetSizer();
    wxSizer*            pVertSizer( new wxBoxSizer( wxVERTICAL ) );
    if( fAbove )
        pVertSizer->Add( Mergee, wxALL );
    pVertSizer->Add( pMainSizer );
    if( !fAbove )
        pVertSizer->Add( Mergee, wxALL );

    Dialog->SetSizerAndFit( pVertSizer, false );
    return TRUE;
}


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

>   static BOOL DialogManager::BringToTop(CWindowID WindowID)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/6/95
    Inputs:     -
    Returns:    FALSE if the function failed.
    Purpose:    This function brings an open dialog to the top of the z-order

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

BOOL DialogManager::BringToTop(CWindowID WindowID, DialogOp* pDlgOp)
{
    ERROR2IF(!WindowID, FALSE, "BringToTop called on a dialog without a window");
    ( (wxWindow *)WindowID )->Raise();
    if (pDlgOp->pEvtHandler->wxAUImanaged)
        CCamFrame::GetMainFrame()->UpdateFrameManager();
    return TRUE;
}



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

>   static void DialogManager::Event (DialogEventHandler *pEvtHandler, wxEvent &event)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/9/93
    Purpose:    OnCommand message handler. Translates a windows Command message into a DIM
    Errors:     -
    SeeAlso:    -

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

void DialogManager::Event (DialogEventHandler *pEvtHandler, wxEvent &event)
{
    WXTYPE EventType = event.GetEventType();
//  CDlgMessage DIM = DIM_NONE;
    ResourceID id = event.GetId();
    UINT_PTR DlgMsgParam = 0;
    INT32 PageID = 0;
    BOOL HandleMessage=FALSE;
    BOOL Defer=TRUE;

    if (!pEvtHandler->pwxWindow || !pEvtHandler->pDialogOp)
    {
        // We are in the process of destruction
        event.Skip();
        return;
    }

    // First handle events we previously asked to defer processing of
    if (event.IsKindOf(CLASSINFO(wxCamDialogEvent)) && (EventType == wxEVT_CAMDIALOG_DEFERREDMSG))
    {
        // We posted this event and asked it to come back later, and it duly has
        wxCamDialogEvent * pDialogEvent = (wxCamDialogEvent *)(&event);
        pDialogEvent->msg.DlgWndID = pEvtHandler->pwxWindow; // this ensures we are using a valid window pointer
        // Send it around
        BROADCAST_TO_CLASS( DialogMsg(pDialogEvent->msg), DialogOp );
        return;
    }

    wxWindow * pGadget = NULL;
    if (id) pGadget = GetGadget(pEvtHandler->pwxWindow, id);

    // We tend to get this second-hand from our child, we handle this differently
    if( !pGadget && (event.GetEventObject() != pEvtHandler->pwxWindow))
    {
        pGadget = (wxWindow *)event.GetEventObject();
        id = pGadget->GetId();
    }

    // Try and find-out whether our control is part of a tabbed dialog page
    if( NULL != pGadget )
    {
        // pEvtHandler->pwxWindow maybe our immediate wxPanel\wxDialog, but won't
        // be in case of tabbed dialog
        wxWindow*   pDialog = pGadget->GetParent();
        while( NULL != pDialog && !pDialog->IsKindOf( CLASSINFO(wxDialog) ) && 
            !pDialog->IsKindOf( CLASSINFO(wxPanel) ) )
        {
            pDialog = pDialog->GetParent();
        }

        // Could this be part of a tabbed dialog?
        if( NULL != pDialog && pDialog->IsKindOf( CLASSINFO(wxPanel) ) )
        {
            // A parent of type wxBookCtrlBase would synch it
            wxWindow *pDialogParent = pDialog->GetParent();
            if( NULL != pDialogParent && pDialogParent->IsKindOf( CLASSINFO(wxBookCtrlBase) ) )
                PageID = pDialog->GetId();
        }
    }

    // Make up a default message
    DialogMsg msg(pEvtHandler->pwxWindow, DIM_NONE, id, DlgMsgParam, PageID);

    if (!event.IsKindOf(CLASSINFO(wxMouseEvent))) // MouseEvents are too noisy
    {
        TRACEUSER("amb",_T("event %d(%s) received, ID=%d(%s), wxw=%llx"), EventType, DialogEventHandler::GetEventName(EventType), id,
                    CamResource::GetObjectName((ResourceID)id), pEvtHandler->pwxWindow);
    }

    if (
        (EventType == wxEVT_LEFT_DCLICK) ||
        (EventType == wxEVT_MIDDLE_DCLICK) ||
        (EventType == wxEVT_RIGHT_DCLICK) ||
        FALSE)
    {
        // OK, these are a bit deadly. We expected there to be TWO mouse up mouse downs. People
        // don't seem to hang off double clicks themselves, but do their own double click handling
        // (why oh why). So we generate an extra mouse down and mouse up, and sending them to
        // ourselves. This may not be necessary on all platforms.
        wxMouseEvent *MouseDown = (wxMouseEvent *)(event.Clone());
        wxMouseEvent *MouseUp = (wxMouseEvent *)(event.Clone());
        if (MouseDown && MouseUp)
        {
            if (EventType == wxEVT_LEFT_DCLICK)
            {
                MouseDown->SetEventType(wxEVT_LEFT_DOWN);
                MouseUp->SetEventType(wxEVT_LEFT_UP);
            }
            else if (EventType == wxEVT_MIDDLE_DCLICK)
            {
                MouseDown->SetEventType(wxEVT_MIDDLE_DOWN);
                MouseUp->SetEventType(wxEVT_MIDDLE_UP);
            }
            else
            {
                MouseDown->SetEventType(wxEVT_RIGHT_DOWN);
                MouseUp->SetEventType(wxEVT_RIGHT_UP);
            }
            
            //MouseDown.SetEventObject(pEvtHandler->pwxWindow);
            // MouseUp.SetEventObject(pEvtHandler->pwxWindow);
            // set it for processing later
            pEvtHandler->pwxWindow->GetEventHandler()->ProcessEvent(*MouseDown);
            pEvtHandler->pwxWindow->GetEventHandler()->ProcessEvent(*MouseUp);
        }
        if (MouseDown) delete MouseDown;
        if (MouseUp) delete MouseUp;
    }   

    /* Here is a list of possible command events
    wxEVT_COMMAND_BUTTON_CLICKED
    wxEVT_COMMAND_CHECKBOX_CLICKED
    wxEVT_COMMAND_CHOICE_SELECTED
    wxEVT_COMMAND_LISTBOX_SELECTED
    wxEVT_COMMAND_LISTBOX_DOUBLECLICKED
    wxEVT_COMMAND_CHECKLISTBOX_TOGGLED
    wxEVT_COMMAND_TEXT_UPDATED  // only with WXWIN_COMPATIBILITY_EVENT_TYPES
    wxEVT_COMMAND_TEXT_ENTER    // only with WXWIN_COMPATIBILITY_EVENT_TYPES
    wxEVT_COMMAND_TEXT_URL      // only with WXWIN_COMPATIBILITY_EVENT_TYPES
    wxEVT_COMMAND_TEXT_MAXLEN   // only with WXWIN_COMPATIBILITY_EVENT_TYPES
    wxEVT_COMMAND_MENU_SELECTED
    wxEVT_COMMAND_SLIDER_UPDATED
    wxEVT_COMMAND_RADIOBOX_SELECTED
    wxEVT_COMMAND_RADIOBUTTON_SELECTED
    wxEVT_COMMAND_SCROLLBAR_UPDATED // Obselete - see wxWVT_SCROLL
    wxEVT_COMMAND_VLBOX_SELECTED
    wxEVT_COMMAND_COMBOBOX_SELECTED
    wxEVT_COMMAND_TOOL_RCLICKED
    wxEVT_COMMAND_TOOL_ENTER
    wxEVT_COMMAND_SPINCTRL_UPDATED

    We can't use switch on these - GRRR!
    */

    if (
        (EventType == wxEVT_COMMAND_BUTTON_CLICKED) ||
        FALSE)
    {
        // We should cope with Right Button here
        if ((ResourceID)id == _R(wxID_OK) )
        {
            msg.DlgMsg = DIM_COMMIT;
            HandleMessage = TRUE;
        }
        else if (id == _R(ID_CC_APPLY_NOW))
        {
            // Clicking on the apply now button is the same as a soft commit
            msg.DlgMsg = DIM_SOFT_COMMIT;
            HandleMessage = TRUE;
        }
        else if (id == _R(wxID_CANCEL))
        {
            msg.DlgMsg = DIM_CANCEL;
            // Do not defer processing of clicks on the close button because the default handler may destroy the window on
            // exit from this call
            Defer=FALSE; 
            HandleMessage = TRUE;
        }
        else if (id == _R(wxID_HELP))
        {
            // Our clients expect this ID, so keep them happy
            msg.DlgMsg = DIM_LFT_BN_CLICKED;
            msg.GadgetID = _R(ID_HELP);
            HandleMessage = TRUE;
        }
        else
        {
            msg.DlgMsg = DIM_LFT_BN_CLICKED;
            HandleMessage = TRUE;
        }
    }
    else if (
        (EventType == wxEVT_COMMAND_CHOICE_SELECTED) ||
        (EventType == wxEVT_COMMAND_LISTBOX_SELECTED) ||
        (EventType == wxEVT_COMMAND_CHECKLISTBOX_TOGGLED) ||
//      We skip this because it's generated when we change the text ourselves. We should probably do something more subtle
//      (EventType == wxEVT_COMMAND_TEXT_UPDATED) ||    // only with WXWIN_COMPATIBILITY_EVENT_TYPES
        (EventType == wxEVT_COMMAND_TEXT_URL) ||        // only with WXWIN_COMPATIBILITY_EVENT_TYPES
//      (EventType == wxEVT_COMMAND_TEXT_MAXLEN) ||     // only with WXWIN_COMPATIBILITY_EVENT_TYPES
        (EventType == wxEVT_COMMAND_MENU_SELECTED) ||
//      (EventType == wxEVT_COMMAND_SLIDER_UPDATED) ||
        (EventType == wxEVT_COMMAND_RADIOBOX_SELECTED) ||
        (EventType == wxEVT_COMMAND_VLBOX_SELECTED) ||
        (EventType == wxEVT_COMMAND_COMBOBOX_SELECTED) ||
        (EventType == wxEVT_COMMAND_SPINCTRL_UPDATED) ||
        ((
        (EventType == wxEVT_SCROLL_CHANGED) || 
        (EventType == wxEVT_SCROLL_THUMBTRACK) || 
        (EventType == wxEVT_SCROLL_THUMBRELEASE) ||
        (EventType == wxEVT_SCROLL_LINEUP) ||
        (EventType == wxEVT_SCROLL_LINEDOWN) ||
        (EventType == wxEVT_SCROLL_PAGEUP) ||
        (EventType == wxEVT_SCROLL_PAGEDOWN)
        ) &&
        !(
          (pGadget && pGadget->IsKindOf(CLASSINFO(wxSlider))) ||
          (pGadget && pGadget->IsKindOf(CLASSINFO(wxSliderCombo)))
        )
        ) || // Don't handle slider scroll stuff here
        (EventType == wxEVT_COMMAND_TREE_SEL_CHANGED) ||
        FALSE)
    {
        msg.DlgMsg = DIM_SELECTION_CHANGED;
        msg.DlgMsgParam = NO_COMMIT;
        HandleMessage = TRUE;
    }
    else if( EventType == wxEVT_COMMAND_TEXT_UPDATED &&     // only with WXWIN_COMPATIBILITY_EVENT_TYPES
        pGadget == wxWindow::FindFocus() )
    {
        msg.DlgMsg = DIM_TEXT_CHANGED;
        HandleMessage = TRUE;
    }
    else if(
        (EventType == wxEVT_COMMAND_TEXT_ENTER) ||
        FALSE)
    {
        msg.DlgMsg = DIM_SELECTION_CHANGED;
        msg.DlgMsgParam = ENTER_COMMIT;
        HandleMessage = TRUE;
    }
    else if(
        (( (EventType == wxEVT_SCROLL_THUMBTRACK) ||
        (EventType == wxEVT_SCROLL_LINEUP) ||
        (EventType == wxEVT_SCROLL_LINEDOWN) ||
        (EventType == wxEVT_SCROLL_PAGEUP) ||
        (EventType == wxEVT_SCROLL_PAGEDOWN)
        ) && (pGadget && ( pGadget->IsKindOf(CLASSINFO(wxSlider)) || pGadget->IsKindOf(CLASSINFO(wxSliderCombo)) ))) || 
        FALSE) // Handle slider movements - note SCROLL_CHANGED always comes later
    {
        msg.DlgMsg = DIM_SLIDER_POS_CHANGING;
        HandleMessage = TRUE;
    }
    else if(
        // Do not handle THUMB_RELEASE because we get a SCROLL_CHANGED anyway, and having two means we generate two SETs which will generate 2 undo records
        // on (for instance) transparency and Bevel tools
        ((/*EventType == wxEVT_SCROLL_THUMBRELEASE ||*/ EventType == wxEVT_SCROLL_CHANGED) &&
         ( (pGadget && pGadget->IsKindOf(CLASSINFO(wxSlider))) || (pGadget && pGadget->IsKindOf(CLASSINFO(wxSliderCombo))) )
        ) || // Handle slider changes
        FALSE)
    {
        msg.DlgMsg = DIM_SLIDER_POS_SET;
        HandleMessage = TRUE;
    }
    else if(
        (EventType == wxEVT_COMMAND_CHECKBOX_CLICKED) ||
        (EventType == wxEVT_COMMAND_RADIOBUTTON_SELECTED) ||
        FALSE)
    {
        msg.DlgMsg = DIM_LFT_BN_CLICKED; // apparently not a DIM_SELECTION_CHANGED - the click itself is eaten by the radio control - please do not change - AMB
        HandleMessage = TRUE;
    }
    else if (
        (EventType == wxEVT_COMMAND_LISTBOX_DOUBLECLICKED) ||
        FALSE)
    {
        msg.DlgMsg = DIM_SELECTION_CHANGED_COMMIT;
        HandleMessage = TRUE;
    }
    else if (
        (EventType == wxEVT_LEFT_DOWN) ||
        FALSE)
    {
        msg.DlgMsg = DIM_LFT_BN_DOWN;
        HandleMessage = TRUE;
    }   
    else if (
        (EventType == wxEVT_LEFT_UP) ||
        FALSE)
    {
        msg.DlgMsg = DIM_LFT_BN_UP;
        HandleMessage = TRUE;
    }   
    else if (
        (EventType == wxEVT_RIGHT_DOWN) ||
        FALSE)
    {
        msg.DlgMsg = DIM_RGT_BN_DOWN;
        HandleMessage = TRUE;
    }   
    else if (
        (EventType == wxEVT_RIGHT_UP) ||
        FALSE)
    {
        msg.DlgMsg = DIM_RGT_BN_UP;
        HandleMessage = TRUE;
    }   
    else if (
        (EventType == wxEVT_MIDDLE_DOWN) ||
        FALSE)
    {
        msg.DlgMsg = DIM_MID_BN_DOWN;
        HandleMessage = TRUE;
    }   
    else if (
        (EventType == wxEVT_MIDDLE_UP) ||
        FALSE)
    {
        msg.DlgMsg = DIM_MID_BN_UP;
        HandleMessage = TRUE;
    }   
    else if (
        (EventType == wxEVT_MOTION) ||
        FALSE)
    {
        msg.DlgMsg = ((wxMouseEvent *)&event)->Dragging()?DIM_MOUSE_DRAG:DIM_MOUSE_MOVE;
        HandleMessage = TRUE;
    }   
    else if (
        (EventType == wxEVT_MOUSEWHEEL) ||
        FALSE)
    {
        msg.DlgMsg = (((wxMouseEvent *)&event)->GetWheelRotation()>0)?DIM_MOUSEWHEEL_UP:DIM_MOUSEWHEEL_DOWN;
        HandleMessage = TRUE;
    }   
    else if (
        (EventType == wxEVT_MOVE) ||
        FALSE)
    {
        msg.DlgMsg = DIM_DLG_MOVED;
        HandleMessage = TRUE;
    }   
    else if (
        (EventType == wxEVT_SIZE) ||
        FALSE)
    {
        if (event.GetEventObject() != pEvtHandler->pwxWindow)
        {
            Defer = FALSE;
            msg.DlgMsg = DIM_CTRL_RESIZED;
            HandleMessage = TRUE;   
        }
        else
        {
            msg.DlgMsg = DIM_DLG_RESIZED;
            HandleMessage = TRUE;
        }
    }
    else if (
        (EventType == wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED) &&
        pGadget && pGadget->IsKindOf(CLASSINFO(wxBookCtrlBase)))
    {
        msg.DlgMsg = DIM_SET_ACTIVE;
        wxWindow *pPage = ((wxBookCtrlBase*)pGadget)->GetCurrentPage();
        msg.PageID = pPage?(pPage->GetId()):0;
        HandleMessage = TRUE;
    }
    else if (
        ((EventType == wxEVT_CAMDIALOG_REDRAW) && (pGadget)) ||
        FALSE)
    {
        if (CCamApp::IsDisabled())
        {
            TRACE( _T("kernel-rendered gadget repaint has been aborted: the system is disabled (due to an error/ensure?)\n"));
            HandleMessage = FALSE;
        }
        else
        {
            // HDC hDC = pInfo->PaintInfo.hdc;
            // HPALETTE OldPalette = PaletteManager::StartPaintPalette(hDC);
        
            ReDrawInfoType ExtraInfo;
        
            ExtraInfo.pMousePos = NULL;     // No mouse position info for redraw events


            // Build a CC dc out of it for rendering to the screen
            // Get a MFC CDC to put the DC in
            CCPaintDC MyDc(pGadget);

            ExtraInfo.pDC = &MyDc;
        
            // The devices DPI
            ExtraInfo.Dpi = OSRenderRegion::GetFixedDCPPI(MyDc).GetHeight();

            // How big the window is
            wxSize WindowSize = pGadget->GetClientSize();
            ExtraInfo.dx = (((INT32)WindowSize.GetWidth())*72000) / ExtraInfo.Dpi;
            ExtraInfo.dy = (((INT32)WindowSize.GetHeight())*72000) / ExtraInfo.Dpi;
        
            MyDc.GetDC()->BeginDrawing();

            wxRegionIterator upd(pGadget->GetUpdateRegion()); // get the update rect list

            BOOL Stop = FALSE;

            while (upd && !Stop)
            {
                // Alternatively we can do this:
                wxRect ClipRect(upd.GetRect());
                // Should we clip this to the WindowSize here? For reasons which are not entirely clear, setting the
                // ClipRect breaks GRenderRegions. But if we don't set the clip rect, it breaks (at least some)
                // code that uses OSRenderRegion (sigh). Right now this is too painful to debug, so instead we
                // cop out, and ask the control whether or not it would like a ClipRect set. Those that say no
                // will paint the entire area, so we only give them one call

                BOOL UseClipRect = (pGadget->IsKindOf(CLASSINFO(wxCamDrawControl)))
                                    && (((wxCamDrawControl*)pGadget)->GetStyle() & wxCDCS_SETCLIPRECT);

                if (UseClipRect)
                {
                    MyDc.GetDC()->SetClippingRegion(ClipRect);
                    ClipRect.Inflate(1,1); // work around wxRect problems.
                }
                else
                {
                    ClipRect = wxRect(WindowSize);
                    Stop = TRUE; // cease drawing after this one
                }
                
                DocRect DocClipRect;
            
                // Convert to millipoints, Also need to flip the y coords to get a
                // rectangle in with the origin in the bottom left.
                DocClipRect.lo.x = (ClipRect.GetLeft() * 72000) / ExtraInfo.Dpi;
                DocClipRect.lo.y = ExtraInfo.dy - ((ClipRect.GetBottom() * 72000) / ExtraInfo.Dpi);
            
                DocClipRect.hi.x = (ClipRect.GetRight() * 72000) / ExtraInfo.Dpi;
                DocClipRect.hi.y = ExtraInfo.dy - ((ClipRect.GetTop() * 72000) / ExtraInfo.Dpi);
            
                // Set the pointer in the extra info structure
                ExtraInfo.pClipRect = &DocClipRect;
            
                // Build the message and send it to the dialog op
                // It is up to the dialog op to build a render region etc and attach the CCDC to it
                // and to tidy the region up after it has finished drawing in it CDlgMessage
                BROADCAST_TO_CLASS(DialogMsg(pEvtHandler->pwxWindow, DIM_REDRAW, id, (UINT_PTR)(void *)&ExtraInfo, PageID), DialogOp);
                
                upd ++ ;
            }
        
            MyDc.GetDC()->EndDrawing();     
        
            // if (OldPalette)
            //  PaletteManager::StopPaintPalette(hDC, OldPalette);
        }
    }

    //case  wxEVT_COMMAND_TOOL_RCLICKED:
    //case  wxEVT_COMMAND_TOOL_ENTER:


    // Handle filling in ExtraInfo on redraw events
    if ((msg.DlgMsg != DIM_NONE) && pGadget && pGadget->IsKindOf(CLASSINFO(wxCamDrawControl)) && event.IsKindOf(CLASSINFO(wxMouseEvent)))
    {
        switch (msg.DlgMsg)
        {
            case DIM_LFT_BN_DOWN:
            case DIM_LFT_BN_UP:
            case DIM_LFT_BN_CLICKED:
            case DIM_RGT_BN_DOWN:
            case DIM_RGT_BN_UP:
            case DIM_RGT_BN_CLICKED:
            case DIM_MID_BN_DOWN:
            case DIM_MID_BN_UP:
            case DIM_MID_BN_CLICKED:
            case DIM_MOUSE_DRAG:
            case DIM_MOUSE_MOVE:
            case DIM_MOUSEWHEEL_UP:
            case DIM_MOUSEWHEEL_DOWN:
            {

                // HDC hDC = pInfo->PaintInfo.hdc;
                // HPALETTE OldPalette = PaletteManager::StartPaintPalette(hDC);
            
                ReDrawInfoType ExtraInfo;
            
                ExtraInfo.pMousePos = NULL;     // No mouse position info for redraw events
        
        
                // Build a CC dc out of it for rendering to the screen
                // Get a MFC CDC to put the DC in
                CCPaintDC MyDc(pGadget);
        
                ExtraInfo.pDC = NULL;
            
                // The devices DPI
                ExtraInfo.Dpi = OSRenderRegion::GetFixedDCPPI(MyDc).GetHeight();
        
                // How big the window is
                wxSize WindowSize = pGadget->GetClientSize();
                ExtraInfo.dx = (((INT32)WindowSize.GetWidth())*72000) / ExtraInfo.Dpi;
                ExtraInfo.dy = (((INT32)WindowSize.GetHeight())*72000) / ExtraInfo.Dpi;

                // Work out the MILLIPOINT coordinates of the mouse position
                // Note that the Y value is flipped, as the kernel-origin is at the bottom left
                INT32 XPos = ((wxMouseEvent *)(&event))->GetX();
                INT32 YPos = ((wxMouseEvent *)(&event))->GetY();
    
                DocCoord MousePos;
                MousePos.x = (XPos * 72000) / ExtraInfo.Dpi;
                MousePos.y = ExtraInfo.dy - ((YPos * 72000) / ExtraInfo.Dpi);
                ExtraInfo.pMousePos = &MousePos;

                BROADCAST_TO_CLASS(DialogMsg(pEvtHandler->pwxWindow, msg.DlgMsg, id, (UINT_PTR)(void *)&ExtraInfo, PageID), DialogOp);

                msg.DlgMsg = DIM_NONE; // Stop further processing
            }

            default:
                break;
        }
    }


    // If we have a message to send, then send it (or defer it for later)
    if (msg.DlgMsg != DIM_NONE)
    {
        // Restore focus after selection change etc. if the dialog Op is non-modal
        if (!(pEvtHandler->pDialogOp->IsModal()) && (( DIM_SELECTION_CHANGED == msg.DlgMsg ) || ( DIM_SLIDER_POS_SET == msg.DlgMsg )))
        {
            TRACEUSER( "luke", _T("Change focus") );
            AfxGetApp().GiveActiveCanvasFocus();
        }

        if (Defer)
        {
            // We should send the message out later - we use the same ID
            wxCamDialogEvent deferredevent (wxEVT_CAMDIALOG_DEFERREDMSG, event.GetId(), msg);
            deferredevent.SetEventObject(pEvtHandler->pwxWindow);
            // set it for processing later
            pEvtHandler->pwxWindow->GetEventHandler()->AddPendingEvent(deferredevent);
        }
        else
        {
            BROADCAST_TO_CLASS( DialogMsg(msg), DialogOp );
        }
    }
    
    // If we haven't marked this message as handled, call Skip() so that others can handle
    // it
    if (!HandleMessage) event.Skip(); // we didn't handle it
    return;
}



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

>   wxBookCtrlBase * DialogManager::GetBookControl(CWindowID WindowID, CGadgetID Gadget =0)

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    11/05/2006
    Inputs:     WindowID - Dialog box window identifier
                Gadget - Identifier of the gadget OR zero
    Returns     pointer to the book control or NULL
    Purpose:    This function will return a pointer to the book control in a window.
                If the window is of type wxPropertySheetDialog then it Gadget is not
                required

Note that the intelligence to use the default gadget won't be there until the window
has been created properly and the event handler added. So if this is being called
from a window creation function (like AddAPage) it is worth specifying the gadget
explicitly.

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

wxBookCtrlBase * DialogManager::GetBookControl(CWindowID WindowID, CGadgetID Gadget /* =0 */)
{
    // No window ID? Well no book control then
    if (!WindowID) return NULL;

    // If it's a property sheet dialog then we know a quick way...
    if (WindowID->IsKindOf(CLASSINFO(wxPropertySheetDialog)))
        return ((wxPropertySheetDialog*)WindowID)->GetBookCtrl();

    // Let's see if there is a default gadget to use in the DialogOp
    if (!Gadget)
    {
        if ((WindowID->GetEventHandler())->IsKindOf(CLASSINFO(DialogEventHandler)))
        {
            DialogOp * pDialogOp = ((DialogEventHandler *)(WindowID->GetEventHandler()))->pDialogOp;
            // If it's a DialogTabOp, ask it for its default book gadget. If there isn't
            // one, that's OK too
            if ((pDialogOp) && (pDialogOp->IS_KIND_OF(DialogTabOp)))
                Gadget=((DialogTabOp*)pDialogOp)->GetDefaultBookGadget();
        }
    }

    // If we were passed a gadget ID, we can go use it
    if (Gadget)
    {
        wxWindow * pGadget = GetGadget(WindowID, Gadget);
        if (pGadget->IsKindOf(CLASSINFO(wxBookCtrlBase)))
            return (wxBookCtrlBase*)pGadget;
        else
            return NULL;
    }

    // See if any of the children are wxBookCtrlBase
    wxWindowList::Node * pNode = WindowID->GetChildren().GetFirst();
    while (pNode)
    {
        wxWindow * child = pNode->GetData();
        if (child->IsKindOf(CLASSINFO(wxBookCtrlBase)))
            return (wxBookCtrlBase*)child;
        pNode = pNode->GetNext();
    }

    // OK, they aren't. Recurse through them
    pNode = WindowID->GetChildren().GetFirst();
    while (pNode)
    {
        wxBookCtrlBase * pBook=GetBookControl(WindowID, 0);
        if (pBook)
            return pBook;
        pNode = pNode->GetNext();
    }

    return NULL;
}




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

>   static BOOL DialogManager::IsGadgetTickable(CWindowID WindowID,
                                                CGadgetID Gadget)


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/6/95
    Inputs:     WindowID: Dialog's window identifier
                Gadget:   The Gadget to test

    Purpose:    Determines if the gadget is of a type that can be ticked

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

BOOL DialogManager::IsGadgetTickable(CWindowID WindowID,
                                    CGadgetID Gadget)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    // Not sure why this is an exhaustive list
    return ( pGadget->IsKindOf(CLASSINFO(wxCheckBox)) ||
            pGadget->IsKindOf(CLASSINFO(wxButton)) ||
            (pGadget->IsKindOf(CLASSINFO(wxCamArtControl)) && (((wxCamArtControl*)pGadget)->GetStyle() & wxCACS_PUSHBUTTON)) ||
            pGadget->IsKindOf(CLASSINFO(wxBitmapButton))
            );
}


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

>   static BOOL DialogManager::ColourPickerAbort(CWindowID WindowID, CGadgetID Gadget)

    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/1/2000
    Inputs:     WindowID:   Dialog's window identifier
                Gadget:     The colourpicker that this request is made upon (which is checked
                            to ensure that it is a custom colour picker).

    Purpose:    Instructs camelots custom colour control (which I also wrote) to 'shutdown'
                and (indirectly) return control to the colour editor dialog.

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

BOOL DialogManager::ColourPickerAbort(CWindowID WindowID, CGadgetID Gadget, WPARAM wParam)
{
    PORTNOTETRACE("dialog","DialogManager::ColourPickerAbort - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    // Currently the gadget is only tickable if it is a button
    HWND hGadget = GetDlgItem((HWND)WindowID, (INT32)Gadget);
    String_256 ClassNameStr;  // The control type

    // Find out the class type of the gadget
    GetClassName(hGadget, (TCHAR*)ClassNameStr, 255);

    if (ClassNameStr == String_8(TEXT("cc_colPicker")))
    {
        BOOL RetVal = FALSE;

        RetVal = SendMessage(hGadget, WM_COLOURPICKERABORT, wParam, 0);

        return (RetVal);
    }

    return (TRUE);
    ENSURE(FALSE, "Calling ColourPickerAbort for an invalid control");
#endif
    return FALSE;
}


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

>   DialogManager::Delete(CWindowID WindowID, DialogOp* pDlgOp)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/8/93
    Inputs:     WindowID: Dialog's window identifier
                pDlgOp:   The DialogOp
    Purpose:    The delete method will delete all system resources and other information
                which is kept about the dialog. It also records the dialogs current position
                so that it can be restored the next time the dialog is created.
    SeeAlso:    DialogOp::Delete

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

void DialogManager::Delete(CWindowID WindowID, DialogOp* pDlgOp)
{
    ERROR2IF (!pDlgOp, (void)0, "No dialog op to DialogManager::Delete()");
    ERROR2IF (!WindowID, (void)0, "No window to DialogManager::Delete()");

    if (!pDlgOp->pEvtHandler)
    {
        ERROR3("DialogManager::Delete() No dialog op event handler - has this window been deleted twice?");
        return;
    }

    // If we've already been destroyed (by something else) - a situation which should never happen - then
    // return without doing anything
    if (pDlgOp->pEvtHandler && pDlgOp->pEvtHandler->m_GrimReaperSent)
    {
        TRACEALL(_T("DialogManager::Delete() Window has been deleted by something else, then Delete() called"));
        return;
    }

    if (((wxWindow *)WindowID)->IsBeingDeleted())
    {
        ERROR3("Trying to delete a window that is already being deleted, has an event handler, but has not sent grim reaper");
        return;
    }

    wxBookCtrlBase * pBook=NULL;
    // Only do special processing for DialogTabOp
    if (pDlgOp->IS_KIND_OF(DialogTabOp))
        pBook=GetBookControl(WindowID);
//  ResourceID BookGadget=pBook?pBook->GetId():0;

    // See if the dialogs has a position record  (If it's a DialogBarOp it won't have one)
    DialogPosition* DlgPos = (DialogPosition*)DialogPositionList.GetHead();
    CWindowIDItem* WinID;
    while(DlgPos != NULL)
    {
        // Search the DlgWinList for the DlgPos for WindowID
        WinID = (CWindowIDItem*)DlgPos->DlgWinList.GetHead();
        while (WinID != NULL)
        {
            if ((WinID->DlgWin) == WindowID) // Found the dialogs position record
            {
                // The Dialogs window is about to be destroyed so delete the WinID from the
                // DlgWinList of DlgPos.
                delete(DlgPos->DlgWinList.RemoveItem((ListItem*)WinID));
                goto FoundPos; // What a rebel
            }
            WinID = (CWindowIDItem*)DlgPos->DlgWinList.GetNext((ListItem*)WinID);
        }
        // Get the next position record
        DlgPos = ((DialogPosition*)DialogPositionList.GetNext((ListItem*)DlgPos));
    }
    // No DialogPosition record was found so must be a DialogBarOp


    FoundPos:

    wxWindow           *pCWnd = (wxWindow *)WindowID;


    if (DlgPos != NULL)
    {
        // Record the dialog's position so that it can be restored if the dialog is created again
        wxRect          DialogRect( pCWnd->GetRect() );
        DlgPos->LastX = DialogRect.x;
        DlgPos->LastY = DialogRect.y;
        DlgPos->ActivePage = 0;
        DlgPos->ActivePageIndex = 0;

        // If the dialog is tabbed then we need to record the active page as well
        // We can't find the runtime class of the DialogOp at this point because Delete can be called
        // from its destructor
        if (pBook)
        {
            wxNotebookPage* pPage = pBook->GetCurrentPage();
            if (pPage)
            {
                DlgPos->ActivePage = pPage->GetId();
                // Store the pages index as well
                GetPageWindow(WindowID, DlgPos->ActivePage, &(DlgPos->ActivePageIndex));
            }
            else
                ERROR3("There is no active page");
        }
    }

    if (pDlgOp->pEvtHandler->wxAUImanaged)
    {
        wxAuiPaneInfo paneinfo = CCamFrame::GetMainFrame()->GetFrameManager()->GetPane(pCWnd);
        if (paneinfo.IsOk())
            SavePaneInfo(wxString(CamResource::GetObjectName(pCWnd->GetId())), paneinfo);
        // Remove the bar from wxAUI
        CCamFrame::GetMainFrame()->GetFrameManager()->DetachPane(pCWnd);
        CCamFrame::GetMainFrame()->UpdateFrameManager();
    }

    // Delete all discardable strings associated with the dialog
    DlgDiscardString* DiscardStr = (DlgDiscardString*)(DiscardStrList.GetHead());
    while (DiscardStr != NULL) // While there are still strings to delete
    {
        DlgDiscardString* Next = (DlgDiscardString*)(DiscardStrList.GetNext(DiscardStr));
        if (DiscardStr->DlgWindow == WindowID)  // The string belongs to the dialog being
                                                // deleted
        {
            delete (DiscardStr->pStr); // Delete the string
            delete(DiscardStrList.RemoveItem(DiscardStr)); // Delete the DiscardStr record
        }
        DiscardStr = Next;  // Get next string record
    }

    // Delete all scrollPageInc information associated with the dialog
    ScrollPageInc* PgInc = (ScrollPageInc*)(ScrollPageIncList.GetHead());
    while (PgInc != NULL)
    {
        ScrollPageInc* Next = (ScrollPageInc*)(ScrollPageIncList.GetNext((ListItem*)PgInc));
        if( PgInc->pDlgWindow == WindowID ) // The ScrollPageInc record belongs to the dialog
                                            // being deleted.
            delete (ScrollPageIncList.RemoveItem( (ListItem*)PgInc) );  // Delete the
                                                                        // ScrollPageInc record
        PgInc = Next; // Get next record
    }

    // Delete all ControlInfo records
    List* ControlInfoList = GetControlList( (wxWindow *)WindowID );

    // Kill of Dropdowns
    DropDown::KillDropDownsByWindow(WindowID);
    CGridDropDown::KillDropDownsByWindow(WindowID);

    // Remove new-form control list
    ControlList::Get()->RemoveWindowAndChildren((wxWindow *)WindowID);

    // We are about to destroy the window. Disconnecting our event handler sounds like a good
    // idea at this point, as Destroy() does not destroy the window immediately, so there
    // is a possibility of receiving further events
    ((wxWindow *)WindowID)->PopEventHandler(FALSE); // leave the DialogOp's destructor to delete it
    pDlgOp->pEvtHandler->Destroy();


    if (pDlgOp->IsModal() && WindowID->IsKindOf(CLASSINFO(wxDialog)))
    // A normal Modal
    {
        ( (wxDialog *)WindowID )->EndModal( TRUE );
        ( (wxWindow *)WindowID )->Destroy();
    }
    else
    {
        ( (wxWindow *)WindowID )->Destroy();
    }

    if (ControlInfoList)
    {
        // Its one of our special windows with an attached list

        while (!ControlInfoList->IsEmpty())
            delete(ControlInfoList->RemoveHead());
        // Delete the ControlInfo list
        delete (ControlInfoList);
        ControlInfoList = NULL;
    }

    // Restore the active/disabled window state
    if (pDlgOp->IsModal())
    {
        // DialogManager::RestoreActiveDialogState();
    }

    DefaultKeyboardFocus();
    // All spick and span
}



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

>   BOOL DialogManager::SetComboListLength( CWindowID WindowID,
                                            CGadgetID Gadget)

    Author:     Chris_Parks (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/7/94
    Inputs:     WindowID:    Dialog box window identifier
                Gadget:      Identifier of the gadget
    Returns:    -
    Purpose:

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build.

    SeeAlso:    DialogOp::SetComboListLength

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

void DialogManager::SetComboListLength(CWindowID WindowID,CGadgetID Gadget)
{
    // This function existed to resize the combo box, but under wx combo boxes resize
    // automagically when their contents are adjusted.
    return;
}

// -----------------------------------------------------------------------------------------
// The following functions are called by same named functions in the DialogOp
// class. The DialogOp functions are provided for ease of use and do not have a
// CWindowID argument.




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

>   void DialogManager::SetGadgetBitmaps(CWindowID WindowID, CGadgetID Gadget,
                                        UINT32 Bitmap1, UINT32 Bitmap2)

    Author:     Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
    Created:    26/10/94
    Inputs:     WindowID - Dialog box window identifier
                Gadget - Identifier of the gadget
                Bitmap1 - The resourse ID of the first bitmap
                Bitmap2 - The resourse ID of the second bitmap
    Purpose:    This function will set the bitmaps associated with a gadget.

                This will only work for cc_Slider and cc_BitmapButton controls

                cc_Slider:
                In this case Bitmap1 is used as the Base of the slider and Bitmap2 is used
                as the little slideing bar.  (Drop the 'e' before 'ing' Rik)

                cc_BitmapButton:
                Bitmap1 & Bitmap2 are ignored. Instead, the bitmaps are specified by the window
                title text, in the same way as bitmap buttons in bars. (added by Markn 27/3/95)

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

void DialogManager::SetGadgetBitmaps(CWindowID WindowID, CGadgetID Gadget, UINT32 Bitmap1, UINT32 Bitmap2)
{
    PORTNOTETRACE("dialog","DialogManager::SetGadgetBitmaps - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    // Find out about the Gadget
    HWND hGadget = GetDlgItem((HWND)WindowID, (INT32)Gadget);

    // Find out the class type of the gadget
    String_256 ClassNameStr;
    GetClassName(hGadget, (TCHAR*)ClassNameStr, 255);

    // Only do something if it is a slider
    if ((ClassNameStr == String_16(TEXT("cc_Slider"))))
    {
        // Fill in the details of the bitmaps
        SliderBitmapInfo BitmapInfo;
        BitmapInfo.hAppInstance = AfxGetResourceHandle(); //AfxGetApp()->m_hInstance;
        BitmapInfo.BaseBmpStr = MAKEINTRESOURCE(Bitmap1);
        BitmapInfo.SliderBmpStr = MAKEINTRESOURCE(Bitmap2);

        // Send a message to the slider, telling to use the bitmaps
        SendMessage(hGadget, WM_SET_CHANNEL_WIDTH, 8, 0);
        SendMessage(hGadget, WM_SET_SLIDERBITMAPS, 0, (INT32)&BitmapInfo);

    }

    // Send new style messages to the button classes because they can use PNG
    // resources
    if (ClassNameStr == String_16(TEXT("cc_BitmapButton"))
        || ClassNameStr == String_16(TEXT("cc_SmallBitmapButton")) )
    {
        SetGadgetBitmaps(hGadget, AfxGetResourceHandle());
    }
#endif
}

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

>   void DialogManager::SetGadgetBitmap(CWindowID WindowID, CGadgetID Gadget,
                                        ResourceID Bitmap)

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    07/05/2006
    Inputs:     WindowID - Dialog box window identifier
                Gadget - Identifier of the gadget
                Bitmap - The resourse ID of the bitmap, or 0 for default;
    Purpose:    This function will set the bitmaps associated with a gadget.

                This works only for bitmap buttons

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

void DialogManager::SetGadgetBitmap(CWindowID WindowID, CGadgetID Gadget, ResourceID Bitmap)
{
    wxWindow* pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return;

    if ( pGadget->IsKindOf(CLASSINFO(wxCamArtControl))
        )
    {
        ((wxCamArtControl *)pGadget)->SetBitmapId(Bitmap);
        pGadget->Refresh();
    }
}

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

>   ResourceID DialogManager::SetGadgetBitmap(CWindowID WindowID, CGadgetID Gadget)

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    07/05/2006
    Inputs:     WindowID - Dialog box window identifier
                Gadget - Identifier of the gadget
    Returns:    The resourse ID of the bitmap
    Purpose:    This function will get the bitmaps associated with a gadget.

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

ResourceID DialogManager::GetGadgetBitmap(CWindowID WindowID, CGadgetID Gadget)
{
    wxWindow* pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return 0;

    if ( pGadget->IsKindOf(CLASSINFO(wxCamArtControl))
        )
    {
        return ((wxCamArtControl *)pGadget)->GetBitmapId();
    }
    return 0;
}

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

>   void DialogManager::SetGadgetBitmaps(CWindowID WindowID, CGadgetID Gadget,
                                        const CGadgetImageList& imagelist)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID - Dialog box window identifier
                Gadget - Identifier of the gadget
                imagelist - the list of images
    Purpose:    This function will set the bitmaps associated with a gadget.

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

void DialogManager::SetGadgetBitmaps(CWindowID WindowID, CGadgetID Gadget, const CGadgetImageList& imagelist)
{
    wxWindow* pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return;

    if ( pGadget->IsKindOf(CLASSINFO(wxTreeCtrl))
        )
    {
        wxImageList* plist = new wxImageList(imagelist.GetWidth(), imagelist.GetHeight());

        CamArtProvider* pCAP = CamArtProvider::Get();
        ERROR3IF(pCAP==NULL, "Can't find CamArtProvider!");

        ListItem* pItem = NULL;
        ResourceID resID=0;
        pItem = imagelist.FindFirstBitmap(&resID);
        while (pItem)
        {
            wxBitmap* pBitmap = pCAP->FindBitmap(resID);
            plist->Add((const wxBitmap&) *pBitmap);

            pItem = imagelist.FindNextBitmap(pItem, &resID);
        }
        
        ((wxTreeCtrl*)pGadget)->AssignImageList(plist);     // Tree control takes ownership of the list

        return;
    }

    ERROR3("SetTreeGadgetItem called on non-tree gadget");
    return;
}


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

>   void DialogManager::SetBitmapButtonIndexes(CWindowID WindowID, CGadgetID Gadget,
                                        UINT32 SelectedIndex, UINT32 UnselectedIndex)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/9/99
    Inputs:     WindowID - Dialog box window identifier
                Gadget - Identifier of the gadget
                SelectedIndex - The index number into the bitmap strip for the glyph
                                representing the buttons selected state
                UnselectedIndex - The index number into the bitmap strip for
                                the unselected glyph
    Purpose:    This function allows you to specify bitmaps for both the
                selected and unselected states of a bitmap button. Most likely you have
                already selected your bitmap for the selected state in your
                resource file, however this allows you to specify the unselected state also.



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

void DialogManager::SetBitmapButtonIndexes(CWindowID WindowID, CGadgetID Gadget,
                                    UINT32 UnselectedIndex, UINT32 SelectedIndex)

{
    PORTNOTETRACE("dialog","DialogManager::SetBitmapButtonIndexes - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    // Find out about the Gadget
    HWND hGadget = GetDlgItem((HWND)WindowID, (INT32)Gadget);

    // Find out the class type of the gadget
    String_256 ClassNameStr;
    GetClassName(hGadget, (TCHAR*)ClassNameStr, 255);


    // Send new style messages to the button classes because they can use PNG
    // resources
    if (ClassNameStr == String_16(TEXT("cc_BitmapButton"))
        || ClassNameStr == String_16(TEXT("cc_SmallBitmapButton")) )
    {
        SetGadgetBitmaps(hGadget, AfxGetResourceHandle(), SelectedIndex, UnselectedIndex);
    }
#endif
}

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

>   void DialogManager::SetGadgetBitmaps( HWND hGadget,
                                        HINSTANCE hResInstance,
                                        INT32 SelectedIndex = -1,
                                        INT32 UnselectedIndex = -1 )

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/03/2004
    Inputs:     HWND - window handle of gadget
                HINSTANCE - Resource module handle
                INT32 - index of selected item or -1 to derive from gadget title string
                INT32 - index of unselected itemor -1 to derive from gadget title string
    Outputs:    -
    Returns:    -
    Purpose:    Send custom WM_SETBITMAPEX message to custom controls
    Errors:     -
    SeeAlso:    DialogManager::SetGadgetBitmaps, DialogManager::SetBitmapButtonIndexes

********************************************************************************************/
/*void DialogManager::SetGadgetBitmaps( wxWindow *pGadget,
                                    // HINSTANCE hResInstance, //
                                    INT32 SelectedIndex,
                                    INT32 UnselectedIndex)
{
    PORTNOTETRACE("dialog","DialogManager::SetGadgetBitmaps - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    char AnsiTitle[256];
    GetWindowText(hGadget,AnsiTitle,255);
    BitmapButtonInfoEx BtnInfo;

    // find the position of the specifier's separator
    INT32 SeparatorPos = 0;
    while (AnsiTitle[SeparatorPos] != 0 && AnsiTitle[SeparatorPos] != '.')
        SeparatorPos++;

    INT32 Index = 0;        // Default to using icon index 0 if no '.' separator was found
    if (AnsiTitle[SeparatorPos] == '.')
    {
        // We found a separator. In that case, truncate the resource string at the '.'
        // so we can extract the bitmap name, and convert the text after the '.' into
        // an integer index.
        Index = _ttoi( AnsiTitle + SeparatorPos+1 );
        AnsiTitle[SeparatorPos] = 0;
    }

    if (SelectedIndex=-1) SelectedIndex = Index;
    if (UnselectedIndex=-1) UnselectedIndex = Index;

    // Fill in the BtnInfo structure
    BtnInfo.hAppInstance = hResInstance;

    String_256 Title =("L");
    Title += TEXT(AnsiTitle);

    String_256 Ansi32Title = AnsiTitle;
    Ansi32Title += ("32");

    String_256 Title32 = ("L");
    Title32 += TEXT(Ansi32Title);

    BtnInfo.Bitmap[BBX_BMP_LARGE_UNSELECTED] = (LPTSTR)Title;
    BtnInfo.Bitmap[BBX_BMP_SMALL_UNSELECTED] = (LPTSTR)AnsiTitle;

    BtnInfo.Bitmap[BBX_BMP_SMALL_SELECTED] = NULL;  // NULL, or name of selected bitmap
    BtnInfo.Bitmap[BBX_BMP_LARGE_SELECTED] = NULL;  // NULL, or name of selected bitmap

    BtnInfo.Bitmap[BBX_BMP32_LARGE_UNSELECTED] = (LPTSTR)Title32;
    BtnInfo.Bitmap[BBX_BMP32_SMALL_UNSELECTED] = (LPTSTR)Ansi32Title;

    String_256 HTitle32 = ("H");                    // "H" for highlighted = selected
    HTitle32 += Title32;
    String_256 HATitle32 = ("H");
    HATitle32 += Ansi32Title;

    BtnInfo.Bitmap[BBX_BMP32_LARGE_SELECTED] = (LPTSTR)HTitle32;
    BtnInfo.Bitmap[BBX_BMP32_SMALL_SELECTED] = (LPTSTR)HATitle32;

    BtnInfo.UnselectedIndex = UnselectedIndex;      //  Indices of glyph bitmaps within the
    BtnInfo.SelectedIndex = SelectedIndex;          //  Unselected/Selected bitmaps

    ::SendMessage(hGadget, WM_SETBITMAPEX, 0, ((LPARAM) &BtnInfo));
#endif
}
*/


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

>   BOOL DialogManager::SetUnitGadgetValue( CWindowID WindowID,
                                            CGadgetID Gadget,
                                            UnitType DlgUnitType,
                                            MILLIPOINT Value,
                                            BOOL EndOfList = TRUE,
                                            INT32 ListPos = 0)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/8/93
    Inputs:     WindowID:    Dialog box window identifier
                Gadget:      Identifier of the gadget
                DlgUnitType: The type of the gadget value (cm, mm, pt, etc.)
                Value:       The value to set the gadget to in MILLIPOINTS

                The following inputs only need to be provided if the gadget has multiple
                values, for example a ListBox.

                EndOfList:   TRUE if the value is to be a added to the end of the gadgets
                            value list. (Default = TRUE)
                            FALSE if the value is to be added to the ListPos position in the
                            list.

                ListPos:     If EndOfList = FALSE then this input specifies the position
                            in the list (Default = 0, so if you want to add the value to
                            the top of the list simply specify EndOfList = FALSE)

                            If the gadget is a ComboBox then setting ListPos = -1 will
                            set the combo box's edit gadget field.

    Outputs:    -
    Returns:    TRUE if the gadgets value could be set as specified
                FALSE if it could not.

    Purpose:    This method is used to set a gadget which should hold a number to a certain
                value. The actual type of the gadget does not matter.

                For example:

                If gadget g1 is a string then

                SetGadgetValue(g1win, g1, pt, 100000) will set g1's value to '100pt'

                If g1 is an integer field then the function would set the gadgets value
                to 100.

                For Windows
                -----------

                The function can be used to set the string values of the following controls. The
                string will have a unit suffix.

                Edit
                Static
                Button
                ListBox
                ComboBox

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetUnitGadgetValue

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

BOOL DialogManager::SetUnitGadgetValue( CWindowID WindowID,
                                    CGadgetID Gadget,
                                    UnitType Unit,
                                    MILLIPOINT Value,
                                    BOOL EndOfList,
                                    INT32 ListPos)
{
    // Convert the unit value into a string
    String_256      StrValue;
//  Convert::MillipointsToString(Value, Unit, 3, &StrValue);
    Convert::MillipointsToString( Value, Unit, &StrValue ); // Display using defaults
    return( SetStringGadgetValue( WindowID, Gadget, StrValue, EndOfList, ListPos ) );
}


/********************************************************************************************
>   BOOL DialogManager::SetDimensionUnitGadgetValue(CWindowID WindowID,
                                                    CGadgetID Gadget,
                                                    UnitType  units,
                                                    double    Value,
                                                    Node*     pNode,
                                                    BOOL      IncludeUnitSpecifier = TRUE,
                                                    BOOL      EndOfList = TRUE,
                                                    INT32       ListPos = 0)

    Author:     Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/10/95
    Inputs:     WindowID:    Dialog box window identifier
                Gadget:      Identifier of the gadget
                units:       unit type
                Value:       The value to set the gadget to in MILLIPOINTS
                pNode:       Ptr to the node from whence Value came from
                IncludeUnitSpecifier :  If TRUE the unit specifier is included
                                        e.g. "1.27 cm" or "1.27" for TRUE or FALSE respectively

                The following inputs only need to be provided if the gadget has multiple
                values, for example a ListBox.

                EndOfList:   TRUE if the value is to be a added to the end of the gadgets
                            value list. (Default = TRUE)
                            FALSE if the value is to be added to the ListPos position in the
                            list.

                ListPos:     If EndOfList = FALSE then this input specifies the position
                            in the list (Default = 0, so if you want to add the value to
                            the top of the list simply specify EndOfList = FALSE)

                            If the gadget is a ComboBox then setting ListPos = -1 will
                            set the combo box's edit gadget field.

    Returns:    FALSE if fails

    Purpose:    as SetDimensionGadgetValue() but you can specify the units in which it is displayed
********************************************************************************************/

BOOL DialogManager::SetDimensionUnitGadgetValue(CWindowID WindowID,
                                                CGadgetID Gadget,
                                                UnitType  units,
                                                double    Value,
                                                Node*     pNode,
                                                BOOL      IncludeUnitSpecifier,
                                                BOOL      EndOfList,
                                                INT32       ListPos)
{
    DimScale* pDimScale = DimScale::GetPtrDimScale(pNode);
    ERROR2IF(pDimScale==NULL,FALSE,"DialogManager::SetDimensionUnitGadgetValue() - pDimScale==NULL");

    String_256 Str;
    BOOL ok = pDimScale->ConvertToUnits(Value,&Str,IncludeUnitSpecifier,-1,units);
    if (ok) ok = SetStringGadgetValue(WindowID,Gadget,Str,EndOfList,ListPos);

    return ok;
}


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

>   BOOL DialogManager::SetLongGadgetValue(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        INT32 Value,
                                        BOOL EndOfList = TRUE,
                                        INT32 ListPos = 0)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/9/93
    Inputs:     WindowID: Dialog box window identifier
                Gadget: Identifier of the gadget
                Value:    INT32 value

                The following inputs only need to be provided if the gadget has multiple
                values, for example a ListBox.

                EndOfList:   TRUE if the value is to be a added to the end of the gadgets
                            value list. (Default = TRUE)
                            FALSE if the value is to be added to the ListPos position in the
                            list.
                ListPos:     If EndOfList = FALSE then this input specifies the position
                            in the list (Default = 0, so if you want to add the value to
                            the top of the list simply specify EndOfList = FALSE)

                            If the gadget is a ComboBox then setting ListPos = -1 will
                            set the combo box's edit gadget field.



    Outputs:    -
    Returns:    TRUE if the gadgets value could be set
                FALSE if it could not

    Purpose:    This function is used to set a numeric gadget value. It performs
                different functions depending on the type of the gadget.

                For Windows
                -----------

                If the gadget is a button it sets the button's current state.

                    For check and radio buttons it sets the state to either checked
                    (Value = 1) or unchecked (Value = 0). In the case of a 3 state button
                    the third state can be specified by a (Value = 2).

                    For Push buttons it can be used to set a depressed (Value = 1)/
                    normal state(Value = 0)

                If the gadget is a scrollbar it sets the current position on the thumb

                The function can be used to set the values of the following controls.

                Edit
                Static
                Button
                ListBox
                ComboBox
                ScrollBar
                cc_CheckList
                cc_Slider

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetLongGadgetValue

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

BOOL DialogManager::SetLongGadgetValue(CWindowID WindowID,
                                    CGadgetID Gadget,
                                    INT32 Value,
                                    BOOL EndOfList,
                                    INT32 ListPos)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    if ( pGadget->IsKindOf(CLASSINFO(wxButton)) ||
        pGadget->IsKindOf(CLASSINFO(wxBitmapButton)) )
    {
        // These bitmap buttons are meant to be tristate
        PORTNOTETRACE("dialog","DialogManager::SetLongGadgetValue on BitmapButton - do nothing");
        return FALSE;
    }

    // Oh if only virtual functions work here. Sadly, they don't, as SetValue is not in wxControl
    if ( pGadget->IsKindOf(CLASSINFO(wxCheckBox)) )
    {
        ((wxCheckBox *)(pGadget))->SetValue(Value !=0);
        return TRUE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxRadioButton)) )
    {
        ((wxRadioButton *)(pGadget))->SetValue( Value != 0 );
        return TRUE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxScrollBar)) )
    {
        ((wxScrollBar *)(pGadget))->SetThumbPosition(Value);
        return TRUE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxSlider)) )
    {
        ((wxSlider *)(pGadget))->SetValue(Value);
        return TRUE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxSliderCombo)) )
    {
        ((wxSliderCombo *)(pGadget))->SetSliderValue(Value);
        return TRUE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxGauge)) )
    {
        ((wxGauge *)(pGadget))->SetValue(Value);
        return TRUE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxCamArtControl)) )
    {
        ((wxCamArtControl *)(pGadget))->SetValue(Value);
        return TRUE;
    }


#if 0
    // it seems on an edit box we might be meant to set the garet, but it's difficult to know what's
    // going on here
    else if (ClassNameStr == String_16(TEXT("cc_CustomEdit")))//?
    {
        ...
    }
#endif

    // Hmmm - no luck so far, let's try a string

    String_256 StrValue;
    // Convert Value to a string
    Convert::LongToString(Value, &StrValue);
    return(SetStringGadgetValue(WindowID, Gadget, StrValue, EndOfList, ListPos));
}

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

>   BOOL DialogManager::SetDoubleGadgetValue(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        double Value,
                                        BOOL EndOfList = TRUE,
                                        INT32 ListPos = 0)

    Author:     Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> (liberally copied from Simon's SetLongGadgetValue)
    Created:    16/12/94
    Inputs:     WindowID: Dialog box window identifier
                Gadget: Identifier of the gadget
                Value:    double value

                The following inputs only need to be provided if the gadget has multiple
                values, for example a ListBox.

                EndOfList:   TRUE if the value is to be a added to the end of the gadgets
                            value list. (Default = TRUE)
                            FALSE if the value is to be added to the ListPos position in the
                            list.
                ListPos:     If EndOfList = FALSE then this input specifies the position
                            in the list (Default = 0, so if you want to add the value to
                            the top of the list simply specify EndOfList = FALSE)

                            If the gadget is a ComboBox then setting ListPos = -1 will
                            set the combo box's edit gadget field.



    Outputs:    -
    Returns:    TRUE if the gadgets value could be set
                FALSE if it could not

    Purpose:    This function is used to set a numeric gadget value. It performs
                different functions depending on the type of the gadget.

                For Windows
                -----------

                If the gadget is a button it sets the button's current state.

                    For check and radio buttons it sets the state to either checked
                    (Value = 1) or unchecked (Value = 0). In the case of a 3 state button
                    the third state can be specified by a (Value = 2).

                    For Push buttons it can be used to set a depressed (Value = 1)/
                    normal state(Value = 0)

                If the gadget is a scrollbar it sets the current position on the thumb

                The function can be used to set the values of the following controls.

                Edit
                Static
                Button
                ListBox
                ComboBox
                ScrollBar
                cc_CheckList
                cc_Slider

                Note most of these only take settings to integer precision so you might as
                well use SetLongGadgetValue instead (the exception being text fields of
                course).

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetDoubleGadgetValue, DialogMgr::SetLongGadgetValue

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

BOOL DialogManager::SetDoubleGadgetValue(CWindowID WindowID,
                                    CGadgetID Gadget,
                                    double Value,
                                    BOOL EndOfList,
                                    INT32 ListPos)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    if (( pGadget->IsKindOf(CLASSINFO(wxButton))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxBitmapButton))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxCheckBox))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxRadioButton))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxScrollBar))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxSlider))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxSliderCombo))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxCamArtControl))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxGauge)))
        )
        return SetLongGadgetValue( WindowID, Gadget, (INT32)(floor(Value+0.5)), EndOfList, ListPos);

    String_256 StrValue;
    // Convert Value to a string
    Convert::DoubleToString(Value, &StrValue);
    return(SetStringGadgetValue(WindowID, Gadget, StrValue, EndOfList, ListPos));
}

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

>   BOOL DialogManager::SetStringGadgetValue(CWindowID WindowID,
                                            CGadgetID Gadget,
                                            UINT32 IDStr,
                                            BOOL EndOfList = TRUE,
                                            INT32 ListPos = 0)




    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/8/93
    Inputs:     WindowID: Dialog box window identifier
                Gadget: Gadget identifier
                StrID:    Resource ID of string

                The following inputs only need to be provided if the gadget has multiple
                values, for example a ListBox.

                EndOfList:   TRUE if the value is to be a added to the end of the gadgets
                            value list. (Default = TRUE)
                            FALSE if the value is to be added to the ListPos position in the
                            list.

                ListPos:     If EndOfList = FALSE then this input specifies the position
                            in the list (Default = 0, so if you want to add the value to
                            the top of the list simply specify EndOfList = FALSE)

                            If the gadget is a ComboBox then setting ListPos = -1 will
                            set the combo box's edit gadget field.


    Outputs:    -

    Returns:    TRUE if the gadgets value could be set
                FALSE if it could not

    Purpose:    This function is used to set a gadgets value to a resource string. It can only
                be used on gadgets with a string value type.

                For Windows
                -----------

                This function can be used to set the string values of the following controls:

                Button
                Static
                Edit
                ListBox
                ComboBox


    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetStringGadgetValue

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

BOOL DialogManager::SetStringGadgetValue(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        UINT32 IDStr,
                                        BOOL EndOfList,
                                        INT32 ListPos)
{
    String_256* StrVal = new String_256(IDStr); // Obtain the string resource
    ERROR1IF(StrVal == NULL, FALSE, _R(IDS_OUT_OF_MEMORY));

    // It is neccessary to store the new strings on the DiscardStrList so that
    // when the dialog is deleted the strings are also deleted.
    DlgDiscardString   *DiscardStr = new DlgDiscardString;
    if( DiscardStr == NULL )
    {
        delete StrVal;
        ERROR1(FALSE, _R(IDS_OUT_OF_MEMORY));
    }

    // If we are setting a string in a gadget on a page within a
    // property sheet then we need to store the windowID of the property sheet
    // This way it will get deleted when the property sheet is deleted in the
    // Delete method

    wxWindow           *pCWnd = (wxWindow *)WindowID;
    wxWindow           *WndID = pCWnd;
/*  if (pCWnd != NULL)
    {
        if (pCWnd->IsKindOf(RUNTIME_CLASS(wxNotebookPage)))
        {
            wxWindow* Parent = pCWnd->GetParent();
            ERROR2IF(Parent == NULL, FALSE, "Property page found without parent property sheet");
            ERROR2IF(!(Parent->IsKindOf(RUNTIME_CLASS(wxPropertySheetDialog))), FALSE,"Property page parent not a property sheet");
            WndID = Parent->GetSafeHwnd();
        }
    } */

    DiscardStr->DlgWindow = WndID;
    DiscardStr->pStr = StrVal;
    DiscardStrList.AddHead( DiscardStr );

    return (SetStringGadgetValue(WindowID, Gadget, *StrVal, EndOfList, ListPos));
}

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

>   static wxWindow * DialogManager::GetGadget(CWindowID WindowID, CGadgetID Gadget)

    Author:     Alex Bligh (alex@alex.org.uk)
    Created:    20/12/2005
    Inputs:     WindowID: Dialog box window identifier
                Gadget: Gadget identifier
                StrID:    Resource ID of string

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

wxWindow * DialogManager::GetGadget(CWindowID WindowID, CGadgetID Gadget)
{
    ERROR2IF(!WindowID || !WindowID->IsKindOf(CLASSINFO(wxWindow)), FALSE, "Bad Window ID passed");
    wxWindow * pGadget=WindowID->FindWindow(Gadget);
//  TRACEUSER("amb",_T("pwxDialog=0x%016llx Gadget=%d(%s) pGadget=0x%016llx"), WindowID, Gadget, CamResource::GetObjectName((ResourceID)Gadget), pGadget);
    if (!pGadget)
    {
        // Some dialogs seem to consciously do this, EG galleries
//      ERROR3_PF((_T("Bad Gadget ID %d(%s) passed"), Gadget, CamResource::GetObjectName((ResourceID)Gadget)));
        return NULL;
    }
#if 0
    const TCHAR * pGadgetClassName = (const TCHAR *) pGadget->GetClassInfo()->GetClassName();
    TRACEUSER("amb",_T("Gadget is a %s"),pGadgetClassName);
#endif
    return pGadget;
}

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

>   static OpDescriptor * DialogManager::GetGadgetOpDescritpor(CWindowID WindowID, CGadgetID Gadget);

    Author:     Alex Bligh (alex@alex.org.uk)
    Created:    20/12/2005
    Inputs:     WindowID: Dialog box window identifier
                Gadget: Gadget identifier
    Returns:    pointer to an OpDescriptor, or NULL if not found

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

OpDescriptor * DialogManager::GetGadgetOpDescriptor(CWindowID WindowID, CGadgetID Gadget)
{
    wxWindow * pWindow = GetGadget(WindowID, Gadget);
    if (!pWindow) return NULL;

    // If it's not a wxControl, return
    if (!pWindow->IsKindOf(CLASSINFO(wxControl)))
        return NULL;

    wxControl * pControl = (wxControl *)pWindow;
    return ControlList::Get()->Find(pControl);
}

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

>   BOOL DialogManager::SetStringGadgetValue(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        StringBase* StrVal,
                                        BOOL EndOfList,
                                        INT32 ListPos)
{
    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/8/93
    Inputs:     WindowID: Dialog box window identifier
                Gadget: Gadget identifier
                StrID:    Resource ID of string


                The following inputs only need to be provided if the gadget has multiple
                values, for example a ListBox.

                EndOfList:   TRUE if the value is to be a added to the end of the gadgets
                            value list. (Default = TRUE)
                            FALSE if the value is to be added to the ListPos position in the
                            list.

                ListPos:     If EndOfList = FALSE then this input specifies the position
                            in the list (Default = 0, so if you want to add the value to
                            the top of the list simply specify EndOfList = FALSE)

                            If the gadget is a ComboBox then setting ListPos = -1 will
                            set the combo box's edit gadget field.


    Outputs:    -
    Returns:    TRUE if the gadgets value could be set
                FALSE if it could not

    Purpose:    This function is used to set a gadgets string value. It can only
                be used on gadgets with a string value type.

                For Windows
                -----------

                This function can be used to set the string values of the following controls:

                Button
                Static
                Edit
                ListBox
                ComboBox


    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetStringGadgetValue

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

BOOL DialogManager::SetStringGadgetValue(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        const StringBase& StrVal,
                                        BOOL EndOfList,
                                        INT32 ListPos)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    wxString String( (const TCHAR*)StrVal );

    //if ( pGadget->IsKindOf(CLASSINFO(wxControlWithItems)) ) // Includes wxListBox - this seems to have false positives
    if ( pGadget->IsKindOf(CLASSINFO(wxListBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxChoice))
        )
    {
        if (EndOfList)
        {
            if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
                ((wxOwnerDrawnComboBox *)pGadget)->Append(String);
            else
                ((wxControlWithItems *)pGadget)->Append(String);
            return TRUE;
        }

        if (pGadget->IsKindOf(CLASSINFO(wxComboBox)) && (pGadget->GetWindowStyle() & wxCB_SORT))
        {
            PORTNOTETRACE("dialog", "Mainting original order of combos displayed sorted is not supported");
            pGadget->SetWindowStyle(pGadget->GetWindowStyle() & ~wxCB_SORT);
        }

        if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) && (pGadget->GetWindowStyle() & wxCB_SORT))
        {
            PORTNOTETRACE("dialog", "Mainting original order of combos displayed sorted is not supported");
            pGadget->SetWindowStyle(pGadget->GetWindowStyle() & ~wxCB_SORT);
        }

        if (pGadget->IsKindOf(CLASSINFO(wxListBox)) && (pGadget->GetWindowStyle() & wxLB_SORT))
        {
            PORTNOTETRACE("dialog", "Mainting original order of list boxes displayed sorted is not supported");
            pGadget->SetWindowStyle(pGadget->GetWindowStyle() & ~wxLB_SORT);
        }

        if (ListPos >=0)
        {
            if (
                (pGadget->IsKindOf(CLASSINFO(wxComboBox)) && (pGadget->GetWindowStyle() & wxCB_SORT)) ||
                (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) && (pGadget->GetWindowStyle() & wxCB_SORT)) ||
                (pGadget->IsKindOf(CLASSINFO(wxListBox)) && (pGadget->GetWindowStyle() & wxLB_SORT)) ||
                (pGadget->IsKindOf(CLASSINFO(wxChoice)))
                )
            {
                // Control does not support inserting at a position as it is sorted. We should append it and
                // it will appear in the right place
                if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
                    ((wxOwnerDrawnComboBox *)pGadget)->Append(String);
                else
                    ((wxControlWithItems *)pGadget)->Append(String);
                return TRUE;
            }
            if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
                return (((wxOwnerDrawnComboBox *)pGadget)->Insert(String, ListPos) <0 )?FALSE:TRUE;
            else
                return (((wxControlWithItems *)pGadget)->Insert(String, ListPos) <0 )?FALSE:TRUE;
        }

        if (pGadget->IsKindOf(CLASSINFO(wxComboBox)))
        {
            ((wxComboBox *)pGadget)->SetValue(String);
            return TRUE;
        }

        if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
        {
            ((wxOwnerDrawnComboBox *)pGadget)->SetValue(String);
            return TRUE;
        }

        ERROR3("Attempt to insert item into edit field of gadget without one");
        return FALSE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxTextCtrl)) )
    {
        ((wxTextCtrl *)pGadget)->SetValue(String);
        return TRUE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxSliderCombo)) )
    {
        ((wxSliderCombo *)pGadget)->SetValue(String);
        return TRUE;
    }

    pGadget->SetLabel(String);

    return TRUE;
}



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

>   BOOL DialogManager::SetCustomComboGadgetValue(CWindowID WindowID,
                                                CGadgetID Gadget,
                                                CustomComboBoxControlDataItem* TheItem,
                                                BOOL EndOfList,
                                                INT32 ListPos)
{
    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> S
    Created:    12/8/99
    Inputs:     WindowID: Dialog box window identifier
                Gadget: Gadget identifier
                TheItem:  The CustomComboBoxControlDataItem that is to be inserted


                EndOfList and ListPos do not actually do anything (as yet),
                BUT have been left a function arguments to avoid having to change
                too many function calls when converting calls on windows
                ComboBoxes into our new custom comboboxes!

                NOTES on ListPos value:

                    >= 0        Insert the item into the control (only at end of list)
                    == -1       Select the item with this index (TheItem should be
                                equal to NULL)

    Outputs:    -
    Returns:    TRUE if the gadgets value could be set
                FALSE if it could not

    Purpose:    This function is used to set a CustomComboBoxes item (i.e.  basically
                insert another item)

                For Windows
                -----------

                This function can be used to set items in the following controls:

                cc_1dBitmapComboBoxEdit
                cc_2dBitmapComboBoxEdit

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    nothing else!

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

BOOL DialogManager::SetCustomComboGadgetValue(CWindowID WindowID,
                                            CGadgetID Gadget,
                                            CustomComboBoxControlDataItem* TheItem,
                                            BOOL EndOfList,
                                            INT32 ListPos)
{
    PORTNOTETRACE("dialog","DialogManager::SetCustomComboGadgetValue - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    String_256 ClassNameStr;  // The control type

    HWND hGadget = GetDlgItem((HWND)WindowID, (INT32)Gadget);
    // Find out the class type of the gadget
    GetClassName(hGadget, (TCHAR*)ClassNameStr, 255);

    if ((ClassNameStr == String_64(TEXT("cc_1dBitmapComboBoxEdit"))) ||
        (ClassNameStr == String_64(TEXT("cc_2dBitmapComboBoxEdit")))   )
    {
        BOOL RetVal = FALSE;

        if (ListPos == 0) // Insert the string in the combo box's edit gadget
        {
            ASSERT (TheItem);

            RetVal = SendMessage (hGadget, WM_CCINSERTBITMAP, 0, (WPARAM) (CustomComboBoxControlDataItem*) TheItem);

        }
        else if (ListPos >= 1)      // but ListPos can be used to set the selected
                                    // item (other than tbe many/custom representations)
        {
            ASSERT (TheItem == NULL);

            RetVal = SendMessage (hGadget, CB_SETCURSEL, (WPARAM) (ListPos-1), (LPARAM) 0);
        }
        else if ((ListPos == -1) || (ListPos == -2))
        {
            ASSERT (TheItem == NULL);

            RetVal = SendMessage (hGadget, CB_SETCURSEL, (WPARAM) (ListPos), (LPARAM) 0);
        }

        return (RetVal);
    }
    return (TRUE);
    ENSURE(FALSE, "Calling SetCustomComboGadgetValue for an invalid control");
#endif
    return FALSE;
}

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

>   BOOL DialogManager::SelectCustomComboGadgetValueOnString (CWindowID WindowID,
                                                            CGadgetID Gadget,
                                                            StringBase* StrVal)
{
    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> S
    Created:    9/9/99
    Inputs:     WindowID: Dialog box window identifier
                Gadget: Gadget identifier
                StrVal:   The name of the item that is to be selected
    Outputs:    -
    Returns:    TRUE if the item could be selected
                FALSE if it could not

    Purpose:    This function is used to select an item (StrVal) within
                cc_2dBitmapComboBoxEdit custom comboboxes

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    nothing else!

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

BOOL DialogManager::SelectCustomComboGadgetValueOnString (CWindowID WindowID,
                                                        CGadgetID Gadget,
                                                        StringBase* StrVal)
{
    PORTNOTETRACE("dialog","DialogManager::SelectCustomComboGadgetValueOnString - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    String_256 ClassNameStr;  // The control type

    HWND hGadget = GetDlgItem((HWND)WindowID, (INT32)Gadget);
    // Find out the class type of the gadget
    GetClassName(hGadget, (TCHAR*)ClassNameStr, 255);

    if( ClassNameStr == String_64( TEXT("cc_2dBitmapComboBoxEdit") ) )
    {
        BOOL RetVal = FALSE;

        RetVal = SendMessage (hGadget, CB_FINDSTRINGEXACT, (WPARAM) (-1), (INT32)(TCHAR*)(*StrVal));

        return (RetVal);
    }
    return (TRUE);
    ENSURE(FALSE, "Calling SelectCustomComboGadgetValueOnString for an invalid control");
#else
    return FALSE;
#endif
}



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

>   BOOL DialogManager::SetGadgetRange(CWindowID WindowID,
                                    CGadgetID Gadget,
                                    INT32 Min,
                                    INT32 Max,
                                    INT32 PageInc = 1)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    2/9/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier
    Outputs:    Min:            Minimum range value
                Max:            Maximum range value
                PageInc:        For gadgets which allow their value to be increased or
                                decreased by a fixed value other than 1.
                                Eg. a scroll bar allows the user to move the scroll
                                bar's thumb a 'page' at a time. PageInc specifies how many
                                units the scroll bar's thumb should move.

    Returns:    -
    Purpose:    For setting the range of a gadget.

                Fow Windows
                -----------

                For scrollbar or trackbar gadgets this function sets the scrollbar's Min and Max
                values. The PageInc value specifies how many units the scroll bar should move
                when a PAGE message is received.

                This function can also be used to set the range of cc_Slider controls.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetGadgetRange

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


BOOL DialogManager::SetGadgetRange(CWindowID WindowID,
                                CGadgetID Gadget,
                                INT32 Min,
                                INT32 Max,
                                INT32 PgIncr)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    INT32 LineIncr = (Max-Min+50)/100;
//  Don't set PgIncr for now
//  if (LineIncr>PgIncr/2)
//      LineIncr = PgIncr/2;
    if (LineIncr<1)
        LineIncr=1;

    if ( pGadget->IsKindOf(CLASSINFO(wxScrollBar)) )
    {
        wxScrollBar * pScroll = (wxScrollBar *)pGadget;
        ERROR3IF(Min !=0 , "Scrollbars with non-zero minimum need to be subclassed");
        pScroll->SetScrollbar(pScroll->GetThumbPosition(), pScroll->GetThumbSize(), Max-Min, PgIncr, TRUE);
        return TRUE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxSlider)) )
    {
        ((wxSlider *)(pGadget))->SetRange(Min, Max);
        ((wxSlider *)(pGadget))->SetLineSize(LineIncr);
        return TRUE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxSliderCombo)) )
    {
        ((wxSliderCombo *)(pGadget))->SetRange(Min, Max);
        ((wxSliderCombo *)(pGadget))->SetLineSize(LineIncr);
        return TRUE;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxGauge)) )
    {
        ERROR3IF(Min !=0 , "Gauges with non-zero minimum need to be subclassed");
        ((wxGauge *)(pGadget))->SetRange(Max-Min);
        return TRUE;
    }

    return FALSE;
}



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

>   static BOOL BOOL DialogManager::SetListBoxSelection( CWindowID WindowID, CGadgetID Gadget,
                                INT32 Index, BOOL SelectIt, BOOL SingleSelection )

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/10/94
    Inputs:     hGadget:        Control window handle
                Index:          Index of value to be selected  (0..Number_of_Items - 1)
                                OR -1 to {de}select all items in the gadget
                SelectIt:       TRUE to select the item
                                FALSE to deselect the item
                SingleSelection:
                                TRUE to set the selection state of a single item (clears
                                any existing selection)
                                FALSE to set selection in a multiple-selection box (does
                                not affect the selection other than on this item). Note
                                that if this is really a single-selection listbox, this
                                flag is effectively always forced to TRUE.

    Returns:    TRUE if the value specified by Index could be selected, FALSE otherwise
    Purpose:    For selecting the Value specified by Index in a list Gadget.
                A subroutine used by the selection-setting DialogManager calls

    Scope:      private

    Errors:     If the function is called on an invalid control then an ERROR3 failure will
                occur in a DEBUG build.

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

BOOL DialogManager::SetListBoxSelection( CWindowID WindowID, CGadgetID Gadget, INT32 Index, BOOL SelectIt, BOOL SingleSelection )
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    if (pGadget->IsKindOf(CLASSINFO(wxListBox)))
    {
        if (SingleSelection)
        {
            ((wxListBox *)pGadget)->SetSelection(wxNOT_FOUND);
            // It's not clear from the docs that that actually clears the selection in a list box (it
            // says "doesn't affect other selected items" so try this to be safe
            wxArrayInt sels;
            INT32 i;
            for (i=0; i<((wxListBox *)pGadget)->GetSelections(sels); i++)
                ((wxListBox *)pGadget)->Deselect(sels[i]);
        }

        if (Index>=0)
        {
            if (SelectIt)
            {
                ((wxListBox *)pGadget)->SetSelection(Index);
            }
            else
            {
                ((wxListBox *)pGadget)->Deselect(Index);
            }
            return TRUE;
        }
        else
        {
            INT32 i;
            for (i=0; i<(INT32)((wxListBox *)pGadget)->GetCount(); i++)
            {
                if (SelectIt)
                {
                    ((wxListBox *)pGadget)->SetSelection(i);
                }
                else
                {
                    ((wxListBox *)pGadget)->Deselect(i);
                }
            }           
        }
    }

    ERROR3("SetListBoxSelection called for non-listbox control");
    return(FALSE);
}


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

>   BOOL DialogManager::SetBoolGadgetSelected(CWindowID WindowID, CGadgetID Gadget,
                                                BOOL SelectIt, INT32 Index = 0)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/10/94
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier
                SelectIt:       TRUE to select, FALSE to deselect the control/item
                Index:          The index of the item within a combo or list box which
                                you wish to (de)select, or -1 to (de)select all items
                                in the list.
    Returns:    TRUE if it succeeded
    Purpose:    For setting the selection state of a gadget, or an item within a list gadget

                For Windows
                -----------
                Can be used to set the selection state for any on/off button type things
                Can be used on combo/list boxes to (de)select items. Note that if the listbox
                is a multiple selection box, setting the selection state of an item does NOT
                affect the state of any other items in the list (so to set only one item
                selected you must either deselect all before calling this function, or call
                SetSelectedGadgetIndex.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetBoolGadgetSelected

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

BOOL DialogManager::SetBoolGadgetSelected(CWindowID WindowID, CGadgetID Gadget,
                                            BOOL SelectIt, INT32 Index)
{
//  INT32 Count = -1;
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    if ( pGadget->IsKindOf(CLASSINFO(wxListBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxChoice))
        )
    {   
        // Support listboxes with multiple selections
        if (pGadget->IsKindOf(CLASSINFO(wxListBox)))
        {
            return SetListBoxSelection(WindowID, Gadget, Index, SelectIt, FALSE);
        }
        
        if (Index>=0)
        {
            if (SelectIt)
            {
                if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
                    ((wxOwnerDrawnComboBox *)pGadget)->SetSelection(Index);
                else    
                    ((wxControlWithItems *)pGadget)->SetSelection(Index);
            }
            else
            {
                // We clear the current selection if it is current
                if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
                {
                    if (((wxOwnerDrawnComboBox *)pGadget)->GetSelection() == Index)
                        ((wxOwnerDrawnComboBox *)pGadget)->SetSelection(wxNOT_FOUND);
                }
                else
                {
                    if (((wxControlWithItems *)pGadget)->GetSelection() == Index)
                        ((wxControlWithItems *)pGadget)->SetSelection(wxNOT_FOUND);
                }   
            }
            return TRUE;
        }
        else
        {
            if (SelectIt)
            {
                // Hmmm - we've been asked to set the selection on every item
                // in a control where only one thing can be selected. Give
                // it a go then..
                INT32 i;
                if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
                    for (i=0; i<(INT32)((wxOwnerDrawnComboBox *)pGadget)->GetCount(); i++)
                        ((wxOwnerDrawnComboBox *)pGadget)->SetSelection(i);
                else
                    for (i=0; i<(INT32)((wxControlWithItems *)pGadget)->GetCount(); i++)
                        ((wxControlWithItems *)pGadget)->SetSelection(i);
            }
            else
            {
                if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
                    ((wxOwnerDrawnComboBox *)pGadget)->SetSelection(wxNOT_FOUND);
                else
                    ((wxControlWithItems *)pGadget)->SetSelection(wxNOT_FOUND);
            }
        }
    }

    // The following types are cannot be ticked /.unticked. OpDescriptors
    // do this then break the control setting
    if ( pGadget->IsKindOf(CLASSINFO(wxScrollBar))
        || pGadget->IsKindOf(CLASSINFO(wxSlider)) 
        || pGadget->IsKindOf(CLASSINFO(wxSliderCombo)) 
        || pGadget->IsKindOf(CLASSINFO(wxGauge))  )
        return TRUE;

    // Assume that we can set it via the SetLongGadgetValue function (radio buttons, etc)
    return(SetLongGadgetValue(WindowID, Gadget, SelectIt));
}


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

>   BOOL DialogManager::SetSelectedValueIndex(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        INT32 Index)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/9/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Dialog identifier
                Index:          Index of value to be selected  (0..Number_of_Items - 1)
                                OR -1 to deselect all values in the gadget (set no-selection)
    Outputs:    -
    Returns:    TRUE if the value specified by Index could be selected, FALSE otherwise
    Purpose:    For selecting the Value specified by Index in a list Gadget

                For Windows
                -----------

                The function can be called on ListBox and ComboBox gadgets to set the
                currently selected value

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

                NOTE that windows controls cannot be guaranteed to accept more than 32768
                items, as an (INT32) is used to pass the index. These controls generate an
                ENSURE failure at present if values outside the range -1 .. 32767 are given.
                In future, special CC controls for Camelot may not have this restriction.

    SeeAlso:    DialogOp::SetSelectedValueIndex

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

BOOL DialogManager::SetSelectedValueIndex(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        INT32 Index)
{
    if (Index>=0)
        return SetBoolGadgetSelected(WindowID, Gadget, TRUE, Index);
    return SetBoolGadgetSelected(WindowID, Gadget, FALSE, -1);
}



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

>   BOOL DialogManager::SetSelectedValueRange(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        WORD StartIndex,
                                        WORD EndIndex,
                                        BOOL Selected)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/04/94
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Dialog identifier
                StartIndex:     Index of first value to be selected  (0..Number_of_Items - 1)
                EndIndex:       Index of last value to be selected  (0..Number_of_Items - 1)
                Selected:       Flag specifying whether range should be selected or not.
    Outputs:    -
    Returns:    TRUE if the value specified by Index could be selected, FALSE otherwise
    Purpose:    For selecting the Value specified by Index in a list Gadget

                For Windows
                -----------

                The function can be called on ListBox or cc_CheckList gadgets to set the
                currently selected value

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetSelectedValueRange

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

BOOL DialogManager::SetSelectedValueRange(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        WORD StartIndex,
                                        WORD EndIndex,
                                        BOOL Selected)
{
    INT32 i;
    for (i=StartIndex; i<=EndIndex; i++)
        SetBoolGadgetSelected(WindowID, Gadget, Selected, i);
    return (TRUE);
}

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

>   BOOL DialogManager::SetDimensionGadgetValue(CWindowID WindowID,
                                                CGadgetID Gadget,
                                                MILLIPOINT Value,
                                                Node* pNode,
                                                BOOL IncludeUnitSpecifier = TRUE,
                                                BOOL EndOfList = TRUE,
                                                INT32 ListPos = 0)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/6/94
    Inputs:     WindowID:    Dialog box window identifier
                Gadget:      Identifier of the gadget
                Value:       The value to set the gadget to in MILLIPOINTS
                pNode:       Ptr to the node from whence Value came from
                IncludeUnitSpecifier :  If TRUE the unit specifier is included
                                        e.g. "1.27 cm" or "1.27" for TRUE or FALSE respectively

                The following inputs only need to be provided if the gadget has multiple
                values, for example a ListBox.

                EndOfList:   TRUE if the value is to be a added to the end of the gadgets
                            value list. (Default = TRUE)
                            FALSE if the value is to be added to the ListPos position in the
                            list.

                ListPos:     If EndOfList = FALSE then this input specifies the position
                            in the list (Default = 0, so if you want to add the value to
                            the top of the list simply specify EndOfList = FALSE)

                            If the gadget is a ComboBox then setting ListPos = -1 will
                            set the combo box's edit gadget field.

    Outputs:    -
    Returns:    TRUE if the gadgets value could be set as specified
                FALSE if it could not.

    Purpose:    This is the routine to call for displaying a node's dimension
                in a control.  It creates a string that represents 'Value' in the units
                the user wants, possibly scaled up/down if the user has specified a
                dimension scaling factor (e.g. 1 mile = 2 cm)
                Once the string is created, SetStringGadgetValue is called on the control,
                so you should be aware of this routine's features/limitations before calling
                SetDimensionGadgetValue.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetDimensionGadgetValue
    SeeAlso:    DialogManager::SetStringGadgetValue

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

BOOL DialogManager::SetDimensionGadgetValue( CWindowID WindowID,
                                            CGadgetID Gadget,
                                            MILLIPOINT Value,
                                            Node* pNode,
                                            BOOL IncludeUnitSpecifier,
                                            BOOL EndOfList,
                                            INT32 ListPos)
{
    DimScale           *pDimScale = DimScale::GetPtrDimScale(pNode);
    String_256          Str;

    pDimScale->ConvertToUnits( Value, &Str, IncludeUnitSpecifier );
    SetStringGadgetValue( WindowID, Gadget, Str, EndOfList, ListPos );

    return TRUE;
}

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

>   BOOL DialogManager::SetMemoryGadgetValue( CWindowID WindowID,
                                            CGadgetID Gadget,
                                            UINT32 Value,
                                            BOOL EndOfList = TRUE,
                                            INT32 ListPos = 0)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/1/95
    Inputs:     WindowID:    Dialog box window identifier
                Gadget:      Identifier of the gadget
                Value:       The value to set the gadget to in bytes.

                The following inputs only need to be provided if the gadget has multiple
                values, for example a ListBox.

                EndOfList:   TRUE if the value is to be a added to the end of the gadgets
                            value list. (Default = TRUE)
                            FALSE if the value is to be added to the ListPos position in the
                            list.

                ListPos:     If EndOfList = FALSE then this input specifies the position
                            in the list (Default = 0, so if you want to add the value to
                            the top of the list simply specify EndOfList = FALSE)

                            If the gadget is a ComboBox then setting ListPos = -1 will
                            set the combo box's edit gadget field.

    Outputs:    -
    Returns:    TRUE if the gadgets value could be set as specified
                FALSE if it could not.

    Purpose:    This method is used to set a gadget which should display an amount of memory
                being used or allocated. The value will be rounded to the nearest K or M or G
                byte value. The actual type of the gadget does not matter.

                For example:

                If gadget g1 is a string then

                SetMemoryGadgetValue(g1win, g1, 4*1024) will set g1's value to '4 Mbytes'

                For Windows
                -----------

                The function can be used to set the string values of the following controls.

                Edit
                Static
                Button
                ListBox
                ComboBox

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetMemoryGadgetValue; DialogOp::GetMemoryGadgetValue;

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

BOOL DialogManager::SetMemoryGadgetValue( CWindowID WindowID,
                                        CGadgetID Gadget,
                                        UINT32 Value,
                                        BOOL EndOfList,
                                        INT32 ListPos)
{
    String_256 StrValue;
    Convert::BytesToString(&StrValue, Value);
    return (SetStringGadgetValue(WindowID, Gadget, StrValue, EndOfList, ListPos));
}


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

>   BOOL DialogManager::SetGadgetHelp( CWindowID WindowID,
                                    CGadgetID Gadget,
                                    UINT32 BubbleID,
                                    UINT32 StatusID,
                                    UINT32 ModuleID = 0)

    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/4/95
    Inputs:     WindowID:    Dialog box window identifier
                Gadget:      Identifier of the gadget

    Outputs:    -
    Returns:    TRUE if the gadgets value could be set as specified
                FALSE if it could not.

    Purpose:    Allows the Bubble and Status ID's of a control to be changed at runtime.

    Errors:     Return FALSE if the Gadget could not be found.

    SeeAlso:    DialogOp::SetMemoryGadgetValue; DialogOp::GetMemoryGadgetValue;

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

BOOL DialogManager::SetGadgetHelp( CWindowID WindowID,
                                CGadgetID Gadget,
                                UINT32 BubbleID,
                                UINT32 StatusID,
                                UINT32 ModuleID)
{
    PORTNOTE("dialog","DialogManager::SetGadgetHelp - do nothing")
#ifndef EXCLUDE_FROM_XARALX
    // Find the gadgets window
    HWND hGadget = GetDlgItem((HWND)WindowID, (INT32)Gadget);

    // Setup the Control help Info structure
    ControlHelpInfo Info;
    Info.BubbleID = BubbleID;
    Info.StatusID = StatusID;
    Info.ModuleID = ModuleID;

    // Tell the the control helper to update the ID's in it's table
    // We must also update any child window's entries.
    do
    {
        if (!ControlHelper::NotifyControlChanged(hGadget, &Info))
            return FALSE;

        hGadget = GetWindow(hGadget, GW_CHILD);
    }
    while (hGadget != NULL);
#endif
    return TRUE;
}


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


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

>   MILLIPOINT DialogManager::GetUnitGadgetValue(CWindowID WindowID,
                                            CGadgetID Gadget,
                                            UnitType DefaultType,
                                            MILLIPOINT StartRange,
                                            MILLIPOINT EndRange,
                                            UINT32 IDSInvalidMsg,
                                            BOOL* Valid)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/8/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Dialog identifier
                TheType:        The type of the gadgets value
                StartRange:     Minimum gadget value
                EndRange:       Maximum gadget value
                InvalidMsgID:   Message displayed to the user when they have entered
                                invalid data (either not the correct type or not in the
                                correct range)
                                This may be 0 if you do not wish an error to be reported

    Outputs:    Valid:          Flag indicating if the value entered was valid or not.
                                If the Valid parameter is NULL, then validity of the result
                                will not be checked, and the actual value of the control
                                will be returned even if it was out of range.
                                If this flag is returned FALSE then the return value will be 0.

    Returns:    The value entered by the user in MILLIPOINTS. If Valid is FALSE then
                NULL will be returned.

    Purpose:    This function will obtain the gadget value and validate it. Validation will
                check that data has been entered in a correct unit type, and that it is
                in the range StartRange..EndRange. If the user enters an incorrect value
                the InvalidMsgID string will be displayed to the user in a dialog
                box, and Valid will have a FALSE value.

                For Windows
                -----------

                The function can be used to obtain a unit value from the string value of the
                following controls:

                Edit
                ListBox
                ComboBox
                Static

                For ListBox and ComboBox controls the unit value of the currently selected
                listitem is returned. This function would normally be called in response to a
                DIM_SELECTION_CHANGED or DIM_SELECTION_CHANGED_COMMIT message.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::GetUnitGadgetValue

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

MILLIPOINT DialogManager::GetUnitGadgetValue(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        UnitType DefaultType,
                                        MILLIPOINT StartRange,
                                        MILLIPOINT EndRange,
                                        UINT32 IDSInvalidMsg,
                                        BOOL* Valid)
{
    MILLIPOINT          Value = 0;    // The return value

    BOOL IsValid;

    // Obtain the controls text
    String_256 StrValue = GetStringGadgetValue(WindowID, Gadget, NULL);

    // Convert the string to millipoints if it's valid
    Value = Convert::StringToMillipoints(StrValue, DefaultType, &IsValid);

    if (Valid == NULL)      // If don't want it validated, return the value now
        return(Value);

    if (IsValid)
    {
        // Check that the value is in the range StartRange..EndRange
        if ((Value >= StartRange) && (Value <= EndRange))
        {
            *Valid = TRUE;
            return (Value); // A correct value was entered
        }
    }

    // The value is invalid
    if (IDSInvalidMsg != 0)
        InformWarning(IDSInvalidMsg); // Scold the user, if a message was supplied

    return( 0 );
}

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

>   INT32 DialogManager::GetLongGadgetValue(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        INT32 StartRange,
                                        INT32 EndRange,
                                        UINT32 IDSInvalidMsg,
                                        BOOL* Valid,
                                        DialogManager::PFNSTRINGTOINT32 pfnParser = ::StringToLong)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/9/93

    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Dialog identifier
                StartRange:     Minimum gadget value
                EndRange:       Maximum gadget value
                InvalidMsgID:   Message displayed to the user when they have entered
                                invalid data (either not the correct type or not in the
                                correct range)
                                This may be 0 if you do not wish an error to be reported
                pfnParser       optional pointer to a function that converts a StringBase
                                to a INT32.  The default is:-
                                    BOOL ::StringToLong(StringBase* in, INT32* out)
                                but any function with a similar prototype will work.
                                This function is called for controls that contain text,
                                eg. a combo-box.  Ask JustinF about this if you aren't
                                sure.

    Outputs:    Valid:          Flag indicating if the value entered was valid or not.
                                If the Valid parameter is NULL, then validity of the result
                                will not be checked, and the actual value of the control
                                will be returned even if it was out of range.
                                If this flag is returned FALSE then the return value will be 0.

    Returns:    The value entered by the user. If Valid is FALSE then
                NULL will be returned.

    Purpose:    This function will obtain the gadget value and validate it. Validation will
                check that a correct INT32 value has been entered, and that it is
                in the range StartRange..EndRange. If the user enters an incorrect value
                the InvalidMsgID string will be displayed to the user in a dialog
                box, and Valid will have a FALSE value.

                For Windows
                -----------

                The function can be used to obtain a INT32 value from the string value of the
                following controls:

                Edit
                ListBox
                ComboBox
                Static
                cc_CheckList
                Button

                For ListBox and ComboBox controls the INT32 value of the currently selected
                listitem is returned. This function would normally be called in response to a
                DIM_SELECTION_CHANGED or DIM_SELECTION_CHANGED_COMMIT message.

                You can override the conversion from the string value to the INT32 by
                providing your own pfnParser parameter.   This could, for example,
                remove percentage signs from the text before conversion.

                For Button controls this function returns back the current state of the button

                For ScrollBar controls this function returns back the current position of
                the scroll bars thumb.

                For cc_Slider controls this function returns the current position of the
                bar in the slider.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::GetLongGadgetValue

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

INT32 DialogManager::GetLongGadgetValue(CWindowID WindowID,
                                    CGadgetID Gadget,
                                    INT32 StartRange,
                                    INT32 EndRange,
                                    UINT32 IDSInvalidMsg,
                                    BOOL* Valid,
                                    Convert::PFNSTRINGTOINT32 pfnParser)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    if ( pGadget->IsKindOf(CLASSINFO(wxButton)) ||
        pGadget->IsKindOf(CLASSINFO(wxBitmapButton)) )
    {
        // These bitmap buttons are meant to be tristate
        PORTNOTETRACE("dialog","DialogManager::GetLongGadgetValue on BitmapButton - do nothing");
        return 0;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxCheckBox)) )
    {
        if (Valid) *Valid=TRUE;
        return ((wxCheckBox *)(pGadget))->GetValue() != 0;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxRadioButton)) )
    {
        if (Valid) *Valid=TRUE;
        return ((wxRadioButton *)(pGadget))->GetValue() != 0;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxScrollBar)) )
    {
        if (Valid) *Valid=TRUE;
        return (INT32)(((wxScrollBar *)(pGadget))->GetThumbPosition());
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxSlider)) )
    {
        if (Valid) *Valid=TRUE;
        return (INT32)(((wxSlider *)(pGadget))->GetValue());
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxSliderCombo)) )
    {
        if (Valid) *Valid=TRUE;
        return (INT32)(((wxSliderCombo *)(pGadget))->GetSliderValue());
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxGauge)) )
    {
        if (Valid) *Valid=TRUE;
        return (INT32)(((wxGauge *)(pGadget))->GetValue());
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxCamArtControl)) )
    {
        if (Valid) *Valid=TRUE;
        return (INT32)(((wxCamArtControl *)(pGadget))->GetValue());
    }

#if 0
    // it seems on an edit box we might be meant to set the garet, but it's difficult to know what's
    // going on here
    else if (ClassNameStr == String_16(TEXT("cc_CustomEdit")))//?
    {
        CCustomEdit* pCEdit = (CCustomEdit*)CWnd::FromHandlePermanent(hGadget);
        Value = pCEdit->GetPos();
        IsValid = ((Value >= StartRange) && (Value <= EndRange));
        TRACEUSER( "Marc", _T("dlgmgr.cpp, getting pos %d\n"),Value);
    }
#endif

    // Hmmm - no luck so far, let's try a string

    // Obtain the controls text
    String_256 StrValue = GetStringGadgetValue(WindowID, Gadget, NULL);

    // Convert the string to an INT32 if it's valid
    INT32 Value=0;
    BOOL IsValid = (*pfnParser)(StrValue, &Value);
    if (IsValid)
    {
        IsValid = ((Value >= StartRange) && (Value <= EndRange));
    }

    if (Valid != NULL)
    {
        *Valid = IsValid;

        if (!IsValid)   // The value is invalid
        {
            if (IDSInvalidMsg != 0)
                InformWarning(IDSInvalidMsg); // Scold the user, if a message was supplied
            return (0);
        }
    }

    return Value; // Valid input, or caller did not want validation
}


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

>   double DialogManager::GetDoubleGadgetValue(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        double StartRange,
                                        double EndRange,
                                        UINT32 IDSInvalidMsg,
                                        BOOL* Valid,
                                        DialogManager::PFNSTRINGTODOUBLE pfnParser = ::StringToDouble)

    Author:     Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> (liberally copied from GetLongGadgetValue)
    Created:    16/12/94

    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Dialog identifier
                StartRange:     Minimum gadget value
                EndRange:       Maximum gadget value
                InvalidMsgID:   Message displayed to the user when they have entered
                                invalid data (either not the correct type or not in the
                                correct range)
                                This may be 0 if you do not wish an error to be reported
                pfnParser       optional pointer to a function that converts a StringBase
                                to a double.  The default is:-
                                    double ::StringToDouble(StringBase* in, Double* out)
                                but any function with a similar prototype will work.
                                This function is called for controls that contain text,
                                eg. a combo-box.  Ask JustinF about this if you aren't
                                sure.

    Outputs:    Valid:          Flag indicating if the value entered was valid or not.
                                If the Valid parameter is NULL, then validity of the result
                                will not be checked, and the actual value of the control
                                will be returned even if it was out of range.
                                If this flag is returned FALSE then the return value will be 0.

    Returns:    The value entered by the user. If Valid is FALSE then
                NULL will be returned.

    Purpose:    This function will obtain the gadget value and validate it. Validation will
                check that a correct double value has been entered, and that it is
                in the range StartRange..EndRange. If the user enters an incorrect value
                the InvalidMsgID string will be displayed to the user in a dialog
                box, and Valid will have a FALSE value.

                For Windows
                -----------

                The function can be used to obtain a double value from the string value of the
                following controls:

                Edit
                ListBox
                ComboBox
                Static
                cc_CheckList
                Button

                For ListBox and ComboBox controls the INT32 value of the currently selected
                listitem is returned. This function would normally be called in response to a
                DIM_SELECTION_CHANGED or DIM_SELECTION_CHANGED_COMMIT message.

                You can override the conversion from the string value to the double by
                providing your own pfnParser parameter.   This could, for example,
                remove percentage signs from the text before conversion.

                For Button controls this function returns back the current state of the button

                For ScrollBar controls this function returns back the current position of
                the scroll bars thumb.

                For cc_Slider controls this function returns the current position of the
                bar in the slider.

                Note for some controls, like sliders, the value comes back as an INT32 converted
                to a double so you might as well use GetLongGadgetValue.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::GetDoubleGadgetValue, DialogManager::GetLongGadgetValue

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

double DialogManager::GetDoubleGadgetValue(CWindowID WindowID,
                                    CGadgetID Gadget,
                                    double StartRange,
                                    double EndRange,
                                    UINT32 IDSInvalidMsg,
                                    BOOL* Valid,
                                    Convert::PFNSTRINGTODOUBLE pfnParser)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    if (( pGadget->IsKindOf(CLASSINFO(wxButton))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxBitmapButton))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxCheckBox))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxRadioButton))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxScrollBar))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxSlider))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxSliderCombo))) ||
        ( pGadget->IsKindOf(CLASSINFO(wxGauge)))
        )
        return (double)GetLongGadgetValue( WindowID, Gadget, (INT32)(floor(StartRange+0.5)), (INT32)(floor(EndRange+0.5)), IDSInvalidMsg, Valid);

    String_256 StrValue = GetStringGadgetValue(WindowID, Gadget, NULL);

    // Convert the string to an INT32 if it's valid
    double Value=0.0;
    BOOL IsValid = (*pfnParser)(StrValue, &Value);
    if (IsValid)
    {
        IsValid = ((Value >= StartRange) && (Value <= EndRange));
    }

    if (Valid != NULL)
    {
        *Valid = IsValid;

        if (!IsValid)   // The value is invalid
        {
            if (IDSInvalidMsg != 0)
                InformWarning(IDSInvalidMsg); // Scold the user, if a message was supplied
            return (0);
        }
    }

    return Value; // Valid input, or caller did not want validation
}

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

>   BOOL DialogManager::GetBoolGadgetSelected(CWindowID WindowID,
                                            CGadgetID Gadget,
                                            UINT32 IDSInvalidMsg = 0,
                                            BOOL* Valid = NULL,
                                            INT32 ListPos = 0)

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

    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Dialog identifier
                InvalidMsgID:   Message displayed to the user when they have entered
                                invalid data (either not the correct type or not in the
                                correct range)
                                This may be 0 if you do not wish an error to be reported
                ListPos:        Specifies which item in a list to read (defaults to 0)

    Outputs:    Valid:          Flag indicating if the value entered was valid or not.
                                If the Valid parameter is NULL, then validity of the result
                                will not be checked, and the actual value of the control
                                will be returned even if it was "invalid".
                                If this flag is returned FALSE then the return value will be 0.

    Returns:    The value entered by the user. If Valid is FALSE then
                FALSE will be returned.

    Purpose:    This function will obtain the gadget value and validate it. Validation will
                check that a correct INT32 value has been entered, and that it is
                in the range StartRange..EndRange. If the user enters an incorrect value
                the InvalidMsgID string will be displayed to the user in a dialog
                box, and Valid will have a FALSE value. [This does not seem correct - AMB]

                For Windows
                -----------

                The function can be used to obtain a BOOL value from the
                following controls:

                Button
                ListBox
                cc_CheckList

                For ListBox/cc_CheckList controls the bool value of the currently selected
                listitem is returned. This function would normally be called in response to a
                DIM_SELECTION_CHANGED or DIM_SELECTION_CHANGED_COMMIT message.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::GetLongGadgetValue

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

BOOL DialogManager::GetBoolGadgetSelected(CWindowID WindowID,
                                            CGadgetID Gadget,
                                            UINT32 IDSInvalidMsg,
                                            BOOL* Valid,
                                            INT32 ListPos)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    if ( pGadget->IsKindOf(CLASSINFO(wxListBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxChoice)) )
    {
        // Support listboxes with multiple selections
        if (pGadget->IsKindOf(CLASSINFO(wxListBox)))
        {
            return ((wxListBox *)pGadget)->IsSelected(ListPos);
        }
        if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
            return (((wxOwnerDrawnComboBox *)pGadget)->GetSelection() == ListPos);
        else
            return (((wxControlWithItems *)pGadget)->GetSelection() == ListPos);
    }

    return GetLongGadgetValue(WindowID, Gadget, 0, 1, IDSInvalidMsg, Valid);
}





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

>   String_256 DialogManager::GetStringGadgetValue(CWindowID WindowID,
                                                CGadgetID Gadget,
                                                BOOL* Valid,
                                                INT32 ListPos = -1)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    2/9/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier
                ListPos:        Index into list if needed (defaults to -1 to mean read
                                the text of the selected item. In the case of a combo
                                this is the text in the editable field - which may be
                                a value which does not exist in the combo's list.

    Outputs:    Valid:          Flag indicating if the string could be read or not
                                You may pass NULL if you don't care about the validity
                                (if invalid, the returned string will be a NULL string)

    Returns:    The gadgets string value if Valid is TRUE, else a NULL string

    Purpose:    For finding a gadgets string value. This function can only be used for
                gadgets with a text value.

                For Windows
                -----------

                This function returns the string value for the following controls

                Edit
                ListBox
                ComboBox
                Static
                Button

                For ListBox and ComboBox controls the string value of the currently selected
                listitem is returned. This function would normally be called in response to a
                DIM_SELECTION_CHANGED or DIM_SELECTION_CHANGED_COMMIT message.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::GetStringGadgetValue

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

String_256 DialogManager::GetStringGadgetValue(CWindowID WindowID,
                                            CGadgetID Gadget,
                                            BOOL* Valid,
                                            INT32 ListPos)
{
    if (Valid)
        *Valid = TRUE;
    String_256 StrVal;

    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    wxString String;

    if (!pGadget) goto invalid;

//  if ( pGadget->IsKindOf(CLASSINFO(wxControlWithItems)) ) // Includes wxListBox - this seems to have false positives
    if ( pGadget->IsKindOf(CLASSINFO(wxListBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxChoice)) )
    {
        if (ListPos >=0)
        {
            if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
            {
                if (ListPos>=(INT32)((wxOwnerDrawnComboBox *)pGadget)->GetCount()) goto invalid;
                String = ((wxOwnerDrawnComboBox *)pGadget)->GetString(ListPos);
            }
            else
            {
                if (ListPos>=(INT32)((wxControlWithItems *)pGadget)->GetCount()) goto invalid;
                String = ((wxControlWithItems *)pGadget)->GetString(ListPos);
            }
            goto out;
        }

        if (pGadget->IsKindOf(CLASSINFO(wxComboBox)))
        {
            String = ((wxComboBox *)pGadget)->GetValue();
            goto out;
        }

        if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
        {
            String = ((wxOwnerDrawnComboBox *)pGadget)->GetValue();
            goto out;
        }

        INT32 sel;
        if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
            sel = ((wxOwnerDrawnComboBox *)pGadget)->GetSelection();
        else
            sel = ((wxControlWithItems *)pGadget)->GetSelection();

        if ( (sel == wxNOT_FOUND) || (sel < 0)) goto invalid;

        if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
            String = ((wxOwnerDrawnComboBox *)pGadget)->GetString(sel);
        else
            String = ((wxControlWithItems *)pGadget)->GetString(sel);

        goto out;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxTextCtrl)) )
    {
        String = ((wxTextCtrl *)pGadget)->GetValue();
        goto out;
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxSliderCombo)) )
    {
        String = ((wxSliderCombo *)pGadget)->GetValue();
        goto out;
    }

    String = pGadget->GetLabel();

out:
    StrVal = String.c_str();
    return StrVal;

invalid:
    if (Valid)
        *Valid=FALSE;
    return StrVal;
}

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

>   BOOL DialogManager::GetGadgetRange(CWindowID WindowID,
                                    CGadgetID Gadget,
                                    INT32* Min,
                                    INT32* Max)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    2/9/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier
    Outputs:    Min:            Minimum range value
                Max:            Maximum range value

    Returns:    TRUE if the gadget's range could be read, FALSE otherwise

    Purpose:    For obtaining the range of a gadget.

                For Windows
                -----------

                The function returns a ScrollBar control's Min and Max values.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::GetGadgetRange

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


BOOL DialogManager::GetGadgetRange(CWindowID WindowID,
                                CGadgetID Gadget,
                                INT32* Min,
                                INT32* Max)
{
    INT32 min=0;
    INT32 max=0;

    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    if ( pGadget->IsKindOf(CLASSINFO(wxScrollBar)) )
    {
        max = ((wxScrollBar *)pGadget)->GetRange();
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxSlider)) )
    {
        min=((wxSlider *)(pGadget))->GetMin();
        max=((wxSlider *)(pGadget))->GetMax();
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxSliderCombo)) )
    {
        min=((wxSliderCombo *)(pGadget))->GetSliderMin();
        max=((wxSliderCombo *)(pGadget))->GetSliderMax();
    }

    if ( pGadget->IsKindOf(CLASSINFO(wxGauge)) )
    {
        max = ((wxGauge *)(pGadget))->GetRange();
    }

    if (Min) *Min=min;
    if (Max) *Max=max;

    return TRUE;
}


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

>   MILLIPOINT DialogManager::GetDimensionGadgetValue(  CWindowID WindowID,
                                                        CGadgetID Gadget,
                                                        Node* pNode,
                                                        BOOL* Valid)
                                                        INT32 ListPos = -1)
    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/6/94
    Inputs:     WindowID:    Dialog box window identifier
                Gadget:      Identifier of the gadget
                pNode:       The node the dimenstion is for
    Outputs:    Valid - TRUE if a valid dimension has been read from the control
                Valid may be a NULL pointer if you are uninterested in the result

    Returns:    The internal millipoint representation of the string in this control
    Purpose:    This is the routine to call for getting user-entered dimensions from
                a control.  The value is scaled from user dimensions to an internal millipoint
                value.
                The routine uses DialogManager::GetStringGadgetValue to extract the string from
                the control.  The caller should be aware of the features/limitations of this routine
                before calling GetDimensionGadgetValue.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::GetDimensionGadgetValue
    SeeAlso:    DialogManager::GetStringGadgetValue

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

MILLIPOINT DialogManager::GetDimensionGadgetValue(  CWindowID WindowID,
                                                    CGadgetID Gadget,
                                                    Node* pNode,
                                                    BOOL* Valid,
                                                    INT32 ListPos)
{
    MILLIPOINT Val=72000;
    DimScale* pDimScale = DimScale::GetPtrDimScale(pNode);
    String_256 Str;

    Str = GetStringGadgetValue(WindowID,Gadget,Valid,ListPos);
    if (Valid != NULL && *Valid)
        *Valid = pDimScale->ConvertToMillipoints(Str,&Val);
    return Val;
}


/********************************************************************************************
BOOL DialogManager::GetDoubleAndUnitGadgetValue(double*   pMPValue,
                                                double*   pUnitValue,
                                                UnitType* pUnitType,
                                                CWindowID WindowID,
                                                CGadgetID Gadget,
                                                Node*     pNode)
    Author:     Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/9/95
    Inputs:     WindowID   -
                Gadget   -
                pNode      - node from which to determine default units (ie page units)
    Outputs:    pMPValue   - value of gadget converted to millipoints (accounting for scaling)
                pUnitValue - value of gadget in terms of units output in pUnitType
                pUnitType  - type of unit the value was specified in (or page units if none)
    Returns:    FALSE if fails
    Purpose:    Read the value from a gadget as a double millipont values accounting for unit scaling
                ALSO read the type of unit specified and the gadget value in terms of these units
                ie 0.5m would return 36000.0, 0.5 and METERS (assuming scaling 1m->1in)
********************************************************************************************/

BOOL DialogManager::GetDoubleAndUnitGadgetValue(double*   pMPValue,
                                                double*   pUnitValue,
                                                UnitType* pUnitType,
                                                CWindowID WindowID,
                                                CGadgetID Gadget,
                                                Node*     pNode)
{
    ERROR2IF(  pMPValue==NULL,FALSE,"DialogManager::GetDoubleAndUnitGadgetValue() - pMPValue==NULL");
    ERROR2IF(pUnitValue==NULL,FALSE,"DialogManager::GetDoubleAndUnitGadgetValue() - pUnitValue==NULL");
    ERROR2IF( pUnitType==NULL,FALSE,"DialogManager::GetDoubleAndUnitGadgetValue() - pUnitType==NULL");
    ERROR2IF(     pNode==NULL,FALSE,"DialogManager::GetDoubleAndUnitGadgetValue() - pNode==NULL");
    DimScale* pDimScale = DimScale::GetPtrDimScale(pNode);
    ERROR2IF( pDimScale==NULL,FALSE,"DialogManager::GetDoubleAndUnitGadgetValue() - pDimScale==NULL");

    // separate string into double value and unit type
    BOOL     ok         = TRUE;
    double   UnitValue  = 1.0;
    UnitType units;
    String_256 GadgetString=GetStringGadgetValue(WindowID,Gadget,&ok);
    if (ok) ok=Convert::StringToComponents(GadgetString, &UnitValue, &units);
    if (!ok) return FALSE;

    // if no unit type specified, use units associated with the specified node
    if (units==NOTYPE)
        units=pDimScale->GetUnits();

    // and get the value in millipoints accounting for scaled units
    double MPValue = 1.0;
    ok=pDimScale->ConvertToDouble(GadgetString,&MPValue);
    if (!ok) return FALSE;

    // set outputs and return
    *pMPValue   = MPValue;
    *pUnitValue = UnitValue;
    *pUnitType  = units;

    return TRUE;
}


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

>   UINT32 DialogManager::GetMemoryGadgetValue(CWindowID WindowID,
                                            CGadgetID Gadget,
                                            UINT32 StartRange,
                                            UINT32 EndRange,
                                            UINT32 IDSInvalidMsg,
                                            BOOL* Valid)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/1/95
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Dialog identifier
                StartRange:     Minimum gadget value
                EndRange:       Maximum gadget value
                InvalidMsgID:   Message displayed to the user when they have entered
                                invalid data (either not the correct type or not in the
                                correct range)
                                This may be 0 if you do not wish an error to be reported

    Outputs:    Valid:          Flag indicating if the value entered was valid or not.
                                If the Valid parameter is NULL, then validity of the result
                                will not be checked, and the actual value of the control
                                will be returned even if it was out of range.
                                If this flag is returned FALSE then the return value will be 0.

    Returns:    The value entered by the user in bytes. If Valid is FALSE then
                NULL will be returned.

    Purpose:    This function allows a memory value to be read back from a control. It will
                cope with the memory being specified in bytes, K, M or G bytes and will also
                validate it. Validation will check that data has been entered in a correct unit
                type, and that it is in the range StartRange..EndRange. If the user enters an
                incorrect value the InvalidMsgID string will be displayed to the user in a
                dialog box, and Valid will have a FALSE value.

                For Windows
                -----------

                The function can be used to obtain a memory value from the string value of the
                following controls:

                Edit
                ListBox
                ComboBox
                Static

                For ListBox and ComboBox controls the unit value of the currently selected
                listitem is returned. This function would normally be called in response to a
                DIM_SELECTION_CHANGED or DIM_SELECTION_CHANGED_COMMIT message.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::GetMemoryGadgetValue; DialogOp::SetMemoryGadgetValue

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

UINT32 DialogManager::GetMemoryGadgetValue(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        UINT32 StartRange,
                                        UINT32 EndRange,
                                        UINT32 IDSInvalidMsg,
                                        BOOL* Valid)
{
    BOOL IsValid;

    // Obtain the controls text
    String_256 StrValue = GetStringGadgetValue(WindowID, Gadget, NULL);

    // Convert the string to millipoints if it's valid
    UINT32 Value = Convert::StringToBytes(StrValue, &IsValid);

    if (Valid == NULL)      // If don't want it validated, return the value now
        return(Value);

    if (IsValid)
    {
        // Check that the value is in the range StartRange..EndRange
        if ((Value >= StartRange) && (Value <= EndRange))
        {
            *Valid = TRUE;
            return (Value); // A correct value was entered
        }
    }

    // The value is invalid
    if (IDSInvalidMsg != 0)
        InformWarning(IDSInvalidMsg); // Scold the user, if a message was supplied

    return( 0 );
}

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

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

>   BOOL DialogManager::DeleteAllValues(CWindowID WindowID, CGadgetID Gadget)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/5/94
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier

    Returns:    TRUE if the values could be deleted, else FALSE.
    Purpose:    For deleting all values in a list-gadget

                For Windows
                -----------

                This function can be used to delete list items from ComboBox, ListBox,
                or cc_ListBox controls. ALL items in the given Gadget will be deleted
                (i.e. it resets the list to containing no items at all. This is equivalent
                to calling DeleteValue for each list item in turn)

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::DeleteAllValues; DialogManager::DeleteValue

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

BOOL DialogManager::DeleteAllValues(CWindowID WindowID, CGadgetID Gadget)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    //if ( pGadget->IsKindOf(CLASSINFO(wxControlWithItems)) ) // Includes wxListBox - this seems to have false positives
    if ( pGadget->IsKindOf(CLASSINFO(wxListBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxChoice))
        )
    {
        ((wxControlWithItems *)pGadget)->Clear();
        return TRUE;
    }
    else if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
    {
        ((wxOwnerDrawnComboBox *)pGadget)->Clear();
        return TRUE;
    }
    else if ( pGadget->IsKindOf(CLASSINFO(wxTreeCtrl))
        )
    {
        ((wxTreeCtrl*)pGadget)->DeleteAllItems();
        return TRUE;
    }

    ERROR3("Invalid control");
    return FALSE;
}



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

>   BOOL DialogManager::DeleteValue(CWindowID WindowID,
                                    CGadgetID Gadget,
                                    BOOL EndOfList = TRUE,
                                    INT32 ListPos = 0)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    9/9/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier

                The following inputs only need to be provided if the gadget has multiple
                values, for example a ListBox.

                EndOfList:   TRUE if the value is to be deleted from the end of the gadgets
                            value list. (Default = TRUE)

                ListPos:     If EndOfList = FALSE then this input specifies the position
                            in the list (Default = 0, so if you want to delete the value at
                            the top of the list simply specify EndOfList = FALSE)

    Returns:    TRUE if the value could be deleted, else FALSE.
    Purpose:    For deleting a gadget value

                For Windows
                -----------

                This function can be used to delete list items from ListBox or ComboBox
                controls.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::DeleteValue

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

BOOL DialogManager::DeleteValue(CWindowID WindowID,
                                CGadgetID Gadget,
                                BOOL EndOfList,
                                INT32 ListPos)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    //if ( pGadget->IsKindOf(CLASSINFO(wxControlWithItems)) ) // Includes wxListBox - this seems to have false positives
    if ( pGadget->IsKindOf(CLASSINFO(wxListBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxChoice))
        )
    {
        if (EndOfList)
            ((wxControlWithItems *)pGadget)->Delete(((wxControlWithItems *)pGadget)->GetCount()-1);
        else
            ((wxControlWithItems *)pGadget)->Delete(ListPos);
        return TRUE;
    }
    else if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
    {
        if (EndOfList)
            ((wxOwnerDrawnComboBox *)pGadget)->Delete(((wxOwnerDrawnComboBox *)pGadget)->GetCount()-1);
        else
            ((wxOwnerDrawnComboBox *)pGadget)->Delete(ListPos);
        return TRUE;
    }

    ERROR3("Invalid control");
    return FALSE;
}

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

>   BOOL GetValueCount(CWindowID WindowID,
                    CGadgetID Gadget,
                    INT32* Count)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    9/9/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier
    Outputs:    Count:          The number of items in the gadget

    Returns:    FALSE if an error occurred

    Purpose:    For finding the number of values stored in a gadget

                For Windows
                -----------

                This function can be called on ListBox and ComboBox controls to obtain the
                number of values in their lists.

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::GetValueCount

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


BOOL DialogManager::GetValueCount(CWindowID WindowID,
                                CGadgetID Gadget,
                                INT32* Count)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    //if ( pGadget->IsKindOf(CLASSINFO(wxControlWithItems)) ) // Includes wxListBox - this seems to have false positives
    if ( pGadget->IsKindOf(CLASSINFO(wxListBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxChoice))
        )
    {
        INT32 c = ((wxControlWithItems *)pGadget)->GetCount();
        if (Count) *Count=c;
        return TRUE;
    }
    else if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
    {
        INT32 c = ((wxOwnerDrawnComboBox *)pGadget)->GetCount();
        if (Count) *Count=c;
        return TRUE;
    }

    ERROR3("Invalid control");
    return FALSE;
}

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

>   INT32 DialogManager::GetSelectedCount(CWindowID WindowID,CGadgetID Gadget, INT32* Count)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    4/10/95
    Inputs:     WindowID = ID of window that contains the gadget
                Gadget = ID of list-type gadget
    Returns:    The number of selected items in the list-type gadget, or -1 if it fails
    Purpose:    Returns the number of selected items in a list-type gadget
    SeeAlso:    -

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

INT32 DialogManager::GetSelectedCount(CWindowID WindowID,CGadgetID Gadget)
{
//  INT32 Count = -1;
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    if ( pGadget->IsKindOf(CLASSINFO(wxListBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxChoice))
        )
    {
        // Support listboxes with multiple selections
        if (pGadget->IsKindOf(CLASSINFO(wxListBox)))
        {
            wxArrayInt sels;
            return ((wxListBox *)pGadget)->GetSelections(sels);
        }

        return (((wxControlWithItems *)pGadget)->GetSelection() == wxNOT_FOUND)?0:1;
    }
    else if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
        return (((wxOwnerDrawnComboBox *)pGadget)->GetSelection() == wxNOT_FOUND)?0:1;

    return -1;
}

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

>   INT32 DialogManager::GetFirstSelectedItem(CWindowID WindowID, CGadgetID Gadget)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    4/10/95
    Inputs:     WindowID = ID of window that contains the gadget
                Gadget = ID of list-type gadget
    Returns:    The index of the firsted selected items in the list-type gadget, or -1 if it fails
    Purpose:    Returns the index of the first selected item in a list-type gadget
    SeeAlso:    -

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

INT32 DialogManager::GetFirstSelectedItem( CWindowID WindowID, CGadgetID Gadget )
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return -1;

    if ( pGadget->IsKindOf(CLASSINFO(wxListBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxChoice)) )
    {
        // Support listboxes with multiple selections
        if (pGadget->IsKindOf(CLASSINFO(wxListBox)))
        {
            wxArrayInt sels;
            if ( ((wxListBox *)pGadget)->GetSelections(sels) )
            {
                return sels[0];
            }
            return -1;
        }
        return ((wxControlWithItems *)pGadget)->GetSelection();
    }
    else if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
        return ((wxOwnerDrawnComboBox *)pGadget)->GetSelection();

    return -1;
}

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

>   INT32* DialogManager::GetSelectedItems(CWindowID WindowID, CGadgetID Gadget)

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    4/10/95
    Inputs:     WindowID = ID of window that contains the gadget
                Gadget = ID of list-type gadget
    Returns:    ptr to the INT32 array, or NULL if it fails
    Purpose:    Returns a ptr to an INT32 array that holds the list of selected indexes.
                The last array entry contains -1.

                NULL is returned if there's no selection, or not enough memory for the required array

                The caller is responsible for deleting the array that's returned.
                e.g
                    INT32* pArray = GetSelectedItems(WindowID,Gadget);
                    if (pArray != NULL)
                    {
                        ..... // Use the array
                        delete [] pArray;
                    }
    SeeAlso:    -

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

INT32* DialogManager::GetSelectedItems(CWindowID WindowID, CGadgetID Gadget)
{
    INT32* pList = NULL;

    wxArrayInt sels;

    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return NULL;

    if ( pGadget->IsKindOf(CLASSINFO(wxListBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) ||
        pGadget->IsKindOf(CLASSINFO(wxChoice)) )
    {
        // Support listboxes with multiple selections
        if (pGadget->IsKindOf(CLASSINFO(wxListBox)))
        {
            ((wxListBox *)pGadget)->GetSelections(sels);
        }
        else if (pGadget->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)))
        {
            sels[0]=((wxOwnerDrawnComboBox *)pGadget)->GetSelection();
        }
        else
        {
            sels[0]=((wxControlWithItems *)pGadget)->GetSelection();
        }

        size_t Count = sels.GetCount();

        pList = new INT32[Count+1];

        if (pList)
        {
            UINT32 i;
            for (i=0; i<Count; i++)
            {
                pList[i]=sels[i];
            }
            pList[Count] = -1;  // terminate the list
        }

        return pList; // may be NULL if no memory

    }
    return NULL;
}

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

>   BOOL DialogManager::GetValueIndex(CWindowID WindowID,
                                    CGadgetID Gadget,
                                    INT32* Index)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> / Jason (Based on Simon's stuff...)
    Created:    11/10/95
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier

    Outputs:    Index:          The index of the currently selected item in the gadget. The
                                index value starts at 0 for the first item in the list.

                                THIS CAN NOW RETURN -1 AS IT SHOULD ALWAYS OF BEEN ABLE TO DO !!!

    Returns:    TRUE if the index value could be read, else FALSE.

    Purpose:    For finding the index of the currently selected item in a gadget

                For Windows
                -----------

                The function can be called for ListBox and ComboBox controls

    Errors:     If the function is called on an invalid gadget then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    Notes:      ALWAYS USE THIS ONE IN PREFERENCE TO THE WORD ONE, IE ALWAYS PASS A INT32 IN,
                NOT A WORD !!!

                This function now works internally as well, since comparing a INT32 -1 with a
                word -1 didn't work out too well...

    SeeAlso:    DialogOp::GetValueIndex

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

BOOL DialogManager::GetValueIndex(CWindowID WindowID,
                                CGadgetID Gadget,
                                INT32* Index)
{
    INT32 index = GetFirstSelectedItem(WindowID, Gadget);
    if (Index) *Index=index;
    TRACEUSER("amb", _T("Index is %d"),index);
    return TRUE;
}


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

>   BOOL DialogManager::GetValueIndex(CWindowID WindowID,
                                    CGadgetID Gadget,
                                    WORD* Index)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    9/9/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier

    Outputs:    Index:          The index of the currently selected item in the gadget. The
                                index value starts at 0 for the first item in the list.

    Returns:    TRUE if the index value could be read, else FALSE.

    Purpose:    For finding the index of the currently selected item in a gadget

                For Windows
                -----------

                The function can be called for ListBox and ComboBox controls
                (including our custom combobox cc_1dBitmapComboBoxEdit)

    Errors:     If the function is called on an invalid gadget then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::GetValueIndex

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

BOOL DialogManager::GetValueIndex(CWindowID WindowID,
                                CGadgetID Gadget,
                                WORD* Index)
{
    if (Index) *Index=GetFirstSelectedItem(WindowID, Gadget);
    return TRUE;
}



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

>   BOOL DialogManager::AddDialogControlToHelper(CWindowID WindowID, CGadgetID Gadget)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    14/7/2000
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier
    Outputs:
    Returns:    TRUE if successful, else FALSE
    Purpose:    To add this control to the static dialog control helper, which will subclass it

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

BOOL DialogManager::AddDialogControlToHelper(CWindowID WindowID, CGadgetID Gadget)
{
    // For the time being, we do this by Hide/Unhide
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;
    pGadget->Show(TRUE);
    return TRUE;
}


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

>   BOOL DialogManager::RemoveDialogControlFromHelper(CWindowID WindowID, CGadgetID Gadget)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    14/7/2000
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier
    Outputs:
    Returns:    TRUE if successful, else FALSE
    Purpose:    To add this control to the static dialog control helper, which will subclass it

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

BOOL DialogManager::RemoveDialogControlFromHelper(CWindowID WindowID, CGadgetID Gadget)
{
    // For the time being, we do this by Hide/Unhide
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;
    pGadget->Show(FALSE);
    return TRUE;
}

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

>   BOOL DialogManager::EnableGadget(CWindowID WindowID, CGadgetID Gadget, BOOL Enabled);

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/9/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier
                Enabled:        TRUE if the gadget is to be enabled.
                                FALSE if the gadget is to be disabled.
    Outputs:
    Returns:    TRUE if successful, else FALSE
    Purpose:    For enabling/disabling a gadget.

                For Windows
                -----------

                This function can be called for all controls

    Errors:     -
    SeeAlso:    DialogOp::EnableGadget

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

BOOL DialogManager::EnableGadget(CWindowID WindowID, CGadgetID Gadget, BOOL Enabled)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;
    pGadget->Enable( FALSE != Enabled );
    return (TRUE);
}

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

>   void DialogManager::SetGadgetWritable(CWindowID id, BOOL enable)

    Author:     DMC
    Created:    15/11/94
    Inputs:     id, the 'IDC_?' of the control.
                enable, TRUE to allow the control to be typed into. FALSE to make it
                        read only.
    Purpose:    Sets the state of the 'Read Only' flag of an edit field or combo box.

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

BOOL DialogManager::SetGadgetWritable(CWindowID WindowID, CGadgetID Gadget, BOOL enable)
{
    // Get the window handle of the gadget, from the gadget ID
    wxWindow*           pGadget = GetGadget( WindowID, Gadget );
    if( !pGadget )
        return FALSE;

    if( pGadget->IsKindOf( CLASSINFO(wxTextCtrl) ) )
        ( (wxTextCtrl*)pGadget )->SetEditable( FALSE != enable );
    else
    {
PORTNOTETRACE("other", "Removed SetGadgetWritable handling of on TextCtrl");
#ifndef EXCLUDE_FROM_XARALX
        // See if it's got a child window (it may be a Combo Box)
        HWND hEdit = ::ChildWindowFromPoint(gadget, CPoint(1,1));

        if (hEdit)              // Was there a child window ?
            gadget = hEdit;     // Yes, so send the message to it

        if (enable)
            ::SendMessage(gadget, EM_SETREADONLY, FALSE, 0);    // Clear the Read Only Flag
        else
            ::SendMessage(gadget, EM_SETREADONLY, TRUE, 0);     // Set the Read Only Flag
#else
        return FALSE;
#endif
    }

    return TRUE;
}

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

>   BOOL DialogManager::IsGadgetEnabled( CWindowID WindowID, CGadgetID Gadget );

    Author:     Luke_Hart (Xara Group Ltd) <lukeh@xara.com>
    Created:    07/09/06
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:         Gadget identifier
    Outputs:
    Returns:    TRUE if enabled, else FALSE
    Purpose:    For checking if a gadget is enabled/disabled.

    Errors:     -
    SeeAlso:    DialogOp::IsGadgetEnabled

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

BOOL DialogManager::IsGadgetEnabled( CWindowID WindowID, CGadgetID Gadget )
{
    wxWindow*           pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget)
        return FALSE;
    
    return pGadget->IsEnabled();
}


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

>   BOOL DialogManager::HideGadget(CWindowID WindowID, CGadgetID Gadget, BOOL Hide)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/9/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier
                Enabled:        TRUE if the gadget is to be hidden.
                                FALSE if the gadget is to be shown.
    Outputs:    -
    Returns:    TRUE if successful, else FALSE
    Purpose:    For hiding/showing gadgets

                For Windows
                -----------

                This function can be called for all controls

    Errors:     -
    SeeAlso:    DialogOp::HideGadget

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

BOOL DialogManager::HideGadget(CWindowID WindowID, CGadgetID Gadget, BOOL Hide)
{
    // For the time being, we do this by Hide/Unhide
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;
    pGadget->Show(!Hide);
    return TRUE;
}

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

>   void DialogManager::Layout(CWindowID WindowID, BOOL CanYield=FALSE)

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    10/05/2006
    Inputs:     WindowID:       Dialog box window identifier
    Outputs:    -
    Returns:    -
    Purpose:    Relayout dialog - for sizer changes
    Errors:     -
    SeeAlso:    -

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

void DialogManager::Layout(CWindowID WindowID, BOOL CanYield /*=FALSE*/)
{
    ((wxWindow *)WindowID)->Layout();
    if (CanYield)
    {
        // wxWidgets needs a yield to process these, but we can't always yield
        wxWindowDisabler(WindowID);
        wxYieldIfNeeded();
    }
}

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

>   BOOL DialogManager::GadgetRedraw(CWindowID WindowID, CGadgetID Gadget, BOOL Redraw)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    9/9/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:     Gadget identifier
                Redraw:         TRUE to turn on gadget redraw
                                FALSE to turn off gadget redraw
    Outputs:    -
    Returns:    TRUE if successful, else FALSE
    Purpose:    This function sets a gadgets redraw state. If Redraw = FALSE then the gadget
                will not be redrawn when changes are made to it. Conversely if Redraw = TRUE
                then the Gadget will redraw itself after any changes are made.

                For Windows
                -----------

                This function can be called for all controls

    Errors:     -
    SeeAlso:    DialogOp::GadgetRedraw

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

BOOL DialogManager::GadgetRedraw(CWindowID WindowID, CGadgetID Gadget, BOOL Redraw)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    if( Redraw )
    {
        pGadget->Thaw();
    }
    else
    {
        pGadget->Freeze();
    }

    return TRUE;
}



/********************************************************************************************
>   static BOOL DialogManager::SetKeyboardFocus(CWindowID WindowID, CGadgetID Gadget)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/11/94
    Inputs:     WindowID            ID of the window / dialogue box containing . . .
                Gadget          ID of the "gadget" (control) to receive the focus
    Outputs:    -
    Returns:    TRUE if successful.
    Purpose:    Sets the keyboard focus to the given control.
    Errors:     -
    SeeAlso:    DialogManager::DefaultKeyboardFocus; DialogOp::SetKeyboardFocus
********************************************************************************************/

BOOL DialogManager::SetKeyboardFocus(CWindowID WindowID, CGadgetID Gadget)
{
    // Set the focus to the control within the given window/dialogue box.
    // For the time being, we do this by Hide/Unhide
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    pGadget->SetFocus();
    return TRUE;
}



/********************************************************************************************
>   static BOOL DialogManager::CaptureMouse(CWindowID WindowID, CGadgetID Gadget)

    Author:     Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/04/97
    Inputs:     WindowID            ID of the window / dialogue box containing . . .
                Gadget          ID of the "gadget" (control) to receive the focus
    Outputs:    -
    Returns:    TRUE if successful.
    Purpose:    Allows the given control to Capture the mouse.
    Errors:     -
    SeeAlso:    DialogManager::DefaultKeyboardFocus; DialogOp::SetKeyboardFocus
********************************************************************************************/

BOOL DialogManager::CaptureMouse(CWindowID WindowID, CGadgetID Gadget)
{
    // Set the focus to the control within the given window/dialogue box.
    // For the time being, we do this by Hide/Unhide
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    pGadget->CaptureMouse();
    return TRUE;
}



/********************************************************************************************
>   static BOOL DialogManager::ReleaseMouse(CWindowID WindowID, CGadgetID Gadget)

    Author:     Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/04/97
    Inputs:     WindowID            ID of the window / dialogue box containing . . .
                Gadget          ID of the "gadget" (control) to receive the focus
    Outputs:    -
    Returns:    TRUE if successful.
    Purpose:    Release the mouse captured by the given control
    Errors:     -
    SeeAlso:    DialogManager::DefaultKeyboardFocus; DialogOp::SetKeyboardFocus
********************************************************************************************/

BOOL DialogManager::ReleaseMouse(CWindowID WindowID, CGadgetID Gadget)
{
    // get the handle off the control
    // For the time being, we do this by Hide/Unhide
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    // Check whether the control has the mouse capture
    if( wxWindow::GetCapture() == pGadget )
    {
        pGadget->ReleaseMouse();
        return TRUE;
    }
    else
        return FALSE;
}



/********************************************************************************************
>   static BOOL DialogManager::DefaultKeyboardFocus()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/11/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if successful.
    Purpose:    Sets the keyboard focus to the "default" window, which currently is the
                main frame window (which in turn sets it to the active view window).
    Errors:     -
    SeeAlso:    DialogManager::SetKeyboardFocus; DialogOp::SetKeyboardFocus
********************************************************************************************/

BOOL DialogManager::DefaultKeyboardFocus()
{
    // Set the focus to the main window, which will in turn set it to the active view.
    GetMainFrame()->SetFocus();
    return TRUE;
}



/********************************************************************************************
>   static BOOL DialogManager::HighlightText(CWindowID WindowID, CGadgetID Gadget,
                                            INT32 nStart = 0, INT32 nEnd = -1)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/11/94
    Inputs:     WindowID            Window/dialogue box ID (handle)
                Gadget          control ID within the window/dialogue box
                nStart          first letter to highlight (by default the very first)
                nEnd            last letter to highlight (by default the very last)
    Outputs:    -
    Returns:    TRUE if successful
    Purpose:    Highlights the given range of text (by default all of it) within a
                control that holds editable text, eg. an edit field.
    Errors:     ERROR3 if you try to highlight text in a control without any, eg. a
                button or a scroller.
    SeeAlso:    DialogOp::HighlightText
********************************************************************************************/

BOOL DialogManager::HighlightText(CWindowID WindowID, CGadgetID Gadget, INT32 nStart, INT32 nEnd)
{
    // Find out the window class of the control.  Only those with editable text can
    // be highlighted.
    // For the time being, we do this by Hide/Unhide
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

#ifdef _DEBUG
    ERROR3IF( !pGadget->IsKindOf( CLASSINFO(wxListBox) ) &&
        !pGadget->IsKindOf( CLASSINFO(wxComboBox) ) &&
        !pGadget->IsKindOf( CLASSINFO(wxOwnerDrawnComboBox) ) &&
        !pGadget->IsKindOf( CLASSINFO(wxTextCtrl) ),
                "Wrong kind of control in DialogManager::HighlightText");
#endif

    if( pGadget->IsKindOf( CLASSINFO(wxTextCtrl) ) )
    {
        ( (wxTextCtrl *)pGadget )->SetSelection( -1, -1 );
    }
    else if( pGadget->IsKindOf( CLASSINFO(wxComboBox) ) )
    {
        ( (wxComboBox *)pGadget )->SetSelection( -1, -1 );
    }
    else if( pGadget->IsKindOf( CLASSINFO(wxOwnerDrawnComboBox) ) )
    {
        ( (wxOwnerDrawnComboBox *)pGadget )->SetSelection( -1 );
    }

    return TRUE;
}



/********************************************************************************************
>   static void DialogManager::PaintGadgetNow(CWindowID WindowID, CGadgetID gid)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/9/94
    Inputs:     WindowID            Window identifier
                gid         Gadget (control) identifier,  or zero for the whole window
    Outputs:    -
    Returns:    -
    Purpose:    Immediate paints any invalid areas of the given control (like the Windows
                "UpdateWindow" function).
    Errors:     -
    SeeAlso:    -
********************************************************************************************/

void DialogManager::PaintGadgetNow(CWindowID WindowID, CGadgetID Gadget)
{
    if (!Gadget)
    {
        ((wxWindow *)WindowID)->Update();
        wxPlatformDependent::Get()->FixUpdate((wxWindow *)WindowID);
        return;
    }
    // For the time being, we do this by Hide/Unhide
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return;

    pGadget->Update();
    wxPlatformDependent::Get()->FixUpdate(pGadget);
}



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

>   static void DialogManager::InvalidateGadget(CWindowID WindowID, CGadgetID Gadget, BOOL EraseBackground)

    Author:     Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/10/94
    Inputs:     WindowID - The Window identifier
                Gadget - The control that requires invalidating
    Purpose:    Invalidates the control so that it will be repainted soon.

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

void DialogManager::InvalidateGadget(CWindowID WindowID, CGadgetID Gadget, BOOL EraseBackground /*=TRUE*/)
{
    if (!Gadget)
    {
        ((wxWindow *)WindowID)->Refresh(EraseBackground);
        return;
    }
    // For the time being, we do this by Hide/Unhide
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return;

    pGadget->Refresh(EraseBackground);
}



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

>   static void DialogManager::InvalidateGadget(CWindowID WindowID, CGadgetID Gadget,
                                                RedrawInfoType *ExtraInfo,
                                                DocRect *InvalidRect);

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/11/94
    Inputs:     WindowID - The Window identifier
                Gadget - The ID of the gadget that you want to be redrawn

                ExtraInfo - The information passed to your DIM_ mouse event handler

                InvalidRect - The MILLIPOINT rectangle to invalidate, in the (0,0)->(dx,dy)
                coordinate space used in ReDrawInfoType structures. (or NULL to invalidate
                the entire window)

    Purpose:    Causes the Dialog Manager to tell the host os to get the cc_DialogDraw
                gadget to be redrawn, over the specfied rectangle. You should recieve
                a DIM_REDRAW message in the not too distant future.

    Notes:      If you are using a Virtual coordinate space which differs from the
                (0,0)->(dx,dy) space that this requires, then you'll need to call
                some conversion methods which do not yet exist!

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

void DialogManager::InvalidateGadget(CWindowID WindowID, CGadgetID Gadget,
                                        ReDrawInfoType *ExtraInfo,
                                        DocRect *InvalidRect)
{
    if (InvalidRect == NULL)    // No rect - invalidate the entire window
    {
        InvalidateGadget(WindowID, Gadget);
        return;
    }

    if (ExtraInfo == NULL || WindowID == 0)
    {
        ERROR2RAW("DialogManager::InvalidateGadget was passed illegal NULL parameter(s)");
        return;
    }

    ERROR3IF(ExtraInfo->Dpi == 0, "Screen DPI is zero? I think not! Divide-by-zeros imminent!");
    if (!ExtraInfo->Dpi) return;

    INT32 PixelSize = 72000 / ExtraInfo->Dpi;       // Size of a pixel in MILLIPOINTS

    DocRect irect=*InvalidRect;
    if (irect.lo.y > irect.hi.y)
    {
        // not an ERROR3 because this is in rendering code
        TRACEALL( _T("Rectangle upside down in InvalidateGadget\n") );
        // swap over the rect Y co-ords
        INT32 temp=irect.lo.y;
        irect.lo.y=irect.hi.y;
        irect.lo.y=temp;
    }

    wxRect ToRedraw(irect.lo.x / PixelSize, (ExtraInfo->dy-irect.hi.y) / PixelSize,
                    (irect.hi.x-irect.lo.x) / PixelSize, (irect.hi.y-irect.lo.y)/PixelSize);

    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    // Invalidate the gadget, but only if we found a legal window to invalidate
    ERROR3IF((!pGadget), "DialogManager::InvalidateGadget - Gadget not valid");

    if (pGadget)
    {
        // GTK seems a bit precious about invalid coordinates, so clip to the client size
        wxRect GadgetRect(pGadget->GetClientSize());
        ToRedraw=ToRedraw.Intersect(GadgetRect);
        pGadget->Refresh(TRUE, &ToRedraw);
    }
}


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

>   static void DialogManager::ScrollKernelRenderedGadget(CWindowID WindowID, CGadgetID Gadget,
                                                DocRect *RectToScroll, DocCoord *ScrollBy)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/1/95
    Inputs:     WindowID - The Window identifier
                Gadget - The ID of the gadget that you want to be redrawn

                RectToScroll - The MILLIPOINT rectangle to scroll, in the (0,0)->(dx,dy)
                coordinate space used in ReDrawInfoType structures. Think of this rectangle
                as the visible portion of the window which will be copied (some of which
                will be scrolled out of view), and let this method worry about invalidating
                the 'hole' left behind to finish off the display.
                This parameter may be NULL, in which case the entire gadget will be scrolled

                ScrollBy - Gives the X and Y amounts in millipoints to scroll the given
                rectangle. I don't know what will happen if neither of these values is zero!

    Outputs:    ScrollBy will be returned with the x and y values grid-locked to the
                underlying display-pixel grid. If you do not use the returned values to
                update your millipoint scroll position, your scroll position will get out
                of sync with the displayed image, and you'll be screwed.

    Purpose:    Causes the Dialog Manager to tell the host os to get the cc_DialogDraw
                gadget to be scrolled, over the specfied rectangle. You should recieve
                a DIM_REDRAW message in the not too distant future, to update any portions
                that 'scroll into view'.

    Notes:      If you are using a Virtual coordinate space which differs from the
                (0,0)->(dx,dy) space that this requires, then you'll need to convert
                your coords.

                If ScrollBy is such that the entire visible region will be scrolled out of
                view, this ends up just invalidating the scrollrect.

                I have not tried scrolling an entire window with this method, so it may
                be that it doesn't work properly (it should work, but you might need to
                set up a proper clipping rectangle to stop masty redraw effects)

                To produce the best results, you should udate your scroll position after
                calling this method and immediately call PaintGadgetNow to minimise the
                time for which the window layout is in a state of flux.

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

void DialogManager::ScrollKernelRenderedGadget(CWindowID WindowID, CGadgetID Gadget,
                                                DocRect *RectToScroll, DocCoord *ScrollBy)
{
    ERROR3IF(ScrollBy == NULL || WindowID == 0 || Gadget == 0,
            "DialogManager::ScrollKernelRenderedGadget - NULL Params are illegal");

    // For the time being, we do this by Hide/Unhide
    wxWindow * pWinToScroll = GetGadget(WindowID, Gadget);
    if (!pWinToScroll) return;

    ERROR3IF( pWinToScroll == 0,
        "DialogManager::ScrollKernelRenderedGadget - Illegal window/gadget");

    if( pWinToScroll == 0 )
        return;

    ReDrawInfoType ExtraInfo;
    GetKernelRenderedGadgetInfo(WindowID, Gadget, &ExtraInfo);

    INT32 PixelSize = 72000 / ExtraInfo.Dpi;        // Size of a pixel in MILLIPOINTS

    INT32 ScrollDX = ScrollBy->x / PixelSize;
    INT32 ScrollDY = ScrollBy->y / PixelSize;

    // Grid-lock the scroll offsets to a multiple of device pixels in size, for return
    ScrollBy->x = ScrollDX * PixelSize;
    ScrollBy->y = ScrollDY * PixelSize;

    if (abs(ScrollBy->x) >= RectToScroll->Width() ||
        abs(ScrollBy->y) >= RectToScroll->Height())
    {
        // Have scrolled far enough that none of the currently visible stuff will be
        // visible after scrolling, so just force redraw the affected rectangle
        // (Actually, the 'else' part should get this right anyway, but I don't
        // want to have to test everything on 6 billion OSes, and it's probably
        // marginally more efficient this way)
        InvalidateGadget(WindowID, Gadget, &ExtraInfo, RectToScroll);
    }
    else
    {
        if (RectToScroll != NULL)
        {
            // Get the base scroll area in Windows OS coords
            wxRect      BaseRect;
            BaseRect.x      = RectToScroll->lo.x / PixelSize;
            BaseRect.width  = ( RectToScroll->hi.x - RectToScroll->lo.x ) / PixelSize;
            BaseRect.y      = ( ExtraInfo.dy - RectToScroll->hi.y ) / PixelSize;
//          BaseRect.height = ( ExtraInfo.dy + RectToScroll->lo.y - RectToScroll->hi.y ) / PixelSize;
            BaseRect.height = ( RectToScroll->hi.y - RectToScroll->lo.y ) / PixelSize;

            // Copy the scroll area contents with a blit, and invalidate the 'hole'
            pWinToScroll->ScrollWindow( -ScrollDX, -ScrollDY, &BaseRect );
        }
        else
        {
            // Just scroll the entire window client area
            pWinToScroll->ScrollWindow( -ScrollDX, -ScrollDY, NULL );
        }
    }
}



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

>   static BOOL DialogManager::GetKernelRenderedGadgetInfo(CWindowID WindowID, CGadgetID Gadget,
                                                            ReDrawInfoType *Result)

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

    Inputs:     WindowID - The parent window identifier
                Gadget - The ID of the gadget that you want info for

    Returns:    FALSE if there was a catastrophic error (it will report an ERROR2 if necessary),
                in which case the returned data is invalid (well, it defaults to 96 Dpi and
                an area of 72000x72000 millipoints, so is 'safe' to use, but probably wrong)
                TRUE under normal conditions

    Outputs:    Result - will be returned filled in with appropriate kernel-rendered-
                dialogue information (dx, dy, and Dpi will be filled in with the appropriate
                values; pMousePOs, pDC, and pClipRect will all be NULL)

    Purpose:    Allows the user access to the same information which is passed in to
                DIM_REDRAW and the kernel-rendered-dialogue mouse-handling messages. This
                is just for convenience so they can calculate stuff at a time other than
                handling those two types of dialogue event (e.g. if a document message
                causes you to have to redraw a small portion of your gadget, you need this
                information to calculate the invalidation rectangle from)

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

BOOL DialogManager::GetKernelRenderedGadgetInfo(CWindowID WindowID, CGadgetID Gadget,
                                                ReDrawInfoType *Result)
{
    ERROR3IF(WindowID == 0 || Gadget == 0 || Result == NULL,
        "DialogManager::GetKernelRenderedGadgetInfo: NULL parameters are illegal!");

    // For the time being, we do this by Hide/Unhide
    wxWindow * pTheWindow = GetGadget(WindowID, Gadget);
    if (!pTheWindow) return FALSE;

    Result->pDC = NULL;
    Result->pClipRect = NULL;
    Result->pMousePos = NULL;

    // Install some 'safe' defaults, just in case of serious error
    Result->dx = Result->dy = 72000;
    Result->Dpi = 96;

    // If a totally rampant call, error (debug) and return failure
    ERROR3IF( NULL == pTheWindow,
                "DialogManager::GetKernelRenderedGadgetInfo - Illegal window/gadget");
    if( pTheWindow == 0 )
        return(FALSE);

    // Get the screen DPI
    wxScreenDC          ScreenDC;
PORTNOTE("dialog","Can't handle different DPIs, using X")
    Result->Dpi = OSRenderRegion::GetFixedDCPPI(ScreenDC).x; // x;

    // Calculate how big the window is, in MILLIPOINTS
    wxSize              WindowSize( pTheWindow->GetClientSize() );

    Result->dx = ( INT32(WindowSize.GetWidth())*72000 ) / Result->Dpi;
    Result->dy = ( INT32(WindowSize.GetHeight())*72000) / Result->Dpi;
    return(TRUE);
}




// -----------------------------------------------------------------------------------------
// Message handler functions

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

>   static void DialogManager::SetGadgetIDToFocus(HWND DialogWnd)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/4/94
    Inputs:     DialogWnd: The dialog window
    Outputs:    -
    Returns:    -
    Purpose:    If a child control of the dialog window has the focus then the function
                sets the Gadget to the ID of this control.

    Scope:      private
    Errors:     -
    SeeAlso:    -

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

void DialogManager::SetGadgetIDToFocus( wxWindow *pDialogWnd )
{
    PORTNOTETRACE("dialog","DialogManager::SetGadgetIDToFocus - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    // Determine which gadget has the focus
    wxWindow           *pFocusWindow = wxWindow::FindFocus();

    // If the Focus Window is a child of the dialog window then set Gadget equal
    // to the control ID of this window
    wxWindow           *pCurrentChild;
    wxWindowList       &listChild = pDialogWnd->GetChildren();
    wxWindowList::iterator iter = listChild.begin();
    wxWindowList::iterator end = listChild.end();
    for(;
        iter != end;
        ++iter )
    {
        if( CurrentChild == FocusWindow )
        {
            // The focus is with a gadget
            Gadget = GetDlgCtrlID( FocusWindow );
            break;
        }
    }
#endif
}
/********************************************************************************************

>   static BOOL CustomControlMsg(HWND hdlg, UINT32 wParam, INT32 lParam)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/4/94
    Inputs:     hdlg: Dialog HWND
    Outputs:    -
    Returns:    TRUE if message handled
    Purpose:    Handles custom control messages
    Errors:     -
    SeeAlso:    -

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

BOOL DialogManager::CustomControlMsg( wxWindow *pDlg, UINT32 wParam, INT32 lParam )
{
    PORTNOTETRACE("dialog","DialogManager::CustomControlMsg - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    String_256 ClassNameStr;
    GetClassName( HWND(lParam), (TCHAR*)ClassNameStr, 255);
    if ((ClassNameStr == String_16(TEXT("cc_BitmapButton")))||
        ClassNameStr == String_16(TEXT("cc_SmallButton")))
    {
        Gadget = HIWORD(wParam);
        switch (LOWORD(wParam))
        {
        case BN_CLICKED:
            DialogManager::DIM = DIM_LFT_BN_CLICKED;
            DialogManager::HandleMessage = TRUE;
            return TRUE;

        case BN_BUTTONUP:
            DialogManager::DIM = DIM_LFT_BN_UP;
            DialogManager::HandleMessage = TRUE;
            return TRUE;

        case WM_MOUSEMOVE:
            DialogManager::DIM = DIM_MOUSE_MOVE;
            DialogManager::HandleMessage = TRUE;
            return TRUE;


        default:
            TRACEUSER( "JustinF", _T("Unknown message ID in DialogManager::CustomControlMsg\n"));
            break;
        }
    }
#endif
    return FALSE; // Not a custom control message
}

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

>   void DialogManager::EnableAllDialogs(BOOL Enable, HWND ExceptMe = NULL)

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

    Inputs:     Enable: When TRUE all dialogs are enabled

                ExceptMe: An optional dialog to exclude. If a modal dialog X has just
                        been created then all dialogs except X will need disabling
    Outputs:    -
    Returns:    -
    Purpose:    Enables or Disables all Dialogs on the DialogOp message handler list.
                This is useful when opening/closing modal dialogs.

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

void DialogManager::EnableAllDialogs( BOOL Enable, wxWindow *pExceptMe )
{
    // Obtain a list of all live dialogs
    List               *pDlgList = MessageHandler::GetClassList( CC_RUNTIME_CLASS(DialogOp) );

    ERROR3IF( pDlgList == NULL, "Could not find the DialogOp Class List" );
    if( NULL != pDlgList )
    {
        ListItem       *CurrentOp = pDlgList->GetHead();
        DialogOp       *pDlgOp;
        while( CurrentOp != NULL )
        {
            if (CurrentOp->IS_KIND_OF(DialogOp)) // They all should be
            {
                pDlgOp = (DialogOp*)CurrentOp;
                // Determine if the dialog has an associated window
                if (pDlgOp->HasWindow())
                {
                    if (pDlgOp->WindowID != pExceptMe)
                    {
                        ( (wxWindow *)pDlgOp->WindowID )->Enable( FALSE != Enable );
                    }
                }
            }
            CurrentOp = pDlgList->GetNext(CurrentOp); // Get next operation in the live list
        }
    }

    // For some reason, the green bit of code below did not disable common dialogs. Therefore
    // the semi-bodge below was added to disable the active window.

    wxWindow           *pActiveWindow = wxWindow::FindFocus();
    if( NULL != pActiveWindow )
    {
        if( pActiveWindow != pExceptMe )
        {
            pActiveWindow->Enable( FALSE != Enable );
        }
    }
}



// End of Message handler functions
// ----------------------------------------------------------------------------------------

// Methods for setting the types of edit fields
// ----------------------------------------------------------------------------------------

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

>   void DialogManager::SetEditGadgetType(CWindowID WindowID,
                                    CGadgetID Gadget,
                                    EditGadgetType Type)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/8/93
    Inputs:     WindowID:   Dialog box window identifier
                Gadget:     The edit gagdet identifier
                Type:       The type of the edit gadget

                UNIT_NUMERIC: Only accept unit chars
                INT_NUMERIC:  Only accept integer chars
                REAL_NUMERIC: Only accept real chars
    Outputs:    -
    Returns:    -
    Purpose:    Subclasses the edit gadget so that it only accepts characters specified by
                the Type parameter.
    Errors:     -
    SeeAlso:    DialogOp::SetEditGadgetType

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


void DialogManager::SetEditGadgetType(CWindowID Win,
                                    CGadgetID Gadget,
                                    EditGadgetType Type)
{
    UINT32 IDSValidChars=0; // Resource ID of valid input characters
    switch (Type)
    {
        // Obtain the resource of the string containing the set of characters which the
        // control should accept.
        case UNIT_NUMERIC: IDSValidChars = _R(IDS_UNIT_NUMERIC_CHARS); break;
        case INT_NUMERIC: IDSValidChars = _R(IDS_INT_NUMERIC_CHARS);   break;
        case REAL_NUMERIC: IDSValidChars = _R(IDS_REAL_NUMERIC_CHARS); break;
    };
    SetEditGadgetType(Win, Gadget, IDSValidChars);
}

// A quick subclass hack to fix requirement that wxTextValidator has data storage
class wxTextValidatorFixed : public wxTextValidator
{
    DECLARE_DYNAMIC_CLASS(wxTextValidatorFixed);
public:
    wxTextValidatorFixed(/*TYPENOTE: Correct*/ long style = wxFILTER_NONE, wxString *val = 0) : wxTextValidator(style, val) {}
    wxTextValidatorFixed(const wxTextValidator& val) : wxTextValidator(val) {}
    ~wxTextValidatorFixed(){}
    virtual wxObject *Clone() const { return new wxTextValidatorFixed(*this); }
    virtual bool TransferToWindow(void) /*TYPENOTE: Correct*/
    {   
        if ( m_stringValue )
        {
            if( !CheckValidator() ) return false;           /*TYPENOTE: Correct*/
            wxTextCtrl *control = (wxTextCtrl *) m_validatorWindow;
            control->SetValue(* m_stringValue);
        }
    return true;                                            /*TYPENOTE: Correct*/
    }
    virtual bool TransferFromWindow(void)   /*TYPENOTE: Correct*/
    {
        if ( m_stringValue )
        {
            if( !CheckValidator() ) return false;           /*TYPENOTE: Correct*/
            wxTextCtrl *control = (wxTextCtrl *) m_validatorWindow;
            *m_stringValue = control->GetValue();
        }
        return true;                                        /*TYPENOTE: Correct*/
    }
};
IMPLEMENT_DYNAMIC_CLASS(wxTextValidatorFixed, wxTextValidator);

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

>   void DialogManager::SetEditGadgetType(CWindowID WindowID,
                                        CGadgetID Gadget,
                                        UINT32 IDSValidChar)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/8/93
    Inputs:     WindowID:       Dialog box window identifier
                Gadget:         The edit gagdet identifier
                IDSValidChar:   Resource ID of the string containing the set of characters
                                that the edit gadget should accept.

    Outputs:    -
    Returns:    -
    Purpose:    To subclass the edit gadget so that it only accepts characters in the string
                specified by IDSValidChar
    Errors:     -
    SeeAlso:    DialogOp::SetEditGadgetType

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


void DialogManager::SetEditGadgetType(CWindowID WindowID,
                                CGadgetID Gadget,
                                UINT32 IDSValidChar)
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return;

    String_256 s;
    if (!s.Load(IDSValidChar))
    {
        ERROR3("Could not load validator string");
        return;
    }
    wxArrayString valstring;
    TCHAR * p = (TCHAR *)s;
    TCHAR c;
    while ((c=*p++)!=0)
    {
        valstring.Add(wxString(c));
    }
    wxTextValidatorFixed validator(wxFILTER_INCLUDE_CHAR_LIST);
    validator.SetIncludes(valstring);
    pGadget->SetValidator(validator);
}

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

>   void DialogManager::DualFunctionButton(CWindowID DialogWnd,
                                    CGadgetID ButtonGadget)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/9/93
    Inputs:     DialogWnd:      Dialog box window identifier
                ButtonGadget:   Button gadget identifier
    Outputs:    -
    Returns:    -
    Purpose:    To subclass the button gadget so that it accepts right mouse button clicks.
    Errors:     -
    SeeAlso:    DialogOp::DualFunctionButton

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

void DialogManager::DualFunctionButton(CWindowID DialogWnd,
                                    CGadgetID ButtonGadget)
{
    PORTNOTETRACE("dialog","DialogManager::DualFunctionButton - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    // This function should only be called for a button control
    HWND hGadget = GetDlgItem((HWND)DialogWnd, (INT32)ButtonGadget);
    #if _DEBUG
    String_256 ClassNameStr;
    GetClassName(hGadget, (TCHAR*)ClassNameStr, 255);

    ENSURE((ClassNameStr == String_8(TEXT("Button"))), "DualFunctionButton function called\n"
                                                    "on a gadget which is not a button");
    #endif

    ControlInfo* ControlInfoPtr;               // This structure will be passed to the
                                            // RgtMOuseButtonProc.

    ControlInfoPtr = new ControlInfo;
    ControlInfoPtr->pControlWnd = hGadget;
    ControlInfoPtr->lpfnOldProc = (FARPROC) GetWindowLong(hGadget, GWL_WNDPROC);

    // Store the button control info in the dialog's Edit control info list
    GetControlList( DialogWnd )->AddHead(ControlInfoPtr);

    FARPROC lpfnDualFn = MakeProcInstance((FARPROC) DialogManager::RgtMouseButtonProc,
                                        AfxGetApp()->m_hInstance);

    // Subclass the control so that it calls the new button proc
    SetWindowLong(hGadget, GWL_WNDPROC, (INT32) lpfnDualFn );
#endif
}

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

>   BOOL DialogManager::MakeListBoxDragable(CWindowID DialogWnd,
                                            CGadgetID ListGadget)


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/12/93
    Inputs:     DialogWnd:  The dialogbox window identifier
                ListGadget: The Identifier of a listbox gadget
    Outputs:    -
    Returns:    TRUE if successful, otherwise FALSE
    Purpose:
    Errors:     An ENSURE failure will occur if ListGadget is not a ListBox control
    SeeAlso:    DialogOP::MakeListBoxDragable

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


BOOL DialogManager::MakeListBoxDragable(CWindowID WindowID,
                                        CGadgetID Gadget)
{
    // This function should only be called for a LISTBOX control
    // For the time being, we do this by Hide/Unhide
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;
#if _DEBUG
    ENSURE( pGadget->IsKindOf( CLASSINFO( wxListBox ) ),
            "MakeListBoxDragable function called\non a gadget which is not a Listbox" );
#endif

    return TRUE;                                        // pretend worked
}


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

>   INT32 FAR PASCAL EXPORT DialogManager::ValidateEditGadgetProc(HWND hwnd,
                                                                UINT32 message,
                                                                UINT32 wParam,
                                                                INT32 lParam)


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/8/93
    Inputs:     hwnd
                message
                wParam
                lParam
    Outputs:    -
    Returns:    -
    Purpose:    subclassed edit control proc
    Errors:     -
    SeeAlso:    -

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

INT32 FAR PASCAL EXPORT DialogManager::ValidateEditGadgetProc( wxWindow *pWnd,
                                                            UINT32 message,
                                                            UINT32 wParam,
                                                            INT32 lParam)
{
    PORTNOTETRACE("dialog","DialogManager::DualFunctionButton - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    // We need to access the control's dialog window to find the valid characters the control
    // should accept.

    HWND DlgWin = GetParent(hwnd);

    // --------------------------------------------------------------------------------------
    // Search the dialog's edit control list to find the information about the control
    List* ControlInfoList = GetControlList(DlgWin);
    ControlInfo* CurrentCntrl = (ControlInfo*)ControlInfoList->GetHead();
    // The lookup must be as quick as possible
    while (CurrentCntrl != NULL)
    {
        if (CurrentCntrl->ControlWnd == hwnd)
            break;
        CurrentCntrl = (ControlInfo*)ControlInfoList->GetNext(CurrentCntrl);
    }

    ENSURE(CurrentCntrl != NULL, "Could not find information for a typed edit control");

    // Load in the valid input characters for the edit control
    String_256 ValidChars;
    ValidChars.Load(CurrentCntrl->IDSValidCh, NULL);

    if (message == WM_CHAR) // Character message
    {

        BOOL CharValid = FALSE;

        INT32 LenValidChars = ValidChars.Length();
        TCHAR KeyCh = ((TCHAR)wParam);
        for (INT32 i=0; ( (i < LenValidChars) && (!CharValid) ); i++)
            if (((TCHAR*)ValidChars)[i] == (TCHAR)KeyCh)
            {
                CharValid = TRUE;
            }
        if (!CharValid)
        {
            // Check if the character is a special control character
            if ((KeyCh != (TCHAR)'\b') && // backspace
                (KeyCh != (TCHAR)'\t') && // tab
                (KeyCh != (TCHAR)'\n') && // linefeed
                (KeyCh != (TCHAR)'\r'))   // carriage return

                return (0);   // An invalid character was input.
        }
    }
    else if (message==WM_DESTROY)
        DeleteControlList( hwnd );

    return CallWindowProc((WNDPROC)(CurrentCntrl->lpfnOldProc), hwnd, message, wParam, lParam);
#else
    return 0;
#endif
}

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

>   INT32 FAR PASCAL EXPORT DialogManager::RgtMouseButtonProc(HWND hwnd,
                                                        UINT32 message,
                                                        UINT32 wParam,
                                                        INT32 lParam)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/9/93
    Inputs:     hwnd
                message
                wParam
                lParam
    Outputs:    -
    Returns:    -
    Purpose:    subclassed button control proc
    Errors:     -
    SeeAlso:    -

********************************************************************************************/
INT32 FAR PASCAL EXPORT DialogManager::RgtMouseButtonProc( wxWindow *pWnd,
                                                        UINT32 message,
                                                        UINT32 wParam,
                                                        INT32 lParam)
{
    PORTNOTETRACE("dialog","DialogManager::DualFunctionButton - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    // We need to access the control's dialog window to find the old proc
    HWND DlgWin = GetParent(hwnd);

    // --------------------------------------------------------------------------------------
    // Search the dialog's control list to find the information about the control
    List* ControlInfoList = GetControlList(DlgWin);
    ControlInfo* CurrentCntrl = (ControlInfo*)ControlInfoList->GetHead();
    // The lookup must be as quick as possible
    while (CurrentCntrl != NULL)
    {
        if (CurrentCntrl->ControlWnd == hwnd)
            break;
        CurrentCntrl = (ControlInfo*)ControlInfoList->GetNext(CurrentCntrl);
    }

    ENSURE(CurrentCntrl != NULL, "Could not find information for a dual function button");
    if ((message == WM_RBUTTONDOWN) || (message == WM_RBUTTONUP))
    {

        // Set the state of the button
        wParam = (message == WM_RBUTTONDOWN) ? 1:0;
        message = BM_SETSTATE;
        lParam = 0L;
        CallWindowProc((WNDPROC)(CurrentCntrl->lpfnOldProc), hwnd, message, wParam, lParam);

        // Send Command message to the control's parent dialog
        if (wParam == 1) // WM_RBUTTONDOWN message
        #if WIN32
            SendMessage(DlgWin, WM_COMMAND, MAKEINT32(GetWindowLong(hwnd, GWL_ID),BN_RGT_CLICKED), LPARAM(hwnd));
        #else
            SendMessage(DlgWin, WM_COMMAND, GetWindowWord(hwnd, GWW_ID), MAKEINT32(hwnd,BN_RGT_CLICKED));
        #endif
    }
    else if (message==WM_DESTROY)
        DeleteControlList( hwnd );
    return CallWindowProc((WNDPROC)(CurrentCntrl->lpfnOldProc), hwnd, message, wParam, lParam);
#else
    return 0;
#endif
}

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

>   static void DialogManager::DeInit()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/9/93
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Deinitialise the DialogManager
    Errors:     -
    SeeAlso:    -

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

void DialogManager::DeInit()
{
    // Because this function is called from CCamApp::SaveAllModified, of all places,
    // it gets called twice on system shutdown (once on receipt of WM_QUERYENDSESSION,
    // which itself calls CCamApp::SaveAllModified, and once on receipt of WM_ENDSESSION,
    // which performs a SC_CLOSE system command which ultimately also calls SaveAllModified.
    // This flags is a bodge for v1.1 to stop this happening, a better solution would be
    // to rewrite the dialog manager to be more rational.

    // It's not currently broken this way changed TRACE to ERROR3- Alex

    static BOOL fCalledOnceBodge = FALSE;
    if (!fCalledOnceBodge) fCalledOnceBodge = TRUE;
    else
    {
        ERROR3( wxT("DialogManager::DeInit called twice - please fix me properly sometime\n") );
        return;
    }

    // save current bar state - this should check whether save prefs on exit is set!!!!
PORTNOTE("dialog","Removed IsFullScreenMode usage")
#ifndef EXCLUDE_FROM_XARALX
    if( GetMainFrame()->IsFullScreenMode() )
        DialogBarOp::WriteNamedBars("clean");
    else
        DialogBarOp::WriteNamedBars("normal");
#endif

    // Send a CANCEL message to all open dialogs
    BROADCAST_TO_CLASS(DialogMsg(NULL, DIM_CANCEL, 0), DialogOp);
    // BODGE Special nasty stuff for v1 release.

    // InformationBarOp is completely deaf to the message broadcast above so we must
    // make sure their windows are destroyed (manually)
    InformationBarOp::SetVisibility(FALSE, TRUE);

    // Delete all Dialog position info
    ListItem* DlgPos = DialogPositionList.GetHead();
    ListItem* NextPos;
    while (DlgPos != NULL)
    {
        // Make sure that all dialogs have been deleted.
        ENSURE( ((DialogPosition*)DlgPos)->DlgWinList.IsEmpty(),
            "Live Dialog box found whilst destoying dialog manager");

        NextPos =  DialogPositionList.GetNext(DlgPos);
        delete DialogPositionList.RemoveItem(DlgPos);
        DlgPos = NextPos;
    }
    // We do not delete s_pPaneInfoHash here because the preferences have not been written out
}

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

>   DialogManager::~DialogManager()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/9/93
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    DialogManager destructor.
    Errors:     -
    SeeAlso:    DialogManager::DeInit

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

DialogManager::~DialogManager()
{
}

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

>   List* DialogManager::GetControlList(HWND hWnd)

    Author:     Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/4/94
    Inputs:     A Window handle
    Outputs:    -
    Returns:    A pointer to its special list, or NULL if it doesn't have one.
    Purpose:    Hide the mechanism we use to attach our lists to various windows. In fact we
                use window properties.
    Errors:     -
    SeeAlso:    -
    Scope:      Private, static

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

List *DialogManager::GetControlList( CWindowID hWnd )
{
    PORTNOTETRACE("dialog","DialogManager::GetControlList - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    HANDLE Prop = GetProp( hWnd, MAKEINTATOM(GetListAtom) );    // Atoms & Properties are fast
    if (Prop)
    {
    #if WIN32
        return (List*)(INT32)Prop;
    #else
        HANDLE Seg = GetProp( hWnd, MAKEINTATOM(GetListAtomSegment) );
        INT32 ptr = MAKEINT32( Prop, Seg );
        return (List*)ptr;
    #endif
    }
    else
#endif
        return NULL;
}

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

>   void DialogManager::DeleteControlList(HWND hWnd)

    Author:     Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com>
    Created:    14/11/94
    Inputs:     A Window handle
    Purpose:    Deletes the Properties that are used to store the ControlList. Should be
                called as the very last thing before the Window is vaped e.g. in response
                to a WM_DESTROY message. Destroying it earlier will cause GetControlList
                to return NULL which proves fatal within the various message handlers.
    Scope:      Private, static

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

void DialogManager::DeleteControlList( CWindowID hWnd )
{
    PORTNOTETRACE("dialog","DialogManager::DeleteControlList - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    RemoveProp( hWnd, MAKEINTATOM(GetListAtom) );
#ifndef WIN32
    RemoveProp( hWnd, MAKEINTATOM(GetListAtomSegment) );
#endif
#endif
}



// This macro aligns a BYTE ptr to a dword boundary
#if WIN32
#define DWORD_ALIGN(x)  if( DWORD_PTR(x) % 4 ) x = ADDR(( DWORD_PTR(x) + 3 ) & ~3);
#else
#define DWORD_ALIGN(x)
#endif


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

>   LPWSTR DialogManager::MovePastWideStr(LPWSTR pWideStr)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/11/93
    Inputs:     pWideStr - the start of the string to skip
    Returns:    Address of first byte past the end of the string.
    Purpose:    Given a ptr to the first byte in a wide string (or char string if win16)
                return a ptr to the byte past the null.

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

LPWSTR DialogManager::MovePastWideStr(LPWSTR pWideStr)
{
    // Skip the string
    while (*pWideStr++)
        ;

    // Return the address of the following character
    return pWideStr;
}

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

>   size_t DialogManager::SizeDlgHeader(DLGTEMPLATE *pHeader)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/11/93
    Inputs:     pHeader - start of the dialog box header.
    Returns:    Size of the dialog box header.
    Purpose:    Given a ptr to DIALOGBOXHEADER, return its size.

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


size_t DialogManager::SizeDlgHeader(DLGTEMPLATE *pHeader)
{
    // Move past the header
    ADDR pResult = (ADDR) (pHeader + 1);

    // skip szMenuName

    #if WIN32

    pResult = (ADDR) MovePastWideStr((LPWSTR) pResult);

    #else

    switch (*pResult++)
    {
        // See SDK help file (Dialog Box Resource) for details
        case 0:
            break;

        case 0xFF:
            pResult += 2;
            break;

        default:
            pResult += camStrlen((LPTCHAR) (pResult)) + 1;
            break;
    }

    #endif

    // then skip szClassName

    pResult = (ADDR) MovePastWideStr((LPWSTR) pResult);

    // then the caption

    pResult = (ADDR) MovePastWideStr((LPWSTR) pResult);

PORTNOTE("dialog","Removed DLGTEMPLATE usage")
#ifndef EXCLUDE_FROM_XARALX
    // then the font stuff
    if( (pHeader->style) & DS_SETFONT )
        pResult = (ADDR) MovePastWideStr((LPWSTR) (pResult + 2));       // skip font size too
#endif

    DWORD_ALIGN(pResult);

    // Compute the size of the header and return it.
    return (size_t) (pResult - ((ADDR) pHeader));
}


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

>   size_t DialogManager::SizeCtrlData(DLGITEMTEMPLATE *pData)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/11/93
    Inputs:     pData - the start of the control structure.
    Returns:    Size of the control data.
    Purpose:    Given a ptr to a controldata struct, return its length.
                Under Win32, all strings are UniCode (as they are in the res file).

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

size_t DialogManager::SizeCtrlData(DLGITEMTEMPLATE *pControl)
{
    #if WIN32
    // Get pointer to the data after the DLGITEMTEMPLATE structure.
    WORD *pData = (WORD *) (pControl + 1);

    // Skip the class
    if (*pData == 0xFFFF)
        // There is only one more word - the atom of the window class - skip it.
        pData += 2;
    else
        // The class is specified as a string - skip it
        pData = (WORD *) MovePastWideStr((LPWSTR) pData);

    // Skip the 'title' array
    if (*pData == 0xFFFF)
        // There is only one more word - it is a resource ID - skip it.
        pData += 2;
    else
        // The title array is a string - skip it
        pData = (WORD *) MovePastWideStr((LPWSTR) pData);

    // Skip the creation data.
    UINT32 Extra = (UINT32) *pData;
    pData++;

    #else
    // Get pointer to the data after the DLGITEMTEMPLATE structure.
    ADDR pData = (ADDR) (pControl + 1);

    // Skip the class
    if ((*pData) & 0x80)
        pData++;
    else
        pData = (ADDR) MovePastWideStr((LPWSTR) pData);

    // Skip the 'text' array
    pData = (ADDR) MovePastWideStr((LPWSTR) pData);

    // Skip the creation data.
    BYTE Extra = *pData;
    pData++;

    #endif

    // Get end pointer and double-word align it.
    ADDR pEnd = (ADDR) pData;
    DWORD_ALIGN(pEnd);

    // Compute size of control data and return it.
    ADDR pStart = (ADDR) pControl;
    pEnd += Extra;
    return (size_t) (pEnd - pStart);
}

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

>   DLGTEMPLATE *DialogManager::MergeDialog(HINSTANCE MainInst,  CDlgResID MainID,
                                            HINSTANCE OtherInst, CDlgResID OtherID)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/11/93
    Inputs:     MainInst - handle of the module containing the 'Main' dialog template.
                MainID - ID of the main dialog resource
                OtherInst - handle of the module containing the 'Other' dialog template.
                OtherID - ID of the other dialog resource
    Returns:    Pointer to a block of memory which contains a dialog template which is the
                result of merging the two templates into one.
    Purpose:    Merge two dialogs together into one dialog template.
                The return value points to the new merged dialog, which the caller should
                pass to CreateDialogIndirect().  Once the dialog has been created using this
                block, CCFree() should be called on the block to return it to the system
                pool.
                The significance of the 'Main' and 'Other' names is that the dialog style
                (border, menuname, classname, title and font) is taken from 'Main' - the
                header of 'Other' is discarded.
    SeeAlso:    CCFree()

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

DLGTEMPLATE *DialogManager::MergeDialog( /*HINSTANCE MainInst, */  CDlgResID MainID,
                                        /*HINSTANCE OtherInst, */ CDlgResID OtherID)
{
    PORTNOTETRACE("dialog","DialogManager::MergeDialog - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    HGLOBAL             hGlobal[2];
    HRSRC               hRes[2];
    DLGTEMPLATE        *pDlg[2];
    INT32               HeaderSize[2];
    ADDR                pNew,
                        pOld;
    INT32               Size;
    DLGTEMPLATE        *pHeader;

    #if WIN32
    WORD                Count, Total;
    #else
    BYTE                Count, Total;
    #endif

    size_t              Len[2],
                        ItemSize;
    UINT32              xOffset = 0;

    // Find, load and lock the dialog resources
    hRes[0] = FindResource(MainInst, MAKEINTRESOURCE(MainID), RT_DIALOG);
    hGlobal[0] = LoadResource(MainInst, hRes[0]);
    pDlg[0] = (DLGTEMPLATE *) LockResource(hGlobal[0]);

    hRes[1] = FindResource(OtherInst, MAKEINTRESOURCE(OtherID), RT_DIALOG);
    hGlobal[1] = LoadResource(OtherInst, hRes[1]);
    pDlg[1] = (DLGTEMPLATE *) LockResource(hGlobal[1]);

    // Calculate how big they each are, excluding header.
    // We would ideally use GlobalSize to find this, but it doesn't work under NT.

    Total = 0;

    for (UINT32 i = 0; i <= 1; i++)
    {
        Count = pDlg[i]->cdit;
        Total += Count;
        HeaderSize[i] = SizeDlgHeader(pDlg[i]);
        pOld = ((ADDR) pDlg[i]) + HeaderSize[i];
        Len[i] = 0;

        while (Count--)
        {
            DLGITEMTEMPLATE *pControl = (DLGITEMTEMPLATE *) pOld;

            // Find out how big the control is
            ItemSize = SizeCtrlData(pControl);

            // Update the right margin limit if this is the main dialog
            if (i == 0)
            {
                UINT32 xLimit = pControl->x + pControl->cx;
                xOffset= max(xOffset, xLimit);
            }

            // Update the length and move on to the next control
            Len[i] += ItemSize;
            pOld += ItemSize;
        }
    }

    // Allocate a new one, using header size + each data size.
    // The header of 'Main' is used for the new dialog.
    Size = SizeDlgHeader(pDlg[0]);
    pNew = (ADDR) CCMalloc(Size + Len[0] + Len[1]);

    // Copy in the header...
    memcpy( pNew, pDlg[0], (size_t) Size );

    pHeader = (DLGTEMPLATE *) pNew;     // new header now
    pNew += Size;

    // ... then data[0] ...
    memcpy(pNew, ((ADDR) pDlg[0]) + HeaderSize[0], Len[0]);
    pNew += Len[0];

    // ... and then data[1].
    memcpy(pNew, ((ADDR) pDlg[1]) + HeaderSize[1], Len[1]);

    // Fixup count in new header.
    pHeader->cdit = Total;

    // Now move all the controls in the sub-dialog to the right so they don't overlap with
    // the controls in the main dialog.
    Count = pDlg[1]->cdit;

    while (Count--)
    {
        DLGITEMTEMPLATE *pControl = (DLGITEMTEMPLATE *) pNew;

        // Shift the control to the right
        pControl->x += xOffset;

        // Move on to the next control
        pNew += SizeCtrlData(pControl);
    }

    // now its safe to free up the resource handles
    // Note: hRes handles never freed - how can you do this?

    UnlockResource(hGlobal[0]);
    FreeResource(hGlobal[0]);

    UnlockResource(hGlobal[1]);
    FreeResource(hGlobal[1]);

    return pHeader;
#else
    return NULL;
#endif
}


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

>   static BOOL DialogManager::IsADialogWindow(HWND hwnd)


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/3/94
    Inputs:     -
    Outputs:    -
    Returns:    Returns TRUE if hwnd is the window handle of a dialog
    Purpose:    To determine if hwnd is the handle of a dialog
    Errors:     -
    SeeAlso:    -

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

BOOL DialogManager::IsADialogWindow( wxWindow *pWnd )
{
    return( DialogOp::IsADialogWindow( pWnd ) );
}

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

>   static BOOL DialogManager::ModalDialogOpen(DialogOp** pModal)


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/3/94
    Inputs:     -
    Outputs:    An optional pointer to the modal dialog which is ope
    Returns:    Returns TRUE if a modal dialog is open
    Purpose:    To determine if there is currently an open modal dialog
    Errors:     -
    SeeAlso:    -

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

BOOL DialogManager::ModalDialogOpen(DialogOp** pModal)
{
    // Obtain the list of all Dialogs
    List* DialogClassList = MessageHandler::GetClassList(CC_RUNTIME_CLASS(DialogOp));
    ENSURE(DialogClassList != NULL, "Could not find DialogOp message handler list");

    // Look for an open modal dialog
    for (MessageHandler* pMsgHandler = (MessageHandler*)DialogClassList->GetHead();
        pMsgHandler != NULL;
        pMsgHandler = (MessageHandler*)DialogClassList->GetNext(pMsgHandler))
    {
        ENSURE(pMsgHandler->IsKindOf(CC_RUNTIME_CLASS(DialogOp)),
            "MessageHandler of DialogOp class list is not a DialogOp");
        if (pMsgHandler->IsKindOf(CC_RUNTIME_CLASS(DialogOp)))
        {
            // Ok we got ourselves a DialogOp
            DialogOp* pDlgOp = (DialogOp*)pMsgHandler;
            // Is the dialog open ?
            if (pDlgOp->WindowID != NULL)
            {
                // Is the Dialog modal
                if (pDlgOp->IsModal() )
                {
                    if (pModal != NULL)
                    {
                        *pModal = pDlgOp;
                    }
                    return TRUE; // found one
                }
            }
        }
    }
    return FALSE; // No modal dialog's open
}

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

>   static BOOL DialogManager::IsWindowVisible(CWindowID Win)


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    30/11/94
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if Win is visible
    Purpose:    To test the visibility of Win
    Errors:     -
    SeeAlso:    -

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

BOOL DialogManager::IsWindowVisible(CWindowID Win)
{
    return ( (wxWindow *)Win )->IsShown();
}

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

>   BOOL DialogManager::IsCustomComboDropdownVisible(CWindowID WindowID, CGadgetID Gadget)


    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/2/2000
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if WinID's dropdown is visible
    Purpose:    To test the visibility of WinID's dropdown
    Errors:     -
    SeeAlso:    -

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

BOOL DialogManager::IsCustomComboDropdownVisible(CWindowID WindowID, CGadgetID Gadget)
{
    PORTNOTETRACE("dialog","DialogManager::IsCustomComboDropdownVisible - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    String_256 ClassNameStr;  // The control type

    HWND hGadget = GetDlgItem((HWND)WindowID, (INT32)Gadget);
    // Find out the class type of the gadget
    GetClassName(hGadget, (TCHAR*)ClassNameStr, 255);

    if ((ClassNameStr == String_64(TEXT("cc_1dBitmapComboBoxEdit"))) ||
        (ClassNameStr == String_64(TEXT("cc_2dBitmapComboBoxEdit")))   )
    {
        BOOL RetVal = FALSE;

        RetVal = SendMessage (hGadget, WM_CCQUERYDROPDOWN, (WPARAM) (0), (LPARAM) 0);

        return (RetVal);
    }
    return (TRUE);
    ENSURE(FALSE, "Calling IsCustomComboDropdownVisible for an invalid control");
#endif
    return FALSE;
}

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

>   BOOL DialogManager::CloseDropdown (CWindowID WindowID, CGadgetID Gadget, BOOL CloseVal)


    Author:     Chris_Snook (Xara Group Ltd) <camelotdev@xara.com>
    Created:    21/2/2000
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if things went ok
    Purpose:    Used to close the controls dropdown.  This routine was written because of
                the amount of trouble that I was experiencing with my custom controls
                down to escape key processing (which is viewed as a hotkey within camelot).
    Errors:     -
    SeeAlso:    -

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

BOOL DialogManager::CloseDropdown (CWindowID WindowID, CGadgetID Gadget, BOOL CloseVal)
{
PORTNOTE("dialog","Programatic CB drop not supported by wx")
    return (TRUE);
}

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

>   wxPropertySheetDialog* DialogManager::GetPropertySheetFromOp( DialogTabOp* pDialogTabOp )

    Author:     Luke_Hart (xara group ltd) <lukeh@xara.com>
    created:    28/04/06
    inputs:     pdialogtabop: the operation we wish to find the property sheet for
    outputs:    -
    returns:    The associated Property sheet (or NULL if none)
    purpose:    Find the property sheet associated with the passed DialogTabOp
    errors:     -
    seealso:    -

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

wxPropertySheetDialog* DialogManager::GetPropertySheetFromOp( DialogTabOp* pDialogTabOp )
{
    wxWindow * pWindow = pDialogTabOp->WindowID;
    return pWindow->IsKindOf(CLASSINFO(wxPropertySheetDialog))?(wxPropertySheetDialog*)pWindow:NULL;
}

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

>   BOOL DialogManager::AddAPage(DialogTabOp* pDialogTabOp, CDlgResID DialogResID, CGadgetID Gadget=0)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/11/94
    Inputs:     pDialogTabOp: The operation we wish to add a page too
                DialogResID:  The resource ID of the dialog page we wish to add to the
                            DialogTabOp
                Gadget        The gadget of the book control to add the page to (or zero to
                            take a good guess)
    Outputs:    -
    Returns:    TRUE if the page was added successfully.
    Purpose:    Adds a page to the tabbed dialog with resource ID DialogResID.
    Errors:     -
    SeeAlso:    -

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


BOOL DialogManager::AddAPage(DialogTabOp* pDialogTabOp, CDlgResID DialogResID, CGadgetID Gadget)
{
    // Try to add the page to the property sheet associated with the DialogTabOp
    // let's try and find it
    wxBookCtrlBase* pNoteBook = GetBookControl(pDialogTabOp->WindowID, Gadget);

    // We need to create a page object
    // Because wxNotebookPage is derived from an MFC object we have to cope with exceptions
    wxWindow*   pNewPage;
    wxString    ObjectName;
    try
    {
        const TCHAR* pDialogName=CamResource::GetObjectNameFail( DialogResID );
        ERROR1IF(pDialogName == NULL, FALSE, _R(IDE_CANNOT_CREATE_DIALOG));
        TRACEUSER( "jlh92", _T("Cre tab %s\n"), pDialogName );
        ObjectName = pDialogName;

        pNewPage = wxXmlResource::Get()->LoadPanel( pNoteBook, pDialogName );
        ERROR1IF(pNewPage == NULL, FALSE, _R(IDE_CANNOT_CREATE_DIALOG));
        pNewPage->SetId( DialogResID );

        CamArtProvider::Get()->EnsureChildBitmapsLoaded( pNewPage );
    }
    catch( CMemoryException )
    {
        ERROR1(FALSE, _R(IDS_OUT_OF_MEMORY));
    }

    // Just to  be safe
    ERROR1IF(pNewPage == NULL, FALSE, _R(IDS_OUT_OF_MEMORY));

    wxString Title = wxEmptyString;
    if (pNewPage->IsKindOf(CLASSINFO(wxDialog)))
        Title=((wxDialog *)pNewPage)->GetTitle();
    if (Title.IsEmpty()) 
        Title = pNewPage->GetLabel(); // because wxPanel doesn't seem to support a title
    if( Title.IsEmpty() )
    {
        ResourceID  NameResID = CamResource::GetResourceID( PCTSTR(ObjectName) );
        PCTSTR      pszStringLookup = CamResource::GetTextFail( NameResID );
        if( NULL != pszStringLookup )
        {
            Title = pszStringLookup;
            TRACEUSER( "jlh92", _T("Page (FST) = \"%s\"\n"), pszStringLookup );
        }
    }
    if( Title.IsEmpty() )
    {
        // Finally, in desperation, we (mis-)use the tooltip string because now the wx folks have removed
        // the label, even though it's needed for accessibility. Aarrghh
        wxToolTip* pTip = pNewPage->GetToolTip();
        if (pTip) Title=pTip->GetTip();
    }

    wxImageList * pImageList = NULL;
    wxBitmap b;
    // Add images if present
    if (pDialogTabOp->HasImages())
    {
        // Get the image list 
        pImageList = pNoteBook->GetImageList();

        wxBitmap * pBitmap = CamArtProvider::Get()->FindBitmap(DialogResID);
        if (!pBitmap || (pBitmap==CamArtProvider::Get()->GetMissingBitmap()) || !pBitmap->Ok())
        {
            TRACEUSER("Phil", _T("Unable to use options tab icon %d\n"), DialogResID);
            int /*TYPENOTE: Correct */ w=32;
            int /*TYPENOTE: Correct */ h=32;
            if (pImageList)
                pImageList->GetSize(0, w, h);
            b = wxArtProvider::GetBitmap(wxART_HELP_SETTINGS, wxART_OTHER, wxSize(w, h));
        }
        else
            b= *pBitmap;

        // If there is no image list, create one
        if (!pImageList)
        {
            pImageList = new wxImageList(b.GetWidth(), b.GetHeight());
            if (pImageList)
                pNoteBook->AssignImageList(pImageList);
        }

    }

    if (pImageList)
        pImageList->Add(b);
    pNoteBook->AddPage( pNewPage, Title );
    if (pImageList)
        pNoteBook->SetPageImage(pNoteBook->GetPageCount()-1, pImageList->GetImageCount()-1);

    return true;
}

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

>   static CWindowID DialogManager::GetPageWindow(CWindowID Win, CDlgResID PageID, INT32* PageIndex = NULL)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/11/94
    Inputs:     Win: The windowID
                PageID: A page resource identifier, If this is not NULL then the WindowID
                        must be that of a Property sheet. We ENSURE that this is true.
    Outputs:    Optionally returns the page index
    Returns:    Window ID of a page within a property sheet
    Purpose:    Returns the Window ID of a page within a property sheet. If the page
                is NULL then Win is simply returned, It can be called  on a
                non property sheet dialog. Just pretend that they are property sheets without
                any pages.
    Errors:     -
    SeeAlso:    -

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

CWindowID DialogManager::GetPageWindow(CWindowID Win, CDlgResID PageID, INT32* PageIndex)
{
    if (PageID == 0)
    {
        return Win; // A page is not required
    }

    wxBookCtrlBase* pBookCtrl = GetBookControl(Win);
    if (!pBookCtrl)
    {
        ERROR3("No BookControl found");
        return Win;
    }

    wxNotebookPage* pCurrentPage;

    // Find the window ID of the page
    for (UINT32 i = 0; i < pBookCtrl->GetPageCount(); i++)
    {
        pCurrentPage =  (wxNotebookPage*)(pBookCtrl->GetPage(i));
        if (pCurrentPage->GetId() == INT32(PageID) )
        {
            if (PageIndex != NULL)
            {
                *PageIndex = i;
            }
            // Found page so return window id
            return pCurrentPage;
        }
    }
    ERROR3("The page specified does not exist on this tabbed dialog");
    return Win; // Probably safer than NULL
}

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

>   BOOL DialogManager::SetTitlebarName(CWindowID Win, String_256* Name)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/12/94
    Inputs:     Win:  The dialog window
                Name: The titlebar text
    Outputs:    -
    Returns:    -
    Purpose:    Sets the titlebar text of the dialog.
    Errors:     -
    SeeAlso:    -

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

BOOL DialogManager::SetTitlebarName( CWindowID Win, String_256* Name )
{
    // iterate to find the TLW
    wxWindow * pTLW = (wxWindow *)(Win);
    while (pTLW && !pTLW->IsKindOf(CLASSINFO(wxTopLevelWindow)))
        pTLW = pTLW->GetParent();

    if (pTLW)
        pTLW->SetLabel( (TCHAR *)(*Name) );

    return true;
}

// -----------------------------------------------------------------------------------------
// Functions to Set and KIll timer events

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

>   static BOOL DialogManager::SetTimer(DialogOp *pDialogOp, CWindowID WindowID, UINT32 nIDEvent, UINT32 nElapse,
                                        void (* lpfnTimer)(void *) = NULL, void * param=NULL, BOOL OneShot =FALSE)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/4/97
    Inputs:     hWnd        Handle of window for timer messages
                nIDEvent    Specifies a nonzero timer identifier.
                nElapse     Specifies the time-out value, in milliseconds.
    Returns:    The timer identifier of the new timer if Nonzero, Zero means a problem.
    Purpose:    Allows the user access to setting a timer caller back or event for a dialog box.
                The caller can either specify a call back procedure to be called when the timer
                goes off or if null is specified, a DIM_TIMER message will be sent.
                This maps onto the Windows API/CWnd call.
                The return value is effectively the handle onto the timer system. It must be
                passed to the KillTimer member function to kill the timer. A Nonzero value
                indicates successful allocation of the timer; non-zero implies a problem.

    Note:       DIM_TIMER code is not tested.

    SeeAlso:    DialogOp::KillTimer; DialogOp::SetTimer;

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

UINT32 DialogManager::SetTimer( DialogOp *pDialogOp, CWindowID WindowID, UINT32 nIDEvent, UINT32 nElapse,
                                void (* lpfnTimer)(void *)/* = NULL*/, void * param/*=NULL*/, BOOL OneShot /*=FALSE*/)
{
    if (!pDialogOp || !pDialogOp->pEvtHandler)
        return 0;

    return pDialogOp->pEvtHandler->AddTimer(pDialogOp, nIDEvent, nElapse, lpfnTimer, param, OneShot);
}

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

>   static BOOL DialogOp::KillTimer( INT32 nIDEvent )

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/4/97
    Inputs:     hWnd        Handle of window for timer messages
                nIDEvent    Specifies a nonzero timer identifier.
    Returns:    True if the event was killed, FALSE if the specified timer event could not be found.
    Purpose:    Allows the user access to killing a timer caller back or event that has been
                set up for a dialog box.
                Kills the timer event identified by nIDEvent from the earlier call to SetTimer.
                Any pending WM_TIMER messages associated with the timer are removed from the
                message queue.
    SeeAlso:    DialogOp::SetTimer; DialogManager::SetTimer;

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

BOOL DialogManager::KillTimer( DialogOp *pDialogOp, CWindowID Wnd, INT32 nIDEvent )
{
    if (!pDialogOp || !pDialogOp->pEvtHandler)
        return 0;

    return pDialogOp->pEvtHandler->DeleteTimer(nIDEvent);
}

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

>   static BOOL DialogManager::GetWindowPosition(CWindowID WindowID, RECT * pRect)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/6/97
    Inputs:     WindowID    Handle of window
    Outputs:    Rect        pointer to the rectangle to fill in
    Returns:    True if the call was successful, FALSE otherwise.
    Purpose:    Allows the user to get the current window position.
    SeeAlso:    DialogOp::GetWindowPosition; DialogManager::SetWindowPosition;

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

BOOL DialogManager::GetWindowPosition( CWindowID WindowID, wxRect *pRect )
{
    *pRect = wxRect(WindowID->GetPosition(), WindowID->GetSize());
    return TRUE;
}

BOOL DialogManager::GetWindowPosition( CWindowID WindowID, RECT *pRect )
{
    wxRect Rect;
    if (!GetWindowPosition(WindowID, &Rect)) return FALSE;
    pRect->bottom=Rect.GetBottom();
    pRect->top=Rect.GetTop();
    pRect->left=Rect.GetLeft();
    pRect->right=Rect.GetRight();
    return TRUE;
}

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

>   static BOOL DialogManager::GetGadgetPosition(CWindowID WindowID, CGadgetID Gadget, RECT * pRect)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/6/97
    Inputs:     WindowID    Handle of window
                Gadget      The icon or gadget that we are interested in.
    Outputs:    Rect        pointer to the rectangle to fill in
    Returns:    True if the call was successful, FALSE otherwise.
    Purpose:    Allows the user to get the current position of the specified gadget or icon.
    SeeAlso:    DialogOp::GetGadgetPosition; DialogManager::SetGadgetPosition;

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

BOOL DialogManager::GetGadgetPosition( CWindowID WindowID, CGadgetID Gadget, wxRect *pRect )
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    // We just need to pass back the normal position of the window
    if (pRect)
        *pRect = pGadget->GetSize();

    return TRUE;
}

BOOL DialogManager::GetGadgetPosition( CWindowID WindowID, CGadgetID Gadget, RECT *pRect )
{
    wxRect Rect;
    if (!GetGadgetPosition(WindowID, Gadget, &Rect)) return FALSE;
    pRect->bottom=Rect.GetBottom();
    pRect->top=Rect.GetTop();
    pRect->left=Rect.GetLeft();
    pRect->right=Rect.GetRight();
    return TRUE;
}

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

>   static BOOL DialogManager::SetWindowPosition(CWindowID WindowID, const RECT& Rect)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/6/97
    Inputs:     hWnd        Handle of window
                Rect        New rectangle for the window position
    Returns:    True if the call was successful, FALSE otherwise.
    Purpose:    Allows the user to set the current window position.
    SeeAlso:    DialogOp::SetWindowPosition; DialogManager::GetWindowPosition;

********************************************************************************************/
// Technical Note:
// Don't even think of using GetWindowRect or GetClientRect as there are not set equivalents.
// MoveWindow is completely spappy and does not use the same coordinates on client items!!!!
// GetWindowPlacement at least has a SetWindowPlacement form which
// uses the same coordinate system.

BOOL DialogManager::SetWindowPosition(CWindowID WindowID, const wxRect &Rect)
{
    WindowID->SetPosition(Rect.GetTopLeft());
    WindowID->SetSize(Rect.GetSize());
    return TRUE;
}

BOOL DialogManager::SetWindowPosition( CWindowID WindowID, const RECT &Rect )
{
    return SetWindowPosition( WindowID, wxRect(wxPoint(Rect.left, Rect.top), wxPoint(Rect.right, Rect.bottom)));
}

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

>   static BOOL DialogManager::SetGadgetPosition(CWindowID WindowID, CGadgetID Gadget, const RECT& Rect)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/6/97
    Inputs:     WindowID    Handle of window
                Gadget      The icon or gadget that we are interested in.
                Rect        New rectangle for the window position
    Returns:    True if the call was successful, FALSE otherwise.
    Purpose:    Allows the user to set the current position of the specified gadget or icon.
    SeeAlso:    DialogOp::SetGadgetPosition; DialogManager::GetGadgetPosition;

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

BOOL DialogManager::SetGadgetPosition( CWindowID WindowID, CGadgetID Gadget, const wxRect &Rect )
{
    wxWindow * pGadget = GetGadget(WindowID, Gadget);
    if (!pGadget) return FALSE;

    pGadget->SetSize( Rect );
    return TRUE;
}

BOOL DialogManager::SetGadgetPosition( CWindowID WindowID, CGadgetID Gadget, const RECT &Rect )
{
    return SetGadgetPosition( WindowID, Gadget, wxRect(wxPoint(Rect.left, Rect.top), wxPoint(Rect.right, Rect.bottom)));
}

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

>   static INT32 DialogManager::GetScreenDpi()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/6/97
    Returns:    0 or the dpi of the screen.
    Purpose:    Allows the user to find out the screen dpi.
    SeeAlso:    DialogOp::GetScreenDpi;

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

INT32 DialogManager::GetScreenDpi()
{
    // Get the screen DPI
    wxScreenDC          ScreenDC;
PORTNOTE("dialog","Can't handle different DPIs, using X")
    return OSRenderRegion::GetFixedDCPPI(ScreenDC).x;
}

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

>   static BOOL DialogManager::GetScreenSize(INT32 * pWidth, INT32 * pHeight)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/6/97
    Outputs:    pWidth  the screen width in pixels
                pHeight the screen height in pixels
    Returns:    True if worked ok, False otherwise.
    Purpose:    Allows the user to find out the screen size.
    SeeAlso:    DialogOp::GetScreenDpi;

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

BOOL DialogManager::GetScreenSize(INT32 * pWidth, INT32 * pHeight)
{
    ERROR2IF(pWidth == NULL || pHeight == NULL,FALSE,"GetScreenSize Bad params!");

    // HORZRES  Width, in pixels, of the screen.
    // VERTRES  Height, in raster lines, of the screen.
    INT32               Width  = wxSystemSettings::GetMetric( wxSYS_SCREEN_X );
    INT32               Height = wxSystemSettings::GetMetric( wxSYS_SCREEN_Y );

    // Tell the caller about the new values
    *pWidth = Width;
    *pHeight = Height;

    return TRUE;
}

// -----------------------------------------------------------------------------------------
// Functions to Save and restore the active dialog state

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

>   static BOOL DialogManager::RecordActiveDialogState()


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    14/7/95
    Returns:    FALSE if we run out of memory
    Purpose:    This function will get called before a MODAL dialog is opened. It records
                which window is currently active, and if the window is a MODAL dialog.
                After a MODAL dialog is closed RestoreActiveDialogState is called to
                restore the active window.
    Errors:
    SeeAlso:    DialogManager::RestoreActiveDialogState
    SeeAlso:    DialogManager::ActiveDlgStack

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

BOOL DialogManager::RecordActiveDialogState()
{
    // The new way of checking if a modal dialog is about is to determine if the
    //ActiveDlgStack is empty
    BOOL IsModal = !(ActiveDlgStack.GetTop() == NULL);
    // Which window is currently active
    wxWindow * ActiveWindow = wxWindow::FindFocus();
    
    // I think we need to look upwards here till we find a TLW
    while (ActiveWindow && !ActiveWindow->IsKindOf(CLASSINFO(wxTopLevelWindow)) && ActiveWindow->GetParent())
    {
        ActiveWindow = ActiveWindow->GetParent();
    }

    // Record this information
    ActiveDlgStateItem* pActiveDlgItem = new ActiveDlgStateItem;
    if (!pActiveDlgItem)
        return FALSE; // Out of memory

    pActiveDlgItem->pActiveWindow   = ActiveWindow;
    pActiveDlgItem->fIsAModalDialog = IsModal;

    DialogManager::ActiveDlgStack.Push(pActiveDlgItem);
    return TRUE;
}

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

>   static BOOL RestoreActiveDialogState();


    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    14/7/95
    Purpose:    This function is called after a MODAL dialog is closed. it restores the
                Active window.

    SeeAlso:    DialogManager::RecordActiveDialogState

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

void DialogManager::RestoreActiveDialogState()
{
    ActiveDlgStateItem *pActiveDlgState = (ActiveDlgStateItem *)ActiveDlgStack.Pop();
    ERROR3IF(!pActiveDlgState, "RestoreActiveDialogState called when stack was empty");
    if (!pActiveDlgState)
        return;

    wxFrame            *MainFrame = GetMainFrame();   // Could be NULL (especially during startup)

    if( NULL != pActiveDlgState->pActiveWindow )
    {
        // Enable/Disable the mainframe
        if (MainFrame)
        {
            MainFrame->Enable( !pActiveDlgState->fIsAModalDialog );
        }

        // Enable the active window
        pActiveDlgState->pActiveWindow->Enable( true );

        // Restore the active window
        pActiveDlgState->pActiveWindow->SetFocus();

        if( pActiveDlgState->fIsAModalDialog )
        {
            // Disable all dialogs except the active window
            EnableAllDialogs( FALSE, pActiveDlgState->pActiveWindow );
        }
        else
        {
            // And all other dialogs
            EnableAllDialogs(TRUE);
        }
    }
    else
    {
        TRACE( wxT("There is no active window to restore. This is expected during startup before the MainFrame has been created\n") );
        // This could be an error situation. Enable everything, so that the user is not locked out.

        // Enable the mainframe
        if( MainFrame )
            MainFrame->Enable( true );

        // And all other dialogs
        EnableAllDialogs( TRUE );
    }
    delete pActiveDlgState;
    return;
}


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

>   static CDlgResID DialogManager::GetActivePage(CWindowID WindowID, CGadgetID Gadget = 0)

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Inputs      WindowID    - The window
                GadgetID    - The gadget of the book control, or zero for none
    Created:    23/3/2000
    Returns:    the pageID of the currently active page in an open tabbed dialog, or -1 if there isn't one
    Purpose:    To find out the currently active page in a tabbed dialog

Alex unbroke this function which used to take no parameters, meaning it would only
work reliably if only one tabbed dialog was up at a time... So if you are trying to
call it, you now know how to fix your parameters...

For an unknown reason this function returns -1 if the gadget is not found. Which I think
is wxID_OK. Who knows

DONT USE THIS FUNCTION

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

CDlgResID DialogManager::GetActivePage(CWindowID WindowID, CGadgetID Gadget /*=0*/)
{
    // first check to see if we have a property sheet object
    wxBookCtrlBase * pBookControl = GetBookControl(WindowID, Gadget);
    if (pBookControl == NULL)
        return CDlgResID(-1);

    wxNotebookPage* pOurPage = pBookControl->GetCurrentPage();
    if (pOurPage == NULL)
        return CDlgResID(-1);

    return pOurPage->GetId();
}




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

>   void DialogManager::SetPropertyPageModified(BOOL Modified)


    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    23/3/2000
    Inputs:     the modified value to set
    Returns:    -
    Purpose:    Sets the modified property of the currently active property page of the current
                tabbed dialog (if it exists)

THIS ROUTINE IS FUNADAMENTALLY BROKEN - IT IS NOT PASSED A WINDOW ID SO CANNOT COPE
WITH MORE THAN ONE OPEN DIALOG

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

void DialogManager::SetPropertyPageModified(BOOL Modified)
{
PORTNOTE( "dialog", "Removed RegisterWindowMessage usage" )
#ifndef EXCLUDE_FROM_XARALX
    DlgTabOpToPropShtItem* pTabItem = (DlgTabOpToPropShtItem*)DlgTabOpToPropShtList.GetHead();
    if (pTabItem->pPropertySheet != NULL)
    {
        wxNotebookPage* pActivePage = pTabItem->pPropertySheet->GetActivePage();
        if (pActivePage != NULL)
            pActivePage->SetModified(Modified);
    }
#endif
}


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

>   ControlInfo::~ControlInfo()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    3/9/93
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    ControlInfo destructor
    Errors:     -
    SeeAlso:    -

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

ControlInfo::~ControlInfo()
{
}



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

>   static BOOL DialogManager::CreateBar(DialogBarOp* DlgOp)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    5/12/94
    Inputs:     DlgOp:  The DialogBarOp to create
    Outputs:    -
    Returns:    -
    Purpose:    Handles the creation of a bar
    Scope:      private
    Errors:     -
    SeeAlso:    DialogManager::Create

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

BOOL DialogManager::CreateBar(DialogBarOp* DlgOp)
{
    PORTNOTETRACE("dialog","DialogManager::CreateBar - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    BaseBar* DBWnd = NULL;
    // We need to create a DialogBar object
    if ( DlgOp->IsKindOf(CC_RUNTIME_CLASS(SuperGallery)) )
    {
#ifdef EXCLUDE_GALS
        return FALSE;
#else
        DBWnd = new GalleryBar();
#endif
    }
    else
    {
        DBWnd = new DialogBar();
    }


    if (DBWnd != NULL)
    {
        // Attempt to create the window
        if(!(DBWnd->Create((DialogBarOp*)DlgOp)))  // Should set the error code
        {
            delete DBWnd;
        }
    }
    else
    {

        ERROR1(FALSE, _R(IDS_OUT_OF_MEMORY));  // Failed to create the DialogBar
    }
#endif
    return TRUE;
}

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

>   static BOOL DialogManager::RelayoutDialog(DialogTabOp* DlgOp)

    Author:     Luke_Hart (Xara Group Ltd) <lukeh@xara.com>
    Created:    04/05/06
    Inputs:     DlgOp:      The DialogTabOp to re-layout
    Outputs:    -
    Returns:    -
    Purpose:    Force the dialog to relayout after control hide\show
    Scope:      public
    Errors:     -
    SeeAlso:    DialogManager::CreateTabbedDialog

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

void DialogManager::RelayoutDialog( DialogTabOp* pDlgOp )
{
    if (pDlgOp->WindowID->IsKindOf(CLASSINFO(wxPropertySheetDialog)))
    {
        ((wxPropertySheetDialog*)(pDlgOp->WindowID))->LayoutDialog();
    }
    else
        Layout(pDlgOp->WindowID);
}


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

>   static BOOL DialogManager::CreateTabbedDialog(DialogTabOp* pTabDlgOp, CDlgMode Mode, INT32 OpeningPage)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    5/12/94
    Inputs:     DlgOp:          The DialogTabOp to create
                CDlgMode:       MODAL/MODELESS
                OpeningPage:    Override the page which is active (defaults to -1)
    Outputs:    -
    Returns:    -
    Purpose:    Handles the creation of a tabbed dialog
                Opening page allows a page to be specified that is not the initial page, which
                will be the default if this is the first time the dialog has been opened or if
                it has been opened before then the initial page will be the last one opened.
    Scope:      private
    Errors:     -
    SeeAlso:    DialogManager::Create

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

BOOL DialogManager::CreateTabbedDialog(DialogTabOp* pTabDlgOp, CDlgMode Mode, INT32 OpeningPage,
    CDlgResID mainDlgID )
{
    wxBookCtrlBase * pBook = GetBookControl(pTabDlgOp->WindowID);
    if (!pBook)
        return TRUE; // nothing to do

    // Before we can create the property sheet we must add pages to it.
    // Let's ask the op do do this for us
    if (!(pTabDlgOp->RegisterYourPagesInOrderPlease()))
    {
        // We failed to add pages to the dialog so we must tidy-up and fail
        return FALSE;
    }
#if 0
    // Something very odd happens with the image list so we copy and reset it
    if (pBook->GetImageList())
    {
        wxImageList temp=*pBook->GetImageList();
        pBook->SetImageList(&temp);
    }
#endif

    // Get the dialog sized to fit
    RelayoutDialog(pTabDlgOp);

    // Scroll to start and end after yeild
    ::wxYield();
    pBook->SetSelection(pBook->GetPageCount()-1);
    pBook->SetSelection(0);

    // First check if the OpeningPage parameter is not equal to -1, in which case this
    // specifies the active page to be opened.
    // Has to be an index as otherwise we have not specified the pages yet and so cannot
    // convert the PageID into an index which is what the PropertySheets require.
    UINT32 ActivePageIndex = 0;
    if (OpeningPage != -1)
    {
        // Set the index of the page that is to be the active one to the one that has
        // been specified.
        ActivePageIndex = OpeningPage;
    }
    else
    {
        // Determine if this dialog has been created before
        DialogPosition* pPosDetails = FindDialogPositionRecord( mainDlgID );
        if (pPosDetails != NULL)
        {
            // The dialog has been created before so find out the index of the active page
            ActivePageIndex = pPosDetails->ActivePageIndex;
        }
    }

    // Now that the pages have been registered, check if the dialog has been opened
    // before. If so force the new ActivePage to be specified rather than the old.
    if (OpeningPage != -1)
    {
        // Determine if this dialog has been created before
        DialogPosition* pPosDetails = FindDialogPositionRecord( mainDlgID );
        if (pPosDetails != NULL)
        {
            // The dialog has been created before so check if the specified page was the
            // last active one. If it was then everything should be ok.
//          if (OpeningPage != pPosDetails->ActivePageIndex)
//          {
                ERROR3IF(pBook == NULL, "There is no current PropertySheet");
                wxNotebookPage* pPage = (wxNotebookPage*)(pBook->GetPage(OpeningPage));
                ERROR3IF(pPage == NULL, "There is no active page");
                pPosDetails->ActivePage = pPage->GetId();
TRACEUSER( "MarkH", _T("CreateTabbedDialog ActivePage = %d\n"),pPosDetails->ActivePage);
//              pPosDetails->ActivePage = 27666;
                pPosDetails->ActivePageIndex = OpeningPage;
//          }
        }
    }

    return TRUE;
}



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

>   static BOOL DialogManager::GetStatusLineText(String_256* ptext, CWindowID window)

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    15/05/2006
    Inputs:     window - the window ID, or NULL for the current mouse position
    Outputs:    pText - pointer to the text to fill in
    Returns:    TRUE on success else FALSE
    Purpose:    Fills in the status line text from the help text if over a control
    Scope:      Public
    Errors:     -
    SeeAlso:    -

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

BOOL DialogManager::GetStatusLineText(String_256* ptext, CWindowID window)
{
    if (!ptext)
        return FALSE;
    if (!window)
        window=::wxChildWindowFromPoint(wxGetMousePosition(), FALSE, -1);
    if (!window)
        return FALSE;

    wxHelpProvider * hp = wxHelpProvider::Get();

    // Now some controls contain other controls, so we look down the heirarch if we can't find one
    // immediately
    wxString help;
    do
    {
        if (!window->IsKindOf(CLASSINFO(wxControl)))
            return FALSE;

        if (hp)
            help = hp->GetHelp(window);
        else
            help = ((wxControl *)window)->GetHelpText();

        if (help.IsEmpty())
        {
            wxToolTip* pTip = window->GetToolTip();
            if (pTip) help=pTip->GetTip();
        }

        window=window->GetParent();
    } while (window && help.IsEmpty());

    if (help.IsEmpty())
        return FALSE;

    *ptext = help;
    return TRUE;
}

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

>   static CWindowID DialogManager::GetWindowUnderPointer(WinCoord * wc=NULL)

    Author:     Alex Bligh <alex@alex.org.uk>
    Created:    15/05/2006
    Inputs:     -
    Outputs:    wc - if non-NULL, filled in with the pointer coords
    Returns:    the window ID under the pointer or NULL for none
    Purpose:    Fills in the status line text from the help text if over a control
    Scope:      Public
    Errors:     -
    SeeAlso:    -

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

CWindowID DialogManager::GetWindowUnderPointer(WinCoord * wc /*=NULL*/)
{
    wxPoint pt=wxGetMousePosition();
    wxWindow * w=::wxChildWindowFromPoint(pt, FALSE, -1);
    if (wc && w)
    {
        pt = w->ScreenToClient(pt);
        wc->x=pt.x;
        wc->y=pt.y;
    }
    return w;
}

// Old windows routine follows
#if 0
/********************************************************************************************

>   static BOOL CALLBACK EXPORT SendDialogMessage(HWND hDlg,
                                                UINT32 Message,
                                                UINT32 wParam,
                                                INT32 lParam);

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/8/93

    Inputs:     hDlg:           Dialog window
                UINT32 Message:   Windows message
                UINT32 wParam:    wParam
                INT32 lParam:    lParam
    Outputs:    -
    Returns:    -
    Purpose:    All messages generated by all dialogs in the Windows dialog system will be
                sent to this callback

                The types of this methods variables will change depending on the platform. It
                receives a platform dependant message, translates it into a DIM and then calls
                the DialogOp's RouteMessage function.
    Errors:     -
    SeeAlso:    -

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

BOOL CALLBACK EXPORT DialogManager::SendDialogMessage( wxWindow *pDlg,
                                                UINT32 Message,
                                                UINT32 wParam,
                                                INT32 lParam )
{
    PORTNOTETRACE("dialog","DialogManager::SendDialogMessage - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    HandleMessage = FALSE;  // Flag indicating if the message received is handled

    INT32 DlgMsgParam = 0;  // Arbitrary INT32 which has meaning with some messages
                            // This gets set by the case statements below and then passed
                            // on to Operations by the BROADCAST_TO_CLASS macro at the bottom.
    Gadget = 0xFFFFFFF0;

    // ----------------------------------------------------------------------------------
    // Determine if the message was broadcast from a page within a Property sheet, if it
    // was then set the hDlg to that of the property sheet, and find the PageID
    PageID = 0;
    HWND BroadcastWindow = hDlg; // The window we should broadcast to.

    wxWindow* pCWnd = CWnd::FromHandlePermanent(hDlg);

    if (pCWnd != NULL)
    {
        if (pCWnd->IsKindOf(RUNTIME_CLASS(wxNotebookPage)))
        {
            wxWindow* pPropertySheet = pCWnd->GetParent();
            if (pPropertySheet)
            {
                ERROR2IF(!(pPropertySheet->IsKindOf(RUNTIME_CLASS(wxPropertySheetDialog))), FALSE,"Property page parent not a property sheet");
                BroadcastWindow = pPropertySheet->GetSafeHwnd(); // The destination of the message
                ERROR2IF(BroadcastWindow == NULL, FALSE, "Property sheet window handle is NULL");
                // We need to find the resource ID of the property sheet page
                PageID = ((wxNotebookPage*)pCWnd)->GetPageID();
            }
            else
            {
                // I'm not sure what this message is,  but we can't do much with it !
                return FALSE;
            }
        }
    }
    // ----------------------------------------------------------------------------------

    BOOL RemoveFocus = FALSE;

//  Removed by Phil on request from Simon, 11/05/94
//  Gadget = 0; // Set to 0 to ensure Info Bar messages are routed ok.

#if WIN16
    WORD Ctl = HIWORD(lParam);

    if (Message == WM_CTLCOLOUR && Ctl == CTLCOLOR_EDIT)
        Message = WM_CTLCOLOREDIT;
#endif

    // Set Current properly by setting it to be the same as Selected. Dialogs should only apply
    // to the Selected Document/View...
    Document::GetSelected()->SetCurrent();
    DocView::GetSelected()->SetCurrent();

    switch (Message)
    {
        case WM_MOVE:
        {
            //DY 4/5/2000 we need to know about this now to update the screen when drawing brushes
            HandleMessage = TRUE;
            DIM = DIM_DLG_MOVED;
        }
        break;

        // This responds to the custom "telephone keypad" message.
        case WM_GRIDBN_PRESSED:
            DIM = DIM_GRID_BUTTON_DOWN;
            HandleMessage = TRUE;
            Gadget = LOWORD(lParam);
            DlgMsgParam = (INT32) HIWORD(lParam);
            break;

        case WM_ACTIVATE:
            // The following bit of code is required so that we only need one IsDialogMessage
            // for many Modeless dialogs
            if (wParam == 0)
            {
                // The dialog is becoming inactive
                hDlgCurrent = NULL;
            }
            else
            {
                hDlgCurrent = hDlg;
            }
            return TRUE;

        case WM_QUERYNEWPALETTE:
            // A Window has become the focus and may select a palette if it likes
            // We always call the palette manager, which makes sure that Gavin's palette
            // is used and GDraw is using the right colours.
            PaletteManager::EnsurePalette(BroadcastWindow, FALSE);
            return(TRUE);

        case WM_PALETTECHANGED:
            // The palette has changed, so ensure we realise our palette in the background
            // but only if it wasn't us who caused this to happen!
            if (hDlg != (HWND)wParam)
                PaletteManager::EnsurePalette(BroadcastWindow, TRUE);
            break;


        case WM_COMMAND:
            Gadget = GET_WM_COMMAND_ID(wParam, lParam);

            // The command ID is only allowed to be a short
            // however the _R(ID_APPLY_NOW) control within a property sheet has a value 59910 so
            // it gets corrupted. So we need to convert it to are own ID value which can fit
            // into a short.
            if (Gadget == _R(ID_APPLY_NOW))
            {
                Gadget = _R(ID_CC_APPLY_NOW);
            }

            // the short casts are here so the sign gets propogated correctly under win32
            if (!CustomControlMsg(hDlg, wParam, lParam))
            {
                DialogManager::Dlg_OnCommand( hDlg,
                                                (short)Gadget,
                                                GET_WM_COMMAND_HWND(wParam, lParam),
                                                (short)GET_WM_COMMAND_CMD(wParam, lParam)
                                            );

                if (HandleMessage && DIM == DIM_SELECTION_CHANGED)
                    RemoveFocus = TRUE;
            }
            break;

        case CBN_CAM_SELCHANGE:
            // Handle a previously sent CBN_SELCHANGE/CBN_DBLCLK on a combo.
            DIM = (CDlgMessage) wParam;
            Gadget = (CGadgetID) lParam;
            HandleMessage = TRUE;
            break;

        case WM_CTL_COMMIT:
            // Handle subclassed bar Edit and Combo controls, send a selection changed message
            Gadget = wParam;
            DIM = DIM_SELECTION_CHANGED;

            // The LPARAM component of the message contains the virtual key code that caused the
            // commit.
            if (lParam == CAMKEY(RETURN)) DlgMsgParam = ENTER_COMMIT;
            else if (lParam == CAMKEY(TAB)) DlgMsgParam = TAB_COMMIT;
            else DlgMsgParam = NO_COMMIT;

            HandleMessage = TRUE;
            RemoveFocus = TRUE;
            break;

        case WM_SIZEPARENT:
            // This should only be received for the InfoBar, so send it on.
            CMainFrame::pInfoBar->OnSizeParent(wParam, lParam);
            break;

        case WM_INITDIALOG:
            if (!lParam)        // Dialog is modal, we need to call PostCreate
            {
                if (!PostCreate(hDlg))
                {
                    // We failed to create a modal dialog
                    EndDialog(hDlg,FALSE);  // It is ok to call this in WM_INITDIALOG
                }
            }
            return !FocusSetDuringInit;

        // Win32 and Win16 handle colour messages a bit differently - Win32 has separated them
        // out into different messages.
        // This code causes our dialogs and static controls to have a grey background.

        // A scrollbar message ?
        case WM_VSCROLL:
        case WM_HSCROLL:
            Gadget = GetDlgCtrlID( GET_WM_HSCROLL_HWND(wParam,lParam) );
            HANDLE_WM_VSCROLL(hDlg, wParam, lParam, DialogManager::Dlg_OnScroll);
            break;

        // Handle mouse button up/down events
        // Gadget IDs will be correct for custom controls but not for normal controls
        // So in the left button cases find the control ID from the supplied position
        case WM_LBUTTONDOWN:
        {
            INT32 xPos = LOWORD(lParam);  // horizontal position of cursor
            INT32 yPos = HIWORD(lParam);  // vertical position of cursor
            POINT point = { xPos, yPos };
            HWND HitWnd = ChildWindowFromPoint(hDlg, point);
            if (HitWnd != NULL)
                Gadget = GetDlgCtrlID(HitWnd); // handle of control
            HandleMessage = TRUE;
            DIM = DIM_LFT_BN_DOWN;
            break;
        }
        case WM_LBUTTONUP:
        {
            INT32 xPos = LOWORD(lParam);  // horizontal position of cursor
            INT32 yPos = HIWORD(lParam);  // vertical position of cursor
            POINT point = { xPos, yPos };
            HWND HitWnd = ChildWindowFromPoint(hDlg, point);
            if (HitWnd != NULL)
                Gadget = GetDlgCtrlID(HitWnd); // handle of control
            HandleMessage = TRUE;
            DIM = DIM_LFT_BN_UP;
            //Gadget = GetDlgCtrlID(hDlg); // handle of control
            break;
        }

        // Gadget IDs will be correct for custom controls but not for normal controls
        case WM_RBUTTONDOWN:
            HandleMessage = TRUE;
            DIM = DIM_RGT_BN_DOWN;
            //Gadget = GetDlgCtrlID(hDlg); // handle of control, returns 0
            break;
        case WM_RBUTTONUP:
            HandleMessage = TRUE;
            DIM = DIM_RGT_BN_UP;
            //Gadget = GetDlgCtrlID(hDlg); // handle of control, returns 0
            break;

        case WM_MOUSEWHEEL:
        {
            INT32 xPos = LOWORD(lParam);  // horizontal position of cursor
            INT32 yPos = HIWORD(lParam);  // vertical position of cursor
            POINT point = { xPos, yPos };
            HWND HitWnd = ChildWindowFromPoint(hDlg, point);
            if (HitWnd != NULL)
                Gadget = GetDlgCtrlID(HitWnd); // handle of control
            HandleMessage = TRUE;
            if ((short)HIWORD(wParam) > 0)
            {
                DIM = DIM_MOUSEWHEEL_UP;
            }
            else
            {
                DIM = DIM_MOUSEWHEEL_DOWN;
            }
            break;
        }


        // Handle Rik's slider notification messages...

        case WMN_POSITION_CHANGING:
            Gadget = GetWindowID((HWND)wParam);
            HandleMessage = TRUE;
            DIM = DIM_SLIDER_POS_CHANGING;
            DlgMsgParam = lParam;           // Pass slider pos on to Ops
            break;
        case WMN_POSITION_IDLE:
            Gadget = GetWindowID((HWND)wParam);
            HandleMessage = TRUE;
            DIM = DIM_SLIDER_POS_IDLE;
            DlgMsgParam = lParam;           // Pass slider pos on to Ops
            break;
        case WMN_POSITION_SET:
            Gadget = GetWindowID((HWND)wParam);
            HandleMessage = TRUE;
            DIM = DIM_SLIDER_POS_SET;
            DlgMsgParam = lParam;           // Pass slider pos on to Ops
            break;


        // A Windows font table change has occured.
        // Something or somebody has added or removed a font from the windows
        // font table.

        case WM_FONTCHANGE:
            HandleMessage = TRUE;
            DIM = DIM_FONTCHANGE;
            break;

        // Somebody has asked for a timer event and here we have recieved one.
        case WM_TIMER:
            // Parameters are:-
            // wTimerID = wParam;            // timer identifier
            // tmprc = (TIMERPROC *) lParam; // address of timer callback
            DlgMsgParam = wParam;   // pass on the timer id just in case dialog wants it
            HandleMessage = TRUE;
            DIM = DIM_TIMER;
            break;

//      // Somebody has changed something in the International Section
//      // of the Windows Control Panel. So note the change and force things
//      // to update the current display
//
//      case WM_WININICHANGE:
//      {
//          // Cause the conversion system to reload the values from the system
//          InitConvert();
//          // Now tell people to update themselves
//          Document * pDocument = Document::GetSelected();
//          BROADCAST_TO_ALL(OptionsChangingMsg(pDocument, OptionsChangingMsg::OptionsState::NEWUNITS));
//          break;
//      }


        // Handle mouse moves/drags

        // These were removed by Simon 25/11 cos they are unlikely to be needed any longer and
        // make debugging a pain.

        // MOUSEMOVE was restored, because its needed in the bitmap export options dialog
        case WM_MOUSEMOVE:
        {
            if (!(wParam & (MK_LBUTTON | MK_RBUTTON | MK_MBUTTON)))
            {
                HandleMessage = TRUE;
                DIM = DIM_MOUSE_MOVE;
            }
            break;
        }

        case WM_NOTIFY:
        {
            HWND hChild = GetDlgItem(hDlg, INT32(wParam));
            TCHAR buffer[32];
            GetClassName(hChild, buffer, sizeof(buffer));
            if (String_32(buffer) == String_32(TEXT("SysTreeView32"))) // so the notification comes from a treeview
            {
                LPNMHDR pNMHDR = (LPNMHDR) lParam;
                switch (pNMHDR->code)
                {
                    // We could handle much more here, but this is rather useful...
                    case TVN_SELCHANGED:
                    {
                        HandleMessage = TRUE;
                        Gadget = wParam;
                        DIM = DIM_SELECTION_CHANGED;
                        DlgMsgParam = lParam;
                    }
                }
            }

            if (String_32(buffer) == (LPCTSTR)CCustomList::WNDCLASSNAME) // so the notification comes from our customlist
            {
                LPNMHDR pNMHDR = (LPNMHDR) lParam;
                CCustomList* pListGadget = CCustomList::GetGadget((CWindowID) hDlg, (CGadgetID) pNMHDR->idFrom);
                BOOL DoubleClick = FALSE;   // Flag to allow sharing of click/double-click code

                if (pListGadget)
                {
                    // the gadget is notifying us that something happened
                    HandleMessage = TRUE;
                    Gadget = wParam;
                    if(pNMHDR->code == NM_DBLCLK)
                    {
                        DIM = DIM_SELECTION_CHANGED_COMMIT;

                    }
                    else
                    {
                        DIM = DIM_SELECTION_CHANGED;
                    }
                }
                else
                {
                    ERROR3("Failed to find list gadget");
                }
            }

            if (String_32(buffer) == String_32(TEXT("msctls_updown32"))) // so the notification comes from an updown control
            {
                NM_UPDOWN* pnmud = (NM_UPDOWN FAR *) lParam;

                if (pnmud->iDelta > 0)
                {
                    SpinControlMessageUp = TRUE;
                    HandleMessage = FALSE;
                }
                else if (pnmud->iDelta < 0)
                {
                    SpinControlMessageDown = TRUE;
                    HandleMessage = FALSE;
                }
                else
                {
                    ERROR3 ("A Fatal error has occured within the OS!");
                }
            }
        }
        break;




//      case WM_DESTROY:
//          // Call CCListGadget::OnDialogClose() so that it destroys any list controls there may be on the form
//          CCustomList::OnDialogClose((CWindowID) hDlg);
//          break;


        // sent when a change is made to a system color setting - forward message to controls
        case WM_SYSCOLORCHANGE:
        {
            HWND hChild = GetDlgItem(hDlg, INT32(wParam));
            if(hChild)
            {
                ::SendMessage(hChild, WM_SYSCOLORCHANGE, 0, 0);
            }
            return TRUE;
            break;
        }

        case WM_DLGDRAWEVENT:   // (Mouse) event from a cc_DialogDraw custom control [Jason: 2/12/94]
        {
            DlgDrawEventInfo *Info = (DlgDrawEventInfo *) lParam;
            ERROR3IF(Info == NULL, "NULL DilaogDraw EventInfo passed to DialogMgr?!");

            switch(Info->msg)
            {
                case WM_LBUTTONDOWN:
                    DIM = DIM_LFT_BN_DOWN;
                    break;

                case WM_LBUTTONUP:
                    DIM = DIM_LFT_BN_UP;
                    break;

                case WM_RBUTTONDOWN:
                    DIM = DIM_RGT_BN_DOWN;
                    break;

                case WM_RBUTTONUP:
                    DIM = DIM_RGT_BN_UP;
                    break;

                case WM_MOUSEMOVE:
                    if (Info->wParam & MK_LBUTTON)
                        DIM = DIM_MOUSE_DRAG;
                    else
                        DIM = DIM_MOUSE_MOVE;
                    break;

                case WM_MOUSEWHEEL:
                    if ((short) HIWORD(Info->wParam) > 0)
                    {
                        //MouseWheel scrolled upwards
                        DIM = DIM_MOUSEWHEEL_UP;
                    }
                    else
                    {
                        //MouseWheel scrolled downwards...
                        DIM = DIM_MOUSEWHEEL_DOWN;
                    }
                    break;

                default:
                    ERROR3("Unknown Event type passed in WM_DLGDRAWEVENT message");
                    break;
            }

            // Set up a MousePosInfoType containing the click position info, and information
            // that will come in handy (size of the gadget, and screen DPI)
            ReDrawInfoType ExtraInfo;

            ExtraInfo.pDC = NULL;       // No redraw info for mouse events
            ExtraInfo.pClipRect = NULL;

            // Get the screen DPI
            HDC ScreenDC = CreateCompatibleDC(NULL);
            if (ScreenDC == NULL)
            {
                ERROR2RAW("DialogManager::SendDialogMessage: Unable to create screen DC");
                break;
            }
            ExtraInfo.Dpi = GetDeviceCaps(ScreenDC, LOGPIXELSY);
            DeleteDC(ScreenDC);

            // Calculate how big the window is, in MILLIPOINTS
            RECT WindowSize;
            if (!GetClientRect(Info->hwnd, &WindowSize))
            {
                ERROR2RAW("GetClientRect failed in DialogManager::SendDialogMessage");
                break;
            }

            ExtraInfo.dx = (((INT32)WindowSize.right)*72000) / ExtraInfo.Dpi;
            ExtraInfo.dy = (((INT32)WindowSize.bottom)*72000) / ExtraInfo.Dpi;

            // Work out the MILLIPOINT coordinates of the mouse position
            // Note that the Y value is flipped, as the kernel-origin is at the bottom left
            INT32 XPos = (INT32) MAKEPOINTS(Info->lParam).x;
            INT32 YPos = (INT32) MAKEPOINTS(Info->lParam).y;

            DocCoord MousePos;
            MousePos.x = (XPos * 72000) / ExtraInfo.Dpi;
            MousePos.y = ExtraInfo.dy - ((YPos * 72000) / ExtraInfo.Dpi);
            ExtraInfo.pMousePos = &MousePos;

            // Now, send the message to the DialogOp to be handled.
            // Note that we leave HandleMessage == FALSE so the caller doesn't send the
            // message a second time!

            BROADCAST_TO_CLASS(DialogMsg(BroadcastWindow, DIM, Info->ControlID, (INT32)&ExtraInfo, PageID), DialogOp);
            break;
        }


        case WM_REDRAW :
        {
            if (CCamApp::IsDisabled())
            {
                TRACE( _T("kernel-rendered gadget repaint has been aborted: the system is disabled (due to an error/ensure?)\n"));
                HandleMessage = FALSE;
                break;
            }

            // Find out about the paint message and fill in the details in the kernel message
            RedrawInfo* pInfo = (RedrawInfo*) lParam;

            HDC hDC = pInfo->PaintInfo.hdc;
            HPALETTE OldPalette = PaletteManager::StartPaintPalette(hDC);

            ReDrawInfoType ExtraInfo;

            ExtraInfo.pMousePos = NULL;     // No mouse position info for redraw events

            // Build a CC dc out of it for rendering to the screen
            // Get a MFC CDC to put the DC in
            CCDC MyDc(RENDERTYPE_SCREEN);
            MyDc.Attach(pInfo->PaintInfo.hdc);
            ExtraInfo.pDC = &MyDc;

            // The devices DPI
            ExtraInfo.Dpi = MyDc.GetDeviceCaps(LOGPIXELSY);

            // How big the window is
            RECT WindowSize;
            if (GetClientRect((HWND)wParam, &WindowSize))
            {
                ExtraInfo.dx = (((INT32)WindowSize.right)*72000) / ExtraInfo.Dpi;
                ExtraInfo.dy = (((INT32)WindowSize.bottom)*72000) / ExtraInfo.Dpi;
            }

            // Work out the size of the invalidated region
            RECT* ClipRect = &pInfo->PaintInfo.rcPaint;
            DocRect DocClipRect;

            // Convert to millipoints, Also need to flip the y coords to get a
            // rectangle in with the origin in the bottom left.
            DocClipRect.lo.x = (ClipRect->left * 72000) / ExtraInfo.Dpi;
            DocClipRect.lo.y = ExtraInfo.dy - ((ClipRect->bottom * 72000) / ExtraInfo.Dpi);

            DocClipRect.hi.x = (ClipRect->right * 72000) / ExtraInfo.Dpi;
            DocClipRect.hi.y = ExtraInfo.dy - ((ClipRect->top * 72000) / ExtraInfo.Dpi);

            // Set the pointer in the extra info structure
            ExtraInfo.pClipRect = &DocClipRect;

            // Build the message and send it to the dialog op
            // It is up to the dialog op to build a render region etc and attach the CCDC to it
            // and to tidy the region up after it has finished drawing in it CDlgMessage
            BROADCAST_TO_CLASS(DialogMsg(BroadcastWindow, DIM_REDRAW, pInfo->ControlID, (INT32) &ExtraInfo, PageID), DialogOp);

            // Give back the dc
            MyDc.Detach();

            if (OldPalette)
                PaletteManager::StopPaintPalette(hDC, OldPalette);
            break;
        }

        case WM_DRAWITEM:
            {
                // First, check if this is for a (Colour/Font) DropDown combobox, and return TRUE if it handles it
                if (DropDown::HandleDrawItem(hDlg, wParam, lParam))
                    return(TRUE);
                // Nope - it must be a custom control, so pass the message on to it
                LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) lParam;

                // If the custom control redraws this, we return TRUE so that the OS/MFC
                // does not go rampantly drawing selection rects around the item or anything
                if (SendMessage( lpdis->hwndItem,
                                DialogManager::MsgSlaveDrawItem, wParam, lParam ))
                    return(TRUE);
            }
            break;

        case WM_MEASUREITEM:
            {
                // Get the colour drop-down list to handle this. Note that it currently always handles
                // this case - if you need to pass it to another control, check first and drop through
                // to this code if you don't handle it.

                if (DropDown::HandleMeasureItem(hDlg, wParam, lParam))
                    return(TRUE);
            }
            break;

        //case WM_WINDOWPOSCHANGING:
        //  static Bodge=0;
        //  if (Bodge >= 1)
        //  {
        //      // If the dialog is modal then do not let the windows Z order change
        //          WINDOWPOS FAR* pwp = (WINDOWPOS FAR*) lParam;  // address of WINDOWPOS structure
        //      pwp->flags = SWP_NOOWNERZORDER;
        //  }
        //  Bodge++;
        //  break;


        // --- Bodge handlers for input focus handling in the colour editor
        // Thanks to the sheer marvellousness of Windows disloague handling, we can't stop the focus
        // going into our dialogue on MouseActivate (normally, we'd just return MA_NOACTIVATE and be
        // happy without the focus). The 17th and final solution (the only one that works) is that
        // when a click occurs on the window titlebar, or when the window has been moved, we warn the
        // dialogue about it, and the colour dialogue schedules an idle-event processor, which pushes
        // the focus back to the document. This has to be done on idles so that the focus is pushed
        // back immediately after the move occurs (if we change the focus immediately, it goes away
        // until the mouse button is released, at which point Windows kindly gives us the focus again!)

        // Actually (25/2/2000) there is a much more suitable (and easier) way of getting our
        // colour editor dialog to do this - we simply process the WM_EXITSIZEMOVE mesage!
        // The message is common to Windows 96/98 and NT (CGS) ....  I discovered this when I
        // made the profile dialog behave in a similiar fashion.

        case WM_MOUSEACTIVATE:      // Look out for clicks on the title bar
            if (((INT32) LOWORD(lParam)) != HTCAPTION)
                return(FALSE);
            else
                return (MA_NOACTIVATE);     // return this - even if windows don't want to listen
                                            // to us; cause afterall, its what we want ....

        case WM_EXITSIZEMOVE:
            DIM = DIM_TITLEFOCUSWARN;       // throw that focus baby!
            BROADCAST_TO_CLASS( DialogMsg(BroadcastWindow, DIM, Gadget, DlgMsgParam, PageID), DialogOp );
            // yo buddy, I've handled the message !
            return (TRUE);



        break;
        // added by Karim 30/9/99 to catch text typed into the font combo-box and change the
        // selection within the combo-box to match whatever the user typed as closely as possible.
        case WM_KEYDOWN:
            {
                // check whether we want this message - ie is the font
                // combo-box a child of the message'd window.
                if (::GetDlgItem(hDlg, _R(IDC_FONT_COMBO)) != NULL &&
                                            (TCHAR)wParam >= 'A' &&
                                            (TCHAR)wParam <= 'Z')
                {
                    // if the character just typed was entered within a specified
                    // timeframe, 'cat it to the end of a comparison string.
                    static DWORD dwTime = 0;
                    static String_256 strCharsTyped = "";

                    DWORD dwNow = ::GetTickCount();
                    if ((dwNow - dwTime)  > 1000 || strCharsTyped.Length() > 255)
                        strCharsTyped.Empty();

                    strCharsTyped += (TCHAR)wParam;

                    // look for the first font whose description starts with
                    // the comparison string.
                    BOOL bMatch = FALSE;
                    FontDropItem* fontItem = NULL;
                    HWND hwndCombo = ::GetDlgItem(hDlg, _R(IDC_FONT_COMBO));
                    INT32 numItems = ComboBox_GetCount(hwndCombo);
                    for (INT32 i = 0; !bMatch && i < numItems; i ++)
                    {
                        fontItem = (FontDropItem*)ComboBox_GetItemData(hwndCombo, i);
                        if (fontItem != NULL)
                        {
                            bMatch = (camStrnicmp(fontItem->GetFontName(),
                                strCharsTyped,
                                camStrlen(strCharsTyped)) == 0);
                        }
                    }

                    // if we found the font, lets go to it
                    if (bMatch)
                        ::SendMessage(hwndCombo, CB_SETCURSEL, i - 1, 0);
                    else
                        strCharsTyped.Empty();

                    // set our timer to the current time.
                    dwTime = ::GetTickCount();

                    return TRUE;    // this message has been processed.
                }
            }
        break;
    }

    // Handle messages from draggable list boxes...
    static LPDRAGLISTINFO lpdli;
    static UINT32 iItemToMove, iItem;

    if (Message == DialogManager::MsgDragList)
    {
    #if USE_COMMON_CONTROLS
        lpdli = (LPDRAGLISTINFO)lParam;
        switch (lpdli->uNotification)
        {
            case DL_BEGINDRAG:
                iItemToMove = LBItemFromPt(lpdli->hWnd, lpdli->ptCursor, TRUE);
                return DL_MOVECURSOR;
            case DL_DRAGGING:
                iItem = LBItemFromPt(lpdli->hWnd, lpdli->ptCursor, TRUE);
                DrawInsert(hDlg, lpdli->hWnd, iItem);
                if (iItem!=-1)
                    return DL_MOVECURSOR;
                return DL_STOPCURSOR;
            case DL_DROPPED:
                iItem = LBItemFromPt(lpdli->hWnd, lpdli->ptCursor, TRUE);
                //if (iItem!=-1)
                //{
                    //SetStringGadgetValue(
                    //ListBox_InsertString(hGadget, iItem, (INT32)(TCHAR*)(*StrVal))
                    //Use list box messages to insert item at new location
                //}
                DrawInsert(hDlg, lpdli->hWnd, -1);
                return DL_CURSORSET;
            default:
                if (IsUserName("Simon"))
                    TRACE( _T("Unknown draglist message 0x%x\n"), lpdli->uNotification);

        }
    #endif
    }

    // If the message should be handled then Route it to the appropriate DialogOp
    if (HandleMessage)
    {
        BROADCAST_TO_CLASS( DialogMsg(BroadcastWindow, DIM, Gadget, DlgMsgParam, PageID), DialogOp );
    }
#endif
    return HandleMessage;
}


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

>   void DialogManager::Dlg_OnCommand(HWND hwnd, INT32 id, HWND hwndCtl, UINT32 codeNotify)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/9/93
    Purpose:    OnCommand message handler. Translates a windows Command message into a DIM
    Errors:     -
    SeeAlso:    -

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

void DialogManager::Dlg_OnCommand( wxWindow *pWnd, INT32 id, wxWindow *pWndCtl, INT32 codeNotify )
{
    PORTNOTETRACE("dialog","DialogManager::Dlg_OnCommand - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    String_256 ClassNameStr;
    GetClassName(hwndCtl, (TCHAR*)ClassNameStr, 255);

    // -------------------------------------------------------------------------------------
    // Special processing

    // Commit processing
    if (id == IDOK)
    {
        if (codeNotify == BN_RGT_CLICKED)
        {
            DialogManager::DIM = DIM_SOFT_COMMIT;
            DialogManager::HandleMessage = TRUE;
            return;
        }
        else
        {
            // Either left button clicked or ENTER was pressed in a control.
            DialogManager::DIM = DIM_COMMIT;
            DialogManager::HandleMessage = TRUE;
            SetGadgetIDToFocus(hwnd);
            //Move focus to the next control in the dialog.
            PostMessage(hwnd, WM_NEXTDLGCTL, 0, 0L) ;
            return;
        }
    }
    else if (id == _R(ID_CC_APPLY_NOW))
    {
        // Clicking on the apply now button is the same as a soft commit
        DialogManager::DIM = DIM_SOFT_COMMIT;
        DialogManager::HandleMessage = TRUE;
        return;

    }
    else if (id == IDCANCEL)
    {
        DialogManager::DIM = DIM_CANCEL;
        DialogManager::HandleMessage = TRUE;
        SetGadgetIDToFocus(hwnd);
        return;
    }

    // -------------------------------------------------------------------------------------
    // Button control messages
    if ((ClassNameStr == String_8(TEXT("Button"))))
    {
        switch (codeNotify)
        {
            case BN_RGT_CLICKED:
                DialogManager::DIM = DIM_RGT_BN_CLICKED;
                DialogManager::HandleMessage = TRUE;
                break;

            case BN_CLICKED:
                DialogManager::DIM = DIM_LFT_BN_CLICKED;
                DialogManager::HandleMessage = TRUE;
                break;
        }
    }
    else if ( (ClassNameStr == String_8(TEXT("ListBox"))) ||  // ListBox control messages
            (ClassNameStr == String_16(TEXT("cc_CheckList")))
            )
    {
        switch (codeNotify)
        {
            case LBN_ERRSPACE:
                DialogManager::DIM = DIM_OUT_OF_SPACE;
                DialogManager::HandleMessage = TRUE;
                break;
            case LBN_SELCHANGE:
                DialogManager::DIM = DIM_SELECTION_CHANGED;
                DialogManager::HandleMessage = TRUE;
//              ::SetFocus(NULL);       // This is done for us by SendDialogMessage
                                        // If we do it here, DIM_SEL_CHANGED is NOT broadcast!
                break;
            case LBN_DBLCLK:
                DialogManager::DIM = DIM_SELECTION_CHANGED_COMMIT;
                DialogManager::HandleMessage = TRUE;
                break;
            case LBN_SELCANCEL:
                DialogManager::DIM = DIM_SELECTION_CANCELED;
                DialogManager::HandleMessage = TRUE;
                break;
        }
    }
    else if ( (ClassNameStr == String_8(TEXT("ComboBox"))) || // ComboBox control messages
            (ClassNameStr == String_64(TEXT("cc_1dBitmapComboBoxEdit"))) ||
            (ClassNameStr == String_64(TEXT("cc_2dBitmapComboBoxEdit")))
            )
    {
//      BOOL SetComboText = FALSE;
        switch (codeNotify)
        {
            case CBN_KILLFOCUS:
                // If a combo box loses the input focus, broadcast this fact. It can be
                // used as a 'confirm' message for the contents of the combo box editable
                // field which will work under all circumstances (pressing return or tab,
                // Alt-tabbing to another application, closing the window, clicking on
                // another control/window/application, etc etc), as opposed to other
                // 'confirm' information which you only get *sometimes*.
                DialogManager::DIM = DIM_FOCUS_LOST;
                DialogManager::HandleMessage = TRUE;
                break;
            case CBN_DROPDOWN:
                // If a combo box loses the input focus, broadcast this fact. It can be
                // used as a 'confirm' message for the contents of the combo box editable
                // field which will work under all circumstances (pressing return or tab,
                // Alt-tabbing to another application, closing the window, clicking on
                // another control/window/application, etc etc), as opposed to other
                // 'confirm' information which you only get *sometimes*.
                DialogManager::DIM = DIM_LISTDROPPED;
                DialogManager::HandleMessage = TRUE;
                break;
            case CBN_ERRSPACE:
                DialogManager::DIM = DIM_OUT_OF_SPACE;
                DialogManager::HandleMessage = TRUE;
                break;
            case CBN_SELCHANGE:
                ::PostMessage(hwnd, CBN_CAM_SELCHANGE,
                            (WPARAM) DIM_SELECTION_CHANGED,
                            (LPARAM) Gadget);
                // Removed by Chris 22 March 95
                // fixes can't cursor through combo's bug
                //::SetFocus(NULL);                     // don't do this - it's senseless
                break;

            case CBN_DBLCLK:        // A "Simple" listbox item has been double-clicked
            case CBN_SELENDOK:      // The user has confirmed their choice (seems to miss kbd input!)
            case CBN_CLOSEUP:       // The control's dropdown is being closed
                ::PostMessage(hwnd, CBN_CAM_SELCHANGE,
                            (WPARAM) DIM_SELECTION_CHANGED_COMMIT,
                            (LPARAM) Gadget);
                break;

            case CBN_EDITCHANGE:                           // Text in edit portion of combo has changed
                DialogManager::DIM = DIM_TEXT_CHANGED;
                DialogManager::HandleMessage = TRUE;
                break;
        }
    }

    else if (ClassNameStr == String_8(TEXT("Edit"))) // ComboBox control messages
    {
        switch (codeNotify)
        {
            case EN_CHANGE:                        // Text in edit control has changed
                DialogManager::DIM = DIM_TEXT_CHANGED;
                DialogManager::HandleMessage = TRUE;
                break;

            case EN_SETFOCUS:                       // Edit control has focus (i.e. been clicked on, tabbed to, etc)
                DialogManager::DIM = DIM_SET_FOCUS;
                DialogManager::HandleMessage = TRUE;
                break;

            case EN_KILLFOCUS:                      // Edit control looses focus (i.e. another field's been clicked on, tabbed to, etc)
                DialogManager::DIM = DIM_KILL_FOCUS;
                DialogManager::HandleMessage = TRUE;
                break;
        }
    }
#endif
}

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

>   void DialogManager::Dlg_OnScroll(HWND hwnd, HWND hwndCtl, UINT32 code, INT32 pos)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/9/93
    Purpose:    OnHScroll and OnVScroll message handler. Translates a windows scroll message
                into a DIM. This routine is used for Scroll bars and Trackbars
    Errors:     -
    SeeAlso:    -

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

void DialogManager::Dlg_OnScroll( wxWindow *pWnd, wxWindow *pWndCtl, UINT32 code, INT32 pos )
{
    PORTNOTETRACE("dialog","DialogManager::Dlg_OnScroll - do nothing");
#ifndef EXCLUDE_FROM_XARALX
    // Determine if the control is a scroll bar or track bar
    String_256 ClassNameStr;
    GetClassName(hwndCtl, (TCHAR*)ClassNameStr, 255);
    BOOL ScrollControl = (ClassNameStr == String_16(TEXT("ScrollBar")));
    BOOL SpinControl = (ClassNameStr == String_32(TEXT("msctls_updown32")));

    INT32 Page; // Number of units to move for a PAGE event

    if (!SpinControl)
    {
        // Obtain Page increment information
        ScrollPageInc* PgInc = (ScrollPageInc*)(ScrollPageIncList.GetHead());
        BOOL FoundPageIncDetails = FALSE;
        while (PgInc != NULL)
        {
            if (PgInc->ScrollBarWnd == hwndCtl) // Found details
            {
                FoundPageIncDetails = TRUE;
                Page = PgInc->PageInc;
            }
            PgInc = (ScrollPageInc*)ScrollPageIncList.GetNext((ListItem*)PgInc);
        }
        ENSURE(FoundPageIncDetails, "Scroll bar has not has its range of values set");
    }

    // Obtain scroll bars range and current thumb position
    INT32 ScrollMin;
    INT32 ScrollMax;

    WORD CurrentThumbPos;

    if (ScrollControl)
    {
        GetScrollRange(hwndCtl, SB_CTL, &ScrollMin, &ScrollMax);
        CurrentThumbPos = (WORD)GetScrollPos(hwndCtl, SB_CTL);
    }
    else if (SpinControl)
    {
        DWORD ScrollRange = SendMessage (hwndCtl, UDM_GETRANGE, 0, 0);
        ScrollMin = HIWORD (ScrollRange);
        ScrollMax = LOWORD (ScrollRange);
        CurrentThumbPos = (INT32) SendMessage(hwndCtl, UDM_GETPOS, 0, 0);

        if (SpinControlMessageUp)
        {
            code = SB_LINEUP;
        }
        else if (SpinControlMessageDown)
        {
            code = SB_LINEDOWN;
        }
        else
        {
            return;
        }
//      else
//      {
//          ERROR3 ("A serious error has occured!");
//      }
    }
    else // Trackbar
    {
        ScrollMin = (INT32) SendMessage(hwndCtl, TBM_GETRANGEMIN, 0, 0);
        ScrollMax = (INT32) SendMessage(hwndCtl, TBM_GETRANGEMAX, 0, 0);
        CurrentThumbPos = (WORD) SendMessage(hwndCtl, TBM_GETPOS, 0, 0);
    }

    INT32 ScrollBarInc = 0;
    INT32 NewPos;

    switch (code)
    {
        case SB_TOP:     // Same as SB_LEFT TB_TOP
            ScrollBarInc = -(INT32)(CurrentThumbPos - ScrollMin);
            break;
        case SB_BOTTOM: // Same as SB_RIGHT, TB_BOTTOM
            ScrollBarInc = ScrollMax - CurrentThumbPos;
            break;
        case SB_LINEUP:  // Same as SB_LINELEFT, TB_LINEUP
            ScrollBarInc = -1;
            break;
        case SB_LINEDOWN: // Same as SB_LINERIGHT, TB_LINEDOWN
            ScrollBarInc = 1;
            break;
        case SB_PAGEUP:   // Same as SB_PAGELEFT, TB_PAGEUP
            ScrollBarInc = -Page;
            break;
        case SB_PAGEDOWN:  // Same as SB_PAGERIGHT, TB_PAGERIGHT
            ScrollBarInc = Page;
            break;
        case SB_THUMBTRACK: // Same as TB_THUMBTRACK
            ScrollBarInc = pos - CurrentThumbPos;
            break;
        case SB_THUMBPOSITION:

            break;
    }

    NewPos = CurrentThumbPos + ScrollBarInc;
    NewPos = max(ScrollMin, min(NewPos, ScrollMax));

    if (ScrollBarInc != 0)
    {
        if (ScrollControl)
        {
            SetScrollPos(hwndCtl, SB_CTL, NewPos, TRUE);
        }
        else if (!SpinControl)
        {
            SendMessage(hwndCtl, TBM_SETPOS,1,(INT32)NewPos );
        }

        // converting all scrollbar messages to DIM_SELECTION_CHANGED seems extremely
        // stupid to me, and in the case of the spin controls this creates a new problem:

        // in dialogs that respond to DIM_SELECTION_CHANGED for the correct purpose, spin
        // controls also enter into this logic - which causes/is extremely undesired behaviour!

        // SOLUTION - I'm adding some new DIM's which will allow me to differentiate ....

        if (ScrollControl)
        {
            DIM = DIM_SELECTION_CHANGED;
        }
        else if (SpinControl)
        {
            if (SpinControlMessageUp)
            {
                DIM = DIM_SPINCONTROLUP;
                SpinControlMessageUp = FALSE;
            }
            else    // MUST be SpinControlMessageDown - otherwise we would have retuned by now!
            {
                SpinControlMessageDown = FALSE;
                DIM = DIM_SPINCONTROLDOWN;
            }
        }
        else
        {
            DIM = DIM_SELECTION_CHANGED;
        }

        HandleMessage = TRUE;
    }
#endif
}


#endif




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

>   static CTreeItemID DialogManager::SetTreeGadgetItem(CWindowID wnd,
                                                        CGadgetID Gadget,
                                                        CTreeItemID hParent,
                                                        const StringBase& str,
                                                        CTreeItemID hInsAfter,
                                                        INT32 iImage,
                                                        CCObject* pObj = NULL)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID: Dialog box window identifier
                Gadget: Gadget identifier
                StrID:    Resource ID of string
    Outputs:    -
    Returns:    TRUE if the gadgets value could be set
                FALSE if it could not
    Purpose:    To insert an item into a tree control

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetStringGadgetValue

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

CTreeItemID DialogManager::SetTreeGadgetItem(CWindowID wnd,
                                            CGadgetID Gadget,
                                            CTreeItemID hParent,
                                            const StringBase& str,
                                            CTreeItemID hInsAfter,
                                            INT32 iImage,
                                            CCObject* pObj)
{
    wxWindow * pGadget = GetGadget(wnd, Gadget);
    if (!pGadget) return CTreeItemID();

    wxString String = str;

    if ( pGadget->IsKindOf(CLASSINFO(wxTreeCtrl))
        )
    {
        CamelotTreeItemData* pData = NULL;
        if (pObj)
            pData = new CamelotTreeItemData(pObj);

        return ((wxTreeCtrl*)pGadget)->InsertItem(hParent, hInsAfter, String, iImage, -1, pData);
    }

    ERROR3("SetTreeGadgetItem called on non-tree gadget");

    return CTreeItemID();
}




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

>   static CCObject* DialogManager::GetTreeGadgetItemData(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID: Dialog box window identifier
                Gadget: Gadget identifier
    Outputs:    -
    Returns:    TRUE if the gadgets value could be set
                FALSE if it could not
    Purpose:    To insert an item into a tree control

    Errors:     If the function is called on an invalid control then an ENSURE failure will
                occur in a DEBUG build. In a retail build FALSE is returned.

    SeeAlso:    DialogOp::SetStringGadgetValue

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

CCObject* DialogManager::GetTreeGadgetItemData(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem)
{
    wxWindow* pGadget = GetGadget(wnd, Gadget);
    if (!pGadget) return NULL;

    if ( pGadget->IsKindOf(CLASSINFO(wxTreeCtrl))
        )
    {
        wxTreeItemData* pData = ((wxTreeCtrl*)pGadget)->GetItemData(hItem);
        if (pData) // && pData->IsKindOf(CLASSINFO(CamelotTreeItemData)))
            return ((CamelotTreeItemData*)pData)->GetObject();

        return NULL;
    }

    ERROR3("SetTreeGadgetItem called on non-tree gadget");

    return NULL;
}




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

>   BOOL DialogManager::SelectTreeGadgetItem(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem, BOOL bNewState)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID    - Dialog box window identifier
                Gadget      - Gadget identifier
                hItem       - ID of item
                bNewState   - Selection state to set
    Outputs:    -
    Returns:    TRUE if the gadget item was selected
                FALSE if it could not
    Purpose:    To select an item in a tree control

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

BOOL DialogManager::SelectTreeGadgetItem(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem, BOOL bNewState)
{
    wxWindow* pGadget = GetGadget(wnd, Gadget);
    if (!pGadget) return FALSE;

    if ( pGadget->IsKindOf(CLASSINFO(wxTreeCtrl))
        )
    {
        ((wxTreeCtrl*)pGadget)->SelectItem(hItem, FALSE != bNewState);
        return TRUE;
    }

    ERROR3("SetTreeGadgetItem called on non-tree gadget");
    return FALSE;
}




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

>   CTreeItemID DialogManager::GetTreeGadgetRootItem(CWindowID wnd, CGadgetID Gadget)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID    - Dialog box window identifier
                Gadget      - Gadget identifier
    Outputs:    -
    Returns:    ID of item
    Purpose:    To get the ID of the root item in the tree control

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

CTreeItemID DialogManager::GetTreeGadgetRootItem(CWindowID wnd, CGadgetID Gadget)
{
    wxWindow* pGadget = GetGadget(wnd, Gadget);
    if (!pGadget) return CTreeItemID();

    if ( pGadget->IsKindOf(CLASSINFO(wxTreeCtrl))
        )
    {
        return ((wxTreeCtrl*)pGadget)->GetRootItem();

        return CTreeItemID();
    }

    ERROR3("SetTreeGadgetItem called on non-tree gadget");
    return CTreeItemID();
}




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

>   CTreeItemID DialogManager::GetTreeGadgetFirstSelectedItem(CWindowID wnd, CGadgetID Gadget)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID    - Dialog box window identifier
                Gadget      - Gadget identifier
                hItem       - ID of item
    Outputs:    -
    Returns:    ID of item
    Purpose:    To get the ID of the first selected item in the tree control

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

CTreeItemID DialogManager::GetTreeGadgetFirstSelectedItem(CWindowID wnd, CGadgetID Gadget)
{
    wxWindow* pGadget = GetGadget(wnd, Gadget);
    if (!pGadget) return CTreeItemID();

    if ( pGadget->IsKindOf(CLASSINFO(wxTreeCtrl))
        )
    {
        return ((wxTreeCtrl*)pGadget)->GetSelection();
    }

    ERROR3("SetTreeGadgetItem called on non-tree gadget");
    return CTreeItemID();
}




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

>   BOOL DialogManager::TreeGadgetExpandItem(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID    - Dialog box window identifier
                Gadget      - Gadget identifier
                hItem       - ID of item
                bNewState   - Selection state to set
    Outputs:    -
    Returns:    TRUE if the gadget item was expanded
                FALSE if it could not
    Purpose:    To expand an item in the tree control

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

BOOL DialogManager::TreeGadgetExpandItem(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem)
{
    wxWindow* pGadget = GetGadget(wnd, Gadget);
    if (!pGadget) return FALSE;

    if ( pGadget->IsKindOf(CLASSINFO(wxTreeCtrl))
        )
    {
        ((wxTreeCtrl*)pGadget)->Expand(hItem);
        return TRUE;
    }

    ERROR3("SetTreeGadgetItem called on non-tree gadget");
    return FALSE;
}




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

>   CTreeItemID DialogManager::GetTreeGadgetNextVisItem(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID    - Dialog box window identifier
                Gadget      - Gadget identifier
                hItem       - ID of item
    Outputs:    -
    Returns:    ID of item
    Purpose:    To get the ID of the next visible item in the tree control after a specified item

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

CTreeItemID DialogManager::GetTreeGadgetNextVisItem(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem)
{
    wxWindow* pGadget = GetGadget(wnd, Gadget);
    if (!pGadget) return CTreeItemID();

    if ( pGadget->IsKindOf(CLASSINFO(wxTreeCtrl))
        )
    {
        return ((wxTreeCtrl*)pGadget)->GetNextVisible(hItem);
    }

    ERROR3("SetTreeGadgetItem called on non-tree gadget");
    return CTreeItemID();
}




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

>   CTreeItemID DialogManager::GetTreeGadgetFirstChildItem(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID    - Dialog box window identifier
                Gadget      - Gadget identifier
                hItem       - ID of item
    Outputs:    -
    Returns:    ID of item
    Purpose:    To get the ID of the first child item of the specified in the tree control

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

CTreeItemID DialogManager::GetTreeGadgetFirstChildItem(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem)
{
    wxWindow* pGadget = GetGadget(wnd, Gadget);
    if (!pGadget) return CTreeItemID();

    if ( pGadget->IsKindOf(CLASSINFO(wxTreeCtrl))
        )
    {
        wxTreeItemIdValue sessioncookie;
        return ((wxTreeCtrl*)pGadget)->GetFirstChild(hItem, sessioncookie);
    }

    ERROR3("SetTreeGadgetItem called on non-tree gadget");
    return CTreeItemID();
}




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

>   size_t DialogManager::GetTreeGadgetChildrenCount(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem, BOOL bRecursive)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID    - Dialog box window identifier
                Gadget      - Gadget identifier
                hItem       - ID of item
                bRecursive  - TRUE if should count children recursively
    Outputs:    -
    Returns:    number of children
    Purpose:    To get the number of children of an item in a tree control

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

UINT32 DialogManager::GetTreeGadgetChildrenCount(CWindowID wnd, CGadgetID Gadget, CTreeItemID hItem, BOOL bRecursive)
{
    wxWindow* pGadget = GetGadget(wnd, Gadget);
    if (!pGadget) return 0;

    if( pGadget->IsKindOf( CLASSINFO(wxTreeCtrl) ) )
    {
        return UINT32( ((wxTreeCtrl*)pGadget)->GetChildrenCount( hItem, FALSE != bRecursive ) );
    }

    ERROR3("SetTreeGadgetItem called on non-tree gadget");
    return 0;
}




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

>   UINT32 DialogManager::GetGadgetImageCount(CWindowID wnd, CGadgetID Gadget)

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     WindowID    - Dialog box window identifier
                Gadget      - Gadget identifier
    Outputs:    -
    Returns:    Number of images in tree control
    Purpose:    To get the number of images set in the trree control

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

UINT32 DialogManager::GetGadgetImageCount(CWindowID wnd, CGadgetID Gadget)
{
    ERROR3("Unimplemented!");
    return 0;
}


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

>   CGadgetImageList::~CGadgetImageList()

    Author:     Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Purpose:    Destructor

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

CGadgetImageList::~CGadgetImageList()
{
    m_BitmapIDList.DeleteAll();
}

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

>   UINT32 CGadgetImageList::Add(CDlgResID resID)

    Author:     Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     resID - resource ID of the image
    Returns:    The index of the image
    Purpose:    Adds an image to the list

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

UINT32 CGadgetImageList::Add(CDlgResID resID)
{
    m_BitmapIDList.AddTail(new ResIDListItem(resID));
    return m_BitmapIDList.GetCount()-1;
}


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

>   ListItem* CGadgetImageList::FindFirstBitmap(ResourceID* presID) const

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     -
    Outputs:    presID  - ResourceID of first tiem in list
    Returns:    Pointer to context list item for iteration or NULL
    Purpose:    To get the first resourceID stored in this image list object

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

ListItem* CGadgetImageList::FindFirstBitmap(ResourceID* presID) const
{
    ResIDListItem* pItem = (ResIDListItem*)m_BitmapIDList.GetHead();
    if (presID && pItem)
        *presID = pItem->m_ResID;

    return (ListItem*)pItem;
}




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

>   ListItem* CGadgetImageList::FindNextBitmap(ListItem* pContextItem, ResourceID* presID) const

    Author:     Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>
    Created:    08/Feb/2006
    Inputs:     pContextItem - pointer to current context
    Outputs:    ResourceID - resource ID from list item
    Returns:    Pointer to context list item for iteration or NULL
    Purpose:    To get the next resourceID stored in this image list object after the specified item

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

ListItem* CGadgetImageList::FindNextBitmap(ListItem* pContextItem, ResourceID* presID) const
{
    ResIDListItem* pItem = (ResIDListItem*)m_BitmapIDList.GetNext(pContextItem);        // (Ahem! Maybe there's a better way to do this...)
    if (presID && pItem)
        *presID = pItem->m_ResID;

    return (ListItem*)pItem;
}

---