Frame: Separate menu creation into individual functions

Keeps related menu items together based on top level menu. This will be
more convenient in the future when debugger menu bar item handling is
moved to CFrame, as it won't be a huge amount of code in one function.

This also makes it easier to locate menu bar code whenever it needs to be
changed.

1 files changed, 247 insertions, 219 deletions

diff --git a/Source/Core/DolphinWX/FrameTools.cpp b/Source/Core/DolphinWX/FrameTools.cpp
index 502380762e..273a3cc97b 100644
--- a/Source/Core/DolphinWX/FrameTools.cpp
+++ b/Source/Core/DolphinWX/FrameTools.cpp
@@ -101,156 +101,247 @@ const wxSize& CFrame::GetToolbarBitmapSize() const
 
 // Create menu items
 // ---------------------
-wxMenuBar* CFrame::CreateMenu()
+wxMenuBar* CFrame::CreateMenuBar()
 {
-  wxMenuBar* menubar = new wxMenuBar();
+  auto* const menu_bar = new wxMenuBar;
+  menu_bar->Append(CreateFileMenu(), _("&File"));
+  menu_bar->Append(CreateEmulationMenu(), _("&Emulation"));
+  menu_bar->Append(CreateMovieMenu(), _("&Movie"));
+  menu_bar->Append(CreateOptionsMenu(), _("&Options"));
+  menu_bar->Append(CreateToolsMenu(), _("&Tools"));
+  menu_bar->Append(CreateViewMenu(), _("&View"));
 
-  // file menu
-  wxMenu* fileMenu = new wxMenu;
-  fileMenu->Append(wxID_OPEN, GetMenuLabel(HK_OPEN));
-  fileMenu->Append(IDM_CHANGE_DISC, GetMenuLabel(HK_CHANGE_DISC));
+  if (g_pCodeWindow)
+  {
+    g_pCodeWindow->CreateMenu(SConfig::GetInstance(), menu_bar);
+  }
+
+  menu_bar->Append(CreateHelpMenu(), _("&Help"));
 
-  wxMenu* externalDrive = new wxMenu;
-  fileMenu->Append(IDM_DRIVES, _("&Boot from DVD Backup"), externalDrive);
+  return menu_bar;
+}
+
+wxMenu* CFrame::CreateFileMenu()
+{
+  auto* const external_drive_menu = new wxMenu;
 
   drives = cdio_get_devices();
   // Windows Limitation of 24 character drives
   for (unsigned int i = 0; i < drives.size() && i < 24; i++)
   {
-    externalDrive->Append(IDM_DRIVE1 + i, StrToWxStr(drives[i]));
-  }
-
-  fileMenu->AppendSeparator();
-  fileMenu->Append(wxID_REFRESH, GetMenuLabel(HK_REFRESH_LIST));
-  fileMenu->AppendSeparator();
-  fileMenu->Append(wxID_EXIT, _("E&xit") + wxString("\tAlt+F4"));
-  menubar->Append(fileMenu, _("&File"));
-
-  // Emulation menu
-  wxMenu* emulationMenu = new wxMenu;
-  emulationMenu->Append(IDM_PLAY, GetMenuLabel(HK_PLAY_PAUSE));
-  emulationMenu->Append(IDM_STOP, GetMenuLabel(HK_STOP));
-  emulationMenu->Append(IDM_RESET, GetMenuLabel(HK_RESET));
-  emulationMenu->AppendSeparator();
-  emulationMenu->Append(IDM_TOGGLE_FULLSCREEN, GetMenuLabel(HK_FULLSCREEN));
-  emulationMenu->Append(IDM_FRAMESTEP, GetMenuLabel(HK_FRAME_ADVANCE), wxEmptyString);
-
-  emulationMenu->AppendSeparator();
-  emulationMenu->Append(IDM_SCREENSHOT, GetMenuLabel(HK_SCREENSHOT));
-
-  emulationMenu->AppendSeparator();
-  wxMenu* saveMenu = new wxMenu;
-  wxMenu* loadMenu = new wxMenu;
-  wxMenu* slotSelectMenu = new wxMenu;
-  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_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));
-  saveMenu->Append(IDM_UNDO_SAVE_STATE, GetMenuLabel(HK_UNDO_SAVE_STATE));
-  saveMenu->AppendSeparator();
-
-  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 = 0; i < State::NUM_STATES; i++)
-  {
-    loadMenu->Append(IDM_LOAD_SLOT_1 + i, GetMenuLabel(HK_LOAD_STATE_SLOT_1 + i));
-    saveMenu->Append(IDM_SAVE_SLOT_1 + i, GetMenuLabel(HK_SAVE_STATE_SLOT_1 + i));
-    slotSelectMenu->Append(IDM_SELECT_SLOT_1 + i, GetMenuLabel(HK_SELECT_STATE_SLOT_1 + i));
+    external_drive_menu->Append(IDM_DRIVE1 + i, StrToWxStr(drives[i]));
   }
 
