]> git.saurik.com Git - wxWidgets.git/blobdiff - samples/regtest/regtest.cpp
info about removal of wxhtml.rc
[wxWidgets.git] / samples / regtest / regtest.cpp
index f670fc00ad735c872d589237b79e07737bb578e8..d08d4a84591116ec11c884f8a475200d0aec7e8f 100644 (file)
@@ -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>
 #include "wx/msw/registry.h"
 #include "wx/msw/imaglist.h"
 
 #include "wx/msw/registry.h"
 #include "wx/msw/imaglist.h"
 
+#include "wx/tokenzr.h"
+
 // ----------------------------------------------------------------------------
 // application type
 // ----------------------------------------------------------------------------
 class RegApp : public wxApp
 // ----------------------------------------------------------------------------
 // application type
 // ----------------------------------------------------------------------------
 class RegApp : public wxApp
-{ 
+{
 public:
 public:
-  bool OnInit(void);
+  bool OnInit();
 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------
@@ -58,9 +60,6 @@ public:
   RegImageList();
 };
 
   RegImageList();
 };
 
-// array of children of the node
-//class TreeNode;
-
 // ----------------------------------------------------------------------------
 // our control
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // our control
 // ----------------------------------------------------------------------------
@@ -76,14 +75,24 @@ public:
   void OnItemExpanding(wxTreeEvent& event);
   void OnSelChanged   (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 OnRightClick   (wxMouseEvent& event);
   void OnChar         (wxKeyEvent& event);
+  void OnIdle         (wxIdleEvent& event);
 
   // forwarded notifications (by the frame)
   void OnMenuTest();
 
   // operations
 
   // forwarded notifications (by the frame)
   void OnMenuTest();
 
   // operations
+  void GoTo(const wxString& location);
+  void Refresh();
   void DeleteSelected();
   void DeleteSelected();
+  void ShowProperties();
   void CreateNewKey(const wxString& strName);
   void CreateNewTextValue(const wxString& strName);
   void CreateNewBinaryValue(const wxString& strName);
   void CreateNewKey(const wxString& strName);
   void CreateNewTextValue(const wxString& strName);
   void CreateNewBinaryValue(const wxString& strName);
@@ -91,94 +100,101 @@ public:
   // information
   bool IsKeySelected() const;
 
   // information
   bool IsKeySelected() const;
 
-  DECLARE_EVENT_TABLE();
-
 private:
 private:
-
   // structure describing a registry key/value
   // structure describing a registry key/value
-       class TreeNode : public wxTreeItemData
+  class TreeNode : public wxTreeItemData
   {
   {
-WX_DEFINE_ARRAY(TreeNode *, TreeChildren);
+  WX_DEFINE_ARRAY(TreeNode *, TreeChildren);
   public:
   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;         }
-
-    // notifications
-    bool OnExpand();
-    void OnCollapse();
-
-    // operations
-    void Refresh() { OnCollapse(); OnExpand(); }
-    void AddDummy();
-    void DestroyChildren();
-    const char *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();
+      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
+
+      // 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();
+
+      // 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;
   wxMenu      *m_pMenuPopup;
+
   TreeNode    *m_pRoot;
   TreeNode    *m_pRoot;
-  wxImageList *m_imageList;
+
+  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((WXHTREEITEM)event.GetItem()); }
 
 public:
   // create a new node and insert it to the tree
 
   TreeNode *GetNode(const wxTreeEvent& event)
     { return (TreeNode *)GetItemData((WXHTREEITEM)event.GetItem()); }
 
 public:
   // create a new node and insert it to the tree
-  TreeNode *InsertNewTreeNode(TreeNode *pParent, 
+  TreeNode *InsertNewTreeNode(TreeNode *pParent,
                               const wxString& strName,
                               int idImage = RegImageList::ClosedKey,
                               const wxString *pstrValue = NULL);
   // add standard registry keys
   void AddStdKeys();
                               const wxString& strName,
                               int idImage = RegImageList::ClosedKey,
                               const wxString *pstrValue = NULL);
   // add standard registry keys
   void AddStdKeys();
+
+private:
+  DECLARE_EVENT_TABLE()
 };
 
 // ----------------------------------------------------------------------------
 // the main window of our application
 // ----------------------------------------------------------------------------
 class RegFrame : public wxFrame
 };
 
 // ----------------------------------------------------------------------------
 // the main window of our application
 // ----------------------------------------------------------------------------
 class RegFrame : public wxFrame
