Fixes to allow compilation with no wchar_t (djgpp probably has a real wchar_t

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

diff --git a/samples/regtest/regtest.cpp b/samples/regtest/regtest.cpp
index 9e4c080e48307a7a5d451b0f9009e8d9ea10a60e..8519a7cbdb583db517a388a06a00edaf1a119b23 100644 (file)
--- a/samples/regtest/regtest.cpp
+++ b/samples/regtest/regtest.cpp
@@ -19,27 +19,31 @@
 #include "wx/wxprec.h"
 
 #ifdef  __BORLANDC__
 #include "wx/wxprec.h"
 
 #ifdef  __BORLANDC__

-  #pragma hdrstop
+#   pragma hdrstop

 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

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

 #endif
 
 #endif
 

-#include "wx/log.h"

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

-#include "wx/msw/registry.h"
-#include "wx/msw/imaglist.h"
-
+#include "wx/config.h"
+#include "wx/imaglist.h"

 #include "wx/tokenzr.h"
 
 #include "wx/tokenzr.h"
 

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

 // ----------------------------------------------------------------------------
 // application type
 // ----------------------------------------------------------------------------
 class RegApp : public wxApp
 {
 public:
 // ----------------------------------------------------------------------------
 // application type
 // ----------------------------------------------------------------------------
 class RegApp : public wxApp
 {
 public:

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

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


@@ -48,156 +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 OnBeginEdit    (wxTreeEvent& event);
-  void OnEndEdit      (wxTreeEvent& event);
+    void OnBeginEdit     (wxTreeEvent& event);
+    void OnEndEdit       (wxTreeEvent& event);

 
 

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

 
 

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

 
 

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

 
 

-  // operations
-  void GoTo(const wxString& location);
-  void Refresh();
-  void DeleteSelected();
-  void ShowProperties();
-  void CreateNewKey(const wxString& strName);
-  void CreateNewTextValue(const wxString& strName);
-  void CreateNewBinaryValue(const wxString& strName);
+    // 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;
+    // 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
+    // structure describing a registry key/value
+    class TreeNode : public wxTreeItemData
+    {
+        WX_DEFINE_ARRAY_PTR(TreeNode *, TreeChildren);
+    public:
+        RegTreeCtrl  *m_pTree;     // must be !NULL
+        TreeNode     *m_pParent;    // NULL only for the root node
+        wxTreeItemId  m_id;         // the id of the tree control item
+        wxString      m_strName;    // name of the key/value
+        TreeChildren  m_aChildren;  // array of subkeys/values
+        bool          m_bKey;       // key or value?
+        wxRegKey     *m_pKey;       // only may be !NULL if m_bKey == true

 
 

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

 
 

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

 
 

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

 
 

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

 
 

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

 
 

-  wxImageList *m_imageList;
-  wxMenu      *m_pMenuPopup;
+    wxImageList *m_imageList;
+    wxMenu      *m_pMenuPopup;

 
 

-  TreeNode    *m_pRoot;
+    TreeNode    *m_pRoot;

 
 

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

 
 

-  bool         m_restoreStatus;     // after OnItemExpanding()
+    bool         m_restoreStatus;     // after OnItemExpanding()

 
 

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

 
 

-  TreeNode *GetNode(const wxTreeEvent& event)
-    { return (TreeNode *)GetItemData((WXHTREEITEM)event.GetItem()); }
+    TreeNode *GetNode(const wxTreeEvent& event)
+        { return (TreeNode *)GetItemData(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, wxChar *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 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

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


@@ -206,22 +218,22 @@ private:
 
 enum
 {
 
 enum
 {

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

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


@@ -229,38 +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_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)
+    EVT_MENU(Menu_Test,     RegFrame::OnTest)
+    EVT_MENU(Menu_About,    RegFrame::OnAbout)
+    EVT_MENU(Menu_Quit,     RegFrame::OnQuit)
+    EVT_MENU(Menu_GoTo,     RegFrame::OnGoTo)
+    EVT_MENU(Menu_Expand,   RegFrame::OnExpand)
+    EVT_MENU(Menu_Collapse, RegFrame::OnCollapse)
+    EVT_MENU(Menu_Toggle,   RegFrame::OnToggle)
+    EVT_MENU(Menu_Refresh,  RegFrame::OnRefresh)
+    EVT_MENU(Menu_Delete,   RegFrame::OnDelete)
+    EVT_MENU(Menu_NewKey,   RegFrame::OnNewKey)
+    EVT_MENU(Menu_NewText,  RegFrame::OnNewText)
+    EVT_MENU(Menu_NewBinary,RegFrame::OnNewBinary)
+    EVT_MENU(Menu_Info,     RegFrame::OnInfo)

 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 

+#if DO_REGTEST
+

 BEGIN_EVENT_TABLE(RegTreeCtrl, wxTreeCtrl)
 BEGIN_EVENT_TABLE(RegTreeCtrl, wxTreeCtrl)

-  EVT_TREE_DELETE_ITEM   (Ctrl_RegTree, RegTreeCtrl::OnDeleteItem)
-  EVT_TREE_ITEM_EXPANDING(Ctrl_RegTree, RegTreeCtrl::OnItemExpanding)
-  EVT_TREE_SEL_CHANGED   (Ctrl_RegTree, RegTreeCtrl::OnSelChanged)
+    EVT_TREE_DELETE_ITEM   (Ctrl_RegTree, RegTreeCtrl::OnDeleteItem)
+    EVT_TREE_ITEM_EXPANDING(Ctrl_RegTree, RegTreeCtrl::OnItemExpanding)
+    EVT_TREE_SEL_CHANGED   (Ctrl_RegTree, RegTreeCtrl::OnSelChanged)

 
 

-  EVT_TREE_BEGIN_LABEL_EDIT(Ctrl_RegTree, RegTreeCtrl::OnBeginEdit)
-  EVT_TREE_END_LABEL_EDIT  (Ctrl_RegTree, RegTreeCtrl::OnEndEdit)
+    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_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_CHAR      (RegTreeCtrl::OnChar)
+    EVT_RIGHT_DOWN(RegTreeCtrl::OnRightClick)
+    EVT_IDLE      (RegTreeCtrl::OnIdle)

 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 

+#endif
+

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


@@ -272,26 +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,    _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;
+    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;

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


@@ -302,13 +318,13 @@ 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, _T("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;

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


@@ -316,149 +332,182 @@ bool RegApp::OnInit()
 // ----------------------------------------------------------------------------
 
 RegFrame::RegFrame(wxFrame *parent, wxChar *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, wxID_ANY, title, wxPoint(x, y), wxSize(w, h))

 {
 {

-  // this reduces flicker effects
-  SetBackgroundColour(wxColour(255, 255, 255));
-
-  // set the icon
-  // ------------
-  SetIcon(wxIcon(_T("app_icon")));
-
-  // create menu
-  // -----------
-  wxMenu *pMenuFile = new wxMenu;
-  pMenuFile->Append(Menu_Test, _T("Te&st"), _T("Test key creation"));
-  pMenuFile->AppendSeparator();
-  pMenuFile->Append(Menu_About, _T("&About..."), _T("Show an extraordinarly beautiful dialog"));
-  pMenuFile->AppendSeparator();
-  pMenuFile->Append(Menu_Quit,  _T("E&xit"), _T("Quit this program"));
-
-  wxMenuBar *pMenu = new wxMenuBar;
-  pMenu->Append(pMenuFile, _T("&File"));
-  pMenu->Append(CreateRegistryMenu(),  _T("&Registry"));
-  SetMenuBar(pMenu);
-
-  // 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
+
+#if wxUSE_STATUSBAR
+    // create the status line
+    // ----------------------
+    CreateStatusBar(2);
+#endif // wxUSE_STATUSBAR

 }
 
 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,
-                         _T("wxRegistry sample\n")
-                         _T("© 1998, 2000 Vadim Zeitlin"),
-                         _T("About wxRegTest"), wxOK);
+    wxMessageDialog dialog(this,
+        _T("wxRegistry sample\n")
+        _T("(c) 1998, 2000 Vadim Zeitlin"),
+        _T("About wxRegTest"), wxOK);

 
 

-  dialog.ShowModal();
+    dialog.ShowModal();

 }
 
 void RegFrame::OnTest(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void RegFrame::OnTest(wxCommandEvent& WXUNUSED(event))
 {

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

 }
 
 void RegFrame::OnGoTo(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void RegFrame::OnGoTo(wxCommandEvent& WXUNUSED(event))
 {

-    static wxString s_location = _T("HKEY_CURRENT_USER\\Software\\wxWindows");
+    static wxString s_location = _T("HKEY_CURRENT_USER\\Software\\wxWidgets");
+
+    wxString location = wxGetTextFromUser(
+        _T("Enter the location to go to:"),
+        _T("wxRegTest question"),
+        s_location,
+        this);

 
 

-    wxString location = wxGetTextFromUser
-                        (
-                         _T("Enter the location to go to:"),
-                         _T("wxRegTest question"),
-                         s_location,
-                         this
-                        );

     if ( !location )
         return;
 
     s_location = location;
     if ( !location )
         return;
 
     s_location = location;

+#if DO_REGTEST

     m_treeCtrl->GoTo(location);
     m_treeCtrl->GoTo(location);

+#endif

 }
 
 void RegFrame::OnExpand(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void RegFrame::OnExpand(wxCommandEvent& WXUNUSED(event))
 {

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

 }
 
 void RegFrame::OnCollapse(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void RegFrame::OnCollapse(wxCommandEvent& WXUNUSED(event))
 {

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

 }
 
 void RegFrame::OnToggle(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void RegFrame::OnToggle(wxCommandEvent& WXUNUSED(event))
 {

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

 }
 
 void RegFrame::OnRefresh(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void RegFrame::OnRefresh(wxCommandEvent& WXUNUSED(event))
 {

-  m_treeCtrl->Refresh();
+#if DO_REGTEST
+    m_treeCtrl->DoRefresh();
+#endif

 }
 
 void RegFrame::OnDelete(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void RegFrame::OnDelete(wxCommandEvent& WXUNUSED(event))
 {

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

 }
 
 void RegFrame::OnNewKey(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void RegFrame::OnNewKey(wxCommandEvent& WXUNUSED(event))
 {

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

 }
 
 void RegFrame::OnNewText(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void RegFrame::OnNewText(wxCommandEvent& WXUNUSED(event))
 {

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

 }
 
 void RegFrame::OnNewBinary(wxCommandEvent& WXUNUSED(event))
 {
 }
 
 void RegFrame::OnNewBinary(wxCommandEvent& WXUNUSED(event))
 {

-  if ( m_treeCtrl->IsKeySelected() ) {
-    m_treeCtrl->CreateNewBinaryValue(
-      wxGetTextFromUser(_T("Enter the name for the new binary value")));
-  }
+#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))
 {
 }
 
 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 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));
-  }
+    // 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
 // ----------------------------------------------------------------------------


@@ -469,75 +518,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, 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);
-  }
-
-  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);
+    }
+
+    if ( pNewNode->IsKey() )
+    {
+        SetItemHasChildren(pNewNode->Id());
+
+        if ( !pNewNode->IsRoot() )
+        {
+            // set the expanded icon as well
+            SetItemImage(pNewNode->Id(),
+                RegImageList::OpenedKey,
+                wxTreeItemIcon_Expanded);
+        }

     }
     }

-  }

 
 

-  return pNewNode;
+    return pNewNode;

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

-           : wxTreeCtrl(parent, id, wxDefaultPosition, wxDefaultSize,
-                        wxTR_HAS_BUTTONS | wxTR_EDIT_LABELS | 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, _T("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));
+    }

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


@@ -546,129 +606,145 @@ 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()
         wxLogStatus(wxT("Ok"));
         wxSetCursor(*wxSTANDARD_CURSOR);
 
         // restore it after OnItemExpanding()
         wxLogStatus(wxT("Ok"));
         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;
+    wxTreeItemId 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, 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;
+    wxTreeItemId 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;

     }
     }

-  }

 
 

-  wxLogError(wxT("Creation of test keys failed."));
+    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(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);
+#if wxUSE_STATUSBAR
+    wxFrame *pFrame = (wxFrame *) wxWindow::GetParent();
+    pFrame->SetStatusText(GetNode(event)->FullName(), 1);
+#else
+    wxUnusedVar(event);
+#endif // wxUSE_STATUSBAR

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

-  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();
+    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);
 }
 
 void RegTreeCtrl::OnBeginEdit(wxTreeEvent& event)
 {
     TreeNode *pNode = GetNode(event);

-    if ( pNode->IsRoot() || pNode->Parent()->IsRoot() ) {
+    if ( pNode->IsRoot() || pNode->Parent()->IsRoot() )
+    {

         wxLogStatus(_T("This registry key can't be renamed."));
 
         event.Veto();
     }
         wxLogStatus(_T("This registry key can't be renamed."));
 
         event.Veto();
     }

-    else {
+    else
+    {

         m_nameOld = pNode->m_strName;
     }
 }
         m_nameOld = pNode->m_strName;
     }
 }


@@ -693,12 +769,14 @@ void RegTreeCtrl::OnEndEdit(wxTreeEvent& event)
         ok = key.RenameValue(m_nameOld, name);
     }
 
         ok = key.RenameValue(m_nameOld, name);
     }
 

-    if ( !ok ) {
+    if ( !ok )
+    {

         wxLogError(_T("Failed to rename '%s' to '%s'."),
         wxLogError(_T("Failed to rename '%s' to '%s'."),

-                   m_nameOld.c_str(), name.c_str());
+            m_nameOld.c_str(), name.c_str());

     }
 #if 0   // MSW tree ctrl doesn't like this at all, it hangs
     }
 #if 0   // MSW tree ctrl doesn't like this at all, it hangs

-    else {
+    else
+    {

         pNode->Refresh();
     }
 #endif // 0
         pNode->Refresh();
     }
 #endif // 0


@@ -712,13 +790,13 @@ void RegTreeCtrl::OnBeginDrag(wxTreeEvent& event)
     if ( pNode->IsRoot() || pNode->Parent()->IsRoot() )
     {
         wxLogStatus(wxT("This registry key can't be %s."),
     if ( pNode->IsRoot() || pNode->Parent()->IsRoot() )
     {
         wxLogStatus(wxT("This registry key can't be %s."),

-                    m_copyOnDrop ? wxT("copied") : wxT("moved"));
+            m_copyOnDrop ? wxT("copied") : wxT("moved"));

     }
     else
     {
         wxLogStatus(wxT("%s item %s..."),
     }
     else
     {
         wxLogStatus(wxT("%s item %s..."),

-                    m_copyOnDrop ? wxT("Copying") : wxT("Moving"),
-                    pNode->FullName());
+            m_copyOnDrop ? wxT("Copying") : wxT("Moving"),
+            pNode->FullName());

 
         m_draggedItem = pNode;
 
 
         m_draggedItem = pNode;
 


@@ -736,11 +814,14 @@ 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() ) {
+
+    if ( !dst || dst->IsRoot() )
+    {

         wxLogError(wxT("Can't create a key here."));
 
         return;
         wxLogError(wxT("Can't create a key here."));
 
         return;


@@ -777,39 +858,48 @@ void RegTreeCtrl::OnEndDrag(wxTreeEvent& event)
     }
 
     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 ) {
+        ok = keyDst.Create(false);
+        if ( !ok )
+        {

             wxLogError(wxT("Key '%s' already exists"), keyDst.GetName().c_str());
         }
             wxLogError(wxT("Key '%s' already exists"), keyDst.GetName().c_str());
         }

-        else {
+        else
+        {

             ok = key.Copy(keyDst);
         }
 
             ok = key.Copy(keyDst);
         }
 

-        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 ) {
+    if ( !ok )
+    {

         wxLogError(wxT("Failed to %s registry %s."),
                    verb.c_str(), what.c_str());
     }
         wxLogError(wxT("Failed to %s registry %s."),
                    verb.c_str(), what.c_str());
     }

-    else {
+    else
+    {

         dst->Refresh();
     }
 }
         dst->Refresh();
     }
 }


