]> git.saurik.com Git - wxWidgets.git/blobdiff - samples/regtest/regtest.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Applied patch [ 853031 ] Japanese po file
[wxWidgets.git] / samples / regtest / regtest.cpp
diff --git a/samples/regtest/regtest.cpp b/samples/regtest/regtest.cpp
index 79c3655f83e0812d1733cc2e7b48477b9f9d8522..76845feb09506282befaac326e0fd75064307434 100644 (file)
--- a/samples/regtest/regtest.cpp
+++ b/samples/regtest/regtest.cpp
@@ -19,17 +19,23 @@
 #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
 
 // ----------------------------------------------------------------------------
 // application type
@@ -37,7 +43,7 @@
 class RegApp : public wxApp
 {
 public:
 class RegApp : public wxApp
 {
 public:
-  bool OnInit();
+    bool OnInit();
 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------
@@ -46,148 +52,164 @@ 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();
 };
 
 };
 
+#if DO_REGTEST
+
 // ----------------------------------------------------------------------------
 // our control
 // ----------------------------------------------------------------------------
 class RegTreeCtrl : public wxTreeCtrl
 {
 public:
 // ----------------------------------------------------------------------------
 // our control
 // ----------------------------------------------------------------------------
 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 OnBeginDrag    (wxTreeEvent& event);
-  void OnEndDrag      (wxTreeEvent& event);
+    void OnBeginEdit     (wxTreeEvent& event);
+    void OnEndEdit       (wxTreeEvent& event);
 
 
-  void OnRightClick   (wxMouseEvent& event);
-  void OnChar         (wxKeyEvent& event);
-  void OnIdle         (wxIdleEvent& event);
+    void OnBeginDrag     (wxTreeEvent& event);
+    void OnEndDrag       (wxTreeEvent& event);
 
 
-  // forwarded notifications (by the frame)
-  void OnMenuTest();
+    void OnRightClick    (wxMouseEvent& event);
+    void OnChar          (wxKeyEvent& event);
+    void OnIdle          (wxIdleEvent& event);
 
 
-  // operations
-  void Refresh();
-  void DeleteSelected();
-  void ShowProperties();
-  void CreateNewKey(const wxString& strName);
-  void CreateNewTextValue(const wxString& strName);
-  void CreateNewBinaryValue(const wxString& strName);
+    // forwarded notifications (by the frame)
+    void OnMenuTest();
 
 
-  // information
-  bool IsKeySelected() const;
+    // operations
+    void GoTo(const wxString& location);
+    void DoRefresh();
+    void DeleteSelected();
+    void ShowProperties();
+    void CreateNewKey(const wxString& strName);
+    void CreateNewTextValue(const wxString& strName);
+    void CreateNewBinaryValue(const wxString& strName);
+
+    // information
+    bool IsKeySelected() const;
 
 private:
 
 private:
-  // 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
-
-      // 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 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();
-  };
-
-  wxImageList *m_imageList;
-  wxMenu      *m_pMenuPopup;
-
-  TreeNode    *m_pRoot;
-
-  TreeNode    *m_draggedItem;       // the item being dragged
-  bool         m_copyOnDrop;        // if FALSE, then move
-
-  bool         m_restoreStatus;     // after OnItemExpanding()
-
-  TreeNode *GetNode(const wxTreeEvent& event)
-    { return (TreeNode *)GetItemData((WXHTREEITEM)event.GetItem()); }
+    // 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
+
+        // 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;
+
+    TreeNode    *m_pRoot;
+
+    TreeNode    *m_draggedItem;       // the item being dragged
+    bool         m_copyOnDrop;        // if false, then move
+
+    bool         m_restoreStatus;     // after OnItemExpanding()
+
+    wxString     m_nameOld;           // the initial value of item being renamed
+
+    TreeNode *GetNode(const wxTreeEvent& event)
+        { return (TreeNode *)GetItemData((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:
 
 private:
-  DECLARE_EVENT_TABLE();
+    DECLARE_EVENT_TABLE()
 };
 
 };
 
+#endif // #if DO_REGTEST
+
 // ----------------------------------------------------------------------------
 // the main window of our application
 // ----------------------------------------------------------------------------
 class RegFrame : public wxFrame
 {
 public:
 // ----------------------------------------------------------------------------
 // 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);
-  virtual ~RegFrame();
+    // 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);
 
 
-  // callbacks
-  void OnQuit (wxCommandEvent& event);
-  void OnAbout(wxCommandEvent& event);
-  void OnTest (wxCommandEvent& event);
+    void OnGoTo (wxCommandEvent& event);
 
 
-  void OnExpand  (wxCommandEvent& event);
-  void OnCollapse(wxCommandEvent& event);
-  void OnToggle  (wxCommandEvent& event);
-  void OnRefresh (wxCommandEvent& event);
+    void 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);
 
 
-  void OnInfo     (wxCommandEvent& event);
+    void OnInfo     (wxCommandEvent& event);
 
 
-  DECLARE_EVENT_TABLE();
+    DECLARE_EVENT_TABLE()
 
 private:
 
 private:
-  RegTreeCtrl *m_treeCtrl;
+
+#if DO_REGTEST
+    RegTreeCtrl *m_treeCtrl;
+#endif
 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------
@@ -196,21 +218,22 @@ private:
 
 enum
 {
 
 enum
 {
-  Menu_Quit     = 100,
-  Menu_About,
-  Menu_Test,
-  Menu_Expand,
-  Menu_Collapse,
-  Menu_Toggle,
-  Menu_Refresh,
-  Menu_New,
-  Menu_NewKey,
-  Menu_NewText,
-  Menu_NewBinary,
-  Menu_Delete,
-  Menu_Info,
-
-  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,
 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------
@@ -218,33 +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_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)
+    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_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)
+    EVT_TREE_DELETE_ITEM   (Ctrl_RegTree, RegTreeCtrl::OnDeleteItem)
+    EVT_TREE_ITEM_EXPANDING(Ctrl_RegTree, RegTreeCtrl::OnItemExpanding)
+    EVT_TREE_SEL_CHANGED   (Ctrl_RegTree, RegTreeCtrl::OnSelChanged)
+
+    EVT_TREE_BEGIN_LABEL_EDIT(Ctrl_RegTree, RegTreeCtrl::OnBeginEdit)
+    EVT_TREE_END_LABEL_EDIT  (Ctrl_RegTree, RegTreeCtrl::OnEndEdit)
+
+    EVT_TREE_BEGIN_DRAG    (Ctrl_RegTree, RegTreeCtrl::OnBeginDrag)
+    EVT_TREE_BEGIN_RDRAG   (Ctrl_RegTree, RegTreeCtrl::OnBeginDrag)
+    EVT_TREE_END_DRAG      (Ctrl_RegTree, RegTreeCtrl::OnEndDrag)
+
+    EVT_CHAR      (RegTreeCtrl::OnChar)
+    EVT_RIGHT_DOWN(RegTreeCtrl::OnRightClick)
+    EVT_IDLE      (RegTreeCtrl::OnIdle)
 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 
+#endif
+
 // ============================================================================
 // implementation
 // ============================================================================
 // ============================================================================
 // implementation
 // ============================================================================
@@ -256,25 +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");
-  pMenuReg->AppendSeparator();
-  pMenuReg->Append(Menu_Refresh,  "&Refresh",   "Refresh the subtree");
-  pMenuReg->AppendSeparator();
-  pMenuReg->Append(Menu_Info,     "&Properties","Information about current selection");
-
-  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;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -285,145 +318,194 @@ 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, "wxRegTest", 50, 50, 600, 350);
-  frame->Show(TRUE);
+    // create the main frame window and show it
+    RegFrame *frame = new RegFrame(NULL, _T("wxRegTest"), 50, 50, 600, 350);
+    frame->Show(true);
 
 
-  SetTopWindow(frame);
+    SetTopWindow(frame);
 
 
-  return TRUE;
+    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));
-
-  // set the icon
-  // ------------
-  SetIcon(wxIcon("app_icon"));
-
-  // 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");
-
-  wxMenuBar *pMenu = new wxMenuBar;
-  pMenu->Append(pMenuFile, "&File");
-  pMenu->Append(CreateRegistryMenu(),  "&Registry");
-  SetMenuBar(pMenu);
-
-  // create child controls
-  // ---------------------
-  m_treeCtrl = new RegTreeCtrl(this, Ctrl_RegTree);
-
-  // create the status line
-  // ----------------------
-  CreateStatusBar(2);
+    // 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
+
+    // create the status line
+    // ----------------------
+    CreateStatusBar(2);
 }
 
 RegFrame::~RegFrame()
 {
 }
 
 RegFrame::~RegFrame()
 {
-  // this makes deletion of it *much* quicker
-  m_treeCtrl->Hide();
+#if DO_REGTEST
+    // this makes deletion of it *much* quicker
+    m_treeCtrl->Hide();
+#endif
 }
 
 }
 
