ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1743 from Stevoisiak/variableNamingConsistency 

Globals.h: Variable naming consistency
This commit is contained in:
Pierre Bourdon 2015-01-04 22:45:30 +01:00
parent 192c69f595 6ad5e54970
commit 1b4b836731
14 changed files with 636 additions and 636 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/Core/DolphinWX/Debugger/CodeView.cpp
View File

@ -141,7 +141,7 @@ void CCodeView::ToggleBreakpoint(u32 address)
Refresh();
// Propagate back to the parent window to update the breakpoint list.
wxCommandEvent evt(wxEVT_HOST_COMMAND, IDM_UPDATEBREAKPOINTS);
wxCommandEvent evt(wxEVT_HOST_COMMAND, IDM_UPDATE_BREAKPOINTS);
GetEventHandler()->AddPendingEvent(evt);
}
@ -311,7 +311,7 @@ void CCodeView::OnPopupMenu(wxCommandEvent& event)
{
// Propagate back to the parent window and tell it
// to flip to the JIT tab for the current address.
wxCommandEvent jit_event(wxEVT_HOST_COMMAND, IDM_UPDATEJITPANE);
wxCommandEvent jit_event(wxEVT_HOST_COMMAND, IDM_UPDATE_JIT_PANE);
GetEventHandler()->AddPendingEvent(jit_event);
}
break;

148
Source/Core/DolphinWX/Debugger/CodeWindow.cpp
View File