@@ -819,117 +909,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(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>");
+    // 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 += _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:
+    {
+        // 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) )

         {
         {

-          wxString strValue;
-          icon = RegImageList::TextValue;
-          m_pKey->QueryValue(str, strValue);
-          strItem += strValue;
+        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;

         }
         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
-    wxTreeItemId theId(Id()); // Temp variable seems necessary for BC++
-    m_pTree->Collapse(theId);
+    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);
-  }
+        // 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()


@@ -944,7 +1043,8 @@ void RegTreeCtrl::TreeNode::Refresh()
 
     OnCollapse();
     m_pTree->SetItemHasChildren(theId);
 
     OnCollapse();
     m_pTree->SetItemHasChildren(theId);

-    if ( wasExpanded ) {
+    if ( wasExpanded )
+    {

         m_pTree->Expand(theId);
         OnExpand();
     }
         m_pTree->Expand(theId);
         OnExpand();
     }


@@ -953,23 +1053,26 @@ void RegTreeCtrl::TreeNode::Refresh()
 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,
+    wxCHECK_MSG( index != wxNOT_FOUND, false,

                  wxT("our child in tree should be in m_aChildren") );
 
     m_aChildren.RemoveAt((size_t)index);
 
     bool ok;
                  wxT("our child in tree should be in m_aChildren") );
 
     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 ) {
+    if ( ok )
+    {

         wxTreeItemId theId(child->Id()); // Temp variable seems necessary for BC++
         m_pTree->Delete(theId);
 
         wxTreeItemId theId(child->Id()); // Temp variable seems necessary for BC++
         m_pTree->Delete(theId);
 


@@ -981,39 +1084,39 @@ 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];
-    wxTreeItemId theId(lId); // Temp variable seems necessary for BC++
-    m_pTree->Delete(theId);
-  }
-
-  m_aChildren.Empty();
+    // destroy all children
+    size_t nCount = m_aChildren.GetCount();
+    for ( size_t n = 0; n < nCount; n++ )
+    {
+        wxTreeItemId lId = m_aChildren[n]->Id();
+        m_pTree->Delete(lId);
+    }
+
+    m_aChildren.Empty();

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