-{ 
+{
 public:
   // ctor & dtor
   RegFrame(wxFrame *parent, char *title, int x, int y, int w, int h);
 public:
   // ctor & dtor
   RegFrame(wxFrame *parent, char *title, int x, int y, int w, int h);
-  virtual ~RegFrame(void);
-    
+  virtual ~RegFrame();
+
   // callbacks
   void OnQuit (wxCommandEvent& event);
   void OnAbout(wxCommandEvent& event);
   void OnTest (wxCommandEvent& event);
 
   // 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 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 OnDelete   (wxCommandEvent& event);
   void OnNewKey   (wxCommandEvent& event);
   void OnNewText  (wxCommandEvent& event);
   void OnNewBinary(wxCommandEvent& event);
 
-  bool OnClose  () { return TRUE; }
+  void OnInfo     (wxCommandEvent& event);
 
 
-  DECLARE_EVENT_TABLE();
+  DECLARE_EVENT_TABLE()
 
 private:
   RegTreeCtrl *m_treeCtrl;
 
 private:
   RegTreeCtrl *m_treeCtrl;
@@ -193,14 +209,17 @@ enum
   Menu_Quit     = 100,
   Menu_About,
   Menu_Test,
   Menu_Quit     = 100,
   Menu_About,
   Menu_Test,
+  Menu_GoTo,
   Menu_Expand,
   Menu_Collapse,
   Menu_Toggle,
   Menu_Expand,
   Menu_Collapse,
   Menu_Toggle,
+  Menu_Refresh,
   Menu_New,
   Menu_New,
-  Menu_NewKey,  
-  Menu_NewText, 
+  Menu_NewKey,
+  Menu_NewText,
   Menu_NewBinary,
   Menu_Delete,
   Menu_NewBinary,
   Menu_Delete,
+  Menu_Info,
 
   Ctrl_RegTree  = 200,
 };
 
   Ctrl_RegTree  = 200,
 };
@@ -213,13 +232,16 @@ 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_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_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_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()
 
 BEGIN_EVENT_TABLE(RegTreeCtrl, wxTreeCtrl)
 END_EVENT_TABLE()
 
 BEGIN_EVENT_TABLE(RegTreeCtrl, wxTreeCtrl)
@@ -227,8 +249,16 @@ BEGIN_EVENT_TABLE(RegTreeCtrl, wxTreeCtrl)
   EVT_TREE_ITEM_EXPANDING(Ctrl_RegTree, RegTreeCtrl::OnItemExpanding)
   EVT_TREE_SEL_CHANGED   (Ctrl_RegTree, RegTreeCtrl::OnSelChanged)
 
   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_CHAR      (RegTreeCtrl::OnChar)
   EVT_RIGHT_DOWN(RegTreeCtrl::OnRightClick)
+  EVT_IDLE      (RegTreeCtrl::OnIdle)
 END_EVENT_TABLE()
 
 // ============================================================================
 END_EVENT_TABLE()
 
 // ============================================================================
@@ -252,9 +282,14 @@ wxMenu *CreateRegistryMenu()
   pMenuReg->Append(Menu_New, "&New", pMenuNew);
   pMenuReg->Append(Menu_Delete,   "&Delete...", "Delete selected key/value");
   pMenuReg->AppendSeparator();
   pMenuReg->Append(Menu_New, "&New", pMenuNew);
   pMenuReg->Append(Menu_Delete,   "&Delete...", "Delete selected key/value");
   pMenuReg->AppendSeparator();