@ -102,11 +102,11 @@ CCodeWindow::CCodeWindow(const SCoreStartupParameter& _LocalCoreStartupParameter
sizerBig->Fit(this);
// Menu
Bind(wxEVT_MENU, &CCodeWindow::OnCPUMode, this, IDM_INTERPRETER, IDM_JITSROFF);
Bind(wxEVT_MENU, &CCodeWindow::OnChangeFont, this, IDM_FONTPICKER);
Bind(wxEVT_MENU, &CCodeWindow::OnJitMenu, this, IDM_CLEARCODECACHE, IDM_SEARCHINSTRUCTION);
Bind(wxEVT_MENU, &CCodeWindow::OnSymbolsMenu, this, IDM_CLEARSYMBOLS, IDM_PATCHHLEFUNCTIONS);
Bind(wxEVT_MENU, &CCodeWindow::OnProfilerMenu, this, IDM_PROFILEBLOCKS, IDM_WRITEPROFILE);
Bind(wxEVT_MENU, &CCodeWindow::OnCPUMode, this, IDM_INTERPRETER, IDM_JIT_SR_OFF);
Bind(wxEVT_MENU, &CCodeWindow::OnChangeFont, this, IDM_FONT_PICKER);
Bind(wxEVT_MENU, &CCodeWindow::OnJitMenu, this, IDM_CLEAR_CODE_CACHE, IDM_SEARCH_INSTRUCTION);
Bind(wxEVT_MENU, &CCodeWindow::OnSymbolsMenu, this, IDM_CLEAR_SYMBOLS, IDM_PATCH_HLE_FUNCTIONS);
Bind(wxEVT_MENU, &CCodeWindow::OnProfilerMenu, this, IDM_PROFILE_BLOCKS, IDM_WRITE_PROFILE);
// Toolbar
Bind(wxEVT_MENU, &CCodeWindow::OnCodeStep, this, IDM_STEP, IDM_GOTOPC);
@ -133,24 +133,24 @@ void CCodeWindow::OnHostMessage(wxCommandEvent& event)
{
switch (event.GetId())
{
case IDM_NOTIFYMAPLOADED:
case IDM_NOTIFY_MAP_LOADED:
NotifyMapLoaded();
if (m_BreakpointWindow) m_BreakpointWindow->NotifyUpdate();
break;
case IDM_UPDATEDISASMDIALOG:
case IDM_UPDATE_DISASM_DIALOG:
Update();
if (codeview) codeview->Center(PC);
if (m_RegisterWindow) m_RegisterWindow->NotifyUpdate();
if (m_WatchWindow) m_WatchWindow->NotifyUpdate();
break;
case IDM_UPDATEBREAKPOINTS:
case IDM_UPDATE_BREAKPOINTS:
Update();
if (m_BreakpointWindow) m_BreakpointWindow->NotifyUpdate();
break;
case IDM_UPDATEJITPANE:
case IDM_UPDATE_JIT_PANE:
// Check if the JIT pane is in the AUI notebook. If not, add it and switch to it.
if (!m_JitWindow)
ToggleJitWindow(true);
@ -439,42 +439,42 @@ void CCodeWindow::CreateMenu(const SCoreStartupParameter& core_startup_parameter
interpreter->Check(core_startup_parameter.iCPUCore == SCoreStartupParameter::CORE_INTERPRETER);
pCoreMenu->AppendSeparator();
pCoreMenu->Append(IDM_JITNOBLOCKLINKING, _("&JIT Block Linking off"),
pCoreMenu->Append(IDM_JIT_NO_BLOCK_LINKING, _("&JIT Block Linking off"),
_("Provide safer execution by not linking the JIT blocks."),
wxITEM_CHECK);
pCoreMenu->Append(IDM_JITNOBLOCKCACHE, _("&Disable JIT Cache"),
pCoreMenu->Append(IDM_JIT_NO_BLOCK_CACHE, _("&Disable JIT Cache"),
_("Avoid any involuntary JIT cache clearing, this may prevent Zelda TP from crashing.\n[This option must be selected before a game is started.]"),
wxITEM_CHECK);
pCoreMenu->Append(IDM_CLEARCODECACHE, _("&Clear JIT cache"));
pCoreMenu->Append(IDM_CLEAR_CODE_CACHE, _("&Clear JIT cache"));
pCoreMenu->AppendSeparator();
pCoreMenu->Append(IDM_LOGINSTRUCTIONS, _("&Log JIT instruction coverage"));
pCoreMenu->Append(IDM_SEARCHINSTRUCTION, _("&Search for an op"));
pCoreMenu->Append(IDM_LOG_INSTRUCTIONS, _("&Log JIT instruction coverage"));
pCoreMenu->Append(IDM_SEARCH_INSTRUCTION, _("&Search for an op"));
pCoreMenu->AppendSeparator();
pCoreMenu->Append(IDM_JITOFF, _("&JIT off (JIT core)"),
pCoreMenu->Append(IDM_JIT_OFF, _("&JIT off (JIT core)"),
_("Turn off all JIT functions, but still use the JIT core from Jit.cpp"),
wxITEM_CHECK);
pCoreMenu->Append(IDM_JITLSOFF, _("&JIT LoadStore off"),
pCoreMenu->Append(IDM_JIT_LS_OFF, _("&JIT LoadStore off"),
wxEmptyString, wxITEM_CHECK);
pCoreMenu->Append(IDM_JITLSLBZXOFF, _(" &JIT LoadStore lbzx off"),
pCoreMenu->Append(IDM_JIT_LSLBZX_OFF, _(" &JIT LoadStore lbzx off"),
wxEmptyString, wxITEM_CHECK);
pCoreMenu->Append(IDM_JITLSLXZOFF, _(" &JIT LoadStore lXz off"),
pCoreMenu->Append(IDM_JIT_LSLXZ_OFF, _(" &JIT LoadStore lXz off"),
wxEmptyString, wxITEM_CHECK);
pCoreMenu->Append(IDM_JITLSLWZOFF, _("&JIT LoadStore lwz off"),
pCoreMenu->Append(IDM_JIT_LSLWZ_OFF, _("&JIT LoadStore lwz off"),
wxEmptyString, wxITEM_CHECK);
pCoreMenu->Append(IDM_JITLSFOFF, _("&JIT LoadStore Floating off"),
pCoreMenu->Append(IDM_JIT_LSF_OFF, _("&JIT LoadStore Floating off"),
wxEmptyString, wxITEM_CHECK);
pCoreMenu->Append(IDM_JITLSPOFF, _("&JIT LoadStore Paired off"),
pCoreMenu->Append(IDM_JIT_LSP_OFF, _("&JIT LoadStore Paired off"),
wxEmptyString, wxITEM_CHECK);
pCoreMenu->Append(IDM_JITFPOFF, _("&JIT FloatingPoint off"),
pCoreMenu->Append(IDM_JIT_FP_OFF, _("&JIT FloatingPoint off"),
wxEmptyString, wxITEM_CHECK);
pCoreMenu->Append(IDM_JITIOFF, _("&JIT Integer off"),
pCoreMenu->Append(IDM_JIT_I_OFF, _("&JIT Integer off"),
wxEmptyString, wxITEM_CHECK);
pCoreMenu->Append(IDM_JITPOFF, _("&JIT Paired off"),
pCoreMenu->Append(IDM_JIT_P_OFF, _("&JIT Paired off"),
wxEmptyString, wxITEM_CHECK);
pCoreMenu->Append(IDM_JITSROFF, _("&JIT SystemRegisters off"),
pCoreMenu->Append(IDM_JIT_SR_OFF, _("&JIT SystemRegisters off"),
wxEmptyString, wxITEM_CHECK);
pMenuBar->Append(pCoreMenu, _("&JIT"));
@ -511,12 +511,12 @@ void CCodeWindow::CreateMenu(const SCoreStartupParameter& core_startup_parameter
void CCodeWindow::CreateMenuOptions(wxMenu* pMenu)
{
wxMenuItem* boottopause = pMenu->Append(IDM_BOOTTOPAUSE, _("Boot to pause"),
wxMenuItem* boottopause = pMenu->Append(IDM_BOOT_TO_PAUSE, _("Boot to pause"),
_("Start the game directly instead of booting to pause"),
wxITEM_CHECK);
boottopause->Check(bBootToPause);
wxMenuItem* automaticstart = pMenu->Append(IDM_AUTOMATICSTART, _("&Automatic start"),
wxMenuItem* automaticstart = pMenu->Append(IDM_AUTOMATIC_START, _("&Automatic start"),
_(
"Automatically load the Default ISO when Dolphin starts, or the last game you loaded,"
" if you have not given it an elf file with the --elf command line. [This can be"
@ -526,7 +526,7 @@ void CCodeWindow::CreateMenuOptions(wxMenu* pMenu)
wxITEM_CHECK);
automaticstart->Check(bAutomaticStart);
pMenu->Append(IDM_FONTPICKER, _("&Font..."));
pMenu->Append(IDM_FONT_PICKER, _("&Font..."));
}
// CPU Mode and JIT Menu
@ -537,43 +537,43 @@ void CCodeWindow::OnCPUMode(wxCommandEvent& event)
case IDM_INTERPRETER:
PowerPC::SetMode(UseInterpreter() ? PowerPC::MODE_INTERPRETER : PowerPC::MODE_JIT);
break;
case IDM_BOOTTOPAUSE:
case IDM_BOOT_TO_PAUSE:
bBootToPause = !bBootToPause;
return;
case IDM_AUTOMATICSTART:
case IDM_AUTOMATIC_START:
bAutomaticStart = !bAutomaticStart;
return;
case IDM_JITOFF:
case IDM_JIT_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITOff = event.IsChecked();
break;
case IDM_JITLSOFF:
case IDM_JIT_LS_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITLoadStoreOff = event.IsChecked();
break;
case IDM_JITLSLXZOFF:
case IDM_JIT_LSLXZ_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITLoadStorelXzOff = event.IsChecked();
break;
case IDM_JITLSLWZOFF:
case IDM_JIT_LSLWZ_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITLoadStorelwzOff = event.IsChecked();
break;
case IDM_JITLSLBZXOFF:
case IDM_JIT_LSLBZX_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITLoadStorelbzxOff = event.IsChecked();
break;
case IDM_JITLSFOFF:
case IDM_JIT_LSF_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITLoadStoreFloatingOff = event.IsChecked();
break;
case IDM_JITLSPOFF:
case IDM_JIT_LSP_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITLoadStorePairedOff = event.IsChecked();
break;
case IDM_JITFPOFF:
case IDM_JIT_FP_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITFloatingPointOff = event.IsChecked();
break;
case IDM_JITIOFF:
case IDM_JIT_I_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITIntegerOff = event.IsChecked();
break;
case IDM_JITPOFF:
case IDM_JIT_P_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITPairedOff = event.IsChecked();
break;
case IDM_JITSROFF:
case IDM_JIT_SR_OFF:
SConfig::GetInstance().m_LocalCoreStartupParameter.bJITSystemRegistersOff = event.IsChecked();
break;
}
@ -589,15 +589,15 @@ void CCodeWindow::OnJitMenu(wxCommandEvent& event)
{
switch (event.GetId())
{
case IDM_LOGINSTRUCTIONS:
case IDM_LOG_INSTRUCTIONS:
PPCTables::LogCompiledInstructions();
break;
case IDM_CLEARCODECACHE:
case IDM_CLEAR_CODE_CACHE:
JitInterface::ClearCache();
break;
case IDM_SEARCHINSTRUCTION:
case IDM_SEARCH_INSTRUCTION:
{
wxString str = wxGetTextFromUser("", _("Op?"), wxEmptyString, this);
auto const wx_name = WxStrToStr(str);
@ -626,22 +626,22 @@ bool CCodeWindow::UseInterpreter()
bool CCodeWindow::BootToPause()
{
return GetMenuBar()->IsChecked(IDM_BOOTTOPAUSE);
return GetMenuBar()->IsChecked(IDM_BOOT_TO_PAUSE);
}
bool CCodeWindow::AutomaticStart()
{
return GetMenuBar()->IsChecked(IDM_AUTOMATICSTART);
return GetMenuBar()->IsChecked(IDM_AUTOMATIC_START);
}
bool CCodeWindow::JITNoBlockCache()
{
return GetMenuBar()->IsChecked(IDM_JITNOBLOCKCACHE);
return GetMenuBar()->IsChecked(IDM_JIT_NO_BLOCK_CACHE);
}
bool CCodeWindow::JITNoBlockLinking()
{
return GetMenuBar()->IsChecked(IDM_JITNOBLOCKLINKING);
return GetMenuBar()->IsChecked(IDM_JIT_NO_BLOCK_LINKING);
}
// Toolbar
@ -731,37 +731,37 @@ void CCodeWindow::UpdateButtonStates()
// ------------------
GetMenuBar()->Enable(IDM_INTERPRETER, Pause); // CPU Mode
GetMenuBar()->Enable(IDM_JITNOBLOCKCACHE, !Initialized);
GetMenuBar()->Enable(IDM_JIT_NO_BLOCK_CACHE, !Initialized);
GetMenuBar()->Enable(IDM_JITOFF, Pause);
GetMenuBar()->Enable(IDM_JITLSOFF, Pause);
GetMenuBar()->Enable(IDM_JITLSLXZOFF, Pause);
GetMenuBar()->Enable(IDM_JITLSLWZOFF, Pause);
GetMenuBar()->Enable(IDM_JITLSLBZXOFF, Pause);
GetMenuBar()->Enable(IDM_JITLSFOFF, Pause);
GetMenuBar()->Enable(IDM_JITLSPOFF, Pause);
GetMenuBar()->Enable(IDM_JITFPOFF, Pause);
GetMenuBar()->Enable(IDM_JITIOFF, Pause);
GetMenuBar()->Enable(IDM_JITPOFF, Pause);
GetMenuBar()->Enable(IDM_JITSROFF, Pause);
GetMenuBar()->Enable(IDM_JIT_OFF, Pause);
GetMenuBar()->Enable(IDM_JIT_LS_OFF, Pause);
GetMenuBar()->Enable(IDM_JIT_LSLXZ_OFF, Pause);
GetMenuBar()->Enable(IDM_JIT_LSLWZ_OFF, Pause);
GetMenuBar()->Enable(IDM_JIT_LSLBZX_OFF, Pause);
GetMenuBar()->Enable(IDM_JIT_LSF_OFF, Pause);
GetMenuBar()->Enable(IDM_JIT_LSP_OFF, Pause);
GetMenuBar()->Enable(IDM_JIT_FP_OFF, Pause);
GetMenuBar()->Enable(IDM_JIT_I_OFF, Pause);
GetMenuBar()->Enable(IDM_JIT_P_OFF, Pause);
GetMenuBar()->Enable(IDM_JIT_SR_OFF, Pause);
GetMenuBar()->Enable(IDM_CLEARCODECACHE, Pause); // JIT Menu
GetMenuBar()->Enable(IDM_SEARCHINSTRUCTION, Initialized);
GetMenuBar()->Enable(IDM_CLEAR_CODE_CACHE, Pause); // JIT Menu
GetMenuBar()->Enable(IDM_SEARCH_INSTRUCTION, Initialized);
GetMenuBar()->Enable(IDM_CLEARSYMBOLS, Initialized); // Symbols menu
GetMenuBar()->Enable(IDM_SCANFUNCTIONS, Initialized);
GetMenuBar()->Enable(IDM_LOADMAPFILE, Initialized);
GetMenuBar()->Enable(IDM_CLEAR_SYMBOLS, Initialized); // Symbols menu
GetMenuBar()->Enable(IDM_SCAN_FUNCTIONS, Initialized);
GetMenuBar()->Enable(IDM_LOAD_MAP_FILE, Initialized);
GetMenuBar()->Enable(IDM_SAVEMAPFILE, Initialized);
GetMenuBar()->Enable(IDM_LOADMAPFILEAS, Initialized);
GetMenuBar()->Enable(IDM_SAVEMAPFILEAS, Initialized);
GetMenuBar()->Enable(IDM_LOADBADMAPFILE, Initialized);
GetMenuBar()->Enable(IDM_SAVEMAPFILEWITHCODES, Initialized);
GetMenuBar()->Enable(IDM_CREATESIGNATUREFILE, Initialized);
GetMenuBar()->Enable(IDM_APPENDSIGNATUREFILE, Initialized);
GetMenuBar()->Enable(IDM_COMBINESIGNATUREFILES, Initialized);
GetMenuBar()->Enable(IDM_LOAD_MAP_FILE_AS, Initialized);
GetMenuBar()->Enable(IDM_SAVE_MAP_FILE_AS, Initialized);
GetMenuBar()->Enable(IDM_LOAD_BAD_MAP_FILE, Initialized);
GetMenuBar()->Enable(IDM_SAVE_MAP_FILE_WITH_CODES, Initialized);
GetMenuBar()->Enable(IDM_CREATE_SIGNATURE_FILE, Initialized);
GetMenuBar()->Enable(IDM_APPEND_SIGNATURE_FILE, Initialized);
GetMenuBar()->Enable(IDM_COMBINE_SIGNATURE_FILES, Initialized);
GetMenuBar()->Enable(IDM_RENAME_SYMBOLS, Initialized);
GetMenuBar()->Enable(IDM_USESIGNATUREFILE, Initialized);
GetMenuBar()->Enable(IDM_PATCHHLEFUNCTIONS, Initialized);
GetMenuBar()->Enable(IDM_USE_SIGNATURE_FILE, Initialized);
GetMenuBar()->Enable(IDM_PATCH_HLE_FUNCTIONS, Initialized);
// Update Fonts
callstack->SetFont(DebuggerFont);

6
Source/Core/DolphinWX/Debugger/CodeWindow.h
View File

@ -51,7 +51,7 @@ public:
CFrame *Parent;
wxMenuBar * GetMenuBar();
wxToolBar * GetToolBar();
wxBitmap m_Bitmaps[ToolbarDebugBitmapMax];
wxBitmap m_Bitmaps[Toolbar_Debug_Bitmap_Max];
bool UseInterpreter();
bool BootToPause();
@ -104,8 +104,8 @@ public:
// Settings
bool bAutomaticStart; bool bBootToPause;
bool bShowOnStart[IDM_VIDEOWINDOW - IDM_LOGWINDOW + 1];
int iNbAffiliation[IDM_CODEWINDOW - IDM_LOGWINDOW + 1];
bool bShowOnStart[IDM_VIDEO_WINDOW - IDM_LOG_WINDOW + 1];
int iNbAffiliation[IDM_CODE_WINDOW - IDM_LOG_WINDOW + 1];
private:
void OnSymbolListChange(wxCommandEvent& event);

154
Source/Core/DolphinWX/Debugger/CodeWindowFunctions.cpp
View File

@ -86,7 +86,7 @@ void CCodeWindow::Load()
};
// Decide what windows to show
for (int i = 0; i <= IDM_VIDEOWINDOW - IDM_LOGWINDOW; i++)
for (int i = 0; i <= IDM_VIDEO_WINDOW - IDM_LOG_WINDOW; i++)
ini.GetOrCreateSection("ShowOnStart")->Get(SettingName[i], &bShowOnStart[i], false);
// Get notebook affiliation
@ -94,11 +94,11 @@ void CCodeWindow::Load()
((Parent->ActivePerspective < Parent->Perspectives.size())
? Parent->Perspectives[Parent->ActivePerspective].Name : "Perspective 1");
for (int i = 0; i <= IDM_CODEWINDOW - IDM_LOGWINDOW; i++)
for (int i = 0; i <= IDM_CODE_WINDOW - IDM_LOG_WINDOW; i++)
ini.GetOrCreateSection(section)->Get(SettingName[i], &iNbAffiliation[i], 0);
// Get floating setting
for (int i = 0; i <= IDM_CODEWINDOW - IDM_LOGWINDOW; i++)
for (int i = 0; i <= IDM_CODE_WINDOW - IDM_LOG_WINDOW; i++)
ini.GetOrCreateSection("Float")->Get(SettingName[i], &Parent->bFloatWindow[i], false);
}
@ -109,8 +109,8 @@ void CCodeWindow::Save()
IniFile::Section* general = ini.GetOrCreateSection("General");
general->Set("DebuggerFont", WxStrToStr(DebuggerFont.GetNativeFontInfoUserDesc()));
general->Set("AutomaticStart", GetMenuBar()->IsChecked(IDM_AUTOMATICSTART));
general->Set("BootToPause", GetMenuBar()->IsChecked(IDM_BOOTTOPAUSE));
general->Set("AutomaticStart", GetMenuBar()->IsChecked(IDM_AUTOMATIC_START));
general->Set("BootToPause", GetMenuBar()->IsChecked(IDM_BOOT_TO_PAUSE));
const char* SettingName[] = {
"Log",
@ -126,17 +126,17 @@ void CCodeWindow::Save()
};
// Save windows settings
for (int i = IDM_LOGWINDOW; i <= IDM_VIDEOWINDOW; i++)
ini.GetOrCreateSection("ShowOnStart")->Set(SettingName[i - IDM_LOGWINDOW], GetMenuBar()->IsChecked(i));
for (int i = IDM_LOG_WINDOW; i <= IDM_VIDEO_WINDOW; i++)
ini.GetOrCreateSection("ShowOnStart")->Set(SettingName[i - IDM_LOG_WINDOW], GetMenuBar()->IsChecked(i));
// Save notebook affiliations
std::string section = "P - " + Parent->Perspectives[Parent->ActivePerspective].Name;
for (int i = 0; i <= IDM_CODEWINDOW - IDM_LOGWINDOW; i++)
for (int i = 0; i <= IDM_CODE_WINDOW - IDM_LOG_WINDOW; i++)
ini.GetOrCreateSection(section)->Set(SettingName[i], iNbAffiliation[i]);
// Save floating setting
for (int i = IDM_LOGWINDOW_PARENT; i <= IDM_CODEWINDOW_PARENT; i++)
ini.GetOrCreateSection("Float")->Set(SettingName[i - IDM_LOGWINDOW_PARENT], !!FindWindowById(i));
for (int i = IDM_LOG_WINDOW_PARENT; i <= IDM_CODE_WINDOW_PARENT; i++)
ini.GetOrCreateSection("Float")->Set(SettingName[i - IDM_LOG_WINDOW_PARENT], !!FindWindowById(i));
ini.Save(File::GetUserPath(F_DEBUGGERCONFIG_IDX));
}
@ -146,24 +146,24 @@ void CCodeWindow::Save()
void CCodeWindow::CreateMenuSymbols(wxMenuBar *pMenuBar)
{
wxMenu *pSymbolsMenu = new wxMenu;
pSymbolsMenu->Append(IDM_CLEARSYMBOLS, _("&Clear symbols"),
pSymbolsMenu->Append(IDM_CLEAR_SYMBOLS, _("&Clear symbols"),
_("Remove names from all functions and variables."));
pSymbolsMenu->Append(IDM_SCANFUNCTIONS, _("&Generate symbol map"),
pSymbolsMenu->Append(IDM_SCAN_FUNCTIONS, _("&Generate symbol map"),
_("Recognise standard functions from sys\\totaldb.dsy, and use generic zz_ names for other functions."));
pSymbolsMenu->AppendSeparator();
pSymbolsMenu->Append(IDM_LOADMAPFILE, _("&Load symbol map"),
pSymbolsMenu->Append(IDM_LOAD_MAP_FILE, _("&Load symbol map"),
_("Try to load this game's function names automatically - but doesn't check .map files stored on the disc image yet."));
pSymbolsMenu->Append(IDM_SAVEMAPFILE, _("&Save symbol map"),
_("Save the function names for each address to a .map file in your user settings map folder, named after the title id."));
pSymbolsMenu->AppendSeparator();
pSymbolsMenu->Append(IDM_LOADMAPFILEAS, _("Load &other map file..."),
pSymbolsMenu->Append(IDM_LOAD_MAP_FILE_AS, _("Load &other map file..."),
_("Load any .map file containing the function names and addresses for this game."));
pSymbolsMenu->Append(IDM_LOADBADMAPFILE, _("Load &bad map file..."),
pSymbolsMenu->Append(IDM_LOAD_BAD_MAP_FILE, _("Load &bad map file..."),
_("Try to load a .map file that might be from a slightly different version."));
pSymbolsMenu->Append(IDM_SAVEMAPFILEAS, _("Save symbol map &as..."),
pSymbolsMenu->Append(IDM_SAVE_MAP_FILE_AS, _("Save symbol map &as..."),
_("Save the function names and addresses for this game as a .map file. If you want to open it in IDA pro, use the .idc script."));
pSymbolsMenu->AppendSeparator();
pSymbolsMenu->Append(IDM_SAVEMAPFILEWITHCODES, _("Save code"),
pSymbolsMenu->Append(IDM_SAVE_MAP_FILE_WITH_CODES, _("Save code"),
_("Save the entire disassembled code. This may take a several seconds"
" and may require between 50 and 100 MB of hard drive space. It will only save code"
" that are in the first 4 MB of memory, if you are debugging a game that load .rel"
@ -172,23 +172,23 @@ void CCodeWindow::CreateMenuSymbols(wxMenuBar *pMenuBar)
);
pSymbolsMenu->AppendSeparator();
pSymbolsMenu->Append(IDM_CREATESIGNATUREFILE, _("&Create signature file..."),
pSymbolsMenu->Append(IDM_CREATE_SIGNATURE_FILE, _("&Create signature file..."),
_("Create a .dsy file that can be used to recognise these same functions in other games."));
pSymbolsMenu->Append(IDM_APPENDSIGNATUREFILE, _("Append to &existing signature file..."),
pSymbolsMenu->Append(IDM_APPEND_SIGNATURE_FILE, _("Append to &existing signature file..."),
_("Add any named functions missing from a .dsy file, so it can also recognise these additional functions in other games."));
pSymbolsMenu->Append(IDM_COMBINESIGNATUREFILES, _("Combine two signature files..."),
pSymbolsMenu->Append(IDM_COMBINE_SIGNATURE_FILES, _("Combine two signature files..."),
_("Make a new .dsy file which can recognise more functions, by combining two existing files. The first input file has priority."));
pSymbolsMenu->Append(IDM_USESIGNATUREFILE, _("Apply signat&ure file..."),
pSymbolsMenu->Append(IDM_USE_SIGNATURE_FILE, _("Apply signat&ure file..."),
_("Must use Generate symbol map first! Recognise names of any standard library functions used in multiple games, by loading them from a .dsy file."));
pSymbolsMenu->AppendSeparator();
pSymbolsMenu->Append(IDM_PATCHHLEFUNCTIONS, _("&Patch HLE functions"));
pSymbolsMenu->Append(IDM_PATCH_HLE_FUNCTIONS, _("&Patch HLE functions"));
pSymbolsMenu->Append(IDM_RENAME_SYMBOLS, _("&Rename symbols from file..."));
pMenuBar->Append(pSymbolsMenu, _("&Symbols"));
wxMenu *pProfilerMenu = new wxMenu;
pProfilerMenu->Append(IDM_PROFILEBLOCKS, _("&Profile blocks"), wxEmptyString, wxITEM_CHECK);
pProfilerMenu->Append(IDM_PROFILE_BLOCKS, _("&Profile blocks"), wxEmptyString, wxITEM_CHECK);
pProfilerMenu->AppendSeparator();
pProfilerMenu->Append(IDM_WRITEPROFILE, _("&Write to profile.txt, show"));
pProfilerMenu->Append(IDM_WRITE_PROFILE, _("&Write to profile.txt, show"));
pMenuBar->Append(pProfilerMenu, _("&Profiler"));
}
@ -196,14 +196,14 @@ void CCodeWindow::OnProfilerMenu(wxCommandEvent& event)
{
switch (event.GetId())
{
case IDM_PROFILEBLOCKS:
case IDM_PROFILE_BLOCKS:
Core::SetState(Core::CORE_PAUSE);
if (jit != nullptr)
jit->ClearCache();
Profiler::g_ProfileBlocks = GetMenuBar()->IsChecked(IDM_PROFILEBLOCKS);
Profiler::g_ProfileBlocks = GetMenuBar()->IsChecked(IDM_PROFILE_BLOCKS);
Core::SetState(Core::CORE_RUN);
break;
case IDM_WRITEPROFILE:
case IDM_WRITE_PROFILE:
if (Core::GetState() == Core::CORE_RUN)
Core::SetState(Core::CORE_PAUSE);
@ -245,12 +245,12 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
&title_id_str);
switch (event.GetId())
{
case IDM_CLEARSYMBOLS:
case IDM_CLEAR_SYMBOLS:
if (!AskYesNoT("Do you want to clear the list of symbol names?")) return;
g_symbolDB.Clear();
Host_NotifyMapLoaded();
break;
case IDM_SCANFUNCTIONS:
case IDM_SCAN_FUNCTIONS:
{
PPCAnalyst::FindFunctions(0x80000000, 0x81800000, &g_symbolDB);
SignatureDB db;
@ -269,7 +269,7 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
NotifyMapLoaded();
break;
}
case IDM_LOADMAPFILE:
case IDM_LOAD_MAP_FILE:
if (!map_exists)
{
g_symbolDB.Clear();
@ -287,7 +287,7 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
HLE::PatchFunctions();
NotifyMapLoaded();
break;
case IDM_LOADMAPFILEAS:
case IDM_LOAD_MAP_FILE_AS:
{
const wxString path = wxFileSelector(
_("Load map file"), File::GetUserPath(D_MAPS_IDX),
@ -304,7 +304,7 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
NotifyMapLoaded();
}
break;
case IDM_LOADBADMAPFILE:
case IDM_LOAD_BAD_MAP_FILE:
{
const wxString path = wxFileSelector(
_("Load bad map file"), File::GetUserPath(D_MAPS_IDX),
@ -324,7 +324,7 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
case IDM_SAVEMAPFILE:
g_symbolDB.SaveMap(writable_map_file);
break;
case IDM_SAVEMAPFILEAS:
case IDM_SAVE_MAP_FILE_AS:
{
const wxString path = wxFileSelector(
_("Save map file as"), File::GetUserPath(D_MAPS_IDX),
@ -336,7 +336,7 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
g_symbolDB.SaveMap(WxStrToStr(path));
}
break;
case IDM_SAVEMAPFILEWITHCODES:
case IDM_SAVE_MAP_FILE_WITH_CODES:
g_symbolDB.SaveMap(writable_map_file, true);
break;
@ -375,7 +375,7 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
}
break;
case IDM_CREATESIGNATUREFILE:
case IDM_CREATE_SIGNATURE_FILE:
{
wxTextEntryDialog input_prefix(
this,
@ -401,7 +401,7 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
}
}
break;
case IDM_APPENDSIGNATUREFILE:
case IDM_APPEND_SIGNATURE_FILE:
{
wxTextEntryDialog input_prefix(
this,
@ -429,7 +429,7 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
}
}
break;
case IDM_USESIGNATUREFILE:
case IDM_USE_SIGNATURE_FILE:
{
wxString path = wxFileSelector(
_("Apply signature file"), File::GetSysDirectory(), wxEmptyString, wxEmptyString,
@ -445,7 +445,7 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
}
}
break;
case IDM_COMBINESIGNATUREFILES:
case IDM_COMBINE_SIGNATURE_FILES:
{
wxString path1 = wxFileSelector(
_("Choose priority input file"), File::GetSysDirectory(), wxEmptyString, wxEmptyString,
@ -473,7 +473,7 @@ void CCodeWindow::OnSymbolsMenu(wxCommandEvent& event)
}
}
break;
case IDM_PATCHHLEFUNCTIONS:
case IDM_PATCH_HLE_FUNCTIONS:
HLE::PatchFunctions();
Update();
break;
@ -541,21 +541,21 @@ void CCodeWindow::OpenPages()
ToggleCodeWindow(true);
if (bShowOnStart[0])
Parent->ToggleLogWindow(true);
if (bShowOnStart[IDM_LOGCONFIGWINDOW - IDM_LOGWINDOW])
if (bShowOnStart[IDM_LOG_CONFIG_WINDOW - IDM_LOG_WINDOW])
Parent->ToggleLogConfigWindow(true);
if (bShowOnStart[IDM_REGISTERWINDOW - IDM_LOGWINDOW])
if (bShowOnStart[IDM_REGISTER_WINDOW - IDM_LOG_WINDOW])
ToggleRegisterWindow(true);
if (bShowOnStart[IDM_WATCHWINDOW - IDM_LOGWINDOW])
if (bShowOnStart[IDM_WATCH_WINDOW - IDM_LOG_WINDOW])
ToggleWatchWindow(true);
if (bShowOnStart[IDM_BREAKPOINTWINDOW - IDM_LOGWINDOW])
if (bShowOnStart[IDM_BREAKPOINT_WINDOW - IDM_LOG_WINDOW])
ToggleBreakPointWindow(true);
if (bShowOnStart[IDM_MEMORYWINDOW - IDM_LOGWINDOW])
if (bShowOnStart[IDM_MEMORY_WINDOW - IDM_LOG_WINDOW])
ToggleMemoryWindow(true);
if (bShowOnStart[IDM_JITWINDOW - IDM_LOGWINDOW])
if (bShowOnStart[IDM_JIT_WINDOW - IDM_LOG_WINDOW])
ToggleJitWindow(true);
if (bShowOnStart[IDM_SOUNDWINDOW - IDM_LOGWINDOW])
if (bShowOnStart[IDM_SOUND_WINDOW - IDM_LOG_WINDOW])
ToggleSoundWindow(true);
if (bShowOnStart[IDM_VIDEOWINDOW - IDM_LOGWINDOW])
if (bShowOnStart[IDM_VIDEO_WINDOW - IDM_LOG_WINDOW])
ToggleVideoWindow(true);
}
@ -563,22 +563,22 @@ void CCodeWindow::ToggleCodeWindow(bool bShow)
{
if (bShow)
Parent->DoAddPage(this,
iNbAffiliation[IDM_CODEWINDOW - IDM_LOGWINDOW],
Parent->bFloatWindow[IDM_CODEWINDOW - IDM_LOGWINDOW]);
iNbAffiliation[IDM_CODE_WINDOW - IDM_LOG_WINDOW],
Parent->bFloatWindow[IDM_CODE_WINDOW - IDM_LOG_WINDOW]);
else // Hide
Parent->DoRemovePage(this);
}
void CCodeWindow::ToggleRegisterWindow(bool bShow)
{
GetMenuBar()->FindItem(IDM_REGISTERWINDOW)->Check(bShow);
GetMenuBar()->FindItem(IDM_REGISTER_WINDOW)->Check(bShow);
if (bShow)
{
if (!m_RegisterWindow)
m_RegisterWindow = new CRegisterWindow(Parent, IDM_REGISTERWINDOW);
m_RegisterWindow = new CRegisterWindow(Parent, IDM_REGISTER_WINDOW);
Parent->DoAddPage(m_RegisterWindow,
iNbAffiliation[IDM_REGISTERWINDOW - IDM_LOGWINDOW],
Parent->bFloatWindow[IDM_REGISTERWINDOW - IDM_LOGWINDOW]);
iNbAffiliation[IDM_REGISTER_WINDOW - IDM_LOG_WINDOW],
Parent->bFloatWindow[IDM_REGISTER_WINDOW - IDM_LOG_WINDOW]);
}
else // Close
{
@ -589,14 +589,14 @@ void CCodeWindow::ToggleRegisterWindow(bool bShow)
void CCodeWindow::ToggleWatchWindow(bool bShow)
{
GetMenuBar()->FindItem(IDM_WATCHWINDOW)->Check(bShow);
GetMenuBar()->FindItem(IDM_WATCH_WINDOW)->Check(bShow);
if (bShow)
{
if (!m_WatchWindow)
m_WatchWindow = new CWatchWindow(Parent, IDM_WATCHWINDOW);
m_WatchWindow = new CWatchWindow(Parent, IDM_WATCH_WINDOW);
Parent->DoAddPage(m_WatchWindow,
iNbAffiliation[IDM_WATCHWINDOW - IDM_LOGWINDOW],
Parent->bFloatWindow[IDM_WATCHWINDOW - IDM_LOGWINDOW]);
iNbAffiliation[IDM_WATCH_WINDOW - IDM_LOG_WINDOW],
Parent->bFloatWindow[IDM_WATCH_WINDOW - IDM_LOG_WINDOW]);
}
else // Close
{
@ -607,14 +607,14 @@ void CCodeWindow::ToggleWatchWindow(bool bShow)
void CCodeWindow::ToggleBreakPointWindow(bool bShow)
{
GetMenuBar()->FindItem(IDM_BREAKPOINTWINDOW)->Check(bShow);
GetMenuBar()->FindItem(IDM_BREAKPOINT_WINDOW)->Check(bShow);
if (bShow)
{
if (!m_BreakpointWindow)
m_BreakpointWindow = new CBreakPointWindow(this, Parent, IDM_BREAKPOINTWINDOW);
m_BreakpointWindow = new CBreakPointWindow(this, Parent, IDM_BREAKPOINT_WINDOW);
Parent->DoAddPage(m_BreakpointWindow,
iNbAffiliation[IDM_BREAKPOINTWINDOW - IDM_LOGWINDOW],
Parent->bFloatWindow[IDM_BREAKPOINTWINDOW - IDM_LOGWINDOW]);
iNbAffiliation[IDM_BREAKPOINT_WINDOW - IDM_LOG_WINDOW],
Parent->bFloatWindow[IDM_BREAKPOINT_WINDOW - IDM_LOG_WINDOW]);
}
else // Close
{
@ -625,14 +625,14 @@ void CCodeWindow::ToggleBreakPointWindow(bool bShow)
void CCodeWindow::ToggleMemoryWindow(bool bShow)
{
GetMenuBar()->FindItem(IDM_MEMORYWINDOW)->Check(bShow);
GetMenuBar()->FindItem(IDM_MEMORY_WINDOW)->Check(bShow);
if (bShow)
{
if (!m_MemoryWindow)
m_MemoryWindow = new CMemoryWindow(Parent, IDM_MEMORYWINDOW);
m_MemoryWindow = new CMemoryWindow(Parent, IDM_MEMORY_WINDOW);
Parent->DoAddPage(m_MemoryWindow,
iNbAffiliation[IDM_MEMORYWINDOW - IDM_LOGWINDOW],
Parent->bFloatWindow[IDM_MEMORYWINDOW - IDM_LOGWINDOW]);
iNbAffiliation[IDM_MEMORY_WINDOW - IDM_LOG_WINDOW],
Parent->bFloatWindow[IDM_MEMORY_WINDOW - IDM_LOG_WINDOW]);
}
else // Close
{
@ -643,14 +643,14 @@ void CCodeWindow::ToggleMemoryWindow(bool bShow)
void CCodeWindow::ToggleJitWindow(bool bShow)
{
GetMenuBar()->FindItem(IDM_JITWINDOW)->Check(bShow);
GetMenuBar()->FindItem(IDM_JIT_WINDOW)->Check(bShow);
if (bShow)
{
if (!m_JitWindow)
m_JitWindow = new CJitWindow(Parent, IDM_JITWINDOW);
m_JitWindow = new CJitWindow(Parent, IDM_JIT_WINDOW);
Parent->DoAddPage(m_JitWindow,
iNbAffiliation[IDM_JITWINDOW - IDM_LOGWINDOW],
Parent->bFloatWindow[IDM_JITWINDOW - IDM_LOGWINDOW]);
iNbAffiliation[IDM_JIT_WINDOW - IDM_LOG_WINDOW],
Parent->bFloatWindow[IDM_JIT_WINDOW - IDM_LOG_WINDOW]);
}
else // Close
{
@ -662,14 +662,14 @@ void CCodeWindow::ToggleJitWindow(bool bShow)
void CCodeWindow::ToggleSoundWindow(bool bShow)
{
GetMenuBar()->FindItem(IDM_SOUNDWINDOW)->Check(bShow);
GetMenuBar()->FindItem(IDM_SOUND_WINDOW)->Check(bShow);
if (bShow)
{
if (!m_SoundWindow)
m_SoundWindow = new DSPDebuggerLLE(Parent, IDM_SOUNDWINDOW);
m_SoundWindow = new DSPDebuggerLLE(Parent, IDM_SOUND_WINDOW);
Parent->DoAddPage(m_SoundWindow,
iNbAffiliation[IDM_SOUNDWINDOW - IDM_LOGWINDOW],
Parent->bFloatWindow[IDM_SOUNDWINDOW - IDM_LOGWINDOW]);
iNbAffiliation[IDM_SOUND_WINDOW - IDM_LOG_WINDOW],
Parent->bFloatWindow[IDM_SOUND_WINDOW - IDM_LOG_WINDOW]);
}
else // Close
{
@ -680,14 +680,14 @@ void CCodeWindow::ToggleSoundWindow(bool bShow)
void CCodeWindow::ToggleVideoWindow(bool bShow)
{
GetMenuBar()->FindItem(IDM_VIDEOWINDOW)->Check(bShow);
GetMenuBar()->FindItem(IDM_VIDEO_WINDOW)->Check(bShow);
if (bShow)
{
if (!m_VideoWindow)
m_VideoWindow = new GFXDebuggerPanel(Parent, IDM_VIDEOWINDOW);
m_VideoWindow = new GFXDebuggerPanel(Parent, IDM_VIDEO_WINDOW);
Parent->DoAddPage(m_VideoWindow,
iNbAffiliation[IDM_VIDEOWINDOW - IDM_LOGWINDOW],
Parent->bFloatWindow[IDM_VIDEOWINDOW - IDM_LOGWINDOW]);
iNbAffiliation[IDM_VIDEO_WINDOW - IDM_LOG_WINDOW],
Parent->bFloatWindow[IDM_VIDEO_WINDOW - IDM_LOG_WINDOW]);
}
else // Close
{

2
Source/Core/DolphinWX/Debugger/JitWindow.cpp
View File

@ -293,7 +293,7 @@ void CJitWindow::OnHostMessage(wxCommandEvent& event)
{
switch (event.GetId())
{
case IDM_NOTIFYMAPLOADED:
case IDM_NOTIFY_MAP_LOADED:
//NotifyMapLoaded();
break;
}

2
Source/Core/DolphinWX/Debugger/MemoryView.cpp
View File

@ -100,7 +100,7 @@ void CMemoryView::OnMouseDownL(wxMouseEvent& event)
Refresh();
// Propagate back to the parent window to update the breakpoint list.
wxCommandEvent evt(wxEVT_HOST_COMMAND, IDM_UPDATEBREAKPOINTS);
wxCommandEvent evt(wxEVT_HOST_COMMAND, IDM_UPDATE_BREAKPOINTS);
GetEventHandler()->AddPendingEvent(evt);
}

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

@ -239,7 +239,7 @@ void CMemoryWindow::OnHostMessage(wxCommandEvent& event)
{
switch (event.GetId())
{
case IDM_NOTIFYMAPLOADED:
case IDM_NOTIFY_MAP_LOADED:
NotifyMapLoaded();
break;
}

224
Source/Core/DolphinWX/Frame.cpp
View File

@ -121,7 +121,7 @@ void CRenderFrame::OnDropFiles(wxDropFilesEvent& event)
{
// let's make the read-only flag consistent at the start of a movie.
Movie::SetReadOnly(true);
main_frame->GetMenuBar()->FindItem(IDM_RECORDREADONLY)->Check(true);
main_frame->GetMenuBar()->FindItem(IDM_RECORD_READ_ONLY)->Check(true);
}
if (Movie::PlayInput(filepath))
@ -236,27 +236,27 @@ BEGIN_EVENT_TABLE(CFrame, CRenderFrame)
// Menu bar
EVT_MENU(wxID_OPEN, CFrame::OnOpen)
EVT_MENU(wxID_EXIT, CFrame::OnQuit)
EVT_MENU(IDM_HELPWEBSITE, CFrame::OnHelp)
EVT_MENU(IDM_HELPONLINEDOCS, CFrame::OnHelp)
EVT_MENU(IDM_HELPGITHUB, CFrame::OnHelp)
EVT_MENU(IDM_HELP_WEBSITE, CFrame::OnHelp)
EVT_MENU(IDM_HELP_ONLINE_DOCS, CFrame::OnHelp)
EVT_MENU(IDM_HELP_GITHUB, CFrame::OnHelp)
EVT_MENU(wxID_ABOUT, CFrame::OnHelp)
EVT_MENU(wxID_REFRESH, CFrame::OnRefresh)
EVT_MENU(IDM_PLAY, CFrame::OnPlay)
EVT_MENU(IDM_STOP, CFrame::OnStop)
EVT_MENU(IDM_RESET, CFrame::OnReset)
EVT_MENU(IDM_RECORD, CFrame::OnRecord)
EVT_MENU(IDM_PLAYRECORD, CFrame::OnPlayRecording)
EVT_MENU(IDM_RECORDEXPORT, CFrame::OnRecordExport)
EVT_MENU(IDM_RECORDREADONLY, CFrame::OnRecordReadOnly)
EVT_MENU(IDM_TASINPUT, CFrame::OnTASInput)
EVT_MENU(IDM_TOGGLE_PAUSEMOVIE, CFrame::OnTogglePauseMovie)
EVT_MENU(IDM_SHOWLAG, CFrame::OnShowLag)
EVT_MENU(IDM_SHOWFRAMECOUNT, CFrame::OnShowFrameCount)
EVT_MENU(IDM_SHOWINPUTDISPLAY, CFrame::OnShowInputDisplay)
EVT_MENU(IDM_PLAY_RECORD, CFrame::OnPlayRecording)
EVT_MENU(IDM_RECORD_EXPORT, CFrame::OnRecordExport)
EVT_MENU(IDM_RECORD_READ_ONLY, CFrame::OnRecordReadOnly)
EVT_MENU(IDM_TAS_INPUT, CFrame::OnTASInput)
EVT_MENU(IDM_TOGGLE_PAUSE_MOVIE, CFrame::OnTogglePauseMovie)
EVT_MENU(IDM_SHOW_LAG, CFrame::OnShowLag)
EVT_MENU(IDM_SHOW_FRAME_COUNT, CFrame::OnShowFrameCount)
EVT_MENU(IDM_SHOW_INPUT_DISPLAY, CFrame::OnShowInputDisplay)
EVT_MENU(IDM_FRAMESTEP, CFrame::OnFrameStep)
EVT_MENU(IDM_SCREENSHOT, CFrame::OnScreenshot)
EVT_MENU(IDM_TOGGLE_DUMPFRAMES, CFrame::OnToggleDumpFrames)
EVT_MENU(IDM_TOGGLE_DUMPAUDIO, CFrame::OnToggleDumpAudio)
EVT_MENU(IDM_TOGGLE_DUMP_FRAMES, CFrame::OnToggleDumpFrames)
EVT_MENU(IDM_TOGGLE_DUMP_AUDIO, CFrame::OnToggleDumpAudio)
EVT_MENU(wxID_PREFERENCES, CFrame::OnConfigMain)
EVT_MENU(IDM_CONFIG_GFX_BACKEND, CFrame::OnConfigGFX)
EVT_MENU(IDM_CONFIG_AUDIO, CFrame::OnConfigAudio)
@ -272,46 +272,46 @@ EVT_MENU(IDM_ADD_PERSPECTIVE, CFrame::OnPerspectiveMenu)
EVT_MENU(IDM_TAB_SPLIT, CFrame::OnPerspectiveMenu)
EVT_MENU(IDM_NO_DOCKING, CFrame::OnPerspectiveMenu)
// Drop down float
EVT_MENU_RANGE(IDM_FLOAT_LOGWINDOW, IDM_FLOAT_CODEWINDOW, CFrame::OnFloatWindow)
EVT_MENU_RANGE(IDM_FLOAT_LOG_WINDOW, IDM_FLOAT_CODE_WINDOW, CFrame::OnFloatWindow)
EVT_MENU(IDM_NETPLAY, CFrame::OnNetPlay)
EVT_MENU(IDM_BROWSE, CFrame::OnBrowse)
EVT_MENU(IDM_MEMCARD, CFrame::OnMemcard)
EVT_MENU(IDM_IMPORTSAVE, CFrame::OnImportSave)
EVT_MENU(IDM_EXPORTALLSAVE, CFrame::OnExportAllSaves)
EVT_MENU(IDM_IMPORT_SAVE, CFrame::OnImportSave)
EVT_MENU(IDM_EXPORT_ALL_SAVE, CFrame::OnExportAllSaves)
EVT_MENU(IDM_CHEATS, CFrame::OnShow_CheatsWindow)
EVT_MENU(IDM_CHANGEDISC, CFrame::OnChangeDisc)
EVT_MENU(IDM_MENU_INSTALLWAD, CFrame::OnInstallWAD)
EVT_MENU(IDM_LIST_INSTALLWAD, CFrame::OnInstallWAD)
EVT_MENU(IDM_CHANGE_DISC, CFrame::OnChangeDisc)
EVT_MENU(IDM_MENU_INSTALL_WAD, CFrame::OnInstallWAD)
EVT_MENU(IDM_LIST_INSTALL_WAD, CFrame::OnInstallWAD)
EVT_MENU(IDM_LOAD_WII_MENU, CFrame::OnLoadWiiMenu)
EVT_MENU(IDM_FIFOPLAYER, CFrame::OnFifoPlayer)
EVT_MENU(IDM_TOGGLE_FULLSCREEN, CFrame::OnToggleFullscreen)
EVT_MENU(IDM_TOGGLE_DUALCORE, CFrame::OnToggleDualCore)
EVT_MENU(IDM_TOGGLE_SKIPIDLE, CFrame::OnToggleSkipIdle)
EVT_MENU(IDM_TOGGLE_DUAL_CORE, CFrame::OnToggleDualCore)
EVT_MENU(IDM_TOGGLE_SKIP_IDLE, CFrame::OnToggleSkipIdle)
EVT_MENU(IDM_TOGGLE_TOOLBAR, CFrame::OnToggleToolbar)
EVT_MENU(IDM_TOGGLE_STATUSBAR, CFrame::OnToggleStatusbar)
EVT_MENU_RANGE(IDM_LOGWINDOW, IDM_VIDEOWINDOW, CFrame::OnToggleWindow)
EVT_MENU_RANGE(IDM_LOG_WINDOW, IDM_VIDEO_WINDOW, CFrame::OnToggleWindow)
EVT_MENU_RANGE(IDM_SHOW_SYSTEM, IDM_SHOW_STATE, CFrame::OnChangeColumnsVisible)
EVT_MENU(IDM_PURGECACHE, CFrame::GameListChanged)
EVT_MENU(IDM_PURGE_CACHE, CFrame::GameListChanged)
EVT_MENU(IDM_SAVEFIRSTSTATE, CFrame::OnSaveFirstState)
EVT_MENU(IDM_UNDOLOADSTATE, CFrame::OnUndoLoadState)
EVT_MENU(IDM_UNDOSAVESTATE, CFrame::OnUndoSaveState)
EVT_MENU(IDM_LOADSTATEFILE, CFrame::OnLoadStateFromFile)
EVT_MENU(IDM_SAVESTATEFILE, CFrame::OnSaveStateToFile)
EVT_MENU(IDM_SAVESELECTEDSLOT, CFrame::OnSaveCurrentSlot)
EVT_MENU(IDM_LOADSELECTEDSLOT, CFrame::OnLoadCurrentSlot)
EVT_MENU(IDM_SAVE_FIRST_STATE, CFrame::OnSaveFirstState)
EVT_MENU(IDM_UNDO_LOAD_STATE, CFrame::OnUndoLoadState)
EVT_MENU(IDM_UNDO_SAVE_STATE, CFrame::OnUndoSaveState)
EVT_MENU(IDM_LOAD_STATE_FILE, CFrame::OnLoadStateFromFile)
EVT_MENU(IDM_SAVE_STATE_FILE, CFrame::OnSaveStateToFile)
EVT_MENU(IDM_SAVE_SELECTED_SLOT, CFrame::OnSaveCurrentSlot)
EVT_MENU(IDM_LOAD_SELECTED_SLOT, CFrame::OnLoadCurrentSlot)
EVT_MENU_RANGE(IDM_LOADSLOT1, IDM_LOADSLOT10, CFrame::OnLoadState)
EVT_MENU_RANGE(IDM_LOADLAST1, IDM_LOADLAST8, CFrame::OnLoadLastState)
EVT_MENU_RANGE(IDM_SAVESLOT1, IDM_SAVESLOT10, CFrame::OnSaveState)
EVT_MENU_RANGE(IDM_SELECTSLOT1, IDM_SELECTSLOT10, CFrame::OnSelectSlot)
EVT_MENU_RANGE(IDM_FRAMESKIP0, IDM_FRAMESKIP9, CFrame::OnFrameSkip)
EVT_MENU_RANGE(IDM_LOAD_SLOT_1, IDM_LOAD_SLOT_10, CFrame::OnLoadState)
EVT_MENU_RANGE(IDM_LOAD_LAST_1, IDM_LOAD_LAST_8, CFrame::OnLoadLastState)
EVT_MENU_RANGE(IDM_SAVE_SLOT_1, IDM_SAVE_SLOT_10, CFrame::OnSaveState)
EVT_MENU_RANGE(IDM_SELECT_SLOT_1, IDM_SELECT_SLOT_10, CFrame::OnSelectSlot)
EVT_MENU_RANGE(IDM_FRAME_SKIP_0, IDM_FRAME_SKIP_9, CFrame::OnFrameSkip)
EVT_MENU_RANGE(IDM_DRIVE1, IDM_DRIVE24, CFrame::OnBootDrive)
EVT_MENU_RANGE(IDM_CONNECT_WIIMOTE1, IDM_CONNECT_BALANCEBOARD, CFrame::OnConnectWiimote)
EVT_MENU_RANGE(IDM_LISTWAD, IDM_LISTDRIVES, CFrame::GameListChanged)
EVT_MENU_RANGE(IDM_LIST_WAD, IDM_LIST_DRIVES, CFrame::GameListChanged)
// Other
EVT_ACTIVATE(CFrame::OnActive)
@ -354,7 +354,7 @@ CFrame::CFrame(wxFrame* parent,
, m_bBatchMode(_BatchMode), m_bEdit(false), m_bTabSplit(false), m_bNoDocking(false)
, m_bGameLoading(false), m_bClosing(false), m_confirmStop(false), m_menubar_shadow(nullptr)
{
for (int i = 0; i <= IDM_CODEWINDOW - IDM_LOGWINDOW; i++)
for (int i = 0; i <= IDM_CODE_WINDOW - IDM_LOG_WINDOW; i++)
bFloatWindow[i] = false;
if (ShowLogWindow)
@ -367,7 +367,7 @@ CFrame::CFrame(wxFrame* parent,
// Debugger class
if (UseDebugger)
{
g_pCodeWindow = new CCodeWindow(SConfig::GetInstance().m_LocalCoreStartupParameter, this, IDM_CODEWINDOW);
g_pCodeWindow = new CCodeWindow(SConfig::GetInstance().m_LocalCoreStartupParameter, this, IDM_CODE_WINDOW);
LoadIniPerspectives();
g_pCodeWindow->Load();
}
@ -417,7 +417,7 @@ CFrame::CFrame(wxFrame* parent,
RecreateToolbar();
if (!SConfig::GetInstance().m_InterfaceToolbar) DoToggleToolbar(false);
m_LogWindow = new CLogWindow(this, IDM_LOGWINDOW);
m_LogWindow = new CLogWindow(this, IDM_LOG_WINDOW);
m_LogWindow->Hide();
m_LogWindow->Disable();
@ -685,20 +685,20 @@ void CFrame::OnHostMessage(wxCommandEvent& event)
{
switch (event.GetId())
{
case IDM_UPDATEGUI:
case IDM_UPDATE_GUI:
UpdateGUI();
break;
case IDM_UPDATESTATUSBAR:
case IDM_UPDATE_STATUS_BAR:
if (GetStatusBar() != nullptr)
GetStatusBar()->SetStatusText(event.GetString(), event.GetInt());
break;
case IDM_UPDATETITLE:
case IDM_UPDATE_TITLE:
UpdateTitle(WxStrToStr(event.GetString()));
break;
case IDM_WINDOWSIZEREQUEST:
case IDM_WINDOW_SIZE_REQUEST:
{
std::pair<int, int> *win_size = (std::pair<int, int> *)(event.GetClientData());
OnRenderWindowSizeRequest(win_size->first, win_size->second);
@ -706,7 +706,7 @@ void CFrame::OnHostMessage(wxCommandEvent& event)
}
break;
case IDM_FULLSCREENREQUEST:
case IDM_FULLSCREEN_REQUEST:
{
bool enable_fullscreen = event.GetInt() == 0 ? false : true;
ToggleDisplayMode(enable_fullscreen);
@ -864,22 +864,22 @@ void CFrame::OnGameListCtrl_ItemActivated(wxListEvent& WXUNUSED (event))
SConfig::GetInstance().m_ListTaiwan =
SConfig::GetInstance().m_ListUnknown = true;
GetMenuBar()->FindItem(IDM_LISTGC)->Check(true);
GetMenuBar()->FindItem(IDM_LISTWII)->Check(true);
GetMenuBar()->FindItem(IDM_LISTWAD)->Check(true);
GetMenuBar()->FindItem(IDM_LISTJAP)->Check(true);
GetMenuBar()->FindItem(IDM_LISTUSA)->Check(true);
GetMenuBar()->FindItem(IDM_LISTPAL)->Check(true);
GetMenuBar()->FindItem(IDM_LISTAUSTRALIA)->Check(true);
GetMenuBar()->FindItem(IDM_LISTFRANCE)->Check(true);
GetMenuBar()->FindItem(IDM_LISTGERMANY)->Check(true);
GetMenuBar()->FindItem(IDM_LISTITALY)->Check(true);
GetMenuBar()->FindItem(IDM_LISTKOREA)->Check(true);
GetMenuBar()->FindItem(IDM_LISTNETHERLANDS)->Check(true);
GetMenuBar()->FindItem(IDM_LISTRUSSIA)->Check(true);
GetMenuBar()->FindItem(IDM_LISTSPAIN)->Check(true);
GetMenuBar()->FindItem(IDM_LISTTAIWAN)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_UNK)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_GC)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_WII)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_WAD)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_JAP)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_USA)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_PAL)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_AUSTRALIA)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_FRANCE)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_GERMANY)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_ITALY)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_KOREA)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_NETHERLANDS)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_RUSSIA)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_SPAIN)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_TAIWAN)->Check(true);
GetMenuBar()->FindItem(IDM_LIST_UNKNOWN)->Check(true);
m_GameListCtrl->Update();
}
@ -906,16 +906,16 @@ int GetCmdForHotkey(unsigned int key)
switch (key)
{
case HK_OPEN: return wxID_OPEN;
case HK_CHANGE_DISC: return IDM_CHANGEDISC;
case HK_CHANGE_DISC: return IDM_CHANGE_DISC;
case HK_REFRESH_LIST: return wxID_REFRESH;
case HK_PLAY_PAUSE: return IDM_PLAY;
case HK_STOP: return IDM_STOP;
case HK_RESET: return IDM_RESET;
case HK_FRAME_ADVANCE: return IDM_FRAMESTEP;
case HK_START_RECORDING: return IDM_RECORD;
case HK_PLAY_RECORDING: return IDM_PLAYRECORD;
case HK_EXPORT_RECORDING: return IDM_RECORDEXPORT;
case HK_READ_ONLY_MODE: return IDM_RECORDREADONLY;
case HK_PLAY_RECORDING: return IDM_PLAY_RECORD;
case HK_EXPORT_RECORDING: return IDM_RECORD_EXPORT;
case HK_READ_ONLY_MODE: return IDM_RECORD_READ_ONLY;
case HK_FULLSCREEN: return IDM_TOGGLE_FULLSCREEN;
case HK_SCREENSHOT: return IDM_SCREENSHOT;
case HK_EXIT: return wxID_EXIT;
@ -926,55 +926,55 @@ int GetCmdForHotkey(unsigned int key)
case HK_WIIMOTE4_CONNECT: return IDM_CONNECT_WIIMOTE4;
case HK_BALANCEBOARD_CONNECT: return IDM_CONNECT_BALANCEBOARD;
case HK_LOAD_STATE_SLOT_1: return IDM_LOADSLOT1;
case HK_LOAD_STATE_SLOT_2: return IDM_LOADSLOT2;
case HK_LOAD_STATE_SLOT_3: return IDM_LOADSLOT3;
case HK_LOAD_STATE_SLOT_4: return IDM_LOADSLOT4;
case HK_LOAD_STATE_SLOT_5: return IDM_LOADSLOT5;
case HK_LOAD_STATE_SLOT_6: return IDM_LOADSLOT6;
case HK_LOAD_STATE_SLOT_7: return IDM_LOADSLOT7;
case HK_LOAD_STATE_SLOT_8: return IDM_LOADSLOT8;
case HK_LOAD_STATE_SLOT_9: return IDM_LOADSLOT9;
case HK_LOAD_STATE_SLOT_10: return IDM_LOADSLOT10;
case HK_LOAD_STATE_SLOT_1: return IDM_LOAD_SLOT_1;
case HK_LOAD_STATE_SLOT_2: return IDM_LOAD_SLOT_2;
case HK_LOAD_STATE_SLOT_3: return IDM_LOAD_SLOT_3;
case HK_LOAD_STATE_SLOT_4: return IDM_LOAD_SLOT_4;
case HK_LOAD_STATE_SLOT_5: return IDM_LOAD_SLOT_5;
case HK_LOAD_STATE_SLOT_6: return IDM_LOAD_SLOT_6;
case HK_LOAD_STATE_SLOT_7: return IDM_LOAD_SLOT_7;
case HK_LOAD_STATE_SLOT_8: return IDM_LOAD_SLOT_8;
case HK_LOAD_STATE_SLOT_9: return IDM_LOAD_SLOT_9;
case HK_LOAD_STATE_SLOT_10: return IDM_LOAD_SLOT_10;
case HK_SAVE_STATE_SLOT_1: return IDM_SAVESLOT1;
case HK_SAVE_STATE_SLOT_2: return IDM_SAVESLOT2;
case HK_SAVE_STATE_SLOT_3: return IDM_SAVESLOT3;
case HK_SAVE_STATE_SLOT_4: return IDM_SAVESLOT4;
case HK_SAVE_STATE_SLOT_5: return IDM_SAVESLOT5;
case HK_SAVE_STATE_SLOT_6: return IDM_SAVESLOT6;
case HK_SAVE_STATE_SLOT_7: return IDM_SAVESLOT7;
case HK_SAVE_STATE_SLOT_8: return IDM_SAVESLOT8;
case HK_SAVE_STATE_SLOT_9: return IDM_SAVESLOT9;
case HK_SAVE_STATE_SLOT_10: return IDM_SAVESLOT10;
case HK_SAVE_STATE_SLOT_1: return IDM_SAVE_SLOT_1;
case HK_SAVE_STATE_SLOT_2: return IDM_SAVE_SLOT_2;
case HK_SAVE_STATE_SLOT_3: return IDM_SAVE_SLOT_3;
case HK_SAVE_STATE_SLOT_4: return IDM_SAVE_SLOT_4;
case HK_SAVE_STATE_SLOT_5: return IDM_SAVE_SLOT_5;
case HK_SAVE_STATE_SLOT_6: return IDM_SAVE_SLOT_6;
case HK_SAVE_STATE_SLOT_7: return IDM_SAVE_SLOT_7;
case HK_SAVE_STATE_SLOT_8: return IDM_SAVE_SLOT_8;
case HK_SAVE_STATE_SLOT_9: return IDM_SAVE_SLOT_9;
case HK_SAVE_STATE_SLOT_10: return IDM_SAVE_SLOT_10;
case HK_LOAD_LAST_STATE_1: return IDM_LOADLAST1;
case HK_LOAD_LAST_STATE_2: return IDM_LOADLAST2;
case HK_LOAD_LAST_STATE_3: return IDM_LOADLAST3;
case HK_LOAD_LAST_STATE_4: return IDM_LOADLAST4;
case HK_LOAD_LAST_STATE_5: return IDM_LOADLAST5;
case HK_LOAD_LAST_STATE_6: return IDM_LOADLAST6;
case HK_LOAD_LAST_STATE_7: return IDM_LOADLAST7;
case HK_LOAD_LAST_STATE_8: return IDM_LOADLAST8;
case HK_LOAD_LAST_STATE_1: return IDM_LOAD_LAST_1;
case HK_LOAD_LAST_STATE_2: return IDM_LOAD_LAST_2;
case HK_LOAD_LAST_STATE_3: return IDM_LOAD_LAST_3;
case HK_LOAD_LAST_STATE_4: return IDM_LOAD_LAST_4;
case HK_LOAD_LAST_STATE_5: return IDM_LOAD_LAST_5;
case HK_LOAD_LAST_STATE_6: return IDM_LOAD_LAST_6;
case HK_LOAD_LAST_STATE_7: return IDM_LOAD_LAST_7;
case HK_LOAD_LAST_STATE_8: return IDM_LOAD_LAST_8;
case HK_SAVE_FIRST_STATE: return IDM_SAVEFIRSTSTATE;
case HK_UNDO_LOAD_STATE: return IDM_UNDOLOADSTATE;
case HK_UNDO_SAVE_STATE: return IDM_UNDOSAVESTATE;
case HK_LOAD_STATE_FILE: return IDM_LOADSTATEFILE;
case HK_SAVE_STATE_FILE: return IDM_SAVESTATEFILE;
case HK_SAVE_FIRST_STATE: return IDM_SAVE_FIRST_STATE;
case HK_UNDO_LOAD_STATE: return IDM_UNDO_LOAD_STATE;
case HK_UNDO_SAVE_STATE: return IDM_UNDO_SAVE_STATE;
case HK_LOAD_STATE_FILE: return IDM_LOAD_STATE_FILE;
case HK_SAVE_STATE_FILE: return IDM_SAVE_STATE_FILE;
case HK_SELECT_STATE_SLOT_1: return IDM_SELECTSLOT1;
case HK_SELECT_STATE_SLOT_2: return IDM_SELECTSLOT2;
case HK_SELECT_STATE_SLOT_3: return IDM_SELECTSLOT3;
case HK_SELECT_STATE_SLOT_4: return IDM_SELECTSLOT4;
case HK_SELECT_STATE_SLOT_5: return IDM_SELECTSLOT5;
case HK_SELECT_STATE_SLOT_6: return IDM_SELECTSLOT6;
case HK_SELECT_STATE_SLOT_7: return IDM_SELECTSLOT7;
case HK_SELECT_STATE_SLOT_8: return IDM_SELECTSLOT8;
case HK_SELECT_STATE_SLOT_9: return IDM_SELECTSLOT9;
case HK_SELECT_STATE_SLOT_10: return IDM_SELECTSLOT10;
case HK_SAVE_STATE_SLOT_SELECTED: return IDM_SAVESELECTEDSLOT;
case HK_LOAD_STATE_SLOT_SELECTED: return IDM_LOADSELECTEDSLOT;
case HK_SELECT_STATE_SLOT_1: return IDM_SELECT_SLOT_1;
case HK_SELECT_STATE_SLOT_2: return IDM_SELECT_SLOT_2;
case HK_SELECT_STATE_SLOT_3: return IDM_SELECT_SLOT_3;
case HK_SELECT_STATE_SLOT_4: return IDM_SELECT_SLOT_4;
case HK_SELECT_STATE_SLOT_5: return IDM_SELECT_SLOT_5;
case HK_SELECT_STATE_SLOT_6: return IDM_SELECT_SLOT_6;
case HK_SELECT_STATE_SLOT_7: return IDM_SELECT_SLOT_7;
case HK_SELECT_STATE_SLOT_8: return IDM_SELECT_SLOT_8;
case HK_SELECT_STATE_SLOT_9: return IDM_SELECT_SLOT_9;
case HK_SELECT_STATE_SLOT_10: return IDM_SELECT_SLOT_10;
case HK_SAVE_STATE_SLOT_SELECTED: return IDM_SAVE_SELECTED_SLOT;
case HK_LOAD_STATE_SLOT_SELECTED: return IDM_LOAD_SELECTED_SLOT;
case HK_FREELOOK_INCREASE_SPEED: return IDM_FREELOOK_INCREASE_SPEED;
case HK_FREELOOK_DECREASE_SPEED: return IDM_FREELOOK_DECREASE_SPEED;
@ -996,7 +996,7 @@ void OnAfterLoadCallback()
// warning: this gets called from the CPU thread, so we should only queue things to do on the proper thread
if (main_frame)
{
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATEGUI);
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATE_GUI);
main_frame->GetEventHandler()->AddPendingEvent(event);
}
}
@ -1151,7 +1151,7 @@ void CFrame::OnKeyDown(wxKeyEvent& event)
if (IsHotkey (event, i))
{
wxCommandEvent slot_event;
slot_event.SetId(i + IDM_SELECTSLOT1 - HK_SELECT_STATE_SLOT_1);
slot_event.SetId(i + IDM_SELECT_SLOT_1 - HK_SELECT_STATE_SLOT_1);
CFrame::OnSelectSlot(slot_event);
}
}

2
Source/Core/DolphinWX/Frame.h
View File

@ -144,7 +144,7 @@ public:
wxToolBar *m_ToolBar;
// AUI
wxAuiManager *m_Mgr;
bool bFloatWindow[IDM_CODEWINDOW - IDM_LOGWINDOW + 1];
bool bFloatWindow[IDM_CODE_WINDOW - IDM_LOG_WINDOW + 1];
// Perspectives (Should find a way to make all of this private)
void DoAddPage(wxWindow *Win, int i, bool Float);

78
Source/Core/DolphinWX/FrameAui.cpp
View File

@ -69,8 +69,8 @@ void CFrame::OnPaneClose(wxAuiManagerEvent& event)
if (!g_pCodeWindow)
{
if (nb->GetPage(0)->GetId() == IDM_LOGWINDOW ||
nb->GetPage(0)->GetId() == IDM_LOGCONFIGWINDOW)
if (nb->GetPage(0)->GetId() == IDM_LOG_WINDOW ||
nb->GetPage(0)->GetId() == IDM_LOG_CONFIG_WINDOW)
{
SConfig::GetInstance().m_InterfaceLogWindow = false;
@ -107,14 +107,14 @@ void CFrame::ToggleLogWindow(bool bShow)
if (!m_LogWindow)
return;
GetMenuBar()->FindItem(IDM_LOGWINDOW)->Check(bShow);
GetMenuBar()->FindItem(IDM_LOG_WINDOW)->Check(bShow);
if (bShow)
{
// Create a new log window if it doesn't exist.
if (!m_LogWindow)
{
m_LogWindow = new CLogWindow(this, IDM_LOGWINDOW);
m_LogWindow = new CLogWindow(this, IDM_LOG_WINDOW);
}
m_LogWindow->Enable();
@ -137,14 +137,14 @@ void CFrame::ToggleLogWindow(bool bShow)
void CFrame::ToggleLogConfigWindow(bool bShow)
{
GetMenuBar()->FindItem(IDM_LOGCONFIGWINDOW)->Check(bShow);
GetMenuBar()->FindItem(IDM_LOG_CONFIG_WINDOW)->Check(bShow);
if (bShow)
{
if (!m_LogConfigWindow)
m_LogConfigWindow = new LogConfigWindow(this, m_LogWindow, IDM_LOGCONFIGWINDOW);
m_LogConfigWindow = new LogConfigWindow(this, m_LogWindow, IDM_LOG_CONFIG_WINDOW);
const int nbIndex = IDM_LOGCONFIGWINDOW - IDM_LOGWINDOW;
const int nbIndex = IDM_LOG_CONFIG_WINDOW - IDM_LOG_WINDOW;
DoAddPage(m_LogConfigWindow,
g_pCodeWindow ? g_pCodeWindow->iNbAffiliation[nbIndex] : 0,
g_pCodeWindow ? bFloatWindow[nbIndex] : false);
@ -166,35 +166,35 @@ void CFrame::OnToggleWindow(wxCommandEvent& event)
switch (event.GetId())
{
case IDM_LOGWINDOW:
case IDM_LOG_WINDOW:
if (!g_pCodeWindow)
SConfig::GetInstance().m_InterfaceLogWindow = bShow;
ToggleLogWindow(bShow);
break;
case IDM_LOGCONFIGWINDOW:
case IDM_LOG_CONFIG_WINDOW:
if (!g_pCodeWindow)
SConfig::GetInstance().m_InterfaceLogConfigWindow = bShow;
ToggleLogConfigWindow(bShow);
break;
case IDM_REGISTERWINDOW:
case IDM_REGISTER_WINDOW:
g_pCodeWindow->ToggleRegisterWindow(bShow);
break;
case IDM_WATCHWINDOW:
case IDM_WATCH_WINDOW:
g_pCodeWindow->ToggleWatchWindow(bShow);
break;
case IDM_BREAKPOINTWINDOW:
case IDM_BREAKPOINT_WINDOW:
g_pCodeWindow->ToggleBreakPointWindow(bShow);
break;
case IDM_MEMORYWINDOW:
case IDM_MEMORY_WINDOW:
g_pCodeWindow->ToggleMemoryWindow(bShow);
break;
case IDM_JITWINDOW:
case IDM_JIT_WINDOW:
g_pCodeWindow->ToggleJitWindow(bShow);
break;
case IDM_SOUNDWINDOW:
case IDM_SOUND_WINDOW:
g_pCodeWindow->ToggleSoundWindow(bShow);
break;
case IDM_VIDEOWINDOW:
case IDM_VIDEO_WINDOW:
g_pCodeWindow->ToggleVideoWindow(bShow);
break;
}
@ -231,10 +231,10 @@ void CFrame::OnNotebookPageChanged(wxAuiNotebookEvent& event)
AddRemoveBlankPage();
// Update the notebook affiliation
for (int i = IDM_LOGWINDOW; i <= IDM_CODEWINDOW; i++)
for (int i = IDM_LOG_WINDOW; i <= IDM_CODE_WINDOW; i++)
{
if (GetNotebookAffiliation(i) >= 0)
g_pCodeWindow->iNbAffiliation[i - IDM_LOGWINDOW] = GetNotebookAffiliation(i);
g_pCodeWindow->iNbAffiliation[i - IDM_LOG_WINDOW] = GetNotebookAffiliation(i);
}
}
@ -245,29 +245,29 @@ void CFrame::OnNotebookPageClose(wxAuiNotebookEvent& event)
wxAuiNotebook* Ctrl = (wxAuiNotebook*)event.GetEventObject();
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_LOGWINDOW)
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_LOG_WINDOW)
ToggleLogWindow(false);
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_LOGCONFIGWINDOW)
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_LOG_CONFIG_WINDOW)
ToggleLogConfigWindow(false);
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_REGISTERWINDOW)
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_REGISTER_WINDOW)
g_pCodeWindow->ToggleRegisterWindow(false);
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_WATCHWINDOW)
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_WATCH_WINDOW)
g_pCodeWindow->ToggleWatchWindow(false);
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_BREAKPOINTWINDOW)
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_BREAKPOINT_WINDOW)
g_pCodeWindow->ToggleBreakPointWindow(false);
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_JITWINDOW)
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_JIT_WINDOW)
g_pCodeWindow->ToggleJitWindow(false);
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_MEMORYWINDOW)
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_MEMORY_WINDOW)
g_pCodeWindow->ToggleMemoryWindow(false);
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_SOUNDWINDOW)
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_SOUND_WINDOW)
g_pCodeWindow->ToggleSoundWindow(false);
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_VIDEOWINDOW)
if (Ctrl->GetPage(event.GetSelection())->GetId() == IDM_VIDEO_WINDOW)
g_pCodeWindow->ToggleVideoWindow(false);
}
void CFrame::OnFloatingPageClosed(wxCloseEvent& event)
{
ToggleFloatWindow(event.GetId() - IDM_LOGWINDOW_PARENT + IDM_FLOAT_LOGWINDOW);
ToggleFloatWindow(event.GetId() - IDM_LOG_WINDOW_PARENT + IDM_FLOAT_LOG_WINDOW);
}
void CFrame::OnFloatingPageSize(wxSizeEvent& event)
@ -282,17 +282,17 @@ void CFrame::OnFloatWindow(wxCommandEvent& event)
void CFrame::ToggleFloatWindow(int Id)
{
wxWindowID WinId = Id - IDM_FLOAT_LOGWINDOW + IDM_LOGWINDOW;
wxWindowID WinId = Id - IDM_FLOAT_LOG_WINDOW + IDM_LOG_WINDOW;
if (GetNotebookPageFromId(WinId))
{
DoFloatNotebookPage(WinId);
bFloatWindow[WinId - IDM_LOGWINDOW] = true;
bFloatWindow[WinId - IDM_LOG_WINDOW] = true;
}
else
{
if (FindWindowById(WinId))
DoUnfloatPage(WinId - IDM_LOGWINDOW + IDM_LOGWINDOW_PARENT);
bFloatWindow[WinId - IDM_LOGWINDOW] = false;
DoUnfloatPage(WinId - IDM_LOG_WINDOW + IDM_LOG_WINDOW_PARENT);
bFloatWindow[WinId - IDM_LOG_WINDOW] = false;
}
}
@ -308,7 +308,7 @@ void CFrame::DoFloatNotebookPage(wxWindowID Id)
{
nb->RemovePage(nb->GetPageIndex(Win));
// Create the parent frame and reparent the window
CreateParentFrame(Win->GetId() + IDM_LOGWINDOW_PARENT - IDM_LOGWINDOW,
CreateParentFrame(Win->GetId() + IDM_LOG_WINDOW_PARENT - IDM_LOG_WINDOW,
Win->GetName(), Win);
if (nb->GetPageCount() == 0)
AddRemoveBlankPage();
@ -323,7 +323,7 @@ void CFrame::DoUnfloatPage(int Id)
wxWindow * Child = Win->GetChildren().Item(0)->GetData();
Child->Reparent(this);
DoAddPage(Child, g_pCodeWindow->iNbAffiliation[Child->GetId() - IDM_LOGWINDOW], false);
DoAddPage(Child, g_pCodeWindow->iNbAffiliation[Child->GetId() - IDM_LOG_WINDOW], false);
Win->Destroy();
}
@ -340,15 +340,15 @@ void CFrame::OnTab(wxAuiNotebookEvent& event)
Item->Enable(false);
MenuPopup.Append(new wxMenuItem(&MenuPopup));
for (int i = IDM_LOGWINDOW; i <= IDM_CODEWINDOW; i++)
for (int i = IDM_LOG_WINDOW; i <= IDM_CODE_WINDOW; i++)
{
wxWindow *Win = FindWindowById(i);
if (Win && Win->IsEnabled())
{
Item = new wxMenuItem(&MenuPopup, i + IDM_FLOAT_LOGWINDOW - IDM_LOGWINDOW,
Item = new wxMenuItem(&MenuPopup, i + IDM_FLOAT_LOG_WINDOW - IDM_LOG_WINDOW,
Win->GetName(), "", wxITEM_CHECK);
MenuPopup.Append(Item);
Item->Check(!!FindWindowById(i + IDM_LOGWINDOW_PARENT - IDM_LOGWINDOW));
Item->Check(!!FindWindowById(i + IDM_LOG_WINDOW_PARENT - IDM_LOG_WINDOW));
}
}
@ -421,7 +421,7 @@ void CFrame::DoRemovePage(wxWindow *Win, bool bHide)
if (!Win) return;
wxWindow *Parent = FindWindowById(Win->GetId() +
IDM_LOGWINDOW_PARENT - IDM_LOGWINDOW);
IDM_LOG_WINDOW_PARENT - IDM_LOG_WINDOW);
if (Parent)
{
@ -477,7 +477,7 @@ void CFrame::DoAddPage(wxWindow *Win, int i, bool Float)
if (!Float)
GetNotebookFromId(i)->AddPage(Win, Win->GetName(), true);
else
CreateParentFrame(Win->GetId() + IDM_LOGWINDOW_PARENT - IDM_LOGWINDOW,
CreateParentFrame(Win->GetId() + IDM_LOG_WINDOW_PARENT - IDM_LOG_WINDOW,
Win->GetName(), Win);
}

250
Source/Core/DolphinWX/FrameTools.cpp
View File

@ -135,7 +135,7 @@ wxMenuBar* CFrame::CreateMenu()
// file menu
wxMenu* fileMenu = new wxMenu;
fileMenu->Append(wxID_OPEN, GetMenuLabel(HK_OPEN));
fileMenu->Append(IDM_CHANGEDISC, GetMenuLabel(HK_CHANGE_DISC));
fileMenu->Append(IDM_CHANGE_DISC, GetMenuLabel(HK_CHANGE_DISC));
wxMenu *externalDrive = new wxMenu;
fileMenu->Append(IDM_DRIVES, _("&Boot from DVD Drive..."), externalDrive);
@ -167,8 +167,8 @@ wxMenuBar* CFrame::CreateMenu()
wxMenu *skippingMenu = new wxMenu;
emulationMenu->AppendSubMenu(skippingMenu, _("Frame S&kipping"));
for (int i = 0; i < 10; i++)
skippingMenu->Append(IDM_FRAMESKIP0 + i, wxString::Format("%i", i), wxEmptyString, wxITEM_RADIO);
skippingMenu->Check(IDM_FRAMESKIP0 + SConfig::GetInstance().m_FrameSkip, true);
skippingMenu->Append(IDM_FRAME_SKIP_0 + i, wxString::Format("%i", i), wxEmptyString, wxITEM_RADIO);
skippingMenu->Check(IDM_FRAME_SKIP_0 + SConfig::GetInstance().m_FrameSkip, true);
Movie::SetFrameSkipping(SConfig::GetInstance().m_FrameSkip);
emulationMenu->AppendSeparator();
@ -178,56 +178,56 @@ wxMenuBar* CFrame::CreateMenu()
wxMenu *saveMenu = new wxMenu;
wxMenu *loadMenu = new wxMenu;
wxMenu *slotSelectMenu = new wxMenu;
emulationMenu->Append(IDM_LOADSTATE, _("&Load State"), loadMenu);
emulationMenu->Append(IDM_SAVESTATE, _("Sa&ve State"), saveMenu);
emulationMenu->Append(IDM_SELECTSLOT, _("Select State slot"), slotSelectMenu);
emulationMenu->Append(IDM_LOAD_STATE, _("&Load State"), loadMenu);
emulationMenu->Append(IDM_SAVE_STATE, _("Sa&ve State"), saveMenu);
emulationMenu->Append(IDM_SELECT_SLOT, _("Select State slot"), slotSelectMenu);
saveMenu->Append(IDM_SAVESTATEFILE, GetMenuLabel(HK_SAVE_STATE_FILE));
saveMenu->Append(IDM_SAVESELECTEDSLOT, GetMenuLabel(HK_SAVE_STATE_SLOT_SELECTED));
saveMenu->Append(IDM_SAVEFIRSTSTATE, GetMenuLabel(HK_SAVE_FIRST_STATE));
loadMenu->Append(IDM_UNDOSAVESTATE, GetMenuLabel(HK_UNDO_SAVE_STATE));
saveMenu->Append(IDM_SAVE_STATE_FILE, GetMenuLabel(HK_SAVE_STATE_FILE));
saveMenu->Append(IDM_SAVE_SELECTED_SLOT, GetMenuLabel(HK_SAVE_STATE_SLOT_SELECTED));
saveMenu->Append(IDM_SAVE_FIRST_STATE, GetMenuLabel(HK_SAVE_FIRST_STATE));
loadMenu->Append(IDM_UNDO_SAVE_STATE, GetMenuLabel(HK_UNDO_SAVE_STATE));
saveMenu->AppendSeparator();
loadMenu->Append(IDM_LOADSTATEFILE, GetMenuLabel(HK_LOAD_STATE_FILE));
loadMenu->Append(IDM_LOADSELECTEDSLOT, GetMenuLabel(HK_LOAD_STATE_SLOT_SELECTED));
loadMenu->Append(IDM_UNDOLOADSTATE, GetMenuLabel(HK_UNDO_LOAD_STATE));
loadMenu->Append(IDM_LOAD_STATE_FILE, GetMenuLabel(HK_LOAD_STATE_FILE));
loadMenu->Append(IDM_LOAD_SELECTED_SLOT, GetMenuLabel(HK_LOAD_STATE_SLOT_SELECTED));
loadMenu->Append(IDM_UNDO_LOAD_STATE, GetMenuLabel(HK_UNDO_LOAD_STATE));
loadMenu->AppendSeparator();
for (unsigned int i = 1; i <= State::NUM_STATES; i++)
{
loadMenu->Append(IDM_LOADSLOT1 + i - 1, GetMenuLabel(HK_LOAD_STATE_SLOT_1 + i - 1));
saveMenu->Append(IDM_SAVESLOT1 + i - 1, GetMenuLabel(HK_SAVE_STATE_SLOT_1 + i - 1));
slotSelectMenu->Append(IDM_SELECTSLOT1 + i - 1, GetMenuLabel(HK_SELECT_STATE_SLOT_1 + i -1));
loadMenu->Append(IDM_LOAD_SLOT_1 + i - 1, GetMenuLabel(HK_LOAD_STATE_SLOT_1 + i - 1));
saveMenu->Append(IDM_SAVE_SLOT_1 + i - 1, GetMenuLabel(HK_SAVE_STATE_SLOT_1 + i - 1));
slotSelectMenu->Append(IDM_SELECT_SLOT_1 + i - 1, GetMenuLabel(HK_SELECT_STATE_SLOT_1 + i -1));
}
loadMenu->AppendSeparator();
for (unsigned int i = 1; i <= State::NUM_STATES; i++)
loadMenu->Append(IDM_LOADLAST1 + i - 1, GetMenuLabel(HK_LOAD_LAST_STATE_1 + i - 1));
loadMenu->Append(IDM_LOAD_LAST_1 + i - 1, GetMenuLabel(HK_LOAD_LAST_STATE_1 + i - 1));
menubar->Append(emulationMenu, _("&Emulation"));
// Movie menu
wxMenu* movieMenu = new wxMenu;
movieMenu->Append(IDM_RECORD, GetMenuLabel(HK_START_RECORDING));
movieMenu->Append(IDM_PLAYRECORD, GetMenuLabel(HK_PLAY_RECORDING));
movieMenu->Append(IDM_RECORDEXPORT, GetMenuLabel(HK_EXPORT_RECORDING));
movieMenu->Append(IDM_RECORDREADONLY, GetMenuLabel(HK_READ_ONLY_MODE), wxEmptyString, wxITEM_CHECK);
movieMenu->Append(IDM_TASINPUT, _("TAS Input"));
movieMenu->Append(IDM_PLAY_RECORD, GetMenuLabel(HK_PLAY_RECORDING));
movieMenu->Append(IDM_RECORD_EXPORT, GetMenuLabel(HK_EXPORT_RECORDING));
movieMenu->Append(IDM_RECORD_READ_ONLY, GetMenuLabel(HK_READ_ONLY_MODE), wxEmptyString, wxITEM_CHECK);
movieMenu->Append(IDM_TAS_INPUT, _("TAS Input"));
movieMenu->AppendSeparator();
movieMenu->AppendCheckItem(IDM_TOGGLE_PAUSEMOVIE, _("Pause at End of Movie"));
movieMenu->Check(IDM_TOGGLE_PAUSEMOVIE, SConfig::GetInstance().m_PauseMovie);
movieMenu->AppendCheckItem(IDM_SHOWLAG, _("Show Lag Counter"));
movieMenu->Check(IDM_SHOWLAG, SConfig::GetInstance().m_ShowLag);
movieMenu->AppendCheckItem(IDM_SHOWFRAMECOUNT, _("Show Frame Counter"));
movieMenu->Check(IDM_SHOWFRAMECOUNT, SConfig::GetInstance().m_ShowFrameCount);
movieMenu->Check(IDM_RECORDREADONLY, true);
movieMenu->AppendCheckItem(IDM_SHOWINPUTDISPLAY, _("Show Input Display"));
movieMenu->Check(IDM_SHOWINPUTDISPLAY, SConfig::GetInstance().m_ShowInputDisplay);
movieMenu->AppendCheckItem(IDM_TOGGLE_PAUSE_MOVIE, _("Pause at End of Movie"));
movieMenu->Check(IDM_TOGGLE_PAUSE_MOVIE, SConfig::GetInstance().m_PauseMovie);
movieMenu->AppendCheckItem(IDM_SHOW_LAG, _("Show Lag Counter"));
movieMenu->Check(IDM_SHOW_LAG, SConfig::GetInstance().m_ShowLag);
movieMenu->AppendCheckItem(IDM_SHOW_FRAME_COUNT, _("Show Frame Counter"));
movieMenu->Check(IDM_SHOW_FRAME_COUNT, SConfig::GetInstance().m_ShowFrameCount);
movieMenu->Check(IDM_RECORD_READ_ONLY, true);
movieMenu->AppendCheckItem(IDM_SHOW_INPUT_DISPLAY, _("Show Input Display"));
movieMenu->Check(IDM_SHOW_INPUT_DISPLAY, SConfig::GetInstance().m_ShowInputDisplay);
movieMenu->AppendSeparator();
movieMenu->AppendCheckItem(IDM_TOGGLE_DUMPFRAMES, _("Dump Frames"));
movieMenu->Check(IDM_TOGGLE_DUMPFRAMES, SConfig::GetInstance().m_DumpFrames);
movieMenu->AppendCheckItem(IDM_TOGGLE_DUMPAUDIO, _("Dump Audio"));
movieMenu->Check(IDM_TOGGLE_DUMPAUDIO, SConfig::GetInstance().m_DumpAudio);
movieMenu->AppendCheckItem(IDM_TOGGLE_DUMP_FRAMES, _("Dump Frames"));
movieMenu->Check(IDM_TOGGLE_DUMP_FRAMES, SConfig::GetInstance().m_DumpFrames);
movieMenu->AppendCheckItem(IDM_TOGGLE_DUMP_AUDIO, _("Dump Audio"));
movieMenu->Check(IDM_TOGGLE_DUMP_AUDIO, SConfig::GetInstance().m_DumpAudio);
menubar->Append(movieMenu, _("&Movie"));
// Options menu
@ -248,13 +248,13 @@ wxMenuBar* CFrame::CreateMenu()
// Tools menu
wxMenu* toolsMenu = new wxMenu;
toolsMenu->Append(IDM_MEMCARD, _("&Memcard Manager (GC)"));
toolsMenu->Append(IDM_IMPORTSAVE, _("Import Wii Save"));
toolsMenu->Append(IDM_EXPORTALLSAVE, _("Export All Wii Saves"));
toolsMenu->Append(IDM_IMPORT_SAVE, _("Import Wii Save"));
toolsMenu->Append(IDM_EXPORT_ALL_SAVE, _("Export All Wii Saves"));
toolsMenu->Append(IDM_CHEATS, _("&Cheats Manager"));
toolsMenu->Append(IDM_NETPLAY, _("Start &NetPlay"));
toolsMenu->Append(IDM_MENU_INSTALLWAD, _("Install WAD"));
toolsMenu->Append(IDM_MENU_INSTALL_WAD, _("Install WAD"));
UpdateWiiMenuChoice(toolsMenu->Append(IDM_LOAD_WII_MENU, "Dummy string to keep wxw happy"));
toolsMenu->Append(IDM_FIFOPLAYER, _("Fifo Player"));
@ -277,13 +277,13 @@ wxMenuBar* CFrame::CreateMenu()
viewMenu->AppendCheckItem(IDM_TOGGLE_STATUSBAR, _("Show &Statusbar"));
viewMenu->Check(IDM_TOGGLE_STATUSBAR, SConfig::GetInstance().m_InterfaceStatusbar);
viewMenu->AppendSeparator();
viewMenu->AppendCheckItem(IDM_LOGWINDOW, _("Show &Log"));
viewMenu->AppendCheckItem(IDM_LOGCONFIGWINDOW, _("Show Log &Configuration"));
viewMenu->AppendCheckItem(IDM_LOG_WINDOW, _("Show &Log"));
viewMenu->AppendCheckItem(IDM_LOG_CONFIG_WINDOW, _("Show Log &Configuration"));
viewMenu->AppendSeparator();
if (g_pCodeWindow)
{
viewMenu->Check(IDM_LOGWINDOW, g_pCodeWindow->bShowOnStart[0]);
viewMenu->Check(IDM_LOG_WINDOW, g_pCodeWindow->bShowOnStart[0]);
const wxString MenuText[] = {
wxTRANSLATE("&Registers"),
@ -295,64 +295,64 @@ wxMenuBar* CFrame::CreateMenu()
wxTRANSLATE("&Video")
};
for (int i = IDM_REGISTERWINDOW; i <= IDM_VIDEOWINDOW; i++)
for (int i = IDM_REGISTER_WINDOW; i <= IDM_VIDEO_WINDOW; i++)
{
viewMenu->AppendCheckItem(i, wxGetTranslation(MenuText[i - IDM_REGISTERWINDOW]));
viewMenu->Check(i, g_pCodeWindow->bShowOnStart[i - IDM_LOGWINDOW]);
viewMenu->AppendCheckItem(i, wxGetTranslation(MenuText[i - IDM_REGISTER_WINDOW]));
viewMenu->Check(i, g_pCodeWindow->bShowOnStart[i - IDM_LOG_WINDOW]);
}
viewMenu->AppendSeparator();
}
else
{
viewMenu->Check(IDM_LOGWINDOW, SConfig::GetInstance().m_InterfaceLogWindow);
viewMenu->Check(IDM_LOGCONFIGWINDOW, SConfig::GetInstance().m_InterfaceLogConfigWindow);
viewMenu->Check(IDM_LOG_WINDOW, SConfig::GetInstance().m_InterfaceLogWindow);
viewMenu->Check(IDM_LOG_CONFIG_WINDOW, SConfig::GetInstance().m_InterfaceLogConfigWindow);
}
wxMenu *platformMenu = new wxMenu;
viewMenu->AppendSubMenu(platformMenu, _("Show Platforms"));
platformMenu->AppendCheckItem(IDM_LISTWII, _("Show Wii"));
platformMenu->Check(IDM_LISTWII, SConfig::GetInstance().m_ListWii);
platformMenu->AppendCheckItem(IDM_LISTGC, _("Show GameCube"));
platformMenu->Check(IDM_LISTGC, SConfig::GetInstance().m_ListGC);
platformMenu->AppendCheckItem(IDM_LISTWAD, _("Show Wad"));
platformMenu->Check(IDM_LISTWAD, SConfig::GetInstance().m_ListWad);
platformMenu->AppendCheckItem(IDM_LIST_WII, _("Show Wii"));
platformMenu->Check(IDM_LIST_WII, SConfig::GetInstance().m_ListWii);
platformMenu->AppendCheckItem(IDM_LIST_GC, _("Show GameCube"));
platformMenu->Check(IDM_LIST_GC, SConfig::GetInstance().m_ListGC);
platformMenu->AppendCheckItem(IDM_LIST_WAD, _("Show Wad"));
platformMenu->Check(IDM_LIST_WAD, SConfig::GetInstance().m_ListWad);
wxMenu *regionMenu = new wxMenu;
viewMenu->AppendSubMenu(regionMenu, _("Show Regions"));
regionMenu->AppendCheckItem(IDM_LISTJAP, _("Show JAP"));
regionMenu->Check(IDM_LISTJAP, SConfig::GetInstance().m_ListJap);
regionMenu->AppendCheckItem(IDM_LISTPAL, _("Show PAL"));
regionMenu->Check(IDM_LISTPAL, SConfig::GetInstance().m_ListPal);
regionMenu->AppendCheckItem(IDM_LISTUSA, _("Show USA"));
regionMenu->Check(IDM_LISTUSA, SConfig::GetInstance().m_ListUsa);
regionMenu->AppendCheckItem(IDM_LIST_JAP, _("Show JAP"));
regionMenu->Check(IDM_LIST_JAP, SConfig::GetInstance().m_ListJap);
regionMenu->AppendCheckItem(IDM_LIST_PAL, _("Show PAL"));
regionMenu->Check(IDM_LIST_PAL, SConfig::GetInstance().m_ListPal);
regionMenu->AppendCheckItem(IDM_LIST_USA, _("Show USA"));
regionMenu->Check(IDM_LIST_USA, SConfig::GetInstance().m_ListUsa);
regionMenu->AppendSeparator();
regionMenu->AppendCheckItem(IDM_LISTAUSTRALIA, _("Show Australia"));
regionMenu->Check(IDM_LISTAUSTRALIA, SConfig::GetInstance().m_ListAustralia);
regionMenu->AppendCheckItem(IDM_LISTFRANCE, _("Show France"));
regionMenu->Check(IDM_LISTFRANCE, SConfig::GetInstance().m_ListFrance);
regionMenu->AppendCheckItem(IDM_LISTGERMANY, _("Show Germany"));
regionMenu->Check(IDM_LISTGERMANY, SConfig::GetInstance().m_ListGermany);
regionMenu->AppendCheckItem(IDM_LISTINTERNATIONAL, _("Show International"));
regionMenu->Check(IDM_LISTINTERNATIONAL, SConfig::GetInstance().m_ListInternational);
regionMenu->AppendCheckItem(IDM_LISTITALY, _("Show Italy"));
regionMenu->Check(IDM_LISTITALY, SConfig::GetInstance().m_ListItaly);
regionMenu->AppendCheckItem(IDM_LISTKOREA, _("Show Korea"));
regionMenu->Check(IDM_LISTKOREA, SConfig::GetInstance().m_ListKorea);
regionMenu->AppendCheckItem(IDM_LISTNETHERLANDS, _("Show Netherlands"));
regionMenu->Check(IDM_LISTNETHERLANDS, SConfig::GetInstance().m_ListNetherlands);
regionMenu->AppendCheckItem(IDM_LISTRUSSIA, _("Show Russia"));
regionMenu->Check(IDM_LISTRUSSIA, SConfig::GetInstance().m_ListRussia);
regionMenu->AppendCheckItem(IDM_LISTSPAIN, _("Show Spain"));
regionMenu->Check(IDM_LISTSPAIN, SConfig::GetInstance().m_ListSpain);
regionMenu->AppendCheckItem(IDM_LISTTAIWAN, _("Show Taiwan"));
regionMenu->Check(IDM_LISTTAIWAN, SConfig::GetInstance().m_ListTaiwan);
regionMenu->AppendCheckItem(IDM_LIST_UNK, _("Show Unknown"));
regionMenu->Check(IDM_LIST_UNK, SConfig::GetInstance().m_ListUnknown);
regionMenu->AppendCheckItem(IDM_LIST_AUSTRALIA, _("Show Australia"));
regionMenu->Check(IDM_LIST_AUSTRALIA, SConfig::GetInstance().m_ListAustralia);
regionMenu->AppendCheckItem(IDM_LIST_FRANCE, _("Show France"));
regionMenu->Check(IDM_LIST_FRANCE, SConfig::GetInstance().m_ListFrance);
regionMenu->AppendCheckItem(IDM_LIST_GERMANY, _("Show Germany"));
regionMenu->Check(IDM_LIST_GERMANY, SConfig::GetInstance().m_ListGermany);
regionMenu->AppendCheckItem(IDM_LIST_INTERNATIONAL, _("Show International"));
regionMenu->Check(IDM_LIST_INTERNATIONAL, SConfig::GetInstance().m_ListInternational);
regionMenu->AppendCheckItem(IDM_LIST_ITALY, _("Show Italy"));
regionMenu->Check(IDM_LIST_ITALY, SConfig::GetInstance().m_ListItaly);
regionMenu->AppendCheckItem(IDM_LIST_KOREA, _("Show Korea"));
regionMenu->Check(IDM_LIST_KOREA, SConfig::GetInstance().m_ListKorea);
regionMenu->AppendCheckItem(IDM_LIST_NETHERLANDS, _("Show Netherlands"));
regionMenu->Check(IDM_LIST_NETHERLANDS, SConfig::GetInstance().m_ListNetherlands);
regionMenu->AppendCheckItem(IDM_LIST_RUSSIA, _("Show Russia"));
regionMenu->Check(IDM_LIST_RUSSIA, SConfig::GetInstance().m_ListRussia);
regionMenu->AppendCheckItem(IDM_LIST_SPAIN, _("Show Spain"));
regionMenu->Check(IDM_LIST_SPAIN, SConfig::GetInstance().m_ListSpain);
regionMenu->AppendCheckItem(IDM_LIST_TAIWAN, _("Show Taiwan"));
regionMenu->Check(IDM_LIST_TAIWAN, SConfig::GetInstance().m_ListTaiwan);
regionMenu->AppendCheckItem(IDM_LIST_UNKNOWN, _("Show Unknown"));
regionMenu->Check(IDM_LIST_UNKNOWN, SConfig::GetInstance().m_ListUnknown);
viewMenu->AppendCheckItem(IDM_LISTDRIVES, _("Show Drives"));
viewMenu->Check(IDM_LISTDRIVES, SConfig::GetInstance().m_ListDrives);
viewMenu->Append(IDM_PURGECACHE, _("Purge Cache"));
viewMenu->AppendCheckItem(IDM_LIST_DRIVES, _("Show Drives"));
viewMenu->Check(IDM_LIST_DRIVES, SConfig::GetInstance().m_ListDrives);
viewMenu->Append(IDM_PURGE_CACHE, _("Purge Cache"));
wxMenu *columnsMenu = new wxMenu;
viewMenu->AppendSubMenu(columnsMenu, _("Select Columns"));
@ -384,9 +384,9 @@ wxMenuBar* CFrame::CreateMenu()
wxMenu* helpMenu = new wxMenu;
// Re-enable when there's something useful to display */
// helpMenu->Append(wxID_HELP, _("&Help"));
helpMenu->Append(IDM_HELPWEBSITE, _("Dolphin &Web Site"));
helpMenu->Append(IDM_HELPONLINEDOCS, _("Online &Documentation"));
helpMenu->Append(IDM_HELPGITHUB, _("Dolphin at &GitHub"));
helpMenu->Append(IDM_HELP_WEBSITE, _("Dolphin &Web Site"));
helpMenu->Append(IDM_HELP_ONLINE_DOCS, _("Online &Documentation"));
helpMenu->Append(IDM_HELP_GITHUB, _("Dolphin at &GitHub"));
helpMenu->AppendSeparator();
helpMenu->Append(wxID_ABOUT, _("&About..."));
menubar->Append(helpMenu, _("&Help"));
@ -810,7 +810,7 @@ void CFrame::OnRecord(wxCommandEvent& WXUNUSED (event))
{
// The user just chose to record a movie, so that should take precedence
Movie::SetReadOnly(false);
GetMenuBar()->FindItem(IDM_RECORDREADONLY)->Check(false);
GetMenuBar()->FindItem(IDM_RECORD_READ_ONLY)->Check(false);
}
for (int i = 0; i < 4; i++)
@ -843,7 +843,7 @@ void CFrame::OnPlayRecording(wxCommandEvent& WXUNUSED (event))
{
// let's make the read-only flag consistent at the start of a movie.
Movie::SetReadOnly(true);
GetMenuBar()->FindItem(IDM_RECORDREADONLY)->Check(true);
GetMenuBar()->FindItem(IDM_RECORD_READ_ONLY)->Check(true);
}
if (Movie::PlayInput(WxStrToStr(path)))
@ -1369,13 +1369,13 @@ void CFrame::OnHelp(wxCommandEvent& event)
frame.ShowModal();
}
break;
case IDM_HELPWEBSITE:
case IDM_HELP_WEBSITE:
WxUtils::Launch("https://dolphin-emu.org/");
break;
case IDM_HELPONLINEDOCS:
case IDM_HELP_ONLINE_DOCS:
WxUtils::Launch("https://dolphin-emu.org/docs/guides/");
break;
case IDM_HELPGITHUB:
case IDM_HELP_GITHUB:
WxUtils::Launch("https://github.com/dolphin-emu/dolphin/");
break;
}
@ -1467,7 +1467,7 @@ void CFrame::OnInstallWAD(wxCommandEvent& event)
switch (event.GetId())
{
case IDM_LIST_INSTALLWAD:
case IDM_LIST_INSTALL_WAD:
{
const GameListItem *iso = m_GameListCtrl->GetSelectedISO();
if (!iso)
@ -1475,7 +1475,7 @@ void CFrame::OnInstallWAD(wxCommandEvent& event)
fileName = iso->GetFileName();
break;
}
case IDM_MENU_INSTALLWAD:
case IDM_MENU_INSTALL_WAD:
{
wxString path = wxFileSelector(
_("Select a Wii WAD file to install"),
@ -1611,7 +1611,7 @@ void CFrame::OnLoadLastState(wxCommandEvent& event)
if (Core::IsRunningAndStarted())
{
int id = event.GetId();
int slot = id - IDM_LOADLAST1 + 1;
int slot = id - IDM_LOAD_LAST_1 + 1;
State::LoadLastSaved(slot);
}
}
@ -1640,7 +1640,7 @@ void CFrame::OnLoadState(wxCommandEvent& event)
if (Core::IsRunningAndStarted())
{
int id = event.GetId();
int slot = id - IDM_LOADSLOT1 + 1;
int slot = id - IDM_LOAD_SLOT_1 + 1;
State::Load(slot);
}
}
@ -1650,14 +1650,14 @@ void CFrame::OnSaveState(wxCommandEvent& event)
if (Core::IsRunningAndStarted())
{
int id = event.GetId();
int slot = id - IDM_SAVESLOT1 + 1;
int slot = id - IDM_SAVE_SLOT_1 + 1;
State::Save(slot);
}
}
void CFrame::OnFrameSkip(wxCommandEvent& event)
{
int amount = event.GetId() - IDM_FRAMESKIP0;
int amount = event.GetId() - IDM_FRAME_SKIP_0;
Movie::SetFrameSkipping((unsigned int)amount);
SConfig::GetInstance().m_FrameSkip = amount;
@ -1665,7 +1665,7 @@ void CFrame::OnFrameSkip(wxCommandEvent& event)
void CFrame::OnSelectSlot(wxCommandEvent& event)
{
g_saveSlot = event.GetId() - IDM_SELECTSLOT1 + 1;
g_saveSlot = event.GetId() - IDM_SELECT_SLOT_1 + 1;
Core::DisplayMessage(StringFromFormat("Selected slot %d", g_saveSlot), 1000);
}
@ -1722,8 +1722,8 @@ void CFrame::UpdateGUI()
GetMenuBar()->FindItem(IDM_STOP)->Enable(Running || Paused);
GetMenuBar()->FindItem(IDM_RESET)->Enable(Running || Paused);
GetMenuBar()->FindItem(IDM_RECORD)->Enable(!Movie::IsRecordingInput());
GetMenuBar()->FindItem(IDM_PLAYRECORD)->Enable(!Initialized);
GetMenuBar()->FindItem(IDM_RECORDEXPORT)->Enable(Movie::IsMovieActive());
GetMenuBar()->FindItem(IDM_PLAY_RECORD)->Enable(!Initialized);
GetMenuBar()->FindItem(IDM_RECORD_EXPORT)->Enable(Movie::IsMovieActive());
GetMenuBar()->FindItem(IDM_FRAMESTEP)->Enable(Running || Paused);
GetMenuBar()->FindItem(IDM_SCREENSHOT)->Enable(Running || Paused);
GetMenuBar()->FindItem(IDM_TOGGLE_FULLSCREEN)->Enable(Running || Paused);
@ -1737,10 +1737,10 @@ void CFrame::UpdateGUI()
GetMenuBar()->FindItem(GetCmdForHotkey(i))->SetItemLabel(GetMenuLabel(i));
}
GetMenuBar()->FindItem(IDM_LOADSTATE)->Enable(Initialized);
GetMenuBar()->FindItem(IDM_SAVESTATE)->Enable(Initialized);
GetMenuBar()->FindItem(IDM_LOAD_STATE)->Enable(Initialized);
GetMenuBar()->FindItem(IDM_SAVE_STATE)->Enable(Initialized);
// Misc
GetMenuBar()->FindItem(IDM_CHANGEDISC)->Enable(Initialized);
GetMenuBar()->FindItem(IDM_CHANGE_DISC)->Enable(Initialized);
if (DiscIO::CNANDContentManager::Access().GetNANDLoader(TITLEID_SYSMENU).IsValid())
GetMenuBar()->FindItem(IDM_LOAD_WII_MENU)->Enable(!Initialized);
@ -1788,7 +1788,7 @@ void CFrame::UpdateGUI()
}
}
GetMenuBar()->FindItem(IDM_RECORDREADONLY)->Enable(Running || Paused);
GetMenuBar()->FindItem(IDM_RECORD_READ_ONLY)->Enable(Running || Paused);
if (!Initialized && !m_bGameLoading)
{
@ -1801,7 +1801,7 @@ void CFrame::UpdateGUI()
m_ToolBar->EnableTool(IDM_PLAY, true);
GetMenuBar()->FindItem(IDM_PLAY)->Enable(true);
GetMenuBar()->FindItem(IDM_RECORD)->Enable(true);
GetMenuBar()->FindItem(IDM_PLAYRECORD)->Enable(true);
GetMenuBar()->FindItem(IDM_PLAY_RECORD)->Enable(true);
}
// Prepare to load last selected file, enable play button
else if (!SConfig::GetInstance().m_LastFilename.empty() &&
@ -1811,7 +1811,7 @@ void CFrame::UpdateGUI()
m_ToolBar->EnableTool(IDM_PLAY, true);
GetMenuBar()->FindItem(IDM_PLAY)->Enable(true);
GetMenuBar()->FindItem(IDM_RECORD)->Enable(true);
GetMenuBar()->FindItem(IDM_PLAYRECORD)->Enable(true);
GetMenuBar()->FindItem(IDM_PLAY_RECORD)->Enable(true);
}
else
{
@ -1820,7 +1820,7 @@ void CFrame::UpdateGUI()
m_ToolBar->EnableTool(IDM_PLAY, false);
GetMenuBar()->FindItem(IDM_PLAY)->Enable(false);
GetMenuBar()->FindItem(IDM_RECORD)->Enable(false);
GetMenuBar()->FindItem(IDM_PLAYRECORD)->Enable(false);
GetMenuBar()->FindItem(IDM_PLAY_RECORD)->Enable(false);
}
}
@ -1837,7 +1837,7 @@ void CFrame::UpdateGUI()
m_ToolBar->EnableTool(IDM_PLAY, true);
GetMenuBar()->FindItem(IDM_PLAY)->Enable(true);
GetMenuBar()->FindItem(IDM_RECORD)->Enable(true);
GetMenuBar()->FindItem(IDM_PLAYRECORD)->Enable(true);
GetMenuBar()->FindItem(IDM_PLAY_RECORD)->Enable(true);
}
}
else if (Initialized)
@ -1879,58 +1879,58 @@ void CFrame::GameListChanged(wxCommandEvent& event)
{
switch (event.GetId())
{
case IDM_LISTWII:
case IDM_LIST_WII:
SConfig::GetInstance().m_ListWii = event.IsChecked();
break;
case IDM_LISTGC:
case IDM_LIST_GC:
SConfig::GetInstance().m_ListGC = event.IsChecked();
break;
case IDM_LISTWAD:
case IDM_LIST_WAD:
SConfig::GetInstance().m_ListWad = event.IsChecked();
break;
case IDM_LISTJAP:
case IDM_LIST_JAP:
SConfig::GetInstance().m_ListJap = event.IsChecked();
break;
case IDM_LISTPAL:
case IDM_LIST_PAL:
SConfig::GetInstance().m_ListPal = event.IsChecked();
break;
case IDM_LISTUSA:
case IDM_LIST_USA:
SConfig::GetInstance().m_ListUsa = event.IsChecked();
break;
case IDM_LISTAUSTRALIA:
case IDM_LIST_AUSTRALIA:
SConfig::GetInstance().m_ListAustralia = event.IsChecked();
break;
case IDM_LISTFRANCE:
case IDM_LIST_FRANCE:
SConfig::GetInstance().m_ListFrance = event.IsChecked();
break;
case IDM_LISTGERMANY:
case IDM_LIST_GERMANY:
SConfig::GetInstance().m_ListGermany = event.IsChecked();
break;
case IDM_LISTITALY:
case IDM_LIST_ITALY:
SConfig::GetInstance().m_ListItaly = event.IsChecked();
break;
case IDM_LISTKOREA:
case IDM_LIST_KOREA:
SConfig::GetInstance().m_ListKorea = event.IsChecked();
break;
case IDM_LISTNETHERLANDS:
case IDM_LIST_NETHERLANDS:
SConfig::GetInstance().m_ListNetherlands = event.IsChecked();
break;
case IDM_LISTRUSSIA:
case IDM_LIST_RUSSIA:
SConfig::GetInstance().m_ListRussia = event.IsChecked();
break;
case IDM_LISTSPAIN:
case IDM_LIST_SPAIN:
SConfig::GetInstance().m_ListSpain = event.IsChecked();
break;
case IDM_LISTTAIWAN:
case IDM_LIST_TAIWAN:
SConfig::GetInstance().m_ListTaiwan = event.IsChecked();
break;
case IDM_LIST_UNK:
case IDM_LIST_UNKNOWN:
SConfig::GetInstance().m_ListUnknown = event.IsChecked();
break;
case IDM_LISTDRIVES:
case IDM_LIST_DRIVES:
SConfig::GetInstance().m_ListDrives = event.IsChecked();
break;
case IDM_PURGECACHE:
case IDM_PURGE_CACHE:
CFileSearch::XStringVector Directories;
Directories.push_back(File::GetUserPath(D_CACHE_IDX));
CFileSearch::XStringVector Extensions;

48
Source/Core/DolphinWX/GameListCtrl.cpp
View File

@ -198,16 +198,16 @@ CGameListCtrl::CGameListCtrl(wxWindow* parent, const wxWindowID id, const
Bind(wxEVT_LIST_COL_CLICK, &CGameListCtrl::OnColumnClick, this);
Bind(wxEVT_MENU, &CGameListCtrl::OnProperties, this, IDM_PROPERTIES);
Bind(wxEVT_MENU, &CGameListCtrl::OnWiki, this, IDM_GAMEWIKI);
Bind(wxEVT_MENU, &CGameListCtrl::OnOpenContainingFolder, this, IDM_OPENCONTAININGFOLDER);
Bind(wxEVT_MENU, &CGameListCtrl::OnOpenSaveFolder, this, IDM_OPENSAVEFOLDER);
Bind(wxEVT_MENU, &CGameListCtrl::OnExportSave, this, IDM_EXPORTSAVE);
Bind(wxEVT_MENU, &CGameListCtrl::OnSetDefaultISO, this, IDM_SETDEFAULTISO);
Bind(wxEVT_MENU, &CGameListCtrl::OnCompressISO, this, IDM_COMPRESSISO);
Bind(wxEVT_MENU, &CGameListCtrl::OnMultiCompressISO, this, IDM_MULTICOMPRESSISO);
Bind(wxEVT_MENU, &CGameListCtrl::OnMultiDecompressISO, this, IDM_MULTIDECOMPRESSISO);
Bind(wxEVT_MENU, &CGameListCtrl::OnDeleteISO, this, IDM_DELETEISO);
Bind(wxEVT_MENU, &CGameListCtrl::OnChangeDisc, this, IDM_LIST_CHANGEDISC);
Bind(wxEVT_MENU, &CGameListCtrl::OnWiki, this, IDM_GAME_WIKI);
Bind(wxEVT_MENU, &CGameListCtrl::OnOpenContainingFolder, this, IDM_OPEN_CONTAINING_FOLDER);
Bind(wxEVT_MENU, &CGameListCtrl::OnOpenSaveFolder, this, IDM_OPEN_SAVE_FOLDER);
Bind(wxEVT_MENU, &CGameListCtrl::OnExportSave, this, IDM_EXPORT_SAVE);
Bind(wxEVT_MENU, &CGameListCtrl::OnSetDefaultISO, this, IDM_SET_DEFAULT_ISO);
Bind(wxEVT_MENU, &CGameListCtrl::OnCompressISO, this, IDM_COMPRESS_ISO);
Bind(wxEVT_MENU, &CGameListCtrl::OnMultiCompressISO, this, IDM_MULTI_COMPRESS_ISO);
Bind(wxEVT_MENU, &CGameListCtrl::OnMultiDecompressISO, this, IDM_MULTI_DECOMPRESS_ISO);
Bind(wxEVT_MENU, &CGameListCtrl::OnDeleteISO, this, IDM_DELETE_ISO);
Bind(wxEVT_MENU, &CGameListCtrl::OnChangeDisc, this, IDM_LIST_CHANGE_DISC);
}
CGameListCtrl::~CGameListCtrl()
@ -931,41 +931,41 @@ void CGameListCtrl::OnRightClick(wxMouseEvent& event)
{
wxMenu popupMenu;
popupMenu.Append(IDM_PROPERTIES, _("&Properties"));
popupMenu.Append(IDM_GAMEWIKI, _("&Wiki"));
popupMenu.Append(IDM_GAME_WIKI, _("&Wiki"));
popupMenu.AppendSeparator();
if (selected_iso->GetPlatform() != GameListItem::GAMECUBE_DISC)
{
popupMenu.Append(IDM_OPENSAVEFOLDER, _("Open Wii &save folder"));
popupMenu.Append(IDM_EXPORTSAVE, _("Export Wii save (Experimental)"));
popupMenu.Append(IDM_OPEN_SAVE_FOLDER, _("Open Wii &save folder"));
popupMenu.Append(IDM_EXPORT_SAVE, _("Export Wii save (Experimental)"));
}
popupMenu.Append(IDM_OPENCONTAININGFOLDER, _("Open &containing folder"));
popupMenu.AppendCheckItem(IDM_SETDEFAULTISO, _("Set as &default ISO"));
popupMenu.Append(IDM_OPEN_CONTAINING_FOLDER, _("Open &containing folder"));
popupMenu.AppendCheckItem(IDM_SET_DEFAULT_ISO, _("Set as &default ISO"));
// First we have to decide a starting value when we append it
if (selected_iso->GetFileName() == SConfig::GetInstance().
m_LocalCoreStartupParameter.m_strDefaultISO)
popupMenu.FindItem(IDM_SETDEFAULTISO)->Check();
popupMenu.FindItem(IDM_SET_DEFAULT_ISO)->Check();
popupMenu.AppendSeparator();
popupMenu.Append(IDM_DELETEISO, _("&Delete ISO..."));
popupMenu.Append(IDM_DELETE_ISO, _("&Delete ISO..."));
if (selected_iso->GetPlatform() != GameListItem::WII_WAD)
{
if (selected_iso->IsCompressed())
popupMenu.Append(IDM_COMPRESSISO, _("Decompress ISO..."));
popupMenu.Append(IDM_COMPRESS_ISO, _("Decompress ISO..."));
else if (selected_iso->GetFileName().substr(selected_iso->GetFileName().find_last_of(".")) != ".ciso" &&
selected_iso->GetFileName().substr(selected_iso->GetFileName().find_last_of(".")) != ".wbfs")
popupMenu.Append(IDM_COMPRESSISO, _("Compress ISO..."));
popupMenu.Append(IDM_COMPRESS_ISO, _("Compress ISO..."));
}
else
{
popupMenu.Append(IDM_LIST_INSTALLWAD, _("Install to Wii Menu"));
popupMenu.Append(IDM_LIST_INSTALL_WAD, _("Install to Wii Menu"));
}
if (selected_iso->GetPlatform() == GameListItem::GAMECUBE_DISC ||
selected_iso->GetPlatform() == GameListItem::WII_DISC)
{
wxMenuItem* changeDiscItem = popupMenu.Append(IDM_LIST_CHANGEDISC, _("Change &Disc"));
wxMenuItem* changeDiscItem = popupMenu.Append(IDM_LIST_CHANGE_DISC, _("Change &Disc"));
changeDiscItem->Enable(Core::IsRunning());
}
@ -975,10 +975,10 @@ void CGameListCtrl::OnRightClick(wxMouseEvent& event)
else if (GetSelectedItemCount() > 1)
{
wxMenu popupMenu;
popupMenu.Append(IDM_DELETEISO, _("&Delete selected ISOs..."));
popupMenu.Append(IDM_DELETE_ISO, _("&Delete selected ISOs..."));
popupMenu.AppendSeparator();
popupMenu.Append(IDM_MULTICOMPRESSISO, _("Compress selected ISOs..."));
popupMenu.Append(IDM_MULTIDECOMPRESSISO, _("Decompress selected ISOs..."));
popupMenu.Append(IDM_MULTI_COMPRESS_ISO, _("Compress selected ISOs..."));
popupMenu.Append(IDM_MULTI_DECOMPRESS_ISO, _("Decompress selected ISOs..."));
PopupMenu(&popupMenu);
}
}

338
Source/Core/DolphinWX/Globals.h
View File

@ -18,86 +18,86 @@ enum
Toolbar_Skip,
Toolbar_GotoPC,
Toolbar_SetPC,
ToolbarDebugBitmapMax
Toolbar_Debug_Bitmap_Max
};
enum
{
IDM_LOADSTATE = 200, // File menu
IDM_SAVESTATE,
IDM_SELECTSLOT,
IDM_SAVEFIRSTSTATE,
IDM_UNDOLOADSTATE,
IDM_UNDOSAVESTATE,
IDM_LOADSTATEFILE,
IDM_SAVESTATEFILE,
IDM_SAVESLOT1,
IDM_SAVESLOT2,
IDM_SAVESLOT3,
IDM_SAVESLOT4,
IDM_SAVESLOT5,
IDM_SAVESLOT6,
IDM_SAVESLOT7,
IDM_SAVESLOT8,
IDM_SAVESLOT9,
IDM_SAVESLOT10,
IDM_LOADSLOT1,
IDM_LOADSLOT2,
IDM_LOADSLOT3,
IDM_LOADSLOT4,
IDM_LOADSLOT5,
IDM_LOADSLOT6,
IDM_LOADSLOT7,
IDM_LOADSLOT8,
IDM_LOADSLOT9,
IDM_LOADSLOT10,
IDM_LOADLAST1,
IDM_LOADLAST2,
IDM_LOADLAST3,
IDM_LOADLAST4,
IDM_LOADLAST5,
IDM_LOADLAST6,
IDM_LOADLAST7,
IDM_LOADLAST8,
IDM_SELECTSLOT1,
IDM_SELECTSLOT2,
IDM_SELECTSLOT3,
IDM_SELECTSLOT4,
IDM_SELECTSLOT5,
IDM_SELECTSLOT6,
IDM_SELECTSLOT7,
IDM_SELECTSLOT8,
IDM_SELECTSLOT9,
IDM_SELECTSLOT10,
IDM_SAVESELECTEDSLOT,
IDM_LOADSELECTEDSLOT,
IDM_FRAMESKIP0,
IDM_FRAMESKIP1,
IDM_FRAMESKIP2,
IDM_FRAMESKIP3,
IDM_FRAMESKIP4,
IDM_FRAMESKIP5,
IDM_FRAMESKIP6,
IDM_FRAMESKIP7,
IDM_FRAMESKIP8,
IDM_FRAMESKIP9,
IDM_LOAD_STATE = 200, // File menu
IDM_SAVE_STATE,
IDM_SELECT_SLOT,
IDM_SAVE_FIRST_STATE,
IDM_UNDO_LOAD_STATE,
IDM_UNDO_SAVE_STATE,
IDM_LOAD_STATE_FILE,
IDM_SAVE_STATE_FILE,
IDM_SAVE_SLOT_1,
IDM_SAVE_SLOT_2,
IDM_SAVE_SLOT_3,
IDM_SAVE_SLOT_4,
IDM_SAVE_SLOT_5,
IDM_SAVE_SLOT_6,
IDM_SAVE_SLOT_7,
IDM_SAVE_SLOT_8,
IDM_SAVE_SLOT_9,
IDM_SAVE_SLOT_10,
IDM_LOAD_SLOT_1,
IDM_LOAD_SLOT_2,
IDM_LOAD_SLOT_3,
IDM_LOAD_SLOT_4,
IDM_LOAD_SLOT_5,
IDM_LOAD_SLOT_6,
IDM_LOAD_SLOT_7,
IDM_LOAD_SLOT_8,
IDM_LOAD_SLOT_9,
IDM_LOAD_SLOT_10,
IDM_LOAD_LAST_1,
IDM_LOAD_LAST_2,
IDM_LOAD_LAST_3,
IDM_LOAD_LAST_4,
IDM_LOAD_LAST_5,
IDM_LOAD_LAST_6,
IDM_LOAD_LAST_7,
IDM_LOAD_LAST_8,
IDM_SELECT_SLOT_1,
IDM_SELECT_SLOT_2,
IDM_SELECT_SLOT_3,
IDM_SELECT_SLOT_4,
IDM_SELECT_SLOT_5,
IDM_SELECT_SLOT_6,
IDM_SELECT_SLOT_7,
IDM_SELECT_SLOT_8,
IDM_SELECT_SLOT_9,
IDM_SELECT_SLOT_10,
IDM_SAVE_SELECTED_SLOT,
IDM_LOAD_SELECTED_SLOT,
IDM_FRAME_SKIP_0,
IDM_FRAME_SKIP_1,
IDM_FRAME_SKIP_2,
IDM_FRAME_SKIP_3,
IDM_FRAME_SKIP_4,
IDM_FRAME_SKIP_5,
IDM_FRAME_SKIP_6,
IDM_FRAME_SKIP_7,
IDM_FRAME_SKIP_8,
IDM_FRAME_SKIP_9,
IDM_PLAY,
IDM_STOP,
IDM_RESET,
IDM_TOGGLE_FULLSCREEN,
IDM_RECORD,
IDM_PLAYRECORD,
IDM_RECORDEXPORT,
IDM_RECORDREADONLY,
IDM_TASINPUT,
IDM_TOGGLE_PAUSEMOVIE,
IDM_SHOWLAG,
IDM_SHOWFRAMECOUNT,
IDM_SHOWINPUTDISPLAY,
IDM_PLAY_RECORD,
IDM_RECORD_EXPORT,
IDM_RECORD_READ_ONLY,
IDM_TAS_INPUT,
IDM_TOGGLE_PAUSE_MOVIE,
IDM_SHOW_LAG,
IDM_SHOW_FRAME_COUNT,
IDM_SHOW_INPUT_DISPLAY,
IDM_FRAMESTEP,
IDM_SCREENSHOT,
IDM_TOGGLE_DUMPFRAMES,
IDM_TOGGLE_DUMPAUDIO,
IDM_TOGGLE_DUMP_FRAMES,
IDM_TOGGLE_DUMP_AUDIO,
IDM_BROWSE,
IDM_DRIVES,
IDM_DRIVE1,
@ -107,13 +107,13 @@ enum
IDM_CHEATS,
IDM_NETPLAY,
IDM_RESTART,
IDM_CHANGEDISC,
IDM_LIST_CHANGEDISC,
IDM_CHANGE_DISC,
IDM_LIST_CHANGE_DISC,
IDM_PROPERTIES,
IDM_GAMEWIKI,
IDM_GAME_WIKI,
IDM_LOAD_WII_MENU,
IDM_MENU_INSTALLWAD,
IDM_LIST_INSTALLWAD,
IDM_MENU_INSTALL_WAD,
IDM_LIST_INSTALL_WAD,
IDM_FIFOPLAYER,
IDM_CONNECT_WIIMOTE1,
IDM_CONNECT_WIIMOTE2,
@ -121,29 +121,29 @@ enum
IDM_CONNECT_WIIMOTE4,
IDM_CONNECT_BALANCEBOARD,
IDM_LISTWAD,
IDM_LISTWII,
IDM_LISTGC,
IDM_LISTJAP,
IDM_LISTPAL,
IDM_LISTUSA,
IDM_LISTAUSTRALIA,
IDM_LISTFRANCE,
IDM_LISTGERMANY,
IDM_LISTINTERNATIONAL,
IDM_LISTITALY,
IDM_LISTKOREA,
IDM_LISTNETHERLANDS,
IDM_LISTRUSSIA,
IDM_LISTSPAIN,
IDM_LISTTAIWAN,
IDM_LIST_UNK,
IDM_LISTDRIVES,
IDM_PURGECACHE,
IDM_LIST_WAD,
IDM_LIST_WII,
IDM_LIST_GC,
IDM_LIST_JAP,
IDM_LIST_PAL,
IDM_LIST_USA,
IDM_LIST_AUSTRALIA,
IDM_LIST_FRANCE,
IDM_LIST_GERMANY,
IDM_LIST_INTERNATIONAL,
IDM_LIST_ITALY,
IDM_LIST_KOREA,
IDM_LIST_NETHERLANDS,
IDM_LIST_RUSSIA,
IDM_LIST_SPAIN,
IDM_LIST_TAIWAN,
IDM_LIST_UNKNOWN,
IDM_LIST_DRIVES,
IDM_PURGE_CACHE,
IDM_HELPWEBSITE, // Help menu
IDM_HELPONLINEDOCS,
IDM_HELPGITHUB,
IDM_HELP_WEBSITE, // Help menu
IDM_HELP_ONLINE_DOCS,
IDM_HELP_GITHUB,
IDM_CONFIG_GFX_BACKEND,
IDM_CONFIG_AUDIO,
@ -152,16 +152,16 @@ enum
IDM_CONFIG_LOGGER,
// Views
IDM_LOGWINDOW,
IDM_LOGCONFIGWINDOW,
IDM_REGISTERWINDOW,
IDM_WATCHWINDOW,
IDM_BREAKPOINTWINDOW,
IDM_MEMORYWINDOW,
IDM_JITWINDOW,
IDM_SOUNDWINDOW,
IDM_VIDEOWINDOW,
IDM_CODEWINDOW,
IDM_LOG_WINDOW,
IDM_LOG_CONFIG_WINDOW,
IDM_REGISTER_WINDOW,
IDM_WATCH_WINDOW,
IDM_BREAKPOINT_WINDOW,
IDM_MEMORY_WINDOW,
IDM_JIT_WINDOW,
IDM_SOUND_WINDOW,
IDM_VIDEO_WINDOW,
IDM_CODE_WINDOW,
// List Column Title Toggles
IDM_SHOW_SYSTEM,
@ -174,63 +174,63 @@ enum
// Float Window IDs
IDM_LOGWINDOW_PARENT,
IDM_LOGCONFIGWINDOW_PARENT,
IDM_REGISTERWINDOW_PARENT,
IDM_BREAKPOINTWINDOW_PARENT,
IDM_MEMORYWINDOW_PARENT,
IDM_JITWINDOW_PARENT,
IDM_SOUNDWINDOW_PARENT,
IDM_VIDEOWINDOW_PARENT,
IDM_CODEWINDOW_PARENT,
IDM_LOG_WINDOW_PARENT,
IDM_LOG_CONFIG_WINDOW_PARENT,
IDM_REGISTER_WINDOW_PARENT,
IDM_BREAKPOINT_WINDOW_PARENT,
IDM_MEMORY_WINDOW_PARENT,
IDM_JIT_WINDOW_PARENT,
IDM_SOUND_WINDOW_PARENT,
IDM_VIDEO_WINDOW_PARENT,
IDM_CODE_WINDOW_PARENT,
// Float popup menu IDs
IDM_FLOAT_LOGWINDOW,
IDM_FLOAT_LOGCONFIGWINDOW,
IDM_FLOAT_REGISTERWINDOW,
IDM_FLOAT_BREAKPOINTWINDOW,
IDM_FLOAT_MEMORYWINDOW,
IDM_FLOAT_JITWINDOW,
IDM_FLOAT_SOUNDWINDOW,
IDM_FLOAT_VIDEOWINDOW,
IDM_FLOAT_CODEWINDOW,
IDM_FLOAT_LOG_WINDOW,
IDM_FLOAT_LOG_CONFIG_WINDOW,
IDM_FLOAT_REGISTER_WINDOW,
IDM_FLOAT_BREAKPOINT_WINDOW,
IDM_FLOAT_MEMORY_WINDOW,
IDM_FLOAT_JIT_WINDOW,
IDM_FLOAT_SOUND_WINDOW,
IDM_FLOAT_VIDEO_WINDOW,
IDM_FLOAT_CODE_WINDOW,
// --------------------------------------------------------------
// Debugger Menu Entries
// --------------------
// CPU Mode
IDM_INTERPRETER,
IDM_AUTOMATICSTART, IDM_BOOTTOPAUSE,
IDM_JITNOBLOCKCACHE, IDM_JITNOBLOCKLINKING, // JIT
IDM_JITOFF,
IDM_JITLSOFF, IDM_JITLSLXZOFF, IDM_JITLSLWZOFF, IDM_JITLSLBZXOFF,
IDM_JITLSPOFF, IDM_JITLSFOFF,
IDM_JITIOFF,
IDM_JITFPOFF,
IDM_JITPOFF,
IDM_JITSROFF,
IDM_FONTPICKER,
IDM_AUTOMATIC_START, IDM_BOOT_TO_PAUSE,
IDM_JIT_NO_BLOCK_CACHE, IDM_JIT_NO_BLOCK_LINKING, // JIT
IDM_JIT_OFF,
IDM_JIT_LS_OFF, IDM_JIT_LSLXZ_OFF, IDM_JIT_LSLWZ_OFF, IDM_JIT_LSLBZX_OFF,
IDM_JIT_LSP_OFF, IDM_JIT_LSF_OFF,
IDM_JIT_I_OFF,
IDM_JIT_FP_OFF,
IDM_JIT_P_OFF,
IDM_JIT_SR_OFF,
IDM_FONT_PICKER,
// Symbols
IDM_CLEARSYMBOLS,
IDM_SCANFUNCTIONS,
IDM_LOADMAPFILE, IDM_LOADMAPFILEAS, IDM_LOADBADMAPFILE,
IDM_SAVEMAPFILE, IDM_SAVEMAPFILEWITHCODES, IDM_SAVEMAPFILEAS,
IDM_CREATESIGNATUREFILE,
IDM_APPENDSIGNATUREFILE,
IDM_COMBINESIGNATUREFILES,
IDM_CLEAR_SYMBOLS,
IDM_SCAN_FUNCTIONS,
IDM_LOAD_MAP_FILE, IDM_LOAD_MAP_FILE_AS, IDM_LOAD_BAD_MAP_FILE,
IDM_SAVEMAPFILE, IDM_SAVE_MAP_FILE_WITH_CODES, IDM_SAVE_MAP_FILE_AS,
IDM_CREATE_SIGNATURE_FILE,
IDM_APPEND_SIGNATURE_FILE,
IDM_COMBINE_SIGNATURE_FILES,
IDM_RENAME_SYMBOLS,
IDM_USESIGNATUREFILE,
IDM_PATCHHLEFUNCTIONS,
IDM_USE_SIGNATURE_FILE,
IDM_PATCH_HLE_FUNCTIONS,
// JIT
IDM_CLEARCODECACHE,
IDM_LOGINSTRUCTIONS,
IDM_SEARCHINSTRUCTION,
IDM_CLEAR_CODE_CACHE,
IDM_LOG_INSTRUCTIONS,
IDM_SEARCH_INSTRUCTION,
// Profiler
IDM_PROFILEBLOCKS,
IDM_WRITEPROFILE,
IDM_PROFILE_BLOCKS,
IDM_WRITE_PROFILE,
// --------------------------------------------------------------
// --------------------------------------------------------------
@ -257,33 +257,33 @@ enum
IDM_PERSPECTIVES_100 = IDM_PERSPECTIVES_0 + 100,
// --------------------------------------------------------------
IDM_TOGGLE_DUALCORE, // Other
IDM_TOGGLE_SKIPIDLE,
IDM_TOGGLE_DUAL_CORE, // Other
IDM_TOGGLE_SKIP_IDLE,
IDM_TOGGLE_TOOLBAR,
IDM_TOGGLE_STATUSBAR,
IDM_NOTIFYMAPLOADED,
IDM_OPENCONTAININGFOLDER,
IDM_OPENSAVEFOLDER,
IDM_EXPORTSAVE,
IDM_IMPORTSAVE,
IDM_EXPORTALLSAVE,
IDM_SETDEFAULTISO,
IDM_DELETEISO,
IDM_COMPRESSISO,
IDM_MULTICOMPRESSISO,
IDM_MULTIDECOMPRESSISO,
IDM_UPDATEDISASMDIALOG,
IDM_UPDATEGUI,
IDM_UPDATESTATUSBAR,
IDM_UPDATETITLE,
IDM_UPDATEBREAKPOINTS,
IDM_UPDATEJITPANE,
IDM_NOTIFY_MAP_LOADED,
IDM_OPEN_CONTAINING_FOLDER,
IDM_OPEN_SAVE_FOLDER,
IDM_EXPORT_SAVE,
IDM_IMPORT_SAVE,
IDM_EXPORT_ALL_SAVE,
IDM_SET_DEFAULT_ISO,
IDM_DELETE_ISO,
IDM_COMPRESS_ISO,
IDM_MULTI_COMPRESS_ISO,
IDM_MULTI_DECOMPRESS_ISO,
IDM_UPDATE_DISASM_DIALOG,
IDM_UPDATE_GUI,
IDM_UPDATE_STATUS_BAR,
IDM_UPDATE_TITLE,
IDM_UPDATE_BREAKPOINTS,
IDM_UPDATE_JIT_PANE,
IDM_PANIC,
IDM_KEYSTATE,
IDM_WINDOWSIZEREQUEST,
IDM_WINDOW_SIZE_REQUEST,
IDM_STOPPED,
IDM_HOST_MESSAGE,
IDM_FULLSCREENREQUEST,
IDM_FULLSCREEN_REQUEST,
IDM_MPANEL, ID_STATUSBAR,

14
Source/Core/DolphinWX/Main.cpp
View File

@ -470,7 +470,7 @@ void* Host_GetRenderHandle()
// wxPostEvent / wxAddPendingEvent is the solution.
void Host_NotifyMapLoaded()
{
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_NOTIFYMAPLOADED);
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_NOTIFY_MAP_LOADED);
main_frame->GetEventHandler()->AddPendingEvent(event);
if (main_frame->g_pCodeWindow)
@ -481,7 +481,7 @@ void Host_NotifyMapLoaded()
void Host_UpdateDisasmDialog()
{
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATEDISASMDIALOG);
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATE_DISASM_DIALOG);
main_frame->GetEventHandler()->AddPendingEvent(event);
if (main_frame->g_pCodeWindow)
@ -492,7 +492,7 @@ void Host_UpdateDisasmDialog()
void Host_UpdateMainFrame()
{
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATEGUI);
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATE_GUI);
main_frame->GetEventHandler()->AddPendingEvent(event);
if (main_frame->g_pCodeWindow)
@ -503,21 +503,21 @@ void Host_UpdateMainFrame()
void Host_UpdateTitle(const std::string& title)
{
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATETITLE);
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATE_TITLE);
event.SetString(StrToWxStr(title));
main_frame->GetEventHandler()->AddPendingEvent(event);
}
void Host_RequestRenderWindowSize(int width, int height)
{
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_WINDOWSIZEREQUEST);
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_WINDOW_SIZE_REQUEST);
event.SetClientData(new std::pair<int, int>(width, height));
main_frame->GetEventHandler()->AddPendingEvent(event);
}
void Host_RequestFullscreen(bool enable_fullscreen)
{
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_FULLSCREENREQUEST);
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_FULLSCREEN_REQUEST);
event.SetInt(enable_fullscreen ? 1 : 0);
main_frame->GetEventHandler()->AddPendingEvent(event);
}
@ -546,7 +546,7 @@ void Host_SetWiiMoteConnectionState(int _State)
return;
currentState = _State;
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATESTATUSBAR);
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATE_STATUS_BAR);
switch (_State)
{