2015-12-20 05:24:48 +00:00
|
|
|
// Copyright 2015 Dolphin Emulator Project
|
|
|
|
// Licensed under GPLv2+
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2018-07-06 22:40:15 +00:00
|
|
|
#include "DolphinQt/MenuBar.h"
|
2017-08-24 15:38:31 +00:00
|
|
|
|
2017-11-02 10:37:51 +00:00
|
|
|
#include <cinttypes>
|
|
|
|
|
2015-12-20 05:24:48 +00:00
|
|
|
#include <QAction>
|
2016-02-11 11:59:44 +00:00
|
|
|
#include <QDesktopServices>
|
2017-05-04 21:01:12 +00:00
|
|
|
#include <QFileDialog>
|
2018-02-14 22:25:01 +00:00
|
|
|
#include <QFontDialog>
|
|
|
|
#include <QInputDialog>
|
2017-05-08 17:03:59 +00:00
|
|
|
#include <QMap>
|
2016-02-11 11:59:44 +00:00
|
|
|
#include <QUrl>
|
2015-12-20 05:24:48 +00:00
|
|
|
|
2017-08-24 14:35:47 +00:00
|
|
|
#include "Common/CommonPaths.h"
|
|
|
|
#include "Common/FileUtil.h"
|
2017-11-02 10:37:51 +00:00
|
|
|
#include "Common/StringUtil.h"
|
2017-11-02 16:34:04 +00:00
|
|
|
|
2018-03-23 00:18:53 +00:00
|
|
|
#include "Common/CDUtils.h"
|
2018-02-14 22:25:01 +00:00
|
|
|
#include "Core/Boot/Boot.h"
|
2017-06-14 09:58:11 +00:00
|
|
|
#include "Core/CommonTitles.h"
|
2017-06-22 22:11:53 +00:00
|
|
|
#include "Core/ConfigManager.h"
|
2017-08-27 11:55:05 +00:00
|
|
|
#include "Core/Core.h"
|
2018-02-14 22:25:01 +00:00
|
|
|
#include "Core/Debugger/RSO.h"
|
|
|
|
#include "Core/HLE/HLE.h"
|
2020-03-10 09:41:59 +00:00
|
|
|
#include "Core/HW/AddressSpace.h"
|
2020-04-28 17:10:50 +00:00
|
|
|
#include "Core/HW/Memmap.h"
|
2018-05-12 20:39:14 +00:00
|
|
|
#include "Core/HW/WiiSave.h"
|
2017-08-27 11:55:05 +00:00
|
|
|
#include "Core/HW/Wiimote.h"
|
2017-06-14 09:58:11 +00:00
|
|
|
#include "Core/IOS/ES/ES.h"
|
|
|
|
#include "Core/IOS/IOS.h"
|
2018-01-24 14:25:35 +00:00
|
|
|
#include "Core/IOS/USB/Bluetooth/BTEmu.h"
|
2017-08-27 11:55:05 +00:00
|
|
|
#include "Core/Movie.h"
|
2018-11-23 10:02:00 +00:00
|
|
|
#include "Core/NetPlayProto.h"
|
2018-04-09 13:31:20 +00:00
|
|
|
#include "Core/PowerPC/JitInterface.h"
|
2018-05-17 21:09:55 +00:00
|
|
|
#include "Core/PowerPC/MMU.h"
|
2018-02-14 22:25:01 +00:00
|
|
|
#include "Core/PowerPC/PPCAnalyst.h"
|
|
|
|
#include "Core/PowerPC/PPCSymbolDB.h"
|
2018-04-09 13:31:20 +00:00
|
|
|
#include "Core/PowerPC/PowerPC.h"
|
2018-02-14 22:25:01 +00:00
|
|
|
#include "Core/PowerPC/SignatureDB/SignatureDB.h"
|
2016-02-15 01:56:40 +00:00
|
|
|
#include "Core/State.h"
|
2017-10-06 19:45:28 +00:00
|
|
|
#include "Core/TitleDatabase.h"
|
2017-10-03 14:45:59 +00:00
|
|
|
#include "Core/WiiUtils.h"
|
2017-11-02 16:34:04 +00:00
|
|
|
|
2019-02-23 18:18:16 +00:00
|
|
|
#include "DiscIO/Enums.h"
|
2017-08-24 15:38:31 +00:00
|
|
|
#include "DiscIO/NANDImporter.h"
|
2017-11-02 16:34:04 +00:00
|
|
|
#include "DiscIO/WiiSaveBanner.h"
|
|
|
|
|
2018-07-06 22:40:15 +00:00
|
|
|
#include "DolphinQt/AboutDialog.h"
|
|
|
|
#include "DolphinQt/Host.h"
|
2019-03-04 19:49:00 +00:00
|
|
|
#include "DolphinQt/QtUtils/ModalMessageBox.h"
|
2018-07-06 22:40:15 +00:00
|
|
|
#include "DolphinQt/Settings.h"
|
|
|
|
#include "DolphinQt/Updater.h"
|
2015-12-20 05:24:48 +00:00
|
|
|
|
2019-02-26 19:40:38 +00:00
|
|
|
#include "UICommon/AutoUpdate.h"
|
2017-12-31 19:33:36 +00:00
|
|
|
#include "UICommon/GameFile.h"
|
|
|
|
|
2019-01-21 20:05:31 +00:00
|
|
|
QPointer<MenuBar> MenuBar::s_menu_bar;
|
|
|
|
|
2019-10-12 16:04:51 +00:00
|
|
|
QString MenuBar::GetSignatureSelector() const
|
|
|
|
{
|
|
|
|
return QStringLiteral("%1 (*.dsy);; %2 (*.csv);; %3 (*.mega)")
|
|
|
|
.arg(tr("Dolphin Signature File"), tr("Dolphin Signature CSV File"),
|
|
|
|
tr("WiiTools Signature MEGA File"));
|
|
|
|
}
|
|
|
|
|
2015-12-20 05:24:48 +00:00
|
|
|
MenuBar::MenuBar(QWidget* parent) : QMenuBar(parent)
|
|
|
|
{
|
2019-01-21 20:05:31 +00:00
|
|
|
s_menu_bar = this;
|
|
|
|
|
2015-12-20 05:24:48 +00:00
|
|
|
AddFileMenu();
|
2016-02-15 01:56:40 +00:00
|
|
|
AddEmulationMenu();
|
2017-08-27 11:55:05 +00:00
|
|
|
AddMovieMenu();
|
2017-06-06 11:49:49 +00:00
|
|
|
AddOptionsMenu();
|
2017-05-04 21:01:12 +00:00
|
|
|
AddToolsMenu();
|
2015-12-20 05:24:48 +00:00
|
|
|
AddViewMenu();
|
2018-04-09 13:31:20 +00:00
|
|
|
AddJITMenu();
|
2018-02-14 22:25:01 +00:00
|
|
|
AddSymbolsMenu();
|
2016-02-11 11:59:44 +00:00
|
|
|
AddHelpMenu();
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-09-04 18:12:13 +00:00
|
|
|
connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
|
|
|
|
[=](Core::State state) { OnEmulationStateChanged(state); });
|
2018-05-05 22:17:06 +00:00
|
|
|
connect(Host::GetInstance(), &Host::UpdateDisasmDialog, this,
|
|
|
|
[this] { OnEmulationStateChanged(Core::GetState()); });
|
|
|
|
|
2017-09-04 18:12:13 +00:00
|
|
|
OnEmulationStateChanged(Core::GetState());
|
2017-09-13 17:33:45 +00:00
|
|
|
connect(&Settings::Instance(), &Settings::DebugModeToggled, this, &MenuBar::OnDebugModeToggled);
|
2017-08-27 11:55:05 +00:00
|
|
|
|
|
|
|
connect(this, &MenuBar::SelectionChanged, this, &MenuBar::OnSelectionChanged);
|
|
|
|
connect(this, &MenuBar::RecordingStatusChanged, this, &MenuBar::OnRecordingStatusChanged);
|
|
|
|
connect(this, &MenuBar::ReadOnlyModeChanged, this, &MenuBar::OnReadOnlyModeChanged);
|
2016-02-15 01:56:40 +00:00
|
|
|
}
|
|
|
|
|
2017-09-04 18:12:13 +00:00
|
|
|
void MenuBar::OnEmulationStateChanged(Core::State state)
|
2016-02-15 01:56:40 +00:00
|
|
|
{
|
2017-09-04 18:12:13 +00:00
|
|
|
bool running = state != Core::State::Uninitialized;
|
|
|
|
bool playing = running && state != Core::State::Paused;
|
2017-08-27 11:55:05 +00:00
|
|
|
|
2018-03-23 00:18:53 +00:00
|
|
|
// File
|
|
|
|
m_eject_disc->setEnabled(running);
|
|
|
|
m_change_disc->setEnabled(running);
|
|
|
|
|
2016-02-15 01:56:40 +00:00
|
|
|
// Emulation
|
2017-09-04 18:12:13 +00:00
|
|
|
m_play_action->setEnabled(!playing);
|
|
|
|
m_play_action->setVisible(!playing);
|
|
|
|
m_pause_action->setEnabled(playing);
|
|
|
|
m_pause_action->setVisible(playing);
|
|
|
|
m_stop_action->setEnabled(running);
|
|
|
|
m_stop_action->setVisible(running);
|
|
|
|
m_reset_action->setEnabled(running);
|
|
|
|
m_fullscreen_action->setEnabled(running);
|
|
|
|
m_frame_advance_action->setEnabled(running);
|
|
|
|
m_screenshot_action->setEnabled(running);
|
|
|
|
m_state_load_menu->setEnabled(running);
|
|
|
|
m_state_save_menu->setEnabled(running);
|
2017-08-27 11:55:05 +00:00
|
|
|
|
|
|
|
// Movie
|
2017-09-04 18:12:13 +00:00
|
|
|
m_recording_read_only->setEnabled(running);
|
|
|
|
if (!running)
|
2019-06-08 06:39:12 +00:00
|
|
|
{
|
2017-09-04 18:12:13 +00:00
|
|
|
m_recording_stop->setEnabled(false);
|
2019-06-08 06:39:12 +00:00
|
|
|
m_recording_export->setEnabled(false);
|
|
|
|
}
|
2019-08-14 11:45:07 +00:00
|
|
|
m_recording_play->setEnabled(m_game_selected && !running);
|
|
|
|
m_recording_start->setEnabled((m_game_selected || running) && !Movie::IsPlayingInput());
|
2017-08-27 11:55:05 +00:00
|
|
|
|
2018-11-23 10:02:00 +00:00
|
|
|
// Options
|
|
|
|
m_controllers_action->setEnabled(NetPlay::IsNetPlayRunning() ? !running : true);
|
|
|
|
|
2018-03-26 02:17:47 +00:00
|
|
|
// Tools
|
2018-04-30 12:19:56 +00:00
|
|
|
m_show_cheat_manager->setEnabled(Settings::Instance().GetCheatsEnabled() && running);
|
2018-03-26 02:17:47 +00:00
|
|
|
|
2018-04-09 13:31:20 +00:00
|
|
|
// JIT
|
|
|
|
m_jit_interpreter_core->setEnabled(running);
|
|
|
|
m_jit_block_linking->setEnabled(!running);
|
|
|
|
m_jit_disable_cache->setEnabled(!running);
|
2020-06-02 10:18:45 +00:00
|
|
|
m_jit_disable_fastmem->setEnabled(!running);
|
2018-04-09 13:31:20 +00:00
|
|
|
m_jit_clear_cache->setEnabled(running);
|
|
|
|
m_jit_log_coverage->setEnabled(!running);
|
|
|
|
m_jit_search_instruction->setEnabled(running);
|
|
|
|
|
|
|
|
for (QAction* action :
|
|
|
|
{m_jit_off, m_jit_loadstore_off, m_jit_loadstore_lbzx_off, m_jit_loadstore_lxz_off,
|
|
|
|
m_jit_loadstore_lwz_off, m_jit_loadstore_floating_off, m_jit_loadstore_paired_off,
|
2018-07-08 18:32:40 +00:00
|
|
|
m_jit_floatingpoint_off, m_jit_integer_off, m_jit_paired_off, m_jit_systemregisters_off,
|
2019-11-16 10:25:26 +00:00
|
|
|
m_jit_branch_off, m_jit_register_cache_off})
|
2018-04-09 13:31:20 +00:00
|
|
|
{
|
2018-05-29 14:40:05 +00:00
|
|
|
action->setEnabled(running && !playing);
|
2018-04-09 13:31:20 +00:00
|
|
|
}
|
|
|
|
|
2018-02-14 22:25:01 +00:00
|
|
|
// Symbols
|
|
|
|
m_symbols->setEnabled(running);
|
|
|
|
|
2016-02-15 01:56:40 +00:00
|
|
|
UpdateStateSlotMenu();
|
2017-09-04 18:12:13 +00:00
|
|
|
UpdateToolsMenu(running);
|
2017-09-13 17:33:45 +00:00
|
|
|
|
|
|
|
OnDebugModeToggled(Settings::Instance().IsDebugModeEnabled());
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::OnDebugModeToggled(bool enabled)
|
|
|
|
{
|
2018-02-14 22:25:01 +00:00
|
|
|
// Options
|
|
|
|
m_boot_to_pause->setVisible(enabled);
|
|
|
|
m_automatic_start->setVisible(enabled);
|
|
|
|
m_change_font->setVisible(enabled);
|
|
|
|
|
|
|
|
// View
|
|
|
|
m_show_code->setVisible(enabled);
|
2017-09-13 17:33:45 +00:00
|
|
|
m_show_registers->setVisible(enabled);
|
2020-03-21 07:48:49 +00:00
|
|
|
m_show_threads->setVisible(enabled);
|
2017-09-27 06:53:05 +00:00
|
|
|
m_show_watch->setVisible(enabled);
|
2017-10-03 16:43:44 +00:00
|
|
|
m_show_breakpoints->setVisible(enabled);
|
2018-03-16 11:39:53 +00:00
|
|
|
m_show_memory->setVisible(enabled);
|
2020-04-19 19:30:50 +00:00
|
|
|
m_show_network->setVisible(enabled);
|
2018-04-09 13:31:20 +00:00
|
|
|
m_show_jit->setVisible(enabled);
|
2018-02-14 22:25:01 +00:00
|
|
|
|
|
|
|
if (enabled)
|
2018-04-09 13:31:20 +00:00
|
|
|
{
|
|
|
|
addMenu(m_jit);
|
2018-02-14 22:25:01 +00:00
|
|
|
addMenu(m_symbols);
|
2018-04-09 13:31:20 +00:00
|
|
|
}
|
2018-02-14 22:25:01 +00:00
|
|
|
else
|
2018-04-09 13:31:20 +00:00
|
|
|
{
|
|
|
|
removeAction(m_jit->menuAction());
|
2018-02-14 22:25:01 +00:00
|
|
|
removeAction(m_symbols->menuAction());
|
2018-04-09 13:31:20 +00:00
|
|
|
}
|
2015-12-20 05:24:48 +00:00
|
|
|
}
|
|
|
|
|
2018-03-23 00:18:53 +00:00
|
|
|
void MenuBar::AddDVDBackupMenu(QMenu* file_menu)
|
|
|
|
{
|
2018-04-16 17:08:58 +00:00
|
|
|
m_backup_menu = file_menu->addMenu(tr("&Boot from DVD Backup"));
|
2018-03-23 00:18:53 +00:00
|
|
|
|
2018-05-27 22:24:43 +00:00
|
|
|
const std::vector<std::string> drives = Common::GetCDDevices();
|
2018-03-23 00:18:53 +00:00
|
|
|
// Windows Limitation of 24 character drives
|
|
|
|
for (size_t i = 0; i < drives.size() && i < 24; i++)
|
|
|
|
{
|
|
|
|
auto drive = QString::fromStdString(drives[i]);
|
2018-07-09 08:02:10 +00:00
|
|
|
m_backup_menu->addAction(drive, this, [this, drive] { emit BootDVDBackup(drive); });
|
2018-03-23 00:18:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-20 05:24:48 +00:00
|
|
|
void MenuBar::AddFileMenu()
|
|
|
|
{
|
2017-07-23 10:58:32 +00:00
|
|
|
QMenu* file_menu = addMenu(tr("&File"));
|
2020-02-26 19:31:10 +00:00
|
|
|
m_open_action = file_menu->addAction(tr("&Open..."), this, &MenuBar::Open, QKeySequence::Open);
|
2018-03-23 00:18:53 +00:00
|
|
|
|
|
|
|
file_menu->addSeparator();
|
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
m_change_disc = file_menu->addAction(tr("Change &Disc..."), this, &MenuBar::ChangeDisc);
|
|
|
|
m_eject_disc = file_menu->addAction(tr("&Eject Disc"), this, &MenuBar::EjectDisc);
|
2018-03-23 00:18:53 +00:00
|
|
|
|
|
|
|
AddDVDBackupMenu(file_menu);
|
|
|
|
|
|
|
|
file_menu->addSeparator();
|
|
|
|
|
2020-02-26 19:31:10 +00:00
|
|
|
m_exit_action = file_menu->addAction(tr("E&xit"), this, &MenuBar::Exit);
|
|
|
|
m_exit_action->setShortcuts({QKeySequence::Quit, QKeySequence(Qt::ALT + Qt::Key_F4)});
|
2016-02-15 01:56:40 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 21:01:12 +00:00
|
|
|
void MenuBar::AddToolsMenu()
|
|
|
|
{
|
2017-07-23 10:58:32 +00:00
|
|
|
QMenu* tools_menu = addMenu(tr("&Tools"));
|
2017-08-24 13:11:04 +00:00
|
|
|
|
2019-05-18 22:24:25 +00:00
|
|
|
tools_menu->addAction(tr("&Resource Pack Manager"), this,
|
|
|
|
[this] { emit ShowResourcePackManager(); });
|
2018-01-25 18:54:50 +00:00
|
|
|
|
2018-03-26 02:17:47 +00:00
|
|
|
m_show_cheat_manager =
|
2018-07-09 08:02:10 +00:00
|
|
|
tools_menu->addAction(tr("&Cheats Manager"), this, [this] { emit ShowCheatsManager(); });
|
2018-03-26 02:17:47 +00:00
|
|
|
|
|
|
|
connect(&Settings::Instance(), &Settings::EnableCheatsChanged, [this](bool enabled) {
|
|
|
|
m_show_cheat_manager->setEnabled(Core::GetState() != Core::State::Uninitialized && enabled);
|
|
|
|
});
|
|
|
|
|
2019-05-18 22:24:25 +00:00
|
|
|
tools_menu->addAction(tr("FIFO Player"), this, &MenuBar::ShowFIFOPlayer);
|
2017-08-24 13:11:04 +00:00
|
|
|
|
|
|
|
tools_menu->addSeparator();
|
|
|
|
|
2019-05-18 22:24:25 +00:00
|
|
|
tools_menu->addAction(tr("Start &NetPlay..."), this, &MenuBar::StartNetPlay);
|
|
|
|
tools_menu->addAction(tr("Browse &NetPlay Sessions...."), this, &MenuBar::BrowseNetPlay);
|
2017-06-14 09:58:11 +00:00
|
|
|
|
2017-08-24 14:35:47 +00:00
|
|
|
tools_menu->addSeparator();
|
2019-05-18 22:24:25 +00:00
|
|
|
|
2017-08-24 14:35:47 +00:00
|
|
|
QMenu* gc_ipl = tools_menu->addMenu(tr("Load GameCube Main Menu"));
|
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
m_ntscj_ipl = gc_ipl->addAction(tr("NTSC-J"), this,
|
|
|
|
[this] { emit BootGameCubeIPL(DiscIO::Region::NTSC_J); });
|
|
|
|
m_ntscu_ipl = gc_ipl->addAction(tr("NTSC-U"), this,
|
|
|
|
[this] { emit BootGameCubeIPL(DiscIO::Region::NTSC_U); });
|
2017-08-24 14:35:47 +00:00
|
|
|
m_pal_ipl =
|
2018-07-09 08:02:10 +00:00
|
|
|
gc_ipl->addAction(tr("PAL"), this, [this] { emit BootGameCubeIPL(DiscIO::Region::PAL); });
|
2017-08-24 14:35:47 +00:00
|
|
|
|
2019-05-18 22:24:25 +00:00
|
|
|
tools_menu->addAction(tr("Memory Card Manager"), this, [this] { emit ShowMemcardManager(); });
|
2017-08-30 14:44:28 +00:00
|
|
|
|
2017-07-20 15:52:45 +00:00
|
|
|
tools_menu->addSeparator();
|
|
|
|
|
2017-07-06 09:00:37 +00:00
|
|
|
// Label will be set by a NANDRefresh later
|
2019-07-30 11:57:06 +00:00
|
|
|
m_boot_sysmenu = tools_menu->addAction(QString{}, this, [this] { emit BootWiiSystemMenu(); });
|
2019-05-18 22:24:25 +00:00
|
|
|
m_wad_install_action = tools_menu->addAction(tr("Install WAD..."), this, &MenuBar::InstallWAD);
|
|
|
|
m_manage_nand_menu = tools_menu->addMenu(tr("Manage NAND"));
|
|
|
|
m_import_backup = m_manage_nand_menu->addAction(tr("Import BootMii NAND Backup..."), this,
|
|
|
|
[this] { emit ImportNANDBackup(); });
|
|
|
|
m_check_nand = m_manage_nand_menu->addAction(tr("Check NAND..."), this, &MenuBar::CheckNAND);
|
|
|
|
m_extract_certificates = m_manage_nand_menu->addAction(tr("Extract Certificates from NAND"), this,
|
|
|
|
&MenuBar::NANDExtractCertificates);
|
2017-08-26 12:41:53 +00:00
|
|
|
|
2017-07-06 09:00:37 +00:00
|
|
|
m_boot_sysmenu->setEnabled(false);
|
|
|
|
|
|
|
|
connect(&Settings::Instance(), &Settings::NANDRefresh, [this] { UpdateToolsMenu(false); });
|
|
|
|
|
2017-06-14 09:58:11 +00:00
|
|
|
m_perform_online_update_menu = tools_menu->addMenu(tr("Perform Online System Update"));
|
2018-07-09 08:02:10 +00:00
|
|
|
m_perform_online_update_for_current_region = m_perform_online_update_menu->addAction(
|
|
|
|
tr("Current Region"), this, [this] { emit PerformOnlineUpdate(""); });
|
2017-06-14 09:58:11 +00:00
|
|
|
m_perform_online_update_menu->addSeparator();
|
2018-07-09 08:02:10 +00:00
|
|
|
m_perform_online_update_menu->addAction(tr("Europe"), this,
|
|
|
|
[this] { emit PerformOnlineUpdate("EUR"); });
|
|
|
|
m_perform_online_update_menu->addAction(tr("Japan"), this,
|
|
|
|
[this] { emit PerformOnlineUpdate("JPN"); });
|
|
|
|
m_perform_online_update_menu->addAction(tr("Korea"), this,
|
|
|
|
[this] { emit PerformOnlineUpdate("KOR"); });
|
|
|
|
m_perform_online_update_menu->addAction(tr("United States"), this,
|
|
|
|
[this] { emit PerformOnlineUpdate("USA"); });
|
2018-01-24 14:25:35 +00:00
|
|
|
|
2019-05-18 22:24:25 +00:00
|
|
|
tools_menu->addSeparator();
|
|
|
|
|
|
|
|
tools_menu->addAction(tr("Import Wii Save..."), this, &MenuBar::ImportWiiSave);
|
|
|
|
tools_menu->addAction(tr("Export All Wii Saves"), this, &MenuBar::ExportWiiSaves);
|
|
|
|
|
2019-03-17 17:51:50 +00:00
|
|
|
QMenu* menu = new QMenu(tr("Connect Wii Remotes"), tools_menu);
|
2018-01-24 14:25:35 +00:00
|
|
|
|
|
|
|
tools_menu->addSeparator();
|
|
|
|
tools_menu->addMenu(menu);
|
|
|
|
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
|
{
|
2018-07-09 08:02:10 +00:00
|
|
|
m_wii_remotes[i] = menu->addAction(tr("Connect Wii Remote %1").arg(i + 1), this,
|
|
|
|
[this, i] { emit ConnectWiiRemote(i); });
|
2018-01-24 14:25:35 +00:00
|
|
|
m_wii_remotes[i]->setCheckable(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
menu->addSeparator();
|
|
|
|
|
|
|
|
m_wii_remotes[4] =
|
2018-07-09 08:02:10 +00:00
|
|
|
menu->addAction(tr("Connect Balance Board"), this, [this] { emit ConnectWiiRemote(4); });
|
2018-01-24 14:25:35 +00:00
|
|
|
m_wii_remotes[4]->setCheckable(true);
|
2017-05-04 21:01:12 +00:00
|
|
|
}
|
|
|
|
|
2016-02-15 01:56:40 +00:00
|
|
|
void MenuBar::AddEmulationMenu()
|
|
|
|
{
|
2017-07-23 10:58:32 +00:00
|
|
|
QMenu* emu_menu = addMenu(tr("&Emulation"));
|
2018-07-09 08:02:10 +00:00
|
|
|
m_play_action = emu_menu->addAction(tr("&Play"), this, &MenuBar::Play);
|
|
|
|
m_pause_action = emu_menu->addAction(tr("&Pause"), this, &MenuBar::Pause);
|
|
|
|
m_stop_action = emu_menu->addAction(tr("&Stop"), this, &MenuBar::Stop);
|
|
|
|
m_reset_action = emu_menu->addAction(tr("&Reset"), this, &MenuBar::Reset);
|
|
|
|
m_fullscreen_action = emu_menu->addAction(tr("Toggle &Fullscreen"), this, &MenuBar::Fullscreen);
|
|
|
|
m_frame_advance_action = emu_menu->addAction(tr("&Frame Advance"), this, &MenuBar::FrameAdvance);
|
2017-07-16 00:36:37 +00:00
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
m_screenshot_action = emu_menu->addAction(tr("Take Screenshot"), this, &MenuBar::Screenshot);
|
2017-07-16 00:36:37 +00:00
|
|
|
|
|
|
|
emu_menu->addSeparator();
|
|
|
|
|
2016-02-15 01:56:40 +00:00
|
|
|
AddStateLoadMenu(emu_menu);
|
|
|
|
AddStateSaveMenu(emu_menu);
|
|
|
|
AddStateSlotMenu(emu_menu);
|
|
|
|
UpdateStateSlotMenu();
|
2019-08-01 17:59:29 +00:00
|
|
|
|
|
|
|
for (QMenu* menu : {m_state_load_menu, m_state_save_menu, m_state_slot_menu})
|
|
|
|
connect(menu, &QMenu::aboutToShow, this, &MenuBar::UpdateStateSlotMenu);
|
2016-02-15 01:56:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::AddStateLoadMenu(QMenu* emu_menu)
|
|
|
|
{
|
2017-07-23 10:58:32 +00:00
|
|
|
m_state_load_menu = emu_menu->addMenu(tr("&Load State"));
|
2018-07-09 08:02:10 +00:00
|
|
|
m_state_load_menu->addAction(tr("Load State from File"), this, &MenuBar::StateLoad);
|
|
|
|
m_state_load_menu->addAction(tr("Load State from Selected Slot"), this, &MenuBar::StateLoadSlot);
|
2016-02-15 01:56:40 +00:00
|
|
|
m_state_load_slots_menu = m_state_load_menu->addMenu(tr("Load State from Slot"));
|
2018-07-09 08:02:10 +00:00
|
|
|
m_state_load_menu->addAction(tr("Undo Load State"), this, &MenuBar::StateLoadUndo);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-02-15 01:56:40 +00:00
|
|
|
for (int i = 1; i <= 10; i++)
|
|
|
|
{
|
2019-07-30 11:57:06 +00:00
|
|
|
QAction* action = m_state_load_slots_menu->addAction(QString{});
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-02-15 01:56:40 +00:00
|
|
|
connect(action, &QAction::triggered, this, [=]() { emit StateLoadSlotAt(i); });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::AddStateSaveMenu(QMenu* emu_menu)
|
|
|
|
{
|
2017-07-23 10:58:32 +00:00
|
|
|
m_state_save_menu = emu_menu->addMenu(tr("Sa&ve State"));
|
2018-07-09 08:02:10 +00:00
|
|
|
m_state_save_menu->addAction(tr("Save State to File"), this, &MenuBar::StateSave);
|
|
|
|
m_state_save_menu->addAction(tr("Save State to Selected Slot"), this, &MenuBar::StateSaveSlot);
|
|
|
|
m_state_save_menu->addAction(tr("Save State to Oldest Slot"), this, &MenuBar::StateSaveOldest);
|
2016-02-15 01:56:40 +00:00
|
|
|
m_state_save_slots_menu = m_state_save_menu->addMenu(tr("Save State to Slot"));
|
2018-07-09 08:02:10 +00:00
|
|
|
m_state_save_menu->addAction(tr("Undo Save State"), this, &MenuBar::StateSaveUndo);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-02-15 01:56:40 +00:00
|
|
|
for (int i = 1; i <= 10; i++)
|
|
|
|
{
|
2019-07-30 11:57:06 +00:00
|
|
|
QAction* action = m_state_save_slots_menu->addAction(QString{});
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-02-15 01:56:40 +00:00
|
|
|
connect(action, &QAction::triggered, this, [=]() { emit StateSaveSlotAt(i); });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::AddStateSlotMenu(QMenu* emu_menu)
|
|
|
|
{
|
|
|
|
m_state_slot_menu = emu_menu->addMenu(tr("Select State Slot"));
|
|
|
|
m_state_slots = new QActionGroup(this);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-02-15 01:56:40 +00:00
|
|
|
for (int i = 1; i <= 10; i++)
|
|
|
|
{
|
2019-07-30 11:57:06 +00:00
|
|
|
QAction* action = m_state_slot_menu->addAction(QString{});
|
2016-02-15 01:56:40 +00:00
|
|
|
action->setCheckable(true);
|
|
|
|
action->setActionGroup(m_state_slots);
|
2017-05-31 07:17:39 +00:00
|
|
|
if (Settings::Instance().GetStateSlot() == i)
|
2016-02-15 01:56:40 +00:00
|
|
|
action->setChecked(true);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2016-02-15 01:56:40 +00:00
|
|
|
connect(action, &QAction::triggered, this, [=]() { emit SetStateSlot(i); });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::UpdateStateSlotMenu()
|
|
|
|
{
|
|
|
|
QList<QAction*> actions_slot = m_state_slots->actions();
|
|
|
|
QList<QAction*> actions_load = m_state_load_slots_menu->actions();
|
|
|
|
QList<QAction*> actions_save = m_state_save_slots_menu->actions();
|
|
|
|
for (int i = 0; i < actions_slot.length(); i++)
|
|
|
|
{
|
|
|
|
int slot = i + 1;
|
|
|
|
QString info = QString::fromStdString(State::GetInfoStringOfSlot(slot));
|
2017-07-23 08:50:20 +00:00
|
|
|
actions_load.at(i)->setText(tr("Load from Slot %1 - %2").arg(slot).arg(info));
|
|
|
|
actions_save.at(i)->setText(tr("Save to Slot %1 - %2").arg(slot).arg(info));
|
|
|
|
actions_slot.at(i)->setText(tr("Select Slot %1 - %2").arg(slot).arg(info));
|
2016-02-15 01:56:40 +00:00
|
|
|
}
|
2015-12-20 05:24:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::AddViewMenu()
|
|
|
|
{
|
2017-07-23 10:58:32 +00:00
|
|
|
QMenu* view_menu = addMenu(tr("&View"));
|
2017-08-03 14:43:50 +00:00
|
|
|
QAction* show_log = view_menu->addAction(tr("Show &Log"));
|
2017-06-29 10:46:20 +00:00
|
|
|
show_log->setCheckable(true);
|
|
|
|
show_log->setChecked(Settings::Instance().IsLogVisible());
|
|
|
|
|
|
|
|
connect(show_log, &QAction::toggled, &Settings::Instance(), &Settings::SetLogVisible);
|
|
|
|
|
2017-08-03 14:43:50 +00:00
|
|
|
QAction* show_log_config = view_menu->addAction(tr("Show Log &Configuration"));
|
2017-06-29 10:46:20 +00:00
|
|
|
show_log_config->setCheckable(true);
|
|
|
|
show_log_config->setChecked(Settings::Instance().IsLogConfigVisible());
|
|
|
|
|
|
|
|
connect(show_log_config, &QAction::toggled, &Settings::Instance(),
|
|
|
|
&Settings::SetLogConfigVisible);
|
|
|
|
|
2018-04-19 09:32:00 +00:00
|
|
|
QAction* show_toolbar = view_menu->addAction(tr("Show &Toolbar"));
|
|
|
|
show_toolbar->setCheckable(true);
|
|
|
|
show_toolbar->setChecked(Settings::Instance().IsToolBarVisible());
|
|
|
|
|
|
|
|
connect(show_toolbar, &QAction::toggled, &Settings::Instance(), &Settings::SetToolBarVisible);
|
|
|
|
|
2017-06-29 10:46:20 +00:00
|
|
|
connect(&Settings::Instance(), &Settings::LogVisibilityChanged, show_log, &QAction::setChecked);
|
|
|
|
connect(&Settings::Instance(), &Settings::LogConfigVisibilityChanged, show_log_config,
|
|
|
|
&QAction::setChecked);
|
2018-04-19 09:32:00 +00:00
|
|
|
connect(&Settings::Instance(), &Settings::ToolBarVisibilityChanged, show_toolbar,
|
|
|
|
&QAction::setChecked);
|
|
|
|
|
|
|
|
QAction* lock_widgets = view_menu->addAction(tr("&Lock Widgets In Place"));
|
|
|
|
lock_widgets->setCheckable(true);
|
|
|
|
lock_widgets->setChecked(Settings::Instance().AreWidgetsLocked());
|
|
|
|
|
|
|
|
connect(lock_widgets, &QAction::toggled, &Settings::Instance(), &Settings::SetWidgetsLocked);
|
2017-06-29 10:46:20 +00:00
|
|
|
|
|
|
|
view_menu->addSeparator();
|
|
|
|
|
2018-02-14 22:25:01 +00:00
|
|
|
m_show_code = view_menu->addAction(tr("&Code"));
|
|
|
|
m_show_code->setCheckable(true);
|
|
|
|
m_show_code->setChecked(Settings::Instance().IsCodeVisible());
|
|
|
|
|
|
|
|
connect(m_show_code, &QAction::toggled, &Settings::Instance(), &Settings::SetCodeVisible);
|
|
|
|
connect(&Settings::Instance(), &Settings::CodeVisibilityChanged, m_show_code,
|
|
|
|
&QAction::setChecked);
|
|
|
|
|
2017-09-13 17:33:45 +00:00
|
|
|
m_show_registers = view_menu->addAction(tr("&Registers"));
|
|
|
|
m_show_registers->setCheckable(true);
|
|
|
|
m_show_registers->setChecked(Settings::Instance().IsRegistersVisible());
|
|
|
|
|
|
|
|
connect(m_show_registers, &QAction::toggled, &Settings::Instance(),
|
|
|
|
&Settings::SetRegistersVisible);
|
|
|
|
connect(&Settings::Instance(), &Settings::RegistersVisibilityChanged, m_show_registers,
|
|
|
|
&QAction::setChecked);
|
|
|
|
|
2020-03-21 07:48:49 +00:00
|
|
|
m_show_threads = view_menu->addAction(tr("&Threads"));
|
|
|
|
m_show_threads->setCheckable(true);
|
|
|
|
m_show_threads->setChecked(Settings::Instance().IsThreadsVisible());
|
|
|
|
|
|
|
|
connect(m_show_threads, &QAction::toggled, &Settings::Instance(), &Settings::SetThreadsVisible);
|
|
|
|
connect(&Settings::Instance(), &Settings::ThreadsVisibilityChanged, m_show_threads,
|
|
|
|
&QAction::setChecked);
|
|
|
|
|
2018-09-08 13:58:15 +00:00
|
|
|
// i18n: This kind of "watch" is used for watching emulated memory.
|
|
|
|
// It's not related to timekeeping devices.
|
2017-09-27 06:53:05 +00:00
|
|
|
m_show_watch = view_menu->addAction(tr("&Watch"));
|
|
|
|
m_show_watch->setCheckable(true);
|
|
|
|
m_show_watch->setChecked(Settings::Instance().IsWatchVisible());
|
|
|
|
|
|
|
|
connect(m_show_watch, &QAction::toggled, &Settings::Instance(), &Settings::SetWatchVisible);
|
|
|
|
connect(&Settings::Instance(), &Settings::WatchVisibilityChanged, m_show_watch,
|
|
|
|
&QAction::setChecked);
|
|
|
|
|
2017-10-03 16:43:44 +00:00
|
|
|
m_show_breakpoints = view_menu->addAction(tr("&Breakpoints"));
|
|
|
|
m_show_breakpoints->setCheckable(true);
|
|
|
|
m_show_breakpoints->setChecked(Settings::Instance().IsBreakpointsVisible());
|
|
|
|
|
|
|
|
connect(m_show_breakpoints, &QAction::toggled, &Settings::Instance(),
|
|
|
|
&Settings::SetBreakpointsVisible);
|
|
|
|
connect(&Settings::Instance(), &Settings::BreakpointsVisibilityChanged, m_show_breakpoints,
|
|
|
|
&QAction::setChecked);
|
|
|
|
|
2018-03-16 11:39:53 +00:00
|
|
|
m_show_memory = view_menu->addAction(tr("&Memory"));
|
|
|
|
m_show_memory->setCheckable(true);
|
|
|
|
m_show_memory->setChecked(Settings::Instance().IsMemoryVisible());
|
|
|
|
|
|
|
|
connect(m_show_memory, &QAction::toggled, &Settings::Instance(), &Settings::SetMemoryVisible);
|
|
|
|
connect(&Settings::Instance(), &Settings::MemoryVisibilityChanged, m_show_memory,
|
|
|
|
&QAction::setChecked);
|
|
|
|
|
2020-04-19 19:30:50 +00:00
|
|
|
m_show_network = view_menu->addAction(tr("&Network"));
|
|
|
|
m_show_network->setCheckable(true);
|
|
|
|
m_show_network->setChecked(Settings::Instance().IsNetworkVisible());
|
|
|
|
|
|
|
|
connect(m_show_network, &QAction::toggled, &Settings::Instance(), &Settings::SetNetworkVisible);
|
|
|
|
connect(&Settings::Instance(), &Settings::NetworkVisibilityChanged, m_show_network,
|
|
|
|
&QAction::setChecked);
|
|
|
|
|
2018-04-09 13:31:20 +00:00
|
|
|
m_show_jit = view_menu->addAction(tr("&JIT"));
|
|
|
|
m_show_jit->setCheckable(true);
|
|
|
|
m_show_jit->setChecked(Settings::Instance().IsJITVisible());
|
|
|
|
connect(m_show_jit, &QAction::toggled, &Settings::Instance(), &Settings::SetJITVisible);
|
|
|
|
connect(&Settings::Instance(), &Settings::JITVisibilityChanged, m_show_jit, &QAction::setChecked);
|
|
|
|
|
2017-09-13 17:33:45 +00:00
|
|
|
view_menu->addSeparator();
|
|
|
|
|
2015-12-20 05:24:48 +00:00
|
|
|
AddGameListTypeSection(view_menu);
|
|
|
|
view_menu->addSeparator();
|
2017-08-05 08:28:53 +00:00
|
|
|
AddListColumnsMenu(view_menu);
|
2017-07-11 14:13:09 +00:00
|
|
|
view_menu->addSeparator();
|
|
|
|
AddShowPlatformsMenu(view_menu);
|
|
|
|
AddShowRegionsMenu(view_menu);
|
2018-03-21 10:13:53 +00:00
|
|
|
|
2018-10-14 16:03:10 +00:00
|
|
|
view_menu->addSeparator();
|
|
|
|
view_menu->addAction(tr("Purge Game List Cache"), this, &MenuBar::PurgeGameListCache);
|
2018-03-21 10:13:53 +00:00
|
|
|
view_menu->addSeparator();
|
2020-02-26 19:31:10 +00:00
|
|
|
view_menu->addAction(tr("Search"), this, &MenuBar::ShowSearch, QKeySequence::Find);
|
2015-12-20 05:24:48 +00:00
|
|
|
}
|
|
|
|
|
2017-06-06 11:49:49 +00:00
|
|
|
void MenuBar::AddOptionsMenu()
|
|
|
|
{
|
2017-07-23 10:58:32 +00:00
|
|
|
QMenu* options_menu = addMenu(tr("&Options"));
|
2020-02-26 19:37:02 +00:00
|
|
|
options_menu->addAction(tr("Co&nfiguration"), this, &MenuBar::Configure,
|
|
|
|
QKeySequence::Preferences);
|
2017-07-16 21:11:11 +00:00
|
|
|
options_menu->addSeparator();
|
2018-07-09 08:02:10 +00:00
|
|
|
options_menu->addAction(tr("&Graphics Settings"), this, &MenuBar::ConfigureGraphics);
|
|
|
|
options_menu->addAction(tr("&Audio Settings"), this, &MenuBar::ConfigureAudio);
|
2018-11-23 10:02:00 +00:00
|
|
|
m_controllers_action =
|
|
|
|
options_menu->addAction(tr("&Controller Settings"), this, &MenuBar::ConfigureControllers);
|
2018-07-09 08:02:10 +00:00
|
|
|
options_menu->addAction(tr("&Hotkey Settings"), this, &MenuBar::ConfigureHotkeys);
|
2018-02-14 22:25:01 +00:00
|
|
|
|
|
|
|
options_menu->addSeparator();
|
|
|
|
|
|
|
|
// Debugging mode only
|
2018-03-19 17:52:46 +00:00
|
|
|
m_boot_to_pause = options_menu->addAction(tr("Boot to Pause"));
|
2018-02-14 22:25:01 +00:00
|
|
|
m_boot_to_pause->setCheckable(true);
|
|
|
|
m_boot_to_pause->setChecked(SConfig::GetInstance().bBootToPause);
|
|
|
|
|
|
|
|
connect(m_boot_to_pause, &QAction::toggled, this,
|
2018-05-14 14:07:52 +00:00
|
|
|
[](bool enable) { SConfig::GetInstance().bBootToPause = enable; });
|
2018-02-14 22:25:01 +00:00
|
|
|
|
|
|
|
m_automatic_start = options_menu->addAction(tr("&Automatic Start"));
|
|
|
|
m_automatic_start->setCheckable(true);
|
|
|
|
m_automatic_start->setChecked(SConfig::GetInstance().bAutomaticStart);
|
|
|
|
|
|
|
|
connect(m_automatic_start, &QAction::toggled, this,
|
2018-05-14 14:07:52 +00:00
|
|
|
[](bool enable) { SConfig::GetInstance().bAutomaticStart = enable; });
|
2018-02-14 22:25:01 +00:00
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
m_change_font = options_menu->addAction(tr("&Font..."), this, &MenuBar::ChangeDebugFont);
|
2017-06-06 11:49:49 +00:00
|
|
|
}
|
|
|
|
|
2018-05-24 22:19:36 +00:00
|
|
|
void MenuBar::InstallUpdateManually()
|
|
|
|
{
|
|
|
|
auto& track = SConfig::GetInstance().m_auto_update_track;
|
|
|
|
auto previous_value = track;
|
|
|
|
|
|
|
|
track = "dev";
|
|
|
|
|
2018-07-09 23:39:50 +00:00
|
|
|
auto* updater = new Updater(this->parentWidget());
|
2018-05-24 22:19:36 +00:00
|
|
|
|
|
|
|
if (!updater->CheckForUpdate())
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::information(
|
2018-05-24 22:19:36 +00:00
|
|
|
this, tr("Update"),
|
2019-01-27 21:59:39 +00:00
|
|
|
tr("You are running the latest version available on this update track."));
|
2018-05-24 22:19:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
track = previous_value;
|
|
|
|
}
|
|
|
|
|
2016-02-11 11:59:44 +00:00
|
|
|
void MenuBar::AddHelpMenu()
|
|
|
|
{
|
2017-07-23 10:58:32 +00:00
|
|
|
QMenu* help_menu = addMenu(tr("&Help"));
|
2018-05-24 22:19:36 +00:00
|
|
|
|
2017-07-23 10:58:32 +00:00
|
|
|
QAction* website = help_menu->addAction(tr("&Website"));
|
2017-05-05 08:08:01 +00:00
|
|
|
connect(website, &QAction::triggered, this,
|
|
|
|
[]() { QDesktopServices::openUrl(QUrl(QStringLiteral("https://dolphin-emu.org/"))); });
|
2017-07-23 10:58:32 +00:00
|
|
|
QAction* documentation = help_menu->addAction(tr("Online &Documentation"));
|
2017-05-05 08:08:01 +00:00
|
|
|
connect(documentation, &QAction::triggered, this, []() {
|
2016-02-11 11:59:44 +00:00
|
|
|
QDesktopServices::openUrl(QUrl(QStringLiteral("https://dolphin-emu.org/docs/guides")));
|
|
|
|
});
|
2017-07-23 10:58:32 +00:00
|
|
|
QAction* github = help_menu->addAction(tr("&GitHub Repository"));
|
2017-05-05 08:08:01 +00:00
|
|
|
connect(github, &QAction::triggered, this, []() {
|
|
|
|
QDesktopServices::openUrl(QUrl(QStringLiteral("https://github.com/dolphin-emu/dolphin")));
|
|
|
|
});
|
2019-08-05 14:51:02 +00:00
|
|
|
QAction* bugtracker = help_menu->addAction(tr("&Bug Tracker"));
|
|
|
|
connect(bugtracker, &QAction::triggered, this, []() {
|
|
|
|
QDesktopServices::openUrl(
|
|
|
|
QUrl(QStringLiteral("https://bugs.dolphin-emu.org/projects/emulator")));
|
|
|
|
});
|
2017-05-05 08:08:01 +00:00
|
|
|
|
2019-02-26 19:40:38 +00:00
|
|
|
if (AutoUpdateChecker::SystemSupportsAutoUpdates())
|
|
|
|
{
|
|
|
|
help_menu->addSeparator();
|
2018-05-24 22:19:36 +00:00
|
|
|
|
2019-02-26 19:40:38 +00:00
|
|
|
help_menu->addAction(tr("&Check for Updates..."), this, &MenuBar::InstallUpdateManually);
|
|
|
|
}
|
2018-05-24 22:19:36 +00:00
|
|
|
|
2019-02-26 19:40:38 +00:00
|
|
|
#ifndef __APPLE__
|
2017-05-05 08:08:01 +00:00
|
|
|
help_menu->addSeparator();
|
2019-02-26 19:40:38 +00:00
|
|
|
#endif
|
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
help_menu->addAction(tr("&About"), this, &MenuBar::ShowAboutDialog);
|
2016-02-11 11:59:44 +00:00
|
|
|
}
|
|
|
|
|
2015-12-20 05:24:48 +00:00
|
|
|
void MenuBar::AddGameListTypeSection(QMenu* view_menu)
|
|
|
|
{
|
2017-08-05 08:28:53 +00:00
|
|
|
QAction* list_view = view_menu->addAction(tr("List View"));
|
2015-12-20 05:24:48 +00:00
|
|
|
list_view->setCheckable(true);
|
|
|
|
|
2017-08-05 08:28:53 +00:00
|
|
|
QAction* grid_view = view_menu->addAction(tr("Grid View"));
|
|
|
|
grid_view->setCheckable(true);
|
|
|
|
|
2015-12-20 05:24:48 +00:00
|
|
|
QActionGroup* list_group = new QActionGroup(this);
|
|
|
|
list_group->addAction(list_view);
|
2017-08-05 08:28:53 +00:00
|
|
|
list_group->addAction(grid_view);
|
2015-12-20 05:24:48 +00:00
|
|
|
|
2017-08-05 08:28:53 +00:00
|
|
|
bool prefer_list = Settings::Instance().GetPreferredView();
|
|
|
|
list_view->setChecked(prefer_list);
|
|
|
|
grid_view->setChecked(!prefer_list);
|
2015-12-20 05:24:48 +00:00
|
|
|
|
|
|
|
connect(list_view, &QAction::triggered, this, &MenuBar::ShowList);
|
2017-08-05 08:28:53 +00:00
|
|
|
connect(grid_view, &QAction::triggered, this, &MenuBar::ShowGrid);
|
2015-12-20 05:24:48 +00:00
|
|
|
}
|
|
|
|
|
2017-08-05 08:28:53 +00:00
|
|
|
void MenuBar::AddListColumnsMenu(QMenu* view_menu)
|
2015-12-20 05:24:48 +00:00
|
|
|
{
|
2017-06-22 22:11:53 +00:00
|
|
|
static const QMap<QString, bool*> columns{
|
|
|
|
{tr("Platform"), &SConfig::GetInstance().m_showSystemColumn},
|
|
|
|
{tr("Banner"), &SConfig::GetInstance().m_showBannerColumn},
|
|
|
|
{tr("Title"), &SConfig::GetInstance().m_showTitleColumn},
|
|
|
|
{tr("Description"), &SConfig::GetInstance().m_showDescriptionColumn},
|
|
|
|
{tr("Maker"), &SConfig::GetInstance().m_showMakerColumn},
|
2017-09-13 19:57:53 +00:00
|
|
|
{tr("File Name"), &SConfig::GetInstance().m_showFileNameColumn},
|
2020-01-24 07:56:38 +00:00
|
|
|
{tr("File Path"), &SConfig::GetInstance().m_showFilePathColumn},
|
2017-09-13 19:57:53 +00:00
|
|
|
{tr("Game ID"), &SConfig::GetInstance().m_showIDColumn},
|
|
|
|
{tr("Region"), &SConfig::GetInstance().m_showRegionColumn},
|
2018-10-01 07:10:40 +00:00
|
|
|
{tr("File Size"), &SConfig::GetInstance().m_showSizeColumn},
|
2020-06-25 10:49:36 +00:00
|
|
|
{tr("File Format"), &SConfig::GetInstance().m_showFileFormatColumn},
|
|
|
|
{tr("Block Size"), &SConfig::GetInstance().m_showBlockSizeColumn},
|
|
|
|
{tr("Compression"), &SConfig::GetInstance().m_showCompressionColumn},
|
2018-10-01 07:10:40 +00:00
|
|
|
{tr("Tags"), &SConfig::GetInstance().m_showTagsColumn}};
|
2017-05-08 17:03:59 +00:00
|
|
|
|
2015-12-20 05:24:48 +00:00
|
|
|
QActionGroup* column_group = new QActionGroup(this);
|
2019-01-21 20:05:31 +00:00
|
|
|
m_cols_menu = view_menu->addMenu(tr("List Columns"));
|
2015-12-20 05:24:48 +00:00
|
|
|
column_group->setExclusive(false);
|
2016-06-24 08:43:46 +00:00
|
|
|
|
2017-05-08 17:03:59 +00:00
|
|
|
for (const auto& key : columns.keys())
|
2015-12-20 05:24:48 +00:00
|
|
|
{
|
2017-05-08 17:03:59 +00:00
|
|
|
bool* config = columns[key];
|
2019-01-21 20:05:31 +00:00
|
|
|
QAction* action = column_group->addAction(m_cols_menu->addAction(key));
|
2015-12-20 05:24:48 +00:00
|
|
|
action->setCheckable(true);
|
2017-05-08 17:03:59 +00:00
|
|
|
action->setChecked(*config);
|
|
|
|
connect(action, &QAction::toggled, [this, config, key](bool value) {
|
|
|
|
*config = value;
|
|
|
|
emit ColumnVisibilityToggled(key, value);
|
|
|
|
});
|
2015-12-20 05:24:48 +00:00
|
|
|
}
|
|
|
|
}
|
2017-05-04 21:01:12 +00:00
|
|
|
|
2017-07-11 14:13:09 +00:00
|
|
|
void MenuBar::AddShowPlatformsMenu(QMenu* view_menu)
|
|
|
|
{
|
|
|
|
static const QMap<QString, bool*> platform_map{
|
|
|
|
{tr("Show Wii"), &SConfig::GetInstance().m_ListWii},
|
|
|
|
{tr("Show GameCube"), &SConfig::GetInstance().m_ListGC},
|
|
|
|
{tr("Show WAD"), &SConfig::GetInstance().m_ListWad},
|
|
|
|
{tr("Show ELF/DOL"), &SConfig::GetInstance().m_ListElfDol}};
|
|
|
|
|
|
|
|
QActionGroup* platform_group = new QActionGroup(this);
|
|
|
|
QMenu* plat_menu = view_menu->addMenu(tr("Show Platforms"));
|
|
|
|
platform_group->setExclusive(false);
|
|
|
|
|
|
|
|
for (const auto& key : platform_map.keys())
|
|
|
|
{
|
|
|
|
bool* config = platform_map[key];
|
|
|
|
QAction* action = platform_group->addAction(plat_menu->addAction(key));
|
|
|
|
action->setCheckable(true);
|
|
|
|
action->setChecked(*config);
|
|
|
|
connect(action, &QAction::toggled, [this, config, key](bool value) {
|
|
|
|
*config = value;
|
|
|
|
emit GameListPlatformVisibilityToggled(key, value);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::AddShowRegionsMenu(QMenu* view_menu)
|
|
|
|
{
|
|
|
|
static const QMap<QString, bool*> region_map{
|
|
|
|
{tr("Show JAP"), &SConfig::GetInstance().m_ListJap},
|
|
|
|
{tr("Show PAL"), &SConfig::GetInstance().m_ListPal},
|
|
|
|
{tr("Show USA"), &SConfig::GetInstance().m_ListUsa},
|
|
|
|
{tr("Show Australia"), &SConfig::GetInstance().m_ListAustralia},
|
|
|
|
{tr("Show France"), &SConfig::GetInstance().m_ListFrance},
|
|
|
|
{tr("Show Germany"), &SConfig::GetInstance().m_ListGermany},
|
|
|
|
{tr("Show Italy"), &SConfig::GetInstance().m_ListItaly},
|
|
|
|
{tr("Show Korea"), &SConfig::GetInstance().m_ListKorea},
|
|
|
|
{tr("Show Netherlands"), &SConfig::GetInstance().m_ListNetherlands},
|
|
|
|
{tr("Show Russia"), &SConfig::GetInstance().m_ListRussia},
|
|
|
|
{tr("Show Spain"), &SConfig::GetInstance().m_ListSpain},
|
|
|
|
{tr("Show Taiwan"), &SConfig::GetInstance().m_ListTaiwan},
|
|
|
|
{tr("Show World"), &SConfig::GetInstance().m_ListWorld},
|
|
|
|
{tr("Show Unknown"), &SConfig::GetInstance().m_ListUnknown}};
|
|
|
|
|
|
|
|
QActionGroup* region_group = new QActionGroup(this);
|
|
|
|
QMenu* region_menu = view_menu->addMenu(tr("Show Regions"));
|
|
|
|
region_group->setExclusive(false);
|
|
|
|
|
|
|
|
for (const auto& key : region_map.keys())
|
|
|
|
{
|
|
|
|
bool* config = region_map[key];
|
|
|
|
QAction* action = region_group->addAction(region_menu->addAction(key));
|
|
|
|
action->setCheckable(true);
|
|
|
|
action->setChecked(*config);
|
|
|
|
connect(action, &QAction::toggled, [this, config, key](bool value) {
|
|
|
|
*config = value;
|
|
|
|
emit GameListRegionVisibilityToggled(key, value);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-27 11:55:05 +00:00
|
|
|
void MenuBar::AddMovieMenu()
|
|
|
|
{
|
|
|
|
auto* movie_menu = addMenu(tr("&Movie"));
|
|
|
|
m_recording_start =
|
2018-07-09 08:02:10 +00:00
|
|
|
movie_menu->addAction(tr("Start Re&cording Input"), this, [this] { emit StartRecording(); });
|
2017-08-27 11:55:05 +00:00
|
|
|
m_recording_play =
|
2018-07-09 08:02:10 +00:00
|
|
|
movie_menu->addAction(tr("P&lay Input Recording..."), this, [this] { emit PlayRecording(); });
|
|
|
|
m_recording_stop = movie_menu->addAction(tr("Stop Playing/Recording Input"), this,
|
|
|
|
[this] { emit StopRecording(); });
|
2017-08-27 11:55:05 +00:00
|
|
|
m_recording_export =
|
2018-07-09 08:02:10 +00:00
|
|
|
movie_menu->addAction(tr("Export Recording..."), this, [this] { emit ExportRecording(); });
|
2017-08-27 11:55:05 +00:00
|
|
|
|
|
|
|
m_recording_start->setEnabled(false);
|
|
|
|
m_recording_play->setEnabled(false);
|
|
|
|
m_recording_stop->setEnabled(false);
|
|
|
|
m_recording_export->setEnabled(false);
|
|
|
|
|
2017-11-02 13:32:16 +00:00
|
|
|
m_recording_read_only = movie_menu->addAction(tr("&Read-Only Mode"));
|
2017-08-27 11:55:05 +00:00
|
|
|
m_recording_read_only->setCheckable(true);
|
|
|
|
m_recording_read_only->setChecked(Movie::IsReadOnly());
|
|
|
|
connect(m_recording_read_only, &QAction::toggled, [](bool value) { Movie::SetReadOnly(value); });
|
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
movie_menu->addAction(tr("TAS Input"), this, [this] { emit ShowTASInput(); });
|
2018-01-27 13:35:02 +00:00
|
|
|
|
2017-08-27 11:55:05 +00:00
|
|
|
movie_menu->addSeparator();
|
|
|
|
|
|
|
|
auto* pause_at_end = movie_menu->addAction(tr("Pause at End of Movie"));
|
|
|
|
pause_at_end->setCheckable(true);
|
|
|
|
pause_at_end->setChecked(SConfig::GetInstance().m_PauseMovie);
|
|
|
|
connect(pause_at_end, &QAction::toggled,
|
|
|
|
[](bool value) { SConfig::GetInstance().m_PauseMovie = value; });
|
|
|
|
|
|
|
|
auto* lag_counter = movie_menu->addAction(tr("Show Lag Counter"));
|
|
|
|
lag_counter->setCheckable(true);
|
|
|
|
lag_counter->setChecked(SConfig::GetInstance().m_ShowLag);
|
|
|
|
connect(lag_counter, &QAction::toggled,
|
|
|
|
[](bool value) { SConfig::GetInstance().m_ShowLag = value; });
|
|
|
|
|
|
|
|
auto* frame_counter = movie_menu->addAction(tr("Show Frame Counter"));
|
|
|
|
frame_counter->setCheckable(true);
|
|
|
|
frame_counter->setChecked(SConfig::GetInstance().m_ShowFrameCount);
|
|
|
|
connect(frame_counter, &QAction::toggled,
|
|
|
|
[](bool value) { SConfig::GetInstance().m_ShowFrameCount = value; });
|
|
|
|
|
|
|
|
auto* input_display = movie_menu->addAction(tr("Show Input Display"));
|
|
|
|
input_display->setCheckable(true);
|
|
|
|
input_display->setChecked(SConfig::GetInstance().m_ShowInputDisplay);
|
2018-05-16 19:07:15 +00:00
|
|
|
connect(input_display, &QAction::toggled,
|
2017-08-27 11:55:05 +00:00
|
|
|
[](bool value) { SConfig::GetInstance().m_ShowInputDisplay = value; });
|
|
|
|
|
|
|
|
auto* system_clock = movie_menu->addAction(tr("Show System Clock"));
|
|
|
|
system_clock->setCheckable(true);
|
|
|
|
system_clock->setChecked(SConfig::GetInstance().m_ShowRTC);
|
|
|
|
connect(system_clock, &QAction::toggled,
|
|
|
|
[](bool value) { SConfig::GetInstance().m_ShowRTC = value; });
|
|
|
|
|
|
|
|
movie_menu->addSeparator();
|
|
|
|
|
|
|
|
auto* dump_frames = movie_menu->addAction(tr("Dump Frames"));
|
|
|
|
dump_frames->setCheckable(true);
|
|
|
|
dump_frames->setChecked(SConfig::GetInstance().m_DumpFrames);
|
|
|
|
connect(dump_frames, &QAction::toggled,
|
|
|
|
[](bool value) { SConfig::GetInstance().m_DumpFrames = value; });
|
|
|
|
|
|
|
|
auto* dump_audio = movie_menu->addAction(tr("Dump Audio"));
|
|
|
|
dump_audio->setCheckable(true);
|
|
|
|
dump_audio->setChecked(SConfig::GetInstance().m_DumpAudio);
|
|
|
|
connect(dump_audio, &QAction::toggled,
|
|
|
|
[](bool value) { SConfig::GetInstance().m_DumpAudio = value; });
|
|
|
|
}
|
|
|
|
|
2018-04-09 13:31:20 +00:00
|
|
|
void MenuBar::AddJITMenu()
|
|
|
|
{
|
|
|
|
m_jit = addMenu(tr("JIT"));
|
|
|
|
|
|
|
|
m_jit_interpreter_core = m_jit->addAction(tr("Interpreter Core"));
|
|
|
|
m_jit_interpreter_core->setCheckable(true);
|
2018-06-15 12:11:18 +00:00
|
|
|
m_jit_interpreter_core->setChecked(SConfig::GetInstance().cpu_core ==
|
|
|
|
PowerPC::CPUCore::Interpreter);
|
2018-04-09 13:31:20 +00:00
|
|
|
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_interpreter_core, &QAction::toggled, [](bool enabled) {
|
|
|
|
PowerPC::SetMode(enabled ? PowerPC::CoreMode::Interpreter : PowerPC::CoreMode::JIT);
|
|
|
|
});
|
|
|
|
|
2018-04-09 13:31:20 +00:00
|
|
|
m_jit->addSeparator();
|
|
|
|
|
|
|
|
m_jit_block_linking = m_jit->addAction(tr("JIT Block Linking Off"));
|
|
|
|
m_jit_block_linking->setCheckable(true);
|
|
|
|
m_jit_block_linking->setChecked(SConfig::GetInstance().bJITNoBlockLinking);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_block_linking, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITNoBlockLinking = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_disable_cache = m_jit->addAction(tr("Disable JIT Cache"));
|
|
|
|
m_jit_disable_cache->setCheckable(true);
|
|
|
|
m_jit_disable_cache->setChecked(SConfig::GetInstance().bJITNoBlockCache);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_disable_cache, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITNoBlockCache = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
2020-06-02 10:18:45 +00:00
|
|
|
m_jit_disable_fastmem = m_jit->addAction(tr("Disable Fastmem"));
|
|
|
|
m_jit_disable_fastmem->setCheckable(true);
|
|
|
|
m_jit_disable_fastmem->setChecked(!SConfig::GetInstance().bFastmem);
|
|
|
|
connect(m_jit_disable_fastmem, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bFastmem = !enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
m_jit_clear_cache = m_jit->addAction(tr("Clear Cache"), this, &MenuBar::ClearCache);
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit->addSeparator();
|
|
|
|
|
|
|
|
m_jit_log_coverage =
|
2018-07-09 08:02:10 +00:00
|
|
|
m_jit->addAction(tr("Log JIT Instruction Coverage"), this, &MenuBar::LogInstructions);
|
2018-04-09 13:31:20 +00:00
|
|
|
m_jit_search_instruction =
|
2018-07-09 08:02:10 +00:00
|
|
|
m_jit->addAction(tr("Search for an Instruction"), this, &MenuBar::SearchInstruction);
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit->addSeparator();
|
|
|
|
|
|
|
|
m_jit_off = m_jit->addAction(tr("JIT Off (JIT Core)"));
|
|
|
|
m_jit_off->setCheckable(true);
|
|
|
|
m_jit_off->setChecked(SConfig::GetInstance().bJITOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_loadstore_off = m_jit->addAction(tr("JIT LoadStore Off"));
|
|
|
|
m_jit_loadstore_off->setCheckable(true);
|
|
|
|
m_jit_loadstore_off->setChecked(SConfig::GetInstance().bJITLoadStoreOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_loadstore_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITLoadStoreOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_loadstore_lbzx_off = m_jit->addAction(tr("JIT LoadStore lbzx Off"));
|
|
|
|
m_jit_loadstore_lbzx_off->setCheckable(true);
|
|
|
|
m_jit_loadstore_lbzx_off->setChecked(SConfig::GetInstance().bJITLoadStorelbzxOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_loadstore_lbzx_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITLoadStorelbzxOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_loadstore_lxz_off = m_jit->addAction(tr("JIT LoadStore lXz Off"));
|
|
|
|
m_jit_loadstore_lxz_off->setCheckable(true);
|
|
|
|
m_jit_loadstore_lxz_off->setChecked(SConfig::GetInstance().bJITLoadStorelXzOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_loadstore_lxz_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITLoadStorelXzOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_loadstore_lwz_off = m_jit->addAction(tr("JIT LoadStore lwz Off"));
|
|
|
|
m_jit_loadstore_lwz_off->setCheckable(true);
|
|
|
|
m_jit_loadstore_lwz_off->setChecked(SConfig::GetInstance().bJITLoadStorelwzOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_loadstore_lwz_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITLoadStorelwzOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_loadstore_floating_off = m_jit->addAction(tr("JIT LoadStore Floating Off"));
|
|
|
|
m_jit_loadstore_floating_off->setCheckable(true);
|
|
|
|
m_jit_loadstore_floating_off->setChecked(SConfig::GetInstance().bJITLoadStoreFloatingOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_loadstore_floating_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITLoadStoreFloatingOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_loadstore_paired_off = m_jit->addAction(tr("JIT LoadStore Paired Off"));
|
|
|
|
m_jit_loadstore_paired_off->setCheckable(true);
|
|
|
|
m_jit_loadstore_paired_off->setChecked(SConfig::GetInstance().bJITLoadStorePairedOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_loadstore_paired_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITLoadStorePairedOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_floatingpoint_off = m_jit->addAction(tr("JIT FloatingPoint Off"));
|
|
|
|
m_jit_floatingpoint_off->setCheckable(true);
|
|
|
|
m_jit_floatingpoint_off->setChecked(SConfig::GetInstance().bJITFloatingPointOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_floatingpoint_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITFloatingPointOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_integer_off = m_jit->addAction(tr("JIT Integer Off"));
|
|
|
|
m_jit_integer_off->setCheckable(true);
|
|
|
|
m_jit_integer_off->setChecked(SConfig::GetInstance().bJITIntegerOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_integer_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITIntegerOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_paired_off = m_jit->addAction(tr("JIT Paired Off"));
|
|
|
|
m_jit_paired_off->setCheckable(true);
|
|
|
|
m_jit_paired_off->setChecked(SConfig::GetInstance().bJITPairedOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_paired_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITPairedOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
m_jit_systemregisters_off = m_jit->addAction(tr("JIT SystemRegisters Off"));
|
|
|
|
m_jit_systemregisters_off->setCheckable(true);
|
|
|
|
m_jit_systemregisters_off->setChecked(SConfig::GetInstance().bJITSystemRegistersOff);
|
2018-05-29 14:40:05 +00:00
|
|
|
connect(m_jit_systemregisters_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITSystemRegistersOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-07-08 18:32:40 +00:00
|
|
|
|
|
|
|
m_jit_branch_off = m_jit->addAction(tr("JIT Branch Off"));
|
|
|
|
m_jit_branch_off->setCheckable(true);
|
|
|
|
m_jit_branch_off->setChecked(SConfig::GetInstance().bJITBranchOff);
|
|
|
|
connect(m_jit_branch_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITBranchOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2019-11-16 10:25:26 +00:00
|
|
|
|
|
|
|
m_jit_register_cache_off = m_jit->addAction(tr("JIT Register Cache Off"));
|
|
|
|
m_jit_register_cache_off->setCheckable(true);
|
|
|
|
m_jit_register_cache_off->setChecked(SConfig::GetInstance().bJITRegisterCacheOff);
|
|
|
|
connect(m_jit_register_cache_off, &QAction::toggled, [this](bool enabled) {
|
|
|
|
SConfig::GetInstance().bJITRegisterCacheOff = enabled;
|
|
|
|
ClearCache();
|
|
|
|
});
|
2018-04-09 13:31:20 +00:00
|
|
|
}
|
|
|
|
|
2018-02-14 22:25:01 +00:00
|
|
|
void MenuBar::AddSymbolsMenu()
|
|
|
|
{
|
|
|
|
m_symbols = addMenu(tr("Symbols"));
|
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
m_symbols->addAction(tr("&Clear Symbols"), this, &MenuBar::ClearSymbols);
|
2018-02-14 22:25:01 +00:00
|
|
|
|
2018-03-19 17:52:46 +00:00
|
|
|
auto* generate = m_symbols->addMenu(tr("&Generate Symbols From"));
|
2018-07-09 08:02:10 +00:00
|
|
|
generate->addAction(tr("Address"), this, &MenuBar::GenerateSymbolsFromAddress);
|
|
|
|
generate->addAction(tr("Signature Database"), this, &MenuBar::GenerateSymbolsFromSignatureDB);
|
|
|
|
generate->addAction(tr("RSO Modules"), this, &MenuBar::GenerateSymbolsFromRSO);
|
2018-02-14 22:25:01 +00:00
|
|
|
m_symbols->addSeparator();
|
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
m_symbols->addAction(tr("&Load Symbol Map"), this, &MenuBar::LoadSymbolMap);
|
|
|
|
m_symbols->addAction(tr("&Save Symbol Map"), this, &MenuBar::SaveSymbolMap);
|
2018-02-14 22:25:01 +00:00
|
|
|
m_symbols->addSeparator();
|
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
m_symbols->addAction(tr("Load &Other Map File..."), this, &MenuBar::LoadOtherSymbolMap);
|
2018-10-09 00:59:55 +00:00
|
|
|
m_symbols->addAction(tr("Load &Bad Map File..."), this, &MenuBar::LoadBadSymbolMap);
|
2018-07-09 08:02:10 +00:00
|
|
|
m_symbols->addAction(tr("Save Symbol Map &As..."), this, &MenuBar::SaveSymbolMapAs);
|
2018-02-14 22:25:01 +00:00
|
|
|
m_symbols->addSeparator();
|
|
|
|
|
2018-10-09 00:59:55 +00:00
|
|
|
m_symbols->addAction(tr("Sa&ve Code"), this, &MenuBar::SaveCode);
|
2018-02-14 22:25:01 +00:00
|
|
|
m_symbols->addSeparator();
|
|
|
|
|
2018-10-09 00:59:55 +00:00
|
|
|
m_symbols->addAction(tr("C&reate Signature File..."), this, &MenuBar::CreateSignatureFile);
|
|
|
|
m_symbols->addAction(tr("Append to &Existing Signature File..."), this,
|
|
|
|
&MenuBar::AppendSignatureFile);
|
|
|
|
m_symbols->addAction(tr("Combine &Two Signature Files..."), this,
|
|
|
|
&MenuBar::CombineSignatureFiles);
|
|
|
|
m_symbols->addAction(tr("Appl&y Signature File..."), this, &MenuBar::ApplySignatureFile);
|
2018-02-14 22:25:01 +00:00
|
|
|
m_symbols->addSeparator();
|
|
|
|
|
2018-07-09 08:02:10 +00:00
|
|
|
m_symbols->addAction(tr("&Patch HLE Functions"), this, &MenuBar::PatchHLEFunctions);
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
|
2017-06-14 09:58:11 +00:00
|
|
|
void MenuBar::UpdateToolsMenu(bool emulation_started)
|
|
|
|
{
|
2017-07-06 09:00:37 +00:00
|
|
|
m_boot_sysmenu->setEnabled(!emulation_started);
|
2017-07-06 09:01:32 +00:00
|
|
|
m_perform_online_update_menu->setEnabled(!emulation_started);
|
2017-08-24 14:35:47 +00:00
|
|
|
m_ntscj_ipl->setEnabled(!emulation_started &&
|
|
|
|
File::Exists(SConfig::GetInstance().GetBootROMPath(JAP_DIR)));
|
|
|
|
m_ntscu_ipl->setEnabled(!emulation_started &&
|
|
|
|
File::Exists(SConfig::GetInstance().GetBootROMPath(USA_DIR)));
|
|
|
|
m_pal_ipl->setEnabled(!emulation_started &&
|
|
|
|
File::Exists(SConfig::GetInstance().GetBootROMPath(EUR_DIR)));
|
2017-08-24 15:38:31 +00:00
|
|
|
m_import_backup->setEnabled(!emulation_started);
|
2017-10-03 14:45:59 +00:00
|
|
|
m_check_nand->setEnabled(!emulation_started);
|
2017-07-06 09:00:37 +00:00
|
|
|
|
2017-07-06 09:01:32 +00:00
|
|
|
if (!emulation_started)
|
2017-06-14 09:58:11 +00:00
|
|
|
{
|
|
|
|
IOS::HLE::Kernel ios;
|
|
|
|
const auto tmd = ios.GetES()->FindInstalledTMD(Titles::SYSTEM_MENU);
|
2017-07-06 09:00:37 +00:00
|
|
|
|
|
|
|
const QString sysmenu_version =
|
|
|
|
tmd.IsValid() ?
|
|
|
|
QString::fromStdString(DiscIO::GetSysMenuVersionString(tmd.GetTitleVersion())) :
|
2019-07-30 11:57:06 +00:00
|
|
|
QString{};
|
2017-07-06 09:00:37 +00:00
|
|
|
m_boot_sysmenu->setText(tr("Load Wii System Menu %1").arg(sysmenu_version));
|
|
|
|
|
2017-07-06 09:01:32 +00:00
|
|
|
m_boot_sysmenu->setEnabled(tmd.IsValid());
|
2017-07-06 09:00:37 +00:00
|
|
|
|
2017-06-14 09:58:11 +00:00
|
|
|
for (QAction* action : m_perform_online_update_menu->actions())
|
|
|
|
action->setEnabled(!tmd.IsValid());
|
|
|
|
m_perform_online_update_for_current_region->setEnabled(tmd.IsValid());
|
|
|
|
}
|
2018-01-24 14:25:35 +00:00
|
|
|
|
|
|
|
const auto ios = IOS::HLE::GetIOS();
|
|
|
|
const auto bt = ios ? std::static_pointer_cast<IOS::HLE::Device::BluetoothEmu>(
|
|
|
|
ios->GetDeviceByName("/dev/usb/oh1/57e/305")) :
|
|
|
|
nullptr;
|
2018-06-20 19:27:31 +00:00
|
|
|
const bool enable_wiimotes =
|
2018-01-24 14:25:35 +00:00
|
|
|
emulation_started && bt && !SConfig::GetInstance().m_bt_passthrough_enabled;
|
|
|
|
|
2018-06-20 19:27:31 +00:00
|
|
|
for (std::size_t i = 0; i < m_wii_remotes.size(); i++)
|
2018-01-24 14:25:35 +00:00
|
|
|
{
|
2018-06-20 19:27:31 +00:00
|
|
|
QAction* const wii_remote = m_wii_remotes[i];
|
|
|
|
|
|
|
|
wii_remote->setEnabled(enable_wiimotes);
|
2018-01-24 14:25:35 +00:00
|
|
|
if (enable_wiimotes)
|
2018-06-21 15:31:26 +00:00
|
|
|
wii_remote->setChecked(bt->AccessWiimoteByIndex(i)->IsConnected());
|
2018-01-24 14:25:35 +00:00
|
|
|
}
|
2017-06-14 09:58:11 +00:00
|
|
|
}
|
|
|
|
|
2017-05-04 21:01:12 +00:00
|
|
|
void MenuBar::InstallWAD()
|
|
|
|
{
|
|
|
|
QString wad_file = QFileDialog::getOpenFileName(this, tr("Select a title to install to NAND"),
|
|
|
|
QString(), tr("WAD files (*.wad)"));
|
|
|
|
|
|
|
|
if (wad_file.isEmpty())
|
|
|
|
return;
|
|
|
|
|
2017-12-31 19:33:36 +00:00
|
|
|
if (WiiUtils::InstallWAD(wad_file.toStdString()))
|
2017-05-04 21:01:12 +00:00
|
|
|
{
|
2017-12-31 19:33:36 +00:00
|
|
|
Settings::Instance().NANDRefresh();
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::information(this, tr("Success"),
|
|
|
|
tr("Successfully installed this title to the NAND."));
|
2017-05-04 21:01:12 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::critical(this, tr("Failure"), tr("Failed to install this title to the NAND."));
|
2017-05-04 21:01:12 +00:00
|
|
|
}
|
|
|
|
}
|
2017-08-24 13:11:04 +00:00
|
|
|
|
|
|
|
void MenuBar::ImportWiiSave()
|
|
|
|
{
|
|
|
|
QString file = QFileDialog::getOpenFileName(this, tr("Select the save file"), QDir::currentPath(),
|
|
|
|
tr("Wii save files (*.bin);;"
|
|
|
|
"All Files (*)"));
|
|
|
|
|
2018-05-13 11:18:19 +00:00
|
|
|
if (file.isEmpty())
|
|
|
|
return;
|
|
|
|
|
2018-06-01 18:41:52 +00:00
|
|
|
bool cancelled = false;
|
|
|
|
auto can_overwrite = [&] {
|
2019-03-04 19:49:00 +00:00
|
|
|
bool yes = ModalMessageBox::question(
|
2018-06-01 18:41:52 +00:00
|
|
|
this, tr("Save Import"),
|
|
|
|
tr("Save data for this title already exists in the NAND. Consider backing up "
|
|
|
|
"the current data before overwriting.\nOverwrite now?")) == QMessageBox::Yes;
|
|
|
|
cancelled = !yes;
|
|
|
|
return yes;
|
|
|
|
};
|
|
|
|
if (WiiSave::Import(file.toStdString(), can_overwrite))
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::information(this, tr("Save Import"), tr("Successfully imported save files."));
|
2018-06-01 18:41:52 +00:00
|
|
|
else if (!cancelled)
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::critical(this, tr("Save Import"), tr("Failed to import save files."));
|
2017-08-24 13:11:04 +00:00
|
|
|
}
|
2017-08-24 13:21:21 +00:00
|
|
|
|
|
|
|
void MenuBar::ExportWiiSaves()
|
|
|
|
{
|
2018-05-13 13:34:30 +00:00
|
|
|
const QString export_dir = QFileDialog::getExistingDirectory(
|
|
|
|
this, tr("Select Export Directory"), QString::fromStdString(File::GetUserPath(D_USER_IDX)),
|
|
|
|
QFileDialog::ShowDirsOnly);
|
|
|
|
if (export_dir.isEmpty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
const size_t count = WiiSave::ExportAll(export_dir.toStdString());
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::information(this, tr("Save Export"),
|
|
|
|
tr("Exported %n save(s)", "", static_cast<int>(count)));
|
2017-08-24 13:21:21 +00:00
|
|
|
}
|
2017-08-24 15:38:31 +00:00
|
|
|
|
2017-10-03 14:45:59 +00:00
|
|
|
void MenuBar::CheckNAND()
|
|
|
|
{
|
|
|
|
IOS::HLE::Kernel ios;
|
2017-10-06 19:45:28 +00:00
|
|
|
WiiUtils::NANDCheckResult result = WiiUtils::CheckNAND(ios);
|
|
|
|
if (!result.bad)
|
2017-10-03 14:45:59 +00:00
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::information(this, tr("NAND Check"), tr("No issues have been detected."));
|
2017-10-03 14:45:59 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-10-06 19:45:28 +00:00
|
|
|
QString message = tr("The emulated NAND is damaged. System titles such as the Wii Menu and "
|
|
|
|
"the Wii Shop Channel may not work correctly.\n\n"
|
|
|
|
"Do you want to try to repair the NAND?");
|
|
|
|
if (!result.titles_to_remove.empty())
|
2017-10-03 14:45:59 +00:00
|
|
|
{
|
2017-11-02 10:37:51 +00:00
|
|
|
std::string title_listings;
|
2017-10-06 19:45:28 +00:00
|
|
|
Core::TitleDatabase title_db;
|
2019-02-23 18:18:16 +00:00
|
|
|
const DiscIO::Language language = SConfig::GetInstance().GetCurrentLanguage(true);
|
2017-10-06 19:45:28 +00:00
|
|
|
for (const u64 title_id : result.titles_to_remove)
|
|
|
|
{
|
2017-11-02 16:34:04 +00:00
|
|
|
title_listings += StringFromFormat("%016" PRIx64, title_id);
|
|
|
|
|
2019-02-23 18:18:16 +00:00
|
|
|
const std::string database_name = title_db.GetChannelName(title_id, language);
|
2017-11-02 16:34:04 +00:00
|
|
|
if (!database_name.empty())
|
|
|
|
{
|
|
|
|
title_listings += " - " + database_name;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
DiscIO::WiiSaveBanner banner(title_id);
|
|
|
|
if (banner.IsValid())
|
|
|
|
{
|
|
|
|
title_listings += " - " + banner.GetName();
|
|
|
|
const std::string description = banner.GetDescription();
|
|
|
|
if (!StripSpaces(description).empty())
|
|
|
|
title_listings += " - " + description;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-02 10:37:51 +00:00
|
|
|
title_listings += "\n";
|
2017-10-06 19:45:28 +00:00
|
|
|
}
|
2017-11-02 10:37:51 +00:00
|
|
|
|
|
|
|
message += tr("\n\nWARNING: Fixing this NAND requires the deletion of titles that have "
|
|
|
|
"incomplete data on the NAND, including all associated save data. "
|
|
|
|
"By continuing, the following title(s) will be removed:\n\n"
|
|
|
|
"%1"
|
|
|
|
"\nLaunching these titles may also fix the issues.")
|
|
|
|
.arg(QString::fromStdString(title_listings));
|
2017-10-03 14:45:59 +00:00
|
|
|
}
|
|
|
|
|
2019-03-04 19:49:00 +00:00
|
|
|
if (ModalMessageBox::question(this, tr("NAND Check"), message) != QMessageBox::Yes)
|
2017-10-06 19:45:28 +00:00
|
|
|
return;
|
|
|
|
|
2017-10-03 14:45:59 +00:00
|
|
|
if (WiiUtils::RepairNAND(ios))
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::information(this, tr("NAND Check"), tr("The NAND has been repaired."));
|
2017-10-03 14:45:59 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::critical(this, tr("NAND Check"),
|
|
|
|
tr("The NAND could not be repaired. It is recommended to back up "
|
|
|
|
"your current data and start over with a fresh NAND."));
|
2017-10-03 14:45:59 +00:00
|
|
|
}
|
|
|
|
|
2017-08-26 12:41:53 +00:00
|
|
|
void MenuBar::NANDExtractCertificates()
|
|
|
|
{
|
|
|
|
if (DiscIO::NANDImporter().ExtractCertificates(File::GetUserPath(D_WIIROOT_IDX)))
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::information(this, tr("Success"),
|
|
|
|
tr("Successfully extracted certificates from NAND"));
|
2017-08-26 12:41:53 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::critical(this, tr("Error"), tr("Failed to extract certificates from NAND"));
|
2017-08-26 12:41:53 +00:00
|
|
|
}
|
|
|
|
}
|
2017-08-27 11:55:05 +00:00
|
|
|
|
2017-12-31 19:33:36 +00:00
|
|
|
void MenuBar::OnSelectionChanged(std::shared_ptr<const UICommon::GameFile> game_file)
|
2017-08-27 11:55:05 +00:00
|
|
|
{
|
2019-08-14 11:45:07 +00:00
|
|
|
m_game_selected = !!game_file;
|
2017-08-27 11:55:05 +00:00
|
|
|
|
2019-08-14 11:45:07 +00:00
|
|
|
m_recording_play->setEnabled(m_game_selected && !Core::IsRunning());
|
|
|
|
m_recording_start->setEnabled((m_game_selected || Core::IsRunning()) && !Movie::IsPlayingInput());
|
2017-08-27 11:55:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::OnRecordingStatusChanged(bool recording)
|
|
|
|
{
|
2019-08-14 11:45:07 +00:00
|
|
|
m_recording_start->setEnabled(!recording && (m_game_selected || Core::IsRunning()));
|
2017-08-27 11:55:05 +00:00
|
|
|
m_recording_stop->setEnabled(recording);
|
2019-06-08 06:39:12 +00:00
|
|
|
m_recording_export->setEnabled(recording);
|
2017-08-27 11:55:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::OnReadOnlyModeChanged(bool read_only)
|
|
|
|
{
|
|
|
|
m_recording_read_only->setChecked(read_only);
|
|
|
|
}
|
2018-02-14 22:25:01 +00:00
|
|
|
|
|
|
|
void MenuBar::ChangeDebugFont()
|
|
|
|
{
|
|
|
|
bool okay;
|
|
|
|
QFont font = QFontDialog::getFont(&okay, Settings::Instance().GetDebugFont(), this,
|
|
|
|
tr("Pick a debug font"));
|
|
|
|
|
|
|
|
if (okay)
|
|
|
|
Settings::Instance().SetDebugFont(font);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::ClearSymbols()
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
auto result = ModalMessageBox::warning(this, tr("Confirmation"),
|
|
|
|
tr("Do you want to clear the list of symbol names?"),
|
|
|
|
QMessageBox::Yes | QMessageBox::Cancel);
|
2018-02-14 22:25:01 +00:00
|
|
|
|
|
|
|
if (result == QMessageBox::Cancel)
|
|
|
|
return;
|
|
|
|
|
|
|
|
g_symbolDB.Clear();
|
2018-05-11 20:38:32 +00:00
|
|
|
emit NotifySymbolsUpdated();
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::GenerateSymbolsFromAddress()
|
|
|
|
{
|
2020-04-28 17:10:50 +00:00
|
|
|
PPCAnalyst::FindFunctions(Memory::MEM1_BASE_ADDR,
|
|
|
|
Memory::MEM1_BASE_ADDR + Memory::GetRamSizeReal(), &g_symbolDB);
|
2018-05-11 20:38:32 +00:00
|
|
|
emit NotifySymbolsUpdated();
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::GenerateSymbolsFromSignatureDB()
|
|
|
|
{
|
2020-04-28 17:10:50 +00:00
|
|
|
PPCAnalyst::FindFunctions(Memory::MEM1_BASE_ADDR,
|
|
|
|
Memory::MEM1_BASE_ADDR + Memory::GetRamSizeReal(), &g_symbolDB);
|
2018-02-14 22:25:01 +00:00
|
|
|
SignatureDB db(SignatureDB::HandlerType::DSY);
|
|
|
|
if (db.Load(File::GetSysDirectory() + TOTALDB))
|
|
|
|
{
|
|
|
|
db.Apply(&g_symbolDB);
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::information(
|
2018-02-14 22:25:01 +00:00
|
|
|
this, tr("Information"),
|
|
|
|
tr("Generated symbol names from '%1'").arg(QString::fromStdString(TOTALDB)));
|
|
|
|
db.List();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::critical(
|
2018-02-14 22:25:01 +00:00
|
|
|
this, tr("Error"),
|
|
|
|
tr("'%1' not found, no symbol names generated").arg(QString::fromStdString(TOTALDB)));
|
|
|
|
}
|
|
|
|
|
2018-05-11 20:38:32 +00:00
|
|
|
emit NotifySymbolsUpdated();
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::GenerateSymbolsFromRSO()
|
|
|
|
{
|
2020-03-10 09:41:59 +00:00
|
|
|
// i18n: RSO refers to a proprietary format for shared objects (like DLL files).
|
|
|
|
const int ret =
|
|
|
|
ModalMessageBox::question(this, tr("RSO auto-detection"), tr("Auto-detect RSO modules?"));
|
|
|
|
if (ret == QMessageBox::Yes)
|
|
|
|
return GenerateSymbolsFromRSOAuto();
|
|
|
|
|
2018-02-14 22:25:01 +00:00
|
|
|
QString text = QInputDialog::getText(this, tr("Input"), tr("Enter the RSO module address:"));
|
|
|
|
bool good;
|
|
|
|
uint address = text.toUInt(&good, 16);
|
|
|
|
|
|
|
|
if (!good)
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::warning(this, tr("Error"), tr("Invalid RSO module address: %1").arg(text));
|
2018-02-14 22:25:01 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
RSOChainView rso_chain;
|
|
|
|
if (rso_chain.Load(static_cast<u32>(address)))
|
|
|
|
{
|
|
|
|
rso_chain.Apply(&g_symbolDB);
|
2018-05-11 20:38:32 +00:00
|
|
|
emit NotifySymbolsUpdated();
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::warning(this, tr("Error"), tr("Failed to load RSO module at %1").arg(text));
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-10 09:41:59 +00:00
|
|
|
void MenuBar::GenerateSymbolsFromRSOAuto()
|
|
|
|
{
|
|
|
|
constexpr std::array<std::string_view, 2> search_for = {".elf", ".plf"};
|
|
|
|
const AddressSpace::Accessors* accessors =
|
|
|
|
AddressSpace::GetAccessors(AddressSpace::Type::Effective);
|
|
|
|
std::vector<std::pair<u32, std::string>> matches;
|
|
|
|
|
|
|
|
// Find filepath to elf/plf commonly used by RSO modules
|
|
|
|
for (const auto& str : search_for)
|
|
|
|
{
|
|
|
|
u32 next = 0;
|
|
|
|
while (true)
|
|
|
|
{
|
|
|
|
auto found_addr =
|
|
|
|
accessors->Search(next, reinterpret_cast<const u8*>(str.data()), str.size() + 1, true);
|
|
|
|
|
|
|
|
if (!found_addr.has_value())
|
|
|
|
break;
|
|
|
|
next = *found_addr + 1;
|
|
|
|
|
|
|
|
// Get the beginning of the string
|
|
|
|
found_addr = accessors->Search(*found_addr, reinterpret_cast<const u8*>(""), 1, false);
|
|
|
|
if (!found_addr.has_value())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Get the string reference
|
|
|
|
const u32 ref_addr = *found_addr + 1;
|
|
|
|
const std::array<u8, 4> ref = {static_cast<u8>(ref_addr >> 24),
|
|
|
|
static_cast<u8>(ref_addr >> 16),
|
|
|
|
static_cast<u8>(ref_addr >> 8), static_cast<u8>(ref_addr)};
|
|
|
|
found_addr = accessors->Search(ref_addr, ref.data(), ref.size(), false);
|
|
|
|
if (!found_addr.has_value() || *found_addr < 16)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Go to the beginning of the RSO header
|
|
|
|
matches.emplace_back(*found_addr - 16, PowerPC::HostGetString(ref_addr, 128));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QStringList items;
|
|
|
|
for (const auto& match : matches)
|
|
|
|
{
|
|
|
|
const QString item = QLatin1String("%1 %2");
|
|
|
|
|
|
|
|
items << item.arg(QString::number(match.first, 16), QString::fromStdString(match.second));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (items.empty())
|
|
|
|
{
|
|
|
|
ModalMessageBox::warning(this, tr("Error"), tr("Unable to auto-detect RSO module"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ok;
|
|
|
|
const QString item = QInputDialog::getItem(
|
|
|
|
this, tr("Input"), tr("Select the RSO module address:"), items, 0, false, &ok);
|
|
|
|
|
|
|
|
if (!ok)
|
|
|
|
return;
|
|
|
|
|
|
|
|
RSOChainView rso_chain;
|
|
|
|
const u32 address = item.mid(0, item.indexOf(QLatin1Char(' '))).toUInt(nullptr, 16);
|
|
|
|
if (rso_chain.Load(address))
|
|
|
|
{
|
|
|
|
rso_chain.Apply(&g_symbolDB);
|
|
|
|
emit NotifySymbolsUpdated();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ModalMessageBox::warning(this, tr("Error"), tr("Failed to load RSO module at %1").arg(address));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-14 22:25:01 +00:00
|
|
|
void MenuBar::LoadSymbolMap()
|
|
|
|
{
|
|
|
|
std::string existing_map_file, writable_map_file;
|
|
|
|
bool map_exists = CBoot::FindMapFile(&existing_map_file, &writable_map_file);
|
|
|
|
|
|
|
|
if (!map_exists)
|
|
|
|
{
|
|
|
|
g_symbolDB.Clear();
|
2020-04-28 17:10:50 +00:00
|
|
|
PPCAnalyst::FindFunctions(Memory::MEM1_BASE_ADDR + 0x1300000,
|
|
|
|
Memory::MEM1_BASE_ADDR + Memory::GetRamSizeReal(), &g_symbolDB);
|
2018-02-14 22:25:01 +00:00
|
|
|
SignatureDB db(SignatureDB::HandlerType::DSY);
|
|
|
|
if (db.Load(File::GetSysDirectory() + TOTALDB))
|
|
|
|
db.Apply(&g_symbolDB);
|
|
|
|
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::warning(this, tr("Warning"),
|
|
|
|
tr("'%1' not found, scanning for common functions instead")
|
|
|
|
.arg(QString::fromStdString(writable_map_file)));
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2018-07-10 18:05:25 +00:00
|
|
|
const QString existing_map_file_path = QString::fromStdString(existing_map_file);
|
|
|
|
|
|
|
|
if (!TryLoadMapFile(existing_map_file_path))
|
|
|
|
return;
|
|
|
|
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::information(this, tr("Information"),
|
|
|
|
tr("Loaded symbols from '%1'").arg(existing_map_file_path));
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
HLE::PatchFunctions();
|
2018-05-11 20:38:32 +00:00
|
|
|
emit NotifySymbolsUpdated();
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::SaveSymbolMap()
|
|
|
|
{
|
|
|
|
std::string existing_map_file, writable_map_file;
|
|
|
|
CBoot::FindMapFile(&existing_map_file, &writable_map_file);
|
|
|
|
|
2018-07-10 18:05:25 +00:00
|
|
|
TrySaveSymbolMap(QString::fromStdString(writable_map_file));
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::LoadOtherSymbolMap()
|
|
|
|
{
|
2018-07-10 18:05:25 +00:00
|
|
|
const QString file = QFileDialog::getOpenFileName(
|
|
|
|
this, tr("Load map file"), QString::fromStdString(File::GetUserPath(D_MAPS_IDX)),
|
|
|
|
tr("Dolphin Map File (*.map)"));
|
2018-02-14 22:25:01 +00:00
|
|
|
|
|
|
|
if (file.isEmpty())
|
|
|
|
return;
|
|
|
|
|
2018-07-10 18:05:25 +00:00
|
|
|
if (!TryLoadMapFile(file))
|
|
|
|
return;
|
|
|
|
|
2018-02-14 22:25:01 +00:00
|
|
|
HLE::PatchFunctions();
|
2018-05-11 20:38:32 +00:00
|
|
|
emit NotifySymbolsUpdated();
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
|
2018-10-09 00:59:55 +00:00
|
|
|
void MenuBar::LoadBadSymbolMap()
|
|
|
|
{
|
|
|
|
const QString file = QFileDialog::getOpenFileName(
|
|
|
|
this, tr("Load map file"), QString::fromStdString(File::GetUserPath(D_MAPS_IDX)),
|
|
|
|
tr("Dolphin Map File (*.map)"));
|
|
|
|
|
|
|
|
if (file.isEmpty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!TryLoadMapFile(file, true))
|
|
|
|
return;
|
|
|
|
|
|
|
|
HLE::PatchFunctions();
|
|
|
|
emit NotifySymbolsUpdated();
|
|
|
|
}
|
|
|
|
|
2018-02-14 22:25:01 +00:00
|
|
|
void MenuBar::SaveSymbolMapAs()
|
|
|
|
{
|
|
|
|
const std::string& title_id_str = SConfig::GetInstance().m_debugger_game_id;
|
2018-07-10 18:05:25 +00:00
|
|
|
const QString file = QFileDialog::getSaveFileName(
|
2018-02-14 22:25:01 +00:00
|
|
|
this, tr("Save map file"),
|
|
|
|
QString::fromStdString(File::GetUserPath(D_MAPS_IDX) + "/" + title_id_str + ".map"),
|
|
|
|
tr("Dolphin Map File (*.map)"));
|
|
|
|
|
|
|
|
if (file.isEmpty())
|
|
|
|
return;
|
|
|
|
|
2018-07-10 18:05:25 +00:00
|
|
|
TrySaveSymbolMap(file);
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::SaveCode()
|
|
|
|
{
|
|
|
|
std::string existing_map_file, writable_map_file;
|
|
|
|
CBoot::FindMapFile(&existing_map_file, &writable_map_file);
|
|
|
|
|
|
|
|
const std::string path =
|
2018-03-28 02:27:48 +00:00
|
|
|
writable_map_file.substr(0, writable_map_file.find_last_of('.')) + "_code.map";
|
2018-02-14 22:25:01 +00:00
|
|
|
|
2018-07-10 18:05:25 +00:00
|
|
|
if (!g_symbolDB.SaveCodeMap(path))
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::warning(
|
2018-07-10 18:05:25 +00:00
|
|
|
this, tr("Error"),
|
|
|
|
tr("Failed to save code map to path '%1'").arg(QString::fromStdString(path)));
|
|
|
|
}
|
2018-02-14 22:25:01 +00:00
|
|
|
}
|
|
|
|
|
2018-10-09 00:59:55 +00:00
|
|
|
bool MenuBar::TryLoadMapFile(const QString& path, const bool bad)
|
2018-02-14 22:25:01 +00:00
|
|
|
{
|
2018-10-09 00:59:55 +00:00
|
|
|
if (!g_symbolDB.LoadMap(path.toStdString(), bad))
|
2018-07-10 18:05:25 +00:00
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::warning(this, tr("Error"), tr("Failed to load map file '%1'").arg(path));
|
2018-07-10 18:05:25 +00:00
|
|
|
return false;
|
|
|
|
}
|
2018-02-14 22:25:01 +00:00
|
|
|
|
2018-07-10 18:05:25 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::TrySaveSymbolMap(const QString& path)
|
|
|
|
{
|
|
|
|
if (g_symbolDB.SaveSymbolMap(path.toStdString()))
|
2018-02-14 22:25:01 +00:00
|
|
|
return;
|
|
|
|
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::warning(this, tr("Error"),
|
|
|
|
tr("Failed to save symbol map to path '%1'").arg(path));
|
2018-07-10 18:05:25 +00:00
|
|
|
}
|
2018-02-14 22:25:01 +00:00
|
|
|
|
2018-07-10 18:05:25 +00:00
|
|
|
void MenuBar::CreateSignatureFile()
|
|
|
|
{
|
|
|
|
const QString text = QInputDialog::getText(
|
|
|
|
this, tr("Input"), tr("Only export symbols with prefix:\n(Blank for all symbols)"));
|
2018-02-14 22:25:01 +00:00
|
|
|
|
2019-10-12 16:04:51 +00:00
|
|
|
const QString file = QFileDialog::getSaveFileName(this, tr("Save signature file"),
|
|
|
|
QDir::homePath(), GetSignatureSelector());
|
2018-02-14 22:25:01 +00:00
|
|
|
if (file.isEmpty())
|
|
|
|
return;
|
|
|
|
|
2018-07-10 18:05:25 +00:00
|
|
|
const std::string prefix = text.toStdString();
|
|
|
|
const std::string save_path = file.toStdString();
|
2018-02-14 22:25:01 +00:00
|
|
|
SignatureDB db(save_path);
|
|
|
|
db.Populate(&g_symbolDB, prefix);
|
2018-07-10 18:05:25 +00:00
|
|
|
|
|
|
|
if (!db.Save(save_path))
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::warning(this, tr("Error"), tr("Failed to save signature file '%1'").arg(file));
|
2018-07-10 18:05:25 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-14 22:25:01 +00:00
|
|
|
db.List();
|
|
|
|
}
|
|
|
|
|
2018-10-09 00:59:55 +00:00
|
|
|
void MenuBar::AppendSignatureFile()
|
|
|
|
{
|
|
|
|
const QString text = QInputDialog::getText(
|
|
|
|
this, tr("Input"), tr("Only append symbols with prefix:\n(Blank for all symbols)"));
|
|
|
|
|
2019-10-12 16:04:51 +00:00
|
|
|
const QString file = QFileDialog::getSaveFileName(this, tr("Append signature to"),
|
|
|
|
QDir::homePath(), GetSignatureSelector());
|
2018-10-09 00:59:55 +00:00
|
|
|
if (file.isEmpty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
const std::string prefix = text.toStdString();
|
|
|
|
const std::string signature_path = file.toStdString();
|
|
|
|
SignatureDB db(signature_path);
|
|
|
|
db.Populate(&g_symbolDB, prefix);
|
|
|
|
db.List();
|
|
|
|
db.Load(signature_path);
|
|
|
|
if (!db.Save(signature_path))
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::warning(this, tr("Error"),
|
|
|
|
tr("Failed to append to signature file '%1'").arg(file));
|
2018-10-09 00:59:55 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
db.List();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::ApplySignatureFile()
|
|
|
|
{
|
2019-10-12 16:04:51 +00:00
|
|
|
const QString file = QFileDialog::getOpenFileName(this, tr("Apply signature file"),
|
|
|
|
QDir::homePath(), GetSignatureSelector());
|
2018-10-09 00:59:55 +00:00
|
|
|
|
|
|
|
if (file.isEmpty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
const std::string load_path = file.toStdString();
|
|
|
|
SignatureDB db(load_path);
|
|
|
|
db.Load(load_path);
|
|
|
|
db.Apply(&g_symbolDB);
|
|
|
|
db.List();
|
|
|
|
HLE::PatchFunctions();
|
|
|
|
emit NotifySymbolsUpdated();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::CombineSignatureFiles()
|
|
|
|
{
|
2019-10-12 16:04:51 +00:00
|
|
|
const QString priorityFile = QFileDialog::getOpenFileName(
|
|
|
|
this, tr("Choose priority input file"), QDir::homePath(), GetSignatureSelector());
|
2018-10-09 00:59:55 +00:00
|
|
|
if (priorityFile.isEmpty())
|
|
|
|
return;
|
|
|
|
|
2019-10-12 16:04:51 +00:00
|
|
|
const QString secondaryFile = QFileDialog::getOpenFileName(
|
|
|
|
this, tr("Choose secondary input file"), QDir::homePath(), GetSignatureSelector());
|
2018-10-09 00:59:55 +00:00
|
|
|
if (secondaryFile.isEmpty())
|
|
|
|
return;
|
|
|
|
|
2019-10-12 16:04:51 +00:00
|
|
|
const QString saveFile = QFileDialog::getSaveFileName(this, tr("Save combined output file as"),
|
|
|
|
QDir::homePath(), GetSignatureSelector());
|
2018-10-09 00:59:55 +00:00
|
|
|
if (saveFile.isEmpty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
const std::string load_pathPriorityFile = priorityFile.toStdString();
|
|
|
|
const std::string load_pathSecondaryFile = secondaryFile.toStdString();
|
|
|
|
const std::string save_path = saveFile.toStdString();
|
|
|
|
SignatureDB db(load_pathPriorityFile);
|
|
|
|
db.Load(load_pathPriorityFile);
|
|
|
|
db.Load(load_pathSecondaryFile);
|
|
|
|
if (!db.Save(save_path))
|
|
|
|
{
|
2019-03-04 19:49:00 +00:00
|
|
|
ModalMessageBox::warning(this, tr("Error"),
|
|
|
|
tr("Failed to save to signature file '%1'").arg(saveFile));
|
2018-10-09 00:59:55 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
db.List();
|
|
|
|
}
|
|
|
|
|
2018-02-14 22:25:01 +00:00
|
|
|
void MenuBar::PatchHLEFunctions()
|
|
|
|
{
|
|
|
|
HLE::PatchFunctions();
|
|
|
|
}
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
void MenuBar::ClearCache()
|
|
|
|
{
|
|
|
|
Core::RunAsCPUThread(JitInterface::ClearCache);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::LogInstructions()
|
|
|
|
{
|
|
|
|
PPCTables::LogCompiledInstructions();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MenuBar::SearchInstruction()
|
|
|
|
{
|
|
|
|
bool good;
|
2019-07-30 11:57:06 +00:00
|
|
|
const QString op = QInputDialog::getText(this, tr("Search instruction"), tr("Instruction:"),
|
|
|
|
QLineEdit::Normal, QString{}, &good);
|
2018-04-09 13:31:20 +00:00
|
|
|
|
|
|
|
if (!good)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bool found = false;
|
2020-04-28 17:10:50 +00:00
|
|
|
for (u32 addr = Memory::MEM1_BASE_ADDR; addr < Memory::MEM1_BASE_ADDR + Memory::GetRamSizeReal();
|
|
|
|
addr += 4)
|
2018-04-09 13:31:20 +00:00
|
|
|
{
|
|
|
|
auto ins_name =
|
|
|
|
QString::fromStdString(PPCTables::GetInstructionName(PowerPC::HostRead_U32(addr)));
|
|
|
|
if (op == ins_name)
|
|
|
|
{
|
|
|
|
NOTICE_LOG(POWERPC, "Found %s at %08x", op.toStdString().c_str(), addr);
|
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found)
|
|
|
|
NOTICE_LOG(POWERPC, "Opcode %s not found", op.toStdString().c_str());
|
|
|
|
}
|