10.2 fixes

[wxWidgets.git] / samples / regtest / regtest.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        regtest.cpp
// Purpose:     wxRegKey class demo
// Author:      Vadim Zeitlin
// Modified by:
// Created:     03.04.98
// RCS-ID:      $Id$
// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows license
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/wxprec.h"

#ifdef  __BORLANDC__
#   pragma hdrstop
#endif

#ifndef WX_PRECOMP
#   include "wx/wx.h"
#endif

#include "wx/treectrl.h"
#include "wx/config.h"
#include "wx/imaglist.h"
#include "wx/tokenzr.h"

#if wxUSE_CONFIG_NATIVE && defined( __WXMSW__ )
#   define DO_REGTEST 1
#else
#   define DO_REGTEST 0
#endif

// ----------------------------------------------------------------------------
// application type
// ----------------------------------------------------------------------------
class RegApp : public wxApp
{
public:
    bool OnInit();
};

// ----------------------------------------------------------------------------
// image list with registry icons
// ----------------------------------------------------------------------------
class RegImageList : public wxImageList
{
public:
    enum Icon
    {
        Root,
        ClosedKey,
        OpenedKey,
        TextValue,
        BinaryValue
    };

    RegImageList();
};

#if DO_REGTEST

// ----------------------------------------------------------------------------
// our control
// ----------------------------------------------------------------------------
class RegTreeCtrl : public wxTreeCtrl
{
public:
    // ctor & dtor
    RegTreeCtrl(wxWindow *parent, wxWindowID id);
    virtual ~RegTreeCtrl();

    // notifications
    void OnDeleteItem    (wxTreeEvent& event);
    void OnItemExpanding (wxTreeEvent& event);
    void OnSelChanged    (wxTreeEvent& event);

    void OnBeginEdit     (wxTreeEvent& event);
    void OnEndEdit       (wxTreeEvent& event);

    void OnBeginDrag     (wxTreeEvent& event);
    void OnEndDrag       (wxTreeEvent& event);

    void OnRightClick    (wxMouseEvent& event);
    void OnChar          (wxKeyEvent& event);
    void OnIdle          (wxIdleEvent& event);

    // forwarded notifications (by the frame)
    void OnMenuTest();

    // operations
    void GoTo(const wxString& location);
    void DoRefresh();
    void DeleteSelected();
    void ShowProperties();
    void CreateNewKey(const wxString& strName);
    void CreateNewTextValue(const wxString& strName);
    void CreateNewBinaryValue(const wxString& strName);

    // information
    bool IsKeySelected() const;

private:
    // structure describing a registry key/value
    class TreeNode : public wxTreeItemData
    {
        WX_DEFINE_ARRAY_PTR(TreeNode *, TreeChildren);
    public:
        RegTreeCtrl  *m_pTree;     // must be !NULL
        TreeNode     *m_pParent;    // NULL only for the root node
        wxTreeItemId  m_id;         // the id of the tree control item
        wxString      m_strName;    // name of the key/value
        TreeChildren  m_aChildren;  // array of subkeys/values
        bool          m_bKey;       // key or value?
        wxRegKey     *m_pKey;       // only may be !NULL if m_bKey == true

        // trivial accessors
        wxTreeItemId  Id()     const { return m_id;              }
        bool          IsRoot() const { return m_pParent == NULL; }
        bool          IsKey()  const { return m_bKey;            }
        TreeNode     *Parent() const { return m_pParent;         }

        // notifications
        bool OnExpand();
        void OnCollapse();

        // operations
        void Refresh();
        bool DeleteChild(TreeNode *child);
        void DestroyChildren();
        const wxChar *FullName() const;

        // get the associated key: make sure the pointer is !NULL
        wxRegKey& Key() { if ( !m_pKey ) OnExpand(); return *m_pKey; }

        // dtor deletes all children
        ~TreeNode();
    };

    wxImageList *m_imageList;
    wxMenu      *m_pMenuPopup;

    TreeNode    *m_pRoot;

    TreeNode    *m_draggedItem;       // the item being dragged
    bool         m_copyOnDrop;        // if false, then move

    bool         m_restoreStatus;     // after OnItemExpanding()

    wxString     m_nameOld;           // the initial value of item being renamed