-  delete m_pKey;
+    delete m_pKey;

 }
 
 const wxChar *RegTreeCtrl::TreeNode::FullName() const
 {
 }
 
 const wxChar *RegTreeCtrl::TreeNode::FullName() const
 {

-  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;
-  }
+    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;
+    }

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


@@ -1026,30 +1129,36 @@ void RegTreeCtrl::GoTo(const wxString& location)
 
     wxTreeItemId id = GetRootItem();
 
 
     wxTreeItemId id = GetRootItem();
 

-    while ( tk.HasMoreTokens() ) {
+    while ( tk.HasMoreTokens() )
+    {

         wxString subkey = tk.GetNextToken();
 
         wxTreeItemId idCurrent = id;
         if ( !IsExpanded(idCurrent) )
             Expand(idCurrent);
 
         wxString subkey = tk.GetNextToken();
 
         wxTreeItemId idCurrent = id;
         if ( !IsExpanded(idCurrent) )
             Expand(idCurrent);
 

-        long dummy;
+        wxTreeItemIdValue dummy;

         id = GetFirstChild(idCurrent, dummy);
 
         id = GetFirstChild(idCurrent, dummy);
 

-        if ( idCurrent == GetRootItem() ) {
+        if ( idCurrent == GetRootItem() )
+        {

             // special case: we understand both HKCU and HKEY_CURRENT_USER here
             // 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) ) {
+            for ( size_t key = 0; key < wxRegKey::nStdKeys; key++ )
+            {
+                if ( subkey == wxRegKey::GetStdKeyName(key)
+                     || subkey == wxRegKey::GetStdKeyShortName(key) )
+                {

                     break;
                 }
 
                 id = GetNextChild(idCurrent, dummy);
             }
         }
                     break;
                 }
 
                 id = GetNextChild(idCurrent, dummy);
             }
         }