+  pMenuReg->Append(Menu_GoTo,     "&Go to...\tCtrl-G",    "Go to registry key");
   pMenuReg->Append(Menu_Expand,   "&Expand",    "Expand current key");
   pMenuReg->Append(Menu_Collapse, "&Collapse",  "Collapse current key");
   pMenuReg->Append(Menu_Toggle,   "&Toggle",    "Toggle current key");
   pMenuReg->Append(Menu_Expand,   "&Expand",    "Expand current key");
   pMenuReg->Append(Menu_Collapse, "&Collapse",  "Collapse current key");
   pMenuReg->Append(Menu_Toggle,   "&Toggle",    "Toggle current key");
+  pMenuReg->AppendSeparator();
+  pMenuReg->Append(Menu_Refresh,  "&Refresh",   "Refresh the subtree");
+  pMenuReg->AppendSeparator();
+  pMenuReg->Append(Menu_Info,     "&Properties","Information about current selection");
 
   return pMenuReg;
 }
 
   return pMenuReg;
 }
@@ -268,12 +303,12 @@ IMPLEMENT_APP(RegApp)
 bool RegApp::OnInit()
 {
   // create the main frame window and show it
 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);
-  
+  RegFrame *frame = new RegFrame(NULL, "wxRegTest", 50, 50, 600, 350);
+  frame->Show(TRUE);
+
   SetTopWindow(frame);
 
   SetTopWindow(frame);
 
-  return true;
+  return TRUE;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -310,15 +345,13 @@ RegFrame::RegFrame(wxFrame *parent, char *title, int x, int y, int w, int h)
 
   // create the status line
   // ----------------------
 
   // create the status line
   // ----------------------
-  int aWidths[2];
-  aWidths[0] = 200;
-  aWidths[1] = -1;
   CreateStatusBar(2);
   CreateStatusBar(2);
-  SetStatusWidths(2, aWidths);
 }
 
 }
 
-RegFrame::~RegFrame(void)
+RegFrame::~RegFrame()
 {
 {
+  // this makes deletion of it *much* quicker
+  m_treeCtrl->Hide();
 }
 
 void RegFrame::OnQuit(wxCommandEvent& event)
 }
 
 void RegFrame::OnQuit(wxCommandEvent& event)
@@ -328,38 +361,63 @@ void RegFrame::OnQuit(wxCommandEvent& event)
 
 void RegFrame::OnAbout(wxCommandEvent& event)
 {
 
 void RegFrame::OnAbout(wxCommandEvent& event)
 {
-  wxMessageDialog dialog(this, "wxRegistry sample\n(c) 1998 Vadim Zeitlin",
-                         "About wxRegistry", wxOK);
+  wxMessageDialog dialog(this,
+                         "wxRegistry sample\n"
+                         "© 1998, 2000 Vadim Zeitlin",
+                         "About wxRegTest", wxOK);
 
   dialog.ShowModal();
 }
 
 
   dialog.ShowModal();
 }
 
-void RegFrame::OnTest(wxCommandEvent& event)
+void RegFrame::OnTest(wxCommandEvent& WXUNUSED(event))
 {
   m_treeCtrl->OnMenuTest();
 }
 
 {
   m_treeCtrl->OnMenuTest();
 }
 
-void RegFrame::OnExpand(wxCommandEvent& event)
+void RegFrame::OnGoTo(wxCommandEvent& WXUNUSED(event))
+{
+    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;
+    m_treeCtrl->GoTo(location);
+}
+
+void RegFrame::OnExpand(wxCommandEvent& WXUNUSED(event))
 {
   m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_EXPAND);
 }
 
 {
   m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_EXPAND);
 }
 
-void RegFrame::OnCollapse(wxCommandEvent& event)
+void RegFrame::OnCollapse(wxCommandEvent& WXUNUSED(event))
 {
   m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_COLLAPSE);
 }
 
 {
   m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_COLLAPSE);
 }
 