    TreeNode *GetNode(const wxTreeEvent& event)
        { return (TreeNode *)GetItemData(event.GetItem()); }

public:
    // create a new node and insert it to the tree
    TreeNode *InsertNewTreeNode(TreeNode *pParent,
        const wxString& strName,
        int idImage = RegImageList::ClosedKey,
        const wxString *pstrValue = NULL);

    // add standard registry keys
    void AddStdKeys();

private:
    DECLARE_EVENT_TABLE()
};

#endif // #if DO_REGTEST

// ----------------------------------------------------------------------------
// the main window of our application
// ----------------------------------------------------------------------------
class RegFrame : public wxFrame
{
public:
    // ctor & dtor
    RegFrame(wxFrame *parent, wxChar *title, int x, int y, int w, int h);
    virtual ~RegFrame();

    // callbacks
    void OnQuit (wxCommandEvent& event);
    void OnAbout(wxCommandEvent& event);
    void OnTest (wxCommandEvent& event);

    void OnGoTo (wxCommandEvent& event);

    void OnExpand  (wxCommandEvent& event);
    void OnCollapse(wxCommandEvent& event);
    void OnToggle  (wxCommandEvent& event);
    void OnRefresh (wxCommandEvent& event);

    void OnDelete   (wxCommandEvent& event);
    void OnNewKey   (wxCommandEvent& event);
    void OnNewText  (wxCommandEvent& event);
    void OnNewBinary(wxCommandEvent& event);

    void OnInfo     (wxCommandEvent& event);

    DECLARE_EVENT_TABLE()

private:

#if DO_REGTEST
    RegTreeCtrl *m_treeCtrl;
#endif
};

// ----------------------------------------------------------------------------
// various ids
// ----------------------------------------------------------------------------

enum
{
    Menu_Quit     = 100,
    Menu_About,
    Menu_Test,
    Menu_GoTo,
    Menu_Expand,
    Menu_Collapse,
    Menu_Toggle,
    Menu_Refresh,
    Menu_New,
    Menu_NewKey,
    Menu_NewText,
    Menu_NewBinary,
    Menu_Delete,
    Menu_Info,

    Ctrl_RegTree  = 200,
};

// ----------------------------------------------------------------------------
// event tables
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(RegFrame, wxFrame)
    EVT_MENU(Menu_Test,     RegFrame::OnTest)
    EVT_MENU(Menu_About,    RegFrame::OnAbout)
    EVT_MENU(Menu_Quit,     RegFrame::OnQuit)
    EVT_MENU(Menu_GoTo,     RegFrame::OnGoTo)
    EVT_MENU(Menu_Expand,   RegFrame::OnExpand)
    EVT_MENU(Menu_Collapse, RegFrame::OnCollapse)
    EVT_MENU(Menu_Toggle,   RegFrame::OnToggle)
    EVT_MENU(Menu_Refresh,  RegFrame::OnRefresh)
    EVT_MENU(Menu_Delete,   RegFrame::OnDelete)
    EVT_MENU(Menu_NewKey,   RegFrame::OnNewKey)
    EVT_MENU(Menu_NewText,  RegFrame::OnNewText)
    EVT_MENU(Menu_NewBinary,RegFrame::OnNewBinary)
    EVT_MENU(Menu_Info,     RegFrame::OnInfo)
END_EVENT_TABLE()

#if DO_REGTEST

BEGIN_EVENT_TABLE(RegTreeCtrl, wxTreeCtrl)
    EVT_TREE_DELETE_ITEM   (Ctrl_RegTree, RegTreeCtrl::OnDeleteItem)
    EVT_TREE_ITEM_EXPANDING(Ctrl_RegTree, RegTreeCtrl::OnItemExpanding)
    EVT_TREE_SEL_CHANGED   (Ctrl_RegTree, RegTreeCtrl::OnSelChanged)

    EVT_TREE_BEGIN_LABEL_EDIT(Ctrl_RegTree, RegTreeCtrl::OnBeginEdit)
    EVT_TREE_END_LABEL_EDIT  (Ctrl_RegTree, RegTreeCtrl::OnEndEdit)

    EVT_TREE_BEGIN_DRAG    (Ctrl_RegTree, RegTreeCtrl::OnBeginDrag)
    EVT_TREE_BEGIN_RDRAG   (Ctrl_RegTree, RegTreeCtrl::OnBeginDrag)
    EVT_TREE_END_DRAG      (Ctrl_RegTree, RegTreeCtrl::OnEndDrag)

    EVT_CHAR      (RegTreeCtrl::OnChar)
    EVT_RIGHT_DOWN(RegTreeCtrl::OnRightClick)
    EVT_IDLE      (RegTreeCtrl::OnIdle)
