#include "wx/msw/registry.h"
#include "wx/msw/imaglist.h"
+#include "wx/tokenzr.h"
+
// ----------------------------------------------------------------------------
// application type
// ----------------------------------------------------------------------------
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 OnMenuTest();
// operations
+ void GoTo(const wxString& location);
+ void Refresh();
void DeleteSelected();
void ShowProperties();
void CreateNewKey(const wxString& strName);
void Refresh();
bool DeleteChild(TreeNode *child);
void DestroyChildren();
- const char *FullName() const;
+ const wxChar *FullName() const;
// get the associated key: make sure the pointer is !NULL
wxRegKey& Key() { if ( !m_pKey ) OnExpand(); return *m_pKey; }
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()); }
void AddStdKeys();
private:
- DECLARE_EVENT_TABLE();
+ DECLARE_EVENT_TABLE()
};
// ----------------------------------------------------------------------------
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 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,
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_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)
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;
// create the status line
// ----------------------
- int aWidths[2];
- aWidths[0] = 200;
- aWidths[1] = -1;
CreateStatusBar(2);
- SetStatusWidths(2, aWidths);
}
RegFrame::~RegFrame()
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& event)
+void RegFrame::OnInfo(wxCommandEvent& WXUNUSED(event))
{
m_treeCtrl->ShowProperties();
}
pNewNode->IsKey() ? strName : *pstrValue,
idImage);
- wxASSERT_MSG( pNewNode->m_id, "can't create tree control item!");
+ wxASSERT_MSG( pNewNode->m_id, wxT("can't create tree control item!"));
// save the pointer in the item
SetItemData(pNewNode->m_id, pNewNode);
RegTreeCtrl::RegTreeCtrl(wxWindow *parent, wxWindowID id)
: wxTreeCtrl(parent, id, wxDefaultPosition, wxDefaultSize,
- wxTR_HAS_BUTTONS | wxSUNKEN_BORDER)
+ wxTR_HAS_BUTTONS | wxTR_EDIT_LABELS | wxSUNKEN_BORDER)
{
// init members
m_draggedItem = NULL;
{
if ( m_restoreStatus ) {
// restore it after OnItemExpanding()
- wxLogStatus("Ok");
+ wxLogStatus(wxT("Ok"));
wxSetCursor(*wxSTANDARD_CURSOR);
m_restoreStatus = FALSE;
{
int iFlags;
long lId = HitTest(wxPoint(event.GetX(), event.GetY()), iFlags);
- if ( !(iFlags & wxTREE_HITTEST_ONITEMLABEL) ) {
- // take the currently selected item if click not on item
- lId = GetSelection();
- }
- else {
+ 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());
}
long lId = GetSelection();
TreeNode *pNode = (TreeNode *)GetItemData(lId);
- wxCHECK_RET( pNode != NULL, "tree item without data?" );
+ wxCHECK_RET( pNode != NULL, wxT("tree item without data?") );
if ( pNode->IsRoot() ) {
- wxLogError("Can't create a subkey under the root key.");
+ wxLogError(wxT("Can't create a subkey under the root key."));
return;
}
if ( !pNode->IsKey() ) {
- wxLogError("Can't create a subkey under a value!");
+ wxLogError(wxT("Can't create a subkey under a value!"));
return;
}
wxRegKey key2a(key1, "key2a"), key2b(key1, "key2b");
if ( key2a.Create() && key2b.Create() ) {
// put some values under the newly created keys
- key1.SetValue("first_term", "10");
- key1.SetValue("second_term", "7");
+ key1.SetValue(wxT("first_term"), "10");
+ key1.SetValue(wxT("second_term"), "7");
key2a = "this is the unnamed value";
- key2b.SetValue("sum", 17);
+ key2b.SetValue(wxT("sum"), 17);
// refresh tree
pNode->Refresh();
- wxLogStatus("Test keys successfully added.");
+ wxLogStatus(wxT("Test keys successfully added."));
return;
}
}
- wxLogError("Creation of test keys failed.");
+ wxLogError(wxT("Creation of test keys failed."));
}
void RegTreeCtrl::OnChar(wxKeyEvent& event)
// expansion might take some time
wxSetCursor(*wxHOURGLASS_CURSOR);
- wxLogStatus("Working...");
+ wxLogStatus(wxT("Working..."));
wxYield(); // to give the status line a chance to refresh itself
m_restoreStatus = TRUE; // some time later...
}
}
+void RegTreeCtrl::OnBeginEdit(wxTreeEvent& event)
+{
+ TreeNode *pNode = GetNode(event);
+ if ( pNode->IsRoot() || pNode->Parent()->IsRoot() ) {
+ wxLogStatus(_T("This registry key can't be renamed."));
+
+ event.Veto();
+ }
+ else {
+ m_nameOld = pNode->m_strName;
+ }
+}
+
+void RegTreeCtrl::OnEndEdit(wxTreeEvent& event)
+{
+ bool ok;
+
+ wxString name = event.GetLabel();
+
+ TreeNode *pNode = GetNode(event);
+ if ( pNode->IsKey() )
+ {
+ wxRegKey& key = pNode->Key();
+ ok = key.Rename(name);
+ }
+ else
+ {
+ 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");
+ wxLogStatus(wxT("This registry key can't be %s."),
+ m_copyOnDrop ? wxT("copied") : wxT("moved"));
}
else
{
- wxLogStatus("%s item %s...",
- m_copyOnDrop ? "Copying" : "Moving",
+ wxLogStatus(wxT("%s item %s..."),
+ m_copyOnDrop ? wxT("Copying") : wxT("Moving"),
pNode->FullName());
m_draggedItem = pNode;
void RegTreeCtrl::OnEndDrag(wxTreeEvent& event)
{
- wxCHECK_RET( m_draggedItem, "end drag without begin drag?" );
+ wxCHECK_RET( m_draggedItem, wxT("end drag without begin drag?") );
// clear the pointer anyhow
TreeNode *src = m_draggedItem;
dst = dst->Parent();
}
if ( !dst || dst->IsRoot() ) {
- wxLogError("Can't create a key here.");
+ wxLogError(wxT("Can't create a key here."));
return;
}
bool isKey = src->IsKey();
if ( (isKey && (src == dst)) ||
- (!isKey && (src->Parent() == dst)) ) {
- wxLogStatus("Can't copy something on itself");
+ (!isKey && (dst->Parent() == src)) ) {
+ wxLogStatus(wxT("Can't copy something on itself"));
return;
}
if ( wxMessageBox(wxString::Format
(
- "Do you really want to %s the %s %s to %s?",
+ wxT("Do you really want to %s the %s %s to %s?"),
verb.c_str(),
what.c_str(),
nameSrc.c_str(),
return;
}
- bool dstExpanded = IsExpanded(dst->Id());
-
bool ok;
if ( isKey ) {
wxRegKey& key = src->Key();
- ok = key.Copy(dst->Key());
- if ( ok && dstExpanded ) {
- dst->OnCollapse();
- dst->OnExpand();
+ wxRegKey keyDst(dst->Key(), src->m_strName);
+ ok = keyDst.Create(FALSE);
+ if ( !ok ) {
+ wxLogError(wxT("Key '%s' already exists"));
+ }
+ else {
+ ok = key.Copy(keyDst);
}
if ( ok && !m_copyOnDrop ) {
wxRegKey& key = src->Parent()->Key();
ok = key.CopyValue(src->m_strName, dst->Key());
if ( ok && !m_copyOnDrop ) {
- // we move it, so delete the old one
+ // we moved it, so delete the old one
ok = key.DeleteValue(src->m_strName);
- if ( ok ) {
- // reexpand the key
- dst->Refresh();
- }
}
}
if ( !ok ) {
- wxLogError("Failed to %s registry %s.", verb.c_str(), what.c_str());
+ wxLogError(wxT("Failed to %s registry %s."),
+ verb.c_str(), what.c_str());
+ }
+ else {
+ dst->Refresh();
}
}
}
if ( !m_pKey->Open() ) {
- wxLogError("The key '%s' can't be opened.", FullName());
+ wxLogError(wxT("The key '%s' can't be opened."), FullName());
return FALSE;
}
if ( isEmpty ) {
// this is for the case when our last child was just deleted
- m_pTree->Collapse(Id());
+ wxTreeItemId theId(Id()); // Temp variable seems necessary for BC++
+ m_pTree->Collapse(theId);
// we won't be expanded any more
- m_pTree->SetItemHasChildren(Id(), FALSE);
+ m_pTree->SetItemHasChildren(theId, FALSE);
}
return TRUE;
void RegTreeCtrl::TreeNode::Refresh()
{
- if ( m_pTree->IsExpanded(Id()) )
- {
- m_pTree->Collapse(Id());
- m_pTree->SetItemHasChildren(Id());
- m_pTree->Expand(Id());
+ if ( !IsKey() )
+ return;
+
+ wxTreeItemId theId(Id()); // Temp variable seems necessary for BC++
+ bool wasExpanded = m_pTree->IsExpanded(theId);
+ if ( wasExpanded )
+ m_pTree->Collapse(theId);
+
+ OnCollapse();
+ m_pTree->SetItemHasChildren(theId);
+ if ( wasExpanded ) {
+ m_pTree->Expand(theId);
+ OnExpand();
}
}
{
int index = m_aChildren.Index(child);
wxCHECK_MSG( index != wxNOT_FOUND, FALSE,
- "our child in tree should be in m_aChildren" );
+ wxT("our child in tree should be in m_aChildren") );
m_aChildren.RemoveAt((size_t)index);
}
if ( ok ) {
- m_pTree->Delete(child->Id());
+ wxTreeItemId theId(child->Id()); // Temp variable seems necessary for BC++
+ m_pTree->Delete(theId);
Refresh();
}
long lId = m_aChildren[n]->Id();
// no, wxTreeCtrl will do it
//delete m_aChildren[n];
- m_pTree->Delete(lId);
+ wxTreeItemId theId(lId); // Temp variable seems necessary for BC++
+ m_pTree->Delete(theId);
}
m_aChildren.Empty();
delete m_pKey;
}
-const char *RegTreeCtrl::TreeNode::FullName() const
+const wxChar *RegTreeCtrl::TreeNode::FullName() const
{
static wxString s_strName;
if ( IsRoot() ) {
- return "Registry Root";
+ 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 << '\\' << m_strName;
+ s_strName << wxT('\\') << m_strName;
return s_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(),
lParent = GetParent(lCurrent);
if ( lParent == 0 ) {
- wxLogError("Can't delete root key.");
+ wxLogError(wxT("Can't delete root key."));
return;
}
TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent),
*pParent = (TreeNode *)GetItemData(lParent);
- wxCHECK_RET( pCurrent && pParent, "either node or parent without data?" );
+ wxCHECK_RET(pCurrent && pParent, wxT("either node or parent without data?"));
if ( pParent->IsRoot() ) {
- wxLogError("Can't delete standard key.");
+ wxLogError(wxT("Can't delete standard key."));
return;
}
wxString what = pCurrent->IsKey() ? "key" : "value";
if ( wxMessageBox(wxString::Format
(
- "Do you really want to delete this %s?",
+ wxT("Do you really want to delete this %s?"),
what.c_str()
),
"Confirmation",
long lCurrent = GetSelection();
TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
- wxCHECK_RET( pCurrent != NULL, "node without data?" );
+ wxCHECK_RET( pCurrent != NULL, wxT("node without data?") );
wxASSERT( pCurrent->IsKey() ); // check must have been done before
if ( pCurrent->IsRoot() ) {
- wxLogError("Can't create a new key under the root key.");
+ wxLogError(wxT("Can't create a new key under the root key."));
return;
}
long lCurrent = GetSelection();
TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
- wxCHECK_RET( pCurrent != NULL, "node without data?" );
+ wxCHECK_RET( pCurrent != NULL, wxT("node without data?") );
wxASSERT( pCurrent->IsKey() ); // check must have been done before
if ( pCurrent->IsRoot() ) {
- wxLogError("Can't create a new value under the root key.");
+ wxLogError(wxT("Can't create a new value under the root key."));
return;
}
long lCurrent = GetSelection();
TreeNode *pCurrent = (TreeNode *)GetItemData(lCurrent);
- wxCHECK_RET( pCurrent != NULL, "node without data?" );
+ wxCHECK_RET( pCurrent != NULL, wxT("node without data?") );
wxASSERT( pCurrent->IsKey() ); // check must have been done before
if ( pCurrent->IsRoot() ) {
- wxLogError("Can't create a new value under the root key.");
+ wxLogError(wxT("Can't create a new value under the root key."));
return;
}
if ( !pCurrent || pCurrent->IsRoot() )
{
- wxLogStatus("No properties");
+ wxLogStatus(wxT("No properties"));
return;
}
size_t nSubKeys, nValues;
if ( !key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
{
- wxLogError("Couldn't get key info");
+ wxLogError(wxT("Couldn't get key info"));
}
else
{
- wxLogMessage("Key '%s' has %u subkeys and %u values.",
+ wxLogMessage(wxT("Key '%s' has %u subkeys and %u values."),
key.GetName().c_str(), nSubKeys, nValues);
}
}
else // it's a value
{
TreeNode *parent = pCurrent->Parent();
- wxCHECK_RET( parent, "reg value without key?" );
+ wxCHECK_RET( parent, wxT("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).",
+ 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) ? "numeric" : "string");
+ key.IsNumericValue(value) ? wxT("numeric") : wxT("string"));
}
}
return pCurrent->IsKey();
}
+
+void RegTreeCtrl::Refresh()
+{
+ long lId = GetSelection();
+ if ( !lId )
+ return;
+
+ TreeNode *pNode = (TreeNode *)GetItemData(lId);
+
+ wxCHECK_RET( pNode != NULL, wxT("tree item without data?") );
+
+ pNode->Refresh();
+}
+
projects / wxWidgets.git / blobdiff