-void RegFrame::OnToggle(wxCommandEvent& event)
+void RegFrame::OnToggle(wxCommandEvent& WXUNUSED(event))
 {
   m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_TOGGLE);
 }
 
 {
   m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_TOGGLE);
 }
 
-void RegFrame::OnDelete(wxCommandEvent& event)
+void RegFrame::OnRefresh(wxCommandEvent& WXUNUSED(event))
+{
+  m_treeCtrl->Refresh();
+}
+
+void RegFrame::OnDelete(wxCommandEvent& WXUNUSED(event))
 {
   m_treeCtrl->DeleteSelected();
 }
 
 {
   m_treeCtrl->DeleteSelected();
 }
 
-void RegFrame::OnNewKey(wxCommandEvent& event)
+void RegFrame::OnNewKey(wxCommandEvent& WXUNUSED(event))
 {
   if ( m_treeCtrl->IsKeySelected() ) {
     m_treeCtrl->CreateNewKey(
 {
   if ( m_treeCtrl->IsKeySelected() ) {
     m_treeCtrl->CreateNewKey(
@@ -367,7 +425,7 @@ void RegFrame::OnNewKey(wxCommandEvent& event)
   }
 }
 
   }
 }
 
-void RegFrame::OnNewText(wxCommandEvent& event)
+void RegFrame::OnNewText(wxCommandEvent& WXUNUSED(event))
 {
   if ( m_treeCtrl->IsKeySelected() ) {
     m_treeCtrl->CreateNewTextValue(
 {
   if ( m_treeCtrl->IsKeySelected() ) {
     m_treeCtrl->CreateNewTextValue(
@@ -375,7 +433,7 @@ void RegFrame::OnNewText(wxCommandEvent& event)
   }
 }
 
   }
 }
 
-void RegFrame::OnNewBinary(wxCommandEvent& event)
+void RegFrame::OnNewBinary(wxCommandEvent& WXUNUSED(event))
 {
   if ( m_treeCtrl->IsKeySelected() ) {
     m_treeCtrl->CreateNewBinaryValue(
 {
   if ( m_treeCtrl->IsKeySelected() ) {
     m_treeCtrl->CreateNewBinaryValue(
@@ -383,6 +441,11 @@ void RegFrame::OnNewBinary(wxCommandEvent& event)
   }
 }
 
   }
 }
 
+void RegFrame::OnInfo(wxCommandEvent& WXUNUSED(event))
+{
+    m_treeCtrl->ShowProperties();
+}
+
 // ----------------------------------------------------------------------------
 // RegImageList
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // RegImageList
 // ----------------------------------------------------------------------------
@@ -401,7 +464,7 @@ RegImageList::RegImageList() : wxImageList(16, 16, TRUE)
 // ----------------------------------------------------------------------------
 
 // create a new tree item and insert it into the tree
 // ----------------------------------------------------------------------------
 
 // 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)
@@ -413,11 +476,11 @@ RegTreeCtrl::TreeNode *RegTreeCtrl::InsertNewTreeNode(TreeNode *pParent,
   pNewNode->m_strName = strName;
   pNewNode->m_bKey    = pstrValue == NULL;
   pNewNode->m_pKey    = NULL;
   pNewNode->m_strName = strName;
   pNewNode->m_bKey    = pstrValue == NULL;
   pNewNode->m_pKey    = NULL;
-  pNewNode->m_id      = InsertItem(pParent ? pParent->m_id : 0, 
+  pNewNode->m_id      = InsertItem(pParent ? pParent->Id() : 0,
                                    pNewNode->IsKey() ? strName : *pstrValue,
                                    idImage);
 
                                    pNewNode->IsKey() ? strName : *pstrValue,
                                    idImage);
 
-  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);
@@ -427,17 +490,28 @@ RegTreeCtrl::TreeNode *RegTreeCtrl::InsertNewTreeNode(TreeNode *pParent,
     pParent->m_aChildren.Add(pNewNode);
   }
 
     pParent->m_aChildren.Add(pNewNode);
   }
 
-  // force the [+] button (@@@ not very elegant...)
-  if ( pNewNode->IsKey() )
-    pNewNode->AddDummy();
+  if ( pNewNode->IsKey() ) {
+    SetItemHasChildren(pNewNode->Id());
+
+    if ( !pNewNode->IsRoot() ) {
+        // set the expanded icon as well
+        SetItemImage(pNewNode->Id(),
+                     RegImageList::OpenedKey,
+                     wxTreeItemIcon_Expanded);
+    }
+  }
 
   return pNewNode;
 }
 
 RegTreeCtrl::RegTreeCtrl(wxWindow *parent, wxWindowID id)
 
   return pNewNode;
 }
 
 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)
 {
 {
+  // init members
+  m_draggedItem = NULL;
+  m_restoreStatus = FALSE;
+
   // create the image list
   // ---------------------
   m_imageList = new RegImageList;
   // create the image list
   // ---------------------
   m_imageList = new RegImageList;
@@ -455,7 +529,7 @@ RegTreeCtrl::RegTreeCtrl(wxWindow *parent, wxWindowID id)
 RegTreeCtrl::~RegTreeCtrl()
 {
   delete m_pMenuPopup;
 RegTreeCtrl::~RegTreeCtrl()
 {
   delete m_pMenuPopup;
-  delete m_pRoot;
+  // delete m_pRoot; -- this is done by the tree now
   delete m_imageList;
 }
 
   delete m_imageList;
 }
 
@@ -470,16 +544,28 @@ void RegTreeCtrl::AddStdKeys()
 // 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)
 {
   int iFlags;
   long lId = HitTest(wxPoint(event.GetX(), event.GetY()), iFlags);
   if ( iFlags & wxTREE_HITTEST_ONITEMLABEL ) {
 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 );
+    // select the item first
     SelectItem(lId);
     SelectItem(lId);
-    PopupMenu(m_pMenuPopup, event.GetX(), event.GetY());
   }
   }
+  //else: take the currently selected item if click not on item
+
+  PopupMenu(m_pMenuPopup, event.GetX(), event.GetY());
 }
 
 
 }
 
 
@@ -493,14 +579,14 @@ void RegTreeCtrl::OnMenuTest()
   long lId = GetSelection();
   TreeNode *pNode = (TreeNode *)GetItemData(lId);
 
   long lId = GetSelection();
   TreeNode *pNode = (TreeNode *)GetItemData(lId);
 
-  wxCHECK_RET( pNode != NULL, "tree item without data?" );
+  wxCHECK_RET( pNode != NULL, wxT("tree item without data?") );
 
   if ( pNode->IsRoot() ) {
 
   if ( pNode->IsRoot() ) {
-    wxLogError("Can't create a subkey under the root key.");
+    wxLogError(wxT("Can't create a subkey under the root key."));
     return;
   }
   if ( !pNode->IsKey() ) {
     return;
   }
   if ( !pNode->IsKey() ) {
-    wxLogError("Can't create a subkey under a value!");
+    wxLogError(wxT("Can't create a subkey under a value!"));
     return;
   }
 
     return;
   }
 
@@ -509,27 +595,39 @@ void RegTreeCtrl::OnMenuTest()
     wxRegKey key2a(key1, "key2a"), key2b(key1, "key2b");
     if ( key2a.Create() && key2b.Create() ) {
       // put some values under the newly created keys
     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");
+      key1.SetValue(wxT("first_term"), "10");
+      key1.SetValue(wxT("second_term"), "7");
       key2a = "this is the unnamed value";
       key2a = "this is the unnamed value";
-      key2b.SetValue("sum", 17);
+      key2b.SetValue(wxT("sum"), 17);
 
       // refresh tree
       pNode->Refresh();
 
       // refresh tree
       pNode->Refresh();
-      wxLogStatus("Test keys successfully added.");
+      wxLogStatus(wxT("Test keys successfully added."));
       return;
     }
   }
       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