-void RegFrame::OnQuit(wxCommandEvent& event)
+void RegFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 {
 {
-  Close(TRUE);
+    Close(true);
 }
 
 }
 
-void RegFrame::OnAbout(wxCommandEvent& event)
+void RegFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 {
 {
-  wxMessageDialog dialog(this,
-                         "wxRegistry sample\n"
-                         "© 1998, 2000 Vadim Zeitlin",
-                         "About wxRegTest", wxOK);
+    wxMessageDialog dialog(this,
+        _T("wxRegistry sample\n")
+        _T("© 1998, 2000 Vadim Zeitlin"),
+        _T("About wxRegTest"), wxOK);
 
 
-  dialog.ShowModal();
+    dialog.ShowModal();
 }
 
 }
 
-void RegFrame::OnTest(wxCommandEvent& event)
+void RegFrame::OnTest(wxCommandEvent& WXUNUSED(event))
 {
 {
-  m_treeCtrl->OnMenuTest();
+#if DO_REGTEST
+    m_treeCtrl->OnMenuTest();
+#endif
 }
 
 }
 
-void RegFrame::OnExpand(wxCommandEvent& event)
+void RegFrame::OnGoTo(wxCommandEvent& WXUNUSED(event))
 {
 {
-  m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_EXPAND);
+    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::OnCollapse(wxCommandEvent& event)
+void RegFrame::OnExpand(wxCommandEvent& WXUNUSED(event))
 {
 {
-  m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_COLLAPSE);
+#if DO_REGTEST
+    m_treeCtrl->Expand(m_treeCtrl->GetSelection());
+#endif
 }
 
 }
 
