updated VC build instructions

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

diff --git a/samples/regtest/regtest.cpp b/samples/regtest/regtest.cpp
index f670fc00ad735c872d589237b79e07737bb578e8..76845feb09506282befaac326e0fd75064307434 100644 (file)
--- a/samples/regtest/regtest.cpp
+++ b/samples/regtest/regtest.cpp
@@ -1,8 +1,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        registry.cpp
+// Name:        regtest.cpp

 // Purpose:     wxRegKey class demo
 // Author:      Vadim Zeitlin
 // Purpose:     wxRegKey class demo
 // Author:      Vadim Zeitlin

-// Modified by: 
+// Modified by:

 // Created:     03.04.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     03.04.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>


@@ -19,25 +19,31 @@
 #include "wx/wxprec.h"
 
 #ifdef  __BORLANDC__
 #include "wx/wxprec.h"
 
 #ifdef  __BORLANDC__

-  #pragma hdrstop
+#   pragma hdrstop

 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-  #include "wx/wx.h"
+#   include "wx/wx.h"

 #endif
 
 #endif
 

-#include "wx/log.h"

 #include "wx/treectrl.h"
 #include "wx/treectrl.h"

-#include "wx/msw/registry.h"
-#include "wx/msw/imaglist.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
 
 // ----------------------------------------------------------------------------
 // application type
 // ----------------------------------------------------------------------------
 class RegApp : public wxApp