-    event.Skip();
+  switch ( event.KeyCode() )
+  {
+      case WXK_DELETE:
+          DeleteSelected();
+          return;
+
+      case WXK_RETURN:
+          if ( event.AltDown() )
+          {
+              ShowProperties();
+
+              return;
+          }
+  }
+
+  event.Skip();
 }
 
 void RegTreeCtrl::OnSelChanged(wxTreeEvent& event)
 }
 
 void RegTreeCtrl::OnSelChanged(wxTreeEvent& event)
@@ -545,8 +643,9 @@ void RegTreeCtrl::OnItemExpanding(wxTreeEvent& event)
 
   // expansion might take some time
   wxSetCursor(*wxHOURGLASS_CURSOR);
 
   // expansion might take some time
   wxSetCursor(*wxHOURGLASS_CURSOR);
-  wxLogStatus("Working...");
+  wxLogStatus(wxT("Working..."));
   wxYield();  // to give the status line a chance to refresh itself
   wxYield();  // to give the status line a chance to refresh itself
+  m_restoreStatus = TRUE;   // some time later...
 
   if ( pNode->IsKey() ) {
     if ( bExpanding ) {
 
   if ( pNode->IsKey() ) {
     if ( bExpanding ) {
@@ -558,17 +657,161 @@ void RegTreeCtrl::OnItemExpanding(wxTreeEvent& event)
       // collapsing: clean up
       pNode->OnCollapse();
     }
       // 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."));
 
 
-    // change icon for non root key
-    if ( !pNode->IsRoot() ) {
-      int idIcon = bExpanding ? RegImageList::OpenedKey 
-                              : RegImageList::ClosedKey;
-      SetItemImage(pNode->Id(), idIcon);
+        event.Veto();
     }
     }
-  }
+    else {
+        m_nameOld = pNode->m_strName;
+    }
+}
+
+void RegTreeCtrl::OnEndEdit(wxTreeEvent& event)
+{
+    bool ok;
 
 
-  wxLogStatus("Ok");
-  wxSetCursor(*wxSTANDARD_CURSOR);
+    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;
+
+        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"));
+
+        return;
+    }
+
+    // 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 ? "copy" : "move";
+    wxString what = isKey ? "key" : "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()
+                        ),
+                      "RegTest Confirm",
+                      wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
+      return;
+    }
+
+    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"));
+        }
+        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);
+        }
+    }
+
+    if ( !ok ) {
+        wxLogError(wxT("Failed to %s registry %s."),
+                   verb.c_str(), what.c_str());
+    }
+    else {
+        dst->Refresh();
+    }
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -576,12 +819,8 @@ 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 add children only once
+  if ( !m_aChildren.IsEmpty() ) {
     // we've been already expanded
     return TRUE;
   }
     // we've been already expanded
     return TRUE;
   }