-void RegFrame::OnToggle(wxCommandEvent& event)
+void RegFrame::OnCollapse(wxCommandEvent& WXUNUSED(event))
 {
 {
-  m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_TOGGLE);
+#if DO_REGTEST
+    m_treeCtrl->Collapse(m_treeCtrl->GetSelection());
+#endif
 }
 
 }
 
-void RegFrame::OnRefresh(wxCommandEvent& event)
+void RegFrame::OnToggle(wxCommandEvent& WXUNUSED(event))
 {
 {
-  m_treeCtrl->Refresh();
+#if DO_REGTEST
+    m_treeCtrl->Toggle(m_treeCtrl->GetSelection());
+#endif
 }
 
 }
 
-void RegFrame::OnDelete(wxCommandEvent& event)
+void RegFrame::OnRefresh(wxCommandEvent& WXUNUSED(event))
 {
 {
-  m_treeCtrl->DeleteSelected();
+#if DO_REGTEST
+    m_treeCtrl->DoRefresh();
+#endif
 }
 
 }
 
-void RegFrame::OnNewKey(wxCommandEvent& event)
+void RegFrame::OnDelete(wxCommandEvent& WXUNUSED(event))
 {
 {
-  if ( m_treeCtrl->IsKeySelected() ) {
-    m_treeCtrl->CreateNewKey(
-      wxGetTextFromUser("Enter the name of the new key"));
-  }
+#if DO_REGTEST
+    m_treeCtrl->DeleteSelected();
+#endif
 }
 
 }
 
-void RegFrame::OnNewText(wxCommandEvent& event)
+void RegFrame::OnNewKey(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->CreateNewKey(
+            wxGetTextFromUser(_T("Enter the name of the new key")));
+    }
+#endif
 }
 
 }
 
