diff --git a/Source/Core/DolphinWX/Debugger/CodeView.cpp b/Source/Core/DolphinWX/Debugger/CodeView.cpp
index 5d70d1f52a..1c36a551fe 100644
--- a/Source/Core/DolphinWX/Debugger/CodeView.cpp
+++ b/Source/Core/DolphinWX/Debugger/CodeView.cpp
@@ -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;
diff --git a/Source/Core/DolphinWX/Debugger/CodeWindow.cpp b/Source/Core/DolphinWX/Debugger/CodeWindow.cpp
index 822913d078..8d5137430e 100644
--- a/Source/Core/DolphinWX/Debugger/CodeWindow.cpp
+++ b/Source/Core/DolphinWX/Debugger/CodeWindow.cpp
@@ -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);
diff --git a/Source/Core/DolphinWX/Debugger/CodeWindow.h b/Source/Core/DolphinWX/Debugger/CodeWindow.h
index cdf82dcfb6..bbb501fec4 100644
--- a/Source/Core/DolphinWX/Debugger/CodeWindow.h
+++ b/Source/Core/DolphinWX/Debugger/CodeWindow.h
@@ -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);
diff --git a/Source/Core/DolphinWX/Debugger/CodeWindowFunctions.cpp b/Source/Core/DolphinWX/Debugger/CodeWindowFunctions.cpp
index 1bf48b523e..441c7688c5 100644
--- a/Source/Core/DolphinWX/Debugger/CodeWindowFunctions.cpp
+++ b/Source/Core/DolphinWX/Debugger/CodeWindowFunctions.cpp
@@ -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
 	{
diff --git a/Source/Core/DolphinWX/Debugger/JitWindow.cpp b/Source/Core/DolphinWX/Debugger/JitWindow.cpp
index 71a9840af4..909a86e77c 100644
--- a/Source/Core/DolphinWX/Debugger/JitWindow.cpp
+++ b/Source/Core/DolphinWX/Debugger/JitWindow.cpp
@@ -293,7 +293,7 @@ void CJitWindow::OnHostMessage(wxCommandEvent& event)
 {
 	switch (event.GetId())
 	{
-		case IDM_NOTIFYMAPLOADED:
+		case IDM_NOTIFY_MAP_LOADED:
 			//NotifyMapLoaded();
 			break;
 	}
diff --git a/Source/Core/DolphinWX/Debugger/MemoryView.cpp b/Source/Core/DolphinWX/Debugger/MemoryView.cpp
index 4f87ef7763..8595883949 100644
--- a/Source/Core/DolphinWX/Debugger/MemoryView.cpp
+++ b/Source/Core/DolphinWX/Debugger/MemoryView.cpp
@@ -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);
 	}
 
diff --git a/Source/Core/DolphinWX/Debugger/MemoryWindow.cpp b/Source/Core/DolphinWX/Debugger/MemoryWindow.cpp
index f4b127c67b..1e129d5770 100644
--- a/Source/Core/DolphinWX/Debugger/MemoryWindow.cpp
+++ b/Source/Core/DolphinWX/Debugger/MemoryWindow.cpp
@@ -239,7 +239,7 @@ void CMemoryWindow::OnHostMessage(wxCommandEvent& event)
 {
 	switch (event.GetId())
 	{
-		case IDM_NOTIFYMAPLOADED:
+		case IDM_NOTIFY_MAP_LOADED:
 			NotifyMapLoaded();
 			break;
 	}
diff --git a/Source/Core/DolphinWX/Frame.cpp b/Source/Core/DolphinWX/Frame.cpp
index 3a0712f495..ca9ed457c7 100644
--- a/Source/Core/DolphinWX/Frame.cpp
+++ b/Source/Core/DolphinWX/Frame.cpp
@@ -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();
 
@@ -684,20 +684,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);
@@ -705,7 +705,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);
@@ -863,22 +863,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();
 	}
@@ -905,16 +905,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;
@@ -925,55 +925,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;
@@ -995,7 +995,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);
 	}
 }
@@ -1150,7 +1150,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);
 				}
 			}
diff --git a/Source/Core/DolphinWX/Frame.h b/Source/Core/DolphinWX/Frame.h
index 94c54cbfef..07f52f6f02 100644
--- a/Source/Core/DolphinWX/Frame.h
+++ b/Source/Core/DolphinWX/Frame.h
@@ -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);
diff --git a/Source/Core/DolphinWX/FrameAui.cpp b/Source/Core/DolphinWX/FrameAui.cpp
index ab95432bd8..f08df2b805 100644
--- a/Source/Core/DolphinWX/FrameAui.cpp
+++ b/Source/Core/DolphinWX/FrameAui.cpp
@@ -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);
 }
 
diff --git a/Source/Core/DolphinWX/FrameTools.cpp b/Source/Core/DolphinWX/FrameTools.cpp
index 55c82d33e6..b13c08ab57 100644
--- a/Source/Core/DolphinWX/FrameTools.cpp
+++ b/Source/Core/DolphinWX/FrameTools.cpp
@@ -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;
diff --git a/Source/Core/DolphinWX/GameListCtrl.cpp b/Source/Core/DolphinWX/GameListCtrl.cpp
index 124c68b8f4..be4ff0ff97 100644
--- a/Source/Core/DolphinWX/GameListCtrl.cpp
+++ b/Source/Core/DolphinWX/GameListCtrl.cpp
@@ -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);
 	}
 }
diff --git a/Source/Core/DolphinWX/Globals.h b/Source/Core/DolphinWX/Globals.h
index 738464ef46..d95bb64bae 100644
--- a/Source/Core/DolphinWX/Globals.h
+++ b/Source/Core/DolphinWX/Globals.h
@@ -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,
 
diff --git a/Source/Core/DolphinWX/Main.cpp b/Source/Core/DolphinWX/Main.cpp
index 1a1378cb7a..b66fd93620 100644
--- a/Source/Core/DolphinWX/Main.cpp
+++ b/Source/Core/DolphinWX/Main.cpp
@@ -456,7 +456,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)
@@ -467,7 +467,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)
@@ -478,7 +478,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)
@@ -489,21 +489,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);
 }
@@ -532,7 +532,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)
 	{