@@ -589,7 +828,7 @@ bool RegTreeCtrl::TreeNode::OnExpand()
   if ( IsRoot() ) {
     // we're the root key
     m_pTree->AddStdKeys();
   if ( IsRoot() ) {
     // we're the root key
     m_pTree->AddStdKeys();
-    return true;
+    return TRUE;
   }
 
   if ( Parent()->IsRoot() ) {
   }
 
   if ( Parent()->IsRoot() ) {
@@ -602,10 +841,13 @@ bool RegTreeCtrl::TreeNode::OnExpand()
   }
 
   if ( !m_pKey->Open() ) {
   }
 
   if ( !m_pKey->Open() ) {
-    wxLogError("The key '%s' can't be opened.", FullName());
-    return false;
+    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;
   // enumeration variables
   long l;
   wxString str;
@@ -616,6 +858,9 @@ bool RegTreeCtrl::TreeNode::OnExpand()
   while ( bCont ) {
     m_pTree->InsertNewTreeNode(this, str, RegImageList::ClosedKey);
     bCont = m_pKey->GetNextKey(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
   }
 
   // enumerate all values
@@ -649,11 +894,9 @@ bool RegTreeCtrl::TreeNode::OnExpand()
 
       case wxRegKey::Type_Dword:
         {
 
       case wxRegKey::Type_Dword:
         {
-          char szBuf[128];
           long l;
           m_pKey->QueryValue(str, &l);
           long l;
           m_pKey->QueryValue(str, &l);
-          sprintf(szBuf, "%lx", l);
-          strItem += szBuf;
+          strItem << l;
         }
 
         // fall through
         }
 
         // fall through
@@ -664,38 +907,88 @@ bool RegTreeCtrl::TreeNode::OnExpand()
 
     m_pTree->InsertNewTreeNode(this, str, icon, &strItem);
     bCont = m_pKey->GetNextValue(str, l);
 
     m_pTree->InsertNewTreeNode(this, str, icon, &strItem);
     bCont = m_pKey->GetNextValue(str, l);
+
+    // we have at least this value...
+    isEmpty = FALSE;
   }
 
   }
 
-  return true;
+  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);
+
+    // 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();
   DestroyChildren();