-void RegFrame::OnNewBinary(wxCommandEvent& event)
+void RegFrame::OnNewText(wxCommandEvent& WXUNUSED(event))
 {
 {
-  if ( m_treeCtrl->IsKeySelected() ) {
-    m_treeCtrl->CreateNewBinaryValue(
-      wxGetTextFromUser("Enter the name for the new binary value"));
-  }
+#if DO_REGTEST
+    if ( m_treeCtrl->IsKeySelected() )
+    {
+        m_treeCtrl->CreateNewTextValue(
+            wxGetTextFromUser(_T("Enter the name for the new text value")));
+    }
+#endif
 }
 
 }
 
-void RegFrame::OnInfo(wxCommandEvent& event)
+void RegFrame::OnNewBinary(wxCommandEvent& WXUNUSED(event))
 {
 {
+#if DO_REGTEST
+    if ( m_treeCtrl->IsKeySelected() )
+    {
+        m_treeCtrl->CreateNewBinaryValue(
+            wxGetTextFromUser(_T("Enter the name for the new binary value")));
+    }
+#endif
+}
+
+void RegFrame::OnInfo(wxCommandEvent& WXUNUSED(event))
+{
+#if DO_REGTEST
     m_treeCtrl->ShowProperties();
     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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // RegTreeCtrl
 // ----------------------------------------------------------------------------
@@ -434,75 +516,86 @@ RegTreeCtrl::TreeNode *RegTreeCtrl::InsertNewTreeNode(TreeNode *pParent,
                                                       int idImage,
                                                       const wxString *pstrValue)
 {
                                                       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->Id() : 0,
-                                   pNewNode->IsKey() ? strName : *pstrValue,
-                                   idImage);
-
-  wxASSERT_MSG( pNewNode->m_id, "can't create tree control item!");
-
-  // 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);
-  }
-
-  if ( pNewNode->IsKey() ) {
-    SetItemHasChildren(pNewNode->Id());
-
-    if ( !pNewNode->IsRoot() ) {
-        // set the expanded icon as well
-        SetItemImage(pNewNode->Id(),
-                     RegImageList::OpenedKey,
-                     wxTreeItemIcon_Expanded);
+    // 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, wxT("can't create tree control item!"));
+
+    // 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);
     }
     }
-  }
 
 
-  return pNewNode;
+    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)
 }
 
 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;
-  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; -- this is done by the tree now
-  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));
+    }
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -511,118 +604,176 @@ void RegTreeCtrl::AddStdKeys()
 
 void RegTreeCtrl::OnIdle(wxIdleEvent& WXUNUSED(event))
 {
 
 void RegTreeCtrl::OnIdle(wxIdleEvent& WXUNUSED(event))
 {
-    if ( m_restoreStatus ) {
+    if ( m_restoreStatus )
+    {
         // restore it after OnItemExpanding()
         // restore it after OnItemExpanding()
-        wxLogStatus("Ok");
+        wxLogStatus(wxT("Ok"));
         wxSetCursor(*wxSTANDARD_CURSOR);
 
         wxSetCursor(*wxSTANDARD_CURSOR);
 
-        m_restoreStatus = FALSE;
+        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 ) {
-    // select the item first
-    SelectItem(lId);
-  }
-  //else: take the currently selected item if click not on item
-
-  PopupMenu(m_pMenuPopup, event.GetX(), event.GetY());
+    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());
 }
 
 
 }
 
 