-{ 
+{

 public:
 public:

-  bool OnInit(void);
+    bool OnInit();

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -46,20 +52,19 @@ public:
 class RegImageList : public wxImageList
 {
 public:
 class RegImageList : public wxImageList
 {
 public:

-  enum Icon
-  {
-    Root,
-    ClosedKey,
-    OpenedKey,
-    TextValue,
-    BinaryValue,
-  };
-
-  RegImageList();
+    enum Icon
+    {
+        Root,
+        ClosedKey,
+        OpenedKey,
+        TextValue,
+        BinaryValue
+    };
+
+    RegImageList();

 };
 
 };
 

-// array of children of the node
-//class TreeNode;
+#if DO_REGTEST

 
 // ----------------------------------------------------------------------------
 // our control
 
 // ----------------------------------------------------------------------------
 // our control


@@ -67,121 +72,144 @@ public:
 class RegTreeCtrl : public wxTreeCtrl
 {
 public:
 class RegTreeCtrl : public wxTreeCtrl
 {
 public:

-  // ctor & dtor
-  RegTreeCtrl(wxWindow *parent, wxWindowID id);
-  virtual ~RegTreeCtrl();
+    // ctor & dtor
+    RegTreeCtrl(wxWindow *parent, wxWindowID id);
+    virtual ~RegTreeCtrl();

 
 

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

 
 

-  void OnRightClick   (wxMouseEvent& event);
-  void OnChar         (wxKeyEvent& event);
+    void OnBeginEdit     (wxTreeEvent& event);
+    void OnEndEdit       (wxTreeEvent& event);

 
 

-  // forwarded notifications (by the frame)
-  void OnMenuTest();
+    void OnBeginDrag     (wxTreeEvent& event);
+    void OnEndDrag       (wxTreeEvent& event);

 
 

-  // operations
-  void DeleteSelected();
-  void CreateNewKey(const wxString& strName);
-  void CreateNewTextValue(const wxString& strName);
-  void CreateNewBinaryValue(const wxString& strName);
+    void OnRightClick    (wxMouseEvent& event);
+    void OnChar          (wxKeyEvent& event);
+    void OnIdle          (wxIdleEvent& event);

 
 

-  // information
-  bool IsKeySelected() const;
+    // 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);

 
 

-  DECLARE_EVENT_TABLE();
+    // information
+    bool IsKeySelected() const;

 
 private:
 
 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
+        long          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

 
 

-  // structure describing a registry key/value
-       class TreeNode : public wxTreeItemData
-  {
-WX_DEFINE_ARRAY(TreeNode *, TreeChildren);
-  public:
-    RegTreeCtrl  *m_pTree;     // must be !NULL
-    TreeNode     *m_pParent;    // NULL only for the root node
-    long          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
-    long          m_lDummy;     // dummy subkey (to make expansion possible)
-
-    // ctor
-    TreeNode() { m_lDummy = 0; }
-
-    // trivial accessors
-    long      Id()     const { return m_id;              }
-    bool      IsRoot() const { return m_pParent == NULL; }
-    bool      IsKey()  const { return m_bKey;            }
-    TreeNode *Parent() const { return m_pParent;         }
+        // trivial accessors
+        long      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();
+        // notifications
+        bool OnExpand();
+        void OnCollapse();

 
 

-    // operations
-    void Refresh() { OnCollapse(); OnExpand(); }
-    void AddDummy();
-    void DestroyChildren();
-    const char *FullName() const;
+        // 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();
+    };

 
 

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

 
 

-    // dtor deletes all children
-    ~TreeNode();
-  };
+    TreeNode    *m_pRoot;

 
 

-  wxMenu      *m_pMenuPopup;
-  TreeNode    *m_pRoot;
-  wxImageList *m_imageList;
+    TreeNode    *m_draggedItem;       // the item being dragged
+    bool         m_copyOnDrop;        // if false, then move

 
 

-  TreeNode *GetNode(const wxTreeEvent& event)
-    { return (TreeNode *)GetItemData((WXHTREEITEM)event.GetItem()); }
+    bool         m_restoreStatus;     // after OnItemExpanding()
+
+    wxString     m_nameOld;           // the initial value of item being renamed
+
+    TreeNode *GetNode(const wxTreeEvent& event)
+        { return (TreeNode *)GetItemData((WXHTREEITEM)event.GetItem()); }

 
 public:
 
 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();
+    // 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
 // ----------------------------------------------------------------------------
 // the main window of our application
 // ----------------------------------------------------------------------------
 class RegFrame : public wxFrame

-{ 
+{

 public:
 public:

-  // ctor & dtor
-  RegFrame(wxFrame *parent, char *title, int x, int y, int w, int h);
-  virtual ~RegFrame(void);
-    
-  // callbacks
-  void OnQuit (wxCommandEvent& event);
-  void OnAbout(wxCommandEvent& event);
-  void OnTest (wxCommandEvent& event);
+    // 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 OnExpand  (wxCommandEvent& event);
-  void OnCollapse(wxCommandEvent& event);
-  void OnToggle  (wxCommandEvent& event);
+    void OnGoTo (wxCommandEvent& event);

 
 

-  void OnDelete   (wxCommandEvent& event);
-  void OnNewKey   (wxCommandEvent& event);
-  void OnNewText  (wxCommandEvent& event);
-  void OnNewBinary(wxCommandEvent& event);
+    void OnExpand  (wxCommandEvent& event);
+    void OnCollapse(wxCommandEvent& event);
+    void OnToggle  (wxCommandEvent& event);
+    void OnRefresh (wxCommandEvent& event);

 
 

-  bool OnClose  () { return TRUE; }
+    void OnDelete   (wxCommandEvent& event);
+    void OnNewKey   (wxCommandEvent& event);
+    void OnNewText  (wxCommandEvent& event);
+    void OnNewBinary(wxCommandEvent& event);

 
 

-  DECLARE_EVENT_TABLE();
+    void OnInfo     (wxCommandEvent& event);
+
+    DECLARE_EVENT_TABLE()

 
 private:
 
 private:

-  RegTreeCtrl *m_treeCtrl;
+
+#if DO_REGTEST
+    RegTreeCtrl *m_treeCtrl;
+#endif

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -190,19 +218,22 @@ private:
 
 enum
 {
 
 enum
 {

-  Menu_Quit     = 100,
-  Menu_About,
-  Menu_Test,
-  Menu_Expand,
-  Menu_Collapse,
-  Menu_Toggle,
-  Menu_New,
-  Menu_NewKey,  
-  Menu_NewText, 
-  Menu_NewBinary,
-  Menu_Delete,
-
-  Ctrl_RegTree  = 200,
+    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,

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -210,27 +241,42 @@ enum
 // ----------------------------------------------------------------------------
 
 BEGIN_EVENT_TABLE(RegFrame, wxFrame)
 // ----------------------------------------------------------------------------
 
 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_Expand,   RegFrame::OnExpand)
-  EVT_MENU(Menu_Collapse, RegFrame::OnCollapse)
-  EVT_MENU(Menu_Toggle,   RegFrame::OnToggle)
-  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_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()
 
 END_EVENT_TABLE()
 

+#if DO_REGTEST
+

 BEGIN_EVENT_TABLE(RegTreeCtrl, wxTreeCtrl)
 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_DELETE_ITEM   (Ctrl_RegTree, RegTreeCtrl::OnDeleteItem)
+    EVT_TREE_ITEM_EXPANDING(Ctrl_RegTree, RegTreeCtrl::OnItemExpanding)
+    EVT_TREE_SEL_CHANGED   (Ctrl_RegTree, RegTreeCtrl::OnSelChanged)

 
 

-  EVT_CHAR      (RegTreeCtrl::OnChar)
-  EVT_RIGHT_DOWN(RegTreeCtrl::OnRightClick)
+    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()
 
 END_EVENT_TABLE()
 

+#endif
+

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


@@ -242,21 +288,26 @@ END_EVENT_TABLE()
 // create the "registry operations" menu
 wxMenu *CreateRegistryMenu()
 {
 // create the "registry operations" menu
 wxMenu *CreateRegistryMenu()
 {

-  wxMenu *pMenuNew = new wxMenu;
-  pMenuNew->Append(Menu_NewKey,    "&Key",          "Create a new key");
-  pMenuNew->AppendSeparator();
-  pMenuNew->Append(Menu_NewText,   "&Text value",   "Create a new text value");
-  pMenuNew->Append(Menu_NewBinary, "&Binary value", "Create a new binary value");
-
-  wxMenu *pMenuReg = new wxMenu;
-  pMenuReg->Append(Menu_New, "&New", pMenuNew);
-  pMenuReg->Append(Menu_Delete,   "&Delete...", "Delete selected key/value");
-  pMenuReg->AppendSeparator();
-  pMenuReg->Append(Menu_Expand,   "&Expand",    "Expand current key");
-  pMenuReg->Append(Menu_Collapse, "&Collapse",  "Collapse current key");
-  pMenuReg->Append(Menu_Toggle,   "&Toggle",    "Toggle current key");
-
-  return pMenuReg;
+    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;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -267,308 +318,584 @@ IMPLEMENT_APP(RegApp)
 // `Main program' equivalent, creating windows and returning main app frame
 bool RegApp::OnInit()
 {
 // `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, "wxRegKey Test", 50, 50, 600, 350);
-  frame->Show(true);
-  
-  SetTopWindow(frame);
+    // create the main frame window and show it
+    RegFrame *frame = new RegFrame(NULL, _T("wxRegTest"), 50, 50, 600, 350);
+    frame->Show(true);

 
 

-  return true;
+    SetTopWindow(frame);
+
+    return true;

 }
 
 // ----------------------------------------------------------------------------
 // RegFrame
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // RegFrame
 // ----------------------------------------------------------------------------
 

-RegFrame::RegFrame(wxFrame *parent, char *title, int x, int y, int w, int h)
+RegFrame::RegFrame(wxFrame *parent, wxChar *title, int x, int y, int w, int h)

         : wxFrame(parent, -1, title, wxPoint(x, y), wxSize(w, h))
 {
         : wxFrame(parent, -1, title, wxPoint(x, y), wxSize(w, h))
 {

-  // this reduces flicker effects
-  SetBackgroundColour(wxColour(255, 255, 255));
+    // 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

 
 

-  // set the icon
-  // ------------
-  SetIcon(wxIcon("app_icon"));
+    // create the status line
+    // ----------------------
+    CreateStatusBar(2);
+}

 
 

-  // create menu
-  // -----------
-  wxMenu *pMenuFile = new wxMenu;
-  pMenuFile->Append(Menu_Test, "Te&st", "Test key creation");
-  pMenuFile->AppendSeparator();
-  pMenuFile->Append(Menu_About, "&About...", "Show an extraordinarly beautiful dialog");
-  pMenuFile->AppendSeparator();
-  pMenuFile->Append(Menu_Quit,  "E&xit", "Quit this program");
+RegFrame::~RegFrame()
+{
+#if DO_REGTEST
+    // this makes deletion of it *much* quicker
+    m_treeCtrl->Hide();
+#endif
+}

 
 

-  wxMenuBar *pMenu = new wxMenuBar;
-  pMenu->Append(pMenuFile, "&File");
-  pMenu->Append(CreateRegistryMenu(),  "&Registry");
-  SetMenuBar(pMenu);
+void RegFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
+{
+    Close(true);
+}

 
 

-  // create child controls
-  // ---------------------
-  m_treeCtrl = new RegTreeCtrl(this, Ctrl_RegTree);
+void RegFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
+{
+    wxMessageDialog dialog(this,
+        _T("wxRegistry sample\n")
+        _T("© 1998, 2000 Vadim Zeitlin"),
+        _T("About wxRegTest"), wxOK);

 
 

-  // create the status line
-  // ----------------------
-  int aWidths[2];
-  aWidths[0] = 200;
-  aWidths[1] = -1;
-  CreateStatusBar(2);
-  SetStatusWidths(2, aWidths);
+    dialog.ShowModal();

 }
 
 }
 

-RegFrame::~RegFrame(void)
+void RegFrame::OnTest(wxCommandEvent& WXUNUSED(event))

 {
 {

+#if DO_REGTEST
+    m_treeCtrl->OnMenuTest();
+#endif

 }
 
 }
 

-void RegFrame::OnQuit(wxCommandEvent& event)
+void RegFrame::OnGoTo(wxCommandEvent& WXUNUSED(event))

 {
 {

-  Close(TRUE);
+    static wxString s_location = _T("HKEY_CURRENT_USER\\Software\\wxWindows");
+
+    wxString location = wxGetTextFromUser(
+        _T("Enter the location to go to:"),
+        _T("wxRegTest question"),
+        s_location,
+        this);
+
+    if ( !location )
+        return;
+
+    s_location = location;
+#if DO_REGTEST
+    m_treeCtrl->GoTo(location);
+#endif

 }
 
 }
 

-void RegFrame::OnAbout(wxCommandEvent& event)
+void RegFrame::OnExpand(wxCommandEvent& WXUNUSED(event))

 {
 {

-  wxMessageDialog dialog(this, "wxRegistry sample\n(c) 1998 Vadim Zeitlin",
-                         "About wxRegistry", wxOK);
-
-  dialog.ShowModal();
+#if DO_REGTEST
+    m_treeCtrl->Expand(m_treeCtrl->GetSelection());
+#endif

 }
 
 }
 

-void RegFrame::OnTest(wxCommandEvent& event)
+void RegFrame::OnCollapse(wxCommandEvent& WXUNUSED(event))

 {
 {

-  m_treeCtrl->OnMenuTest();
+#if DO_REGTEST
+    m_treeCtrl->Collapse(m_treeCtrl->GetSelection());
+#endif

 }
 
 }
 

-void RegFrame::OnExpand(wxCommandEvent& event)
+void RegFrame::OnToggle(wxCommandEvent& WXUNUSED(event))

 {
 {

-  m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_EXPAND);
+#if DO_REGTEST
+    m_treeCtrl->Toggle(m_treeCtrl->GetSelection());
+#endif

 }
 
 }
 

-void RegFrame::OnCollapse(wxCommandEvent& event)
+void RegFrame::OnRefresh(wxCommandEvent& WXUNUSED(event))

 {
 {

-  m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_COLLAPSE);
+#if DO_REGTEST
+    m_treeCtrl->DoRefresh();
+#endif

 }
 
 }
 

-void RegFrame::OnToggle(wxCommandEvent& event)
+void RegFrame::OnDelete(wxCommandEvent& WXUNUSED(event))

 {
 {

-  m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_TOGGLE);
+#if DO_REGTEST
+    m_treeCtrl->DeleteSelected();
+#endif

 }
 
 }
 

-void RegFrame::OnDelete(wxCommandEvent& event)
+void RegFrame::OnNewKey(wxCommandEvent& WXUNUSED(event))

 {
 {

-  m_treeCtrl->DeleteSelected();
+#if DO_REGTEST
+    if ( m_treeCtrl->IsKeySelected() )
+    {
+        m_treeCtrl->CreateNewKey(
+            wxGetTextFromUser(_T("Enter the name of the new key")));
+    }
+#endif

 }
 
 }
 

-void RegFrame::OnNewKey(wxCommandEvent& event)
+void RegFrame::OnNewText(wxCommandEvent& WXUNUSED(event))

 {
 {

-  if ( m_treeCtrl->IsKeySelected() ) {
-    m_treeCtrl->CreateNewKey(
-      wxGetTextFromUser("Enter the name of the new key"));
-  }
+#if DO_REGTEST
+    if ( m_treeCtrl->IsKeySelected() )
+    {
+        m_treeCtrl->CreateNewTextValue(
+            wxGetTextFromUser(_T("Enter the name for the new text value")));
+    }
+#endif

 }
 
 }
 

-void RegFrame::OnNewText(wxCommandEvent& event)
+void RegFrame::OnNewBinary(wxCommandEvent& WXUNUSED(event))

 {
 {

-  if ( m_treeCtrl->IsKeySelected() ) {
-    m_treeCtrl->CreateNewTextValue(
-      wxGetTextFromUser("Enter the name for the new text value"));
-  }
+#if DO_REGTEST
+    if ( m_treeCtrl->IsKeySelected() )
+    {
+        m_treeCtrl->CreateNewBinaryValue(
+            wxGetTextFromUser(_T("Enter the name for the new binary value")));
+    }
+#endif

 }
 
 }
 

-void RegFrame::OnNewBinary(wxCommandEvent& event)
+void RegFrame::OnInfo(wxCommandEvent& WXUNUSED(event))

 {
 {

-  if ( m_treeCtrl->IsKeySelected() ) {
-    m_treeCtrl->CreateNewBinaryValue(
-      wxGetTextFromUser("Enter the name for the new binary value"));
-  }
+#if DO_REGTEST
+    m_treeCtrl->ShowProperties();
+#endif

 }
 
 // ----------------------------------------------------------------------------
 // RegImageList
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
 // RegImageList
 // ----------------------------------------------------------------------------

-RegImageList::RegImageList() : wxImageList(16, 16, TRUE)
+RegImageList::RegImageList() : wxImageList(16, 16, true)

 {
 {

-  // should be in sync with enum RegImageList::RegIcon
-  static const char *aszIcons[] = { "key1","key2","key3","value1","value2" };
-  wxString str = "icon_";
-  for ( unsigned int n = 0; n < WXSIZEOF(aszIcons); n++ ) {
-    Add(wxIcon(str + aszIcons[n], wxBITMAP_TYPE_ICO_RESOURCE));
-  }
+    // should be in sync with enum RegImageList::RegIcon
+    static const wxChar *aszIcons[] = { _T("key1"),_T("key2"),_T("key3"),_T("value1"),_T("value2") };
+    wxString str = _T("icon_");
+    for ( unsigned int n = 0; n < WXSIZEOF(aszIcons); n++ )
+    {
+        Add(wxIcon(str + aszIcons[n], wxBITMAP_TYPE_ICO_RESOURCE));
+    }

 }
 
 }
 

+#if DO_REGTEST
+

 // ----------------------------------------------------------------------------
 // RegTreeCtrl
 // ----------------------------------------------------------------------------
 
 // create a new tree item and insert it into the tree
 // ----------------------------------------------------------------------------
 // RegTreeCtrl
 // ----------------------------------------------------------------------------
 
 // create a new tree item and insert it into the tree

-RegTreeCtrl::TreeNode *RegTreeCtrl::InsertNewTreeNode(TreeNode *pParent, 
+RegTreeCtrl::TreeNode *RegTreeCtrl::InsertNewTreeNode(TreeNode *pParent,

                                                       const wxString& strName,
                                                       int idImage,
                                                       const wxString *pstrValue)
 {
                                                       const wxString& strName,
                                                       int idImage,
                                                       const wxString *pstrValue)
 {

-  // create new item & insert it
-  TreeNode *pNewNode = new TreeNode;
-  pNewNode->m_pTree  = this;
-  pNewNode->m_pParent = pParent;
-  pNewNode->m_strName = strName;
-  pNewNode->m_bKey    = pstrValue == NULL;
-  pNewNode->m_pKey    = NULL;
-  pNewNode->m_id      = InsertItem(pParent ? pParent->m_id : 0, 
-                                   pNewNode->IsKey() ? strName : *pstrValue,
-                                   idImage);
+    // create new item & insert it
+    TreeNode *pNewNode = new TreeNode;
+    pNewNode->m_pTree  = this;
+    pNewNode->m_pParent = pParent;
+    pNewNode->m_strName = strName;
+    pNewNode->m_bKey    = pstrValue == NULL;
+    pNewNode->m_pKey    = NULL;
+    if (pParent)
+    {
+        pNewNode->m_id  = AppendItem(pParent->Id(),
+            pNewNode->IsKey() ? strName : *pstrValue,
+            idImage);
+    }
+    else
+    {
+        pNewNode->m_id  = AddRoot(strName);
+    }

 
 

-  wxASSERT_MSG( pNewNode->m_id, "can't create tree control item!");
+    wxASSERT_MSG( pNewNode->m_id, wxT("can't create tree control item!"));

 
 

-  // save the pointer in the item
-  SetItemData(pNewNode->m_id, pNewNode);
+    // save the pointer in the item
+    SetItemData(pNewNode->m_id, pNewNode);

 
 

-  // add it to the list of parent's children
-  if ( pParent != NULL ) {
-    pParent->m_aChildren.Add(pNewNode);
-  }
+    // add it to the list of parent's children
+    if ( pParent != NULL )
+    {
+        pParent->m_aChildren.Add(pNewNode);
+    }

 
 

-  // force the [+] button (@@@ not very elegant...)
-  if ( pNewNode->IsKey() )
-    pNewNode->AddDummy();
+    if ( pNewNode->IsKey() )
+    {
+        SetItemHasChildren(pNewNode->Id());

 
 

-  return pNewNode;
+        if ( !pNewNode->IsRoot() )
+        {
+            // set the expanded icon as well
+            SetItemImage(pNewNode->Id(),
+                RegImageList::OpenedKey,
+                wxTreeItemIcon_Expanded);
+        }
+    }
+
+    return pNewNode;

 }
 
 RegTreeCtrl::RegTreeCtrl(wxWindow *parent, wxWindowID id)
 }
 
 RegTreeCtrl::RegTreeCtrl(wxWindow *parent, wxWindowID id)

-           : wxTreeCtrl(parent, id, wxDefaultPosition, wxDefaultSize, 
-                        wxTR_HAS_BUTTONS | wxSUNKEN_BORDER)
+    : wxTreeCtrl(parent, id, wxDefaultPosition, wxDefaultSize,
+        wxTR_HAS_BUTTONS | wxTR_EDIT_LABELS | wxSUNKEN_BORDER)

 {
 {

-  // create the image list
-  // ---------------------
-  m_imageList = new RegImageList;
-  SetImageList(m_imageList, wxIMAGE_LIST_NORMAL);
-
-  // create root keys
-  // ----------------
-  m_pRoot = InsertNewTreeNode(NULL, "Registry Root", RegImageList::Root);
-
-  // create popup menu
-  // -----------------
-  m_pMenuPopup = CreateRegistryMenu();
+    // init members
+    m_draggedItem = NULL;
+    m_restoreStatus = false;
+
+    // create the image list
+    // ---------------------
+    m_imageList = new RegImageList;
+    SetImageList(m_imageList);
+
+    // create root keys
+    // ----------------
+    m_pRoot = InsertNewTreeNode(NULL, _T("Registry Root"), RegImageList::Root);
+
+    // create popup menu
+    // -----------------
+    m_pMenuPopup = CreateRegistryMenu();

 }
 
 RegTreeCtrl::~RegTreeCtrl()
 {
 }
 
 RegTreeCtrl::~RegTreeCtrl()
 {

-  delete m_pMenuPopup;
-  delete m_pRoot;
-  delete m_imageList;
+    delete m_pMenuPopup;
+    // delete m_pRoot; -- this is done by the tree now
+    delete m_imageList;

 }
 
 void RegTreeCtrl::AddStdKeys()
 {
 }
 
 void RegTreeCtrl::AddStdKeys()
 {

-  for ( unsigned int ui = 0; ui < wxRegKey::nStdKeys; ui++ ) {
-    InsertNewTreeNode(m_pRoot, wxRegKey::GetStdKeyName(ui));
-  }
+    for ( unsigned int ui = 0; ui < wxRegKey::nStdKeys; ui++ )
+    {
+        InsertNewTreeNode(m_pRoot, wxRegKey::GetStdKeyName(ui));
+    }

 }
 
 // ----------------------------------------------------------------------------
 // notifications
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // notifications
 // ----------------------------------------------------------------------------
 

+void RegTreeCtrl::OnIdle(wxIdleEvent& WXUNUSED(event))
+{
+    if ( m_restoreStatus )
+    {
+        // restore it after OnItemExpanding()
+        wxLogStatus(wxT("Ok"));
+        wxSetCursor(*wxSTANDARD_CURSOR);
+
+        m_restoreStatus = false;
+    }
+}
+

 void RegTreeCtrl::OnRightClick(wxMouseEvent& event)
 {
 void RegTreeCtrl::OnRightClick(wxMouseEvent& event)
 {

-  int iFlags;
-  long lId = HitTest(wxPoint(event.GetX(), event.GetY()), iFlags);
-  if ( iFlags & wxTREE_HITTEST_ONITEMLABEL ) {
-    // popup menu only if an item was clicked
-    wxASSERT( lId != 0 );
-    SelectItem(lId);
+    int iFlags;
+    long lId = HitTest(wxPoint(event.GetX(), event.GetY()), iFlags);
+    if ( iFlags & wxTREE_HITTEST_ONITEMLABEL )
+    {
+        // select the item first
+        SelectItem(lId);
+    }
+    //else: take the currently selected item if click not on item
+

     PopupMenu(m_pMenuPopup, event.GetX(), event.GetY());
     PopupMenu(m_pMenuPopup, event.GetX(), event.GetY());

-  }

 }
 
 
 }
 
 

-void RegTreeCtrl::OnDeleteItem(wxTreeEvent& event)
+void RegTreeCtrl::OnDeleteItem(wxTreeEvent& WXUNUSED(event))

 {
 }
 
 // test the key creation functions
 void RegTreeCtrl::OnMenuTest()
 {
 {
 }
 
 // test the key creation functions
 void RegTreeCtrl::OnMenuTest()
 {

-  long lId = GetSelection();
-  TreeNode *pNode = (TreeNode *)GetItemData(lId);
-
-  wxCHECK_RET( pNode != NULL, "tree item without data?" );
-
-  if ( pNode->IsRoot() ) {
-    wxLogError("Can't create a subkey under the root key.");
-    return;
-  }
-  if ( !pNode->IsKey() ) {
-    wxLogError("Can't create a subkey under a value!");
-    return;
-  }
-
-  wxRegKey key1(pNode->Key(), "key1");
-  if ( key1.Create() ) {
-    wxRegKey key2a(key1, "key2a"), key2b(key1, "key2b");
-    if ( key2a.Create() && key2b.Create() ) {
-      // put some values under the newly created keys
-      key1.SetValue("first_term", "10");
-      key1.SetValue("second_term", "7");
-      key2a = "this is the unnamed value";
-      key2b.SetValue("sum", 17);
-
-      // refresh tree
-      pNode->Refresh();
-      wxLogStatus("Test keys successfully added.");
-      return;
+    long lId = GetSelection();
+    TreeNode *pNode = (TreeNode *)GetItemData(lId);
+
+    wxCHECK_RET( pNode != NULL, wxT("tree item without data?") );
+
+    if ( pNode->IsRoot() )
+    {
+        wxLogError(wxT("Can't create a subkey under the root key."));
+        return;
+    }
+
+    if ( !pNode->IsKey() )
+    {
+        wxLogError(wxT("Can't create a subkey under a value!"));
+        return;
+    }
+
+    wxRegKey key1(pNode->Key(), _T("key1"));
+    if ( key1.Create() )
+    {
+        wxRegKey key2a(key1, _T("key2a")), key2b(key1, _T("key2b"));
+        if ( key2a.Create() && key2b.Create() )
+        {
+            // put some values under the newly created keys
+            key1.SetValue(wxT("first_term"), _T("10"));
+            key1.SetValue(wxT("second_term"), _T("7"));
+            key2a = _T("this is the unnamed value");
+            key2b.SetValue(wxT("sum"), 17);
+
+            // refresh tree
+            pNode->Refresh();
+            wxLogStatus(wxT("Test keys successfully added."));
+            return;
+        }

     }
     }

-  }
-  
-  wxLogError("Creation of test keys failed.");
+
+    wxLogError(wxT("Creation of test keys failed."));

 }
 
 void RegTreeCtrl::OnChar(wxKeyEvent& event)
 {
 }
 
 void RegTreeCtrl::OnChar(wxKeyEvent& event)
 {

-  if ( event.KeyCode() == WXK_DELETE )
-    DeleteSelected();
-  else
+    switch ( event.GetKeyCode() )
+    {
+    case WXK_DELETE:
+        DeleteSelected();
+        return;
+
+    case WXK_RETURN:
+        if ( event.AltDown() )
+        {
+            ShowProperties();
+
+            return;
+        }
+    }
+

     event.Skip();
 }
 
 void RegTreeCtrl::OnSelChanged(wxTreeEvent& event)
 {
     event.Skip();
 }
 
 void RegTreeCtrl::OnSelChanged(wxTreeEvent& event)
 {

-  wxFrame *pFrame = (wxFrame *)(wxWindow::GetParent());
-  pFrame->SetStatusText(GetNode(event)->FullName(), 1);
+    wxFrame *pFrame = (wxFrame *) wxWindow::GetParent();
+    pFrame->SetStatusText(GetNode(event)->FullName(), 1);

 }
 
 void RegTreeCtrl::OnItemExpanding(wxTreeEvent& event)
 {
 }
 
 void RegTreeCtrl::OnItemExpanding(wxTreeEvent& event)
 {

-  TreeNode *pNode = GetNode(event);
-  bool bExpanding = event.GetCode() == wxTREE_EXPAND_EXPAND;
+    TreeNode *pNode = GetNode(event);
+    bool bExpanding = event.GetKeyCode() == wxTREE_EXPAND_EXPAND;
+
+    // expansion might take some time
+    wxSetCursor(*wxHOURGLASS_CURSOR);
+    wxLogStatus(wxT("Working..."));
+    wxYield();  // to give the status line a chance to refresh itself
+    m_restoreStatus = true;   // some time later...
+
+    if ( pNode->IsKey() )
+    {
+        if ( bExpanding )
+        {
+            // expanding: add subkeys/values
+            if ( !pNode->OnExpand() )
+                return;
+        }
+        else
+        {
+            // collapsing: clean up
+            pNode->OnCollapse();
+        }
+    }
+}
+
+void RegTreeCtrl::OnBeginEdit(wxTreeEvent& event)
+{
+    TreeNode *pNode = GetNode(event);
+    if ( pNode->IsRoot() || pNode->Parent()->IsRoot() )
+    {
+        wxLogStatus(_T("This registry key can't be renamed."));
+
+        event.Veto();
+    }
+    else
+    {
+        m_nameOld = pNode->m_strName;
+    }
+}
+
+void RegTreeCtrl::OnEndEdit(wxTreeEvent& event)
+{
+    bool ok;
+
+    wxString name = event.GetLabel();
+
+    TreeNode *pNode = GetNode(event);
+    if ( pNode->IsKey() )
+    {
+        wxRegKey& key = pNode->Key();
+        ok = key.Rename(name);
+    }
+    else
+    {
+        pNode = pNode->Parent();
+        wxRegKey& key = pNode->Key();
+
+        ok = key.RenameValue(m_nameOld, name);
+    }
+
+    if ( !ok )
+    {
+        wxLogError(_T("Failed to rename '%s' to '%s'."),
+            m_nameOld.c_str(), name.c_str());
+    }
+#if 0   // MSW tree ctrl doesn't like this at all, it hangs
+    else
+    {
+        pNode->Refresh();
+    }
+#endif // 0
+}
+
+void RegTreeCtrl::OnBeginDrag(wxTreeEvent& event)
+{
+    m_copyOnDrop = event.GetEventType() == wxEVT_COMMAND_TREE_BEGIN_DRAG;
+
+    TreeNode *pNode = GetNode(event);
+    if ( pNode->IsRoot() || pNode->Parent()->IsRoot() )
+    {
+        wxLogStatus(wxT("This registry key can't be %s."),
+            m_copyOnDrop ? wxT("copied") : wxT("moved"));
+    }
+    else
+    {
+        wxLogStatus(wxT("%s item %s..."),
+            m_copyOnDrop ? wxT("Copying") : wxT("Moving"),
+            pNode->FullName());
+
+        m_draggedItem = pNode;

 
 

-  // expansion might take some time
-  wxSetCursor(*wxHOURGLASS_CURSOR);
-  wxLogStatus("Working...");
-  wxYield();  // to give the status line a chance to refresh itself
+        event.Allow();
+    }
+}
+
+void RegTreeCtrl::OnEndDrag(wxTreeEvent& event)
+{
+    wxCHECK_RET( m_draggedItem, wxT("end drag without begin drag?") );
+
+    // clear the pointer anyhow
+    TreeNode *src = m_draggedItem;
+    m_draggedItem = NULL;
+
+    // where are we going to drop it?
+    TreeNode *dst = GetNode(event);
+    if ( dst && !dst->IsKey() )
+    {
+        // we need a parent key
+        dst = dst->Parent();
+    }
+
+    if ( !dst || dst->IsRoot() )
+    {
+        wxLogError(wxT("Can't create a key here."));
+
+        return;
+    }
+
+    bool isKey = src->IsKey();
+    if ( (isKey && (src == dst)) ||
+         (!isKey && (dst->Parent() == src)) ) {
+        wxLogStatus(wxT("Can't copy something on itself"));

 
 

-  if ( pNode->IsKey() ) {
-    if ( bExpanding ) {
-      // expanding: add subkeys/values
-      if ( !pNode->OnExpand() )

         return;
     }
         return;
     }

-    else {
-      // collapsing: clean up
-      pNode->OnCollapse();
+
+    // remove the "Registry Root\\" from the full name
+    wxString nameSrc, nameDst;
+    nameSrc << wxString(src->FullName()).AfterFirst('\\');
+    nameDst << wxString(dst->FullName()).AfterFirst('\\') << '\\'
+            << wxString(src->FullName()).AfterLast('\\');
+
+    wxString verb = m_copyOnDrop ? _T("copy") : _T("move");
+    wxString what = isKey ? _T("key") : _T("value");
+
+    if ( wxMessageBox(wxString::Format
+                        (
+                         wxT("Do you really want to %s the %s %s to %s?"),
+                         verb.c_str(),
+                         what.c_str(),
+                         nameSrc.c_str(),
+                         nameDst.c_str()
+                        ),
+                      _T("RegTest Confirm"),
+                      wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
+      return;

     }
 
     }
 

-    // change icon for non root key
-    if ( !pNode->IsRoot() ) {
-      int idIcon = bExpanding ? RegImageList::OpenedKey 
-                              : RegImageList::ClosedKey;
-      SetItemImage(pNode->Id(), idIcon);
+    bool ok;
+    if ( isKey )
+    {
+        wxRegKey& key = src->Key();
+        wxRegKey keyDst(dst->Key(), src->m_strName);
+        ok = keyDst.Create(false);
+        if ( !ok )
+        {
+            wxLogError(wxT("Key '%s' already exists"), keyDst.GetName().c_str());
+        }
+        else
+        {
+            ok = key.Copy(keyDst);
+        }
+
+        if ( ok && !m_copyOnDrop )
+        {
+            // delete the old key
+            ok = key.DeleteSelf();
+            if ( ok )
+            {
+                src->Parent()->Refresh();
+            }
+        }
+    }
+    else // value
+    {
+        wxRegKey& key = src->Parent()->Key();
+        ok = key.CopyValue(src->m_strName, dst->Key());
+        if ( ok && !m_copyOnDrop )
+        {
+            // we moved it, so delete the old one
+            ok = key.DeleteValue(src->m_strName);
+        }

     }
     }

-  }

 
 

-  wxLogStatus("Ok");
-  wxSetCursor(*wxSTANDARD_CURSOR);
+    if ( !ok )
+    {
+        wxLogError(wxT("Failed to %s registry %s."),
+                   verb.c_str(), what.c_str());
+    }
+    else
+    {
+        dst->Refresh();
+    }

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -576,265 +903,437 @@ void RegTreeCtrl::OnItemExpanding(wxTreeEvent& event)
 // ----------------------------------------------------------------------------
 bool RegTreeCtrl::TreeNode::OnExpand()
 {
 // ----------------------------------------------------------------------------
 bool RegTreeCtrl::TreeNode::OnExpand()
 {

-  // remove dummy item
-  if ( m_lDummy != 0 ) {
-    m_pTree->Delete(m_lDummy);
-    m_lDummy = 0;
-  }
-  else {
-    // we've been already expanded
-    return TRUE;
-  }
-
-  if ( IsRoot() ) {
-    // we're the root key
-    m_pTree->AddStdKeys();
-    return true;
-  }
-
-  if ( Parent()->IsRoot() ) {
-    // we're a standard key
-    m_pKey = new wxRegKey(m_strName);
-  }
-  else {
-    // we're a normal key
-    m_pKey = new wxRegKey(*(Parent()->m_pKey), m_strName);
-  }
-
-  if ( !m_pKey->Open() ) {
-    wxLogError("The key '%s' can't be opened.", FullName());
-    return false;
-  }
-
-  // enumeration variables
-  long l;
-  wxString str;
-  bool bCont;
-
-  // enumerate all subkeys
-  bCont = m_pKey->GetFirstKey(str, l);
-  while ( bCont ) {
-    m_pTree->InsertNewTreeNode(this, str, RegImageList::ClosedKey);
-    bCont = m_pKey->GetNextKey(str, l);
-  }
-
-  // enumerate all values
-  bCont = m_pKey->GetFirstValue(str, l);
-  while ( bCont ) {
-    wxString strItem;
-    if (str.IsEmpty())
-        strItem = "<default>";
+    // we add children only once
+    if ( !m_aChildren.IsEmpty() )
+    {
+        // we've been already expanded
+        return true;
+    }
+
+    if ( IsRoot() )
+    {
+        // we're the root key
+        m_pTree->AddStdKeys();
+        return true;
+    }
+
+    if ( Parent()->IsRoot() )
+    {
+        // we're a standard key
+        m_pKey = new wxRegKey(m_strName);
+    }

     else
     else

-        strItem = str;
-    strItem += " = ";
-
-    // determine the appropriate icon
-    RegImageList::Icon icon;
-    switch ( m_pKey->GetValueType(str) ) {
-      case wxRegKey::Type_String:
-      case wxRegKey::Type_Expand_String:
-      case wxRegKey::Type_Multi_String:
+    {
+        // we're a normal key
+        m_pKey = new wxRegKey(*(Parent()->m_pKey), m_strName);
+    }
+
+    if ( !m_pKey->Open() )
+    {
+        wxLogError(wxT("The key '%s' can't be opened."), FullName());
+        return false;
+    }
+
+    // if we're empty, we shouldn't be expandable at all
+    bool isEmpty = true;
+
+    // enumeration variables
+    long l;
+    wxString str;
+    bool bCont;
+
+    // enumerate all subkeys
+    bCont = m_pKey->GetFirstKey(str, l);
+    while ( bCont )
+    {
+        m_pTree->InsertNewTreeNode(this, str, RegImageList::ClosedKey);
+        bCont = m_pKey->GetNextKey(str, l);
+
+        // we have at least this key...
+        isEmpty = false;
+    }
+
+    // enumerate all values
+    bCont = m_pKey->GetFirstValue(str, l);
+    while ( bCont )
+    {
+        wxString strItem;
+        if (str.IsEmpty())
+            strItem = _T("<default>");
+        else
+            strItem = str;
+        strItem += _T(" = ");
+
+        // determine the appropriate icon
+        RegImageList::Icon icon;
+        switch ( m_pKey->GetValueType(str) )
+        {
+        case wxRegKey::Type_String:
+        case wxRegKey::Type_Expand_String:
+        case wxRegKey::Type_Multi_String:

         {
         {

-          wxString strValue;
-          icon = RegImageList::TextValue;
-          m_pKey->QueryValue(str, strValue);
-          strItem += strValue;
+            wxString strValue;
+            icon = RegImageList::TextValue;
+            m_pKey->QueryValue(str, strValue);
+            strItem += strValue;

         }
         break;
 
         }
         break;
 

-      case wxRegKey::Type_None:
-        // @@ handle the error...
-        icon = RegImageList::BinaryValue;
-        break;
+        case wxRegKey::Type_None:
+            // @@ handle the error...
+            icon = RegImageList::BinaryValue;
+            break;

 
 

-      case wxRegKey::Type_Dword:
+        case wxRegKey::Type_Dword:

         {
         {

-          char szBuf[128];
-          long l;
-          m_pKey->QueryValue(str, &l);
-          sprintf(szBuf, "%lx", l);
-          strItem += szBuf;
+            long l;
+            m_pKey->QueryValue(str, &l);
+            strItem << l;

         }
 
         // fall through
 
         }
 
         // fall through
 

-      default:
-        icon = RegImageList::BinaryValue;
+        default:
+            icon = RegImageList::BinaryValue;
+        }
+
+        m_pTree->InsertNewTreeNode(this, str, icon, &strItem);
+        bCont = m_pKey->GetNextValue(str, l);
+
+        // we have at least this value...
+        isEmpty = false;

     }
 
     }
 

-    m_pTree->InsertNewTreeNode(this, str, icon, &strItem);
-    bCont = m_pKey->GetNextValue(str, l);
-  }
+    if ( isEmpty )
+    {
+        // this is for the case when our last child was just deleted
+        wxTreeItemId theId(Id()); // Temp variable seems necessary for BC++
+        m_pTree->Collapse(theId);

 
 

-  return true;
+        // we won't be expanded any more
+        m_pTree->SetItemHasChildren(theId, false);
+    }
+
+    return true;

 }
 
 void RegTreeCtrl::TreeNode::OnCollapse()
 {
 }
 
 void RegTreeCtrl::TreeNode::OnCollapse()
 {

-  bool bHasChildren = !m_aChildren.IsEmpty();
-  DestroyChildren();
-  if ( bHasChildren )
-    AddDummy();
-  else
-    m_lDummy = 0;
+    DestroyChildren();
+
+    delete m_pKey;
+    m_pKey = NULL;
+}
+
+void RegTreeCtrl::TreeNode::Refresh()
+{
+    if ( !IsKey() )
+        return;

 
 

-  delete m_pKey;
-  m_pKey = NULL;
+    wxTreeItemId theId(Id()); // Temp variable seems necessary for BC++
+    bool wasExpanded = m_pTree->IsExpanded(theId);
+    if ( wasExpanded )
+        m_pTree->Collapse(theId);
+
+    OnCollapse();
+    m_pTree->SetItemHasChildren(theId);
+    if ( wasExpanded )
+    {
+        m_pTree->Expand(theId);
+        OnExpand();
+    }

 }
 
 }
 

-void RegTreeCtrl::TreeNode::AddDummy()
+bool RegTreeCtrl::TreeNode::DeleteChild(TreeNode *child)

 {
 {

-  // insert dummy item forcing appearance of [+] button
-  m_lDummy = m_pTree->InsertItem(Id(), "");
+    int index = m_aChildren.Index(child);
+    wxCHECK_MSG( index != wxNOT_FOUND, false,
+                 wxT("our child in tree should be in m_aChildren") );
+
+    m_aChildren.RemoveAt((size_t)index);
+
+    bool ok;
+    if ( child->IsKey() )
+    {
+        // must close key before deleting it
+        child->OnCollapse();
+
+        ok = Key().DeleteKey(child->m_strName);
+    }
+    else
+    {
+        ok = Key().DeleteValue(child->m_strName);
+    }
+
+    if ( ok )
+    {
+        wxTreeItemId theId(child->Id()); // Temp variable seems necessary for BC++
+        m_pTree->Delete(theId);
+
+        Refresh();
+    }
+
+    return ok;

 }
 
 void RegTreeCtrl::TreeNode::DestroyChildren()
 {
 }
 
 void RegTreeCtrl::TreeNode::DestroyChildren()
 {

-  // destroy all children
-  unsigned int nCount = m_aChildren.Count();
-  for ( unsigned int n = 0; n < nCount; n++ ) {
-         long lId = m_aChildren[n]->Id();
-    delete m_aChildren[n];
-    m_pTree->Delete(lId);
-  }
+    // destroy all children
+    size_t nCount = m_aChildren.GetCount();
+    for ( size_t n = 0; n < nCount; n++ )
+    {
+        long lId = m_aChildren[n]->Id();
+        // no, wxTreeCtrl will do it
+        //delete m_aChildren[n];
+        wxTreeItemId theId(lId); // Temp variable seems necessary for BC++
+        m_pTree->Delete(theId);
+    }

 
 

-  m_aChildren.Empty();
+    m_aChildren.Empty();

 }
 
 RegTreeCtrl::TreeNode::~TreeNode()
 {
 }
 
 RegTreeCtrl::TreeNode::~TreeNode()
 {

-  DestroyChildren();
-
-  delete m_pKey;
+    delete m_pKey;

 }
 
 }
 

-const char *RegTreeCtrl::TreeNode::FullName() const
+const wxChar *RegTreeCtrl::TreeNode::FullName() const

 {
 {

-  static wxString s_strName;
+    static wxString s_strName;

 
 

-  if ( IsRoot() ) {
-    return "Registry Root";
-  }
-  else {
-    // our own registry key might not (yet) exist or we might be a value, 
-    // so just use the parent's and concatenate
-    s_strName = Parent()->FullName();
-    s_strName << '\\' << m_strName;
+    if ( IsRoot() )
+    {
+        return wxT("Registry Root");
+    }
+    else
+    {
+        // our own registry key might not (yet) exist or we might be a value,
+        // so just use the parent's and concatenate
+        s_strName = Parent()->FullName();
+        s_strName << wxT('\\') << m_strName;

 
 

-    return s_strName;
-  }
+        return s_strName;
+    }

 }
 
 // ----------------------------------------------------------------------------
 // operations on RegTreeCtrl
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // operations on RegTreeCtrl
 // ----------------------------------------------------------------------------
 

-void RegTreeCtrl::DeleteSelected()
+void RegTreeCtrl::GoTo(const wxString& location)

 {
 {

-  long lCurrent = GetSelection(),
-       lParent  = GetParent(lCurrent);
+    wxStringTokenizer tk(location, _T("\\"));

 
 

-  if ( lParent == 0 ) {
-    wxLogError("Can't delete root key.");
-    return;
-  }
+    wxTreeItemId id = GetRootItem();

 
 

-  TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent),
-           *pParent  = (TreeNode *)GetItemData(lParent);
+    while ( tk.HasMoreTokens() )
+    {
+        wxString subkey = tk.GetNextToken();

 
 

-  wxCHECK_RET( pCurrent && pParent, "either node or parent without data?" );
+        wxTreeItemId idCurrent = id;
+        if ( !IsExpanded(idCurrent) )
+            Expand(idCurrent);

 
 

-  if ( pParent->IsRoot() ) {
-    wxLogError("Can't delete standard key.");
-    return;
-  }
+        wxTreeItemIdValue dummy;
+        id = GetFirstChild(idCurrent, dummy);

 
 

-  if ( pCurrent->IsKey() ) {
-    if ( wxMessageBox("Do you really want to delete this key?",
-                      "Confirmation", 
-                      wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
-      return;
+        if ( idCurrent == GetRootItem() )
+        {
+            // special case: we understand both HKCU and HKEY_CURRENT_USER here
+            for ( size_t key = 0; key < wxRegKey::nStdKeys; key++ )
+            {
+                if ( subkey == wxRegKey::GetStdKeyName(key)
+                     || subkey == wxRegKey::GetStdKeyShortName(key) )
+                {
+                    break;
+                }
+
+                id = GetNextChild(idCurrent, dummy);
+            }
+        }
+        else
+        {
+            // enum all children
+            while ( id.IsOk() )
+            {
+                if ( subkey == ((TreeNode *)GetItemData(id))->m_strName )
+                    break;
+
+                id = GetNextChild(idCurrent, dummy);
+            }
+        }
+
+        if ( !id.IsOk() )
+        {
+            wxLogError(_T("No such key '%s'."), location.c_str());
+
+            return;
+        }
+    }
+
+    if ( id.IsOk() )
+        SelectItem(id);
+}
+
+void RegTreeCtrl::DeleteSelected()
+{
+    long lCurrent = GetSelection(),
+        lParent  = GetItemParent(lCurrent);
+
+    if ( lParent == 0 )
+    {
+        wxLogError(wxT("Can't delete root key."));
+        return;

     }
 
     }
 

-    // must close key before deleting it
-    pCurrent->OnCollapse();
+    TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent),
+        *pParent  = (TreeNode *)GetItemData(lParent);

 
 

-    if ( pParent->Key().DeleteKey(pCurrent->m_strName) )
-      pParent->Refresh();
-  }
-  else {
-    if ( wxMessageBox("Do you really want to delete this value?",
-                      "Confirmation", 
-                      wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
-      return;
+    wxCHECK_RET(pCurrent && pParent, wxT("either node or parent without data?"));
+
+    if ( pParent->IsRoot() )
+    {
+        wxLogError(wxT("Can't delete standard key."));
+        return;
+    }
+
+    wxString what = pCurrent->IsKey() ? _T("key") : _T("value");
+    if ( wxMessageBox(wxString::Format
+        (
+            wxT("Do you really want to delete this %s?"),
+            what.c_str()
+        ),
+        _T("Confirmation"),
+        wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES )
+    {
+        return;

     }
 
     }
 

-    if ( pParent->Key().DeleteValue(pCurrent->m_strName) )
-      pParent->Refresh();
-  }
+    pParent->DeleteChild(pCurrent);

 }
 
 void RegTreeCtrl::CreateNewKey(const wxString& strName)
 {
 }
 
 void RegTreeCtrl::CreateNewKey(const wxString& strName)
 {

-  long lCurrent = GetSelection();
-  TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
+    long lCurrent = GetSelection();
+    TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);

 
 

-  wxCHECK_RET( pCurrent != NULL, "node without data?" );
-  
-  wxASSERT( pCurrent->IsKey() );  // check must have been done before
+    wxCHECK_RET( pCurrent != NULL, wxT("node without data?") );

 
 

-  if ( pCurrent->IsRoot() ) {
-    wxLogError("Can't create a new key under the root key.");
-    return;
-  }
+    wxASSERT( pCurrent->IsKey() );  // check must have been done before
+
+    if ( pCurrent->IsRoot() )
+    {
+        wxLogError(wxT("Can't create a new key under the root key."));
+        return;
+    }

 
 

-  wxRegKey key(pCurrent->Key(), strName);
-  if ( key.Create() )
-    pCurrent->Refresh();
+    wxRegKey key(pCurrent->Key(), strName);
+    if ( key.Create() )
+        pCurrent->Refresh();

 }
 
 void RegTreeCtrl::CreateNewTextValue(const wxString& strName)
 {
 }
 
 void RegTreeCtrl::CreateNewTextValue(const wxString& strName)
 {

-  long lCurrent = GetSelection();
-  TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
+    long lCurrent = GetSelection();
+    TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
+
+    wxCHECK_RET( pCurrent != NULL, wxT("node without data?") );

 
 

-  wxCHECK_RET( pCurrent != NULL, "node without data?" );
-  
-  wxASSERT( pCurrent->IsKey() );  // check must have been done before
+    wxASSERT( pCurrent->IsKey() );  // check must have been done before

 
 

-  if ( pCurrent->IsRoot() ) {
-    wxLogError("Can't create a new value under the root key.");
-    return;
-  }
+    if ( pCurrent->IsRoot() )
+    {
+        wxLogError(wxT("Can't create a new value under the root key."));
+        return;
+    }

 
 

-  if ( pCurrent->Key().SetValue(strName, "") )
-    pCurrent->Refresh();
+    if ( pCurrent->Key().SetValue(strName, wxEmptyString) )
+        pCurrent->Refresh();

 }
 
 void RegTreeCtrl::CreateNewBinaryValue(const wxString& strName)
 {
 }
 
 void RegTreeCtrl::CreateNewBinaryValue(const wxString& strName)
 {

-  long lCurrent = GetSelection();
-  TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
+    long lCurrent = GetSelection();
+    TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
+
+    wxCHECK_RET( pCurrent != NULL, wxT("node without data?") );
+
+    wxASSERT( pCurrent->IsKey() );  // check must have been done before
+
+    if ( pCurrent->IsRoot() )
+    {
+        wxLogError(wxT("Can't create a new value under the root key."));
+        return;
+    }
+
+    if ( pCurrent->Key().SetValue(strName, 0) )
+        pCurrent->Refresh();
+}
+
+void RegTreeCtrl::ShowProperties()
+{
+    long lCurrent = GetSelection();
+    TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
+
+    if ( !pCurrent || pCurrent->IsRoot() )
+    {
+        wxLogStatus(wxT("No properties"));

 
 

-  wxCHECK_RET( pCurrent != NULL, "node without data?" );
-  
-  wxASSERT( pCurrent->IsKey() );  // check must have been done before
+        return;
+    }

 
 

-  if ( pCurrent->IsRoot() ) {
-    wxLogError("Can't create a new value under the root key.");
-    return;
-  }
+    if ( pCurrent->IsKey() )
+    {
+        const wxRegKey& key = pCurrent->Key();
+        size_t nSubKeys, nValues;
+        if ( !key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
+        {
+            wxLogError(wxT("Couldn't get key info"));
+        }
+        else
+        {
+            wxLogMessage(wxT("Key '%s' has %u subkeys and %u values."),
+                         key.GetName().c_str(), nSubKeys, nValues);
+        }
+    }
+    else // it's a value
+    {
+        TreeNode *parent = pCurrent->Parent();
+        wxCHECK_RET( parent, wxT("reg value without key?") );
+
+        const wxRegKey& key = parent->Key();
+        const wxChar *value = pCurrent->m_strName.c_str();
+        wxLogMessage(wxT("Value '%s' under the key '%s' is of type ")
+            wxT("%d (%s)."),
+            value,
+            parent->m_strName.c_str(),
+            key.GetValueType(value),
+            key.IsNumericValue(value) ? wxT("numeric") : wxT("string"));

 
 

-  if ( pCurrent->Key().SetValue(strName, 0) )
-    pCurrent->Refresh();
+    }

 }
 
 bool RegTreeCtrl::IsKeySelected() const
 {
 }
 
 bool RegTreeCtrl::IsKeySelected() const
 {

-  long lCurrent = GetSelection();
-  TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
+    long lCurrent = GetSelection();
+    TreeNode *pCurrent = (TreeNode *) GetItemData(lCurrent);
+
+    wxCHECK( pCurrent != NULL, false );
+
+    return pCurrent->IsKey();
+}
+
+void RegTreeCtrl::DoRefresh()
+{
+    long lId = GetSelection();
+    if ( !lId )
+        return;

 
 

-  wxCHECK( pCurrent != NULL, false );
+    TreeNode *pNode = (TreeNode *) GetItemData(lId);

 
 

-  return pCurrent->IsKey();
-}
\ No newline at end of file
+    wxCHECK_RET( pNode != NULL, wxT("tree item without data?") );
+
+    pNode->Refresh();
+}
+
+#endif