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

2192 lines
72 KiB
C++
Raw Blame History

// Copyright 2008 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include <array>
#include <cstdarg>
#include <cstdio>
#include <mutex>
#include <string>
#include <vector>
#include <wx/app.h>
#include <wx/aui/framemanager.h>
#include <wx/bitmap.h>
#include <wx/filedlg.h>
#include <wx/filefn.h>
#include <wx/menu.h>
#include <wx/msgdlg.h>
#include <wx/panel.h>
#include <wx/progdlg.h>
#include <wx/statusbr.h>
#include <wx/thread.h>
#include <wx/toolbar.h>
#include <wx/toplevel.h>
#include "Common/CDUtils.h"
#include "Common/CommonTypes.h"
#include "Common/FileSearch.h"
#include "Common/FileUtil.h"
#include "Common/NandPaths.h"
#include "Common/StringUtil.h"
#include "Core/BootManager.h"
#include "Core/ConfigManager.h"
#include "Core/Core.h"
#include "Core/HW/CPU.h"
#include "Core/HW/DVDInterface.h"
#include "Core/HW/GCKeyboard.h"
#include "Core/HW/GCPad.h"
#include "Core/HW/ProcessorInterface.h"
#include "Core/HW/SI_Device.h"
#include "Core/HW/WiiSaveCrypted.h"
#include "Core/HW/Wiimote.h"
#include "Core/Host.h"
#include "Core/HotkeyManager.h"
#include "Core/IPC_HLE/WII_IPC_HLE_Device_usb_bt_emu.h"
#include "Core/IPC_HLE/WII_IPC_HLE_WiiMote.h"
#include "Core/Movie.h"
#include "Core/PowerPC/PPCSymbolDB.h"
#include "Core/PowerPC/PowerPC.h"
#include "Core/State.h"
#include "DiscIO/NANDContentLoader.h"
#include "DolphinWX/AboutDolphin.h"
#include "DolphinWX/Cheats/CheatsWindow.h"
#include "DolphinWX/Config/ConfigMain.h"
#include "DolphinWX/ControllerConfigDiag.h"
#include "DolphinWX/Debugger/BreakpointWindow.h"
#include "DolphinWX/Debugger/CodeWindow.h"
#include "DolphinWX/Debugger/WatchWindow.h"
#include "DolphinWX/FifoPlayerDlg.h"
#include "DolphinWX/Frame.h"
#include "DolphinWX/GameListCtrl.h"
#include "DolphinWX/Globals.h"
#include "DolphinWX/ISOFile.h"
#include "DolphinWX/InputConfigDiag.h"
#include "DolphinWX/LogWindow.h"
#include "DolphinWX/MemcardManager.h"
#include "DolphinWX/NetPlay/NetPlaySetupFrame.h"
#include "DolphinWX/NetPlay/NetWindow.h"
#include "DolphinWX/TASInputDlg.h"
#include "DolphinWX/WXInputBase.h"
#include "DolphinWX/WxUtils.h"
#include "InputCommon/ControllerInterface/ControllerInterface.h"
#include "VideoCommon/RenderBase.h"
#include "VideoCommon/VideoBackendBase.h"
#include "VideoCommon/VideoConfig.h"
class InputConfig;
class wxFrame;
// This override allows returning a fake menubar object while removing the real one from the screen
wxMenuBar* CFrame::GetMenuBar() const
{
if (m_frameMenuBar)
{
return m_frameMenuBar;
}
else
{
return m_menubar_shadow;
}
}
const wxSize& CFrame::GetToolbarBitmapSize() const
{
return m_toolbar_bitmap_size;
}
// Create menu items
// ---------------------
wxMenuBar* CFrame::CreateMenuBar()
{
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"));
if (UseDebugger)
{
menu_bar->Append(CreateJITMenu(), _("&JIT"));
menu_bar->Append(CreateDebugMenu(), _("&Debug"));
menu_bar->Append(CreateSymbolsMenu(), _("&Symbols"));
menu_bar->Append(CreateProfilerMenu(), _("&Profiler"));
}
menu_bar->Append(CreateHelpMenu(), _("&Help"));
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++)
{
external_drive_menu->Append(IDM_DRIVE1 + i, StrToWxStr(drives[i]));
}
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");
return file_menu;
}
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();
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();
auto* const slot_select_menu = new wxMenu;
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));
}
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"));
if (UseDebugger)
{
options_menu->AppendSeparator();
const auto& config_instance = SConfig::GetInstance();
auto* const boot_to_pause =
options_menu->AppendCheckItem(IDM_BOOT_TO_PAUSE, _("Boot to Pause"),
_("Start the game directly instead of booting to pause"));
boot_to_pause->Check(config_instance.bBootToPause);
auto* const automatic_start = options_menu->AppendCheckItem(
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"
" convenient if you are bug-testing with a certain game and want to rebuild"
" and retry it several times, either with changes to Dolphin or if you are"
" developing a homebrew game.]"));
automatic_start->Check(config_instance.bAutomaticStart);
options_menu->Append(IDM_FONT_PICKER, _("&Font..."));
}
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)
{
view_menu->Check(IDM_LOG_WINDOW, g_pCodeWindow->bShowOnStart[0]);
static const wxString menu_text[] = {_("&Registers"), _("&Watch"), _("&Breakpoints"),
_("&Memory"), _("&JIT"), _("&Sound"),
_("&Video")};
for (int i = IDM_REGISTER_WINDOW; i <= IDM_VIDEO_WINDOW; i++)
{
view_menu->AppendCheckItem(i, menu_text[i - IDM_REGISTER_WINDOW]);
view_menu->Check(i, g_pCodeWindow->bShowOnStart[i - IDM_LOG_WINDOW]);
}
view_menu->AppendSeparator();
}
else
{
view_menu->Check(IDM_LOG_WINDOW, config_instance.m_InterfaceLogWindow);
view_menu->Check(IDM_LOG_CONFIG_WINDOW, config_instance.m_InterfaceLogConfigWindow);
}
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::CreateJITMenu()
{
auto* const jit_menu = new wxMenu;
const auto& config_instance = SConfig::GetInstance();
auto* const interpreter = jit_menu->AppendCheckItem(
IDM_INTERPRETER, _("&Interpreter Core"),
_("This is necessary to get break points"
" and stepping to work as explained in the Developer Documentation. But it can be very"
" slow, perhaps slower than 1 fps."));
interpreter->Check(config_instance.iCPUCore == PowerPC::CORE_INTERPRETER);
jit_menu->AppendSeparator();
jit_menu->AppendCheckItem(IDM_JIT_NO_BLOCK_LINKING, _("&JIT Block Linking Off"),
_("Provide safer execution by not linking the JIT blocks."));
jit_menu->AppendCheckItem(
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.]"));
jit_menu->Append(IDM_CLEAR_CODE_CACHE, _("&Clear JIT Cache"));
jit_menu->AppendSeparator();
jit_menu->Append(IDM_LOG_INSTRUCTIONS, _("&Log JIT Instruction Coverage"));
jit_menu->Append(IDM_SEARCH_INSTRUCTION, _("&Search for an Instruction"));
jit_menu->AppendSeparator();
jit_menu->AppendCheckItem(
IDM_JIT_OFF, _("&JIT Off (JIT Core)"),
_("Turn off all JIT functions, but still use the JIT core from Jit.cpp"));
jit_menu->AppendCheckItem(IDM_JIT_LS_OFF, _("&JIT LoadStore Off"));
jit_menu->AppendCheckItem(IDM_JIT_LSLBZX_OFF, _("&JIT LoadStore lbzx Off"));
jit_menu->AppendCheckItem(IDM_JIT_LSLXZ_OFF, _("&JIT LoadStore lXz Off"));
jit_menu->AppendCheckItem(IDM_JIT_LSLWZ_OFF, _("&JIT LoadStore lwz Off"));
jit_menu->AppendCheckItem(IDM_JIT_LSF_OFF, _("&JIT LoadStore Floating Off"));
jit_menu->AppendCheckItem(IDM_JIT_LSP_OFF, _("&JIT LoadStore Paired Off"));
jit_menu->AppendCheckItem(IDM_JIT_FP_OFF, _("&JIT FloatingPoint Off"));
jit_menu->AppendCheckItem(IDM_JIT_I_OFF, _("&JIT Integer Off"));
jit_menu->AppendCheckItem(IDM_JIT_P_OFF, _("&JIT Paired Off"));
jit_menu->AppendCheckItem(IDM_JIT_SR_OFF, _("&JIT SystemRegisters Off"));
return jit_menu;
}
wxMenu* CFrame::CreateDebugMenu()
{
m_SavedPerspectives = new wxMenu;
PopulateSavedPerspectives();
auto* const add_pane_menu = new wxMenu;
add_pane_menu->Append(IDM_PERSPECTIVES_ADD_PANE_TOP, _("Top"));
add_pane_menu->Append(IDM_PERSPECTIVES_ADD_PANE_BOTTOM, _("Bottom"));
add_pane_menu->Append(IDM_PERSPECTIVES_ADD_PANE_LEFT, _("Left"));
add_pane_menu->Append(IDM_PERSPECTIVES_ADD_PANE_RIGHT, _("Right"));
add_pane_menu->Append(IDM_PERSPECTIVES_ADD_PANE_CENTER, _("Center"));
auto* const perspective_menu = new wxMenu;
perspective_menu->Append(IDM_SAVE_PERSPECTIVE, _("Save Perspectives"),
_("Save currently-toggled perspectives"));
perspective_menu->AppendCheckItem(IDM_EDIT_PERSPECTIVES, _("Edit Perspectives"),
_("Toggle editing of perspectives"));
perspective_menu->AppendSeparator();
perspective_menu->Append(IDM_ADD_PERSPECTIVE, _("Create New Perspective"));
perspective_menu->AppendSubMenu(m_SavedPerspectives, _("Saved Perspectives"));
perspective_menu->AppendSeparator();
perspective_menu->AppendSubMenu(add_pane_menu, _("Add New Pane To"));
perspective_menu->AppendCheckItem(IDM_TAB_SPLIT, _("Tab Split"));
perspective_menu->AppendCheckItem(IDM_NO_DOCKING, _("Disable Docking"),
_("Disable docking of perspective panes to main window"));
auto* const debug_menu = new wxMenu;
debug_menu->Append(IDM_STEP, _("Step &Into\tF11"));
debug_menu->Append(IDM_STEPOVER, _("Step &Over\tF10"));
debug_menu->Append(IDM_STEPOUT, _("Step O&ut\tSHIFT+F11"));
debug_menu->Append(IDM_TOGGLE_BREAKPOINT, _("Toggle &Breakpoint\tF9"));
debug_menu->AppendSeparator();
debug_menu->AppendSubMenu(perspective_menu, _("Perspectives"), _("Edit Perspectives"));
return debug_menu;
}
wxMenu* CFrame::CreateSymbolsMenu()
{
auto* const symbols_menu = new wxMenu;
symbols_menu->Append(IDM_CLEAR_SYMBOLS, _("&Clear Symbols"),
_("Remove names from all functions and variables."));
symbols_menu->Append(IDM_SCAN_FUNCTIONS, _("&Generate Symbol Map"),
_("Recognise standard functions from sys\\totaldb.dsy, and use generic zz_ "
"names for other functions."));
symbols_menu->AppendSeparator();
symbols_menu->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."));
symbols_menu->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."));
symbols_menu->AppendSeparator();
symbols_menu->Append(
IDM_LOAD_MAP_FILE_AS, _("Load &Other Map File..."),
_("Load any .map file containing the function names and addresses for this game."));
symbols_menu->Append(
IDM_LOAD_BAD_MAP_FILE, _("Load &Bad Map File..."),
_("Try to load a .map file that might be from a slightly different version."));
symbols_menu->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."));
symbols_menu->AppendSeparator();
symbols_menu->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"
" files with code to memory you may want to increase that to perhaps 8 MB, you can do"
" that from SymbolDB::SaveMap()."));
symbols_menu->AppendSeparator();
symbols_menu->Append(
IDM_CREATE_SIGNATURE_FILE, _("&Create Signature File..."),
_("Create a .dsy file that can be used to recognise these same functions in other games."));
symbols_menu->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."));
symbols_menu->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."));
symbols_menu->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."));
symbols_menu->AppendSeparator();
symbols_menu->Append(IDM_PATCH_HLE_FUNCTIONS, _("&Patch HLE Functions"));
symbols_menu->Append(IDM_RENAME_SYMBOLS, _("&Rename Symbols from File..."));
return symbols_menu;
}
wxMenu* CFrame::CreateProfilerMenu()
{
auto* const profiler_menu = new wxMenu;
profiler_menu->AppendCheckItem(IDM_PROFILE_BLOCKS, _("&Profile Blocks"));
profiler_menu->AppendSeparator();
profiler_menu->Append(IDM_WRITE_PROFILE, _("&Write to profile.txt, Show"));
return profiler_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 help_menu;
}
wxString CFrame::GetMenuLabel(int Id)
{
wxString Label;
switch (Id)
{
case HK_OPEN:
Label = _("&Open...");
break;
case HK_CHANGE_DISC:
Label = _("Change &Disc...");
break;
case HK_REFRESH_LIST:
Label = _("&Refresh List");
break;
case HK_PLAY_PAUSE:
if (Core::GetState() == Core::CORE_RUN)
Label = _("&Pause");
else
Label = _("&Play");
break;
case HK_STOP:
Label = _("&Stop");
break;
case HK_RESET:
Label = _("&Reset");
break;
case HK_FRAME_ADVANCE:
Label = _("&Frame Advance");
break;
case HK_START_RECORDING:
Label = _("Start Re&cording Input");
break;
case HK_PLAY_RECORDING:
Label = _("P&lay Input Recording...");
break;
case HK_EXPORT_RECORDING:
Label = _("Export Recording...");
break;
case HK_READ_ONLY_MODE:
Label = _("&Read-Only Mode");
break;
case HK_FULLSCREEN:
Label = _("&Fullscreen");
break;
case HK_SCREENSHOT:
Label = _("Take Screenshot");
break;
case HK_EXIT:
Label = _("Exit");
break;
case HK_WIIMOTE1_CONNECT:
case HK_WIIMOTE2_CONNECT:
case HK_WIIMOTE3_CONNECT:
case HK_WIIMOTE4_CONNECT:
Label = wxString::Format(_("Connect Wiimote %i"), Id - HK_WIIMOTE1_CONNECT + 1);
break;
case HK_BALANCEBOARD_CONNECT:
Label = _("Connect Balance Board");
break;
case HK_LOAD_STATE_SLOT_1:
case HK_LOAD_STATE_SLOT_2:
case HK_LOAD_STATE_SLOT_3:
case HK_LOAD_STATE_SLOT_4:
case HK_LOAD_STATE_SLOT_5:
case HK_LOAD_STATE_SLOT_6:
case HK_LOAD_STATE_SLOT_7:
case HK_LOAD_STATE_SLOT_8:
case HK_LOAD_STATE_SLOT_9:
case HK_LOAD_STATE_SLOT_10:
Label = wxString::Format(_("Slot %i - %s"), Id - HK_LOAD_STATE_SLOT_1 + 1,
StrToWxStr(State::GetInfoStringOfSlot(Id - HK_LOAD_STATE_SLOT_1 + 1)));
break;
case HK_SAVE_STATE_SLOT_1:
case HK_SAVE_STATE_SLOT_2:
case HK_SAVE_STATE_SLOT_3:
case HK_SAVE_STATE_SLOT_4:
case HK_SAVE_STATE_SLOT_5:
case HK_SAVE_STATE_SLOT_6:
case HK_SAVE_STATE_SLOT_7:
case HK_SAVE_STATE_SLOT_8:
case HK_SAVE_STATE_SLOT_9:
case HK_SAVE_STATE_SLOT_10:
Label = wxString::Format(_("Slot %i - %s"), Id - HK_SAVE_STATE_SLOT_1 + 1,
StrToWxStr(State::GetInfoStringOfSlot(Id - HK_SAVE_STATE_SLOT_1 + 1)));
break;
case HK_SAVE_STATE_FILE:
Label = _("Save State...");
break;
case HK_LOAD_LAST_STATE_1:
case HK_LOAD_LAST_STATE_2:
case HK_LOAD_LAST_STATE_3:
case HK_LOAD_LAST_STATE_4:
case HK_LOAD_LAST_STATE_5:
case HK_LOAD_LAST_STATE_6:
case HK_LOAD_LAST_STATE_7:
case HK_LOAD_LAST_STATE_8:
case HK_LOAD_LAST_STATE_9:
case HK_LOAD_LAST_STATE_10:
Label = wxString::Format(_("Last %i"), Id - HK_LOAD_LAST_STATE_1 + 1);
break;
case HK_LOAD_STATE_FILE:
Label = _("Load State...");
break;
case HK_SAVE_FIRST_STATE:
Label = _("Save Oldest State");
break;
case HK_UNDO_LOAD_STATE:
Label = _("Undo Load State");
break;
case HK_UNDO_SAVE_STATE:
Label = _("Undo Save State");
break;
case HK_SAVE_STATE_SLOT_SELECTED:
Label = _("Save State to Selected Slot");
break;
case HK_LOAD_STATE_SLOT_SELECTED:
Label = _("Load State from Selected Slot");
break;
case HK_SELECT_STATE_SLOT_1:
case HK_SELECT_STATE_SLOT_2:
case HK_SELECT_STATE_SLOT_3:
case HK_SELECT_STATE_SLOT_4:
case HK_SELECT_STATE_SLOT_5:
case HK_SELECT_STATE_SLOT_6:
case HK_SELECT_STATE_SLOT_7:
case HK_SELECT_STATE_SLOT_8:
case HK_SELECT_STATE_SLOT_9:
case HK_SELECT_STATE_SLOT_10:
Label =
wxString::Format(_("Select Slot %i - %s"), Id - HK_SELECT_STATE_SLOT_1 + 1,
StrToWxStr(State::GetInfoStringOfSlot(Id - HK_SELECT_STATE_SLOT_1 + 1)));
break;
default:
Label = wxString::Format(_("Undefined %i"), Id);
}
return Label;
}
// Create toolbar items
// ---------------------
void CFrame::PopulateToolbar(wxToolBar* ToolBar)
{
WxUtils::AddToolbarButton(ToolBar, wxID_OPEN, _("Open"), m_Bitmaps[Toolbar_FileOpen],
_("Open file..."));
WxUtils::AddToolbarButton(ToolBar, wxID_REFRESH, _("Refresh"), m_Bitmaps[Toolbar_Refresh],
_("Refresh game list"));
ToolBar->AddSeparator();
WxUtils::AddToolbarButton(ToolBar, IDM_PLAY, _("Play"), m_Bitmaps[Toolbar_Play], _("Play"));
WxUtils::AddToolbarButton(ToolBar, IDM_STOP, _("Stop"), m_Bitmaps[Toolbar_Stop], _("Stop"));
WxUtils::AddToolbarButton(ToolBar, IDM_TOGGLE_FULLSCREEN, _("FullScr"),
m_Bitmaps[Toolbar_FullScreen], _("Toggle fullscreen"));
WxUtils::AddToolbarButton(ToolBar, IDM_SCREENSHOT, _("ScrShot"), m_Bitmaps[Toolbar_Screenshot],
_("Take screenshot"));
ToolBar->AddSeparator();
WxUtils::AddToolbarButton(ToolBar, wxID_PREFERENCES, _("Config"), m_Bitmaps[Toolbar_ConfigMain],
_("Configure..."));
WxUtils::AddToolbarButton(ToolBar, IDM_CONFIG_GFX_BACKEND, _("Graphics"),
m_Bitmaps[Toolbar_ConfigGFX], _("Graphics settings"));
WxUtils::AddToolbarButton(ToolBar, IDM_CONFIG_CONTROLLERS, _("Controllers"),
m_Bitmaps[Toolbar_Controller], _("Controller settings"));
}
// Delete and recreate the toolbar
void CFrame::RecreateToolbar()
{
static constexpr long TOOLBAR_STYLE = wxTB_DEFAULT_STYLE | wxTB_TEXT | wxTB_FLAT;
if (m_ToolBar != nullptr)
{
m_ToolBar->Destroy();
m_ToolBar = nullptr;
}
m_ToolBar = CreateToolBar(TOOLBAR_STYLE, wxID_ANY);
m_ToolBar->SetToolBitmapSize(m_toolbar_bitmap_size);
if (g_pCodeWindow)
{
g_pCodeWindow->PopulateToolbar(m_ToolBar);
m_ToolBar->AddSeparator();
}
PopulateToolbar(m_ToolBar);
// after adding the buttons to the toolbar, must call Realize() to reflect
// the changes
m_ToolBar->Realize();
UpdateGUI();
}
void CFrame::InitBitmaps()
{
static constexpr std::array<const char* const, EToolbar_Max> s_image_names{
{"open", "refresh", "play", "stop", "pause", "screenshot", "fullscreen", "config", "graphics",
"classic"}};
for (std::size_t i = 0; i < s_image_names.size(); ++i)
m_Bitmaps[i] = WxUtils::LoadScaledThemeBitmap(s_image_names[i], this, m_toolbar_bitmap_size);
// Update in case the bitmap has been updated
if (m_ToolBar != nullptr)
RecreateToolbar();
}
void CFrame::OpenGeneralConfiguration(int tab)
{
CConfigMain config_main(this);
if (tab > -1)
config_main.SetSelectedTab(tab);
HotkeyManagerEmu::Enable(false);
if (config_main.ShowModal() == wxID_OK)
UpdateGameList();
HotkeyManagerEmu::Enable(true);
UpdateGUI();
}
// Menu items
// Start the game or change the disc.
// Boot priority:
// 1. Show the game list and boot the selected game.
// 2. Default ISO
// 3. Boot last selected game
void CFrame::BootGame(const std::string& filename)
{
std::string bootfile = filename;
SConfig& StartUp = SConfig::GetInstance();
if (Core::GetState() != Core::CORE_UNINITIALIZED)
return;
// Start filename if non empty.
// Start the selected ISO, or try one of the saved paths.
// If all that fails, ask to add a dir and don't boot
if (bootfile.empty())
{
if (m_GameListCtrl->GetSelectedISO() != nullptr)
{
if (m_GameListCtrl->GetSelectedISO()->IsValid())
bootfile = m_GameListCtrl->GetSelectedISO()->GetFileName();
}
else if (!StartUp.m_strDefaultISO.empty() && File::Exists(StartUp.m_strDefaultISO))
{
bootfile = StartUp.m_strDefaultISO;
}
else
{
if (!SConfig::GetInstance().m_LastFilename.empty() &&
File::Exists(SConfig::GetInstance().m_LastFilename))
{
bootfile = SConfig::GetInstance().m_LastFilename;
}
else
{
m_GameListCtrl->BrowseForDirectory();
return;
}
}
}
if (!bootfile.empty())
{
StartGame(bootfile);
if (UseDebugger && g_pCodeWindow)
{
if (g_pCodeWindow->HasPanel<CWatchWindow>())
g_pCodeWindow->GetPanel<CWatchWindow>()->LoadAll();
if (g_pCodeWindow->HasPanel<CBreakPointWindow>())
g_pCodeWindow->GetPanel<CBreakPointWindow>()->LoadAll();
}
}
}
// Open file to boot
void CFrame::OnOpen(wxCommandEvent& WXUNUSED(event))
{
if (Core::GetState() == Core::CORE_UNINITIALIZED)
DoOpen(true);
}
void CFrame::DoOpen(bool Boot)
{
std::string currentDir = File::GetCurrentDir();
wxString path = wxFileSelector(
_("Select the file to load"), wxEmptyString, wxEmptyString, wxEmptyString,
_("All GC/Wii files (elf, dol, gcm, iso, wbfs, ciso, gcz, wad)") +
wxString::Format("|*.elf;*.dol;*.gcm;*.iso;*.wbfs;*.ciso;*.gcz;*.wad;*.dff;*.tmd|%s",
wxGetTranslation(wxALL_FILES)),
wxFD_OPEN | wxFD_FILE_MUST_EXIST, this);
if (path.IsEmpty())
return;
std::string currentDir2 = File::GetCurrentDir();
if (currentDir != currentDir2)
{
PanicAlertT("Current directory changed from %s to %s after wxFileSelector!", currentDir.c_str(),
currentDir2.c_str());
File::SetCurrentDir(currentDir);
}
// Should we boot a new game or just change the disc?
if (Boot && !path.IsEmpty())
{
BootGame(WxStrToStr(path));
}
else
{
DVDInterface::ChangeDiscAsHost(WxStrToStr(path));
}
}
void CFrame::OnRecordReadOnly(wxCommandEvent& event)
{
Movie::SetReadOnly(event.IsChecked());
}
void CFrame::OnTASInput(wxCommandEvent& event)
{
for (int i = 0; i < 4; ++i)
{
if (SConfig::GetInstance().m_SIDevice[i] != SIDEVICE_NONE &&
SConfig::GetInstance().m_SIDevice[i] != SIDEVICE_GC_GBA)
{
g_TASInputDlg[i]->CreateGCLayout();
g_TASInputDlg[i]->Show();
g_TASInputDlg[i]->SetTitle(wxString::Format(_("TAS Input - Controller %d"), i + 1));
}
if (g_wiimote_sources[i] == WIIMOTE_SRC_EMU &&
!(Core::IsRunning() && !SConfig::GetInstance().bWii))
{
g_TASInputDlg[i + 4]->CreateWiiLayout(i);
g_TASInputDlg[i + 4]->Show();
g_TASInputDlg[i + 4]->SetTitle(wxString::Format(_("TAS Input - Wiimote %d"), i + 1));
}
}
}
void CFrame::OnTogglePauseMovie(wxCommandEvent& WXUNUSED(event))
{
SConfig::GetInstance().m_PauseMovie = !SConfig::GetInstance().m_PauseMovie;
SConfig::GetInstance().SaveSettings();
}
void CFrame::OnToggleDumpFrames(wxCommandEvent& WXUNUSED(event))
{
SConfig::GetInstance().m_DumpFrames = !SConfig::GetInstance().m_DumpFrames;
SConfig::GetInstance().SaveSettings();
}
void CFrame::OnToggleDumpAudio(wxCommandEvent& WXUNUSED(event))
{
SConfig::GetInstance().m_DumpAudio = !SConfig::GetInstance().m_DumpAudio;
}
void CFrame::OnShowLag(wxCommandEvent& WXUNUSED(event))
{
SConfig::GetInstance().m_ShowLag = !SConfig::GetInstance().m_ShowLag;
SConfig::GetInstance().SaveSettings();
}
void CFrame::OnShowFrameCount(wxCommandEvent& WXUNUSED(event))
{
SConfig::GetInstance().m_ShowFrameCount = !SConfig::GetInstance().m_ShowFrameCount;
SConfig::GetInstance().SaveSettings();
}
void CFrame::OnShowInputDisplay(wxCommandEvent& WXUNUSED(event))
{
SConfig::GetInstance().m_ShowInputDisplay = !SConfig::GetInstance().m_ShowInputDisplay;
SConfig::GetInstance().SaveSettings();
}
void CFrame::OnShowRTCDisplay(wxCommandEvent& WXUNUSED(event))
{
SConfig::GetInstance().m_ShowRTC = !SConfig::GetInstance().m_ShowRTC;
SConfig::GetInstance().SaveSettings();
}
void CFrame::OnFrameStep(wxCommandEvent& event)
{
bool wasPaused = (Core::GetState() == Core::CORE_PAUSE);
Movie::DoFrameStep();
bool isPaused = (Core::GetState() == Core::CORE_PAUSE);
if (isPaused && !wasPaused) // don't update on unpause, otherwise the status would be wrong when
// pausing next frame
UpdateGUI();
}
void CFrame::OnChangeDisc(wxCommandEvent& WXUNUSED(event))
{
DoOpen(false);
}
void CFrame::OnRecord(wxCommandEvent& WXUNUSED(event))
{
if ((!Core::IsRunningAndStarted() && Core::IsRunning()) || Movie::IsRecordingInput() ||
Movie::IsPlayingInput())
return;
int controllers = 0;
if (Movie::IsReadOnly())
{
// The user just chose to record a movie, so that should take precedence
Movie::SetReadOnly(false);
GetMenuBar()->FindItem(IDM_RECORD_READ_ONLY)->Check(false);
}
for (int i = 0; i < 4; i++)
{
if (SIDevice_IsGCController(SConfig::GetInstance().m_SIDevice[i]))
controllers |= (1 << i);
if (g_wiimote_sources[i] != WIIMOTE_SRC_NONE)
controllers |= (1 << (i + 4));
}
if (Movie::BeginRecordingInput(controllers))
BootGame("");
}
void CFrame::OnPlayRecording(wxCommandEvent& WXUNUSED(event))
{
wxString path =
wxFileSelector(_("Select The Recording File"), wxEmptyString, wxEmptyString, wxEmptyString,
_("Dolphin TAS Movies (*.dtm)") +
wxString::Format("|*.dtm|%s", wxGetTranslation(wxALL_FILES)),
wxFD_OPEN | wxFD_PREVIEW | wxFD_FILE_MUST_EXIST, this);
if (path.IsEmpty())
return;
if (!Movie::IsReadOnly())
{
// let's make the read-only flag consistent at the start of a movie.
Movie::SetReadOnly(true);
GetMenuBar()->FindItem(IDM_RECORD_READ_ONLY)->Check();
}
if (Movie::PlayInput(WxStrToStr(path)))
BootGame("");
}
void CFrame::OnRecordExport(wxCommandEvent& WXUNUSED(event))
{
DoRecordingSave();
}
void CFrame::OnPlay(wxCommandEvent& WXUNUSED(event))
{
if (Core::IsRunning())
{
// Core is initialized and emulator is running
if (UseDebugger)
{
CPU::EnableStepping(!CPU::IsStepping());
wxThread::Sleep(20);
g_pCodeWindow->JumpToAddress(PC);
g_pCodeWindow->Repopulate();
// Update toolbar with Play/Pause status
UpdateGUI();
}
else
{
DoPause();
}
}
else
{
// Core is uninitialized, start the game
BootGame("");
}
}
void CFrame::OnRenderParentClose(wxCloseEvent& event)
{
// Before closing the window we need to shut down the emulation core.
// We'll try to close this window again once that is done.
if (Core::GetState() != Core::CORE_UNINITIALIZED)
{
DoStop();
if (event.CanVeto())
{
event.Veto();
}
return;
}
event.Skip();
}
void CFrame::OnRenderParentMove(wxMoveEvent& event)
{
if (Core::GetState() != Core::CORE_UNINITIALIZED && !RendererIsFullscreen() &&
!m_RenderFrame->IsMaximized() && !m_RenderFrame->IsIconized())
{
SConfig::GetInstance().iRenderWindowXPos = m_RenderFrame->GetPosition().x;
SConfig::GetInstance().iRenderWindowYPos = m_RenderFrame->GetPosition().y;
}
event.Skip();
}
void CFrame::OnRenderParentResize(wxSizeEvent& event)
{
if (Core::GetState() != Core::CORE_UNINITIALIZED)
{
int width, height;
if (!SConfig::GetInstance().bRenderToMain && !RendererIsFullscreen() &&
!m_RenderFrame->IsMaximized() && !m_RenderFrame->IsIconized())
{
m_RenderFrame->GetClientSize(&width, &height);
SConfig::GetInstance().iRenderWindowWidth = width;
SConfig::GetInstance().iRenderWindowHeight = height;
}
m_LogWindow->Refresh();
m_LogWindow->Update();
// We call Renderer::ChangeSurface here to indicate the size has changed,
// but pass the same window handle. This is needed for the Vulkan backend,
// otherwise it cannot tell that the window has been resized on some drivers.
if (g_renderer)
g_renderer->ChangeSurface(GetRenderHandle());
}
event.Skip();
}
void CFrame::ToggleDisplayMode(bool bFullscreen)
{
#ifdef _WIN32
if (bFullscreen && SConfig::GetInstance().strFullscreenResolution != "Auto")
{
DEVMODE dmScreenSettings;
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
sscanf(SConfig::GetInstance().strFullscreenResolution.c_str(), "%dx%d",
&dmScreenSettings.dmPelsWidth, &dmScreenSettings.dmPelsHeight);
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);
}
else
{
// Change to default resolution
ChangeDisplaySettings(nullptr, CDS_FULLSCREEN);
}
#elif defined(HAVE_XRANDR) && HAVE_XRANDR
if (SConfig::GetInstance().strFullscreenResolution != "Auto")
m_XRRConfig->ToggleDisplayMode(bFullscreen);
#endif
}
// Prepare the GUI to start the game.
void CFrame::StartGame(const std::string& filename)
{
if (m_bGameLoading)
return;
m_bGameLoading = true;
if (m_ToolBar)
m_ToolBar->EnableTool(IDM_PLAY, false);
GetMenuBar()->FindItem(IDM_PLAY)->Enable(false);
if (SConfig::GetInstance().bRenderToMain)
{
// Game has been started, hide the game list
m_GameListCtrl->Disable();
m_GameListCtrl->Hide();
m_RenderParent = m_Panel;
m_RenderFrame = this;
if (SConfig::GetInstance().bKeepWindowOnTop)
m_RenderFrame->SetWindowStyle(m_RenderFrame->GetWindowStyle() | wxSTAY_ON_TOP);
else
m_RenderFrame->SetWindowStyle(m_RenderFrame->GetWindowStyle() & ~wxSTAY_ON_TOP);
// No, I really don't want TAB_TRAVERSAL being set behind my back,
// thanks. (Note that calling DisableSelfFocus would prevent this flag
// from being set for new children, but wouldn't reset the existing
// flag.)
m_RenderParent->SetWindowStyle(m_RenderParent->GetWindowStyle() & ~wxTAB_TRAVERSAL);
}
else
{
wxRect window_geometry(
SConfig::GetInstance().iRenderWindowXPos, SConfig::GetInstance().iRenderWindowYPos,
SConfig::GetInstance().iRenderWindowWidth, SConfig::GetInstance().iRenderWindowHeight);
// Set window size in framebuffer pixels since the 3D rendering will be operating at
// that level.
wxSize default_size{wxSize(640, 480) * (1.0 / GetContentScaleFactor())};
m_RenderFrame = new CRenderFrame(this, wxID_ANY, _("Dolphin"), wxDefaultPosition, default_size);
// Convert ClientSize coordinates to frame sizes.
wxSize decoration_fudge = m_RenderFrame->GetSize() - m_RenderFrame->GetClientSize();
default_size += decoration_fudge;
if (!window_geometry.IsEmpty())
window_geometry.SetSize(window_geometry.GetSize() + decoration_fudge);
WxUtils::SetWindowSizeAndFitToScreen(m_RenderFrame, window_geometry.GetPosition(),
window_geometry.GetSize(), default_size);
if (SConfig::GetInstance().bKeepWindowOnTop)
m_RenderFrame->SetWindowStyle(m_RenderFrame->GetWindowStyle() | wxSTAY_ON_TOP);
else
m_RenderFrame->SetWindowStyle(m_RenderFrame->GetWindowStyle() & ~wxSTAY_ON_TOP);
m_RenderFrame->SetBackgroundColour(*wxBLACK);
m_RenderFrame->Bind(wxEVT_CLOSE_WINDOW, &CFrame::OnRenderParentClose, this);
m_RenderFrame->Bind(wxEVT_ACTIVATE, &CFrame::OnActive, this);
m_RenderFrame->Bind(wxEVT_MOVE, &CFrame::OnRenderParentMove, this);
#ifdef _WIN32
// The renderer should use a top-level window for exclusive fullscreen support.
m_RenderParent = m_RenderFrame;
#else
// To capture key events on Linux and Mac OS X the frame needs at least one child.
m_RenderParent = new wxPanel(m_RenderFrame, IDM_MPANEL, wxDefaultPosition, wxDefaultSize, 0);
#endif
m_RenderFrame->Show();
}
#if defined(__APPLE__)
m_RenderFrame->EnableFullScreenView(true);
#endif
wxBusyCursor hourglass;
DoFullscreen(SConfig::GetInstance().bFullscreen);
if (!BootManager::BootCore(filename))
{
DoFullscreen(false);
// Destroy the renderer frame when not rendering to main
if (!SConfig::GetInstance().bRenderToMain)
m_RenderFrame->Destroy();
m_RenderFrame = nullptr;
m_RenderParent = nullptr;
m_bGameLoading = false;
UpdateGUI();
}
else
{
#if defined(HAVE_X11) && HAVE_X11
if (SConfig::GetInstance().bDisableScreenSaver)
X11Utils::InhibitScreensaver(X11Utils::XDisplayFromHandle(GetHandle()),
X11Utils::XWindowFromHandle(GetHandle()), true);
#endif
#ifdef _WIN32
// Prevents Windows from sleeping, turning off the display, or idling
EXECUTION_STATE shouldScreenSave =
SConfig::GetInstance().bDisableScreenSaver ? ES_DISPLAY_REQUIRED : 0;
SetThreadExecutionState(ES_CONTINUOUS | shouldScreenSave | ES_SYSTEM_REQUIRED);
#endif
m_RenderParent->SetFocus();
wxTheApp->Bind(wxEVT_KEY_DOWN, &CFrame::OnKeyDown, this);
wxTheApp->Bind(wxEVT_RIGHT_DOWN, &CFrame::OnMouse, this);
wxTheApp->Bind(wxEVT_RIGHT_UP, &CFrame::OnMouse, this);
wxTheApp->Bind(wxEVT_MIDDLE_DOWN, &CFrame::OnMouse, this);
wxTheApp->Bind(wxEVT_MIDDLE_UP, &CFrame::OnMouse, this);
wxTheApp->Bind(wxEVT_MOTION, &CFrame::OnMouse, this);
wxTheApp->Bind(wxEVT_SET_FOCUS, &CFrame::OnFocusChange, this);
wxTheApp->Bind(wxEVT_KILL_FOCUS, &CFrame::OnFocusChange, this);
m_RenderParent->Bind(wxEVT_SIZE, &CFrame::OnRenderParentResize, this);
}
}
void CFrame::OnBootDrive(wxCommandEvent& event)
{
BootGame(drives[event.GetId() - IDM_DRIVE1]);
}
// Refresh the file list and browse for a favorites directory
void CFrame::OnRefresh(wxCommandEvent& WXUNUSED(event))
{
UpdateGameList();
}
// Create screenshot
void CFrame::OnScreenshot(wxCommandEvent& WXUNUSED(event))
{
Core::SaveScreenShot();
}
// Pause the emulation
void CFrame::DoPause()
{
if (Core::GetState() == Core::CORE_RUN)
{
Core::SetState(Core::CORE_PAUSE);
if (SConfig::GetInstance().bHideCursor)
m_RenderParent->SetCursor(wxNullCursor);
Core::UpdateTitle();
}
else
{
Core::SetState(Core::CORE_RUN);
if (SConfig::GetInstance().bHideCursor && RendererHasFocus())
m_RenderParent->SetCursor(wxCURSOR_BLANK);
}
UpdateGUI();
}
// Stop the emulation
void CFrame::DoStop()
{
if (!Core::IsRunningAndStarted())
return;
if (m_confirmStop)
return;
// don't let this function run again until it finishes, or is aborted.
m_confirmStop = true;
m_bGameLoading = false;
if (Core::GetState() != Core::CORE_UNINITIALIZED || m_RenderParent != nullptr)
{
#if defined __WXGTK__
wxMutexGuiLeave();
std::lock_guard<std::recursive_mutex> lk(keystate_lock);
wxMutexGuiEnter();
#endif
// Ask for confirmation in case the user accidentally clicked Stop / Escape
if (SConfig::GetInstance().bConfirmStop)
{
// Exit fullscreen to ensure it does not cover the stop dialog.
DoFullscreen(false);
// Pause the state during confirmation and restore it afterwards
Core::EState state = Core::GetState();
// Do not pause if netplay is running as CPU thread might be blocked
// waiting on inputs
bool should_pause = !NetPlayDialog::GetNetPlayClient();
// If exclusive fullscreen is not enabled then we can pause the emulation
// before we've exited fullscreen. If not then we need to exit fullscreen first.
should_pause =
should_pause && (!RendererIsFullscreen() || !g_Config.ExclusiveFullscreenEnabled() ||
SConfig::GetInstance().bRenderToMain);
if (should_pause)
{
Core::SetState(Core::CORE_PAUSE);
}
wxMessageDialog m_StopDlg(
this, !m_tried_graceful_shutdown ? _("Do you want to stop the current emulation?") :
_("A shutdown is already in progress. Unsaved data "
"may be lost if you stop the current emulation "
"before it completes. Force stop?"),
_("Please confirm..."), wxYES_NO | wxSTAY_ON_TOP | wxICON_EXCLAMATION, wxDefaultPosition);
HotkeyManagerEmu::Enable(false);
int Ret = m_StopDlg.ShowModal();
HotkeyManagerEmu::Enable(true);
if (Ret != wxID_YES)
{
if (should_pause)
Core::SetState(state);
m_confirmStop = false;
return;
}
}
if (SConfig::GetInstance().bWii && !m_tried_graceful_shutdown)
{
Core::DisplayMessage("Shutting down", 30000);
Core::SetState(Core::CORE_RUN);
ProcessorInterface::PowerButton_Tap();
m_confirmStop = false;
m_tried_graceful_shutdown = true;
return;
}
if (UseDebugger && g_pCodeWindow)
{
if (g_pCodeWindow->HasPanel<CWatchWindow>())
g_pCodeWindow->GetPanel<CWatchWindow>()->SaveAll();
PowerPC::watches.Clear();
if (g_pCodeWindow->HasPanel<CBreakPointWindow>())
g_pCodeWindow->GetPanel<CBreakPointWindow>()->SaveAll();
PowerPC::breakpoints.Clear();
PowerPC::memchecks.Clear();
if (g_pCodeWindow->HasPanel<CBreakPointWindow>())
g_pCodeWindow->GetPanel<CBreakPointWindow>()->NotifyUpdate();
g_symbolDB.Clear();
Host_NotifyMapLoaded();
}
// TODO: Show the author/description dialog here
if (Movie::IsRecordingInput())
DoRecordingSave();
if (Movie::IsMovieActive())
Movie::EndPlayInput(false);
if (NetPlayDialog::GetNetPlayClient())
NetPlayDialog::GetNetPlayClient()->Stop();
Core::Stop();
UpdateGUI();
}
}
void CFrame::OnStopped()
{
m_confirmStop = false;
m_tried_graceful_shutdown = false;
#if defined(HAVE_X11) && HAVE_X11
if (SConfig::GetInstance().bDisableScreenSaver)
X11Utils::InhibitScreensaver(X11Utils::XDisplayFromHandle(GetHandle()),
X11Utils::XWindowFromHandle(GetHandle()), false);
#endif
#ifdef _WIN32
// Allow windows to resume normal idling behavior
SetThreadExecutionState(ES_CONTINUOUS);
#endif
m_RenderFrame->SetTitle(StrToWxStr(scm_rev_str));
// Destroy the renderer frame when not rendering to main
m_RenderParent->Unbind(wxEVT_SIZE, &CFrame::OnRenderParentResize, this);
// Mouse
wxTheApp->Unbind(wxEVT_RIGHT_DOWN, &CFrame::OnMouse, this);
wxTheApp->Unbind(wxEVT_RIGHT_UP, &CFrame::OnMouse, this);
wxTheApp->Unbind(wxEVT_MIDDLE_DOWN, &CFrame::OnMouse, this);
wxTheApp->Unbind(wxEVT_MIDDLE_UP, &CFrame::OnMouse, this);
wxTheApp->Unbind(wxEVT_MOTION, &CFrame::OnMouse, this);
if (SConfig::GetInstance().bHideCursor)
m_RenderParent->SetCursor(wxNullCursor);
DoFullscreen(false);
if (!SConfig::GetInstance().bRenderToMain)
{
m_RenderFrame->Destroy();
}
else
{
#if defined(__APPLE__)
// Disable the full screen button when not in a game.
m_RenderFrame->EnableFullScreenView(false);
#endif
// Make sure the window is not longer set to stay on top
m_RenderFrame->SetWindowStyle(m_RenderFrame->GetWindowStyle() & ~wxSTAY_ON_TOP);
}
m_RenderParent = nullptr;
// Clean framerate indications from the status bar.
GetStatusBar()->SetStatusText(" ", 0);
// Clear wiimote connection status from the status bar.
GetStatusBar()->SetStatusText(" ", 1);
// If batch mode was specified on the command-line or we were already closing, exit now.
if (m_bBatchMode || m_bClosing)
Close(true);
// If using auto size with render to main, reset the application size.
if (SConfig::GetInstance().bRenderToMain && SConfig::GetInstance().bRenderWindowAutoSize)
SetSize(SConfig::GetInstance().iWidth, SConfig::GetInstance().iHeight);
m_GameListCtrl->Enable();
m_GameListCtrl->Show();
m_GameListCtrl->SetFocus();
UpdateGUI();
}
void CFrame::DoRecordingSave()
{
bool paused = (Core::GetState() == Core::CORE_PAUSE);
if (!paused)
DoPause();
wxString path =
wxFileSelector(_("Select The Recording File"), wxEmptyString, wxEmptyString, wxEmptyString,
_("Dolphin TAS Movies (*.dtm)") +
wxString::Format("|*.dtm|%s", wxGetTranslation(wxALL_FILES)),
wxFD_SAVE | wxFD_PREVIEW | wxFD_OVERWRITE_PROMPT, this);
if (path.IsEmpty())
return;
Movie::SaveRecording(WxStrToStr(path));
if (!paused)
DoPause();
}
void CFrame::OnStop(wxCommandEvent& WXUNUSED(event))
{
DoStop();
}
void CFrame::OnReset(wxCommandEvent& WXUNUSED(event))
{
if (Movie::IsRecordingInput())
Movie::SetReset(true);
ProcessorInterface::ResetButton_Tap();
}
void CFrame::OnConfigMain(wxCommandEvent& WXUNUSED(event))
{
OpenGeneralConfiguration();
}
void CFrame::OnConfigGFX(wxCommandEvent& WXUNUSED(event))
{
HotkeyManagerEmu::Enable(false);
if (g_video_backend)
g_video_backend->ShowConfig(this);
HotkeyManagerEmu::Enable(true);
}
void CFrame::OnConfigAudio(wxCommandEvent& WXUNUSED(event))
{
OpenGeneralConfiguration(CConfigMain::ID_AUDIOPAGE);
}
void CFrame::OnConfigControllers(wxCommandEvent& WXUNUSED(event))
{
ControllerConfigDiag config_dlg(this);
HotkeyManagerEmu::Enable(false);
config_dlg.ShowModal();
HotkeyManagerEmu::Enable(true);
}
void CFrame::OnConfigHotkey(wxCommandEvent& WXUNUSED(event))
{
InputConfig* const hotkey_plugin = HotkeyManagerEmu::GetConfig();
// check if game is running
bool game_running = false;
if (Core::GetState() == Core::CORE_RUN)
{
Core::SetState(Core::CORE_PAUSE);
game_running = true;
}
HotkeyManagerEmu::Enable(false);
InputConfigDialog m_ConfigFrame(this, *hotkey_plugin, _("Dolphin Hotkeys"));
m_ConfigFrame.ShowModal();
// Update references in case controllers were refreshed
Wiimote::LoadConfig();
Keyboard::LoadConfig();
Pad::LoadConfig();
HotkeyManagerEmu::LoadConfig();
HotkeyManagerEmu::Enable(true);
// if game isn't running
if (game_running)
{
Core::SetState(Core::CORE_RUN);
}
// Update the GUI in case menu accelerators were changed
UpdateGUI();
}
void CFrame::OnHelp(wxCommandEvent& event)
{
switch (event.GetId())
{
case wxID_ABOUT:
{
AboutDolphin frame(this);
HotkeyManagerEmu::Enable(false);
frame.ShowModal();
HotkeyManagerEmu::Enable(true);
}
break;
case IDM_HELP_WEBSITE:
WxUtils::Launch("https://dolphin-emu.org/");
break;
case IDM_HELP_ONLINE_DOCS:
WxUtils::Launch("https://dolphin-emu.org/docs/guides/");
break;
case IDM_HELP_GITHUB:
WxUtils::Launch("https://github.com/dolphin-emu/dolphin");
break;
}
}
void CFrame::ClearStatusBar()
{
if (this->GetStatusBar()->IsEnabled())
{
this->GetStatusBar()->SetStatusText("", 0);
}
}
void CFrame::StatusBarMessage(const char* Text, ...)
{
const int MAX_BYTES = 1024 * 10;
char Str[MAX_BYTES];
va_list ArgPtr;
va_start(ArgPtr, Text);
vsnprintf(Str, MAX_BYTES, Text, ArgPtr);
va_end(ArgPtr);
if (this->GetStatusBar()->IsEnabled())
{
this->GetStatusBar()->SetStatusText(StrToWxStr(Str), 0);
}
}
// Miscellaneous menus
// ---------------------
// NetPlay stuff
void CFrame::OnNetPlay(wxCommandEvent& WXUNUSED(event))
{
if (!g_NetPlaySetupDiag)
{
if (NetPlayDialog::GetInstance() != nullptr)
NetPlayDialog::GetInstance()->Raise();
else
g_NetPlaySetupDiag = new NetPlaySetupFrame(this, m_GameListCtrl);
}
else
{
g_NetPlaySetupDiag->Raise();
}
}
void CFrame::OnMemcard(wxCommandEvent& WXUNUSED(event))
{
CMemcardManager MemcardManager(this);
HotkeyManagerEmu::Enable(false);
MemcardManager.ShowModal();
HotkeyManagerEmu::Enable(true);
}
void CFrame::OnExportAllSaves(wxCommandEvent& WXUNUSED(event))
{
CWiiSaveCrypted::ExportAllSaves();
}
void CFrame::OnImportSave(wxCommandEvent& WXUNUSED(event))
{
wxString path =
wxFileSelector(_("Select the save file"), wxEmptyString, wxEmptyString, wxEmptyString,
_("Wii save files (*.bin)") + "|*.bin|" + wxGetTranslation(wxALL_FILES),
wxFD_OPEN | wxFD_PREVIEW | wxFD_FILE_MUST_EXIST, this);
if (!path.IsEmpty())
CWiiSaveCrypted::ImportWiiSave(WxStrToStr(path));
}
void CFrame::OnShowCheatsWindow(wxCommandEvent& WXUNUSED(event))
{
if (!g_CheatsWindow)
g_CheatsWindow = new wxCheatsWindow(this);
else
g_CheatsWindow->Raise();
}
void CFrame::OnLoadWiiMenu(wxCommandEvent& WXUNUSED(event))
{
BootGame(Common::GetTitleContentPath(TITLEID_SYSMENU, Common::FROM_CONFIGURED_ROOT));
}
void CFrame::OnInstallWAD(wxCommandEvent& event)
{
std::string fileName;
switch (event.GetId())
{
case IDM_LIST_INSTALL_WAD:
{
const GameListItem* iso = m_GameListCtrl->GetSelectedISO();
if (!iso)
return;
fileName = iso->GetFileName();
break;
}
case IDM_MENU_INSTALL_WAD:
{
wxString path = wxFileSelector(
_("Select a Wii WAD file to install"), wxEmptyString, wxEmptyString, wxEmptyString,
_("Wii WAD files (*.wad)") + "|*.wad|" + wxGetTranslation(wxALL_FILES),
wxFD_OPEN | wxFD_PREVIEW | wxFD_FILE_MUST_EXIST, this);
fileName = WxStrToStr(path);
break;
}
default:
return;
}
wxProgressDialog dialog(_("Installing WAD..."), _("Working..."), 1000, this,
wxPD_APP_MODAL | wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME |
wxPD_REMAINING_TIME | wxPD_SMOOTH);
u64 titleID = DiscIO::CNANDContentManager::Access().Install_WiiWAD(fileName);
if (titleID == TITLEID_SYSMENU)
{
UpdateWiiMenuChoice();
}
}
void CFrame::UpdateWiiMenuChoice(wxMenuItem* WiiMenuItem)
{
if (!WiiMenuItem)
{
WiiMenuItem = GetMenuBar()->FindItem(IDM_LOAD_WII_MENU);
}
const DiscIO::CNANDContentLoader& SysMenu_Loader =
DiscIO::CNANDContentManager::Access().GetNANDLoader(TITLEID_SYSMENU,
Common::FROM_CONFIGURED_ROOT);
if (SysMenu_Loader.IsValid())
{
int sysmenuVersion = SysMenu_Loader.GetTitleVersion();
char sysmenuRegion = SysMenu_Loader.GetCountryChar();
WiiMenuItem->Enable();
WiiMenuItem->SetItemLabel(
wxString::Format(_("Load Wii System Menu %d%c"), sysmenuVersion, sysmenuRegion));
}
else
{
WiiMenuItem->Enable(false);
WiiMenuItem->SetItemLabel(_("Load Wii System Menu"));
}
}
void CFrame::OnFifoPlayer(wxCommandEvent& WXUNUSED(event))
{
if (m_FifoPlayerDlg)
{
m_FifoPlayerDlg->Show();
m_FifoPlayerDlg->SetFocus();
}
else
{
m_FifoPlayerDlg = new FifoPlayerDlg(this);
}
}
void CFrame::ConnectWiimote(int wm_idx, bool connect)
{
if (Core::IsRunning() && SConfig::GetInstance().bWii &&
!SConfig::GetInstance().m_bt_passthrough_enabled)
{
bool was_unpaused = Core::PauseAndLock(true);
GetUsbPointer()->AccessWiiMote(wm_idx | 0x100)->Activate(connect);
const char* message = connect ? "Wiimote %i connected" : "Wiimote %i disconnected";
Core::DisplayMessage(StringFromFormat(message, wm_idx + 1), 3000);
Host_UpdateMainFrame();
Core::PauseAndLock(false, was_unpaused);
}
}
void CFrame::OnConnectWiimote(wxCommandEvent& event)
{
if (SConfig::GetInstance().m_bt_passthrough_enabled)
return;
bool was_unpaused = Core::PauseAndLock(true);
ConnectWiimote(event.GetId() - IDM_CONNECT_WIIMOTE1,
!GetUsbPointer()
->AccessWiiMote((event.GetId() - IDM_CONNECT_WIIMOTE1) | 0x100)
->IsConnected());
Core::PauseAndLock(false, was_unpaused);
}
// Toggle fullscreen. In Windows the fullscreen mode is accomplished by expanding the m_Panel to
// cover
// the entire screen (when we render to the main window).
void CFrame::OnToggleFullscreen(wxCommandEvent& WXUNUSED(event))
{
DoFullscreen(!RendererIsFullscreen());
}
void CFrame::OnToggleDualCore(wxCommandEvent& WXUNUSED(event))
{
SConfig::GetInstance().bCPUThread = !SConfig::GetInstance().bCPUThread;
SConfig::GetInstance().SaveSettings();
}
void CFrame::OnLoadStateFromFile(wxCommandEvent& WXUNUSED(event))
{
wxString path =
wxFileSelector(_("Select the state to load"), wxEmptyString, wxEmptyString, wxEmptyString,
_("All Save States (sav, s##)") +
wxString::Format("|*.sav;*.s??|%s", wxGetTranslation(wxALL_FILES)),
wxFD_OPEN | wxFD_PREVIEW | wxFD_FILE_MUST_EXIST, this);
if (!path.IsEmpty())
State::LoadAs(WxStrToStr(path));
}
void CFrame::OnSaveStateToFile(wxCommandEvent& WXUNUSED(event))
{
wxString path =
wxFileSelector(_("Select the state to save"), wxEmptyString, wxEmptyString, wxEmptyString,
_("All Save States (sav, s##)") +
wxString::Format("|*.sav;*.s??|%s", wxGetTranslation(wxALL_FILES)),
wxFD_SAVE, this);
if (!path.IsEmpty())
State::SaveAs(WxStrToStr(path));
}
void CFrame::OnLoadLastState(wxCommandEvent& event)
{
if (Core::IsRunningAndStarted())
{
int id = event.GetId();
int slot = id - IDM_LOAD_LAST_1 + 1;
State::LoadLastSaved(slot);
}
}
void CFrame::OnSaveFirstState(wxCommandEvent& WXUNUSED(event))
{
if (Core::IsRunningAndStarted())
State::SaveFirstSaved();
}
void CFrame::OnUndoLoadState(wxCommandEvent& WXUNUSED(event))
{
if (Core::IsRunningAndStarted())
State::UndoLoadState();
}
void CFrame::OnUndoSaveState(wxCommandEvent& WXUNUSED(event))
{
if (Core::IsRunningAndStarted())
State::UndoSaveState();
}
void CFrame::OnLoadState(wxCommandEvent& event)
{
if (Core::IsRunningAndStarted())
{
int id = event.GetId();
int slot = id - IDM_LOAD_SLOT_1 + 1;
State::Load(slot);
}
}
void CFrame::OnSaveState(wxCommandEvent& event)
{
if (Core::IsRunningAndStarted())
{
int id = event.GetId();
int slot = id - IDM_SAVE_SLOT_1 + 1;
State::Save(slot);
}
}
void CFrame::OnSelectSlot(wxCommandEvent& event)
{
m_saveSlot = event.GetId() - IDM_SELECT_SLOT_1 + 1;
Core::DisplayMessage(StringFromFormat("Selected slot %d - %s", m_saveSlot,
State::GetInfoStringOfSlot(m_saveSlot, false).c_str()),
2500);
}
void CFrame::OnLoadCurrentSlot(wxCommandEvent& event)
{
if (Core::IsRunningAndStarted())
{
State::Load(m_saveSlot);
}
}
void CFrame::OnSaveCurrentSlot(wxCommandEvent& event)
{
if (Core::IsRunningAndStarted())
{
State::Save(m_saveSlot);
}
}
// GUI
// ---------------------
// Update the enabled/disabled status
void CFrame::UpdateGUI()
{
// Save status
bool Initialized = Core::IsRunning();
bool Running = Core::GetState() == Core::CORE_RUN;
bool Paused = Core::GetState() == Core::CORE_PAUSE;
bool Stopping = Core::GetState() == Core::CORE_STOPPING;
// Make sure that we have a toolbar
if (m_ToolBar)
{
// Enable/disable the Config and Stop buttons
m_ToolBar->EnableTool(wxID_OPEN, !Initialized);
// Don't allow refresh when we don't show the list
m_ToolBar->EnableTool(wxID_REFRESH, !Initialized);
m_ToolBar->EnableTool(IDM_STOP, Running || Paused);
m_ToolBar->EnableTool(IDM_TOGGLE_FULLSCREEN, Running || Paused);
m_ToolBar->EnableTool(IDM_SCREENSHOT, Running || Paused);
}
// File
GetMenuBar()->FindItem(wxID_OPEN)->Enable(!Initialized);
GetMenuBar()->FindItem(IDM_DRIVES)->Enable(!Initialized);
GetMenuBar()->FindItem(wxID_REFRESH)->Enable(!Initialized);
// Emulation
GetMenuBar()->FindItem(IDM_STOP)->Enable(Running || Paused);
GetMenuBar()->FindItem(IDM_RESET)->Enable(Running || Paused);
GetMenuBar()->FindItem(IDM_RECORD)->Enable(!Movie::IsRecordingInput());
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);
// Update Key Shortcuts
for (unsigned int i = 0; i < NUM_HOTKEYS; i++)
{
if (GetCmdForHotkey(i) == -1)
continue;
if (GetMenuBar()->FindItem(GetCmdForHotkey(i)))
GetMenuBar()->FindItem(GetCmdForHotkey(i))->SetItemLabel(GetMenuLabel(i));
}
GetMenuBar()->FindItem(IDM_LOAD_STATE)->Enable(Initialized);
GetMenuBar()->FindItem(IDM_SAVE_STATE)->Enable(Initialized);
// Misc
GetMenuBar()->FindItem(IDM_CHANGE_DISC)->Enable(Initialized);
if (DiscIO::CNANDContentManager::Access()
.GetNANDLoader(TITLEID_SYSMENU, Common::FROM_CONFIGURED_ROOT)
.IsValid())
GetMenuBar()->FindItem(IDM_LOAD_WII_MENU)->Enable(!Initialized);
// Tools
GetMenuBar()->FindItem(IDM_CHEATS)->Enable(SConfig::GetInstance().bEnableCheats);
bool ShouldEnableWiimotes = Initialized && SConfig::GetInstance().bWii &&
!SConfig::GetInstance().m_bt_passthrough_enabled;
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE1)->Enable(ShouldEnableWiimotes);
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE2)->Enable(ShouldEnableWiimotes);
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE3)->Enable(ShouldEnableWiimotes);
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE4)->Enable(ShouldEnableWiimotes);
GetMenuBar()->FindItem(IDM_CONNECT_BALANCEBOARD)->Enable(ShouldEnableWiimotes);
if (ShouldEnableWiimotes)
{
bool was_unpaused = Core::PauseAndLock(true);
GetMenuBar()
->FindItem(IDM_CONNECT_WIIMOTE1)
->Check(GetUsbPointer()->AccessWiiMote(0x0100)->IsConnected());
GetMenuBar()
->FindItem(IDM_CONNECT_WIIMOTE2)
->Check(GetUsbPointer()->AccessWiiMote(0x0101)->IsConnected());
GetMenuBar()
->FindItem(IDM_CONNECT_WIIMOTE3)
->Check(GetUsbPointer()->AccessWiiMote(0x0102)->IsConnected());
GetMenuBar()
->FindItem(IDM_CONNECT_WIIMOTE4)
->Check(GetUsbPointer()->AccessWiiMote(0x0103)->IsConnected());
GetMenuBar()
->FindItem(IDM_CONNECT_BALANCEBOARD)
->Check(GetUsbPointer()->AccessWiiMote(0x0104)->IsConnected());
Core::PauseAndLock(false, was_unpaused);
}
if (m_ToolBar)
{
// Get the tool that controls pausing/playing
wxToolBarToolBase* PlayTool = m_ToolBar->FindById(IDM_PLAY);
if (PlayTool)
{
int position = m_ToolBar->GetToolPos(IDM_PLAY);
if (Running)
{
m_ToolBar->DeleteTool(IDM_PLAY);
m_ToolBar->InsertTool(position, IDM_PLAY, _("Pause"), m_Bitmaps[Toolbar_Pause],
WxUtils::CreateDisabledButtonBitmap(m_Bitmaps[Toolbar_Pause]),
wxITEM_NORMAL, _("Pause"));
}
else
{
m_ToolBar->DeleteTool(IDM_PLAY);
m_ToolBar->InsertTool(position, IDM_PLAY, _("Play"), m_Bitmaps[Toolbar_Play],
WxUtils::CreateDisabledButtonBitmap(m_Bitmaps[Toolbar_Play]),
wxITEM_NORMAL, _("Play"));
}
m_ToolBar->Realize();
}
}
GetMenuBar()->FindItem(IDM_RECORD_READ_ONLY)->Enable(Running || Paused);
if (!Initialized && !m_bGameLoading)
{
if (m_GameListCtrl->IsEnabled())
{
// Prepare to load Default ISO, enable play button
if (!SConfig::GetInstance().m_strDefaultISO.empty())
{
if (m_ToolBar)
m_ToolBar->EnableTool(IDM_PLAY, true);
GetMenuBar()->FindItem(IDM_PLAY)->Enable();
GetMenuBar()->FindItem(IDM_RECORD)->Enable();
GetMenuBar()->FindItem(IDM_PLAY_RECORD)->Enable();
}
// Prepare to load last selected file, enable play button
else if (!SConfig::GetInstance().m_LastFilename.empty() &&
File::Exists(SConfig::GetInstance().m_LastFilename))
{
if (m_ToolBar)
m_ToolBar->EnableTool(IDM_PLAY, true);
GetMenuBar()->FindItem(IDM_PLAY)->Enable();
GetMenuBar()->FindItem(IDM_RECORD)->Enable();
GetMenuBar()->FindItem(IDM_PLAY_RECORD)->Enable();
}
else
{
// No game has been selected yet, disable play button
if (m_ToolBar)
m_ToolBar->EnableTool(IDM_PLAY, false);
GetMenuBar()->FindItem(IDM_PLAY)->Enable(false);
GetMenuBar()->FindItem(IDM_RECORD)->Enable(false);
GetMenuBar()->FindItem(IDM_PLAY_RECORD)->Enable(false);
}
}
// Game has not started, show game list
if (!m_GameListCtrl->IsShown())
{
m_GameListCtrl->Enable();
m_GameListCtrl->Show();
}
// Game has been selected but not started, enable play button
if (m_GameListCtrl->GetSelectedISO() != nullptr && m_GameListCtrl->IsEnabled())
{
if (m_ToolBar)
m_ToolBar->EnableTool(IDM_PLAY, true);
GetMenuBar()->FindItem(IDM_PLAY)->Enable();
GetMenuBar()->FindItem(IDM_RECORD)->Enable();
GetMenuBar()->FindItem(IDM_PLAY_RECORD)->Enable();
}
}
else if (Initialized)
{
// Game has been loaded, enable the pause button
if (m_ToolBar)
m_ToolBar->EnableTool(IDM_PLAY, !Stopping);
GetMenuBar()->FindItem(IDM_PLAY)->Enable(!Stopping);
// Reset game loading flag
m_bGameLoading = false;
}
// Refresh toolbar
if (m_ToolBar)
{
m_ToolBar->Refresh();
}
// Commit changes to manager
m_Mgr->Update();
// Update non-modal windows
if (g_CheatsWindow)
{
if (SConfig::GetInstance().bEnableCheats)
g_CheatsWindow->UpdateGUI();
else
g_CheatsWindow->Close();
}
}
void CFrame::UpdateGameList()
{
if (m_GameListCtrl)
m_GameListCtrl->ReloadList();
}
void CFrame::GameListChanged(wxCommandEvent& event)
{
switch (event.GetId())
{
case IDM_LIST_WII:
SConfig::GetInstance().m_ListWii = event.IsChecked();
break;
case IDM_LIST_GC:
SConfig::GetInstance().m_ListGC = event.IsChecked();
break;
case IDM_LIST_WAD:
SConfig::GetInstance().m_ListWad = event.IsChecked();
break;
case IDM_LIST_ELFDOL:
SConfig::GetInstance().m_ListElfDol = event.IsChecked();
break;
case IDM_LIST_JAP:
SConfig::GetInstance().m_ListJap = event.IsChecked();
break;
case IDM_LIST_PAL:
SConfig::GetInstance().m_ListPal = event.IsChecked();
break;
case IDM_LIST_USA:
SConfig::GetInstance().m_ListUsa = event.IsChecked();
break;
case IDM_LIST_AUSTRALIA:
SConfig::GetInstance().m_ListAustralia = event.IsChecked();
break;
case IDM_LIST_FRANCE:
SConfig::GetInstance().m_ListFrance = event.IsChecked();
break;
case IDM_LIST_GERMANY:
SConfig::GetInstance().m_ListGermany = event.IsChecked();
break;
case IDM_LIST_ITALY:
SConfig::GetInstance().m_ListItaly = event.IsChecked();
break;
case IDM_LIST_KOREA:
SConfig::GetInstance().m_ListKorea = event.IsChecked();
break;
case IDM_LIST_NETHERLANDS:
SConfig::GetInstance().m_ListNetherlands = event.IsChecked();
break;
case IDM_LIST_RUSSIA:
SConfig::GetInstance().m_ListRussia = event.IsChecked();
break;
case IDM_LIST_SPAIN:
SConfig::GetInstance().m_ListSpain = event.IsChecked();
break;
case IDM_LIST_TAIWAN:
SConfig::GetInstance().m_ListTaiwan = event.IsChecked();
break;
case IDM_LIST_WORLD:
SConfig::GetInstance().m_ListWorld = event.IsChecked();
break;
case IDM_LIST_UNKNOWN:
SConfig::GetInstance().m_ListUnknown = event.IsChecked();
break;
case IDM_LIST_DRIVES:
SConfig::GetInstance().m_ListDrives = event.IsChecked();
break;
case IDM_PURGE_GAME_LIST_CACHE:
std::vector<std::string> rFilenames =
DoFileSearch({".cache"}, {File::GetUserPath(D_CACHE_IDX)});
for (const std::string& rFilename : rFilenames)
{
File::Delete(rFilename);
}
break;
}
UpdateGameList();
}
// Enable and disable the toolbar
void CFrame::OnToggleToolbar(wxCommandEvent& event)
{
SConfig::GetInstance().m_InterfaceToolbar = event.IsChecked();
DoToggleToolbar(event.IsChecked());
}
void CFrame::DoToggleToolbar(bool _show)
{
GetToolBar()->Show(_show);
m_Mgr->Update();
}
// Enable and disable the status bar
void CFrame::OnToggleStatusbar(wxCommandEvent& event)
{
SConfig::GetInstance().m_InterfaceStatusbar = event.IsChecked();
GetStatusBar()->Show(event.IsChecked());
SendSizeEvent();
}
void CFrame::OnChangeColumnsVisible(wxCommandEvent& event)
{
switch (event.GetId())
{
case IDM_SHOW_SYSTEM:
SConfig::GetInstance().m_showSystemColumn = !SConfig::GetInstance().m_showSystemColumn;
break;
case IDM_SHOW_BANNER:
SConfig::GetInstance().m_showBannerColumn = !SConfig::GetInstance().m_showBannerColumn;
break;
case IDM_SHOW_MAKER:
SConfig::GetInstance().m_showMakerColumn = !SConfig::GetInstance().m_showMakerColumn;
break;
case IDM_SHOW_FILENAME:
SConfig::GetInstance().m_showFileNameColumn = !SConfig::GetInstance().m_showFileNameColumn;
break;
case IDM_SHOW_ID:
SConfig::GetInstance().m_showIDColumn = !SConfig::GetInstance().m_showIDColumn;
break;
case IDM_SHOW_REGION:
SConfig::GetInstance().m_showRegionColumn = !SConfig::GetInstance().m_showRegionColumn;
break;
case IDM_SHOW_SIZE:
SConfig::GetInstance().m_showSizeColumn = !SConfig::GetInstance().m_showSizeColumn;
break;
case IDM_SHOW_STATE:
SConfig::GetInstance().m_showStateColumn = !SConfig::GetInstance().m_showStateColumn;
break;
default:
return;
}
UpdateGameList();
SConfig::GetInstance().SaveSettings();
}
Reference in New Issue View Git Blame Copy Permalink