///////////////////////////////////////////////////////////////////////////////
-// Name: registry.cpp
+// Name: regtest.cpp
// Purpose: wxRegKey class demo
// Author: Vadim Zeitlin
-// Modified by:
+// Modified by:
// Created: 03.04.98
// RCS-ID: $Id$
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
#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(void);
+ bool OnInit();
};
// ----------------------------------------------------------------------------
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;
- DECLARE_EVENT_TABLE();
-
private:
- // array of children of the node
- struct TreeNode;
- WX_DEFINE_ARRAY(TreeNode *, TreeChildren);
-
// structure describing a registry key/value
- struct TreeNode
+ class TreeNode : public wxTreeItemData
{
- RegTreeCtrl *m_pTree; // must be !NULL
- TreeNode *m_pParent; // NULL only for the root node
- long m_id; // the id of the tree control item
- wxString m_strName; // name of the key/value
- TreeChildren m_aChildren; // array of subkeys/values
- bool m_bKey; // key or value?
- wxRegKey *m_pKey; // only may be !NULL if m_bKey == true
- long m_lDummy; // dummy subkey (to make expansion possible)
-
- // ctor
- TreeNode() { m_lDummy = 0; }
-
- // trivial accessors
- long Id() const { return m_id; }
- bool IsRoot() const { return m_pParent == NULL; }
- bool IsKey() const { return m_bKey; }
- TreeNode *Parent() const { return m_pParent; }
-
- // notifications
- bool OnExpand();
- void OnCollapse();
-
- // operations
- void Refresh() { OnCollapse(); OnExpand(); }
- void AddDummy();
- void DestroyChildren();
- const char *FullName() const;
-
- // get the associated key: make sure the pointer is !NULL
- wxRegKey& Key() { if ( !m_pKey ) OnExpand(); return *m_pKey; }
-
- // dtor deletes all children
- ~TreeNode();
+ 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;
- wxImageList *m_imageList;
+
+ TreeNode *m_draggedItem; // the item being dragged
+ bool m_copyOnDrop; // if FALSE, then move
+
+ bool m_restoreStatus; // after OnItemExpanding()
+
+ wxString m_nameOld; // the initial value of item being renamed
TreeNode *GetNode(const wxTreeEvent& event)
- { return (TreeNode *)GetItemData(event.m_item.m_itemId); }
+ { return (TreeNode *)GetItemData((WXHTREEITEM)event.GetItem()); }
public:
// create a new node and insert it to the tree
- TreeNode *InsertNewTreeNode(TreeNode *pParent,
+ TreeNode *InsertNewTreeNode(TreeNode *pParent,
const wxString& strName,
int idImage = RegImageList::ClosedKey,
const wxString *pstrValue = NULL);
// add standard registry keys
void AddStdKeys();
+
+private:
+ DECLARE_EVENT_TABLE()
};
// ----------------------------------------------------------------------------
// 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(void);
-
+ 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);
- bool OnClose () { return TRUE; }
+ void OnInfo (wxCommandEvent& event);
- DECLARE_EVENT_TABLE();
+ DECLARE_EVENT_TABLE()
private:
RegTreeCtrl *m_treeCtrl;
Menu_Quit = 100,
Menu_About,
Menu_Test,
+ Menu_GoTo,
Menu_Expand,
Menu_Collapse,
Menu_Toggle,
+ Menu_Refresh,
Menu_New,
- Menu_NewKey,
- Menu_NewText,
+ Menu_NewKey,
+ Menu_NewText,
Menu_NewBinary,
Menu_Delete,
+ Menu_Info,
Ctrl_RegTree = 200,
};
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_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()
// ============================================================================
pMenuReg->Append(Menu_New, "&New", pMenuNew);
pMenuReg->Append(Menu_Delete, "&Delete...", "Delete selected key/value");
pMenuReg->AppendSeparator();
+ pMenuReg->Append(Menu_GoTo, "&Go to...\tCtrl-G", "Go to registry key");
pMenuReg->Append(Menu_Expand, "&Expand", "Expand current key");
pMenuReg->Append(Menu_Collapse, "&Collapse", "Collapse current key");
pMenuReg->Append(Menu_Toggle, "&Toggle", "Toggle current key");
+ pMenuReg->AppendSeparator();
+ pMenuReg->Append(Menu_Refresh, "&Refresh", "Refresh the subtree");
+ pMenuReg->AppendSeparator();
+ pMenuReg->Append(Menu_Info, "&Properties","Information about current selection");
return pMenuReg;
}
bool RegApp::OnInit()
{
// create the main frame window and show it
- RegFrame *frame = new RegFrame(NULL, "wxRegKey Test", 50, 50, 600, 350);
- frame->Show(true);
-
+ RegFrame *frame = new RegFrame(NULL, "wxRegTest", 50, 50, 600, 350);
+ frame->Show(TRUE);
+
SetTopWindow(frame);
- return true;
+ return TRUE;
}
// ----------------------------------------------------------------------------
// create the status line
// ----------------------
- int aWidths[2];
- aWidths[0] = 200;
- aWidths[1] = -1;
CreateStatusBar(2);
- SetStatusWidths(2, aWidths);
}
-RegFrame::~RegFrame(void)
+RegFrame::~RegFrame()
{
+ // this makes deletion of it *much* quicker
+ m_treeCtrl->Hide();
}
void RegFrame::OnQuit(wxCommandEvent& event)
void RegFrame::OnAbout(wxCommandEvent& event)
{
- wxMessageDialog dialog(this, "wxRegistry sample\n(c) 1998 Vadim Zeitlin",
- "About wxRegistry", wxOK);
+ wxMessageDialog dialog(this,
+ "wxRegistry sample\n"
+ "© 1998, 2000 Vadim Zeitlin",
+ "About wxRegTest", wxOK);
dialog.ShowModal();
}
-void RegFrame::OnTest(wxCommandEvent& event)
+void RegFrame::OnTest(wxCommandEvent& WXUNUSED(event))
{
m_treeCtrl->OnMenuTest();
}
-void RegFrame::OnExpand(wxCommandEvent& event)
+void RegFrame::OnGoTo(wxCommandEvent& WXUNUSED(event))
+{
+ static wxString s_location = _T("HKEY_CURRENT_USER\\Software\\wxWindows");
+
+ wxString location = wxGetTextFromUser
+ (
+ _T("Enter the location to go to:"),
+ _T("wxRegTest question"),
+ s_location,
+ this
+ );
+ if ( !location )
+ return;
+
+ s_location = location;
+ m_treeCtrl->GoTo(location);
+}
+
+void RegFrame::OnExpand(wxCommandEvent& WXUNUSED(event))
{
m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_EXPAND);
}
-void RegFrame::OnCollapse(wxCommandEvent& event)
+void RegFrame::OnCollapse(wxCommandEvent& WXUNUSED(event))
{
m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_COLLAPSE);
}
-void RegFrame::OnToggle(wxCommandEvent& event)
+void RegFrame::OnToggle(wxCommandEvent& WXUNUSED(event))
{
m_treeCtrl->ExpandItem(m_treeCtrl->GetSelection(), wxTREE_EXPAND_TOGGLE);
}
-void RegFrame::OnDelete(wxCommandEvent& event)
+void RegFrame::OnRefresh(wxCommandEvent& WXUNUSED(event))
+{
+ m_treeCtrl->Refresh();
+}
+
+void RegFrame::OnDelete(wxCommandEvent& WXUNUSED(event))
{
m_treeCtrl->DeleteSelected();
}
-void RegFrame::OnNewKey(wxCommandEvent& event)
+void RegFrame::OnNewKey(wxCommandEvent& WXUNUSED(event))
{
if ( m_treeCtrl->IsKeySelected() ) {
m_treeCtrl->CreateNewKey(
}
}
-void RegFrame::OnNewText(wxCommandEvent& event)
+void RegFrame::OnNewText(wxCommandEvent& WXUNUSED(event))
{
if ( m_treeCtrl->IsKeySelected() ) {
m_treeCtrl->CreateNewTextValue(
}
}
-void RegFrame::OnNewBinary(wxCommandEvent& event)
+void RegFrame::OnNewBinary(wxCommandEvent& WXUNUSED(event))
{
if ( m_treeCtrl->IsKeySelected() ) {
m_treeCtrl->CreateNewBinaryValue(
}
}
+void RegFrame::OnInfo(wxCommandEvent& WXUNUSED(event))
+{
+ m_treeCtrl->ShowProperties();
+}
+
// ----------------------------------------------------------------------------
// RegImageList
// ----------------------------------------------------------------------------
// should be in sync with enum RegImageList::RegIcon
static const char *aszIcons[] = { "key1","key2","key3","value1","value2" };
wxString str = "icon_";
- for ( uint n = 0; n < WXSIZEOF(aszIcons); n++ ) {
+ for ( unsigned int n = 0; n < WXSIZEOF(aszIcons); n++ ) {
Add(wxIcon(str + aszIcons[n], wxBITMAP_TYPE_ICO_RESOURCE));
}
}
// ----------------------------------------------------------------------------
// create a new tree item and insert it into the tree
-RegTreeCtrl::TreeNode *RegTreeCtrl::InsertNewTreeNode(TreeNode *pParent,
+RegTreeCtrl::TreeNode *RegTreeCtrl::InsertNewTreeNode(TreeNode *pParent,
const wxString& strName,
int idImage,
const wxString *pstrValue)
pNewNode->m_strName = strName;
pNewNode->m_bKey = pstrValue == NULL;
pNewNode->m_pKey = NULL;
- pNewNode->m_id = InsertItem(pParent ? pParent->m_id : 0,
+ pNewNode->m_id = InsertItem(pParent ? pParent->Id() : 0,
pNewNode->IsKey() ? strName : *pstrValue,
idImage);
wxASSERT_MSG( pNewNode->m_id, "can't create tree control item!");
// save the pointer in the item
- if ( !SetItemData(pNewNode->m_id, (long)pNewNode) ) {
- wxFAIL_MSG("can't store item's data in tree control!");
- }
+ SetItemData(pNewNode->m_id, pNewNode);
// add it to the list of parent's children
if ( pParent != NULL ) {
pParent->m_aChildren.Add(pNewNode);
}
- // force the [+] button (@@@ not very elegant...)
- if ( pNewNode->IsKey() )
- pNewNode->AddDummy();
+ if ( pNewNode->IsKey() ) {
+ SetItemHasChildren(pNewNode->Id());
+
+ if ( !pNewNode->IsRoot() ) {
+ // set the expanded icon as well
+ SetItemImage(pNewNode->Id(),
+ RegImageList::OpenedKey,
+ wxTreeItemIcon_Expanded);
+ }
+ }
return pNewNode;
}
RegTreeCtrl::RegTreeCtrl(wxWindow *parent, wxWindowID id)
- : wxTreeCtrl(parent, id, wxDefaultPosition, wxDefaultSize,
- wxTR_HAS_BUTTONS | wxSUNKEN_BORDER)
+ : wxTreeCtrl(parent, id, wxDefaultPosition, wxDefaultSize,
+ wxTR_HAS_BUTTONS | wxTR_EDIT_LABELS | wxSUNKEN_BORDER)
{
+ // init members
+ m_draggedItem = NULL;
+ m_restoreStatus = FALSE;
+
// create the image list
// ---------------------
m_imageList = new RegImageList;
RegTreeCtrl::~RegTreeCtrl()
{
delete m_pMenuPopup;
- delete m_pRoot;
+ // delete m_pRoot; -- this is done by the tree now
delete m_imageList;
}
void RegTreeCtrl::AddStdKeys()
{
- for ( uint ui = 0; ui < wxRegKey::nStdKeys; ui++ ) {
+ for ( unsigned int ui = 0; ui < wxRegKey::nStdKeys; ui++ ) {
InsertNewTreeNode(m_pRoot, wxRegKey::GetStdKeyName(ui));
}
}
// notifications
// ----------------------------------------------------------------------------
+void RegTreeCtrl::OnIdle(wxIdleEvent& WXUNUSED(event))
+{
+ if ( m_restoreStatus ) {
+ // restore it after OnItemExpanding()
+ wxLogStatus("Ok");
+ wxSetCursor(*wxSTANDARD_CURSOR);
+
+ m_restoreStatus = FALSE;
+ }
+}
+
void RegTreeCtrl::OnRightClick(wxMouseEvent& event)
{
int iFlags;
long lId = HitTest(wxPoint(event.GetX(), event.GetY()), iFlags);
if ( iFlags & wxTREE_HITTEST_ONITEMLABEL ) {
- // popup menu only if an item was clicked
- wxASSERT( lId != 0 );
+ // select the item first
SelectItem(lId);
- PopupMenu(m_pMenuPopup, event.GetX(), event.GetY());
}
+ //else: take the currently selected item if click not on item
+
+ PopupMenu(m_pMenuPopup, event.GetX(), event.GetY());
}
return;
}
}
-
+
wxLogError("Creation of test keys failed.");
}
void RegTreeCtrl::OnChar(wxKeyEvent& event)
{
- if ( event.KeyCode() == WXK_DELETE )
- DeleteSelected();
- else
- wxTreeCtrl::OnChar(event);
+ switch ( event.KeyCode() )
+ {
+ case WXK_DELETE:
+ DeleteSelected();
+ return;
+
+ case WXK_RETURN:
+ if ( event.AltDown() )
+ {
+ ShowProperties();
+
+ return;
+ }
+ }
+
+ event.Skip();
}
void RegTreeCtrl::OnSelChanged(wxTreeEvent& event)
void RegTreeCtrl::OnItemExpanding(wxTreeEvent& event)
{
TreeNode *pNode = GetNode(event);
- bool bExpanding = event.m_code == wxTREE_EXPAND_EXPAND;
+ 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 ) {
// collapsing: clean up
pNode->OnCollapse();
}
+ }
+}
+
+void RegTreeCtrl::OnBeginEdit(wxTreeEvent& event)
+{
+ TreeNode *pNode = GetNode(event);
+ if ( pNode->IsRoot() || pNode->Parent()->IsRoot() ) {
+ wxLogStatus(_T("This registry key can't be renamed."));
- // change icon for non root key
- if ( !pNode->IsRoot() ) {
- int idIcon = bExpanding ? RegImageList::OpenedKey
- : RegImageList::ClosedKey;
- SetItemImage(pNode->Id(), idIcon, idIcon);
+ event.Veto();
+ }
+ else {
+ m_nameOld = pNode->m_strName;
+ }
+}
+
+void RegTreeCtrl::OnEndEdit(wxTreeEvent& event)
+{
+ bool ok;
+
+ wxString name = event.GetLabel();
+
+ TreeNode *pNode = GetNode(event);
+ if ( pNode->IsKey() )
+ {
+ wxRegKey& key = pNode->Key();
+ ok = key.Rename(name);
+ }
+ else
+ {
+ pNode = pNode->Parent();
+ wxRegKey& key = pNode->Key();
+
+ ok = key.RenameValue(m_nameOld, name);
+ }
+
+ if ( !ok ) {
+ wxLogError(_T("Failed to rename '%s' to '%s'."),
+ m_nameOld.c_str(), name.c_str());
+ }
+#if 0 // MSW tree ctrl doesn't like this at all, it hangs
+ else {
+ pNode->Refresh();
+ }
+#endif // 0
+}
+
+void RegTreeCtrl::OnBeginDrag(wxTreeEvent& event)
+{
+ m_copyOnDrop = event.GetEventType() == wxEVT_COMMAND_TREE_BEGIN_DRAG;
+
+ TreeNode *pNode = GetNode(event);
+ if ( pNode->IsRoot() || pNode->Parent()->IsRoot() )
+ {
+ wxLogStatus("This registry key can't be %s.",
+ m_copyOnDrop ? "copied" : "moved");
+ }
+ else
+ {
+ wxLogStatus("%s item %s...",
+ m_copyOnDrop ? "Copying" : "Moving",
+ pNode->FullName());
+
+ m_draggedItem = pNode;
+
+ event.Allow();
+ }
+}
+
+void RegTreeCtrl::OnEndDrag(wxTreeEvent& event)
+{
+ wxCHECK_RET( m_draggedItem, "end drag without begin drag?" );
+
+ // clear the pointer anyhow
+ TreeNode *src = m_draggedItem;
+ m_draggedItem = NULL;
+
+ // where are we going to drop it?
+ TreeNode *dst = GetNode(event);
+ if ( dst && !dst->IsKey() ) {
+ // we need a parent key
+ dst = dst->Parent();
+ }
+ if ( !dst || dst->IsRoot() ) {
+ wxLogError("Can't create a key here.");
+
+ return;
+ }
+
+ bool isKey = src->IsKey();
+ if ( (isKey && (src == dst)) ||
+ (!isKey && (dst->Parent() == src)) ) {
+ wxLogStatus("Can't copy something on itself");
+
+ return;
+ }
+
+ // remove the "Registry Root\\" from the full name
+ wxString nameSrc, nameDst;
+ nameSrc << wxString(src->FullName()).AfterFirst('\\');
+ nameDst << wxString(dst->FullName()).AfterFirst('\\') << '\\'
+ << wxString(src->FullName()).AfterLast('\\');
+
+ wxString verb = m_copyOnDrop ? "copy" : "move";
+ wxString what = isKey ? "key" : "value";
+
+ if ( wxMessageBox(wxString::Format
+ (
+ "Do you really want to %s the %s %s to %s?",
+ verb.c_str(),
+ what.c_str(),
+ nameSrc.c_str(),
+ nameDst.c_str()
+ ),
+ "RegTest Confirm",
+ wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
+ return;
+ }
+
+ bool ok;
+ if ( isKey ) {
+ wxRegKey& key = src->Key();
+ wxRegKey keyDst(dst->Key(), src->m_strName);
+ ok = keyDst.Create(FALSE);
+ if ( !ok ) {
+ wxLogError("Key '%s' already exists");
+ }
+ else {
+ ok = key.Copy(keyDst);
+ }
+
+ if ( ok && !m_copyOnDrop ) {
+ // delete the old key
+ ok = key.DeleteSelf();
+ if ( ok ) {
+ src->Parent()->Refresh();
+ }
+ }
+ }
+ else { // value
+ wxRegKey& key = src->Parent()->Key();
+ ok = key.CopyValue(src->m_strName, dst->Key());
+ if ( ok && !m_copyOnDrop ) {
+ // we moved it, so delete the old one
+ ok = key.DeleteValue(src->m_strName);
+ }
}
- }
- wxLogStatus("Ok");
- wxSetCursor(*wxSTANDARD_CURSOR);
+ if ( !ok ) {
+ wxLogError("Failed to %s registry %s.", verb.c_str(), what.c_str());
+ }
+ else {
+ dst->Refresh();
+ }
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
bool RegTreeCtrl::TreeNode::OnExpand()
{
- // remove dummy item
- if ( m_lDummy != 0 ) {
- m_pTree->DeleteItem(m_lDummy);
- m_lDummy = 0;
- }
- else {
+ // 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;
+ return TRUE;
}
if ( Parent()->IsRoot() ) {
if ( !m_pKey->Open() ) {
wxLogError("The key '%s' can't be opened.", FullName());
- return false;
+ return FALSE;
}
+ // if we're empty, we shouldn't be expandable at all
+ bool isEmpty = TRUE;
+
// enumeration variables
long l;
wxString str;
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
case wxRegKey::Type_Dword:
{
- char szBuf[128];
long l;
m_pKey->QueryValue(str, &l);
- sprintf(szBuf, "%lx", l);
- strItem += szBuf;
+ strItem << l;
}
// fall through
m_pTree->InsertNewTreeNode(this, str, icon, &strItem);
bCont = m_pKey->GetNextValue(str, l);
+
+ // 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);
+
+ // we won't be expanded any more
+ m_pTree->SetItemHasChildren(theId, FALSE);
}
- return true;
+ return TRUE;
}
void RegTreeCtrl::TreeNode::OnCollapse()
{
- bool bHasChildren = !m_aChildren.IsEmpty();
DestroyChildren();
- if ( bHasChildren )
- AddDummy();
- else
- m_lDummy = 0;
delete m_pKey;
m_pKey = NULL;
}
-void RegTreeCtrl::TreeNode::AddDummy()
+void RegTreeCtrl::TreeNode::Refresh()
+{
+ if ( !IsKey() )
+ return;
+
+ wxTreeItemId theId(Id()); // Temp variable seems necessary for BC++
+ bool wasExpanded = m_pTree->IsExpanded(theId);
+ if ( wasExpanded )
+ m_pTree->Collapse(theId);
+
+ OnCollapse();
+ m_pTree->SetItemHasChildren(theId);
+ if ( wasExpanded ) {
+ m_pTree->Expand(theId);
+ OnExpand();
+ }
+}
+
+bool RegTreeCtrl::TreeNode::DeleteChild(TreeNode *child)
{
- // insert dummy item forcing appearance of [+] button
- m_lDummy = m_pTree->InsertItem(Id(), "");
+ int index = m_aChildren.Index(child);
+ wxCHECK_MSG( index != wxNOT_FOUND, FALSE,
+ "our child in tree should be in m_aChildren" );
+
+ m_aChildren.RemoveAt((size_t)index);
+
+ bool ok;
+ if ( child->IsKey() ) {
+ // must close key before deleting it
+ child->OnCollapse();
+
+ ok = Key().DeleteKey(child->m_strName);
+ }
+ else {
+ ok = Key().DeleteValue(child->m_strName);
+ }
+
+ if ( ok ) {
+ wxTreeItemId theId(child->Id()); // Temp variable seems necessary for BC++
+ m_pTree->Delete(theId);
+
+ Refresh();
+ }
+
+ return ok;
}
void RegTreeCtrl::TreeNode::DestroyChildren()
{
// destroy all children
- uint nCount = m_aChildren.Count();
- for ( uint n = 0; n < nCount; n++ ) {
+ size_t nCount = m_aChildren.GetCount();
+ for ( size_t n = 0; n < nCount; n++ ) {
long lId = m_aChildren[n]->Id();
- delete m_aChildren[n];
- m_pTree->DeleteItem(lId);
+ // 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()
{
- DestroyChildren();
-
delete m_pKey;
}
return "Registry Root";
}
else {
- // our own registry key might not (yet) exist or we might be a value,
+ // our own registry key might not (yet) exist or we might be a value,
// so just use the parent's and concatenate
s_strName = Parent()->FullName();
s_strName << '\\' << m_strName;
// operations on RegTreeCtrl
// ----------------------------------------------------------------------------
+void RegTreeCtrl::GoTo(const wxString& location)
+{
+ wxStringTokenizer tk(location, _T("\\"));
+
+ wxTreeItemId id = GetRootItem();
+
+ while ( tk.HasMoreTokens() ) {
+ wxString subkey = tk.GetNextToken();
+
+ wxTreeItemId idCurrent = id;
+ if ( !IsExpanded(idCurrent) )
+ Expand(idCurrent);
+
+ long dummy;
+ id = GetFirstChild(idCurrent, dummy);
+
+ if ( idCurrent == GetRootItem() ) {
+ // special case: we understand both HKCU and HKEY_CURRENT_USER here
+ for ( size_t key = 0; key < wxRegKey::nStdKeys; key++ ) {
+ if ( subkey == wxRegKey::GetStdKeyName(key) ||
+ subkey == wxRegKey::GetStdKeyShortName(key) ) {
+ break;
+ }
+
+ id = GetNextChild(idCurrent, dummy);
+ }
+ }
+ else {
+ // enum all children
+ while ( id.IsOk() ) {
+ if ( subkey == ((TreeNode *)GetItemData(id))->m_strName )
+ break;
+
+ id = GetNextChild(idCurrent, dummy);
+ }
+ }
+
+ if ( !id.IsOk() ) {
+ wxLogError(_T("No such key '%s'."), location.c_str());
+
+ return;
+ }
+ }
+
+ if ( id.IsOk() )
+ SelectItem(id);
+}
+
void RegTreeCtrl::DeleteSelected()
{
long lCurrent = GetSelection(),
return;
}
- if ( pCurrent->IsKey() ) {
- if ( wxMessageBox("Do you really want to delete this key?",
- "Confirmation",
- wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
- return;
- }
-
- // must close key before deleting it
- pCurrent->OnCollapse();
-
- if ( pParent->Key().DeleteKey(pCurrent->m_strName) )
- pParent->Refresh();
+ wxString what = pCurrent->IsKey() ? "key" : "value";
+ if ( wxMessageBox(wxString::Format
+ (
+ "Do you really want to delete this %s?",
+ what.c_str()
+ ),
+ "Confirmation",
+ wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
+ return;
}
- else {
- if ( wxMessageBox("Do you really want to delete this value?",
- "Confirmation",
- wxICON_QUESTION | wxYES_NO | wxCANCEL, this) != wxYES ) {
- return;
- }
- if ( pParent->Key().DeleteValue(pCurrent->m_strName) )
- pParent->Refresh();
- }
+ pParent->DeleteChild(pCurrent);
}
void RegTreeCtrl::CreateNewKey(const wxString& strName)
TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
wxCHECK_RET( pCurrent != NULL, "node without data?" );
-
+
wxASSERT( pCurrent->IsKey() ); // check must have been done before
if ( pCurrent->IsRoot() ) {
TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
wxCHECK_RET( pCurrent != NULL, "node without data?" );
-
+
wxASSERT( pCurrent->IsKey() ); // check must have been done before
if ( pCurrent->IsRoot() ) {
TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
wxCHECK_RET( pCurrent != NULL, "node without data?" );
-
+
wxASSERT( pCurrent->IsKey() ); // check must have been done before
if ( pCurrent->IsRoot() ) {
pCurrent->Refresh();
}
+void RegTreeCtrl::ShowProperties()
+{
+ long lCurrent = GetSelection();
+ TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
+
+ if ( !pCurrent || pCurrent->IsRoot() )
+ {
+ wxLogStatus("No properties");
+
+ return;
+ }
+
+ if ( pCurrent->IsKey() )
+ {
+ const wxRegKey& key = pCurrent->Key();
+ size_t nSubKeys, nValues;
+ if ( !key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
+ {
+ wxLogError("Couldn't get key info");
+ }
+ else
+ {
+ wxLogMessage("Key '%s' has %u subkeys and %u values.",
+ key.GetName().c_str(), nSubKeys, nValues);
+ }
+ }
+ else // it's a value
+ {
+ TreeNode *parent = pCurrent->Parent();
+ wxCHECK_RET( parent, "reg value without 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");
+
+ }
+}
+
bool RegTreeCtrl::IsKeySelected() const
{
long lCurrent = GetSelection();
TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
- wxCHECK( pCurrent != NULL, false );
+ wxCHECK( pCurrent != NULL, FALSE );
return pCurrent->IsKey();
-}
\ No newline at end of file
+}
+
+void RegTreeCtrl::Refresh()
+{
+ long lId = GetSelection();
+ if ( !lId )
+ return;
+
+ TreeNode *pNode = (TreeNode *)GetItemData(lId);
+
+ wxCHECK_RET( pNode != NULL, "tree item without data?" );
+
+ pNode->Refresh();
+}
+
projects / wxWidgets.git / blobdiff