-  loadMenu->AppendSeparator();
-  for (unsigned int i = 0; i < State::NUM_STATES; i++)
-    loadMenu->Append(IDM_LOAD_LAST_1 + i, GetMenuLabel(HK_LOAD_LAST_STATE_1 + i));
-
-  menubar->Append(emulationMenu, _("&Emulation"));
-
-  // Movie menu
-  wxMenu* movieMenu = new wxMenu;
-  movieMenu->Append(IDM_RECORD, GetMenuLabel(HK_START_RECORDING));
-  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_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->AppendCheckItem(IDM_SHOW_RTC_DISPLAY, _("Show System Clock"));
-  movieMenu->Check(IDM_SHOW_RTC_DISPLAY, SConfig::GetInstance().m_ShowRTC);
-  movieMenu->AppendSeparator();
-  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
-  wxMenu* pOptionsMenu = new wxMenu;
-  pOptionsMenu->Append(wxID_PREFERENCES, _("Co&nfigure..."));
-  pOptionsMenu->AppendSeparator();
-  pOptionsMenu->Append(IDM_CONFIG_GFX_BACKEND, _("&Graphics Settings"));
-  pOptionsMenu->Append(IDM_CONFIG_AUDIO, _("&Audio Settings"));
-  pOptionsMenu->Append(IDM_CONFIG_CONTROLLERS, _("&Controller Settings"));
-  pOptionsMenu->Append(IDM_CONFIG_HOTKEYS, _("&Hotkey Settings"));
-  if (g_pCodeWindow)
-  {
-    pOptionsMenu->AppendSeparator();
-    g_pCodeWindow->CreateMenuOptions(pOptionsMenu);
-  }
-  menubar->Append(pOptionsMenu, _("&Options"));
+  auto* const file_menu = new wxMenu;
+  file_menu->Append(wxID_OPEN, GetMenuLabel(HK_OPEN));
+  file_menu->Append(IDM_CHANGE_DISC, GetMenuLabel(HK_CHANGE_DISC));
+  file_menu->Append(IDM_DRIVES, _("&Boot from DVD Backup"), external_drive_menu);
+  file_menu->AppendSeparator();
+  file_menu->Append(wxID_REFRESH, GetMenuLabel(HK_REFRESH_LIST));
+  file_menu->AppendSeparator();
+  file_menu->Append(wxID_EXIT, _("E&xit") + "\tAlt+F4");
 
-  // Tools menu
-  wxMenu* toolsMenu = new wxMenu;
-  toolsMenu->Append(IDM_MEMCARD, _("&Memcard Manager (GC)"));
-  toolsMenu->Append(IDM_IMPORT_SAVE, _("Import Wii Save..."));
-  toolsMenu->Append(IDM_EXPORT_ALL_SAVE, _("Export All Wii Saves"));
-  toolsMenu->Append(IDM_CHEATS, _("&Cheat Manager"));
+  return file_menu;
+}
 