-  if ( bHasChildren )
-    AddDummy();
-  else
-    m_lDummy = 0;
 
   delete m_pKey;
   m_pKey = NULL;
 }
 
 
   delete m_pKey;
   m_pKey = NULL;
 }
 
-void RegTreeCtrl::TreeNode::AddDummy()
+void RegTreeCtrl::TreeNode::Refresh()
 {
 {
-  // insert dummy item forcing appearance of [+] button
-  m_lDummy = m_pTree->InsertItem(Id(), "");
+    if ( !IsKey() )
+        return;
+
+    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();
+    }
+}
+
+bool RegTreeCtrl::TreeNode::DeleteChild(TreeNode *child)
+{
+    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()
 {
   // destroy all children
 }
 
 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);
+  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();
@@ -703,23 +996,21 @@ void RegTreeCtrl::TreeNode::DestroyChildren()
 
 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;
 
   if ( IsRoot() ) {
 {
   static wxString s_strName;
 
   if ( IsRoot() ) {
-    return "Registry Root";
+    return wxT("Registry Root");
   }
   else {
   }
   else {
-    // our own registry key might not (yet) exist or we might be a value, 
+    // 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();
     // so just use the parent's and concatenate
     s_strName = Parent()->FullName();
-    s_strName << '\\' << m_strName;
+    s_strName << wxT('\\') << m_strName;
 
     return s_strName;
   }
 
     return s_strName;
   }
@@ -729,49 +1020,86 @@ const char *RegTreeCtrl::TreeNode::FullName() const
 // operations on RegTreeCtrl
 // ----------------------------------------------------------------------------
 
 // operations on RegTreeCtrl
 // ----------------------------------------------------------------------------
 
+void RegTreeCtrl::GoTo(const wxString& location)
+{
+    wxStringTokenizer tk(location, _T("\\"));
+
+    wxTreeItemId id = GetRootItem();
+
+    while ( tk.HasMoreTokens() ) {
+        wxString subkey = tk.GetNextToken();
+
+        wxTreeItemId idCurrent = id;
+        if ( !IsExpanded(idCurrent) )
+            Expand(idCurrent);
+
+        long dummy;
+        id = GetFirstChild(idCurrent, dummy);
+
+        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  = GetParent(lCurrent);
 
   if ( lParent == 0 ) {
 void RegTreeCtrl::DeleteSelected()
 {
   long lCurrent = GetSelection(),
        lParent  = GetParent(lCurrent);
 
   if ( lParent == 0 ) {
-    wxLogError("Can't delete root key.");
+    wxLogError(wxT("Can't delete root key."));
     return;
   }
 
   TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent),
            *pParent  = (TreeNode *)GetItemData(lParent);
 
     return;
   }
 
   TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent),
            *pParent  = (TreeNode *)GetItemData(lParent);
 
-  wxCHECK_RET( pCurrent && pParent, "either node or parent without data?" );
+  wxCHECK_RET(pCurrent && pParent, wxT("either node or parent without data?"));
 
   if ( pParent->IsRoot() ) {
 
   if ( pParent->IsRoot() ) {
-    wxLogError("Can't delete standard key.");
+    wxLogError(wxT("Can't delete standard key."));
     return;
   }
 
     return;
   }
 
-  if ( pCurrent->IsKey() ) {
-    if ( wxMessageBox("Do you really want to delete this key?",
-                      "Confirmation", 
-                      wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
-      return;
-    }
-
-    // must close key before deleting it
-    pCurrent->OnCollapse();
-
-    if ( pParent->Key().DeleteKey(pCurrent->m_strName) )
-      pParent->Refresh();
+  wxString what = pCurrent->IsKey() ? "key" : "value";
+  if ( wxMessageBox(wxString::Format
+                    (
+                      wxT("Do you really want to delete this %s?"),
+                      what.c_str()
+                    ),
+                    "Confirmation",
+                    wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
+    return;
   }
   }
-  else {
-    if ( wxMessageBox("Do you really want to delete this value?",
-                      "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)
@@ -779,12 +1107,12 @@ 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?" );
-  
+  wxCHECK_RET( pCurrent != NULL, wxT("node without data?") );
+
   wxASSERT( pCurrent->IsKey() );  // check must have been done before
 
   if ( pCurrent->IsRoot() ) {
   wxASSERT( pCurrent->IsKey() );  // check must have been done before
 
   if ( pCurrent->IsRoot() ) {
-    wxLogError("Can't create a new key under the root key.");
+    wxLogError(wxT("Can't create a new key under the root key."));
     return;
   }
 
     return;
   }
 
@@ -798,12 +1126,12 @@ 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, "node without data?" );
-  
+  wxCHECK_RET( pCurrent != NULL, wxT("node without data?") );
+
   wxASSERT( pCurrent->IsKey() );  // check must have been done before
 
   if ( pCurrent->IsRoot() ) {
   wxASSERT( pCurrent->IsKey() );  // check must have been done before
 
   if ( pCurrent->IsRoot() ) {
-    wxLogError("Can't create a new value under the root key.");
+    wxLogError(wxT("Can't create a new value under the root key."));
     return;
   }
 
     return;
   }
 
@@ -816,12 +1144,12 @@ 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, "node without data?" );
-  
+  wxCHECK_RET( pCurrent != NULL, wxT("node without data?") );
+
   wxASSERT( pCurrent->IsKey() );  // check must have been done before
 
   if ( pCurrent->IsRoot() ) {
   wxASSERT( pCurrent->IsKey() );  // check must have been done before
 
   if ( pCurrent->IsRoot() ) {
-    wxLogError("Can't create a new value under the root key.");
+    wxLogError(wxT("Can't create a new value under the root key."));
     return;
   }
 
     return;
   }
 
@@ -829,12 +1157,69 @@ void RegTreeCtrl::CreateNewBinaryValue(const wxString& strName)
     pCurrent->Refresh();
 }
 
     pCurrent->Refresh();
 }
 
+void RegTreeCtrl::ShowProperties()
+{
+    long lCurrent = GetSelection();
+    TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
+
+    if ( !pCurrent || pCurrent->IsRoot() )
+    {
+        wxLogStatus(wxT("No properties"));
+
+        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"));
+
+    }
+}
+
 bool RegTreeCtrl::IsKeySelected() const
 {
   long lCurrent = GetSelection();
   TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
 
 bool RegTreeCtrl::IsKeySelected() const
 {
   long lCurrent = GetSelection();
   TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
 
-  wxCHECK( pCurrent != NULL, false );
+  wxCHECK( pCurrent != NULL, FALSE );
 
   return pCurrent->IsKey();
 
   return pCurrent->IsKey();
-}
\ No newline at end of file
+}
+
+void RegTreeCtrl::Refresh()
+{
+    long lId = GetSelection();
+    if ( !lId )
+        return;
+
+    TreeNode *pNode = (TreeNode *)GetItemData(lId);
+
+    wxCHECK_RET( pNode != NULL, wxT("tree item without data?") );
+
+    pNode->Refresh();
+}
+