Applied patch #845884 (Fixes Unicode compilation of stc sample with Watcom).

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

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

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

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

#ifdef  __BORLANDC__
  #pragma hdrstop
#endif

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

#include "wx/log.h"
#include "wx/treectrl.h"
#include "wx/msw/registry.h"
#include "wx/msw/imaglist.h"

#include "wx/tokenzr.h"

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

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

  RegImageList();
};

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

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

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

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

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

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

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

  // information
  bool IsKeySelected() const;

private:
  // structure describing a registry key/value
  class TreeNode : public wxTreeItemData
  {
  WX_DEFINE_ARRAY_PTR(TreeNode *, TreeChildren);
  public:
      RegTreeCtrl  *m_pTree;     // must be !NULL
      TreeNode     *m_pParent;    // NULL only for the root node
      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:
  // create a new node and insert it to the tree
  TreeNode *InsertNewTreeNode(TreeNode *pParent,
                              const wxString& strName,
                              int idImage = RegImageList::ClosedKey,
                              const wxString *pstrValue = NULL);
  // add standard registry keys
  void AddStdKeys();

private:
  DECLARE_EVENT_TABLE()
};

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

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

  void OnGoTo (wxCommandEvent& event);

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

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

  void OnInfo     (wxCommandEvent& event);

  DECLARE_EVENT_TABLE()

private:
  RegTreeCtrl *m_treeCtrl;
};

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

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

  Ctrl_RegTree  = 200,
};

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

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

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

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

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

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

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

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

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

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

  return pMenuReg;
}

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

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

  SetTopWindow(frame);

  return TRUE;
}

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

RegFrame::RegFrame(wxFrame *parent, wxChar *title, int x, int y, int w, int h)
        : wxFrame(parent, -1, 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);
}

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

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

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