-  toolsMenu->Append(IDM_NETPLAY, _("Start &NetPlay..."));
+wxMenu* CFrame::CreateEmulationMenu()
+{
+  auto* const load_state_menu = new wxMenu;
+  load_state_menu->Append(IDM_LOAD_STATE_FILE, GetMenuLabel(HK_LOAD_STATE_FILE));
+  load_state_menu->Append(IDM_LOAD_SELECTED_SLOT, GetMenuLabel(HK_LOAD_STATE_SLOT_SELECTED));
+  load_state_menu->Append(IDM_UNDO_LOAD_STATE, GetMenuLabel(HK_UNDO_LOAD_STATE));
+  load_state_menu->AppendSeparator();
 
-  toolsMenu->Append(IDM_MENU_INSTALL_WAD, _("Install WAD..."));
-  UpdateWiiMenuChoice(toolsMenu->Append(IDM_LOAD_WII_MENU, "Dummy string to keep wxw happy"));
+  auto* const save_state_menu = new wxMenu;
+  save_state_menu->Append(IDM_SAVE_STATE_FILE, GetMenuLabel(HK_SAVE_STATE_FILE));
+  save_state_menu->Append(IDM_SAVE_SELECTED_SLOT, GetMenuLabel(HK_SAVE_STATE_SLOT_SELECTED));
+  save_state_menu->Append(IDM_SAVE_FIRST_STATE, GetMenuLabel(HK_SAVE_FIRST_STATE));
+  save_state_menu->Append(IDM_UNDO_SAVE_STATE, GetMenuLabel(HK_UNDO_SAVE_STATE));
+  save_state_menu->AppendSeparator();
 
-  toolsMenu->Append(IDM_FIFOPLAYER, _("FIFO Player"));
+  auto* const slot_select_menu = new wxMenu;
 
-  toolsMenu->AppendSeparator();
-  wxMenu* wiimoteMenu = new wxMenu;
-  toolsMenu->AppendSubMenu(wiimoteMenu, _("Connect Wiimotes"));
-  wiimoteMenu->AppendCheckItem(IDM_CONNECT_WIIMOTE1, GetMenuLabel(HK_WIIMOTE1_CONNECT));
-  wiimoteMenu->AppendCheckItem(IDM_CONNECT_WIIMOTE2, GetMenuLabel(HK_WIIMOTE2_CONNECT));
-  wiimoteMenu->AppendCheckItem(IDM_CONNECT_WIIMOTE3, GetMenuLabel(HK_WIIMOTE3_CONNECT));
-  wiimoteMenu->AppendCheckItem(IDM_CONNECT_WIIMOTE4, GetMenuLabel(HK_WIIMOTE4_CONNECT));
-  wiimoteMenu->AppendSeparator();
-  wiimoteMenu->AppendCheckItem(IDM_CONNECT_BALANCEBOARD, GetMenuLabel(HK_BALANCEBOARD_CONNECT));
+  for (unsigned int i = 0; i < State::NUM_STATES; i++)
+  {
+    load_state_menu->Append(IDM_LOAD_SLOT_1 + i, GetMenuLabel(HK_LOAD_STATE_SLOT_1 + i));
+    save_state_menu->Append(IDM_SAVE_SLOT_1 + i, GetMenuLabel(HK_SAVE_STATE_SLOT_1 + i));
+    slot_select_menu->Append(IDM_SELECT_SLOT_1 + i, GetMenuLabel(HK_SELECT_STATE_SLOT_1 + i));
+  }
 
-  menubar->Append(toolsMenu, _("&Tools"));
+  load_state_menu->AppendSeparator();
+  for (unsigned int i = 0; i < State::NUM_STATES; i++)
+    load_state_menu->Append(IDM_LOAD_LAST_1 + i, GetMenuLabel(HK_LOAD_LAST_STATE_1 + i));
+
+  auto* const emulation_menu = new wxMenu;
+  emulation_menu->Append(IDM_PLAY, GetMenuLabel(HK_PLAY_PAUSE));
+  emulation_menu->Append(IDM_STOP, GetMenuLabel(HK_STOP));
+  emulation_menu->Append(IDM_RESET, GetMenuLabel(HK_RESET));
+  emulation_menu->AppendSeparator();
+  emulation_menu->Append(IDM_TOGGLE_FULLSCREEN, GetMenuLabel(HK_FULLSCREEN));
+  emulation_menu->Append(IDM_FRAMESTEP, GetMenuLabel(HK_FRAME_ADVANCE));
+  emulation_menu->AppendSeparator();
+  emulation_menu->Append(IDM_SCREENSHOT, GetMenuLabel(HK_SCREENSHOT));
+  emulation_menu->AppendSeparator();
+  emulation_menu->Append(IDM_LOAD_STATE, _("&Load State"), load_state_menu);
+  emulation_menu->Append(IDM_SAVE_STATE, _("Sa&ve State"), save_state_menu);
+  emulation_menu->Append(IDM_SELECT_SLOT, _("Select State Slot"), slot_select_menu);
+
+  return emulation_menu;
+}
+
+wxMenu* CFrame::CreateMovieMenu()
+{
+  auto* const movie_menu = new wxMenu;
+  const auto& config_instance = SConfig::GetInstance();
+
+  movie_menu->Append(IDM_RECORD, GetMenuLabel(HK_START_RECORDING));
+  movie_menu->Append(IDM_PLAY_RECORD, GetMenuLabel(HK_PLAY_RECORDING));
+  movie_menu->Append(IDM_RECORD_EXPORT, GetMenuLabel(HK_EXPORT_RECORDING));
+  movie_menu->AppendCheckItem(IDM_RECORD_READ_ONLY, GetMenuLabel(HK_READ_ONLY_MODE));
+  movie_menu->Append(IDM_TAS_INPUT, _("TAS Input"));
+  movie_menu->AppendSeparator();
+  movie_menu->AppendCheckItem(IDM_TOGGLE_PAUSE_MOVIE, _("Pause at End of Movie"));
+  movie_menu->Check(IDM_TOGGLE_PAUSE_MOVIE, config_instance.m_PauseMovie);
+  movie_menu->AppendCheckItem(IDM_SHOW_LAG, _("Show Lag Counter"));
+  movie_menu->Check(IDM_SHOW_LAG, config_instance.m_ShowLag);
+  movie_menu->AppendCheckItem(IDM_SHOW_FRAME_COUNT, _("Show Frame Counter"));
+  movie_menu->Check(IDM_SHOW_FRAME_COUNT, config_instance.m_ShowFrameCount);
+  movie_menu->Check(IDM_RECORD_READ_ONLY, true);
+  movie_menu->AppendCheckItem(IDM_SHOW_INPUT_DISPLAY, _("Show Input Display"));
+  movie_menu->Check(IDM_SHOW_INPUT_DISPLAY, config_instance.m_ShowInputDisplay);
+  movie_menu->AppendCheckItem(IDM_SHOW_RTC_DISPLAY, _("Show System Clock"));
+  movie_menu->Check(IDM_SHOW_RTC_DISPLAY, config_instance.m_ShowRTC);
+  movie_menu->AppendSeparator();
+  movie_menu->AppendCheckItem(IDM_TOGGLE_DUMP_FRAMES, _("Dump Frames"));
+  movie_menu->Check(IDM_TOGGLE_DUMP_FRAMES, config_instance.m_DumpFrames);
+  movie_menu->AppendCheckItem(IDM_TOGGLE_DUMP_AUDIO, _("Dump Audio"));
+  movie_menu->Check(IDM_TOGGLE_DUMP_AUDIO, config_instance.m_DumpAudio);
+
+  return movie_menu;
+}
+
+wxMenu* CFrame::CreateOptionsMenu()
+{
+  auto* const options_menu = new wxMenu;
+  options_menu->Append(wxID_PREFERENCES, _("Co&nfigure..."));
+  options_menu->AppendSeparator();
+  options_menu->Append(IDM_CONFIG_GFX_BACKEND, _("&Graphics Settings"));
+  options_menu->Append(IDM_CONFIG_AUDIO, _("&Audio Settings"));
+  options_menu->Append(IDM_CONFIG_CONTROLLERS, _("&Controller Settings"));
+  options_menu->Append(IDM_CONFIG_HOTKEYS, _("&Hotkey Settings"));
 
-  wxMenu* viewMenu = new wxMenu;
-  viewMenu->AppendCheckItem(IDM_TOGGLE_TOOLBAR, _("Show &Toolbar"));
-  viewMenu->Check(IDM_TOGGLE_TOOLBAR, SConfig::GetInstance().m_InterfaceToolbar);
-  viewMenu->AppendCheckItem(IDM_TOGGLE_STATUSBAR, _("Show &Status Bar"));
-  viewMenu->Check(IDM_TOGGLE_STATUSBAR, SConfig::GetInstance().m_InterfaceStatusbar);
-  viewMenu->AppendSeparator();
-  viewMenu->AppendCheckItem(IDM_LOG_WINDOW, _("Show &Log"));
-  viewMenu->AppendCheckItem(IDM_LOG_CONFIG_WINDOW, _("Show Log &Configuration"));
-  viewMenu->AppendSeparator();
+  if (g_pCodeWindow)
+  {
+    options_menu->AppendSeparator();
+    g_pCodeWindow->CreateMenuOptions(options_menu);
+  }
+
+  return options_menu;
+}
+
+wxMenu* CFrame::CreateToolsMenu()
+{
+  auto* const wiimote_menu = new wxMenu;
+  wiimote_menu->AppendCheckItem(IDM_CONNECT_WIIMOTE1, GetMenuLabel(HK_WIIMOTE1_CONNECT));
+  wiimote_menu->AppendCheckItem(IDM_CONNECT_WIIMOTE2, GetMenuLabel(HK_WIIMOTE2_CONNECT));
+  wiimote_menu->AppendCheckItem(IDM_CONNECT_WIIMOTE3, GetMenuLabel(HK_WIIMOTE3_CONNECT));
+  wiimote_menu->AppendCheckItem(IDM_CONNECT_WIIMOTE4, GetMenuLabel(HK_WIIMOTE4_CONNECT));
+  wiimote_menu->AppendSeparator();
+  wiimote_menu->AppendCheckItem(IDM_CONNECT_BALANCEBOARD, GetMenuLabel(HK_BALANCEBOARD_CONNECT));
+
+  auto* const tools_menu = new wxMenu;
+  tools_menu->Append(IDM_MEMCARD, _("&Memcard Manager (GC)"));
+  tools_menu->Append(IDM_IMPORT_SAVE, _("Import Wii Save..."));
+  tools_menu->Append(IDM_EXPORT_ALL_SAVE, _("Export All Wii Saves"));
+  tools_menu->Append(IDM_CHEATS, _("&Cheat Manager"));
+  tools_menu->Append(IDM_NETPLAY, _("Start &NetPlay..."));
+  tools_menu->Append(IDM_MENU_INSTALL_WAD, _("Install WAD..."));
+
+  UpdateWiiMenuChoice(tools_menu->Append(IDM_LOAD_WII_MENU, "Dummy string to keep wxw happy"));
+
+  tools_menu->Append(IDM_FIFOPLAYER, _("FIFO Player"));
+  tools_menu->AppendSeparator();
+  tools_menu->AppendSubMenu(wiimote_menu, _("Connect Wiimotes"));
+
+  return tools_menu;
+}
+
+wxMenu* CFrame::CreateViewMenu()
+{
+  const auto& config_instance = SConfig::GetInstance();
+
+  auto* const platform_menu = new wxMenu;
+  platform_menu->AppendCheckItem(IDM_LIST_WII, _("Show Wii"));
+  platform_menu->Check(IDM_LIST_WII, config_instance.m_ListWii);
+  platform_menu->AppendCheckItem(IDM_LIST_GC, _("Show GameCube"));
+  platform_menu->Check(IDM_LIST_GC, config_instance.m_ListGC);
+  platform_menu->AppendCheckItem(IDM_LIST_WAD, _("Show WAD"));
+  platform_menu->Check(IDM_LIST_WAD, config_instance.m_ListWad);
+  platform_menu->AppendCheckItem(IDM_LIST_ELFDOL, _("Show ELF/DOL"));
+  platform_menu->Check(IDM_LIST_ELFDOL, config_instance.m_ListElfDol);
+
+  auto* const region_menu = new wxMenu;
+  region_menu->AppendCheckItem(IDM_LIST_JAP, _("Show JAP"));
+  region_menu->Check(IDM_LIST_JAP, config_instance.m_ListJap);
+  region_menu->AppendCheckItem(IDM_LIST_PAL, _("Show PAL"));
+  region_menu->Check(IDM_LIST_PAL, config_instance.m_ListPal);
+  region_menu->AppendCheckItem(IDM_LIST_USA, _("Show USA"));
+  region_menu->Check(IDM_LIST_USA, config_instance.m_ListUsa);
+  region_menu->AppendSeparator();
+  region_menu->AppendCheckItem(IDM_LIST_AUSTRALIA, _("Show Australia"));
+  region_menu->Check(IDM_LIST_AUSTRALIA, config_instance.m_ListAustralia);
+  region_menu->AppendCheckItem(IDM_LIST_FRANCE, _("Show France"));
+  region_menu->Check(IDM_LIST_FRANCE, config_instance.m_ListFrance);
+  region_menu->AppendCheckItem(IDM_LIST_GERMANY, _("Show Germany"));
+  region_menu->Check(IDM_LIST_GERMANY, config_instance.m_ListGermany);
+  region_menu->AppendCheckItem(IDM_LIST_ITALY, _("Show Italy"));
+  region_menu->Check(IDM_LIST_ITALY, config_instance.m_ListItaly);
+  region_menu->AppendCheckItem(IDM_LIST_KOREA, _("Show Korea"));
+  region_menu->Check(IDM_LIST_KOREA, config_instance.m_ListKorea);
+  region_menu->AppendCheckItem(IDM_LIST_NETHERLANDS, _("Show Netherlands"));
+  region_menu->Check(IDM_LIST_NETHERLANDS, config_instance.m_ListNetherlands);
+  region_menu->AppendCheckItem(IDM_LIST_RUSSIA, _("Show Russia"));
+  region_menu->Check(IDM_LIST_RUSSIA, config_instance.m_ListRussia);
+  region_menu->AppendCheckItem(IDM_LIST_SPAIN, _("Show Spain"));
+  region_menu->Check(IDM_LIST_SPAIN, config_instance.m_ListSpain);
+  region_menu->AppendCheckItem(IDM_LIST_TAIWAN, _("Show Taiwan"));
+  region_menu->Check(IDM_LIST_TAIWAN, config_instance.m_ListTaiwan);
+  region_menu->AppendCheckItem(IDM_LIST_WORLD, _("Show World"));
+  region_menu->Check(IDM_LIST_WORLD, config_instance.m_ListWorld);
+  region_menu->AppendCheckItem(IDM_LIST_UNKNOWN, _("Show Unknown"));
+  region_menu->Check(IDM_LIST_UNKNOWN, config_instance.m_ListUnknown);
+
+  auto* const columns_menu = new wxMenu;
+  columns_menu->AppendCheckItem(IDM_SHOW_SYSTEM, _("Platform"));
+  columns_menu->Check(IDM_SHOW_SYSTEM, config_instance.m_showSystemColumn);
+  columns_menu->AppendCheckItem(IDM_SHOW_BANNER, _("Banner"));
+  columns_menu->Check(IDM_SHOW_BANNER, config_instance.m_showBannerColumn);
+  columns_menu->AppendCheckItem(IDM_SHOW_MAKER, _("Maker"));
+  columns_menu->Check(IDM_SHOW_MAKER, config_instance.m_showMakerColumn);
+  columns_menu->AppendCheckItem(IDM_SHOW_FILENAME, _("File Name"));
+  columns_menu->Check(IDM_SHOW_FILENAME, config_instance.m_showFileNameColumn);
+  columns_menu->AppendCheckItem(IDM_SHOW_ID, _("Game ID"));
+  columns_menu->Check(IDM_SHOW_ID, config_instance.m_showIDColumn);
+  columns_menu->AppendCheckItem(IDM_SHOW_REGION, _("Region"));
+  columns_menu->Check(IDM_SHOW_REGION, config_instance.m_showRegionColumn);
+  columns_menu->AppendCheckItem(IDM_SHOW_SIZE, _("File Size"));
+  columns_menu->Check(IDM_SHOW_SIZE, config_instance.m_showSizeColumn);
+  columns_menu->AppendCheckItem(IDM_SHOW_STATE, _("State"));
+  columns_menu->Check(IDM_SHOW_STATE, config_instance.m_showStateColumn);
+
+  auto* const view_menu = new wxMenu;
+  view_menu->AppendCheckItem(IDM_TOGGLE_TOOLBAR, _("Show &Toolbar"));
+  view_menu->Check(IDM_TOGGLE_TOOLBAR, config_instance.m_InterfaceToolbar);
+  view_menu->AppendCheckItem(IDM_TOGGLE_STATUSBAR, _("Show &Status Bar"));
+  view_menu->Check(IDM_TOGGLE_STATUSBAR, config_instance.m_InterfaceStatusbar);
+  view_menu->AppendSeparator();
+  view_menu->AppendCheckItem(IDM_LOG_WINDOW, _("Show &Log"));
+  view_menu->AppendCheckItem(IDM_LOG_CONFIG_WINDOW, _("Show Log &Configuration"));
+  view_menu->AppendSeparator();
 
   if (g_pCodeWindow)
   {
-    viewMenu->Check(IDM_LOG_WINDOW, g_pCodeWindow->bShowOnStart[0]);
+    view_menu->Check(IDM_LOG_WINDOW, g_pCodeWindow->bShowOnStart[0]);
 
     static const wxString menu_text[] = {_("&Registers"), _("&Watch"), _("&Breakpoints"),
                                          _("&Memory"),    _("&JIT"),   _("&Sound"),
@@ -258,103 +349,40 @@ wxMenuBar* CFrame::CreateMenu()
 
     for (int i = IDM_REGISTER_WINDOW; i <= IDM_VIDEO_WINDOW; i++)
     {
-      viewMenu->AppendCheckItem(i, menu_text[i - IDM_REGISTER_WINDOW]);
-      viewMenu->Check(i, g_pCodeWindow->bShowOnStart[i - IDM_LOG_WINDOW]);
+      view_menu->AppendCheckItem(i, menu_text[i - IDM_REGISTER_WINDOW]);
+      view_menu->Check(i, g_pCodeWindow->bShowOnStart[i - IDM_LOG_WINDOW]);
     }
 
-    viewMenu->AppendSeparator();
+    view_menu->AppendSeparator();
   }
   else
   {
-    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_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);
-  platformMenu->AppendCheckItem(IDM_LIST_ELFDOL, _("Show ELF/DOL"));
-  platformMenu->Check(IDM_LIST_ELFDOL, SConfig::GetInstance().m_ListElfDol);
-
-  wxMenu* regionMenu = new wxMenu;
-  viewMenu->AppendSubMenu(regionMenu, _("Show Regions"));
-  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_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_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_WORLD, _("Show World"));
-  regionMenu->Check(IDM_LIST_WORLD, SConfig::GetInstance().m_ListWorld);
-  regionMenu->AppendCheckItem(IDM_LIST_UNKNOWN, _("Show Unknown"));
-  regionMenu->Check(IDM_LIST_UNKNOWN, SConfig::GetInstance().m_ListUnknown);
-
-  viewMenu->AppendCheckItem(IDM_LIST_DRIVES, _("Show Drives"));
-  viewMenu->Check(IDM_LIST_DRIVES, SConfig::GetInstance().m_ListDrives);
-  viewMenu->Append(IDM_PURGE_GAME_LIST_CACHE, _("Purge Game List Cache"));
-
-  wxMenu* columnsMenu = new wxMenu;
-  viewMenu->AppendSubMenu(columnsMenu, _("Select Columns"));
-  columnsMenu->AppendCheckItem(IDM_SHOW_SYSTEM, _("Platform"));
-  columnsMenu->Check(IDM_SHOW_SYSTEM, SConfig::GetInstance().m_showSystemColumn);
-  columnsMenu->AppendCheckItem(IDM_SHOW_BANNER, _("Banner"));
-  columnsMenu->Check(IDM_SHOW_BANNER, SConfig::GetInstance().m_showBannerColumn);
-  columnsMenu->AppendCheckItem(IDM_SHOW_MAKER, _("Maker"));
-  columnsMenu->Check(IDM_SHOW_MAKER, SConfig::GetInstance().m_showMakerColumn);
-  columnsMenu->AppendCheckItem(IDM_SHOW_FILENAME, _("File Name"));
-  columnsMenu->Check(IDM_SHOW_FILENAME, SConfig::GetInstance().m_showFileNameColumn);
-  columnsMenu->AppendCheckItem(IDM_SHOW_ID, _("Game ID"));
-  columnsMenu->Check(IDM_SHOW_ID, SConfig::GetInstance().m_showIDColumn);
-  columnsMenu->AppendCheckItem(IDM_SHOW_REGION, _("Region"));
-  columnsMenu->Check(IDM_SHOW_REGION, SConfig::GetInstance().m_showRegionColumn);
-  columnsMenu->AppendCheckItem(IDM_SHOW_SIZE, _("File Size"));
-  columnsMenu->Check(IDM_SHOW_SIZE, SConfig::GetInstance().m_showSizeColumn);
-  columnsMenu->AppendCheckItem(IDM_SHOW_STATE, _("State"));
-  columnsMenu->Check(IDM_SHOW_STATE, SConfig::GetInstance().m_showStateColumn);
-
-  menubar->Append(viewMenu, _("&View"));
-
-  if (g_pCodeWindow)
-  {
-    g_pCodeWindow->CreateMenu(SConfig::GetInstance(), menubar);
+    view_menu->Check(IDM_LOG_WINDOW, config_instance.m_InterfaceLogWindow);
+    view_menu->Check(IDM_LOG_CONFIG_WINDOW, config_instance.m_InterfaceLogConfigWindow);
   }
 
-  // Help menu
-  wxMenu* helpMenu = new wxMenu;
-  // Re-enable when there's something useful to display */
-  // helpMenu->Append(wxID_HELP, _("&Help"));
-  helpMenu->Append(IDM_HELP_WEBSITE, _("&Website"));
-  helpMenu->Append(IDM_HELP_ONLINE_DOCS, _("Online &Documentation"));
-  helpMenu->Append(IDM_HELP_GITHUB, _("&GitHub Repository"));
-  helpMenu->AppendSeparator();
-  helpMenu->Append(wxID_ABOUT, _("&About"));
-  menubar->Append(helpMenu, _("&Help"));
+  view_menu->AppendSubMenu(platform_menu, _("Show Platforms"));
+  view_menu->AppendSubMenu(region_menu, _("Show Regions"));
+
+  view_menu->AppendCheckItem(IDM_LIST_DRIVES, _("Show Drives"));
+  view_menu->Check(IDM_LIST_DRIVES, config_instance.m_ListDrives);
+
+  view_menu->Append(IDM_PURGE_GAME_LIST_CACHE, _("Purge Game List Cache"));
+  view_menu->AppendSubMenu(columns_menu, _("Select Columns"));
+
+  return view_menu;
+}
+
+wxMenu* CFrame::CreateHelpMenu()
+{
+  auto* const help_menu = new wxMenu;
+  help_menu->Append(IDM_HELP_WEBSITE, _("&Website"));
+  help_menu->Append(IDM_HELP_ONLINE_DOCS, _("Online &Documentation"));
+  help_menu->Append(IDM_HELP_GITHUB, _("&GitHub Repository"));
+  help_menu->AppendSeparator();
+  help_menu->Append(wxID_ABOUT, _("&About"));
 
-  return menubar;
+  return help_menu;
 }
 
 wxString CFrame::GetMenuLabel(int Id)