END_EVENT_TABLE()

#endif

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// global functions
// ----------------------------------------------------------------------------

// create the "registry operations" menu
wxMenu *CreateRegistryMenu()
{
    wxMenu *pMenuNew = new wxMenu;
    pMenuNew->Append(Menu_NewKey,    _T("&Key"),          _T("Create a new key"));
    pMenuNew->AppendSeparator();
    pMenuNew->Append(Menu_NewText,   _T("&Text value"),   _T("Create a new text value"));
    pMenuNew->Append(Menu_NewBinary, _T("&Binary value"), _T("Create a new binary value"));

    wxMenu *pMenuReg = new wxMenu;
    pMenuReg->Append(Menu_New, _T("&New"), pMenuNew);
    pMenuReg->Append(Menu_Delete,   _T("&Delete..."), _T("Delete selected key/value"));
    pMenuReg->AppendSeparator();
    pMenuReg->Append(Menu_GoTo,     _T("&Go to...\tCtrl-G"),    _T("Go to registry key"));
    pMenuReg->Append(Menu_Expand,   _T("&Expand"),    _T("Expand current key"));
    pMenuReg->Append(Menu_Collapse, _T("&Collapse"),  _T("Collapse current key"));
    pMenuReg->Append(Menu_Toggle,   _T("&Toggle"),    _T("Toggle current key"));
    pMenuReg->AppendSeparator();
    pMenuReg->Append(Menu_Refresh,  _T("&Refresh"),   _T("Refresh the subtree"));
    pMenuReg->AppendSeparator();
    pMenuReg->Append(Menu_Info,     _T("&Properties"),_T("Information about current selection"));

    return pMenuReg;
}

// ----------------------------------------------------------------------------
// application class
// ----------------------------------------------------------------------------
IMPLEMENT_APP(RegApp)

// `Main program' equivalent, creating windows and returning main app frame
bool RegApp::OnInit()
{
    // create the main frame window and show it
    RegFrame *frame = new RegFrame(NULL, _T("wxRegTest"), 50, 50, 600, 350);
    frame->Show(true);

    SetTopWindow(frame);

    return true;
}

// ----------------------------------------------------------------------------
// RegFrame
// ----------------------------------------------------------------------------

RegFrame::RegFrame(wxFrame *parent, wxChar *title, int x, int y, int w, int h)
        : wxFrame(parent, wxID_ANY, title, wxPoint(x, y), wxSize(w, h))
{
    // this reduces flicker effects
    SetBackgroundColour(wxColour(255, 255, 255));

    // set the icon
    // ------------
    SetIcon(wxIcon(_T("app_icon")));

    // create menu
    // -----------
    wxMenu *pMenuFile = new wxMenu;
    pMenuFile->Append(Menu_Test, _T("Te&st"), _T("Test key creation"));
    pMenuFile->AppendSeparator();
    pMenuFile->Append(Menu_About, _T("&About..."), _T("Show an extraordinarly beautiful dialog"));
    pMenuFile->AppendSeparator();
    pMenuFile->Append(Menu_Quit,  _T("E&xit"), _T("Quit this program"));

    wxMenuBar *pMenu = new wxMenuBar;
    pMenu->Append(pMenuFile, _T("&File"));
    pMenu->Append(CreateRegistryMenu(),  _T("&Registry"));
    SetMenuBar(pMenu);

#if DO_REGTEST
    // create child controls
    // ---------------------
    m_treeCtrl = new RegTreeCtrl(this, Ctrl_RegTree);
#endif

#if wxUSE_STATUSBAR
    // create the status line
    // ----------------------
    CreateStatusBar(2);
#endif // wxUSE_STATUSBAR
}

RegFrame::~RegFrame()
{
#if DO_REGTEST
    // this makes deletion of it *much* quicker
    m_treeCtrl->Hide();
#endif
}

void RegFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    Close(true);
}

void RegFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    wxMessageDialog dialog(this,
        _T("wxRegistry sample\n")