-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)
 {
-  switch ( event.KeyCode() )
-  {
-      case WXK_DELETE:
-          DeleteSelected();
-          return;
-
-      case WXK_RETURN:
-          if ( event.AltDown() )
-          {
-              ShowProperties();
-
-              return;
-          }
-  }
-
-  event.Skip();
+    switch ( event.GetKeyCode() )
+    {
+    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)
 {
-  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;
-
-  // expansion might take some time
-  wxSetCursor(*wxHOURGLASS_CURSOR);
-  wxLogStatus("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;
+    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 {
-      // collapsing: clean up
-      pNode->OnCollapse();
+    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)
 }
 
 void RegTreeCtrl::OnBeginDrag(wxTreeEvent& event)
@@ -632,14 +783,14 @@ void RegTreeCtrl::OnBeginDrag(wxTreeEvent& event)
     TreeNode *pNode = GetNode(event);
     if ( pNode->IsRoot() || pNode->Parent()->IsRoot() )
     {
     TreeNode *pNode = GetNode(event);
     if ( pNode->IsRoot() || pNode->Parent()->IsRoot() )
     {
-        wxLogStatus("This registry key can't be %s.",
-                    m_copyOnDrop ? "copied" : "moved");
+        wxLogStatus(wxT("This registry key can't be %s."),
+            m_copyOnDrop ? wxT("copied") : wxT("moved"));
     }
     else
     {
     }
     else
     {
-        wxLogStatus("%s item %s...",
-                    m_copyOnDrop ? "Copying" : "Moving",
-                    pNode->FullName());
+        wxLogStatus(wxT("%s item %s..."),
+            m_copyOnDrop ? wxT("Copying") : wxT("Moving"),
+            pNode->FullName());
 
         m_draggedItem = pNode;
 
 
         m_draggedItem = pNode;
 
@@ -649,7 +800,7 @@ void RegTreeCtrl::OnBeginDrag(wxTreeEvent& event)
 
 void RegTreeCtrl::OnEndDrag(wxTreeEvent& event)
 {
 
 void RegTreeCtrl::OnEndDrag(wxTreeEvent& event)
 {
-    wxCHECK_RET( m_draggedItem, "end drag without begin drag?" );
+    wxCHECK_RET( m_draggedItem, wxT("end drag without begin drag?") );
 
     // clear the pointer anyhow
     TreeNode *src = m_draggedItem;
 
     // clear the pointer anyhow
     TreeNode *src = m_draggedItem;
@@ -657,12 +808,15 @@ void RegTreeCtrl::OnEndDrag(wxTreeEvent& event)
 
     // where are we going to drop it?
     TreeNode *dst = GetNode(event);
 
     // where are we going to drop it?
     TreeNode *dst = GetNode(event);
-    if ( dst && !dst->IsKey() ) {
+    if ( dst && !dst->IsKey() )
+    {
         // we need a parent key
         dst = dst->Parent();
     }
         // we need a parent key
         dst = dst->Parent();
     }
-    if ( !dst || dst->IsRoot() ) {
-        wxLogError("Can't create a key here.");
+
+    if ( !dst || dst->IsRoot() )
+    {
+        wxLogError(wxT("Can't create a key here."));
 
         return;
     }
 
         return;
     }
@@ -670,7 +824,7 @@ void RegTreeCtrl::OnEndDrag(wxTreeEvent& event)
     bool isKey = src->IsKey();
     if ( (isKey && (src == dst)) ||
          (!isKey && (dst->Parent() == src)) ) {
     bool isKey = src->IsKey();
     if ( (isKey && (src == dst)) ||
          (!isKey && (dst->Parent() == src)) ) {
-        wxLogStatus("Can't copy something on itself");
+        wxLogStatus(wxT("Can't copy something on itself"));
 
         return;
     }
 
         return;
     }
@@ -681,63 +835,66 @@ void RegTreeCtrl::OnEndDrag(wxTreeEvent& event)
     nameDst << wxString(dst->FullName()).AfterFirst('\\') << '\\'
             << wxString(src->FullName()).AfterLast('\\');
 
     nameDst << wxString(dst->FullName()).AfterFirst('\\') << '\\'
             << wxString(src->FullName()).AfterLast('\\');
 
-    wxString verb = m_copyOnDrop ? "copy" : "move";
-    wxString what = isKey ? "key" : "value";
+    wxString verb = m_copyOnDrop ? _T("copy") : _T("move");
+    wxString what = isKey ? _T("key") : _T("value");
 
     if ( wxMessageBox(wxString::Format
                         (
 
     if ( wxMessageBox(wxString::Format
                         (
-                         "Do you really want to %s the %s %s to %s?",
+                         wxT("Do you really want to %s the %s %s to %s?"),
                          verb.c_str(),
                          what.c_str(),
                          nameSrc.c_str(),
                          nameDst.c_str()
                         ),
                          verb.c_str(),
                          what.c_str(),
                          nameSrc.c_str(),
                          nameDst.c_str()
                         ),
-                      "RegTest Confirm",
+                      _T("RegTest Confirm"),
                       wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
       return;
     }
 
                       wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
       return;
     }
 
-    bool dstExpanded = IsExpanded(dst->Id());
-
     bool ok;
     bool ok;
-    if ( isKey ) {
+    if ( isKey )
+    {
         wxRegKey& key = src->Key();
         wxRegKey keyDst(dst->Key(), src->m_strName);
         wxRegKey& key = src->Key();
         wxRegKey keyDst(dst->Key(), src->m_strName);
-        ok = keyDst.Create(FALSE);
-        if ( !ok ) {
-            wxLogError("Key '%s' already exists");
+        ok = keyDst.Create(false);
+        if ( !ok )
+        {
+            wxLogError(wxT("Key '%s' already exists"), keyDst.GetName().c_str());
         }
         }
-        else {
+        else
+        {
             ok = key.Copy(keyDst);
         }
             ok = key.Copy(keyDst);
         }
-        if ( ok && dstExpanded ) {
-            dst->OnCollapse();
-            dst->OnExpand();
-        }
 
 
-        if ( ok && !m_copyOnDrop ) {
+        if ( ok && !m_copyOnDrop )
+        {
             // delete the old key
             ok = key.DeleteSelf();
             // delete the old key
             ok = key.DeleteSelf();
-            if ( ok ) {
+            if ( ok )
+            {
                 src->Parent()->Refresh();
             }
         }
     }
                 src->Parent()->Refresh();
             }
         }
     }
-    else { // value
+    else // value
+    {
         wxRegKey& key = src->Parent()->Key();
         ok = key.CopyValue(src->m_strName, dst->Key());
         wxRegKey& key = src->Parent()->Key();
         ok = key.CopyValue(src->m_strName, dst->Key());
-        if ( ok && !m_copyOnDrop ) {
+        if ( ok && !m_copyOnDrop )
+        {
             // we moved it, so delete the old one
             ok = key.DeleteValue(src->m_strName);
             // we moved it, so delete the old one
             ok = key.DeleteValue(src->m_strName);
-            if ( ok ) {
-                // reexpand the key
-                dst->Refresh();
-            }
         }
     }
 
         }
     }
 
-    if ( !ok ) {
-        wxLogError("Failed to %s registry %s.", verb.c_str(), what.c_str());
+    if ( !ok )
+    {
+        wxLogError(wxT("Failed to %s registry %s."),
+                   verb.c_str(), what.c_str());
+    }
+    else
+    {
+        dst->Refresh();
     }
 }
 
     }
 }
 
@@ -746,116 +903,126 @@ void RegTreeCtrl::OnEndDrag(wxTreeEvent& event)
 // ----------------------------------------------------------------------------
 bool RegTreeCtrl::TreeNode::OnExpand()
 {
 // ----------------------------------------------------------------------------
 bool RegTreeCtrl::TreeNode::OnExpand()
 {
-  // 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 {
-    // 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;
-  }
-
-  // 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 = "<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:
         {
         {
-          long l;
-          m_pKey->QueryValue(str, &l);
-          strItem << l;
+            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);
+        m_pTree->InsertNewTreeNode(this, str, icon, &strItem);
+        bCont = m_pKey->GetNextValue(str, l);
 
 
-    // we have at least this value...
-    isEmpty = FALSE;
-  }
+        // we have at least this value...
+        isEmpty = false;
+    }
 
 
-  if ( isEmpty ) {
-    // this is for the case when our last child was just deleted
-    m_pTree->Collapse(Id());
+    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(Id(), FALSE);
-  }
+        // we won't be expanded any more
+        m_pTree->SetItemHasChildren(theId, false);
+    }
 
 
-  return TRUE;
+    return true;
 }
 
 void RegTreeCtrl::TreeNode::OnCollapse()
 {
 }
 
 void RegTreeCtrl::TreeNode::OnCollapse()
 {
-  DestroyChildren();
+    DestroyChildren();
 
 
-  delete m_pKey;
-  m_pKey = NULL;
+    delete m_pKey;
+    m_pKey = NULL;
 }
 
 void RegTreeCtrl::TreeNode::Refresh()
 }
 
 void RegTreeCtrl::TreeNode::Refresh()
@@ -863,40 +1030,45 @@ void RegTreeCtrl::TreeNode::Refresh()
     if ( !IsKey() )
         return;
 
     if ( !IsKey() )
         return;
 
-    if ( m_pTree->IsExpanded(Id()) ) {
-        m_pTree->Collapse(Id());
-        OnCollapse();
-        m_pTree->SetItemHasChildren(Id());
-        m_pTree->Expand(Id());
+    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();
     }
         OnExpand();
     }
-    else {
-        // just allow it to be expanded
-        m_pTree->SetItemHasChildren(Id());
-    }
 }
 
 bool RegTreeCtrl::TreeNode::DeleteChild(TreeNode *child)
 {
     int index = m_aChildren.Index(child);
 }
 
 bool RegTreeCtrl::TreeNode::DeleteChild(TreeNode *child)
 {
     int index = m_aChildren.Index(child);
-    wxCHECK_MSG( index != wxNOT_FOUND, FALSE,
-                 "our child in tree should be in m_aChildren" );
+    wxCHECK_MSG( index != wxNOT_FOUND, false,
+                 wxT("our child in tree should be in m_aChildren") );
 
     m_aChildren.RemoveAt((size_t)index);
 
     bool ok;
 
     m_aChildren.RemoveAt((size_t)index);
 
     bool ok;
-    if ( child->IsKey() ) {
+    if ( child->IsKey() )
+    {
         // must close key before deleting it
         child->OnCollapse();
 
         ok = Key().DeleteKey(child->m_strName);
     }
         // must close key before deleting it
         child->OnCollapse();
 
         ok = Key().DeleteKey(child->m_strName);
     }
-    else {
+    else
+    {
         ok = Key().DeleteValue(child->m_strName);
     }
 
         ok = Key().DeleteValue(child->m_strName);
     }
 
-    if ( ok ) {
-        m_pTree->Delete(child->Id());
+    if ( ok )
+    {
+        wxTreeItemId theId(child->Id()); // Temp variable seems necessary for BC++
+        m_pTree->Delete(theId);
 
         Refresh();
     }
 
         Refresh();
     }
@@ -906,131 +1078,196 @@ bool RegTreeCtrl::TreeNode::DeleteChild(TreeNode *child)
 
 void RegTreeCtrl::TreeNode::DestroyChildren()
 {
 
 void RegTreeCtrl::TreeNode::DestroyChildren()
 {
-  // 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];
-    m_pTree->Delete(lId);
-  }
-
-  m_aChildren.Empty();
+    // 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();
 }
 
 RegTreeCtrl::TreeNode::~TreeNode()
 {
 }
 
 RegTreeCtrl::TreeNode::~TreeNode()
 {
-  delete m_pKey;
+    delete m_pKey;
 }
 
 }
 
-const char *RegTreeCtrl::TreeNode::FullName() const
+const wxChar *RegTreeCtrl::TreeNode::FullName() const
 {
 {
-  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;
-
-    return s_strName;
-  }
+    static wxString s_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;
+    }
 }
 
 // ----------------------------------------------------------------------------
 // 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);
