The-Homebrew-Cloud/dolphin
2
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-01-10 16:19:28 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5344 from lioncash/table

Browse Source 
MemoryWindow: Minor cleanup
This commit is contained in:
Mat M 2017-04-30 18:32:29 -04:00 committed by GitHub
commit 1bad3bef4b
2 changed files with 179 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

263
Source/Core/DolphinWX/Debugger/MemoryWindow.cpp
View File

@ -40,13 +40,13 @@
enum enum
{ {
IDM_MEM_ADDRBOX, IDM_ADDRESS_SEARCH_CTRL,
IDM_SYMBOLLIST, IDM_SYMBOL_LIST,
IDM_SETVALBUTTON, IDM_SET_VALUE_BUTTON,
IDM_DUMP_MEMORY, IDM_DUMP_MEMORY,
IDM_DUMP_MEM2, IDM_DUMP_MEM2,
IDM_DUMP_FAKEVMEM, IDM_DUMP_FAKEVMEM,
IDM_VALBOX, IDM_VALUE_TEXT_CTRL,
IDM_DATA_TYPE_RBOX, IDM_DATA_TYPE_RBOX,
IDM_FIND_NEXT, IDM_FIND_NEXT,
IDM_FIND_PREVIOUS, IDM_FIND_PREVIOUS,
@ -55,62 +55,32 @@ enum
IDM_MEMCHECK_OPTIONS_CHANGE IDM_MEMCHECK_OPTIONS_CHANGE
}; };
BEGIN_EVENT_TABLE(CMemoryWindow, wxPanel)
EVT_BUTTON(IDM_SETVALBUTTON, CMemoryWindow::SetMemoryValue)
EVT_BUTTON(IDM_DUMP_MEMORY, CMemoryWindow::OnDumpMemory)
EVT_BUTTON(IDM_DUMP_MEM2, CMemoryWindow::OnDumpMem2)
EVT_BUTTON(IDM_DUMP_FAKEVMEM, CMemoryWindow::OnDumpFakeVMEM)
EVT_RADIOBOX(IDM_DATA_TYPE_RBOX, CMemoryWindow::OnDataTypeChanged)
EVT_BUTTON(IDM_FIND_NEXT, CMemoryWindow::OnFindNext)
EVT_BUTTON(IDM_FIND_PREVIOUS, CMemoryWindow::OnFindPrevious)
EVT_RADIOBUTTON(IDM_MEMCHECK_OPTIONS_CHANGE, CMemoryWindow::OnMemCheckOptionChange)
EVT_CHECKBOX(IDM_MEMCHECK_OPTIONS_CHANGE, CMemoryWindow::OnMemCheckOptionChange)
END_EVENT_TABLE()
CMemoryWindow::CMemoryWindow(wxWindow* parent, wxWindowID id, const wxPoint& pos, CMemoryWindow::CMemoryWindow(wxWindow* parent, wxWindowID id, const wxPoint& pos,
const wxSize& size, long style, const wxString& name) const wxSize& size, long style, const wxString& name)
: wxPanel(parent, id, pos, size, style, name) : wxPanel(parent, id, pos, size, style, name)
{ {
DebugInterface* di = &PowerPC::debug_interface; CreateGUI();
}
memview = new CMemoryView(di, this); void CMemoryWindow::CreateGUI()
memview->Bind(DOLPHIN_EVT_MEMORY_VIEW_DATA_TYPE_CHANGED, &CMemoryWindow::OnDataTypeChanged, this); {
m_memory_view = new CMemoryView(&PowerPC::debug_interface, this);
addrbox = new wxSearchCtrl(this, IDM_MEM_ADDRBOX); m_memory_view->Bind(DOLPHIN_EVT_MEMORY_VIEW_DATA_TYPE_CHANGED, &CMemoryWindow::OnDataTypeChanged,
addrbox->Bind(wxEVT_TEXT, &CMemoryWindow::OnAddrBoxChange, this); this);
addrbox->SetDescriptiveText(_("Search Address"));
valbox =
new wxTextCtrl(this, IDM_VALBOX, "", wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER);
valbox->Bind(wxEVT_TEXT_ENTER, &CMemoryWindow::SetMemoryValueFromValBox, this);
valbox->Bind(wxEVT_TEXT, &CMemoryWindow::OnValueChanged, this);
const int space3 = FromDIP(3); const int space3 = FromDIP(3);
const int space5 = FromDIP(5);
wxBoxSizer* const search_sizer = new wxBoxSizer(wxVERTICAL); wxBoxSizer* const main_sizer = new wxBoxSizer(wxHORIZONTAL);
search_sizer->Add(addrbox, 0, wxEXPAND); main_sizer->Add(m_memory_view, 20, wxEXPAND);
search_sizer->Add(valbox, 0, wxEXPAND); main_sizer->AddSpacer(space3);
search_sizer->Add(new wxButton(this, IDM_SETVALBUTTON, _("Set Value"))); main_sizer->Add(CreateRightHandSideSizer(), 0, wxEXPAND | wxTOP | wxBOTTOM, space3);
main_sizer->AddSpacer(space3);
wxBoxSizer* const dump_sizer = new wxBoxSizer(wxVERTICAL); SetSizerAndFit(main_sizer);
dump_sizer->Add(new wxButton(this, IDM_DUMP_MEMORY, _("Dump MRAM")), 0, wxEXPAND); }
dump_sizer->Add(new wxButton(this, IDM_DUMP_MEM2, _("Dump EXRAM")), 0, wxEXPAND);
if (!SConfig::GetInstance().bMMU)
dump_sizer->Add(new wxButton(this, IDM_DUMP_FAKEVMEM, _("Dump FakeVMEM")), 0, wxEXPAND);
wxStaticBoxSizer* const sizerSearchType = new wxStaticBoxSizer(wxVERTICAL, this, _("Search"));
sizerSearchType->Add(m_btn_find_next = new wxButton(this, IDM_FIND_NEXT, _("Find Next")));
sizerSearchType->Add(m_btn_find_previous =
new wxButton(this, IDM_FIND_PREVIOUS, _("Find Previous")));
sizerSearchType->Add(m_rb_ascii = new wxRadioButton(this, IDM_ASCII, "Ascii", wxDefaultPosition,
wxDefaultSize, wxRB_GROUP));
sizerSearchType->Add(m_rb_hex = new wxRadioButton(this, IDM_HEX, _("Hex")));
m_search_result_msg =
new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxST_NO_AUTORESIZE | wxALIGN_CENTER_HORIZONTAL);
sizerSearchType->Add(m_search_result_msg, 0, wxEXPAND);
wxSizer* CMemoryWindow::CreateRightHandSideSizer()
{
wxArrayString data_type_options; wxArrayString data_type_options;
data_type_options.Add("U8"); data_type_options.Add("U8");
data_type_options.Add("U16"); data_type_options.Add("U16");
@ -119,53 +89,132 @@ CMemoryWindow::CMemoryWindow(wxWindow* parent, wxWindowID id, const wxPoint& pos
data_type_options.Add("Float32"); data_type_options.Add("Float32");
m_rbox_data_type = new wxRadioBox(this, IDM_DATA_TYPE_RBOX, _("Data Type"), wxDefaultPosition, m_rbox_data_type = new wxRadioBox(this, IDM_DATA_TYPE_RBOX, _("Data Type"), wxDefaultPosition,
wxDefaultSize, data_type_options, 1); wxDefaultSize, data_type_options, 1);
m_rbox_data_type->Bind(wxEVT_RADIOBOX, &CMemoryWindow::OnDataTypeChanged, this);
m_rbox_data_type->SetSelection(static_cast<int>(m_memory_view->GetDataType()));
wxStaticBoxSizer* const memcheck_options_sizer = const int space5 = FromDIP(5);
new wxStaticBoxSizer(wxVERTICAL, this, "Memory breakpoint options");
memcheck_options_sizer->Add(rdbReadWrite = new wxRadioButton(this, IDM_MEMCHECK_OPTIONS_CHANGE,
"Read and Write", wxDefaultPosition,
wxDefaultSize, wxRB_GROUP));
memcheck_options_sizer->Add(
rdbRead = new wxRadioButton(this, IDM_MEMCHECK_OPTIONS_CHANGE, "Read only"));
memcheck_options_sizer->Add(
rdbWrite = new wxRadioButton(this, IDM_MEMCHECK_OPTIONS_CHANGE, "Write only"));
memcheck_options_sizer->Add(chkLog = new wxCheckBox(this, IDM_MEMCHECK_OPTIONS_CHANGE, "Log"));
wxBoxSizer* const sizerRight = new wxBoxSizer(wxVERTICAL); auto* const right_sizer = new wxBoxSizer(wxVERTICAL);
sizerRight->Add(search_sizer); right_sizer->Add(CreateSearchSizer(), 0, wxEXPAND);
sizerRight->AddSpacer(space5); right_sizer->AddSpacer(space5);
sizerRight->Add(dump_sizer, 0, wxEXPAND); right_sizer->Add(CreateDumpSizer(), 0, wxEXPAND);
sizerRight->Add(sizerSearchType, 0, wxEXPAND); right_sizer->Add(CreateSearchTypeSizer(), 0, wxEXPAND);
sizerRight->Add(m_rbox_data_type, 0, wxEXPAND); right_sizer->Add(m_rbox_data_type, 0, wxEXPAND);
sizerRight->Add(memcheck_options_sizer, 0, wxEXPAND); right_sizer->Add(CreateMemcheckOptionSizer(), 0, wxEXPAND);
wxBoxSizer* const sizerBig = new wxBoxSizer(wxHORIZONTAL); return right_sizer;
sizerBig->Add(memview, 20, wxEXPAND);
sizerBig->AddSpacer(space3);
sizerBig->Add(sizerRight, 0, wxEXPAND | wxTOP | wxBOTTOM, space3);
sizerBig->AddSpacer(space3);
SetSizer(sizerBig);
m_rb_hex->SetValue(true); // Set defaults
chkLog->SetValue(true);
m_rbox_data_type->SetSelection(static_cast<int>(memview->GetDataType()));
sizerRight->Fit(this);
sizerBig->Fit(this);
} }
void CMemoryWindow::JumpToAddress(u32 _Address) wxSizer* CMemoryWindow::CreateSearchSizer()
{ {
memview->Center(_Address); m_address_search_ctrl = new wxSearchCtrl(this, IDM_ADDRESS_SEARCH_CTRL);
m_address_search_ctrl->Bind(wxEVT_TEXT, &CMemoryWindow::OnSearchAddressChanged, this);
m_address_search_ctrl->SetDescriptiveText(_("Search Address"));
m_value_text_ctrl = new wxTextCtrl(this, IDM_VALUE_TEXT_CTRL, "", wxDefaultPosition,
wxDefaultSize, wxTE_PROCESS_ENTER);
m_value_text_ctrl->Bind(wxEVT_TEXT_ENTER, &CMemoryWindow::OnSetMemoryValueFromValBox, this);
m_value_text_ctrl->Bind(wxEVT_TEXT, &CMemoryWindow::OnValueChanged, this);
auto* const set_value_button = new wxButton(this, IDM_SET_VALUE_BUTTON, _("Set Value"));
set_value_button->Bind(wxEVT_BUTTON, &CMemoryWindow::OnSetMemoryValue, this);
auto* const search_sizer = new wxBoxSizer(wxVERTICAL);
search_sizer->Add(m_address_search_ctrl, 0, wxEXPAND);
search_sizer->Add(m_value_text_ctrl, 0, wxEXPAND);
search_sizer->Add(set_value_button);
return search_sizer;
} }
void CMemoryWindow::SetMemoryValueFromValBox(wxCommandEvent& event) wxSizer* CMemoryWindow::CreateDumpSizer()
{ {
SetMemoryValue(event); auto* const dump_mram_button = new wxButton(this, IDM_DUMP_MEMORY, _("Dump MRAM"));
valbox->SetFocus(); dump_mram_button->Bind(wxEVT_BUTTON, &CMemoryWindow::OnDumpMemory, this);
auto* const dump_exram_button = new wxButton(this, IDM_DUMP_MEM2, _("Dump EXRAM"));
dump_exram_button->Bind(wxEVT_BUTTON, &CMemoryWindow::OnDumpMem2, this);
auto* const dump_sizer = new wxBoxSizer(wxVERTICAL);
dump_sizer->Add(dump_mram_button, 0, wxEXPAND);
dump_sizer->Add(dump_exram_button, 0, wxEXPAND);
if (!SConfig::GetInstance().bMMU)
{
auto* const dump_fake_vmem_button = new wxButton(this, IDM_DUMP_FAKEVMEM, _("Dump FakeVMEM"));
dump_fake_vmem_button->Bind(wxEVT_BUTTON, &CMemoryWindow::OnDumpFakeVMEM, this);
dump_sizer->Add(dump_fake_vmem_button, 0, wxEXPAND);
}
return dump_sizer;
} }
void CMemoryWindow::SetMemoryValue(wxCommandEvent& event) wxSizer* CMemoryWindow::CreateSearchTypeSizer()
{
m_btn_find_next = new wxButton(this, IDM_FIND_NEXT, _("Find Next"));
m_btn_find_next->Bind(wxEVT_BUTTON, &CMemoryWindow::OnFindNext, this);
m_btn_find_previous = new wxButton(this, IDM_FIND_PREVIOUS, _("Find Previous"));
m_btn_find_previous->Bind(wxEVT_BUTTON, &CMemoryWindow::OnFindPrevious, this);
m_rb_ascii =
new wxRadioButton(this, IDM_ASCII, "Ascii", wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
m_rb_hex = new wxRadioButton(this, IDM_HEX, _("Hex"));
m_rb_hex->SetValue(true);
m_search_result_msg =
new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxST_NO_AUTORESIZE | wxALIGN_CENTER_HORIZONTAL);
auto* const search_type_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Search"));
search_type_sizer->Add(m_btn_find_next);
search_type_sizer->Add(m_btn_find_previous);
search_type_sizer->Add(m_rb_ascii);
search_type_sizer->Add(m_rb_hex);
search_type_sizer->Add(m_search_result_msg, 0, wxEXPAND);
return search_type_sizer;
}
wxSizer* CMemoryWindow::CreateMemcheckOptionSizer()
{
m_read_write_radio_btn = new wxRadioButton(this, IDM_MEMCHECK_OPTIONS_CHANGE, _("Read and Write"),
wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
m_read_write_radio_btn->Bind(wxEVT_RADIOBUTTON, &CMemoryWindow::OnMemCheckOptionChange, this);
m_read_radio_btn = new wxRadioButton(this, IDM_MEMCHECK_OPTIONS_CHANGE, _("Read only"));
m_read_radio_btn->Bind(wxEVT_RADIOBUTTON, &CMemoryWindow::OnMemCheckOptionChange, this);
m_write_radio_btn = new wxRadioButton(this, IDM_MEMCHECK_OPTIONS_CHANGE, _("Write only"));
m_write_radio_btn->Bind(wxEVT_RADIOBUTTON, &CMemoryWindow::OnMemCheckOptionChange, this);
m_log_checkbox = new wxCheckBox(this, IDM_MEMCHECK_OPTIONS_CHANGE, _("Log"));
m_log_checkbox->Bind(wxEVT_CHECKBOX, &CMemoryWindow::OnMemCheckOptionChange, this);
m_log_checkbox->SetValue(true);
auto* const memcheck_options_sizer =
new wxStaticBoxSizer(wxVERTICAL, this, _("Memory breakpoint options"));
memcheck_options_sizer->Add(m_read_write_radio_btn);
memcheck_options_sizer->Add(m_read_radio_btn);
memcheck_options_sizer->Add(m_write_radio_btn);
memcheck_options_sizer->Add(m_log_checkbox);
return memcheck_options_sizer;
}
void CMemoryWindow::JumpToAddress(u32 address)
{
m_memory_view->Center(address);
}
void CMemoryWindow::OnSetMemoryValueFromValBox(wxCommandEvent& event)
{
OnSetMemoryValue(event);
m_value_text_ctrl->SetFocus();
}
void CMemoryWindow::OnSetMemoryValue(wxCommandEvent& event)
{ {
if (!Memory::IsInitialized()) if (!Memory::IsInitialized())
{ {
@ -173,35 +222,34 @@ void CMemoryWindow::SetMemoryValue(wxCommandEvent& event)
return; return;
} }
std::string str_addr = WxStrToStr(addrbox->GetValue()); std::string str_addr = WxStrToStr(m_address_search_ctrl->GetValue());
std::string str_val = WxStrToStr(valbox->GetValue());
u32 addr; u32 addr;
u32 val; if (!TryParse("0x" + str_addr, &addr))
if (!TryParse(std::string("0x") + str_addr, &addr))
{ {
WxUtils::ShowErrorDialog(wxString::Format(_("Invalid address: %s"), str_addr.c_str())); WxUtils::ShowErrorDialog(wxString::Format(_("Invalid address: %s"), str_addr.c_str()));
return; return;
} }
if (!TryParse(std::string("0x") + str_val, &val)) std::string str_val = WxStrToStr(m_value_text_ctrl->GetValue());
u32 val;
if (!TryParse("0x" + str_val, &val))
{ {
WxUtils::ShowErrorDialog(wxString::Format(_("Invalid value: %s"), str_val.c_str())); WxUtils::ShowErrorDialog(wxString::Format(_("Invalid value: %s"), str_val.c_str()));
return; return;
} }
PowerPC::HostWrite_U32(val, addr); PowerPC::HostWrite_U32(val, addr);
memview->Refresh(); m_memory_view->Refresh();
} }
void CMemoryWindow::OnAddrBoxChange(wxCommandEvent& event) void CMemoryWindow::OnSearchAddressChanged(wxCommandEvent& event)
{ {
wxString txt = addrbox->GetValue(); wxString txt = m_address_search_ctrl->GetValue();
if (txt.size()) if (txt.size())
{ {
u32 addr; u32 addr;
sscanf(WxStrToStr(txt).c_str(), "%08x", &addr); sscanf(WxStrToStr(txt).c_str(), "%08x", &addr);
memview->Center(addr & ~3); m_memory_view->Center(addr & ~3);
} }
event.Skip(); event.Skip();
@ -209,7 +257,7 @@ void CMemoryWindow::OnAddrBoxChange(wxCommandEvent& event)
void CMemoryWindow::Repopulate() void CMemoryWindow::Repopulate()
{ {
memview->Center(PC); m_memory_view->Center(PC);
} }
void CMemoryWindow::OnValueChanged(wxCommandEvent&) void CMemoryWindow::OnValueChanged(wxCommandEvent&)
@ -258,7 +306,7 @@ void CMemoryWindow::OnDataTypeChanged(wxCommandEvent& ev)
MemoryDataType::FloatingPoint}}; MemoryDataType::FloatingPoint}};
if (ev.GetId() == IDM_DATA_TYPE_RBOX) if (ev.GetId() == IDM_DATA_TYPE_RBOX)
{ {
memview->SetDataType(map.at(ev.GetSelection())); m_memory_view->SetDataType(map.at(ev.GetSelection()));
} }
else else
{ {
@ -288,7 +336,7 @@ void CMemoryWindow::Search(SearchType search_type)
u8* ram_ptr = nullptr; u8* ram_ptr = nullptr;
std::size_t ram_size = 0; std::size_t ram_size = 0;
// NOTE: We're assuming the base address is zero. // NOTE: We're assuming the base address is zero.
switch (memview->GetMemoryType()) switch (m_memory_view->GetMemoryType())
{ {
case 0: case 0:
default: default:
@ -316,7 +364,7 @@ void CMemoryWindow::Search(SearchType search_type)
} }
std::vector<u8> search_bytes; std::vector<u8> search_bytes;
wxString search_val = valbox->GetValue(); wxString search_val = m_value_text_ctrl->GetValue();
if (m_rb_hex->GetValue()) if (m_rb_hex->GetValue())
{ {
@ -363,7 +411,7 @@ void CMemoryWindow::Search(SearchType search_type)
// Search starting from specified address if there is one. // Search starting from specified address if there is one.
u32 addr = 0; // Base address u32 addr = 0; // Base address
{ {
wxString addr_val = addrbox->GetValue(); wxString addr_val = m_address_search_ctrl->GetValue();
addr_val.Trim(true).Trim(false); addr_val.Trim(true).Trim(false);
if (!addr_val.empty()) if (!addr_val.empty())
{ {
@ -408,7 +456,7 @@ void CMemoryWindow::Search(SearchType search_type)
m_search_result_msg->SetLabel(_("Match Found")); m_search_result_msg->SetLabel(_("Match Found"));
u32 offset = static_cast<u32>(ptr - ram_ptr); u32 offset = static_cast<u32>(ptr - ram_ptr);
// NOTE: SetValue() generates a synthetic wxEVT_TEXT // NOTE: SetValue() generates a synthetic wxEVT_TEXT
addrbox->SetValue(wxString::Format("%08x", offset)); m_address_search_ctrl->SetValue(wxString::Format("%08x", offset));
m_last_search_address = offset; m_last_search_address = offset;
m_continue_search = true; m_continue_search = true;
return; return;
@ -419,8 +467,13 @@ void CMemoryWindow::Search(SearchType search_type)
void CMemoryWindow::OnMemCheckOptionChange(wxCommandEvent& event) void CMemoryWindow::OnMemCheckOptionChange(wxCommandEvent& event)
{ {
if (rdbReadWrite->GetValue()) if (m_read_write_radio_btn->GetValue())
memview->SetMemCheckOptions(true, true, chkLog->GetValue()); {
m_memory_view->SetMemCheckOptions(true, true, m_log_checkbox->GetValue());
}
else else
memview->SetMemCheckOptions(rdbRead->GetValue(), rdbWrite->GetValue(), chkLog->GetValue()); {
m_memory_view->SetMemCheckOptions(m_read_radio_btn->GetValue(), m_write_radio_btn->GetValue(),
m_log_checkbox->GetValue());
}
} }

37
Source/Core/DolphinWX/Debugger/MemoryWindow.h
View File

@ -8,7 +8,6 @@
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
class CMemoryView; class CMemoryView;
class CCodeWindow;
class IniFile; class IniFile;
class wxButton; class wxButton;
class wxCheckBox; class wxCheckBox;
@ -23,13 +22,14 @@ class wxRadioButton;
class CMemoryWindow : public wxPanel class CMemoryWindow : public wxPanel
{ {
public: public:
CMemoryWindow(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, explicit CMemoryWindow(wxWindow* parent, wxWindowID id = wxID_ANY,
const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL | wxBORDER_NONE, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL | wxBORDER_NONE,
const wxString& name = _("Memory")); const wxString& name = _("Memory"));
void Repopulate(); void Repopulate();
void JumpToAddress(u32 _Address); void JumpToAddress(u32 address);
private: private:
enum class SearchType enum class SearchType
@ -38,15 +38,20 @@ private:
FindPrevious FindPrevious
}; };
DECLARE_EVENT_TABLE() void CreateGUI();
wxSizer* CreateRightHandSideSizer();
wxSizer* CreateSearchSizer();
wxSizer* CreateDumpSizer();
wxSizer* CreateSearchTypeSizer();
wxSizer* CreateMemcheckOptionSizer();
void OnDataTypeChanged(wxCommandEvent& event); void OnDataTypeChanged(wxCommandEvent& event);
void OnFindNext(wxCommandEvent& event); void OnFindNext(wxCommandEvent& event);
void OnFindPrevious(wxCommandEvent& event); void OnFindPrevious(wxCommandEvent& event);
void OnAddrBoxChange(wxCommandEvent& event); void OnSearchAddressChanged(wxCommandEvent& event);
void OnValueChanged(wxCommandEvent&); void OnValueChanged(wxCommandEvent&);
void SetMemoryValueFromValBox(wxCommandEvent& event); void OnSetMemoryValueFromValBox(wxCommandEvent& event);
void SetMemoryValue(wxCommandEvent& event); void OnSetMemoryValue(wxCommandEvent& event);
void OnDumpMemory(wxCommandEvent& event); void OnDumpMemory(wxCommandEvent& event);
void OnDumpMem2(wxCommandEvent& event); void OnDumpMem2(wxCommandEvent& event);
void OnDumpFakeVMEM(wxCommandEvent& event); void OnDumpFakeVMEM(wxCommandEvent& event);
@ -62,17 +67,15 @@ private:
wxRadioBox* m_rbox_data_type; wxRadioBox* m_rbox_data_type;
wxStaticText* m_search_result_msg; wxStaticText* m_search_result_msg;
wxCheckBox* chkLog; wxCheckBox* m_log_checkbox;
wxRadioButton* rdbRead; wxRadioButton* m_read_radio_btn;
wxRadioButton* rdbWrite; wxRadioButton* m_write_radio_btn;
wxRadioButton* rdbReadWrite; wxRadioButton* m_read_write_radio_btn;
CCodeWindow* m_code_window; CMemoryView* m_memory_view;
CMemoryView* memview; wxSearchCtrl* m_address_search_ctrl;
wxTextCtrl* m_value_text_ctrl;
wxSearchCtrl* addrbox;
wxTextCtrl* valbox;
u32 m_last_search_address = 0; u32 m_last_search_address = 0;
bool m_continue_search = false; bool m_continue_search = false;