-        else {
+        else
+        {

             // enum all children
             // enum all children

-            while ( id.IsOk() ) {
+            while ( id.IsOk() )
+            {

                 if ( subkey == ((TreeNode *)GetItemData(id))->m_strName )
                     break;
 
                 if ( subkey == ((TreeNode *)GetItemData(id))->m_strName )
                     break;
 


@@ -1057,7 +1166,8 @@ void RegTreeCtrl::GoTo(const wxString& location)
             }
         }
 
             }
         }
 

-        if ( !id.IsOk() ) {
+        if ( !id.IsOk() )
+        {

             wxLogError(_T("No such key '%s'."), location.c_str());
 
             return;
             wxLogError(_T("No such key '%s'."), location.c_str());
 
             return;


@@ -1070,96 +1180,102 @@ void RegTreeCtrl::GoTo(const wxString& location)
 
 void RegTreeCtrl::DeleteSelected()
 {
 
 void RegTreeCtrl::DeleteSelected()
 {

-  long lCurrent = GetSelection(),
-       lParent  = GetParent(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);
+    wxTreeItemId lCurrent = GetSelection(),
+                 lParent  = GetItemParent(lCurrent);
+
+    if ( lParent == GetRootItem() )
+    {
+        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);
+    wxTreeItemId lCurrent = GetSelection();
+    TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);

 
 

-  wxCHECK_RET( pCurrent != NULL, wxT("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(wxT("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);
+    wxTreeItemId lCurrent = GetSelection();
+    TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);

 
 

-  wxCHECK_RET( pCurrent != NULL, wxT("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(wxT("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, _T("")) )
-    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);
+    wxTreeItemId lCurrent = GetSelection();
+    TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);

 
 

-  wxCHECK_RET( pCurrent != NULL, wxT("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(wxT("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()
 {

-    long lCurrent = GetSelection();
+    wxTreeItemId lCurrent = GetSelection();

     TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
 
     if ( !pCurrent || pCurrent->IsRoot() )
     TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
 
     if ( !pCurrent || pCurrent->IsRoot() )


@@ -1191,35 +1307,36 @@ void RegTreeCtrl::ShowProperties()
         const wxRegKey& key = parent->Key();
         const wxChar *value = pCurrent->m_strName.c_str();
         wxLogMessage(wxT("Value '%s' under the key '%s' is of type ")
         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"));
+            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);
+    wxTreeItemId 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();
+    wxTreeItemId lId = GetSelection();

     if ( !lId )
         return;
 
     if ( !lId )
         return;
 

-    TreeNode *pNode = (TreeNode *)GetItemData(lId);
+    TreeNode *pNode = (TreeNode *) GetItemData(lId);

 
     wxCHECK_RET( pNode != NULL, wxT("tree item without data?") );
 
     pNode->Refresh();
 }
 
 
     wxCHECK_RET( pNode != NULL, wxT("tree item without data?") );
 
     pNode->Refresh();
 }
 

+#endif