+
+        wxTreeItemIdValue 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()
 {
 void RegTreeCtrl::DeleteSelected()
 {
-  long lCurrent = GetSelection(),
-       lParent  = GetParent(lCurrent);
-
-  if ( lParent == 0 ) {
-    wxLogError("Can't delete root key.");
-    return;
-  }
-
-  TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent),
-           *pParent  = (TreeNode *)GetItemData(lParent);
-
-  wxCHECK_RET( pCurrent && pParent, "either node or parent without data?" );
-
-  if ( pParent->IsRoot() ) {
-    wxLogError("Can't delete standard key.");
-    return;
-  }
-
-  wxString what = pCurrent->IsKey() ? "key" : "value";
-  if ( wxMessageBox(wxString::Format
-                    (
-                      "Do you really want to delete this %s?",
-                      what.c_str()
-                    ),
-                    "Confirmation",
-                    wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
-    return;
-  }
-
-  pParent->DeleteChild(pCurrent);
+    long lCurrent = GetSelection(),
+        lParent  = GetItemParent(lCurrent);
+
+    if ( lParent == 0 )
+    {
+        wxLogError(wxT("Can't delete root key."));
+        return;
+    }
+
+    TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent),
+        *pParent  = (TreeNode *)GetItemData(lParent);
+
+    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;
+    }
+
+    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?" );
+    wxCHECK_RET( pCurrent != NULL, wxT("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 key under the root key.");
-    return;
-  }
+    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, "node without data?" );
+    wxCHECK_RET( pCurrent != NULL, wxT("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, "node without data?" );
+    wxCHECK_RET( pCurrent != NULL, wxT("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, 0) )
-    pCurrent->Refresh();
+    if ( pCurrent->Key().SetValue(strName, 0) )
+        pCurrent->Refresh();
 }
 
 void RegTreeCtrl::ShowProperties()
 }
 
 void RegTreeCtrl::ShowProperties()
@@ -1040,7 +1277,7 @@ void RegTreeCtrl::ShowProperties()
 
     if ( !pCurrent || pCurrent->IsRoot() )
     {
 
     if ( !pCurrent || pCurrent->IsRoot() )
     {
-        wxLogStatus("No properties");
+        wxLogStatus(wxT("No properties"));
 
         return;
     }
 
         return;
     }
@@ -1051,51 +1288,52 @@ void RegTreeCtrl::ShowProperties()
         size_t nSubKeys, nValues;
         if ( !key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
         {
         size_t nSubKeys, nValues;
         if ( !key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
         {
-            wxLogError("Couldn't get key info");
+            wxLogError(wxT("Couldn't get key info"));
         }
         else
         {
         }
         else
         {
-            wxLogMessage("Key '%s' has %u subkeys and %u values.",
+            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();
                          key.GetName().c_str(), nSubKeys, nValues);
         }
     }
     else // it's a value
     {
         TreeNode *parent = pCurrent->Parent();
-        wxCHECK_RET( parent, "reg value without key?" );
+        wxCHECK_RET( parent, wxT("reg value without key?") );
 
         const wxRegKey& key = parent->Key();
 
         const wxRegKey& key = parent->Key();
-        const char *value = pCurrent->m_strName.c_str();
-        wxLogMessage("Value '%s' under the key '%s' is of type "
-                     "%d (%s).",
-                     value,
-                     parent->m_strName.c_str(),
-                     key.GetValueType(value),
-                     key.IsNumericValue(value) ? "numeric" : "string");
+        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
 {
 
     }
 }
 
 bool RegTreeCtrl::IsKeySelected() const
 {
-  long lCurrent = GetSelection();
-  TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
+    long lCurrent = GetSelection();
+    TreeNode *pCurrent = (TreeNode *) GetItemData(lCurrent);
 
 
-  wxCHECK( pCurrent != NULL, FALSE );
+    wxCHECK( pCurrent != NULL, false );
 
 
-  return pCurrent->IsKey();
+    return pCurrent->IsKey();
 }
 
 }
 
-void RegTreeCtrl::Refresh()
+void RegTreeCtrl::DoRefresh()
 {
     long lId = GetSelection();
     if ( !lId )
         return;
 
 {
     long lId = GetSelection();
     if ( !lId )
         return;
 
-    TreeNode *pNode = (TreeNode *)GetItemData(lId);
+    TreeNode *pNode = (TreeNode *) GetItemData(lId);
 
 
-    wxCHECK_RET( pNode != NULL, "tree item without data?" );
+    wxCHECK_RET( pNode != NULL, wxT("tree item without data?") );
 
     pNode->Refresh();
 }
 
 
     pNode->Refresh();
 }
 
+#endif
wxWidgets (Impactor)