chore: make yuzu REUSE compliant
[REUSE] is a specification that aims at making file copyright
information consistent, so that it can be both human and machine
readable. It basically requires that all files have a header containing
copyright and licensing information. When this isn't possible, like
when dealing with binary assets, generated files or embedded third-party
dependencies, it is permitted to insert copyright information in the
`.reuse/dep5` file.
Oh, and it also requires that all the licenses used in the project are
present in the `LICENSES` folder, that's why the diff is so huge.
This can be done automatically with `reuse download --all`.
The `reuse` tool also contains a handy subcommand that analyzes the
project and tells whether or not the project is (still) compliant,
`reuse lint`.
Following REUSE has a few advantages over the current approach:
- Copyright information is easy to access for users / downstream
- Files like `dist/license.md` do not need to exist anymore, as
`.reuse/dep5` is used instead
- `reuse lint` makes it easy to ensure that copyright information of
files like binary assets / images is always accurate and up to date
To add copyright information of files that didn't have it I looked up
who committed what and when, for each file. As yuzu contributors do not
have to sign a CLA or similar I couldn't assume that copyright ownership
was of the "yuzu Emulator Project", so I used the name and/or email of
the commit author instead.
[REUSE]: https://reuse.software
Follow-up to 01cf05bc75b1e47beb08937439f3ed9339e7b254
2022-05-15 00:06:02 +00:00
|
|
|
// SPDX-FileCopyrightText: 2014 Citra Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2015-01-04 17:36:57 +00:00
|
|
|
|
2016-12-15 09:56:32 +00:00
|
|
|
#include <cinttypes>
|
2016-03-06 13:04:47 +00:00
|
|
|
#include <clocale>
|
2022-04-18 21:21:02 +00:00
|
|
|
#include <cmath>
|
2021-07-29 03:02:29 +00:00
|
|
|
#include <fstream>
|
|
|
|
#include <iostream>
|
2016-04-05 12:29:55 +00:00
|
|
|
#include <memory>
|
2014-10-28 07:36:00 +00:00
|
|
|
#include <thread>
|
2019-08-13 19:42:22 +00:00
|
|
|
#ifdef __APPLE__
|
|
|
|
#include <unistd.h> // for chdir
|
|
|
|
#endif
|
2022-11-04 12:12:46 +00:00
|
|
|
#ifdef __unix__
|
2022-07-27 19:51:26 +00:00
|
|
|
#include <csignal>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#endif
|
2018-08-15 09:38:37 +00:00
|
|
|
|
2018-09-20 02:09:23 +00:00
|
|
|
// VFS includes must be before glad as they will conflict with Windows file api, which uses defines.
|
2022-11-13 21:14:08 +00:00
|
|
|
#include "applets/qt_amiibo_settings.h"
|
2021-07-14 04:29:12 +00:00
|
|
|
#include "applets/qt_controller.h"
|
|
|
|
#include "applets/qt_error.h"
|
|
|
|
#include "applets/qt_profile_select.h"
|
|
|
|
#include "applets/qt_software_keyboard.h"
|
|
|
|
#include "applets/qt_web_browser.h"
|
2021-01-20 23:09:57 +00:00
|
|
|
#include "common/nvidia_flags.h"
|
2019-03-06 18:31:23 +00:00
|
|
|
#include "configuration/configure_input.h"
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
#include "configuration/configure_per_game.h"
|
2021-06-19 19:38:49 +00:00
|
|
|
#include "configuration/configure_tas.h"
|
2023-05-01 03:28:31 +00:00
|
|
|
#include "core/file_sys/romfs_factory.h"
|
2018-09-20 02:09:23 +00:00
|
|
|
#include "core/file_sys/vfs.h"
|
|
|
|
#include "core/file_sys/vfs_real.h"
|
2022-11-13 17:07:48 +00:00
|
|
|
#include "core/frontend/applets/cabinet.h"
|
2020-08-21 11:39:24 +00:00
|
|
|
#include "core/frontend/applets/controller.h"
|
2019-03-11 23:39:48 +00:00
|
|
|
#include "core/frontend/applets/general_frontend.h"
|
2022-03-17 07:01:03 +00:00
|
|
|
#include "core/frontend/applets/mii_edit.h"
|
2020-08-21 11:39:24 +00:00
|
|
|
#include "core/frontend/applets/software_keyboard.h"
|
2021-11-01 20:17:53 +00:00
|
|
|
#include "core/hid/emulated_controller.h"
|
2021-09-21 00:44:34 +00:00
|
|
|
#include "core/hid/hid_core.h"
|
2018-10-11 01:49:20 +00:00
|
|
|
#include "core/hle/service/acc/profile_manager.h"
|
2019-09-22 02:46:53 +00:00
|
|
|
#include "core/hle/service/am/applet_ae.h"
|
|
|
|
#include "core/hle/service/am/applet_oe.h"
|
2018-11-10 01:38:11 +00:00
|
|
|
#include "core/hle/service/am/applets/applets.h"
|
2021-12-25 19:27:52 +00:00
|
|
|
#include "yuzu/multiplayer/state.h"
|
2021-11-15 23:57:41 +00:00
|
|
|
#include "yuzu/util/controller_navigation.h"
|
2018-09-20 02:09:23 +00:00
|
|
|
|
2018-11-13 14:06:41 +00:00
|
|
|
// These are wrappers to avoid the calls to CreateDirectory and CreateFile because of the Windows
|
2018-09-20 02:09:23 +00:00
|
|
|
// defines.
|
|
|
|
static FileSys::VirtualDir VfsFilesystemCreateDirectoryWrapper(
|
|
|
|
const FileSys::VirtualFilesystem& vfs, const std::string& path, FileSys::Mode mode) {
|
|
|
|
return vfs->CreateDirectory(path, mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::VirtualDir& dir,
|
|
|
|
const std::string& path) {
|
|
|
|
return dir->CreateFile(path);
|
|
|
|
}
|
|
|
|
|
2018-08-15 09:38:37 +00:00
|
|
|
#include <fmt/ostream.h>
|
2016-03-19 01:31:01 +00:00
|
|
|
#include <glad/glad.h>
|
2018-08-15 09:38:37 +00:00
|
|
|
|
2016-03-19 01:31:01 +00:00
|
|
|
#define QT_NO_OPENGL
|
2019-04-04 15:29:16 +00:00
|
|
|
#include <QClipboard>
|
|
|
|
#include <QDesktopServices>
|
2018-10-24 13:37:29 +00:00
|
|
|
#include <QFile>
|
2014-04-01 02:26:50 +00:00
|
|
|
#include <QFileDialog>
|
2019-04-04 15:29:16 +00:00
|
|
|
#include <QInputDialog>
|
2015-07-28 16:43:18 +00:00
|
|
|
#include <QMessageBox>
|
2019-04-04 15:29:16 +00:00
|
|
|
#include <QProgressBar>
|
|
|
|
#include <QProgressDialog>
|
2020-10-27 17:33:25 +00:00
|
|
|
#include <QPushButton>
|
2022-06-05 22:03:03 +00:00
|
|
|
#include <QScreen>
|
2019-04-04 15:29:16 +00:00
|
|
|
#include <QShortcut>
|
|
|
|
#include <QStatusBar>
|
2021-03-07 15:56:22 +00:00
|
|
|
#include <QString>
|
2019-09-21 12:24:16 +00:00
|
|
|
#include <QSysInfo>
|
2020-06-21 04:09:28 +00:00
|
|
|
#include <QUrl>
|
2018-09-24 01:06:33 +00:00
|
|
|
#include <QtConcurrent/QtConcurrent>
|
2019-04-04 15:29:16 +00:00
|
|
|
|
2021-10-30 05:21:26 +00:00
|
|
|
#ifdef HAVE_SDL2
|
|
|
|
#include <SDL.h> // For SDL ScreenSaver functions
|
|
|
|
#endif
|
|
|
|
|
2018-08-29 13:42:53 +00:00
|
|
|
#include <fmt/format.h>
|
2018-09-16 18:05:51 +00:00
|
|
|
#include "common/detached_tasks.h"
|
2021-05-25 23:32:56 +00:00
|
|
|
#include "common/fs/fs.h"
|
|
|
|
#include "common/fs/path_util.h"
|
2021-12-15 07:49:25 +00:00
|
|
|
#include "common/literals.h"
|
2016-09-18 00:38:01 +00:00
|
|
|
#include "common/logging/backend.h"
|
|
|
|
#include "common/logging/log.h"
|
2020-05-17 18:45:12 +00:00
|
|
|
#include "common/memory_detect.h"
|
2015-08-17 21:25:21 +00:00
|
|
|
#include "common/microprofile.h"
|
2015-06-21 13:58:59 +00:00
|
|
|
#include "common/scm_rev.h"
|
2014-10-28 07:36:00 +00:00
|
|
|
#include "common/scope_exit.h"
|
2023-03-02 01:07:59 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
#include "common/windows/timer_resolution.h"
|
|
|
|
#endif
|
2019-09-21 12:24:16 +00:00
|
|
|
#ifdef ARCHITECTURE_x86_64
|
|
|
|
#include "common/x64/cpu_detect.h"
|
|
|
|
#endif
|
2021-04-14 23:07:40 +00:00
|
|
|
#include "common/settings.h"
|
2018-08-31 16:21:34 +00:00
|
|
|
#include "common/telemetry.h"
|
2016-09-18 00:38:01 +00:00
|
|
|
#include "core/core.h"
|
2023-07-02 19:05:35 +00:00
|
|
|
#include "core/core_timing.h"
|
2018-07-29 01:39:42 +00:00
|
|
|
#include "core/crypto/key_manager.h"
|
2018-08-10 01:33:13 +00:00
|
|
|
#include "core/file_sys/card_image.h"
|
2020-12-04 06:41:21 +00:00
|
|
|
#include "core/file_sys/common_funcs.h"
|
2018-09-04 01:58:19 +00:00
|
|
|
#include "core/file_sys/content_archive.h"
|
2018-09-04 21:01:40 +00:00
|
|
|
#include "core/file_sys/control_metadata.h"
|
|
|
|
#include "core/file_sys/patch_manager.h"
|
2018-08-21 00:36:36 +00:00
|
|
|
#include "core/file_sys/registered_cache.h"
|
2018-09-20 02:09:23 +00:00
|
|
|
#include "core/file_sys/romfs.h"
|
2018-08-21 04:46:40 +00:00
|
|
|
#include "core/file_sys/savedata_factory.h"
|
2018-09-04 18:44:40 +00:00
|
|
|
#include "core/file_sys/submission_package.h"
|
2021-04-24 05:04:28 +00:00
|
|
|
#include "core/hle/kernel/k_process.h"
|
2019-09-22 02:46:53 +00:00
|
|
|
#include "core/hle/service/am/am.h"
|
2018-08-31 16:21:34 +00:00
|
|
|
#include "core/hle/service/filesystem/filesystem.h"
|
2018-10-23 23:28:17 +00:00
|
|
|
#include "core/hle/service/sm/sm.h"
|
2015-09-11 04:23:00 +00:00
|
|
|
#include "core/loader/loader.h"
|
2018-08-31 16:21:34 +00:00
|
|
|
#include "core/perf_stats.h"
|
|
|
|
#include "core/telemetry_session.h"
|
2021-09-21 00:39:08 +00:00
|
|
|
#include "input_common/drivers/tas_input.h"
|
2022-09-25 01:31:54 +00:00
|
|
|
#include "input_common/drivers/virtual_amiibo.h"
|
2020-08-27 19:16:47 +00:00
|
|
|
#include "input_common/main.h"
|
2021-10-15 19:27:18 +00:00
|
|
|
#include "ui_main.h"
|
2021-03-20 11:57:31 +00:00
|
|
|
#include "util/overlay_dialog.h"
|
2020-07-10 03:36:38 +00:00
|
|
|
#include "video_core/gpu.h"
|
2021-06-20 21:26:55 +00:00
|
|
|
#include "video_core/renderer_base.h"
|
2020-07-10 03:36:38 +00:00
|
|
|
#include "video_core/shader_notify.h"
|
2018-01-14 18:15:45 +00:00
|
|
|
#include "yuzu/about_dialog.h"
|
2018-01-12 03:33:56 +00:00
|
|
|
#include "yuzu/bootmanager.h"
|
2018-09-16 18:05:51 +00:00
|
|
|
#include "yuzu/compatdb.h"
|
2018-09-09 23:09:37 +00:00
|
|
|
#include "yuzu/compatibility_list.h"
|
2018-01-12 03:33:56 +00:00
|
|
|
#include "yuzu/configuration/config.h"
|
|
|
|
#include "yuzu/configuration/configure_dialog.h"
|
2022-11-18 00:23:48 +00:00
|
|
|
#include "yuzu/configuration/configure_input_per_game.h"
|
2018-07-02 17:10:41 +00:00
|
|
|
#include "yuzu/debugger/console.h"
|
2021-01-22 00:51:24 +00:00
|
|
|
#include "yuzu/debugger/controller.h"
|
2018-01-12 03:33:56 +00:00
|
|
|
#include "yuzu/debugger/profiler.h"
|
|
|
|
#include "yuzu/debugger/wait_tree.h"
|
2018-09-16 18:05:51 +00:00
|
|
|
#include "yuzu/discord.h"
|
2018-01-12 03:33:56 +00:00
|
|
|
#include "yuzu/game_list.h"
|
2018-08-31 16:21:34 +00:00
|
|
|
#include "yuzu/game_list_p.h"
|
2018-01-12 03:33:56 +00:00
|
|
|
#include "yuzu/hotkeys.h"
|
2020-04-17 03:27:38 +00:00
|
|
|
#include "yuzu/install_dialog.h"
|
2019-01-17 07:01:00 +00:00
|
|
|
#include "yuzu/loading_screen.h"
|
2018-01-12 03:33:56 +00:00
|
|
|
#include "yuzu/main.h"
|
2022-07-10 15:46:53 +00:00
|
|
|
#include "yuzu/startup_checks.h"
|
2019-07-29 20:06:33 +00:00
|
|
|
#include "yuzu/uisettings.h"
|
2021-12-25 19:27:52 +00:00
|
|
|
#include "yuzu/util/clickable_label.h"
|
2023-05-28 21:46:02 +00:00
|
|
|
#include "yuzu/vk_device_info.h"
|
2015-05-19 04:21:33 +00:00
|
|
|
|
2022-07-10 15:29:10 +00:00
|
|
|
#ifdef YUZU_DBGHELP
|
|
|
|
#include "yuzu/mini_dump.h"
|
|
|
|
#endif
|
|
|
|
|
2021-12-15 07:49:25 +00:00
|
|
|
using namespace Common::Literals;
|
|
|
|
|
2018-09-16 18:05:51 +00:00
|
|
|
#ifdef USE_DISCORD_PRESENCE
|
|
|
|
#include "yuzu/discord_impl.h"
|
|
|
|
#endif
|
|
|
|
|
2016-08-01 21:13:35 +00:00
|
|
|
#ifdef QT_STATICPLUGIN
|
|
|
|
Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin);
|
|
|
|
#endif
|
|
|
|
|
2018-04-19 18:22:26 +00:00
|
|
|
#ifdef _WIN32
|
2019-09-03 21:00:34 +00:00
|
|
|
#include <windows.h>
|
2018-04-19 18:22:26 +00:00
|
|
|
extern "C" {
|
|
|
|
// tells Nvidia and AMD drivers to use the dedicated GPU by default on laptops with switchable
|
|
|
|
// graphics
|
|
|
|
__declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001;
|
|
|
|
__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2022-04-19 20:22:51 +00:00
|
|
|
constexpr int default_mouse_hide_timeout = 2500;
|
|
|
|
constexpr int default_mouse_center_timeout = 10;
|
2022-11-27 01:08:44 +00:00
|
|
|
constexpr int default_input_update_timeout = 1;
|
2020-04-11 02:22:50 +00:00
|
|
|
|
2017-08-09 00:06:25 +00:00
|
|
|
/**
|
|
|
|
* "Callouts" are one-time instructional messages shown to the user. In the config settings, there
|
|
|
|
* is a bitfield "callout_flags" options, used to track if a message has already been shown to the
|
2021-01-02 14:00:05 +00:00
|
|
|
* user. This is 32-bits - if we have more than 32 callouts, we should retire and recycle old ones.
|
2017-08-09 00:06:25 +00:00
|
|
|
*/
|
|
|
|
enum class CalloutFlag : uint32_t {
|
|
|
|
Telemetry = 0x1,
|
2018-09-04 18:44:40 +00:00
|
|
|
DRDDeprecation = 0x2,
|
2017-08-09 00:06:25 +00:00
|
|
|
};
|
|
|
|
|
2018-09-16 18:05:51 +00:00
|
|
|
void GMainWindow::ShowTelemetryCallout() {
|
2021-06-28 21:32:24 +00:00
|
|
|
if (UISettings::values.callout_flags.GetValue() &
|
|
|
|
static_cast<uint32_t>(CalloutFlag::Telemetry)) {
|
2017-08-09 00:06:25 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-06-28 21:32:24 +00:00
|
|
|
UISettings::values.callout_flags =
|
|
|
|
UISettings::values.callout_flags.GetValue() | static_cast<uint32_t>(CalloutFlag::Telemetry);
|
2018-09-17 15:16:01 +00:00
|
|
|
const QString telemetry_message =
|
2018-10-06 07:15:27 +00:00
|
|
|
tr("<a href='https://yuzu-emu.org/help/feature/telemetry/'>Anonymous "
|
2018-09-16 18:05:51 +00:00
|
|
|
"data is collected</a> to help improve yuzu. "
|
|
|
|
"<br/><br/>Would you like to share your usage data with us?");
|
|
|
|
if (QMessageBox::question(this, tr("Telemetry"), telemetry_message) != QMessageBox::Yes) {
|
|
|
|
Settings::values.enable_telemetry = false;
|
2021-10-14 18:32:19 +00:00
|
|
|
system->ApplySettings();
|
2018-09-16 18:05:51 +00:00
|
|
|
}
|
2017-08-09 00:06:25 +00:00
|
|
|
}
|
|
|
|
|
2018-08-09 01:44:59 +00:00
|
|
|
const int GMainWindow::max_recent_files_item;
|
|
|
|
|
2020-11-30 13:31:26 +00:00
|
|
|
static void RemoveCachedContents() {
|
2021-05-25 23:32:56 +00:00
|
|
|
const auto cache_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir);
|
|
|
|
const auto offline_fonts = cache_dir / "fonts";
|
|
|
|
const auto offline_manual = cache_dir / "offline_web_applet_manual";
|
|
|
|
const auto offline_legal_information = cache_dir / "offline_web_applet_legal_information";
|
|
|
|
const auto offline_system_data = cache_dir / "offline_web_applet_system_data";
|
|
|
|
|
2021-06-19 07:43:16 +00:00
|
|
|
Common::FS::RemoveDirRecursively(offline_fonts);
|
|
|
|
Common::FS::RemoveDirRecursively(offline_manual);
|
|
|
|
Common::FS::RemoveDirRecursively(offline_legal_information);
|
|
|
|
Common::FS::RemoveDirRecursively(offline_system_data);
|
2020-11-30 13:31:26 +00:00
|
|
|
}
|
|
|
|
|
2022-06-11 03:37:47 +00:00
|
|
|
static void LogRuntimes() {
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
// It is possible that the name of the dll will change.
|
|
|
|
// vcruntime140.dll is for 2015 and onwards
|
2023-02-14 16:13:47 +00:00
|
|
|
static constexpr char runtime_dll_name[] = "vcruntime140.dll";
|
2022-06-11 03:37:47 +00:00
|
|
|
UINT sz = GetFileVersionInfoSizeA(runtime_dll_name, nullptr);
|
|
|
|
bool runtime_version_inspection_worked = false;
|
|
|
|
if (sz > 0) {
|
|
|
|
std::vector<u8> buf(sz);
|
|
|
|
if (GetFileVersionInfoA(runtime_dll_name, 0, sz, buf.data())) {
|
|
|
|
VS_FIXEDFILEINFO* pvi;
|
|
|
|
sz = sizeof(VS_FIXEDFILEINFO);
|
|
|
|
if (VerQueryValueA(buf.data(), "\\", reinterpret_cast<LPVOID*>(&pvi), &sz)) {
|
|
|
|
if (pvi->dwSignature == VS_FFI_SIGNATURE) {
|
|
|
|
runtime_version_inspection_worked = true;
|
|
|
|
LOG_INFO(Frontend, "MSVC Compiler: {} Runtime: {}.{}.{}.{}", _MSC_VER,
|
|
|
|
pvi->dwProductVersionMS >> 16, pvi->dwProductVersionMS & 0xFFFF,
|
|
|
|
pvi->dwProductVersionLS >> 16, pvi->dwProductVersionLS & 0xFFFF);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!runtime_version_inspection_worked) {
|
|
|
|
LOG_INFO(Frontend, "Unable to inspect {}", runtime_dll_name);
|
|
|
|
}
|
|
|
|
#endif
|
2022-09-02 02:27:33 +00:00
|
|
|
LOG_INFO(Frontend, "Qt Compile: {} Runtime: {}", QT_VERSION_STR, qVersion());
|
2022-06-11 03:37:47 +00:00
|
|
|
}
|
|
|
|
|
2022-05-21 02:39:12 +00:00
|
|
|
static QString PrettyProductName() {
|
|
|
|
#ifdef _WIN32
|
|
|
|
// After Windows 10 Version 2004, Microsoft decided to switch to a different notation: 20H2
|
|
|
|
// With that notation change they changed the registry key used to denote the current version
|
|
|
|
QSettings windows_registry(
|
|
|
|
QStringLiteral("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"),
|
|
|
|
QSettings::NativeFormat);
|
|
|
|
const QString release_id = windows_registry.value(QStringLiteral("ReleaseId")).toString();
|
|
|
|
if (release_id == QStringLiteral("2009")) {
|
|
|
|
const u32 current_build = windows_registry.value(QStringLiteral("CurrentBuild")).toUInt();
|
|
|
|
const QString display_version =
|
|
|
|
windows_registry.value(QStringLiteral("DisplayVersion")).toString();
|
|
|
|
const u32 ubr = windows_registry.value(QStringLiteral("UBR")).toUInt();
|
|
|
|
u32 version = 10;
|
|
|
|
if (current_build >= 22000) {
|
|
|
|
version = 11;
|
|
|
|
}
|
|
|
|
return QStringLiteral("Windows %1 Version %2 (Build %3.%4)")
|
|
|
|
.arg(QString::number(version), display_version, QString::number(current_build),
|
|
|
|
QString::number(ubr));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return QSysInfo::prettyProductName();
|
|
|
|
}
|
|
|
|
|
Qt: work around Qt5's font choice for Chinese
On Windows there are currently two fonts used.
The first, does the Menu, QTreeView and Tooltips
Second is Everything else which is a default font.
From inspecting QApplication::font() at runtime
Windows 10 English: QFont(MS Shell Dlg 2,8.25,-1,5,50,0,0,0,0,0)
Windows 11 Japanese: MS UI Gothic,9 ,-1,5,50,0,0,0,0,0
Windows 11 Traditional Chinese: PMingLiU,9 ,-1,5,50,0,0,0,0,0
Windows 11 Simplified Chinese: SimSun,9 ,-1,5,50,0,0,0,0,0
Windows 11 Korean: Gulim,9 ,-1,5,50,0,0,0,0,0
I initially investigated dynamically changing the font when
the UI language is English, but this was getting quite messy
Qt6 makes changes to default font in some situations, so this
PR is being narrowed in scope to only effect Chinese font choices.
This change only effects rendering of Latin/Cyrillic characters.
2022-10-01 22:27:23 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
static void OverrideWindowsFont() {
|
2023-03-12 03:10:38 +00:00
|
|
|
// Qt5 chooses these fonts on Windows and they have fairly ugly alphanumeric/cyrillic characters
|
Qt: work around Qt5's font choice for Chinese
On Windows there are currently two fonts used.
The first, does the Menu, QTreeView and Tooltips
Second is Everything else which is a default font.
From inspecting QApplication::font() at runtime
Windows 10 English: QFont(MS Shell Dlg 2,8.25,-1,5,50,0,0,0,0,0)
Windows 11 Japanese: MS UI Gothic,9 ,-1,5,50,0,0,0,0,0
Windows 11 Traditional Chinese: PMingLiU,9 ,-1,5,50,0,0,0,0,0
Windows 11 Simplified Chinese: SimSun,9 ,-1,5,50,0,0,0,0,0
Windows 11 Korean: Gulim,9 ,-1,5,50,0,0,0,0,0
I initially investigated dynamically changing the font when
the UI language is English, but this was getting quite messy
Qt6 makes changes to default font in some situations, so this
PR is being narrowed in scope to only effect Chinese font choices.
This change only effects rendering of Latin/Cyrillic characters.
2022-10-01 22:27:23 +00:00
|
|
|
// Asking to use "MS Shell Dlg 2" gives better other chars while leaving the Chinese Characters.
|
|
|
|
const QString startup_font = QApplication::font().family();
|
|
|
|
const QStringList ugly_fonts = {QStringLiteral("SimSun"), QStringLiteral("PMingLiU")};
|
|
|
|
if (ugly_fonts.contains(startup_font)) {
|
|
|
|
QApplication::setFont(QFont(QStringLiteral("MS Shell Dlg 2"), 9, QFont::Normal));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2022-08-12 13:10:18 +00:00
|
|
|
bool GMainWindow::CheckDarkMode() {
|
2022-11-04 12:12:46 +00:00
|
|
|
#ifdef __unix__
|
2022-07-28 14:50:20 +00:00
|
|
|
const QPalette test_palette(qApp->palette());
|
|
|
|
const QColor text_color = test_palette.color(QPalette::Active, QPalette::Text);
|
|
|
|
const QColor window_color = test_palette.color(QPalette::Active, QPalette::Window);
|
|
|
|
return (text_color.value() > window_color.value());
|
|
|
|
#else
|
|
|
|
// TODO: Windows
|
|
|
|
return false;
|
2022-11-04 12:12:46 +00:00
|
|
|
#endif // __unix__
|
2022-07-28 14:50:20 +00:00
|
|
|
}
|
|
|
|
|
2022-07-10 15:29:10 +00:00
|
|
|
GMainWindow::GMainWindow(std::unique_ptr<Config> config_, bool has_broken_vulkan)
|
2021-10-15 23:36:52 +00:00
|
|
|
: ui{std::make_unique<Ui::MainWindow>()}, system{std::make_unique<Core::System>()},
|
2022-07-10 15:29:10 +00:00
|
|
|
input_subsystem{std::make_shared<InputCommon::InputSubsystem>()}, config{std::move(config_)},
|
2021-09-03 01:40:55 +00:00
|
|
|
vfs{std::make_shared<FileSys::RealVfsFilesystem>()},
|
2020-08-27 19:16:47 +00:00
|
|
|
provider{std::make_unique<FileSys::ManualContentProvider>()} {
|
2022-11-04 12:12:46 +00:00
|
|
|
#ifdef __unix__
|
2022-07-27 19:51:26 +00:00
|
|
|
SetupSigInterrupts();
|
|
|
|
#endif
|
2022-09-10 08:48:15 +00:00
|
|
|
system->Initialize();
|
2022-07-27 19:51:26 +00:00
|
|
|
|
2021-08-24 05:32:38 +00:00
|
|
|
Common::Log::Initialize();
|
2023-03-27 18:18:26 +00:00
|
|
|
Common::Log::Start();
|
|
|
|
|
2020-01-25 23:26:07 +00:00
|
|
|
LoadTranslation();
|
|
|
|
|
2017-02-16 03:23:30 +00:00
|
|
|
setAcceptDrops(true);
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->setupUi(this);
|
2014-04-01 02:26:50 +00:00
|
|
|
statusBar()->hide();
|
|
|
|
|
2022-07-28 14:50:20 +00:00
|
|
|
// Check dark mode before a theme is loaded
|
2022-08-12 13:10:18 +00:00
|
|
|
os_dark_mode = CheckDarkMode();
|
2022-07-28 14:50:20 +00:00
|
|
|
startup_icon_theme = QIcon::themeName();
|
|
|
|
// fallback can only be set once, colorful theme icons are okay on both light/dark
|
|
|
|
QIcon::setFallbackThemeName(QStringLiteral("colorful"));
|
|
|
|
QIcon::setFallbackSearchPaths(QStringList(QStringLiteral(":/icons")));
|
|
|
|
|
2018-03-30 15:38:34 +00:00
|
|
|
default_theme_paths = QIcon::themeSearchPaths();
|
|
|
|
UpdateUITheme();
|
|
|
|
|
2021-06-28 21:32:24 +00:00
|
|
|
SetDiscordEnabled(UISettings::values.enable_discord_presence.GetValue());
|
2018-09-16 18:05:51 +00:00
|
|
|
discord_rpc->Update();
|
|
|
|
|
2022-07-22 14:31:13 +00:00
|
|
|
system->GetRoomNetwork().Init();
|
2021-12-25 19:27:52 +00:00
|
|
|
|
2021-03-26 09:26:16 +00:00
|
|
|
RegisterMetaTypes();
|
|
|
|
|
2016-12-19 19:50:58 +00:00
|
|
|
InitializeWidgets();
|
2017-02-18 10:16:24 +00:00
|
|
|
InitializeDebugWidgets();
|
2016-12-19 19:50:58 +00:00
|
|
|
InitializeRecentFileMenuActions();
|
|
|
|
InitializeHotkeys();
|
|
|
|
|
|
|
|
SetDefaultUIGeometry();
|
|
|
|
RestoreUIState();
|
|
|
|
|
2017-02-18 10:26:57 +00:00
|
|
|
ConnectMenuEvents();
|
2016-12-19 19:50:58 +00:00
|
|
|
ConnectWidgetEvents();
|
2019-05-09 05:41:33 +00:00
|
|
|
|
2021-10-16 00:07:47 +00:00
|
|
|
system->HIDCore().ReloadInputDevices();
|
2021-11-04 19:08:30 +00:00
|
|
|
controller_dialog->refreshConfiguration();
|
2021-09-21 00:44:34 +00:00
|
|
|
|
2021-05-17 02:17:17 +00:00
|
|
|
const auto branch_name = std::string(Common::g_scm_branch);
|
|
|
|
const auto description = std::string(Common::g_scm_desc);
|
2020-04-07 20:41:45 +00:00
|
|
|
const auto build_id = std::string(Common::g_build_id);
|
|
|
|
|
2021-05-17 02:17:17 +00:00
|
|
|
const auto yuzu_build = fmt::format("yuzu Development Build | {}-{}", branch_name, description);
|
2021-06-23 13:59:56 +00:00
|
|
|
const auto override_build =
|
|
|
|
fmt::format(fmt::runtime(std::string(Common::g_title_bar_format_idle)), build_id);
|
2021-05-17 02:17:17 +00:00
|
|
|
const auto yuzu_build_version = override_build.empty() ? yuzu_build : override_build;
|
2022-11-10 18:46:08 +00:00
|
|
|
const auto processor_count = std::thread::hardware_concurrency();
|
2021-05-17 02:17:17 +00:00
|
|
|
|
|
|
|
LOG_INFO(Frontend, "yuzu Version: {}", yuzu_build_version);
|
2022-06-11 03:37:47 +00:00
|
|
|
LogRuntimes();
|
2019-09-21 12:24:16 +00:00
|
|
|
#ifdef ARCHITECTURE_x86_64
|
2020-05-16 11:35:15 +00:00
|
|
|
const auto& caps = Common::GetCPUCaps();
|
|
|
|
std::string cpu_string = caps.cpu_string;
|
2022-03-10 02:11:46 +00:00
|
|
|
if (caps.avx || caps.avx2 || caps.avx512f) {
|
2020-05-16 11:35:15 +00:00
|
|
|
cpu_string += " | AVX";
|
2022-03-10 02:11:46 +00:00
|
|
|
if (caps.avx512f) {
|
2020-05-16 11:35:15 +00:00
|
|
|
cpu_string += "512";
|
|
|
|
} else if (caps.avx2) {
|
|
|
|
cpu_string += '2';
|
|
|
|
}
|
|
|
|
if (caps.fma || caps.fma4) {
|
|
|
|
cpu_string += " | FMA";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
LOG_INFO(Frontend, "Host CPU: {}", cpu_string);
|
2022-11-11 08:36:47 +00:00
|
|
|
if (std::optional<int> processor_core = Common::GetProcessorCount()) {
|
|
|
|
LOG_INFO(Frontend, "Host CPU Cores: {}", *processor_core);
|
|
|
|
}
|
2022-11-12 18:31:54 +00:00
|
|
|
#endif
|
2022-11-10 21:36:39 +00:00
|
|
|
LOG_INFO(Frontend, "Host CPU Threads: {}", processor_count);
|
2022-05-21 02:39:12 +00:00
|
|
|
LOG_INFO(Frontend, "Host OS: {}", PrettyProductName().toStdString());
|
2021-12-15 07:49:25 +00:00
|
|
|
LOG_INFO(Frontend, "Host RAM: {:.2f} GiB",
|
|
|
|
Common::GetMemInfo().TotalPhysicalMemory / f64{1_GiB});
|
|
|
|
LOG_INFO(Frontend, "Host Swap: {:.2f} GiB", Common::GetMemInfo().TotalSwapMemory / f64{1_GiB});
|
2023-03-02 01:07:59 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
LOG_INFO(Frontend, "Host Timer Resolution: {:.4f} ms",
|
|
|
|
std::chrono::duration_cast<std::chrono::duration<f64, std::milli>>(
|
|
|
|
Common::Windows::SetCurrentTimerResolutionToMaximum())
|
|
|
|
.count());
|
2023-07-02 19:05:35 +00:00
|
|
|
system->CoreTiming().SetTimerResolutionNs(Common::Windows::GetCurrentTimerResolution());
|
2023-03-02 01:07:59 +00:00
|
|
|
#endif
|
2019-05-09 05:41:33 +00:00
|
|
|
UpdateWindowTitle();
|
2016-12-19 19:50:58 +00:00
|
|
|
|
|
|
|
show();
|
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
system->SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
|
|
|
|
system->RegisterContentProvider(FileSys::ContentProviderUnionSlot::FrontendManual,
|
|
|
|
provider.get());
|
|
|
|
system->GetFileSystemController().CreateFactories(*vfs);
|
2019-03-04 17:40:53 +00:00
|
|
|
|
2020-11-30 13:31:26 +00:00
|
|
|
// Remove cached contents generated during the previous session
|
|
|
|
RemoveCachedContents();
|
|
|
|
|
2018-09-24 01:06:33 +00:00
|
|
|
// Gen keys if necessary
|
2018-09-29 15:48:51 +00:00
|
|
|
OnReinitializeKeys(ReinitializeKeyBehavior::NoWarning);
|
2018-09-24 01:06:33 +00:00
|
|
|
|
2018-08-29 13:42:53 +00:00
|
|
|
game_list->LoadCompatibilityList();
|
2019-05-01 21:21:04 +00:00
|
|
|
game_list->PopulateAsync(UISettings::values.game_dirs);
|
2016-12-19 19:50:58 +00:00
|
|
|
|
2017-08-09 00:06:25 +00:00
|
|
|
// Show one-time "callout" messages to the user
|
2018-09-16 18:05:51 +00:00
|
|
|
ShowTelemetryCallout();
|
2017-08-09 00:06:25 +00:00
|
|
|
|
2020-04-11 02:22:50 +00:00
|
|
|
// make sure menubar has the arrow cursor instead of inheriting from this
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->menubar->setCursor(QCursor());
|
2020-04-11 02:22:50 +00:00
|
|
|
statusBar()->setCursor(QCursor());
|
|
|
|
|
2022-04-19 20:22:51 +00:00
|
|
|
mouse_hide_timer.setInterval(default_mouse_hide_timeout);
|
2020-04-11 02:22:50 +00:00
|
|
|
connect(&mouse_hide_timer, &QTimer::timeout, this, &GMainWindow::HideMouseCursor);
|
2021-10-15 19:27:18 +00:00
|
|
|
connect(ui->menubar, &QMenuBar::hovered, this, &GMainWindow::ShowMouseCursor);
|
2020-04-11 02:22:50 +00:00
|
|
|
|
2022-04-19 20:22:51 +00:00
|
|
|
mouse_center_timer.setInterval(default_mouse_center_timeout);
|
|
|
|
connect(&mouse_center_timer, &QTimer::timeout, this, &GMainWindow::CenterMouseCursor);
|
|
|
|
|
2022-11-27 01:08:44 +00:00
|
|
|
update_input_timer.setInterval(default_input_update_timeout);
|
|
|
|
connect(&update_input_timer, &QTimer::timeout, this, &GMainWindow::UpdateInputDrivers);
|
|
|
|
update_input_timer.start();
|
|
|
|
|
2020-12-25 20:17:49 +00:00
|
|
|
MigrateConfigFiles();
|
|
|
|
|
2022-07-10 20:10:35 +00:00
|
|
|
if (has_broken_vulkan) {
|
|
|
|
UISettings::values.has_broken_vulkan = true;
|
|
|
|
|
|
|
|
QMessageBox::warning(this, tr("Broken Vulkan Installation Detected"),
|
|
|
|
tr("Vulkan initialization failed during boot.<br><br>Click <a "
|
|
|
|
"href='https://yuzu-emu.org/wiki/faq/"
|
|
|
|
"#yuzu-starts-with-the-error-broken-vulkan-installation-detected'>"
|
|
|
|
"here for instructions to fix the issue</a>."));
|
2022-05-30 03:38:51 +00:00
|
|
|
|
2022-05-28 06:33:23 +00:00
|
|
|
Settings::values.renderer_backend = Settings::RendererBackend::OpenGL;
|
|
|
|
|
|
|
|
renderer_status_button->setDisabled(true);
|
|
|
|
renderer_status_button->setChecked(false);
|
2023-05-28 21:46:02 +00:00
|
|
|
} else {
|
|
|
|
VkDeviceInfo::PopulateRecords(vk_device_records, this->window()->windowHandle());
|
2022-05-28 06:33:23 +00:00
|
|
|
}
|
|
|
|
|
2021-10-30 05:21:26 +00:00
|
|
|
#if defined(HAVE_SDL2) && !defined(_WIN32)
|
|
|
|
SDL_InitSubSystem(SDL_INIT_VIDEO);
|
2023-06-09 04:42:23 +00:00
|
|
|
|
|
|
|
// Set a screensaver inhibition reason string. Currently passed to DBus by SDL and visible to
|
|
|
|
// the user through their desktop environment.
|
|
|
|
//: TRANSLATORS: This string is shown to the user to explain why yuzu needs to prevent the
|
|
|
|
//: computer from sleeping
|
|
|
|
QByteArray wakelock_reason = tr("Running a game").toLatin1();
|
|
|
|
SDL_SetHint(SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME, wakelock_reason.data());
|
|
|
|
|
2021-10-30 05:21:26 +00:00
|
|
|
// SDL disables the screen saver by default, and setting the hint
|
|
|
|
// SDL_HINT_VIDEO_ALLOW_SCREENSAVER doesn't seem to work, so we just enable the screen saver
|
|
|
|
// for now.
|
|
|
|
SDL_EnableScreenSaver();
|
|
|
|
#endif
|
|
|
|
|
2022-07-27 23:46:03 +00:00
|
|
|
SetupPrepareForSleep();
|
|
|
|
|
2016-12-19 19:50:58 +00:00
|
|
|
QStringList args = QApplication::arguments();
|
2020-12-25 20:17:49 +00:00
|
|
|
|
|
|
|
if (args.size() < 2) {
|
|
|
|
return;
|
2016-12-19 19:50:58 +00:00
|
|
|
}
|
2020-09-27 18:20:22 +00:00
|
|
|
|
2020-12-25 20:17:49 +00:00
|
|
|
QString game_path;
|
2022-03-29 00:52:27 +00:00
|
|
|
bool has_gamepath = false;
|
|
|
|
bool is_fullscreen = false;
|
2020-12-25 20:17:49 +00:00
|
|
|
|
|
|
|
for (int i = 1; i < args.size(); ++i) {
|
|
|
|
// Preserves drag/drop functionality
|
|
|
|
if (args.size() == 2 && !args[1].startsWith(QChar::fromLatin1('-'))) {
|
|
|
|
game_path = args[1];
|
2022-03-29 00:52:27 +00:00
|
|
|
has_gamepath = true;
|
2020-12-25 20:17:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Launch game in fullscreen mode
|
|
|
|
if (args[i] == QStringLiteral("-f")) {
|
2022-03-29 00:52:27 +00:00
|
|
|
is_fullscreen = true;
|
2020-12-25 20:17:49 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2021-03-27 17:34:48 +00:00
|
|
|
// Launch game with a specific user
|
|
|
|
if (args[i] == QStringLiteral("-u")) {
|
|
|
|
if (i >= args.size() - 1) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (args[i + 1].startsWith(QChar::fromLatin1('-'))) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool argument_ok;
|
|
|
|
const std::size_t selected_user = args[++i].toUInt(&argument_ok);
|
|
|
|
|
|
|
|
if (!argument_ok) {
|
|
|
|
LOG_ERROR(Frontend, "Invalid user argument");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Service::Account::ProfileManager manager;
|
|
|
|
if (!manager.UserExistsIndex(selected_user)) {
|
|
|
|
LOG_ERROR(Frontend, "Selected user doesn't exist");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2021-04-28 16:22:41 +00:00
|
|
|
Settings::values.current_user = static_cast<s32>(selected_user);
|
2021-03-27 17:34:48 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2020-12-25 20:17:49 +00:00
|
|
|
// Launch game at path
|
|
|
|
if (args[i] == QStringLiteral("-g")) {
|
|
|
|
if (i >= args.size() - 1) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (args[i + 1].startsWith(QChar::fromLatin1('-'))) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
game_path = args[++i];
|
2022-03-29 00:52:27 +00:00
|
|
|
has_gamepath = true;
|
2020-12-25 20:17:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-29 00:52:27 +00:00
|
|
|
// Override fullscreen setting if gamepath or argument is provided
|
|
|
|
if (has_gamepath || is_fullscreen) {
|
|
|
|
ui->action_Fullscreen->setChecked(is_fullscreen);
|
|
|
|
}
|
|
|
|
|
2020-12-25 20:17:49 +00:00
|
|
|
if (!game_path.isEmpty()) {
|
|
|
|
BootGame(game_path);
|
|
|
|
}
|
2016-12-19 19:50:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GMainWindow::~GMainWindow() {
|
|
|
|
// will get automatically deleted otherwise
|
2021-10-30 05:21:26 +00:00
|
|
|
if (render_window->parent() == nullptr) {
|
2016-12-19 19:50:58 +00:00
|
|
|
delete render_window;
|
2021-10-30 05:21:26 +00:00
|
|
|
}
|
2022-07-27 19:51:26 +00:00
|
|
|
|
2022-11-04 12:12:46 +00:00
|
|
|
#ifdef __unix__
|
2022-07-27 19:51:26 +00:00
|
|
|
::close(sig_interrupt_fds[0]);
|
|
|
|
::close(sig_interrupt_fds[1]);
|
|
|
|
#endif
|
2016-12-19 19:50:58 +00:00
|
|
|
}
|
|
|
|
|
2021-03-26 09:26:16 +00:00
|
|
|
void GMainWindow::RegisterMetaTypes() {
|
|
|
|
// Register integral and floating point types
|
|
|
|
qRegisterMetaType<u8>("u8");
|
|
|
|
qRegisterMetaType<u16>("u16");
|
|
|
|
qRegisterMetaType<u32>("u32");
|
|
|
|
qRegisterMetaType<u64>("u64");
|
|
|
|
qRegisterMetaType<u128>("u128");
|
|
|
|
qRegisterMetaType<s8>("s8");
|
|
|
|
qRegisterMetaType<s16>("s16");
|
|
|
|
qRegisterMetaType<s32>("s32");
|
|
|
|
qRegisterMetaType<s64>("s64");
|
|
|
|
qRegisterMetaType<f32>("f32");
|
|
|
|
qRegisterMetaType<f64>("f64");
|
|
|
|
|
|
|
|
// Register string types
|
|
|
|
qRegisterMetaType<std::string>("std::string");
|
|
|
|
qRegisterMetaType<std::wstring>("std::wstring");
|
|
|
|
qRegisterMetaType<std::u8string>("std::u8string");
|
|
|
|
qRegisterMetaType<std::u16string>("std::u16string");
|
|
|
|
qRegisterMetaType<std::u32string>("std::u32string");
|
|
|
|
qRegisterMetaType<std::string_view>("std::string_view");
|
|
|
|
qRegisterMetaType<std::wstring_view>("std::wstring_view");
|
|
|
|
qRegisterMetaType<std::u8string_view>("std::u8string_view");
|
|
|
|
qRegisterMetaType<std::u16string_view>("std::u16string_view");
|
|
|
|
qRegisterMetaType<std::u32string_view>("std::u32string_view");
|
|
|
|
|
|
|
|
// Register applet types
|
|
|
|
|
2022-11-13 19:43:03 +00:00
|
|
|
// Cabinet Applet
|
|
|
|
qRegisterMetaType<Core::Frontend::CabinetParameters>("Core::Frontend::CabinetParameters");
|
2023-04-20 01:01:23 +00:00
|
|
|
qRegisterMetaType<std::shared_ptr<Service::NFC::NfcDevice>>(
|
|
|
|
"std::shared_ptr<Service::NFC::NfcDevice>");
|
2022-11-13 19:43:03 +00:00
|
|
|
|
2021-03-26 09:26:16 +00:00
|
|
|
// Controller Applet
|
|
|
|
qRegisterMetaType<Core::Frontend::ControllerParameters>("Core::Frontend::ControllerParameters");
|
|
|
|
|
2023-03-29 02:55:06 +00:00
|
|
|
// Profile Select Applet
|
|
|
|
qRegisterMetaType<Core::Frontend::ProfileSelectParameters>(
|
|
|
|
"Core::Frontend::ProfileSelectParameters");
|
|
|
|
|
2021-03-26 09:26:16 +00:00
|
|
|
// Software Keyboard Applet
|
|
|
|
qRegisterMetaType<Core::Frontend::KeyboardInitializeParameters>(
|
|
|
|
"Core::Frontend::KeyboardInitializeParameters");
|
|
|
|
qRegisterMetaType<Core::Frontend::InlineAppearParameters>(
|
|
|
|
"Core::Frontend::InlineAppearParameters");
|
|
|
|
qRegisterMetaType<Core::Frontend::InlineTextParameters>("Core::Frontend::InlineTextParameters");
|
|
|
|
qRegisterMetaType<Service::AM::Applets::SwkbdResult>("Service::AM::Applets::SwkbdResult");
|
|
|
|
qRegisterMetaType<Service::AM::Applets::SwkbdTextCheckResult>(
|
|
|
|
"Service::AM::Applets::SwkbdTextCheckResult");
|
|
|
|
qRegisterMetaType<Service::AM::Applets::SwkbdReplyType>("Service::AM::Applets::SwkbdReplyType");
|
|
|
|
|
|
|
|
// Web Browser Applet
|
|
|
|
qRegisterMetaType<Service::AM::Applets::WebExitReason>("Service::AM::Applets::WebExitReason");
|
|
|
|
|
|
|
|
// Register loader types
|
2021-10-14 22:14:40 +00:00
|
|
|
qRegisterMetaType<Core::SystemResultStatus>("Core::SystemResultStatus");
|
2021-03-26 09:26:16 +00:00
|
|
|
}
|
|
|
|
|
2022-11-13 21:14:08 +00:00
|
|
|
void GMainWindow::AmiiboSettingsShowDialog(const Core::Frontend::CabinetParameters& parameters,
|
2023-04-20 01:01:23 +00:00
|
|
|
std::shared_ptr<Service::NFC::NfcDevice> nfp_device) {
|
2023-03-25 17:29:08 +00:00
|
|
|
cabinet_applet =
|
|
|
|
new QtAmiiboSettingsDialog(this, parameters, input_subsystem.get(), nfp_device);
|
|
|
|
SCOPE_EXIT({
|
|
|
|
cabinet_applet->deleteLater();
|
|
|
|
cabinet_applet = nullptr;
|
|
|
|
});
|
2022-11-13 19:43:03 +00:00
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
cabinet_applet->setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint | Qt::WindowStaysOnTopHint |
|
|
|
|
Qt::WindowTitleHint | Qt::WindowSystemMenuHint);
|
|
|
|
cabinet_applet->setWindowModality(Qt::WindowModal);
|
|
|
|
|
|
|
|
if (cabinet_applet->exec() == QDialog::Rejected) {
|
2022-11-13 21:14:08 +00:00
|
|
|
emit AmiiboSettingsFinished(false, {});
|
2022-11-13 19:43:03 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
emit AmiiboSettingsFinished(true, cabinet_applet->GetName());
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::AmiiboSettingsRequestExit() {
|
|
|
|
if (cabinet_applet) {
|
|
|
|
cabinet_applet->reject();
|
|
|
|
}
|
2022-11-13 19:43:03 +00:00
|
|
|
}
|
|
|
|
|
2020-08-21 11:39:24 +00:00
|
|
|
void GMainWindow::ControllerSelectorReconfigureControllers(
|
|
|
|
const Core::Frontend::ControllerParameters& parameters) {
|
2023-03-25 17:29:08 +00:00
|
|
|
controller_applet =
|
|
|
|
new QtControllerSelectorDialog(this, parameters, input_subsystem.get(), *system);
|
|
|
|
SCOPE_EXIT({
|
|
|
|
controller_applet->deleteLater();
|
|
|
|
controller_applet = nullptr;
|
|
|
|
});
|
2020-09-27 15:18:07 +00:00
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
controller_applet->setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint |
|
|
|
|
Qt::WindowStaysOnTopHint | Qt::WindowTitleHint |
|
|
|
|
Qt::WindowSystemMenuHint);
|
|
|
|
controller_applet->setWindowModality(Qt::WindowModal);
|
2023-03-27 03:26:28 +00:00
|
|
|
bool is_success = controller_applet->exec() != QDialog::Rejected;
|
2020-08-21 11:39:24 +00:00
|
|
|
|
2020-08-27 15:58:28 +00:00
|
|
|
// Don't forget to apply settings.
|
2023-03-27 03:26:28 +00:00
|
|
|
system->HIDCore().DisableAllControllerConfiguration();
|
2021-10-14 18:32:19 +00:00
|
|
|
system->ApplySettings();
|
2020-08-27 15:58:28 +00:00
|
|
|
config->Save();
|
|
|
|
|
2020-08-21 11:39:24 +00:00
|
|
|
UpdateStatusButtons();
|
2023-03-27 03:26:28 +00:00
|
|
|
|
|
|
|
emit ControllerSelectorReconfigureFinished(is_success);
|
2020-08-21 11:39:24 +00:00
|
|
|
}
|
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
void GMainWindow::ControllerSelectorRequestExit() {
|
|
|
|
if (controller_applet) {
|
|
|
|
controller_applet->reject();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-29 02:55:06 +00:00
|
|
|
void GMainWindow::ProfileSelectorSelectProfile(
|
|
|
|
const Core::Frontend::ProfileSelectParameters& parameters) {
|
|
|
|
profile_select_applet = new QtProfileSelectionDialog(system->HIDCore(), this, parameters);
|
2023-03-25 17:29:08 +00:00
|
|
|
SCOPE_EXIT({
|
|
|
|
profile_select_applet->deleteLater();
|
|
|
|
profile_select_applet = nullptr;
|
|
|
|
});
|
|
|
|
|
|
|
|
profile_select_applet->setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint |
|
|
|
|
Qt::WindowStaysOnTopHint | Qt::WindowTitleHint |
|
|
|
|
Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint);
|
|
|
|
profile_select_applet->setWindowModality(Qt::WindowModal);
|
|
|
|
if (profile_select_applet->exec() == QDialog::Rejected) {
|
2020-10-21 18:36:57 +00:00
|
|
|
emit ProfileSelectorFinishedSelection(std::nullopt);
|
|
|
|
return;
|
2018-11-23 02:03:33 +00:00
|
|
|
}
|
|
|
|
|
2020-10-21 18:36:57 +00:00
|
|
|
const Service::Account::ProfileManager manager;
|
2023-03-25 17:29:08 +00:00
|
|
|
const auto uuid = manager.GetUser(static_cast<std::size_t>(profile_select_applet->GetIndex()));
|
2018-11-23 02:03:33 +00:00
|
|
|
if (!uuid.has_value()) {
|
|
|
|
emit ProfileSelectorFinishedSelection(std::nullopt);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
emit ProfileSelectorFinishedSelection(uuid);
|
|
|
|
}
|
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
void GMainWindow::ProfileSelectorRequestExit() {
|
|
|
|
if (profile_select_applet) {
|
|
|
|
profile_select_applet->reject();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-27 19:15:32 +00:00
|
|
|
void GMainWindow::SoftwareKeyboardInitialize(
|
|
|
|
bool is_inline, Core::Frontend::KeyboardInitializeParameters initialize_parameters) {
|
|
|
|
if (software_keyboard) {
|
|
|
|
LOG_ERROR(Frontend, "The software keyboard is already initialized!");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
software_keyboard = new QtSoftwareKeyboardDialog(render_window, *system, is_inline,
|
2021-09-03 01:40:55 +00:00
|
|
|
std::move(initialize_parameters));
|
2021-03-27 19:15:32 +00:00
|
|
|
|
|
|
|
if (is_inline) {
|
|
|
|
connect(
|
|
|
|
software_keyboard, &QtSoftwareKeyboardDialog::SubmitInlineText, this,
|
|
|
|
[this](Service::AM::Applets::SwkbdReplyType reply_type, std::u16string submitted_text,
|
|
|
|
s32 cursor_position) {
|
|
|
|
emit SoftwareKeyboardSubmitInlineText(reply_type, submitted_text, cursor_position);
|
|
|
|
},
|
|
|
|
Qt::QueuedConnection);
|
|
|
|
} else {
|
|
|
|
connect(
|
|
|
|
software_keyboard, &QtSoftwareKeyboardDialog::SubmitNormalText, this,
|
2021-11-08 18:05:50 +00:00
|
|
|
[this](Service::AM::Applets::SwkbdResult result, std::u16string submitted_text,
|
|
|
|
bool confirmed) {
|
|
|
|
emit SoftwareKeyboardSubmitNormalText(result, submitted_text, confirmed);
|
2021-03-27 19:15:32 +00:00
|
|
|
},
|
|
|
|
Qt::QueuedConnection);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::SoftwareKeyboardShowNormal() {
|
|
|
|
if (!software_keyboard) {
|
|
|
|
LOG_ERROR(Frontend, "The software keyboard is not initialized!");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto& layout = render_window->GetFramebufferLayout();
|
|
|
|
|
|
|
|
const auto x = layout.screen.left;
|
|
|
|
const auto y = layout.screen.top;
|
|
|
|
const auto w = layout.screen.GetWidth();
|
|
|
|
const auto h = layout.screen.GetHeight();
|
2023-01-26 02:16:05 +00:00
|
|
|
const auto scale_ratio = devicePixelRatioF();
|
2021-03-27 19:15:32 +00:00
|
|
|
|
2023-01-26 02:16:05 +00:00
|
|
|
software_keyboard->ShowNormalKeyboard(render_window->mapToGlobal(QPoint(x, y) / scale_ratio),
|
|
|
|
QSize(w, h) / scale_ratio);
|
2021-03-27 19:15:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::SoftwareKeyboardShowTextCheck(
|
|
|
|
Service::AM::Applets::SwkbdTextCheckResult text_check_result,
|
|
|
|
std::u16string text_check_message) {
|
|
|
|
if (!software_keyboard) {
|
|
|
|
LOG_ERROR(Frontend, "The software keyboard is not initialized!");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
software_keyboard->ShowTextCheckDialog(text_check_result, text_check_message);
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::SoftwareKeyboardShowInline(
|
|
|
|
Core::Frontend::InlineAppearParameters appear_parameters) {
|
|
|
|
if (!software_keyboard) {
|
|
|
|
LOG_ERROR(Frontend, "The software keyboard is not initialized!");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto& layout = render_window->GetFramebufferLayout();
|
|
|
|
|
|
|
|
const auto x =
|
|
|
|
static_cast<int>(layout.screen.left + (0.5f * layout.screen.GetWidth() *
|
|
|
|
((2.0f * appear_parameters.key_top_translate_x) +
|
|
|
|
(1.0f - appear_parameters.key_top_scale_x))));
|
|
|
|
const auto y =
|
|
|
|
static_cast<int>(layout.screen.top + (layout.screen.GetHeight() *
|
|
|
|
((2.0f * appear_parameters.key_top_translate_y) +
|
|
|
|
(1.0f - appear_parameters.key_top_scale_y))));
|
|
|
|
const auto w = static_cast<int>(layout.screen.GetWidth() * appear_parameters.key_top_scale_x);
|
|
|
|
const auto h = static_cast<int>(layout.screen.GetHeight() * appear_parameters.key_top_scale_y);
|
2023-01-26 02:16:05 +00:00
|
|
|
const auto scale_ratio = devicePixelRatioF();
|
2021-03-27 19:15:32 +00:00
|
|
|
|
|
|
|
software_keyboard->ShowInlineKeyboard(std::move(appear_parameters),
|
2023-01-26 02:16:05 +00:00
|
|
|
render_window->mapToGlobal(QPoint(x, y) / scale_ratio),
|
|
|
|
QSize(w, h) / scale_ratio);
|
2021-03-27 19:15:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::SoftwareKeyboardHideInline() {
|
|
|
|
if (!software_keyboard) {
|
|
|
|
LOG_ERROR(Frontend, "The software keyboard is not initialized!");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
software_keyboard->HideInlineKeyboard();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::SoftwareKeyboardInlineTextChanged(
|
|
|
|
Core::Frontend::InlineTextParameters text_parameters) {
|
|
|
|
if (!software_keyboard) {
|
|
|
|
LOG_ERROR(Frontend, "The software keyboard is not initialized!");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
software_keyboard->InlineTextChanged(std::move(text_parameters));
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::SoftwareKeyboardExit() {
|
|
|
|
if (!software_keyboard) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
software_keyboard->ExitKeyboard();
|
|
|
|
|
|
|
|
software_keyboard = nullptr;
|
|
|
|
}
|
|
|
|
|
2021-04-28 15:32:44 +00:00
|
|
|
void GMainWindow::WebBrowserOpenWebPage(const std::string& main_url,
|
|
|
|
const std::string& additional_args, bool is_local) {
|
2020-11-30 13:31:26 +00:00
|
|
|
#ifdef YUZU_USE_QT_WEB_ENGINE
|
|
|
|
|
2021-09-01 23:48:01 +00:00
|
|
|
// Raw input breaks with the web applet, Disable web applets if enabled
|
2022-03-17 20:55:30 +00:00
|
|
|
if (UISettings::values.disable_web_applet || Settings::values.enable_raw_input) {
|
2020-11-30 15:34:18 +00:00
|
|
|
emit WebBrowserClosed(Service::AM::Applets::WebExitReason::WindowClosed,
|
2020-12-08 11:20:45 +00:00
|
|
|
"http://localhost/");
|
2020-11-30 15:34:18 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
web_applet = new QtNXWebEngineView(this, *system, input_subsystem.get());
|
2020-11-30 13:31:26 +00:00
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Pause->setEnabled(false);
|
|
|
|
ui->action_Restart->setEnabled(false);
|
|
|
|
ui->action_Stop->setEnabled(false);
|
2020-11-30 13:31:26 +00:00
|
|
|
|
2020-11-30 15:15:00 +00:00
|
|
|
{
|
|
|
|
QProgressDialog loading_progress(this);
|
|
|
|
loading_progress.setLabelText(tr("Loading Web Applet..."));
|
|
|
|
loading_progress.setRange(0, 3);
|
|
|
|
loading_progress.setValue(0);
|
|
|
|
|
2021-04-28 15:32:44 +00:00
|
|
|
if (is_local && !Common::FS::Exists(main_url)) {
|
2020-11-30 15:15:00 +00:00
|
|
|
loading_progress.show();
|
|
|
|
|
|
|
|
auto future = QtConcurrent::run([this] { emit WebBrowserExtractOfflineRomFS(); });
|
|
|
|
|
|
|
|
while (!future.isFinished()) {
|
|
|
|
QCoreApplication::processEvents();
|
2021-04-28 15:32:44 +00:00
|
|
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
2020-11-30 15:15:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
loading_progress.setValue(1);
|
2020-11-30 13:31:26 +00:00
|
|
|
|
2020-12-08 11:20:45 +00:00
|
|
|
if (is_local) {
|
2023-03-25 17:29:08 +00:00
|
|
|
web_applet->LoadLocalWebPage(main_url, additional_args);
|
2020-12-08 11:20:45 +00:00
|
|
|
} else {
|
2023-03-25 17:29:08 +00:00
|
|
|
web_applet->LoadExternalWebPage(main_url, additional_args);
|
2020-12-08 11:20:45 +00:00
|
|
|
}
|
2020-11-30 13:31:26 +00:00
|
|
|
|
2020-11-30 15:15:00 +00:00
|
|
|
if (render_window->IsLoadingComplete()) {
|
|
|
|
render_window->hide();
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto& layout = render_window->GetFramebufferLayout();
|
2023-01-26 02:16:05 +00:00
|
|
|
const auto scale_ratio = devicePixelRatioF();
|
2023-03-25 17:29:08 +00:00
|
|
|
web_applet->resize(layout.screen.GetWidth() / scale_ratio,
|
|
|
|
layout.screen.GetHeight() / scale_ratio);
|
|
|
|
web_applet->move(layout.screen.left / scale_ratio,
|
|
|
|
(layout.screen.top / scale_ratio) + menuBar()->height());
|
|
|
|
web_applet->setZoomFactor(static_cast<qreal>(layout.screen.GetWidth() / scale_ratio) /
|
|
|
|
static_cast<qreal>(Layout::ScreenUndocked::Width));
|
2020-11-30 15:15:00 +00:00
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
web_applet->setFocus();
|
|
|
|
web_applet->show();
|
2020-11-30 15:15:00 +00:00
|
|
|
|
|
|
|
loading_progress.setValue(2);
|
|
|
|
|
|
|
|
QCoreApplication::processEvents();
|
|
|
|
|
|
|
|
loading_progress.setValue(3);
|
|
|
|
}
|
2020-11-30 13:31:26 +00:00
|
|
|
|
|
|
|
bool exit_check = false;
|
|
|
|
|
2020-11-30 15:34:18 +00:00
|
|
|
// TODO (Morph): Remove this
|
|
|
|
QAction* exit_action = new QAction(tr("Disable Web Applet"), this);
|
2023-03-25 17:29:08 +00:00
|
|
|
connect(exit_action, &QAction::triggered, this, [this] {
|
2020-11-30 15:34:18 +00:00
|
|
|
const auto result = QMessageBox::warning(
|
|
|
|
this, tr("Disable Web Applet"),
|
2022-03-17 22:14:27 +00:00
|
|
|
tr("Disabling the web applet can lead to undefined behavior and should only be used "
|
2022-03-17 23:20:15 +00:00
|
|
|
"with Super Mario 3D All-Stars. Are you sure you want to disable the web "
|
|
|
|
"applet?\n(This can be re-enabled in the Debug settings.)"),
|
2020-11-30 15:34:18 +00:00
|
|
|
QMessageBox::Yes | QMessageBox::No);
|
|
|
|
if (result == QMessageBox::Yes) {
|
2022-03-17 20:55:30 +00:00
|
|
|
UISettings::values.disable_web_applet = true;
|
2023-03-25 17:29:08 +00:00
|
|
|
web_applet->SetFinished(true);
|
2020-11-30 15:34:18 +00:00
|
|
|
}
|
|
|
|
});
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->menubar->addAction(exit_action);
|
2020-11-30 15:34:18 +00:00
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
while (!web_applet->IsFinished()) {
|
2020-11-30 13:31:26 +00:00
|
|
|
QCoreApplication::processEvents();
|
|
|
|
|
|
|
|
if (!exit_check) {
|
2023-03-25 17:29:08 +00:00
|
|
|
web_applet->page()->runJavaScript(
|
2020-11-30 13:31:26 +00:00
|
|
|
QStringLiteral("end_applet;"), [&](const QVariant& variant) {
|
|
|
|
exit_check = false;
|
|
|
|
if (variant.toBool()) {
|
2023-03-25 17:29:08 +00:00
|
|
|
web_applet->SetFinished(true);
|
|
|
|
web_applet->SetExitReason(
|
2020-11-30 15:15:00 +00:00
|
|
|
Service::AM::Applets::WebExitReason::EndButtonPressed);
|
2020-11-30 13:31:26 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
exit_check = true;
|
|
|
|
}
|
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
if (web_applet->GetCurrentURL().contains(QStringLiteral("localhost"))) {
|
|
|
|
if (!web_applet->IsFinished()) {
|
|
|
|
web_applet->SetFinished(true);
|
|
|
|
web_applet->SetExitReason(Service::AM::Applets::WebExitReason::CallbackURL);
|
2020-11-30 13:31:26 +00:00
|
|
|
}
|
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
web_applet->SetLastURL(web_applet->GetCurrentURL().toStdString());
|
2020-11-30 13:31:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
|
|
}
|
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
const auto exit_reason = web_applet->GetExitReason();
|
|
|
|
const auto last_url = web_applet->GetLastURL();
|
2020-11-30 13:31:26 +00:00
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
web_applet->hide();
|
2020-11-30 13:31:26 +00:00
|
|
|
|
|
|
|
render_window->setFocus();
|
|
|
|
|
|
|
|
if (render_window->IsLoadingComplete()) {
|
|
|
|
render_window->show();
|
|
|
|
}
|
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Pause->setEnabled(true);
|
|
|
|
ui->action_Restart->setEnabled(true);
|
|
|
|
ui->action_Stop->setEnabled(true);
|
2020-11-30 13:31:26 +00:00
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->menubar->removeAction(exit_action);
|
2020-11-30 15:34:18 +00:00
|
|
|
|
2020-11-30 15:15:00 +00:00
|
|
|
QCoreApplication::processEvents();
|
|
|
|
|
2020-11-30 13:31:26 +00:00
|
|
|
emit WebBrowserClosed(exit_reason, last_url);
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
// Utilize the same fallback as the default web browser applet.
|
2020-12-08 11:20:45 +00:00
|
|
|
emit WebBrowserClosed(Service::AM::Applets::WebExitReason::WindowClosed, "http://localhost/");
|
2020-11-30 13:31:26 +00:00
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
void GMainWindow::WebBrowserRequestExit() {
|
|
|
|
#ifdef YUZU_USE_QT_WEB_ENGINE
|
|
|
|
if (web_applet) {
|
|
|
|
web_applet->SetExitReason(Service::AM::Applets::WebExitReason::ExitRequested);
|
|
|
|
web_applet->SetFinished(true);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-12-19 19:50:58 +00:00
|
|
|
void GMainWindow::InitializeWidgets() {
|
2018-09-16 18:05:51 +00:00
|
|
|
#ifdef YUZU_ENABLE_COMPATIBILITY_REPORTING
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Report_Compatibility->setVisible(true);
|
2018-09-16 18:05:51 +00:00
|
|
|
#endif
|
2021-10-14 18:32:19 +00:00
|
|
|
render_window = new GRenderWindow(this, emu_thread.get(), input_subsystem, *system);
|
2014-04-22 03:15:17 +00:00
|
|
|
render_window->hide();
|
2014-04-01 02:26:50 +00:00
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
game_list = new GameList(vfs, provider.get(), *system, this);
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->horizontalLayout->addWidget(game_list);
|
2017-02-18 20:09:14 +00:00
|
|
|
|
2019-05-01 21:21:04 +00:00
|
|
|
game_list_placeholder = new GameListPlaceholder(this);
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->horizontalLayout->addWidget(game_list_placeholder);
|
2019-05-01 21:21:04 +00:00
|
|
|
game_list_placeholder->setVisible(false);
|
|
|
|
|
2019-01-17 07:01:00 +00:00
|
|
|
loading_screen = new LoadingScreen(this);
|
|
|
|
loading_screen->hide();
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->horizontalLayout->addWidget(loading_screen);
|
2019-01-21 16:20:16 +00:00
|
|
|
connect(loading_screen, &LoadingScreen::Hidden, [&] {
|
|
|
|
loading_screen->Clear();
|
|
|
|
if (emulation_running) {
|
|
|
|
render_window->show();
|
|
|
|
render_window->setFocus();
|
|
|
|
}
|
|
|
|
});
|
2019-01-17 07:01:00 +00:00
|
|
|
|
2021-12-25 19:27:52 +00:00
|
|
|
multiplayer_state = new MultiplayerState(this, game_list->GetModel(), ui->action_Leave_Room,
|
2022-08-27 01:41:19 +00:00
|
|
|
ui->action_Show_Room, *system);
|
2021-12-25 19:27:52 +00:00
|
|
|
multiplayer_state->setVisible(false);
|
|
|
|
|
2017-02-18 20:09:14 +00:00
|
|
|
// Create status bar
|
2017-04-13 05:10:19 +00:00
|
|
|
message_label = new QLabel();
|
|
|
|
// Configured separately for left alignment
|
|
|
|
message_label->setFrameStyle(QFrame::NoFrame);
|
|
|
|
message_label->setContentsMargins(4, 0, 4, 0);
|
|
|
|
message_label->setAlignment(Qt::AlignLeft);
|
|
|
|
statusBar()->addPermanentWidget(message_label, 1);
|
|
|
|
|
2020-07-10 03:36:38 +00:00
|
|
|
shader_building_label = new QLabel();
|
|
|
|
shader_building_label->setToolTip(tr("The amount of shaders currently being built"));
|
2021-07-26 05:58:02 +00:00
|
|
|
res_scale_label = new QLabel();
|
|
|
|
res_scale_label->setToolTip(tr("The current selected resolution scaling multiplier."));
|
2017-02-18 20:09:14 +00:00
|
|
|
emu_speed_label = new QLabel();
|
2018-01-16 18:05:21 +00:00
|
|
|
emu_speed_label->setToolTip(
|
|
|
|
tr("Current emulation speed. Values higher or lower than 100% "
|
|
|
|
"indicate emulation is running faster or slower than a Switch."));
|
2017-02-18 20:09:14 +00:00
|
|
|
game_fps_label = new QLabel();
|
2017-02-20 03:09:46 +00:00
|
|
|
game_fps_label->setToolTip(tr("How many frames per second the game is currently displaying. "
|
|
|
|
"This will vary from game to game and scene to scene."));
|
2017-02-18 20:09:14 +00:00
|
|
|
emu_frametime_label = new QLabel();
|
2017-02-20 03:09:46 +00:00
|
|
|
emu_frametime_label->setToolTip(
|
2018-01-13 23:49:16 +00:00
|
|
|
tr("Time taken to emulate a Switch frame, not counting framelimiting or v-sync. For "
|
2017-02-20 03:09:46 +00:00
|
|
|
"full-speed emulation this should be at most 16.67 ms."));
|
2017-02-18 20:09:14 +00:00
|
|
|
|
2021-07-26 05:58:02 +00:00
|
|
|
for (auto& label : {shader_building_label, res_scale_label, emu_speed_label, game_fps_label,
|
|
|
|
emu_frametime_label}) {
|
2017-02-18 20:09:14 +00:00
|
|
|
label->setVisible(false);
|
2017-02-21 00:53:40 +00:00
|
|
|
label->setFrameStyle(QFrame::NoFrame);
|
|
|
|
label->setContentsMargins(4, 0, 4, 0);
|
2020-01-28 22:59:30 +00:00
|
|
|
statusBar()->addPermanentWidget(label);
|
2017-02-18 20:09:14 +00:00
|
|
|
}
|
2020-01-28 22:59:30 +00:00
|
|
|
|
2022-07-06 02:19:18 +00:00
|
|
|
// TODO (flTobi): Add the widget when multiplayer is fully implemented
|
2022-07-31 02:46:26 +00:00
|
|
|
statusBar()->addPermanentWidget(multiplayer_state->GetStatusText(), 0);
|
|
|
|
statusBar()->addPermanentWidget(multiplayer_state->GetStatusIcon(), 0);
|
2021-12-25 19:27:52 +00:00
|
|
|
|
2021-06-19 19:38:49 +00:00
|
|
|
tas_label = new QLabel();
|
|
|
|
tas_label->setObjectName(QStringLiteral("TASlabel"));
|
|
|
|
tas_label->setFocusPolicy(Qt::NoFocus);
|
|
|
|
statusBar()->insertPermanentWidget(0, tas_label);
|
|
|
|
|
2023-01-19 14:13:23 +00:00
|
|
|
volume_popup = new QWidget(this);
|
|
|
|
volume_popup->setWindowFlags(Qt::FramelessWindowHint | Qt::NoDropShadowWindowHint | Qt::Popup);
|
|
|
|
volume_popup->setLayout(new QVBoxLayout());
|
|
|
|
volume_popup->setMinimumWidth(200);
|
|
|
|
|
|
|
|
volume_slider = new QSlider(Qt::Horizontal);
|
|
|
|
volume_slider->setObjectName(QStringLiteral("volume_slider"));
|
|
|
|
volume_slider->setMaximum(200);
|
|
|
|
volume_slider->setPageStep(5);
|
|
|
|
connect(volume_slider, &QSlider::valueChanged, this, [this](int percentage) {
|
|
|
|
Settings::values.audio_muted = false;
|
|
|
|
const auto volume = static_cast<u8>(percentage);
|
|
|
|
Settings::values.volume.SetValue(volume);
|
|
|
|
UpdateVolumeUI();
|
|
|
|
});
|
|
|
|
volume_popup->layout()->addWidget(volume_slider);
|
|
|
|
|
|
|
|
volume_button = new QPushButton();
|
|
|
|
volume_button->setObjectName(QStringLiteral("TogglableStatusBarButton"));
|
|
|
|
volume_button->setFocusPolicy(Qt::NoFocus);
|
|
|
|
volume_button->setCheckable(true);
|
|
|
|
UpdateVolumeUI();
|
|
|
|
connect(volume_button, &QPushButton::clicked, this, [&] {
|
|
|
|
UpdateVolumeUI();
|
|
|
|
volume_popup->setVisible(!volume_popup->isVisible());
|
|
|
|
QRect rect = volume_button->geometry();
|
|
|
|
QPoint bottomLeft = statusBar()->mapToGlobal(rect.topLeft());
|
|
|
|
bottomLeft.setY(bottomLeft.y() - volume_popup->geometry().height());
|
|
|
|
volume_popup->setGeometry(QRect(bottomLeft, QSize(rect.width(), rect.height())));
|
|
|
|
});
|
2023-05-16 19:17:54 +00:00
|
|
|
volume_button->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
|
|
connect(volume_button, &QPushButton::customContextMenuRequested,
|
|
|
|
[this](const QPoint& menu_location) {
|
|
|
|
QMenu context_menu;
|
|
|
|
context_menu.addAction(
|
|
|
|
Settings::values.audio_muted ? tr("Unmute") : tr("Mute"), [this] {
|
|
|
|
Settings::values.audio_muted = !Settings::values.audio_muted;
|
|
|
|
UpdateVolumeUI();
|
|
|
|
});
|
|
|
|
|
|
|
|
context_menu.addAction(tr("Reset Volume"), [this] {
|
|
|
|
Settings::values.volume.SetValue(100);
|
|
|
|
UpdateVolumeUI();
|
|
|
|
});
|
|
|
|
|
|
|
|
context_menu.exec(volume_button->mapToGlobal(menu_location));
|
|
|
|
volume_button->repaint();
|
|
|
|
});
|
2023-01-19 14:13:23 +00:00
|
|
|
statusBar()->insertPermanentWidget(0, volume_button);
|
|
|
|
|
2021-10-22 20:56:08 +00:00
|
|
|
// setup AA button
|
|
|
|
aa_status_button = new QPushButton();
|
|
|
|
aa_status_button->setObjectName(QStringLiteral("TogglableStatusBarButton"));
|
|
|
|
aa_status_button->setFocusPolicy(Qt::NoFocus);
|
|
|
|
connect(aa_status_button, &QPushButton::clicked, [&] {
|
|
|
|
auto aa_mode = Settings::values.anti_aliasing.GetValue();
|
|
|
|
if (aa_mode == Settings::AntiAliasing::LastAA) {
|
|
|
|
aa_mode = Settings::AntiAliasing::None;
|
|
|
|
} else {
|
|
|
|
aa_mode = static_cast<Settings::AntiAliasing>(static_cast<u32>(aa_mode) + 1);
|
|
|
|
}
|
|
|
|
Settings::values.anti_aliasing.SetValue(aa_mode);
|
|
|
|
aa_status_button->setChecked(true);
|
|
|
|
UpdateAAText();
|
|
|
|
});
|
|
|
|
UpdateAAText();
|
|
|
|
aa_status_button->setCheckable(true);
|
|
|
|
aa_status_button->setChecked(true);
|
2023-05-16 19:17:54 +00:00
|
|
|
aa_status_button->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
|
|
connect(aa_status_button, &QPushButton::customContextMenuRequested,
|
|
|
|
[this](const QPoint& menu_location) {
|
|
|
|
QMenu context_menu;
|
|
|
|
for (auto const& aa_text_pair : Config::anti_aliasing_texts_map) {
|
|
|
|
context_menu.addAction(aa_text_pair.second, [this, aa_text_pair] {
|
|
|
|
Settings::values.anti_aliasing.SetValue(aa_text_pair.first);
|
|
|
|
UpdateAAText();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
context_menu.exec(aa_status_button->mapToGlobal(menu_location));
|
|
|
|
aa_status_button->repaint();
|
|
|
|
});
|
2021-10-22 20:56:08 +00:00
|
|
|
statusBar()->insertPermanentWidget(0, aa_status_button);
|
|
|
|
|
2021-10-21 00:05:16 +00:00
|
|
|
// Setup Filter button
|
|
|
|
filter_status_button = new QPushButton();
|
|
|
|
filter_status_button->setObjectName(QStringLiteral("TogglableStatusBarButton"));
|
|
|
|
filter_status_button->setFocusPolicy(Qt::NoFocus);
|
2022-02-07 02:27:38 +00:00
|
|
|
connect(filter_status_button, &QPushButton::clicked, this,
|
|
|
|
&GMainWindow::OnToggleAdaptingFilter);
|
2021-10-21 00:05:16 +00:00
|
|
|
UpdateFilterText();
|
|
|
|
filter_status_button->setCheckable(true);
|
2021-10-22 20:56:08 +00:00
|
|
|
filter_status_button->setChecked(true);
|
2023-05-16 19:17:54 +00:00
|
|
|
filter_status_button->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
|
|
connect(filter_status_button, &QPushButton::customContextMenuRequested,
|
|
|
|
[this](const QPoint& menu_location) {
|
|
|
|
QMenu context_menu;
|
|
|
|
for (auto const& filter_text_pair : Config::scaling_filter_texts_map) {
|
|
|
|
context_menu.addAction(filter_text_pair.second, [this, filter_text_pair] {
|
|
|
|
Settings::values.scaling_filter.SetValue(filter_text_pair.first);
|
|
|
|
UpdateFilterText();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
context_menu.exec(filter_status_button->mapToGlobal(menu_location));
|
|
|
|
filter_status_button->repaint();
|
|
|
|
});
|
2021-10-21 00:05:16 +00:00
|
|
|
statusBar()->insertPermanentWidget(0, filter_status_button);
|
|
|
|
|
2020-01-28 22:59:30 +00:00
|
|
|
// Setup Dock button
|
|
|
|
dock_status_button = new QPushButton();
|
2022-06-01 07:59:58 +00:00
|
|
|
dock_status_button->setObjectName(QStringLiteral("DockingStatusBarButton"));
|
2020-01-28 22:59:30 +00:00
|
|
|
dock_status_button->setFocusPolicy(Qt::NoFocus);
|
2022-02-07 02:27:38 +00:00
|
|
|
connect(dock_status_button, &QPushButton::clicked, this, &GMainWindow::OnToggleDockedMode);
|
2020-01-28 22:59:30 +00:00
|
|
|
dock_status_button->setCheckable(true);
|
2022-06-01 07:59:58 +00:00
|
|
|
UpdateDockedButton();
|
2023-05-16 19:17:54 +00:00
|
|
|
dock_status_button->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
|
|
connect(dock_status_button, &QPushButton::customContextMenuRequested,
|
|
|
|
[this](const QPoint& menu_location) {
|
|
|
|
QMenu context_menu;
|
|
|
|
|
|
|
|
for (auto const& docked_mode_pair : Config::use_docked_mode_texts_map) {
|
|
|
|
context_menu.addAction(docked_mode_pair.second, [this, docked_mode_pair] {
|
|
|
|
if (docked_mode_pair.first != Settings::values.use_docked_mode.GetValue()) {
|
|
|
|
OnToggleDockedMode();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
context_menu.exec(dock_status_button->mapToGlobal(menu_location));
|
|
|
|
dock_status_button->repaint();
|
|
|
|
});
|
2020-01-28 22:59:30 +00:00
|
|
|
statusBar()->insertPermanentWidget(0, dock_status_button);
|
|
|
|
|
2023-05-16 19:17:54 +00:00
|
|
|
// Setup GPU Accuracy button
|
2021-07-08 21:21:08 +00:00
|
|
|
gpu_accuracy_button = new QPushButton();
|
|
|
|
gpu_accuracy_button->setObjectName(QStringLiteral("GPUStatusBarButton"));
|
|
|
|
gpu_accuracy_button->setCheckable(true);
|
|
|
|
gpu_accuracy_button->setFocusPolicy(Qt::NoFocus);
|
2022-02-07 02:27:38 +00:00
|
|
|
connect(gpu_accuracy_button, &QPushButton::clicked, this, &GMainWindow::OnToggleGpuAccuracy);
|
2021-07-08 21:21:08 +00:00
|
|
|
UpdateGPUAccuracyButton();
|
2023-05-16 19:17:54 +00:00
|
|
|
gpu_accuracy_button->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
|
|
connect(gpu_accuracy_button, &QPushButton::customContextMenuRequested,
|
|
|
|
[this](const QPoint& menu_location) {
|
|
|
|
QMenu context_menu;
|
|
|
|
|
|
|
|
for (auto const& gpu_accuracy_pair : Config::gpu_accuracy_texts_map) {
|
|
|
|
if (gpu_accuracy_pair.first == Settings::GPUAccuracy::Extreme) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
context_menu.addAction(gpu_accuracy_pair.second, [this, gpu_accuracy_pair] {
|
|
|
|
Settings::values.gpu_accuracy.SetValue(gpu_accuracy_pair.first);
|
|
|
|
UpdateGPUAccuracyButton();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
context_menu.exec(gpu_accuracy_button->mapToGlobal(menu_location));
|
|
|
|
gpu_accuracy_button->repaint();
|
|
|
|
});
|
2021-07-08 21:21:08 +00:00
|
|
|
statusBar()->insertPermanentWidget(0, gpu_accuracy_button);
|
2020-01-28 22:59:30 +00:00
|
|
|
|
|
|
|
// Setup Renderer API button
|
|
|
|
renderer_status_button = new QPushButton();
|
|
|
|
renderer_status_button->setObjectName(QStringLiteral("RendererStatusBarButton"));
|
|
|
|
renderer_status_button->setCheckable(true);
|
|
|
|
renderer_status_button->setFocusPolicy(Qt::NoFocus);
|
2022-11-28 01:37:37 +00:00
|
|
|
connect(renderer_status_button, &QPushButton::clicked, this, &GMainWindow::OnToggleGraphicsAPI);
|
|
|
|
UpdateAPIText();
|
|
|
|
renderer_status_button->setCheckable(true);
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
renderer_status_button->setChecked(Settings::values.renderer_backend.GetValue() ==
|
2020-01-28 22:59:30 +00:00
|
|
|
Settings::RendererBackend::Vulkan);
|
2023-05-16 19:17:54 +00:00
|
|
|
renderer_status_button->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
|
|
connect(renderer_status_button, &QPushButton::customContextMenuRequested,
|
|
|
|
[this](const QPoint& menu_location) {
|
|
|
|
QMenu context_menu;
|
|
|
|
|
|
|
|
for (auto const& renderer_backend_pair : Config::renderer_backend_texts_map) {
|
|
|
|
if (renderer_backend_pair.first == Settings::RendererBackend::Null) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
context_menu.addAction(
|
|
|
|
renderer_backend_pair.second, [this, renderer_backend_pair] {
|
|
|
|
Settings::values.renderer_backend.SetValue(renderer_backend_pair.first);
|
|
|
|
UpdateAPIText();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
context_menu.exec(renderer_status_button->mapToGlobal(menu_location));
|
|
|
|
renderer_status_button->repaint();
|
|
|
|
});
|
2020-01-28 22:59:30 +00:00
|
|
|
statusBar()->insertPermanentWidget(0, renderer_status_button);
|
|
|
|
|
2017-02-18 20:09:14 +00:00
|
|
|
statusBar()->setVisible(true);
|
2019-05-24 23:44:06 +00:00
|
|
|
setStyleSheet(QStringLiteral("QStatusBar::item{border: none;}"));
|
2017-02-18 10:16:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::InitializeDebugWidgets() {
|
2021-10-15 19:27:18 +00:00
|
|
|
QMenu* debug_menu = ui->menu_View_Debugging;
|
2015-09-01 04:35:33 +00:00
|
|
|
|
2016-04-29 00:17:31 +00:00
|
|
|
#if MICROPROFILE_ENABLED
|
2015-08-17 21:25:21 +00:00
|
|
|
microProfileDialog = new MicroProfileDialog(this);
|
|
|
|
microProfileDialog->hide();
|
2017-02-18 10:16:24 +00:00
|
|
|
debug_menu->addAction(microProfileDialog->toggleViewAction());
|
2016-04-29 00:17:31 +00:00
|
|
|
#endif
|
2015-08-17 21:25:21 +00:00
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
waitTreeWidget = new WaitTreeWidget(*system, this);
|
2016-04-08 16:28:54 +00:00
|
|
|
addDockWidget(Qt::LeftDockWidgetArea, waitTreeWidget);
|
|
|
|
waitTreeWidget->hide();
|
|
|
|
debug_menu->addAction(waitTreeWidget->toggleViewAction());
|
2021-01-22 00:51:24 +00:00
|
|
|
|
2021-11-05 01:05:58 +00:00
|
|
|
controller_dialog = new ControllerDialog(system->HIDCore(), input_subsystem, this);
|
2021-02-04 14:54:27 +00:00
|
|
|
controller_dialog->hide();
|
|
|
|
debug_menu->addAction(controller_dialog->toggleViewAction());
|
2021-01-22 00:51:24 +00:00
|
|
|
|
2017-02-18 10:16:24 +00:00
|
|
|
connect(this, &GMainWindow::EmulationStarting, waitTreeWidget,
|
|
|
|
&WaitTreeWidget::OnEmulationStarting);
|
|
|
|
connect(this, &GMainWindow::EmulationStopping, waitTreeWidget,
|
|
|
|
&WaitTreeWidget::OnEmulationStopping);
|
2016-12-19 19:50:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::InitializeRecentFileMenuActions() {
|
|
|
|
for (int i = 0; i < max_recent_files_item; ++i) {
|
|
|
|
actions_recent_files[i] = new QAction(this);
|
|
|
|
actions_recent_files[i]->setVisible(false);
|
2018-01-19 01:03:13 +00:00
|
|
|
connect(actions_recent_files[i], &QAction::triggered, this, &GMainWindow::OnMenuRecentFile);
|
2016-12-19 19:50:58 +00:00
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->menu_recent_files->addAction(actions_recent_files[i]);
|
2016-12-19 19:50:58 +00:00
|
|
|
}
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->menu_recent_files->addSeparator();
|
2018-08-21 11:12:45 +00:00
|
|
|
QAction* action_clear_recent_files = new QAction(this);
|
2020-12-23 00:32:58 +00:00
|
|
|
action_clear_recent_files->setText(tr("&Clear Recent Files"));
|
2018-08-21 11:12:45 +00:00
|
|
|
connect(action_clear_recent_files, &QAction::triggered, this, [this] {
|
|
|
|
UISettings::values.recent_files.clear();
|
|
|
|
UpdateRecentFiles();
|
|
|
|
});
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->menu_recent_files->addAction(action_clear_recent_files);
|
2016-12-19 19:50:58 +00:00
|
|
|
|
|
|
|
UpdateRecentFiles();
|
|
|
|
}
|
|
|
|
|
2023-04-28 16:42:18 +00:00
|
|
|
void GMainWindow::LinkActionShortcut(QAction* action, const QString& action_name,
|
|
|
|
const bool tas_allowed) {
|
2021-11-25 02:27:25 +00:00
|
|
|
static const QString main_window = QStringLiteral("Main Window");
|
|
|
|
action->setShortcut(hotkey_registry.GetKeySequence(main_window, action_name));
|
|
|
|
action->setShortcutContext(hotkey_registry.GetShortcutContext(main_window, action_name));
|
2022-02-02 03:00:07 +00:00
|
|
|
action->setAutoRepeat(false);
|
2021-11-25 02:27:25 +00:00
|
|
|
|
|
|
|
this->addAction(action);
|
2021-11-15 23:57:41 +00:00
|
|
|
|
|
|
|
auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
|
|
|
|
const auto* controller_hotkey =
|
|
|
|
hotkey_registry.GetControllerHotkey(main_window, action_name, controller);
|
2022-04-23 16:56:30 +00:00
|
|
|
connect(
|
2023-04-28 16:42:18 +00:00
|
|
|
controller_hotkey, &ControllerShortcut::Activated, this,
|
|
|
|
[action, tas_allowed, this] {
|
|
|
|
auto [tas_status, current_tas_frame, total_tas_frames] =
|
|
|
|
input_subsystem->GetTas()->GetStatus();
|
|
|
|
if (tas_allowed || tas_status == InputCommon::TasInput::TasState::Stopped) {
|
|
|
|
action->trigger();
|
|
|
|
}
|
|
|
|
},
|
2022-04-23 16:56:30 +00:00
|
|
|
Qt::QueuedConnection);
|
2021-11-25 02:27:25 +00:00
|
|
|
}
|
|
|
|
|
2016-12-19 19:50:58 +00:00
|
|
|
void GMainWindow::InitializeHotkeys() {
|
2018-08-07 04:43:07 +00:00
|
|
|
hotkey_registry.LoadHotkeys();
|
|
|
|
|
2021-11-25 02:27:25 +00:00
|
|
|
LinkActionShortcut(ui->action_Load_File, QStringLiteral("Load File"));
|
2022-02-08 03:39:39 +00:00
|
|
|
LinkActionShortcut(ui->action_Load_Amiibo, QStringLiteral("Load/Remove Amiibo"));
|
2021-11-25 02:27:25 +00:00
|
|
|
LinkActionShortcut(ui->action_Exit, QStringLiteral("Exit yuzu"));
|
|
|
|
LinkActionShortcut(ui->action_Restart, QStringLiteral("Restart Emulation"));
|
|
|
|
LinkActionShortcut(ui->action_Pause, QStringLiteral("Continue/Pause Emulation"));
|
|
|
|
LinkActionShortcut(ui->action_Stop, QStringLiteral("Stop Emulation"));
|
|
|
|
LinkActionShortcut(ui->action_Show_Filter_Bar, QStringLiteral("Toggle Filter Bar"));
|
|
|
|
LinkActionShortcut(ui->action_Show_Status_Bar, QStringLiteral("Toggle Status Bar"));
|
|
|
|
LinkActionShortcut(ui->action_Fullscreen, QStringLiteral("Fullscreen"));
|
|
|
|
LinkActionShortcut(ui->action_Capture_Screenshot, QStringLiteral("Capture Screenshot"));
|
2023-04-28 16:42:18 +00:00
|
|
|
LinkActionShortcut(ui->action_TAS_Start, QStringLiteral("TAS Start/Stop"), true);
|
|
|
|
LinkActionShortcut(ui->action_TAS_Record, QStringLiteral("TAS Record"), true);
|
|
|
|
LinkActionShortcut(ui->action_TAS_Reset, QStringLiteral("TAS Reset"), true);
|
2021-11-25 02:27:25 +00:00
|
|
|
|
|
|
|
static const QString main_window = QStringLiteral("Main Window");
|
|
|
|
const auto connect_shortcut = [&]<typename Fn>(const QString& action_name, const Fn& function) {
|
2021-11-15 23:57:41 +00:00
|
|
|
const auto* hotkey = hotkey_registry.GetHotkey(main_window, action_name, this);
|
|
|
|
auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
|
|
|
|
const auto* controller_hotkey =
|
|
|
|
hotkey_registry.GetControllerHotkey(main_window, action_name, controller);
|
2021-11-25 02:27:25 +00:00
|
|
|
connect(hotkey, &QShortcut::activated, this, function);
|
2022-04-23 16:56:30 +00:00
|
|
|
connect(controller_hotkey, &ControllerShortcut::Activated, this, function,
|
|
|
|
Qt::QueuedConnection);
|
2021-11-25 02:27:25 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
connect_shortcut(QStringLiteral("Exit Fullscreen"), [&] {
|
|
|
|
if (emulation_running && ui->action_Fullscreen->isChecked()) {
|
|
|
|
ui->action_Fullscreen->setChecked(false);
|
|
|
|
ToggleFullscreen();
|
|
|
|
}
|
|
|
|
});
|
2022-02-07 02:27:38 +00:00
|
|
|
connect_shortcut(QStringLiteral("Change Adapting Filter"),
|
|
|
|
&GMainWindow::OnToggleAdaptingFilter);
|
|
|
|
connect_shortcut(QStringLiteral("Change Docked Mode"), &GMainWindow::OnToggleDockedMode);
|
|
|
|
connect_shortcut(QStringLiteral("Change GPU Accuracy"), &GMainWindow::OnToggleGpuAccuracy);
|
2023-01-19 14:13:23 +00:00
|
|
|
connect_shortcut(QStringLiteral("Audio Mute/Unmute"), &GMainWindow::OnMute);
|
|
|
|
connect_shortcut(QStringLiteral("Audio Volume Down"), &GMainWindow::OnDecreaseVolume);
|
|
|
|
connect_shortcut(QStringLiteral("Audio Volume Up"), &GMainWindow::OnIncreaseVolume);
|
2021-11-25 02:27:25 +00:00
|
|
|
connect_shortcut(QStringLiteral("Toggle Framerate Limit"), [] {
|
2022-07-16 05:14:00 +00:00
|
|
|
Settings::values.use_speed_limit.SetValue(!Settings::values.use_speed_limit.GetValue());
|
2021-11-25 02:27:25 +00:00
|
|
|
});
|
|
|
|
connect_shortcut(QStringLiteral("Toggle Mouse Panning"), [&] {
|
2023-02-16 19:38:50 +00:00
|
|
|
if (Settings::values.mouse_enabled) {
|
|
|
|
Settings::values.mouse_panning = false;
|
|
|
|
QMessageBox::warning(
|
|
|
|
this, tr("Emulated mouse is enabled"),
|
|
|
|
tr("Real mouse input and mouse panning are incompatible. Please disable the "
|
|
|
|
"emulated mouse in input advanced settings to allow mouse panning."));
|
|
|
|
return;
|
|
|
|
}
|
2021-11-25 02:27:25 +00:00
|
|
|
Settings::values.mouse_panning = !Settings::values.mouse_panning;
|
|
|
|
if (Settings::values.mouse_panning) {
|
|
|
|
render_window->installEventFilter(render_window);
|
|
|
|
render_window->setAttribute(Qt::WA_Hover, true);
|
|
|
|
}
|
|
|
|
});
|
2016-12-19 19:50:58 +00:00
|
|
|
}
|
2014-04-01 02:26:50 +00:00
|
|
|
|
2016-12-19 19:50:58 +00:00
|
|
|
void GMainWindow::SetDefaultUIGeometry() {
|
2020-05-15 20:22:27 +00:00
|
|
|
// geometry: 53% of the window contents are in the upper screen half, 47% in the lower half
|
2022-06-05 22:03:03 +00:00
|
|
|
const QRect screenRect = QGuiApplication::primaryScreen()->geometry();
|
2016-12-19 19:50:58 +00:00
|
|
|
|
|
|
|
const int w = screenRect.width() * 2 / 3;
|
2020-05-15 20:22:27 +00:00
|
|
|
const int h = screenRect.height() * 2 / 3;
|
2016-12-19 19:50:58 +00:00
|
|
|
const int x = (screenRect.x() + screenRect.width()) / 2 - w / 2;
|
2020-05-15 20:22:27 +00:00
|
|
|
const int y = (screenRect.y() + screenRect.height()) / 2 - h * 53 / 100;
|
2016-12-19 19:50:58 +00:00
|
|
|
|
2014-04-01 02:26:50 +00:00
|
|
|
setGeometry(x, y, w, h);
|
2016-12-19 19:50:58 +00:00
|
|
|
}
|
2014-04-01 02:26:50 +00:00
|
|
|
|
2016-12-19 19:50:58 +00:00
|
|
|
void GMainWindow::RestoreUIState() {
|
2022-02-04 04:12:40 +00:00
|
|
|
setWindowFlags(windowFlags() & ~Qt::FramelessWindowHint);
|
2016-01-24 20:23:55 +00:00
|
|
|
restoreGeometry(UISettings::values.geometry);
|
2022-06-01 01:32:04 +00:00
|
|
|
// Work-around because the games list isn't supposed to be full screen
|
|
|
|
if (isFullScreen()) {
|
|
|
|
showNormal();
|
|
|
|
}
|
2016-01-24 20:23:55 +00:00
|
|
|
restoreState(UISettings::values.state);
|
2022-02-04 04:12:40 +00:00
|
|
|
render_window->setWindowFlags(render_window->windowFlags() & ~Qt::FramelessWindowHint);
|
2016-01-24 20:23:55 +00:00
|
|
|
render_window->restoreGeometry(UISettings::values.renderwindow_geometry);
|
2016-04-29 00:17:31 +00:00
|
|
|
#if MICROPROFILE_ENABLED
|
2016-01-24 20:23:55 +00:00
|
|
|
microProfileDialog->restoreGeometry(UISettings::values.microprofile_geometry);
|
2021-06-28 21:32:24 +00:00
|
|
|
microProfileDialog->setVisible(UISettings::values.microprofile_visible.GetValue());
|
2016-04-29 00:17:31 +00:00
|
|
|
#endif
|
2015-09-07 06:51:57 +00:00
|
|
|
|
2016-01-24 20:23:55 +00:00
|
|
|
game_list->LoadInterfaceLayout();
|
2015-09-02 12:56:38 +00:00
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Single_Window_Mode->setChecked(UISettings::values.single_window_mode.GetValue());
|
2014-04-22 03:15:17 +00:00
|
|
|
ToggleWindowMode();
|
2014-04-01 02:26:50 +00:00
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Fullscreen->setChecked(UISettings::values.fullscreen.GetValue());
|
2018-01-16 14:50:33 +00:00
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Display_Dock_Widget_Headers->setChecked(
|
2021-06-28 21:32:24 +00:00
|
|
|
UISettings::values.display_titlebar.GetValue());
|
2021-10-15 19:27:18 +00:00
|
|
|
OnDisplayTitleBars(ui->action_Display_Dock_Widget_Headers->isChecked());
|
2017-02-18 20:09:14 +00:00
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Show_Filter_Bar->setChecked(UISettings::values.show_filter_bar.GetValue());
|
|
|
|
game_list->SetFilterVisible(ui->action_Show_Filter_Bar->isChecked());
|
2017-04-30 02:04:39 +00:00
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Show_Status_Bar->setChecked(UISettings::values.show_status_bar.GetValue());
|
|
|
|
statusBar()->setVisible(ui->action_Show_Status_Bar->isChecked());
|
2018-07-02 17:10:41 +00:00
|
|
|
Debugger::ToggleConsole();
|
2016-12-19 19:50:58 +00:00
|
|
|
}
|
2015-01-06 15:09:30 +00:00
|
|
|
|
2019-09-26 12:54:31 +00:00
|
|
|
void GMainWindow::OnAppFocusStateChanged(Qt::ApplicationState state) {
|
|
|
|
if (state != Qt::ApplicationHidden && state != Qt::ApplicationInactive &&
|
|
|
|
state != Qt::ApplicationActive) {
|
|
|
|
LOG_DEBUG(Frontend, "ApplicationState unusual flag: {} ", state);
|
|
|
|
}
|
2022-02-07 02:46:22 +00:00
|
|
|
if (!emulation_running) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (UISettings::values.pause_when_in_background) {
|
2021-12-05 07:06:56 +00:00
|
|
|
if (emu_thread->IsRunning() &&
|
|
|
|
(state & (Qt::ApplicationHidden | Qt::ApplicationInactive))) {
|
|
|
|
auto_paused = true;
|
|
|
|
OnPauseGame();
|
|
|
|
} else if (!emu_thread->IsRunning() && auto_paused && state == Qt::ApplicationActive) {
|
|
|
|
auto_paused = false;
|
2022-07-15 01:42:56 +00:00
|
|
|
RequestGameResume();
|
2021-12-05 07:06:56 +00:00
|
|
|
OnStartGame();
|
|
|
|
}
|
2019-09-26 12:54:31 +00:00
|
|
|
}
|
2022-02-07 02:46:22 +00:00
|
|
|
if (UISettings::values.mute_when_in_background) {
|
|
|
|
if (!Settings::values.audio_muted &&
|
|
|
|
(state & (Qt::ApplicationHidden | Qt::ApplicationInactive))) {
|
|
|
|
Settings::values.audio_muted = true;
|
|
|
|
auto_muted = true;
|
|
|
|
} else if (auto_muted && state == Qt::ApplicationActive) {
|
|
|
|
Settings::values.audio_muted = false;
|
|
|
|
auto_muted = false;
|
|
|
|
}
|
|
|
|
}
|
2019-09-26 12:54:31 +00:00
|
|
|
}
|
|
|
|
|
2016-12-19 19:50:58 +00:00
|
|
|
void GMainWindow::ConnectWidgetEvents() {
|
2021-06-08 00:22:39 +00:00
|
|
|
connect(game_list, &GameList::BootGame, this, &GMainWindow::BootGame);
|
2018-01-19 01:03:13 +00:00
|
|
|
connect(game_list, &GameList::GameChosen, this, &GMainWindow::OnGameListLoadFile);
|
2019-05-01 21:21:04 +00:00
|
|
|
connect(game_list, &GameList::OpenDirectory, this, &GMainWindow::OnGameListOpenDirectory);
|
2018-08-21 04:46:40 +00:00
|
|
|
connect(game_list, &GameList::OpenFolderRequested, this, &GMainWindow::OnGameListOpenFolder);
|
2019-02-08 08:05:51 +00:00
|
|
|
connect(game_list, &GameList::OpenTransferableShaderCacheRequested, this,
|
|
|
|
&GMainWindow::OnTransferableShaderCacheOpenFile);
|
2020-07-17 09:21:26 +00:00
|
|
|
connect(game_list, &GameList::RemoveInstalledEntryRequested, this,
|
|
|
|
&GMainWindow::OnGameListRemoveInstalledEntry);
|
|
|
|
connect(game_list, &GameList::RemoveFileRequested, this, &GMainWindow::OnGameListRemoveFile);
|
2018-09-20 02:09:23 +00:00
|
|
|
connect(game_list, &GameList::DumpRomFSRequested, this, &GMainWindow::OnGameListDumpRomFS);
|
|
|
|
connect(game_list, &GameList::CopyTIDRequested, this, &GMainWindow::OnGameListCopyTID);
|
2018-08-29 13:42:53 +00:00
|
|
|
connect(game_list, &GameList::NavigateToGamedbEntryRequested, this,
|
|
|
|
&GMainWindow::OnGameListNavigateToGamedbEntry);
|
2021-07-29 03:02:29 +00:00
|
|
|
connect(game_list, &GameList::CreateShortcut, this, &GMainWindow::OnGameListCreateShortcut);
|
2019-05-01 21:21:04 +00:00
|
|
|
connect(game_list, &GameList::AddDirectory, this, &GMainWindow::OnGameListAddDirectory);
|
|
|
|
connect(game_list_placeholder, &GameListPlaceholder::AddDirectory, this,
|
|
|
|
&GMainWindow::OnGameListAddDirectory);
|
|
|
|
connect(game_list, &GameList::ShowList, this, &GMainWindow::OnGameListShowList);
|
2021-12-25 19:27:52 +00:00
|
|
|
connect(game_list, &GameList::PopulatingCompleted,
|
|
|
|
[this] { multiplayer_state->UpdateGameList(game_list->GetModel()); });
|
2023-02-16 16:53:42 +00:00
|
|
|
connect(game_list, &GameList::SaveConfig, this, &GMainWindow::OnSaveConfig);
|
2019-05-01 21:21:04 +00:00
|
|
|
|
2018-12-04 18:34:46 +00:00
|
|
|
connect(game_list, &GameList::OpenPerGameGeneralRequested, this,
|
|
|
|
&GMainWindow::OnGameListOpenPerGameProperties);
|
2014-04-01 02:26:50 +00:00
|
|
|
|
2020-07-05 13:29:39 +00:00
|
|
|
connect(this, &GMainWindow::UpdateInstallProgress, this,
|
|
|
|
&GMainWindow::IncrementInstallProgress);
|
|
|
|
|
2018-01-19 01:03:13 +00:00
|
|
|
connect(this, &GMainWindow::EmulationStarting, render_window,
|
|
|
|
&GRenderWindow::OnEmulationStarting);
|
|
|
|
connect(this, &GMainWindow::EmulationStopping, render_window,
|
|
|
|
&GRenderWindow::OnEmulationStopping);
|
2017-02-19 22:34:47 +00:00
|
|
|
|
2021-03-27 19:15:32 +00:00
|
|
|
// Software Keyboard Applet
|
|
|
|
connect(this, &GMainWindow::EmulationStarting, this, &GMainWindow::SoftwareKeyboardExit);
|
|
|
|
connect(this, &GMainWindow::EmulationStopping, this, &GMainWindow::SoftwareKeyboardExit);
|
|
|
|
|
2017-02-19 22:34:47 +00:00
|
|
|
connect(&status_bar_update_timer, &QTimer::timeout, this, &GMainWindow::UpdateStatusBar);
|
2021-12-25 19:27:52 +00:00
|
|
|
|
|
|
|
connect(this, &GMainWindow::UpdateThemedIcons, multiplayer_state,
|
|
|
|
&MultiplayerState::UpdateThemedIcons);
|
2014-04-01 02:26:50 +00:00
|
|
|
}
|
|
|
|
|
2017-02-18 10:26:57 +00:00
|
|
|
void GMainWindow::ConnectMenuEvents() {
|
2021-11-25 02:27:25 +00:00
|
|
|
const auto connect_menu = [&]<typename Fn>(QAction* action, const Fn& event_fn) {
|
|
|
|
connect(action, &QAction::triggered, this, event_fn);
|
|
|
|
// Add actions to this window so that hiding menus in fullscreen won't disable them
|
|
|
|
addAction(action);
|
|
|
|
// Add actions to the render window so that they work outside of single window mode
|
|
|
|
render_window->addAction(action);
|
|
|
|
};
|
|
|
|
|
2017-02-18 10:26:57 +00:00
|
|
|
// File
|
2021-11-25 02:27:25 +00:00
|
|
|
connect_menu(ui->action_Load_File, &GMainWindow::OnMenuLoadFile);
|
|
|
|
connect_menu(ui->action_Load_Folder, &GMainWindow::OnMenuLoadFolder);
|
|
|
|
connect_menu(ui->action_Install_File_NAND, &GMainWindow::OnMenuInstallToNAND);
|
|
|
|
connect_menu(ui->action_Exit, &QMainWindow::close);
|
|
|
|
connect_menu(ui->action_Load_Amiibo, &GMainWindow::OnLoadAmiibo);
|
2017-02-18 10:26:57 +00:00
|
|
|
|
|
|
|
// Emulation
|
2021-11-25 02:27:25 +00:00
|
|
|
connect_menu(ui->action_Pause, &GMainWindow::OnPauseContinueGame);
|
|
|
|
connect_menu(ui->action_Stop, &GMainWindow::OnStopGame);
|
|
|
|
connect_menu(ui->action_Report_Compatibility, &GMainWindow::OnMenuReportCompatibility);
|
|
|
|
connect_menu(ui->action_Open_Mods_Page, &GMainWindow::OnOpenModsPage);
|
|
|
|
connect_menu(ui->action_Open_Quickstart_Guide, &GMainWindow::OnOpenQuickstartGuide);
|
|
|
|
connect_menu(ui->action_Open_FAQ, &GMainWindow::OnOpenFAQ);
|
|
|
|
connect_menu(ui->action_Restart, &GMainWindow::OnRestartGame);
|
|
|
|
connect_menu(ui->action_Configure, &GMainWindow::OnConfigure);
|
|
|
|
connect_menu(ui->action_Configure_Current_Game, &GMainWindow::OnConfigurePerGame);
|
2017-02-18 10:26:57 +00:00
|
|
|
|
|
|
|
// View
|
2021-11-25 02:27:25 +00:00
|
|
|
connect_menu(ui->action_Fullscreen, &GMainWindow::ToggleFullscreen);
|
|
|
|
connect_menu(ui->action_Single_Window_Mode, &GMainWindow::ToggleWindowMode);
|
|
|
|
connect_menu(ui->action_Display_Dock_Widget_Headers, &GMainWindow::OnDisplayTitleBars);
|
|
|
|
connect_menu(ui->action_Show_Filter_Bar, &GMainWindow::OnToggleFilterBar);
|
2021-11-15 23:57:41 +00:00
|
|
|
connect_menu(ui->action_Show_Status_Bar, &GMainWindow::OnToggleStatusBar);
|
2021-10-11 01:04:58 +00:00
|
|
|
|
2021-11-25 02:27:25 +00:00
|
|
|
connect_menu(ui->action_Reset_Window_Size_720, &GMainWindow::ResetWindowSize720);
|
|
|
|
connect_menu(ui->action_Reset_Window_Size_900, &GMainWindow::ResetWindowSize900);
|
|
|
|
connect_menu(ui->action_Reset_Window_Size_1080, &GMainWindow::ResetWindowSize1080);
|
|
|
|
ui->menu_Reset_Window_Size->addActions({ui->action_Reset_Window_Size_720,
|
|
|
|
ui->action_Reset_Window_Size_900,
|
|
|
|
ui->action_Reset_Window_Size_1080});
|
2018-01-14 18:15:45 +00:00
|
|
|
|
2021-12-25 19:27:52 +00:00
|
|
|
// Multiplayer
|
|
|
|
connect(ui->action_View_Lobby, &QAction::triggered, multiplayer_state,
|
|
|
|
&MultiplayerState::OnViewLobby);
|
|
|
|
connect(ui->action_Start_Room, &QAction::triggered, multiplayer_state,
|
|
|
|
&MultiplayerState::OnCreateRoom);
|
|
|
|
connect(ui->action_Leave_Room, &QAction::triggered, multiplayer_state,
|
|
|
|
&MultiplayerState::OnCloseRoom);
|
|
|
|
connect(ui->action_Connect_To_Room, &QAction::triggered, multiplayer_state,
|
|
|
|
&MultiplayerState::OnDirectConnectToRoom);
|
|
|
|
connect(ui->action_Show_Room, &QAction::triggered, multiplayer_state,
|
|
|
|
&MultiplayerState::OnOpenNetworkRoom);
|
2022-09-09 20:29:22 +00:00
|
|
|
connect(multiplayer_state, &MultiplayerState::SaveConfig, this, &GMainWindow::OnSaveConfig);
|
2021-12-25 19:27:52 +00:00
|
|
|
|
2021-11-22 01:28:47 +00:00
|
|
|
// Tools
|
2021-11-25 02:27:25 +00:00
|
|
|
connect_menu(ui->action_Rederive, std::bind(&GMainWindow::OnReinitializeKeys, this,
|
|
|
|
ReinitializeKeyBehavior::Warning));
|
|
|
|
connect_menu(ui->action_Capture_Screenshot, &GMainWindow::OnCaptureScreenshot);
|
2018-08-31 06:16:16 +00:00
|
|
|
|
2021-11-22 01:28:47 +00:00
|
|
|
// TAS
|
2021-11-25 02:27:25 +00:00
|
|
|
connect_menu(ui->action_TAS_Start, &GMainWindow::OnTasStartStop);
|
|
|
|
connect_menu(ui->action_TAS_Record, &GMainWindow::OnTasRecord);
|
|
|
|
connect_menu(ui->action_TAS_Reset, &GMainWindow::OnTasReset);
|
|
|
|
connect_menu(ui->action_Configure_Tas, &GMainWindow::OnConfigureTas);
|
2021-11-22 01:28:47 +00:00
|
|
|
|
2018-01-14 18:15:45 +00:00
|
|
|
// Help
|
2021-11-25 02:27:25 +00:00
|
|
|
connect_menu(ui->action_Open_yuzu_Folder, &GMainWindow::OnOpenYuzuFolder);
|
|
|
|
connect_menu(ui->action_About, &GMainWindow::OnAbout);
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::UpdateMenuState() {
|
|
|
|
const bool is_paused = emu_thread == nullptr || !emu_thread->IsRunning();
|
|
|
|
|
|
|
|
const std::array running_actions{
|
|
|
|
ui->action_Stop,
|
|
|
|
ui->action_Restart,
|
|
|
|
ui->action_Configure_Current_Game,
|
|
|
|
ui->action_Report_Compatibility,
|
|
|
|
ui->action_Load_Amiibo,
|
|
|
|
ui->action_Pause,
|
|
|
|
};
|
|
|
|
|
|
|
|
for (QAction* action : running_actions) {
|
|
|
|
action->setEnabled(emulation_running);
|
|
|
|
}
|
|
|
|
|
|
|
|
ui->action_Capture_Screenshot->setEnabled(emulation_running && !is_paused);
|
|
|
|
|
|
|
|
if (emulation_running && is_paused) {
|
|
|
|
ui->action_Pause->setText(tr("&Continue"));
|
|
|
|
} else {
|
|
|
|
ui->action_Pause->setText(tr("&Pause"));
|
|
|
|
}
|
2022-09-09 20:29:22 +00:00
|
|
|
|
|
|
|
multiplayer_state->UpdateNotificationStatus();
|
2017-02-18 10:26:57 +00:00
|
|
|
}
|
|
|
|
|
2016-09-18 00:38:01 +00:00
|
|
|
void GMainWindow::OnDisplayTitleBars(bool show) {
|
2015-01-06 15:09:30 +00:00
|
|
|
QList<QDockWidget*> widgets = findChildren<QDockWidget*>();
|
|
|
|
|
|
|
|
if (show) {
|
2016-09-18 00:38:01 +00:00
|
|
|
for (QDockWidget* widget : widgets) {
|
2015-01-06 15:09:30 +00:00
|
|
|
QWidget* old = widget->titleBarWidget();
|
|
|
|
widget->setTitleBarWidget(nullptr);
|
|
|
|
if (old != nullptr)
|
|
|
|
delete old;
|
|
|
|
}
|
|
|
|
} else {
|
2016-09-18 00:38:01 +00:00
|
|
|
for (QDockWidget* widget : widgets) {
|
2015-01-06 15:09:30 +00:00
|
|
|
QWidget* old = widget->titleBarWidget();
|
|
|
|
widget->setTitleBarWidget(new QWidget());
|
|
|
|
if (old != nullptr)
|
|
|
|
delete old;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-27 23:46:03 +00:00
|
|
|
void GMainWindow::SetupPrepareForSleep() {
|
2022-11-04 12:12:46 +00:00
|
|
|
#ifdef __unix__
|
2022-07-27 23:46:03 +00:00
|
|
|
auto bus = QDBusConnection::systemBus();
|
|
|
|
if (bus.isConnected()) {
|
|
|
|
const bool success = bus.connect(
|
|
|
|
QStringLiteral("org.freedesktop.login1"), QStringLiteral("/org/freedesktop/login1"),
|
|
|
|
QStringLiteral("org.freedesktop.login1.Manager"), QStringLiteral("PrepareForSleep"),
|
|
|
|
QStringLiteral("b"), this, SLOT(OnPrepareForSleep(bool)));
|
|
|
|
|
|
|
|
if (!success) {
|
|
|
|
LOG_WARNING(Frontend, "Couldn't register PrepareForSleep signal");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
LOG_WARNING(Frontend, "QDBusConnection system bus is not connected");
|
|
|
|
}
|
2022-11-04 12:12:46 +00:00
|
|
|
#endif // __unix__
|
2022-07-27 23:46:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnPrepareForSleep(bool prepare_sleep) {
|
|
|
|
if (emu_thread == nullptr) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prepare_sleep) {
|
|
|
|
if (emu_thread->IsRunning()) {
|
|
|
|
auto_paused = true;
|
|
|
|
OnPauseGame();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!emu_thread->IsRunning() && auto_paused) {
|
|
|
|
auto_paused = false;
|
|
|
|
RequestGameResume();
|
|
|
|
OnStartGame();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-04 12:12:46 +00:00
|
|
|
#ifdef __unix__
|
2022-07-27 19:51:26 +00:00
|
|
|
std::array<int, 3> GMainWindow::sig_interrupt_fds{0, 0, 0};
|
|
|
|
|
|
|
|
void GMainWindow::SetupSigInterrupts() {
|
|
|
|
if (sig_interrupt_fds[2] == 1) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
socketpair(AF_UNIX, SOCK_STREAM, 0, sig_interrupt_fds.data());
|
|
|
|
sig_interrupt_fds[2] = 1;
|
|
|
|
|
|
|
|
struct sigaction sa;
|
|
|
|
sa.sa_handler = &GMainWindow::HandleSigInterrupt;
|
|
|
|
sigemptyset(&sa.sa_mask);
|
|
|
|
sa.sa_flags = SA_RESETHAND;
|
|
|
|
sigaction(SIGINT, &sa, nullptr);
|
|
|
|
sigaction(SIGTERM, &sa, nullptr);
|
|
|
|
|
|
|
|
sig_interrupt_notifier = new QSocketNotifier(sig_interrupt_fds[1], QSocketNotifier::Read, this);
|
|
|
|
connect(sig_interrupt_notifier, &QSocketNotifier::activated, this,
|
|
|
|
&GMainWindow::OnSigInterruptNotifierActivated);
|
|
|
|
connect(this, &GMainWindow::SigInterrupt, this, &GMainWindow::close);
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::HandleSigInterrupt(int sig) {
|
|
|
|
if (sig == SIGINT) {
|
2022-12-17 20:54:34 +00:00
|
|
|
_exit(1);
|
2022-07-27 19:51:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Calling into Qt directly from a signal handler is not safe,
|
|
|
|
// so wake up a QSocketNotifier with this hacky write call instead.
|
|
|
|
char a = 1;
|
|
|
|
int ret = write(sig_interrupt_fds[0], &a, sizeof(a));
|
|
|
|
(void)ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnSigInterruptNotifierActivated() {
|
|
|
|
sig_interrupt_notifier->setEnabled(false);
|
|
|
|
|
|
|
|
char a;
|
|
|
|
int ret = read(sig_interrupt_fds[1], &a, sizeof(a));
|
|
|
|
(void)ret;
|
|
|
|
|
|
|
|
sig_interrupt_notifier->setEnabled(true);
|
|
|
|
|
|
|
|
emit SigInterrupt();
|
|
|
|
}
|
2022-11-04 12:12:46 +00:00
|
|
|
#endif // __unix__
|
2021-12-21 09:47:24 +00:00
|
|
|
|
2019-09-03 21:00:34 +00:00
|
|
|
void GMainWindow::PreventOSSleep() {
|
|
|
|
#ifdef _WIN32
|
|
|
|
SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED);
|
2021-10-30 05:21:26 +00:00
|
|
|
#elif defined(HAVE_SDL2)
|
|
|
|
SDL_DisableScreenSaver();
|
2019-09-03 21:00:34 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::AllowOSSleep() {
|
|
|
|
#ifdef _WIN32
|
|
|
|
SetThreadExecutionState(ES_CONTINUOUS);
|
2021-10-30 05:21:26 +00:00
|
|
|
#elif defined(HAVE_SDL2)
|
|
|
|
SDL_EnableScreenSaver();
|
2019-09-03 21:00:34 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2021-07-20 05:10:05 +00:00
|
|
|
bool GMainWindow::LoadROM(const QString& filename, u64 program_id, std::size_t program_index) {
|
2015-07-28 16:43:18 +00:00
|
|
|
// Shutdown previous session if the emu thread is still active...
|
2022-12-19 04:09:44 +00:00
|
|
|
if (emu_thread != nullptr) {
|
2015-07-28 16:43:18 +00:00
|
|
|
ShutdownGame();
|
2022-12-19 04:09:44 +00:00
|
|
|
}
|
2015-07-28 16:43:18 +00:00
|
|
|
|
2020-01-21 19:40:53 +00:00
|
|
|
if (!render_window->InitRenderTarget()) {
|
2018-05-30 20:38:22 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
system->SetFilesystem(vfs);
|
2016-01-07 19:33:54 +00:00
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
system->SetAppletFrontendSet({
|
2023-06-27 21:55:23 +00:00
|
|
|
std::make_unique<QtAmiiboSettings>(*this), // Amiibo Settings
|
|
|
|
(UISettings::values.controller_applet_disabled.GetValue() == true)
|
|
|
|
? nullptr
|
|
|
|
: std::make_unique<QtControllerSelector>(*this), // Controller Selector
|
|
|
|
std::make_unique<QtErrorDisplay>(*this), // Error Display
|
|
|
|
nullptr, // Mii Editor
|
|
|
|
nullptr, // Parental Controls
|
|
|
|
nullptr, // Photo Viewer
|
|
|
|
std::make_unique<QtProfileSelector>(*this), // Profile Selector
|
|
|
|
std::make_unique<QtSoftwareKeyboard>(*this), // Software Keyboard
|
|
|
|
std::make_unique<QtWebBrowser>(*this), // Web Browser
|
2019-03-11 23:39:48 +00:00
|
|
|
});
|
2018-11-10 01:38:11 +00:00
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
const Core::SystemResultStatus result{
|
2021-10-14 18:32:19 +00:00
|
|
|
system->Load(*render_window, filename.toStdString(), program_id, program_index)};
|
2014-04-04 01:24:07 +00:00
|
|
|
|
2021-06-28 21:32:24 +00:00
|
|
|
const auto drd_callout = (UISettings::values.callout_flags.GetValue() &
|
|
|
|
static_cast<u32>(CalloutFlag::DRDDeprecation)) == 0;
|
2018-09-04 18:44:40 +00:00
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
if (result == Core::SystemResultStatus::Success &&
|
2021-10-14 18:32:19 +00:00
|
|
|
system->GetAppLoader().GetFileType() == Loader::FileType::DeconstructedRomDirectory &&
|
2018-09-04 18:44:40 +00:00
|
|
|
drd_callout) {
|
2021-06-28 21:32:24 +00:00
|
|
|
UISettings::values.callout_flags = UISettings::values.callout_flags.GetValue() |
|
|
|
|
static_cast<u32>(CalloutFlag::DRDDeprecation);
|
2018-08-30 20:59:49 +00:00
|
|
|
QMessageBox::warning(
|
|
|
|
this, tr("Warning Outdated Game Format"),
|
|
|
|
tr("You are using the deconstructed ROM directory format for this game, which is an "
|
|
|
|
"outdated format that has been superseded by others such as NCA, NAX, XCI, or "
|
2018-09-04 18:44:40 +00:00
|
|
|
"NSP. Deconstructed ROM directories lack icons, metadata, and update "
|
|
|
|
"support.<br><br>For an explanation of the various Switch formats yuzu supports, <a "
|
2018-08-30 20:59:49 +00:00
|
|
|
"href='https://yuzu-emu.org/wiki/overview-of-switch-game-formats'>check out our "
|
2018-09-04 18:44:40 +00:00
|
|
|
"wiki</a>. This message will not be shown again."));
|
2018-08-30 20:59:49 +00:00
|
|
|
}
|
|
|
|
|
2021-10-14 22:14:40 +00:00
|
|
|
if (result != Core::SystemResultStatus::Success) {
|
2016-11-05 03:14:38 +00:00
|
|
|
switch (result) {
|
2021-10-14 22:14:40 +00:00
|
|
|
case Core::SystemResultStatus::ErrorGetLoader:
|
2018-07-02 16:13:26 +00:00
|
|
|
LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", filename.toStdString());
|
2016-11-05 03:14:38 +00:00
|
|
|
QMessageBox::critical(this, tr("Error while loading ROM!"),
|
2016-12-17 06:20:47 +00:00
|
|
|
tr("The ROM format is not supported."));
|
2016-11-05 03:14:38 +00:00
|
|
|
break;
|
2021-10-14 22:14:40 +00:00
|
|
|
case Core::SystemResultStatus::ErrorVideoCore:
|
2017-03-09 01:21:31 +00:00
|
|
|
QMessageBox::critical(
|
2018-08-03 16:55:58 +00:00
|
|
|
this, tr("An error occurred initializing the video core."),
|
2021-12-16 05:57:45 +00:00
|
|
|
tr("yuzu has encountered an error while running the video core. "
|
|
|
|
"This is usually caused by outdated GPU drivers, including integrated ones. "
|
2021-12-07 00:17:02 +00:00
|
|
|
"Please see the log for more details. "
|
2017-03-09 01:21:31 +00:00
|
|
|
"For more information on accessing the log, please see the following page: "
|
2021-12-16 05:40:30 +00:00
|
|
|
"<a href='https://yuzu-emu.org/help/reference/log-files/'>"
|
2021-12-07 00:17:02 +00:00
|
|
|
"How to Upload the Log File</a>. "));
|
2017-03-08 21:28:30 +00:00
|
|
|
break;
|
2016-01-07 17:36:10 +00:00
|
|
|
default:
|
2021-10-14 22:14:40 +00:00
|
|
|
if (result > Core::SystemResultStatus::ErrorLoader) {
|
|
|
|
const u16 loader_id = static_cast<u16>(Core::SystemResultStatus::ErrorLoader);
|
2018-08-10 01:06:44 +00:00
|
|
|
const u16 error_id = static_cast<u16>(result) - loader_id;
|
2020-04-14 00:56:22 +00:00
|
|
|
const std::string error_code = fmt::format("({:04X}-{:04X})", loader_id, error_id);
|
|
|
|
LOG_CRITICAL(Frontend, "Failed to load ROM! {}", error_code);
|
2020-12-31 15:28:42 +00:00
|
|
|
|
|
|
|
const auto title =
|
|
|
|
tr("Error while loading ROM! %1", "%1 signifies a numeric error code.")
|
|
|
|
.arg(QString::fromStdString(error_code));
|
|
|
|
const auto description =
|
|
|
|
tr("%1<br>Please follow <a href='https://yuzu-emu.org/help/quickstart/'>the "
|
|
|
|
"yuzu quickstart guide</a> to redump your files.<br>You can refer "
|
|
|
|
"to the yuzu wiki</a> or the yuzu Discord</a> for help.",
|
2021-01-03 18:18:02 +00:00
|
|
|
"%1 signifies an error string.")
|
|
|
|
.arg(QString::fromStdString(
|
|
|
|
GetResultStatusString(static_cast<Loader::ResultStatus>(error_id))));
|
2020-12-31 15:28:42 +00:00
|
|
|
|
|
|
|
QMessageBox::critical(this, title, description);
|
2018-08-10 01:06:44 +00:00
|
|
|
} else {
|
|
|
|
QMessageBox::critical(
|
|
|
|
this, tr("Error while loading ROM!"),
|
|
|
|
tr("An unknown error occurred. Please see the log for more details."));
|
|
|
|
}
|
2016-01-07 17:36:10 +00:00
|
|
|
break;
|
|
|
|
}
|
2016-01-07 19:33:54 +00:00
|
|
|
return false;
|
2014-04-04 01:24:07 +00:00
|
|
|
}
|
2022-05-26 23:57:35 +00:00
|
|
|
current_game_path = filename;
|
2018-08-21 11:12:45 +00:00
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
system->TelemetrySession().AddField(Common::Telemetry::FieldType::App, "Frontend", "Qt");
|
2016-01-07 19:33:54 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2023-03-29 02:55:06 +00:00
|
|
|
bool GMainWindow::SelectAndSetCurrentUser(
|
|
|
|
const Core::Frontend::ProfileSelectParameters& parameters) {
|
|
|
|
QtProfileSelectionDialog dialog(system->HIDCore(), this, parameters);
|
2018-12-25 15:42:02 +00:00
|
|
|
dialog.setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint | Qt::WindowTitleHint |
|
|
|
|
Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint);
|
|
|
|
dialog.setWindowModality(Qt::WindowModal);
|
|
|
|
|
2019-05-29 04:34:42 +00:00
|
|
|
if (dialog.exec() == QDialog::Rejected) {
|
2022-08-05 15:02:04 +00:00
|
|
|
return false;
|
2018-12-25 15:42:02 +00:00
|
|
|
}
|
2019-05-29 04:34:42 +00:00
|
|
|
|
|
|
|
Settings::values.current_user = dialog.GetIndex();
|
2022-08-05 15:02:04 +00:00
|
|
|
return true;
|
2018-12-25 15:42:02 +00:00
|
|
|
}
|
|
|
|
|
2021-07-20 05:10:05 +00:00
|
|
|
void GMainWindow::BootGame(const QString& filename, u64 program_id, std::size_t program_index,
|
|
|
|
StartGameType type) {
|
2018-07-02 16:13:26 +00:00
|
|
|
LOG_INFO(Frontend, "yuzu starting...");
|
2016-03-06 10:22:45 +00:00
|
|
|
StoreRecentFile(filename); // Put the filename on top of the list
|
2016-01-07 19:33:54 +00:00
|
|
|
|
2022-11-18 00:23:48 +00:00
|
|
|
// Save configurations
|
|
|
|
UpdateUISettings();
|
|
|
|
game_list->SaveInterfaceLayout();
|
|
|
|
config->Save();
|
|
|
|
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
u64 title_id{0};
|
2020-11-24 23:18:29 +00:00
|
|
|
|
|
|
|
last_filename_booted = filename;
|
|
|
|
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
const auto v_file = Core::GetGameFileFromPath(vfs, filename.toUtf8().constData());
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto loader = Loader::GetLoader(*system, v_file, program_id, program_index);
|
2020-11-24 23:18:29 +00:00
|
|
|
|
2021-06-08 00:22:39 +00:00
|
|
|
if (loader != nullptr && loader->ReadProgramId(title_id) == Loader::ResultStatus::Success &&
|
|
|
|
type == StartGameType::Normal) {
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
// Load per game settings
|
2022-05-15 22:09:19 +00:00
|
|
|
const auto file_path =
|
|
|
|
std::filesystem::path{Common::U16StringFromBuffer(filename.utf16(), filename.size())};
|
2021-05-26 01:39:57 +00:00
|
|
|
const auto config_file_name = title_id == 0
|
2021-06-02 19:05:45 +00:00
|
|
|
? Common::FS::PathToUTF8String(file_path.filename())
|
2021-05-26 01:39:57 +00:00
|
|
|
: fmt::format("{:016X}", title_id);
|
2022-07-10 15:29:10 +00:00
|
|
|
Config per_game_config(config_file_name, Config::ConfigType::PerGameConfig);
|
2022-11-19 20:39:09 +00:00
|
|
|
system->HIDCore().ReloadInputDevices();
|
2022-07-10 15:29:10 +00:00
|
|
|
system->ApplySettings();
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Settings::LogSettings();
|
|
|
|
|
2018-12-25 15:42:02 +00:00
|
|
|
if (UISettings::values.select_user_on_boot) {
|
2023-03-29 02:55:06 +00:00
|
|
|
const Core::Frontend::ProfileSelectParameters parameters{
|
|
|
|
.mode = Service::AM::Applets::UiMode::UserSelector,
|
|
|
|
.invalid_uid_list = {},
|
|
|
|
.display_options = {},
|
|
|
|
.purpose = Service::AM::Applets::UserSelectionPurpose::General,
|
|
|
|
};
|
|
|
|
if (SelectAndSetCurrentUser(parameters) == false) {
|
2022-08-05 15:02:04 +00:00
|
|
|
return;
|
|
|
|
}
|
2018-12-25 15:42:02 +00:00
|
|
|
}
|
2016-01-07 19:33:54 +00:00
|
|
|
|
2022-08-05 15:02:04 +00:00
|
|
|
if (!LoadROM(filename, program_id, program_index)) {
|
2016-01-07 19:33:54 +00:00
|
|
|
return;
|
2022-08-05 15:02:04 +00:00
|
|
|
}
|
2016-01-07 19:33:54 +00:00
|
|
|
|
2022-07-16 22:48:45 +00:00
|
|
|
system->SetShuttingDown(false);
|
2023-05-28 16:14:41 +00:00
|
|
|
game_list->setDisabled(true);
|
2022-07-16 22:48:45 +00:00
|
|
|
|
2015-04-29 04:01:41 +00:00
|
|
|
// Create and start the emulation thread
|
2021-10-14 18:32:19 +00:00
|
|
|
emu_thread = std::make_unique<EmuThread>(*system);
|
2015-04-30 23:46:50 +00:00
|
|
|
emit EmulationStarting(emu_thread.get());
|
2015-04-16 22:35:09 +00:00
|
|
|
emu_thread->start();
|
2014-04-22 03:15:17 +00:00
|
|
|
|
2020-11-24 23:18:29 +00:00
|
|
|
// Register an ExecuteProgram callback such that Core can execute a sub-program
|
2021-10-14 18:32:19 +00:00
|
|
|
system->RegisterExecuteProgramCallback(
|
2022-06-14 18:09:45 +00:00
|
|
|
[this](std::size_t program_index_) { render_window->ExecuteProgram(program_index_); });
|
2020-11-24 23:18:29 +00:00
|
|
|
|
2022-12-22 00:55:01 +00:00
|
|
|
system->RegisterExitCallback([this] {
|
|
|
|
emu_thread->ForceStop();
|
|
|
|
render_window->Exit();
|
|
|
|
});
|
|
|
|
|
2018-01-19 01:03:13 +00:00
|
|
|
connect(render_window, &GRenderWindow::Closed, this, &GMainWindow::OnStopGame);
|
2020-12-30 19:41:14 +00:00
|
|
|
connect(render_window, &GRenderWindow::MouseActivity, this, &GMainWindow::OnMouseActivity);
|
2016-09-18 00:38:01 +00:00
|
|
|
// BlockingQueuedConnection is important here, it makes sure we've finished refreshing our views
|
|
|
|
// before the CPU continues
|
2018-01-19 01:03:13 +00:00
|
|
|
connect(emu_thread.get(), &EmuThread::DebugModeEntered, waitTreeWidget,
|
|
|
|
&WaitTreeWidget::OnDebugModeEntered, Qt::BlockingQueuedConnection);
|
|
|
|
connect(emu_thread.get(), &EmuThread::DebugModeLeft, waitTreeWidget,
|
|
|
|
&WaitTreeWidget::OnDebugModeLeft, Qt::BlockingQueuedConnection);
|
2015-04-29 04:01:41 +00:00
|
|
|
|
2019-01-21 19:38:23 +00:00
|
|
|
connect(emu_thread.get(), &EmuThread::LoadProgress, loading_screen,
|
|
|
|
&LoadingScreen::OnLoadProgress, Qt::QueuedConnection);
|
|
|
|
|
2015-04-29 04:01:41 +00:00
|
|
|
// Update the GUI
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
UpdateStatusButtons();
|
2021-10-15 19:27:18 +00:00
|
|
|
if (ui->action_Single_Window_Mode->isChecked()) {
|
2015-09-01 04:35:33 +00:00
|
|
|
game_list->hide();
|
2019-05-01 21:21:04 +00:00
|
|
|
game_list_placeholder->hide();
|
2015-09-01 04:35:33 +00:00
|
|
|
}
|
2021-05-16 00:34:20 +00:00
|
|
|
status_bar_update_timer.start(500);
|
2020-01-28 22:59:30 +00:00
|
|
|
renderer_status_button->setDisabled(true);
|
2017-02-19 22:34:47 +00:00
|
|
|
|
2021-02-03 18:34:25 +00:00
|
|
|
if (UISettings::values.hide_mouse || Settings::values.mouse_panning) {
|
2020-12-30 19:41:14 +00:00
|
|
|
render_window->installEventFilter(render_window);
|
|
|
|
render_window->setAttribute(Qt::WA_Hover, true);
|
2020-04-11 02:22:50 +00:00
|
|
|
}
|
|
|
|
|
2021-02-24 02:39:02 +00:00
|
|
|
if (UISettings::values.hide_mouse) {
|
|
|
|
mouse_hide_timer.start();
|
|
|
|
}
|
|
|
|
|
2022-06-19 04:34:28 +00:00
|
|
|
render_window->InitializeCamera();
|
|
|
|
|
2018-08-23 18:12:56 +00:00
|
|
|
std::string title_name;
|
2020-06-08 21:58:04 +00:00
|
|
|
std::string title_version;
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto res = system->GetGameName(title_name);
|
2018-09-03 22:57:52 +00:00
|
|
|
|
2021-09-03 01:40:55 +00:00
|
|
|
const auto metadata = [this, title_id] {
|
2021-10-14 18:32:19 +00:00
|
|
|
const FileSys::PatchManager pm(title_id, system->GetFileSystemController(),
|
|
|
|
system->GetContentProvider());
|
2020-11-18 12:53:10 +00:00
|
|
|
return pm.GetControlMetadata();
|
|
|
|
}();
|
2020-06-08 21:58:04 +00:00
|
|
|
if (metadata.first != nullptr) {
|
|
|
|
title_version = metadata.first->GetVersionString();
|
|
|
|
title_name = metadata.first->GetApplicationName();
|
2018-09-03 22:57:52 +00:00
|
|
|
}
|
2020-06-08 21:58:04 +00:00
|
|
|
if (res != Loader::ResultStatus::Success || title_name.empty()) {
|
2021-05-25 23:32:56 +00:00
|
|
|
title_name = Common::FS::PathToUTF8String(
|
2022-05-15 22:09:19 +00:00
|
|
|
std::filesystem::path{Common::U16StringFromBuffer(filename.utf16(), filename.size())}
|
|
|
|
.filename());
|
2020-06-08 21:58:04 +00:00
|
|
|
}
|
2023-02-13 16:21:43 +00:00
|
|
|
const bool is_64bit = system->Kernel().ApplicationProcess()->Is64BitProcess();
|
2021-07-08 19:06:14 +00:00
|
|
|
const auto instruction_set_suffix = is_64bit ? tr("(64-bit)") : tr("(32-bit)");
|
|
|
|
title_name = tr("%1 %2", "%1 is the title name. %2 indicates if the title is 64-bit or 32-bit")
|
|
|
|
.arg(QString::fromStdString(title_name), instruction_set_suffix)
|
|
|
|
.toStdString();
|
2020-06-08 21:58:04 +00:00
|
|
|
LOG_INFO(Frontend, "Booting game: {:016X} | {} | {}", title_id, title_name, title_version);
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto gpu_vendor = system->GPU().Renderer().GetDeviceVendor();
|
2021-06-20 21:26:55 +00:00
|
|
|
UpdateWindowTitle(title_name, title_version, gpu_vendor);
|
2018-08-23 18:12:56 +00:00
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
loading_screen->Prepare(system->GetAppLoader());
|
2019-01-17 07:01:00 +00:00
|
|
|
loading_screen->show();
|
2015-04-29 04:01:41 +00:00
|
|
|
|
2015-09-01 01:30:06 +00:00
|
|
|
emulation_running = true;
|
2021-10-15 19:27:18 +00:00
|
|
|
if (ui->action_Fullscreen->isChecked()) {
|
2018-01-16 14:59:30 +00:00
|
|
|
ShowFullscreen();
|
|
|
|
}
|
2014-10-31 05:44:51 +00:00
|
|
|
OnStartGame();
|
2014-04-01 02:26:50 +00:00
|
|
|
}
|
|
|
|
|
2022-12-24 22:31:34 +00:00
|
|
|
bool GMainWindow::OnShutdownBegin() {
|
2020-03-28 01:31:35 +00:00
|
|
|
if (!emulation_running) {
|
2022-12-24 22:31:34 +00:00
|
|
|
return false;
|
2020-03-28 01:31:35 +00:00
|
|
|
}
|
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
if (ui->action_Fullscreen->isChecked()) {
|
2020-03-28 01:31:35 +00:00
|
|
|
HideFullscreen();
|
|
|
|
}
|
|
|
|
|
2019-09-03 21:00:34 +00:00
|
|
|
AllowOSSleep();
|
|
|
|
|
2022-12-13 01:21:30 +00:00
|
|
|
// Disable unlimited frame rate
|
|
|
|
Settings::values.use_speed_limit.SetValue(true);
|
|
|
|
|
2022-12-24 22:31:34 +00:00
|
|
|
if (system->IsShuttingDown()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-07-16 22:48:45 +00:00
|
|
|
system->SetShuttingDown(true);
|
2018-09-16 18:05:51 +00:00
|
|
|
discord_rpc->Pause();
|
2022-07-18 07:41:29 +00:00
|
|
|
|
|
|
|
RequestGameExit();
|
2022-12-17 19:34:03 +00:00
|
|
|
emu_thread->disconnect();
|
|
|
|
emu_thread->SetRunning(true);
|
2015-04-28 03:13:57 +00:00
|
|
|
|
2015-04-30 23:46:50 +00:00
|
|
|
emit EmulationStopping();
|
2015-04-29 04:01:41 +00:00
|
|
|
|
2022-12-19 04:09:44 +00:00
|
|
|
shutdown_timer.setSingleShot(true);
|
|
|
|
shutdown_timer.start(system->DebuggerEnabled() ? 0 : 5000);
|
|
|
|
connect(&shutdown_timer, &QTimer::timeout, this, &GMainWindow::OnEmulationStopTimeExpired);
|
|
|
|
connect(emu_thread.get(), &QThread::finished, this, &GMainWindow::OnEmulationStopped);
|
|
|
|
|
|
|
|
// Disable everything to prevent anything from being triggered here
|
|
|
|
ui->action_Pause->setEnabled(false);
|
|
|
|
ui->action_Restart->setEnabled(false);
|
|
|
|
ui->action_Stop->setEnabled(false);
|
2022-12-24 22:31:34 +00:00
|
|
|
|
|
|
|
return true;
|
2022-12-19 04:09:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnShutdownBeginDialog() {
|
2022-12-22 00:27:11 +00:00
|
|
|
shutdown_dialog = new OverlayDialog(this, *system, QString{}, tr("Closing software..."),
|
|
|
|
QString{}, QString{}, Qt::AlignHCenter | Qt::AlignVCenter);
|
2022-12-19 04:09:44 +00:00
|
|
|
shutdown_dialog->open();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnEmulationStopTimeExpired() {
|
|
|
|
if (emu_thread) {
|
2022-12-13 02:38:20 +00:00
|
|
|
emu_thread->ForceStop();
|
|
|
|
}
|
2022-12-19 04:09:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnEmulationStopped() {
|
|
|
|
shutdown_timer.stop();
|
2023-01-06 23:50:01 +00:00
|
|
|
if (emu_thread) {
|
|
|
|
emu_thread->disconnect();
|
|
|
|
emu_thread->wait();
|
|
|
|
emu_thread.reset();
|
|
|
|
}
|
2015-04-29 04:01:41 +00:00
|
|
|
|
2022-12-19 04:09:44 +00:00
|
|
|
if (shutdown_dialog) {
|
|
|
|
shutdown_dialog->deleteLater();
|
|
|
|
shutdown_dialog = nullptr;
|
|
|
|
}
|
|
|
|
|
2022-01-01 23:57:43 +00:00
|
|
|
emulation_running = false;
|
|
|
|
|
2018-09-16 18:05:51 +00:00
|
|
|
discord_rpc->Update();
|
|
|
|
|
2015-09-05 10:29:44 +00:00
|
|
|
// The emulation is stopped, so closing the window or not does not matter anymore
|
2018-01-19 01:03:13 +00:00
|
|
|
disconnect(render_window, &GRenderWindow::Closed, this, &GMainWindow::OnStopGame);
|
2015-09-05 10:29:44 +00:00
|
|
|
|
2015-04-28 23:03:01 +00:00
|
|
|
// Update the GUI
|
2021-11-25 02:27:25 +00:00
|
|
|
UpdateMenuState();
|
|
|
|
|
2015-04-28 03:13:57 +00:00
|
|
|
render_window->hide();
|
2019-01-17 07:01:00 +00:00
|
|
|
loading_screen->hide();
|
|
|
|
loading_screen->Clear();
|
2020-09-23 15:28:08 +00:00
|
|
|
if (game_list->IsEmpty()) {
|
2019-05-01 21:21:04 +00:00
|
|
|
game_list_placeholder->show();
|
2020-09-23 15:28:08 +00:00
|
|
|
} else {
|
2019-05-01 21:21:04 +00:00
|
|
|
game_list->show();
|
2020-09-23 15:28:08 +00:00
|
|
|
}
|
|
|
|
game_list->SetFilterFocus();
|
2021-07-26 01:52:19 +00:00
|
|
|
tas_label->clear();
|
|
|
|
input_subsystem->GetTas()->Stop();
|
2021-11-22 01:28:47 +00:00
|
|
|
OnTasStateChanged();
|
2022-06-19 04:34:28 +00:00
|
|
|
render_window->FinalizeCamera();
|
2019-05-09 05:41:33 +00:00
|
|
|
|
2021-12-05 01:37:03 +00:00
|
|
|
// Enable all controllers
|
|
|
|
system->HIDCore().SetSupportedStyleTag({Core::HID::NpadStyleSet::All});
|
|
|
|
|
2020-12-30 19:41:14 +00:00
|
|
|
render_window->removeEventFilter(render_window);
|
|
|
|
render_window->setAttribute(Qt::WA_Hover, false);
|
2020-04-11 02:22:50 +00:00
|
|
|
|
2019-05-09 05:41:33 +00:00
|
|
|
UpdateWindowTitle();
|
2015-09-01 01:30:06 +00:00
|
|
|
|
2017-02-19 22:34:47 +00:00
|
|
|
// Disable status bar updates
|
|
|
|
status_bar_update_timer.stop();
|
2020-07-10 03:36:38 +00:00
|
|
|
shader_building_label->setVisible(false);
|
2021-07-26 05:58:02 +00:00
|
|
|
res_scale_label->setVisible(false);
|
2017-02-19 22:34:47 +00:00
|
|
|
emu_speed_label->setVisible(false);
|
|
|
|
game_fps_label->setVisible(false);
|
|
|
|
emu_frametime_label->setVisible(false);
|
2022-05-28 06:33:23 +00:00
|
|
|
renderer_status_button->setEnabled(!UISettings::values.has_broken_vulkan);
|
2017-02-19 22:34:47 +00:00
|
|
|
|
2022-05-26 23:57:35 +00:00
|
|
|
current_game_path.clear();
|
2020-02-17 20:49:52 +00:00
|
|
|
|
|
|
|
// When closing the game, destroy the GLWindow to clear the context after the game is closed
|
|
|
|
render_window->ReleaseRenderTarget();
|
2022-12-19 04:09:44 +00:00
|
|
|
|
2023-05-28 16:14:41 +00:00
|
|
|
// Enable game list
|
|
|
|
game_list->setEnabled(true);
|
|
|
|
|
2022-12-19 04:09:44 +00:00
|
|
|
Settings::RestoreGlobalState(system->IsPoweredOn());
|
|
|
|
system->HIDCore().ReloadInputDevices();
|
|
|
|
UpdateStatusButtons();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::ShutdownGame() {
|
|
|
|
if (!emulation_running) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
OnShutdownBegin();
|
|
|
|
OnEmulationStopTimeExpired();
|
|
|
|
OnEmulationStopped();
|
2015-04-28 03:13:57 +00:00
|
|
|
}
|
|
|
|
|
2017-02-17 06:32:22 +00:00
|
|
|
void GMainWindow::StoreRecentFile(const QString& filename) {
|
|
|
|
UISettings::values.recent_files.prepend(filename);
|
2016-01-24 20:23:55 +00:00
|
|
|
UISettings::values.recent_files.removeDuplicates();
|
|
|
|
while (UISettings::values.recent_files.size() > max_recent_files_item) {
|
|
|
|
UISettings::values.recent_files.removeLast();
|
2015-09-08 01:00:08 +00:00
|
|
|
}
|
|
|
|
|
2015-08-17 20:50:52 +00:00
|
|
|
UpdateRecentFiles();
|
|
|
|
}
|
|
|
|
|
2015-07-28 16:43:18 +00:00
|
|
|
void GMainWindow::UpdateRecentFiles() {
|
2018-08-06 18:30:04 +00:00
|
|
|
const int num_recent_files =
|
2022-05-12 14:03:37 +00:00
|
|
|
std::min(static_cast<int>(UISettings::values.recent_files.size()), max_recent_files_item);
|
2015-07-28 16:43:18 +00:00
|
|
|
|
2018-08-06 18:30:04 +00:00
|
|
|
for (int i = 0; i < num_recent_files; i++) {
|
2019-05-24 23:44:06 +00:00
|
|
|
const QString text = QStringLiteral("&%1. %2").arg(i + 1).arg(
|
2016-09-18 00:38:01 +00:00
|
|
|
QFileInfo(UISettings::values.recent_files[i]).fileName());
|
2015-07-28 16:43:18 +00:00
|
|
|
actions_recent_files[i]->setText(text);
|
2016-01-24 20:23:55 +00:00
|
|
|
actions_recent_files[i]->setData(UISettings::values.recent_files[i]);
|
|
|
|
actions_recent_files[i]->setToolTip(UISettings::values.recent_files[i]);
|
2015-07-28 16:43:18 +00:00
|
|
|
actions_recent_files[i]->setVisible(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int j = num_recent_files; j < max_recent_files_item; ++j) {
|
|
|
|
actions_recent_files[j]->setVisible(false);
|
|
|
|
}
|
|
|
|
|
2018-08-06 18:28:01 +00:00
|
|
|
// Enable the recent files menu if the list isn't empty
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->menu_recent_files->setEnabled(num_recent_files != 0);
|
2015-07-28 16:43:18 +00:00
|
|
|
}
|
|
|
|
|
2021-07-20 05:10:05 +00:00
|
|
|
void GMainWindow::OnGameListLoadFile(QString game_path, u64 program_id) {
|
|
|
|
BootGame(game_path, program_id);
|
2015-09-01 04:35:33 +00:00
|
|
|
}
|
|
|
|
|
2020-07-19 11:14:46 +00:00
|
|
|
void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target,
|
|
|
|
const std::string& game_path) {
|
2021-05-25 23:32:56 +00:00
|
|
|
std::filesystem::path path;
|
2019-05-24 23:44:06 +00:00
|
|
|
QString open_target;
|
2020-04-14 19:08:13 +00:00
|
|
|
|
2021-09-03 01:40:55 +00:00
|
|
|
const auto [user_save_size, device_save_size] = [this, &game_path, &program_id] {
|
2021-10-14 18:32:19 +00:00
|
|
|
const FileSys::PatchManager pm{program_id, system->GetFileSystemController(),
|
|
|
|
system->GetContentProvider()};
|
2020-07-20 03:52:06 +00:00
|
|
|
const auto control = pm.GetControlMetadata().first;
|
|
|
|
if (control != nullptr) {
|
|
|
|
return std::make_pair(control->GetDefaultNormalSaveSize(),
|
|
|
|
control->GetDeviceSaveDataSize());
|
|
|
|
} else {
|
|
|
|
const auto file = Core::GetGameFileFromPath(vfs, game_path);
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto loader = Loader::GetLoader(*system, file);
|
2020-04-14 19:08:13 +00:00
|
|
|
|
2020-07-20 03:52:06 +00:00
|
|
|
FileSys::NACP nacp{};
|
|
|
|
loader->ReadControlData(nacp);
|
|
|
|
return std::make_pair(nacp.GetDefaultNormalSaveSize(), nacp.GetDeviceSaveDataSize());
|
|
|
|
}
|
|
|
|
}();
|
2020-04-14 19:08:13 +00:00
|
|
|
|
2020-07-20 03:52:06 +00:00
|
|
|
const bool has_user_save{user_save_size > 0};
|
|
|
|
const bool has_device_save{device_save_size > 0};
|
2020-04-14 19:08:13 +00:00
|
|
|
|
|
|
|
ASSERT_MSG(has_user_save != has_device_save, "Game uses both user and device savedata?");
|
|
|
|
|
2018-08-21 04:46:40 +00:00
|
|
|
switch (target) {
|
|
|
|
case GameListOpenTarget::SaveData: {
|
2019-05-24 23:44:06 +00:00
|
|
|
open_target = tr("Save Data");
|
2021-05-25 23:32:56 +00:00
|
|
|
const auto nand_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir);
|
2022-10-17 02:58:44 +00:00
|
|
|
auto vfs_nand_dir =
|
|
|
|
vfs->OpenDirectory(Common::FS::PathToUTF8String(nand_dir), FileSys::Mode::Read);
|
2018-10-10 01:53:26 +00:00
|
|
|
|
2020-04-14 19:08:13 +00:00
|
|
|
if (has_user_save) {
|
|
|
|
// User save data
|
|
|
|
const auto select_profile = [this] {
|
2023-03-29 02:55:06 +00:00
|
|
|
const Core::Frontend::ProfileSelectParameters parameters{
|
|
|
|
.mode = Service::AM::Applets::UiMode::UserSelector,
|
|
|
|
.invalid_uid_list = {},
|
|
|
|
.display_options = {},
|
|
|
|
.purpose = Service::AM::Applets::UserSelectionPurpose::General,
|
|
|
|
};
|
|
|
|
QtProfileSelectionDialog dialog(system->HIDCore(), this, parameters);
|
2020-04-14 19:08:13 +00:00
|
|
|
dialog.setWindowFlags(Qt::Dialog | Qt::CustomizeWindowHint | Qt::WindowTitleHint |
|
|
|
|
Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint);
|
|
|
|
dialog.setWindowModality(Qt::WindowModal);
|
2018-12-25 15:52:43 +00:00
|
|
|
|
2020-04-14 19:08:13 +00:00
|
|
|
if (dialog.exec() == QDialog::Rejected) {
|
|
|
|
return -1;
|
|
|
|
}
|
2018-10-10 01:53:26 +00:00
|
|
|
|
2020-04-14 19:08:13 +00:00
|
|
|
return dialog.GetIndex();
|
|
|
|
};
|
2018-10-10 01:53:26 +00:00
|
|
|
|
2020-04-14 19:08:13 +00:00
|
|
|
const auto index = select_profile();
|
|
|
|
if (index == -1) {
|
|
|
|
return;
|
|
|
|
}
|
2018-10-10 01:53:26 +00:00
|
|
|
|
2020-04-14 19:08:13 +00:00
|
|
|
Service::Account::ProfileManager manager;
|
|
|
|
const auto user_id = manager.GetUser(static_cast<std::size_t>(index));
|
|
|
|
ASSERT(user_id);
|
2021-05-25 23:32:56 +00:00
|
|
|
|
|
|
|
const auto user_save_data_path = FileSys::SaveDataFactory::GetFullPath(
|
2022-10-17 02:58:44 +00:00
|
|
|
*system, vfs_nand_dir, FileSys::SaveDataSpaceId::NandUser,
|
|
|
|
FileSys::SaveDataType::SaveData, program_id, user_id->AsU128(), 0);
|
2021-05-25 23:32:56 +00:00
|
|
|
|
|
|
|
path = Common::FS::ConcatPathSafe(nand_dir, user_save_data_path);
|
2020-04-14 19:08:13 +00:00
|
|
|
} else {
|
|
|
|
// Device save data
|
2021-05-25 23:32:56 +00:00
|
|
|
const auto device_save_data_path = FileSys::SaveDataFactory::GetFullPath(
|
2022-10-17 02:58:44 +00:00
|
|
|
*system, vfs_nand_dir, FileSys::SaveDataSpaceId::NandUser,
|
|
|
|
FileSys::SaveDataType::SaveData, program_id, {}, 0);
|
2021-05-25 23:32:56 +00:00
|
|
|
|
|
|
|
path = Common::FS::ConcatPathSafe(nand_dir, device_save_data_path);
|
2020-04-14 19:08:13 +00:00
|
|
|
}
|
2018-10-10 01:53:26 +00:00
|
|
|
|
2021-05-25 23:32:56 +00:00
|
|
|
if (!Common::FS::CreateDirs(path)) {
|
|
|
|
LOG_ERROR(Frontend, "Unable to create the directories for save data");
|
2018-10-10 01:53:26 +00:00
|
|
|
}
|
|
|
|
|
2018-08-21 04:46:40 +00:00
|
|
|
break;
|
|
|
|
}
|
2018-09-20 02:09:23 +00:00
|
|
|
case GameListOpenTarget::ModData: {
|
2019-05-24 23:44:06 +00:00
|
|
|
open_target = tr("Mod Data");
|
2021-05-25 23:32:56 +00:00
|
|
|
path = Common::FS::GetYuzuPath(Common::FS::YuzuPath::LoadDir) /
|
|
|
|
fmt::format("{:016X}", program_id);
|
2018-09-20 02:09:23 +00:00
|
|
|
break;
|
|
|
|
}
|
2018-08-21 04:46:40 +00:00
|
|
|
default:
|
|
|
|
UNIMPLEMENTED();
|
2022-11-11 12:12:37 +00:00
|
|
|
break;
|
2018-08-21 04:46:40 +00:00
|
|
|
}
|
|
|
|
|
2021-05-25 23:32:56 +00:00
|
|
|
const QString qpath = QString::fromStdString(Common::FS::PathToUTF8String(path));
|
2018-08-21 04:46:40 +00:00
|
|
|
const QDir dir(qpath);
|
|
|
|
if (!dir.exists()) {
|
2019-05-24 23:44:06 +00:00
|
|
|
QMessageBox::warning(this, tr("Error Opening %1 Folder").arg(open_target),
|
2018-08-21 04:46:40 +00:00
|
|
|
tr("Folder does not exist!"));
|
|
|
|
return;
|
|
|
|
}
|
2019-05-24 23:44:06 +00:00
|
|
|
LOG_INFO(Frontend, "Opening {} path for program_id={:016x}", open_target.toStdString(),
|
|
|
|
program_id);
|
2018-08-21 04:46:40 +00:00
|
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(qpath));
|
2016-12-15 09:56:32 +00:00
|
|
|
}
|
|
|
|
|
2019-02-08 08:05:51 +00:00
|
|
|
void GMainWindow::OnTransferableShaderCacheOpenFile(u64 program_id) {
|
2021-05-25 23:32:56 +00:00
|
|
|
const auto shader_cache_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ShaderDir);
|
2021-06-12 20:57:31 +00:00
|
|
|
const auto shader_cache_folder_path{shader_cache_dir / fmt::format("{:016x}", program_id)};
|
2021-07-11 18:39:13 +00:00
|
|
|
if (!Common::FS::CreateDirs(shader_cache_folder_path)) {
|
2019-04-04 04:06:32 +00:00
|
|
|
QMessageBox::warning(this, tr("Error Opening Transferable Shader Cache"),
|
2021-10-16 16:53:06 +00:00
|
|
|
tr("Failed to create the shader cache directory for this title."));
|
2019-02-08 08:05:51 +00:00
|
|
|
return;
|
|
|
|
}
|
2021-06-12 20:57:31 +00:00
|
|
|
const auto shader_path_string{Common::FS::PathToUTF8String(shader_cache_folder_path)};
|
|
|
|
const auto qt_shader_cache_path = QString::fromStdString(shader_path_string);
|
|
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(qt_shader_cache_path));
|
2019-02-08 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
2018-09-25 22:04:22 +00:00
|
|
|
static std::size_t CalculateRomFSEntrySize(const FileSys::VirtualDir& dir, bool full) {
|
|
|
|
std::size_t out = 0;
|
|
|
|
|
|
|
|
for (const auto& subdir : dir->GetSubdirectories()) {
|
|
|
|
out += 1 + CalculateRomFSEntrySize(subdir, full);
|
|
|
|
}
|
|
|
|
|
2018-09-25 22:06:35 +00:00
|
|
|
return out + (full ? dir->GetFiles().size() : 0);
|
2018-09-25 22:04:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool RomFSRawCopy(QProgressDialog& dialog, const FileSys::VirtualDir& src,
|
|
|
|
const FileSys::VirtualDir& dest, std::size_t block_size, bool full) {
|
|
|
|
if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable())
|
|
|
|
return false;
|
|
|
|
if (dialog.wasCanceled())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (full) {
|
|
|
|
for (const auto& file : src->GetFiles()) {
|
|
|
|
const auto out = VfsDirectoryCreateFileWrapper(dest, file->GetName());
|
|
|
|
if (!FileSys::VfsRawCopy(file, out, block_size))
|
|
|
|
return false;
|
|
|
|
dialog.setValue(dialog.value() + 1);
|
|
|
|
if (dialog.wasCanceled())
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const auto& dir : src->GetSubdirectories()) {
|
|
|
|
const auto out = dest->CreateSubdirectory(dir->GetName());
|
|
|
|
if (!RomFSRawCopy(dialog, dir, out, block_size, full))
|
|
|
|
return false;
|
|
|
|
dialog.setValue(dialog.value() + 1);
|
|
|
|
if (dialog.wasCanceled())
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2022-11-04 11:59:32 +00:00
|
|
|
QString GMainWindow::GetGameListErrorRemoving(InstalledEntryType type) const {
|
|
|
|
switch (type) {
|
|
|
|
case InstalledEntryType::Game:
|
|
|
|
return tr("Error Removing Contents");
|
|
|
|
case InstalledEntryType::Update:
|
|
|
|
return tr("Error Removing Update");
|
|
|
|
case InstalledEntryType::AddOnContent:
|
|
|
|
return tr("Error Removing DLC");
|
|
|
|
default:
|
|
|
|
return QStringLiteral("Error Removing <Invalid Type>");
|
|
|
|
}
|
|
|
|
}
|
2020-07-17 09:21:26 +00:00
|
|
|
void GMainWindow::OnGameListRemoveInstalledEntry(u64 program_id, InstalledEntryType type) {
|
2022-11-04 11:59:32 +00:00
|
|
|
const QString entry_question = [type] {
|
2020-07-17 10:06:56 +00:00
|
|
|
switch (type) {
|
|
|
|
case InstalledEntryType::Game:
|
2022-11-04 11:59:32 +00:00
|
|
|
return tr("Remove Installed Game Contents?");
|
2020-07-17 10:06:56 +00:00
|
|
|
case InstalledEntryType::Update:
|
2022-11-04 11:59:32 +00:00
|
|
|
return tr("Remove Installed Game Update?");
|
2020-07-17 10:06:56 +00:00
|
|
|
case InstalledEntryType::AddOnContent:
|
2022-11-04 11:59:32 +00:00
|
|
|
return tr("Remove Installed Game DLC?");
|
2020-07-17 10:06:56 +00:00
|
|
|
default:
|
2022-11-04 11:59:32 +00:00
|
|
|
return QStringLiteral("Remove Installed Game <Invalid Type>?");
|
2020-07-17 10:06:56 +00:00
|
|
|
}
|
|
|
|
}();
|
2020-07-17 09:21:26 +00:00
|
|
|
|
2022-11-04 11:59:32 +00:00
|
|
|
if (QMessageBox::question(this, tr("Remove Entry"), entry_question,
|
|
|
|
QMessageBox::Yes | QMessageBox::No,
|
|
|
|
QMessageBox::No) != QMessageBox::Yes) {
|
2020-07-17 09:21:26 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case InstalledEntryType::Game:
|
2022-11-04 11:59:32 +00:00
|
|
|
RemoveBaseContent(program_id, type);
|
2020-07-17 09:21:26 +00:00
|
|
|
[[fallthrough]];
|
|
|
|
case InstalledEntryType::Update:
|
2022-11-04 11:59:32 +00:00
|
|
|
RemoveUpdateContent(program_id, type);
|
2020-07-17 10:14:13 +00:00
|
|
|
if (type != InstalledEntryType::Game) {
|
2020-07-17 09:21:26 +00:00
|
|
|
break;
|
|
|
|
}
|
2020-07-17 10:14:13 +00:00
|
|
|
[[fallthrough]];
|
2020-07-17 09:21:26 +00:00
|
|
|
case InstalledEntryType::AddOnContent:
|
2022-11-04 11:59:32 +00:00
|
|
|
RemoveAddOnContent(program_id, type);
|
2020-07-17 09:21:26 +00:00
|
|
|
break;
|
|
|
|
}
|
2021-06-19 07:43:16 +00:00
|
|
|
Common::FS::RemoveDirRecursively(Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir) /
|
|
|
|
"game_list");
|
2020-07-20 14:30:56 +00:00
|
|
|
game_list->PopulateAsync(UISettings::values.game_dirs);
|
2020-07-17 09:21:26 +00:00
|
|
|
}
|
|
|
|
|
2022-11-04 11:59:32 +00:00
|
|
|
void GMainWindow::RemoveBaseContent(u64 program_id, InstalledEntryType type) {
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto& fs_controller = system->GetFileSystemController();
|
2020-07-20 14:30:56 +00:00
|
|
|
const auto res = fs_controller.GetUserNANDContents()->RemoveExistingEntry(program_id) ||
|
|
|
|
fs_controller.GetSDMCContents()->RemoveExistingEntry(program_id);
|
2020-07-17 10:06:56 +00:00
|
|
|
|
|
|
|
if (res) {
|
|
|
|
QMessageBox::information(this, tr("Successfully Removed"),
|
|
|
|
tr("Successfully removed the installed base game."));
|
|
|
|
} else {
|
|
|
|
QMessageBox::warning(
|
2022-11-04 11:59:32 +00:00
|
|
|
this, GetGameListErrorRemoving(type),
|
2020-07-17 10:06:56 +00:00
|
|
|
tr("The base game is not installed in the NAND and cannot be removed."));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-04 11:59:32 +00:00
|
|
|
void GMainWindow::RemoveUpdateContent(u64 program_id, InstalledEntryType type) {
|
2020-07-20 14:30:56 +00:00
|
|
|
const auto update_id = program_id | 0x800;
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto& fs_controller = system->GetFileSystemController();
|
2020-07-20 14:30:56 +00:00
|
|
|
const auto res = fs_controller.GetUserNANDContents()->RemoveExistingEntry(update_id) ||
|
|
|
|
fs_controller.GetSDMCContents()->RemoveExistingEntry(update_id);
|
2020-07-17 10:06:56 +00:00
|
|
|
|
|
|
|
if (res) {
|
|
|
|
QMessageBox::information(this, tr("Successfully Removed"),
|
|
|
|
tr("Successfully removed the installed update."));
|
|
|
|
} else {
|
2022-11-04 11:59:32 +00:00
|
|
|
QMessageBox::warning(this, GetGameListErrorRemoving(type),
|
2020-07-17 10:06:56 +00:00
|
|
|
tr("There is no update installed for this title."));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-04 11:59:32 +00:00
|
|
|
void GMainWindow::RemoveAddOnContent(u64 program_id, InstalledEntryType type) {
|
2020-07-17 10:06:56 +00:00
|
|
|
u32 count{};
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto& fs_controller = system->GetFileSystemController();
|
|
|
|
const auto dlc_entries = system->GetContentProvider().ListEntriesFilter(
|
2020-07-17 10:06:56 +00:00
|
|
|
FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
|
|
|
|
|
|
|
|
for (const auto& entry : dlc_entries) {
|
2020-12-04 06:41:21 +00:00
|
|
|
if (FileSys::GetBaseTitleID(entry.title_id) == program_id) {
|
2020-07-20 14:30:56 +00:00
|
|
|
const auto res =
|
|
|
|
fs_controller.GetUserNANDContents()->RemoveExistingEntry(entry.title_id) ||
|
|
|
|
fs_controller.GetSDMCContents()->RemoveExistingEntry(entry.title_id);
|
2020-07-17 10:06:56 +00:00
|
|
|
if (res) {
|
|
|
|
++count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (count == 0) {
|
2022-11-04 11:59:32 +00:00
|
|
|
QMessageBox::warning(this, GetGameListErrorRemoving(type),
|
2020-07-17 10:06:56 +00:00
|
|
|
tr("There are no DLC installed for this title."));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
QMessageBox::information(this, tr("Successfully Removed"),
|
|
|
|
tr("Successfully removed %1 installed DLC.").arg(count));
|
|
|
|
}
|
|
|
|
|
2021-05-26 00:06:06 +00:00
|
|
|
void GMainWindow::OnGameListRemoveFile(u64 program_id, GameListRemoveTarget target,
|
2021-06-02 19:05:45 +00:00
|
|
|
const std::string& game_path) {
|
2022-09-21 16:51:31 +00:00
|
|
|
const QString question = [target] {
|
2020-07-17 10:06:56 +00:00
|
|
|
switch (target) {
|
2021-07-11 18:39:13 +00:00
|
|
|
case GameListRemoveTarget::GlShaderCache:
|
|
|
|
return tr("Delete OpenGL Transferable Shader Cache?");
|
|
|
|
case GameListRemoveTarget::VkShaderCache:
|
|
|
|
return tr("Delete Vulkan Transferable Shader Cache?");
|
|
|
|
case GameListRemoveTarget::AllShaderCache:
|
|
|
|
return tr("Delete All Transferable Shader Caches?");
|
2020-07-17 10:06:56 +00:00
|
|
|
case GameListRemoveTarget::CustomConfiguration:
|
|
|
|
return tr("Remove Custom Game Configuration?");
|
2023-05-27 03:21:18 +00:00
|
|
|
case GameListRemoveTarget::CacheStorage:
|
|
|
|
return tr("Remove Cache Storage?");
|
2020-07-17 10:06:56 +00:00
|
|
|
default:
|
|
|
|
return QString{};
|
|
|
|
}
|
|
|
|
}();
|
|
|
|
|
|
|
|
if (QMessageBox::question(this, tr("Remove File"), question, QMessageBox::Yes | QMessageBox::No,
|
|
|
|
QMessageBox::No) != QMessageBox::Yes) {
|
|
|
|
return;
|
|
|
|
}
|
2020-07-17 09:21:26 +00:00
|
|
|
|
|
|
|
switch (target) {
|
2021-07-11 18:39:13 +00:00
|
|
|
case GameListRemoveTarget::VkShaderCache:
|
2023-01-03 03:18:45 +00:00
|
|
|
RemoveVulkanDriverPipelineCache(program_id);
|
|
|
|
[[fallthrough]];
|
|
|
|
case GameListRemoveTarget::GlShaderCache:
|
2021-07-11 18:39:13 +00:00
|
|
|
RemoveTransferableShaderCache(program_id, target);
|
|
|
|
break;
|
|
|
|
case GameListRemoveTarget::AllShaderCache:
|
|
|
|
RemoveAllTransferableShaderCaches(program_id);
|
2020-07-17 09:21:26 +00:00
|
|
|
break;
|
|
|
|
case GameListRemoveTarget::CustomConfiguration:
|
2021-05-26 00:06:06 +00:00
|
|
|
RemoveCustomConfiguration(program_id, game_path);
|
2020-07-17 09:21:26 +00:00
|
|
|
break;
|
2023-05-27 03:21:18 +00:00
|
|
|
case GameListRemoveTarget::CacheStorage:
|
|
|
|
RemoveCacheStorage(program_id);
|
|
|
|
break;
|
2020-07-17 09:21:26 +00:00
|
|
|
}
|
2020-07-17 10:06:56 +00:00
|
|
|
}
|
2020-07-17 09:21:26 +00:00
|
|
|
|
2021-07-11 18:39:13 +00:00
|
|
|
void GMainWindow::RemoveTransferableShaderCache(u64 program_id, GameListRemoveTarget target) {
|
|
|
|
const auto target_file_name = [target] {
|
|
|
|
switch (target) {
|
|
|
|
case GameListRemoveTarget::GlShaderCache:
|
|
|
|
return "opengl.bin";
|
|
|
|
case GameListRemoveTarget::VkShaderCache:
|
|
|
|
return "vulkan.bin";
|
|
|
|
default:
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
}();
|
2021-05-25 23:32:56 +00:00
|
|
|
const auto shader_cache_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ShaderDir);
|
2021-07-11 18:39:13 +00:00
|
|
|
const auto shader_cache_folder_path = shader_cache_dir / fmt::format("{:016x}", program_id);
|
|
|
|
const auto target_file = shader_cache_folder_path / target_file_name;
|
2021-05-25 23:32:56 +00:00
|
|
|
|
2021-07-11 18:39:13 +00:00
|
|
|
if (!Common::FS::Exists(target_file)) {
|
2020-07-17 10:06:56 +00:00
|
|
|
QMessageBox::warning(this, tr("Error Removing Transferable Shader Cache"),
|
|
|
|
tr("A shader cache for this title does not exist."));
|
2020-07-17 09:21:26 +00:00
|
|
|
return;
|
|
|
|
}
|
2021-07-11 18:39:13 +00:00
|
|
|
if (Common::FS::RemoveFile(target_file)) {
|
2020-07-17 10:06:56 +00:00
|
|
|
QMessageBox::information(this, tr("Successfully Removed"),
|
|
|
|
tr("Successfully removed the transferable shader cache."));
|
|
|
|
} else {
|
|
|
|
QMessageBox::warning(this, tr("Error Removing Transferable Shader Cache"),
|
|
|
|
tr("Failed to remove the transferable shader cache."));
|
2020-07-17 09:21:26 +00:00
|
|
|
}
|
2020-07-17 10:06:56 +00:00
|
|
|
}
|
2020-07-17 09:21:26 +00:00
|
|
|
|
2023-01-03 03:18:45 +00:00
|
|
|
void GMainWindow::RemoveVulkanDriverPipelineCache(u64 program_id) {
|
|
|
|
static constexpr std::string_view target_file_name = "vulkan_pipelines.bin";
|
|
|
|
|
|
|
|
const auto shader_cache_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ShaderDir);
|
|
|
|
const auto shader_cache_folder_path = shader_cache_dir / fmt::format("{:016x}", program_id);
|
|
|
|
const auto target_file = shader_cache_folder_path / target_file_name;
|
|
|
|
|
|
|
|
if (!Common::FS::Exists(target_file)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!Common::FS::RemoveFile(target_file)) {
|
|
|
|
QMessageBox::warning(this, tr("Error Removing Vulkan Driver Pipeline Cache"),
|
|
|
|
tr("Failed to remove the driver pipeline cache."));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-11 18:39:13 +00:00
|
|
|
void GMainWindow::RemoveAllTransferableShaderCaches(u64 program_id) {
|
|
|
|
const auto shader_cache_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ShaderDir);
|
|
|
|
const auto program_shader_cache_dir = shader_cache_dir / fmt::format("{:016x}", program_id);
|
|
|
|
|
|
|
|
if (!Common::FS::Exists(program_shader_cache_dir)) {
|
|
|
|
QMessageBox::warning(this, tr("Error Removing Transferable Shader Caches"),
|
|
|
|
tr("A shader cache for this title does not exist."));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (Common::FS::RemoveDirRecursively(program_shader_cache_dir)) {
|
|
|
|
QMessageBox::information(this, tr("Successfully Removed"),
|
|
|
|
tr("Successfully removed the transferable shader caches."));
|
|
|
|
} else {
|
|
|
|
QMessageBox::warning(this, tr("Error Removing Transferable Shader Caches"),
|
|
|
|
tr("Failed to remove the transferable shader cache directory."));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-02 19:05:45 +00:00
|
|
|
void GMainWindow::RemoveCustomConfiguration(u64 program_id, const std::string& game_path) {
|
|
|
|
const auto file_path = std::filesystem::path(Common::FS::ToU8String(game_path));
|
|
|
|
const auto config_file_name =
|
|
|
|
program_id == 0 ? Common::FS::PathToUTF8String(file_path.filename()).append(".ini")
|
|
|
|
: fmt::format("{:016X}.ini", program_id);
|
2021-05-26 01:39:57 +00:00
|
|
|
const auto custom_config_file_path =
|
|
|
|
Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir) / "custom" / config_file_name;
|
2020-07-17 10:06:56 +00:00
|
|
|
|
2021-05-25 23:32:56 +00:00
|
|
|
if (!Common::FS::Exists(custom_config_file_path)) {
|
2020-07-17 10:06:56 +00:00
|
|
|
QMessageBox::warning(this, tr("Error Removing Custom Configuration"),
|
|
|
|
tr("A custom configuration for this title does not exist."));
|
|
|
|
return;
|
2020-07-17 09:21:26 +00:00
|
|
|
}
|
2020-07-17 10:06:56 +00:00
|
|
|
|
2021-05-25 23:32:56 +00:00
|
|
|
if (Common::FS::RemoveFile(custom_config_file_path)) {
|
2020-07-17 10:06:56 +00:00
|
|
|
QMessageBox::information(this, tr("Successfully Removed"),
|
|
|
|
tr("Successfully removed the custom game configuration."));
|
|
|
|
} else {
|
|
|
|
QMessageBox::warning(this, tr("Error Removing Custom Configuration"),
|
|
|
|
tr("Failed to remove the custom game configuration."));
|
2020-07-17 09:21:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-05-27 03:21:18 +00:00
|
|
|
void GMainWindow::RemoveCacheStorage(u64 program_id) {
|
|
|
|
const auto nand_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir);
|
|
|
|
auto vfs_nand_dir =
|
|
|
|
vfs->OpenDirectory(Common::FS::PathToUTF8String(nand_dir), FileSys::Mode::Read);
|
|
|
|
|
|
|
|
const auto cache_storage_path = FileSys::SaveDataFactory::GetFullPath(
|
|
|
|
*system, vfs_nand_dir, FileSys::SaveDataSpaceId::NandUser,
|
|
|
|
FileSys::SaveDataType::CacheStorage, 0 /* program_id */, {}, 0);
|
|
|
|
|
|
|
|
const auto path = Common::FS::ConcatPathSafe(nand_dir, cache_storage_path);
|
|
|
|
|
|
|
|
// Not an error if it wasn't cleared.
|
|
|
|
Common::FS::RemoveDirRecursively(path);
|
|
|
|
}
|
|
|
|
|
2021-06-14 21:13:08 +00:00
|
|
|
void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_path,
|
|
|
|
DumpRomFSTarget target) {
|
2018-10-17 22:27:23 +00:00
|
|
|
const auto failed = [this] {
|
2018-09-20 02:09:23 +00:00
|
|
|
QMessageBox::warning(this, tr("RomFS Extraction Failed!"),
|
|
|
|
tr("There was an error copying the RomFS files or the user "
|
|
|
|
"cancelled the operation."));
|
|
|
|
};
|
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto loader = Loader::GetLoader(*system, vfs->OpenFile(game_path, FileSys::Mode::Read));
|
2018-09-20 02:09:23 +00:00
|
|
|
if (loader == nullptr) {
|
|
|
|
failed();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
FileSys::VirtualFile file;
|
|
|
|
if (loader->ReadRomFS(file) != Loader::ResultStatus::Success) {
|
|
|
|
failed();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto& installed = system->GetContentProvider();
|
2018-12-02 01:32:38 +00:00
|
|
|
const auto romfs_title_id = SelectRomFSDumpTarget(installed, program_id);
|
2018-10-17 22:27:23 +00:00
|
|
|
|
|
|
|
if (!romfs_title_id) {
|
|
|
|
failed();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-06-14 21:13:08 +00:00
|
|
|
const auto dump_dir =
|
|
|
|
target == DumpRomFSTarget::Normal
|
|
|
|
? Common::FS::GetYuzuPath(Common::FS::YuzuPath::DumpDir)
|
|
|
|
: Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir) / "atmosphere" / "contents";
|
2021-05-25 23:32:56 +00:00
|
|
|
const auto romfs_dir = fmt::format("{:016X}/romfs", *romfs_title_id);
|
|
|
|
|
|
|
|
const auto path = Common::FS::PathToUTF8String(dump_dir / romfs_dir);
|
2018-10-17 22:27:23 +00:00
|
|
|
|
|
|
|
FileSys::VirtualFile romfs;
|
|
|
|
|
|
|
|
if (*romfs_title_id == program_id) {
|
2020-04-23 12:10:06 +00:00
|
|
|
const u64 ivfc_offset = loader->ReadRomFSIVFCOffset();
|
2021-10-14 18:32:19 +00:00
|
|
|
const FileSys::PatchManager pm{program_id, system->GetFileSystemController(), installed};
|
2021-06-28 14:07:40 +00:00
|
|
|
romfs =
|
|
|
|
pm.PatchRomFS(file, ivfc_offset, FileSys::ContentRecordType::Program, nullptr, false);
|
2018-10-17 22:27:23 +00:00
|
|
|
} else {
|
2018-12-02 01:32:38 +00:00
|
|
|
romfs = installed.GetEntry(*romfs_title_id, FileSys::ContentRecordType::Data)->GetRomFS();
|
2018-10-17 22:27:23 +00:00
|
|
|
}
|
2018-09-20 02:09:23 +00:00
|
|
|
|
2018-09-24 01:50:16 +00:00
|
|
|
const auto extracted = FileSys::ExtractRomFS(romfs, FileSys::RomFSExtractionType::Full);
|
2018-09-20 02:09:23 +00:00
|
|
|
if (extracted == nullptr) {
|
|
|
|
failed();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto out = VfsFilesystemCreateDirectoryWrapper(vfs, path, FileSys::Mode::ReadWrite);
|
|
|
|
|
|
|
|
if (out == nullptr) {
|
|
|
|
failed();
|
2018-10-17 22:27:23 +00:00
|
|
|
vfs->DeleteDirectory(path);
|
2018-09-20 02:09:23 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-05-24 23:44:06 +00:00
|
|
|
bool ok = false;
|
|
|
|
const QStringList selections{tr("Full"), tr("Skeleton")};
|
2018-09-20 02:09:23 +00:00
|
|
|
const auto res = QInputDialog::getItem(
|
|
|
|
this, tr("Select RomFS Dump Mode"),
|
|
|
|
tr("Please select the how you would like the RomFS dumped.<br>Full will copy all of the "
|
|
|
|
"files into the new directory while <br>skeleton will only create the directory "
|
|
|
|
"structure."),
|
2019-05-24 23:44:06 +00:00
|
|
|
selections, 0, false, &ok);
|
2018-10-17 22:27:23 +00:00
|
|
|
if (!ok) {
|
2018-09-20 02:09:23 +00:00
|
|
|
failed();
|
2018-10-17 22:27:23 +00:00
|
|
|
vfs->DeleteDirectory(path);
|
|
|
|
return;
|
|
|
|
}
|
2018-09-20 02:09:23 +00:00
|
|
|
|
2019-05-24 23:44:06 +00:00
|
|
|
const auto full = res == selections.constFirst();
|
2018-09-25 22:04:22 +00:00
|
|
|
const auto entry_size = CalculateRomFSEntrySize(extracted, full);
|
2018-09-20 02:09:23 +00:00
|
|
|
|
2021-06-11 18:01:57 +00:00
|
|
|
// The minimum required space is the size of the extracted RomFS + 1 GiB
|
|
|
|
const auto minimum_free_space = extracted->GetSize() + 0x40000000;
|
|
|
|
|
|
|
|
if (full && Common::FS::GetFreeSpaceSize(path) < minimum_free_space) {
|
|
|
|
QMessageBox::warning(this, tr("RomFS Extraction Failed!"),
|
|
|
|
tr("There is not enough free space at %1 to extract the RomFS. Please "
|
|
|
|
"free up space or select a different dump directory at "
|
|
|
|
"Emulation > Configure > System > Filesystem > Dump Root")
|
|
|
|
.arg(QString::fromStdString(path)));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-11-06 14:22:24 +00:00
|
|
|
QProgressDialog progress(tr("Extracting RomFS..."), tr("Cancel"), 0,
|
|
|
|
static_cast<s32>(entry_size), this);
|
2018-09-20 02:09:23 +00:00
|
|
|
progress.setWindowModality(Qt::WindowModal);
|
|
|
|
progress.setMinimumDuration(100);
|
|
|
|
|
2018-09-25 22:04:22 +00:00
|
|
|
if (RomFSRawCopy(progress, extracted, out, 0x400000, full)) {
|
2018-09-20 02:09:23 +00:00
|
|
|
progress.close();
|
|
|
|
QMessageBox::information(this, tr("RomFS Extraction Succeeded!"),
|
|
|
|
tr("The operation completed successfully."));
|
|
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(QString::fromStdString(path)));
|
|
|
|
} else {
|
|
|
|
progress.close();
|
|
|
|
failed();
|
2018-10-17 22:27:23 +00:00
|
|
|
vfs->DeleteDirectory(path);
|
2018-09-20 02:09:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnGameListCopyTID(u64 program_id) {
|
|
|
|
QClipboard* clipboard = QGuiApplication::clipboard();
|
|
|
|
clipboard->setText(QString::fromStdString(fmt::format("{:016X}", program_id)));
|
|
|
|
}
|
|
|
|
|
2018-09-09 23:09:37 +00:00
|
|
|
void GMainWindow::OnGameListNavigateToGamedbEntry(u64 program_id,
|
2018-09-09 23:35:05 +00:00
|
|
|
const CompatibilityList& compatibility_list) {
|
2018-09-09 23:09:37 +00:00
|
|
|
const auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
|
2018-08-29 13:42:53 +00:00
|
|
|
|
|
|
|
QString directory;
|
2019-05-24 23:44:06 +00:00
|
|
|
if (it != compatibility_list.end()) {
|
2018-08-29 13:42:53 +00:00
|
|
|
directory = it->second.second;
|
2019-05-24 23:44:06 +00:00
|
|
|
}
|
2018-08-29 13:42:53 +00:00
|
|
|
|
2019-05-24 23:44:06 +00:00
|
|
|
QDesktopServices::openUrl(QUrl(QStringLiteral("https://yuzu-emu.org/game/") + directory));
|
2018-08-29 13:42:53 +00:00
|
|
|
}
|
|
|
|
|
2021-07-29 03:02:29 +00:00
|
|
|
void GMainWindow::OnGameListCreateShortcut(u64 program_id, const std::string& game_path,
|
|
|
|
GameListShortcutTarget target) {
|
|
|
|
// Get path to yuzu executable
|
|
|
|
const QStringList args = QApplication::arguments();
|
|
|
|
std::filesystem::path yuzu_command = args[0].toStdString();
|
|
|
|
|
|
|
|
#if defined(__linux__) || defined(__FreeBSD__)
|
|
|
|
// If relative path, make it an absolute path
|
|
|
|
if (yuzu_command.c_str()[0] == '.') {
|
|
|
|
yuzu_command = Common::FS::GetCurrentDir() / yuzu_command;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(__linux__)
|
|
|
|
// Warn once if we are making a shortcut to a volatile AppImage
|
|
|
|
const std::string appimage_ending =
|
|
|
|
std::string(Common::g_scm_rev).substr(0, 9).append(".AppImage");
|
|
|
|
if (yuzu_command.string().ends_with(appimage_ending) &&
|
|
|
|
!UISettings::values.shortcut_already_warned) {
|
|
|
|
if (QMessageBox::warning(this, tr("Create Shortcut"),
|
|
|
|
tr("This will create a shortcut to the current AppImage. This may "
|
|
|
|
"not work well if you update. Continue?"),
|
|
|
|
QMessageBox::StandardButton::Ok |
|
|
|
|
QMessageBox::StandardButton::Cancel) ==
|
|
|
|
QMessageBox::StandardButton::Cancel) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
UISettings::values.shortcut_already_warned = true;
|
|
|
|
}
|
|
|
|
#endif // __linux__
|
|
|
|
#endif // __linux__ || __FreeBSD__
|
|
|
|
|
|
|
|
std::filesystem::path target_directory{};
|
|
|
|
// Determine target directory for shortcut
|
|
|
|
#if defined(__linux__) || defined(__FreeBSD__)
|
|
|
|
const char* home = std::getenv("HOME");
|
|
|
|
const std::filesystem::path home_path = (home == nullptr ? "~" : home);
|
|
|
|
const char* xdg_data_home = std::getenv("XDG_DATA_HOME");
|
|
|
|
|
|
|
|
if (target == GameListShortcutTarget::Desktop) {
|
|
|
|
target_directory = home_path / "Desktop";
|
|
|
|
if (!Common::FS::IsDir(target_directory)) {
|
|
|
|
QMessageBox::critical(
|
|
|
|
this, tr("Create Shortcut"),
|
2022-03-11 20:57:39 +00:00
|
|
|
tr("Cannot create shortcut on desktop. Path \"%1\" does not exist.")
|
|
|
|
.arg(QString::fromStdString(target_directory)),
|
2021-07-29 03:02:29 +00:00
|
|
|
QMessageBox::StandardButton::Ok);
|
|
|
|
return;
|
|
|
|
}
|
2022-03-11 20:57:39 +00:00
|
|
|
} else if (target == GameListShortcutTarget::Applications) {
|
|
|
|
target_directory = (xdg_data_home == nullptr ? home_path / ".local/share" : xdg_data_home) /
|
|
|
|
"applications";
|
|
|
|
if (!Common::FS::CreateDirs(target_directory)) {
|
|
|
|
QMessageBox::critical(this, tr("Create Shortcut"),
|
|
|
|
tr("Cannot create shortcut in applications menu. Path \"%1\" "
|
|
|
|
"does not exist and cannot be created.")
|
|
|
|
.arg(QString::fromStdString(target_directory)),
|
|
|
|
QMessageBox::StandardButton::Ok);
|
|
|
|
return;
|
|
|
|
}
|
2021-07-29 03:02:29 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
const std::string game_file_name = std::filesystem::path(game_path).filename().string();
|
|
|
|
// Determine full paths for icon and shortcut
|
|
|
|
#if defined(__linux__) || defined(__FreeBSD__)
|
2022-03-11 20:57:39 +00:00
|
|
|
std::filesystem::path system_icons_path =
|
|
|
|
(xdg_data_home == nullptr ? home_path / ".local/share/" : xdg_data_home) /
|
|
|
|
"icons/hicolor/256x256";
|
|
|
|
if (!Common::FS::CreateDirs(system_icons_path)) {
|
|
|
|
QMessageBox::critical(
|
|
|
|
this, tr("Create Icon"),
|
|
|
|
tr("Cannot create icon file. Path \"%1\" does not exist and cannot be created.")
|
|
|
|
.arg(QString::fromStdString(system_icons_path)),
|
|
|
|
QMessageBox::StandardButton::Ok);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
std::filesystem::path icon_path =
|
|
|
|
system_icons_path / (program_id == 0 ? fmt::format("yuzu-{}.png", game_file_name)
|
|
|
|
: fmt::format("yuzu-{:016X}.png", program_id));
|
2021-07-29 03:02:29 +00:00
|
|
|
const std::filesystem::path shortcut_path =
|
2022-03-11 20:57:39 +00:00
|
|
|
target_directory / (program_id == 0 ? fmt::format("yuzu-{}.desktop", game_file_name)
|
|
|
|
: fmt::format("yuzu-{:016X}.desktop", program_id));
|
2021-07-29 03:02:29 +00:00
|
|
|
#else
|
|
|
|
const std::filesystem::path icon_path{};
|
|
|
|
const std::filesystem::path shortcut_path{};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Get title from game file
|
|
|
|
const FileSys::PatchManager pm{program_id, system->GetFileSystemController(),
|
|
|
|
system->GetContentProvider()};
|
|
|
|
const auto control = pm.GetControlMetadata();
|
|
|
|
const auto loader = Loader::GetLoader(*system, vfs->OpenFile(game_path, FileSys::Mode::Read));
|
|
|
|
|
|
|
|
std::string title{fmt::format("{:016X}", program_id)};
|
|
|
|
|
|
|
|
if (control.first != nullptr) {
|
|
|
|
title = control.first->GetApplicationName();
|
|
|
|
} else {
|
|
|
|
loader->ReadTitle(title);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get icon from game file
|
|
|
|
std::vector<u8> icon_image_file{};
|
|
|
|
if (control.second != nullptr) {
|
|
|
|
icon_image_file = control.second->ReadAllBytes();
|
|
|
|
} else if (loader->ReadIcon(icon_image_file) != Loader::ResultStatus::Success) {
|
|
|
|
LOG_WARNING(Frontend, "Could not read icon from {:s}", game_path);
|
|
|
|
}
|
|
|
|
|
2022-03-11 20:57:39 +00:00
|
|
|
QImage icon_jpeg =
|
|
|
|
QImage::fromData(icon_image_file.data(), static_cast<int>(icon_image_file.size()));
|
2021-07-29 03:02:29 +00:00
|
|
|
#if defined(__linux__) || defined(__FreeBSD__)
|
|
|
|
// Convert and write the icon as a PNG
|
|
|
|
if (!icon_jpeg.save(QString::fromStdString(icon_path.string()))) {
|
|
|
|
LOG_ERROR(Frontend, "Could not write icon as PNG to file");
|
|
|
|
} else {
|
2022-03-11 20:57:39 +00:00
|
|
|
LOG_INFO(Frontend, "Wrote an icon to {}", icon_path.string());
|
2021-07-29 03:02:29 +00:00
|
|
|
}
|
|
|
|
#endif // __linux__
|
|
|
|
|
|
|
|
#if defined(__linux__) || defined(__FreeBSD__)
|
|
|
|
const std::string comment =
|
|
|
|
tr("Start %1 with the yuzu Emulator").arg(QString::fromStdString(title)).toStdString();
|
|
|
|
const std::string arguments = fmt::format("-g \"{:s}\"", game_path);
|
|
|
|
const std::string categories = "Game;Emulator;Qt;";
|
|
|
|
const std::string keywords = "Switch;Nintendo;";
|
|
|
|
#else
|
|
|
|
const std::string comment{};
|
|
|
|
const std::string arguments{};
|
|
|
|
const std::string categories{};
|
|
|
|
const std::string keywords{};
|
|
|
|
#endif
|
|
|
|
if (!CreateShortcut(shortcut_path.string(), title, comment, icon_path.string(),
|
|
|
|
yuzu_command.string(), arguments, categories, keywords)) {
|
|
|
|
QMessageBox::critical(this, tr("Create Shortcut"),
|
|
|
|
tr("Failed to create a shortcut at %1")
|
|
|
|
.arg(QString::fromStdString(shortcut_path.string())));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-03-11 20:57:39 +00:00
|
|
|
LOG_INFO(Frontend, "Wrote a shortcut to {}", shortcut_path.string());
|
2021-07-29 03:02:29 +00:00
|
|
|
QMessageBox::information(
|
|
|
|
this, tr("Create Shortcut"),
|
|
|
|
tr("Successfully created a shortcut to %1").arg(QString::fromStdString(title)));
|
|
|
|
}
|
|
|
|
|
2019-05-03 17:21:57 +00:00
|
|
|
void GMainWindow::OnGameListOpenDirectory(const QString& directory) {
|
2021-05-25 23:32:56 +00:00
|
|
|
std::filesystem::path fs_path;
|
2019-05-05 01:07:09 +00:00
|
|
|
if (directory == QStringLiteral("SDMC")) {
|
2021-05-25 23:32:56 +00:00
|
|
|
fs_path =
|
|
|
|
Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir) / "Nintendo/Contents/registered";
|
2019-05-05 01:07:09 +00:00
|
|
|
} else if (directory == QStringLiteral("UserNAND")) {
|
2021-05-25 23:32:56 +00:00
|
|
|
fs_path =
|
|
|
|
Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) / "user/Contents/registered";
|
2019-05-05 01:07:09 +00:00
|
|
|
} else if (directory == QStringLiteral("SysNAND")) {
|
2021-05-25 23:32:56 +00:00
|
|
|
fs_path =
|
|
|
|
Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) / "system/Contents/registered";
|
2019-05-01 21:21:04 +00:00
|
|
|
} else {
|
2021-05-25 23:32:56 +00:00
|
|
|
fs_path = directory.toStdString();
|
2019-05-01 21:21:04 +00:00
|
|
|
}
|
2021-05-25 23:32:56 +00:00
|
|
|
|
|
|
|
const auto qt_path = QString::fromStdString(Common::FS::PathToUTF8String(fs_path));
|
|
|
|
|
|
|
|
if (!Common::FS::IsDir(fs_path)) {
|
|
|
|
QMessageBox::critical(this, tr("Error Opening %1").arg(qt_path),
|
|
|
|
tr("Folder does not exist!"));
|
2019-05-01 21:21:04 +00:00
|
|
|
return;
|
|
|
|
}
|
2021-05-25 23:32:56 +00:00
|
|
|
|
|
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(qt_path));
|
2019-05-01 21:21:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnGameListAddDirectory() {
|
2019-05-03 17:21:57 +00:00
|
|
|
const QString dir_path = QFileDialog::getExistingDirectory(this, tr("Select Directory"));
|
2020-08-15 12:33:16 +00:00
|
|
|
if (dir_path.isEmpty()) {
|
2019-05-01 21:21:04 +00:00
|
|
|
return;
|
2020-08-15 12:33:16 +00:00
|
|
|
}
|
|
|
|
|
2019-05-01 21:21:04 +00:00
|
|
|
UISettings::GameDir game_dir{dir_path, false, true};
|
|
|
|
if (!UISettings::values.game_dirs.contains(game_dir)) {
|
|
|
|
UISettings::values.game_dirs.append(game_dir);
|
|
|
|
game_list->PopulateAsync(UISettings::values.game_dirs);
|
|
|
|
} else {
|
|
|
|
LOG_WARNING(Frontend, "Selected directory is already in the game list");
|
|
|
|
}
|
2023-02-16 16:53:42 +00:00
|
|
|
|
|
|
|
OnSaveConfig();
|
2019-05-01 21:21:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnGameListShowList(bool show) {
|
2021-10-15 19:27:18 +00:00
|
|
|
if (emulation_running && ui->action_Single_Window_Mode->isChecked())
|
2019-05-01 21:21:04 +00:00
|
|
|
return;
|
|
|
|
game_list->setVisible(show);
|
|
|
|
game_list_placeholder->setVisible(!show);
|
|
|
|
};
|
|
|
|
|
2018-12-04 18:34:46 +00:00
|
|
|
void GMainWindow::OnGameListOpenPerGameProperties(const std::string& file) {
|
|
|
|
u64 title_id{};
|
|
|
|
const auto v_file = Core::GetGameFileFromPath(vfs, file);
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto loader = Loader::GetLoader(*system, v_file);
|
2020-11-18 12:53:10 +00:00
|
|
|
|
2018-12-04 18:34:46 +00:00
|
|
|
if (loader == nullptr || loader->ReadProgramId(title_id) != Loader::ResultStatus::Success) {
|
|
|
|
QMessageBox::information(this, tr("Properties"),
|
|
|
|
tr("The game properties could not be loaded."));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-08-11 18:57:29 +00:00
|
|
|
OpenPerGameConfiguration(title_id, file);
|
2018-12-04 18:34:46 +00:00
|
|
|
}
|
|
|
|
|
2015-07-28 16:43:18 +00:00
|
|
|
void GMainWindow::OnMenuLoadFile() {
|
2021-11-15 23:57:41 +00:00
|
|
|
if (is_load_file_select_active) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
is_load_file_select_active = true;
|
2018-10-13 14:23:50 +00:00
|
|
|
const QString extensions =
|
2019-05-24 23:44:06 +00:00
|
|
|
QStringLiteral("*.")
|
|
|
|
.append(GameList::supported_file_extensions.join(QStringLiteral(" *.")))
|
|
|
|
.append(QStringLiteral(" main"));
|
2018-10-13 14:23:50 +00:00
|
|
|
const QString file_filter = tr("Switch Executable (%1);;All Files (*.*)",
|
|
|
|
"%1 is an identifier for the Switch executable file extensions.")
|
|
|
|
.arg(extensions);
|
|
|
|
const QString filename = QFileDialog::getOpenFileName(
|
|
|
|
this, tr("Load File"), UISettings::values.roms_path, file_filter);
|
2021-11-15 23:57:41 +00:00
|
|
|
is_load_file_select_active = false;
|
2018-10-13 14:23:50 +00:00
|
|
|
|
|
|
|
if (filename.isEmpty()) {
|
|
|
|
return;
|
2015-04-28 23:03:01 +00:00
|
|
|
}
|
2018-10-13 14:23:50 +00:00
|
|
|
|
|
|
|
UISettings::values.roms_path = QFileInfo(filename).path();
|
|
|
|
BootGame(filename);
|
2014-04-01 02:26:50 +00:00
|
|
|
}
|
|
|
|
|
2018-06-14 16:27:29 +00:00
|
|
|
void GMainWindow::OnMenuLoadFolder() {
|
2018-08-06 18:02:31 +00:00
|
|
|
const QString dir_path =
|
|
|
|
QFileDialog::getExistingDirectory(this, tr("Open Extracted ROM Directory"));
|
2018-06-14 16:27:29 +00:00
|
|
|
|
2018-08-06 18:02:31 +00:00
|
|
|
if (dir_path.isNull()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QDir dir{dir_path};
|
2019-05-24 23:44:06 +00:00
|
|
|
const QStringList matching_main = dir.entryList({QStringLiteral("main")}, QDir::Files);
|
2018-06-14 21:25:40 +00:00
|
|
|
if (matching_main.size() == 1) {
|
2019-05-24 23:44:06 +00:00
|
|
|
BootGame(dir.path() + QDir::separator() + matching_main[0]);
|
2018-06-14 21:25:40 +00:00
|
|
|
} else {
|
|
|
|
QMessageBox::warning(this, tr("Invalid Directory Selected"),
|
|
|
|
tr("The directory you have selected does not contain a 'main' file."));
|
2018-06-14 16:27:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-05 13:29:39 +00:00
|
|
|
void GMainWindow::IncrementInstallProgress() {
|
|
|
|
install_progress->setValue(install_progress->value() + 1);
|
|
|
|
}
|
|
|
|
|
2018-08-10 01:33:13 +00:00
|
|
|
void GMainWindow::OnMenuInstallToNAND() {
|
2018-08-10 03:10:32 +00:00
|
|
|
const QString file_filter =
|
2018-08-25 15:50:15 +00:00
|
|
|
tr("Installable Switch File (*.nca *.nsp *.xci);;Nintendo Content Archive "
|
2020-04-17 03:27:38 +00:00
|
|
|
"(*.nca);;Nintendo Submission Package (*.nsp);;NX Cartridge "
|
2018-08-10 01:33:13 +00:00
|
|
|
"Image (*.xci)");
|
2018-08-10 19:07:06 +00:00
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
QStringList filenames = QFileDialog::getOpenFileNames(
|
|
|
|
this, tr("Install Files"), UISettings::values.roms_path, file_filter);
|
|
|
|
|
|
|
|
if (filenames.isEmpty()) {
|
2020-04-17 03:27:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
InstallDialog installDialog(this, filenames);
|
2020-04-17 03:27:38 +00:00
|
|
|
if (installDialog.exec() == QDialog::Rejected) {
|
2018-08-16 14:37:56 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
const QStringList files = installDialog.GetFiles();
|
2020-04-17 03:27:38 +00:00
|
|
|
|
2020-07-08 17:01:25 +00:00
|
|
|
if (files.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-12-18 06:36:21 +00:00
|
|
|
// Save folder location of the first selected file
|
|
|
|
UISettings::values.roms_path = QFileInfo(filenames[0]).path();
|
|
|
|
|
2020-07-05 13:29:39 +00:00
|
|
|
int remaining = filenames.size();
|
|
|
|
|
|
|
|
// This would only overflow above 2^43 bytes (8.796 TB)
|
|
|
|
int total_size = 0;
|
|
|
|
for (const QString& file : files) {
|
|
|
|
total_size += static_cast<int>(QFile(file).size() / 0x1000);
|
|
|
|
}
|
|
|
|
if (total_size < 0) {
|
|
|
|
LOG_CRITICAL(Frontend, "Attempting to install too many files, aborting.");
|
|
|
|
return;
|
|
|
|
}
|
2020-07-01 20:15:57 +00:00
|
|
|
|
|
|
|
QStringList new_files{}; // Newly installed files that do not yet exist in the NAND
|
|
|
|
QStringList overwritten_files{}; // Files that overwrote those existing in the NAND
|
2020-07-05 13:29:39 +00:00
|
|
|
QStringList failed_files{}; // Files that failed to install due to errors
|
2021-05-16 04:24:06 +00:00
|
|
|
bool detected_base_install{}; // Whether a base game was attempted to be installed
|
2020-07-01 20:15:57 +00:00
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Install_File_NAND->setEnabled(false);
|
2020-07-01 20:15:57 +00:00
|
|
|
|
2020-07-28 01:02:08 +00:00
|
|
|
install_progress = new QProgressDialog(QString{}, tr("Cancel"), 0, total_size, this);
|
2023-01-25 06:11:20 +00:00
|
|
|
install_progress->setWindowFlags(windowFlags() & ~Qt::WindowMaximizeButtonHint);
|
2020-07-05 13:29:39 +00:00
|
|
|
install_progress->setAttribute(Qt::WA_DeleteOnClose, true);
|
|
|
|
install_progress->setFixedWidth(installDialog.GetMinimumWidth() + 40);
|
|
|
|
install_progress->show();
|
2020-07-01 20:15:57 +00:00
|
|
|
|
|
|
|
for (const QString& file : files) {
|
2020-07-05 13:29:39 +00:00
|
|
|
install_progress->setWindowTitle(tr("%n file(s) remaining", "", remaining));
|
|
|
|
install_progress->setLabelText(
|
2020-07-01 20:15:57 +00:00
|
|
|
tr("Installing file \"%1\"...").arg(QFileInfo(file).fileName()));
|
|
|
|
|
|
|
|
QFuture<InstallResult> future;
|
|
|
|
InstallResult result;
|
|
|
|
|
|
|
|
if (file.endsWith(QStringLiteral("xci"), Qt::CaseInsensitive) ||
|
|
|
|
file.endsWith(QStringLiteral("nsp"), Qt::CaseInsensitive)) {
|
2020-07-05 13:29:39 +00:00
|
|
|
|
|
|
|
future = QtConcurrent::run([this, &file] { return InstallNSPXCI(file); });
|
2020-07-01 20:15:57 +00:00
|
|
|
|
|
|
|
while (!future.isFinished()) {
|
|
|
|
QCoreApplication::processEvents();
|
2021-05-16 04:24:06 +00:00
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
2020-07-01 20:15:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
result = future.result();
|
2020-07-05 13:29:39 +00:00
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
} else {
|
2020-07-05 13:29:39 +00:00
|
|
|
result = InstallNCA(file);
|
2020-07-01 20:15:57 +00:00
|
|
|
}
|
|
|
|
|
2020-07-05 13:29:39 +00:00
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
switch (result) {
|
|
|
|
case InstallResult::Success:
|
|
|
|
new_files.append(QFileInfo(file).fileName());
|
|
|
|
break;
|
|
|
|
case InstallResult::Overwrite:
|
|
|
|
overwritten_files.append(QFileInfo(file).fileName());
|
|
|
|
break;
|
|
|
|
case InstallResult::Failure:
|
|
|
|
failed_files.append(QFileInfo(file).fileName());
|
|
|
|
break;
|
2021-05-16 04:24:06 +00:00
|
|
|
case InstallResult::BaseInstallAttempted:
|
|
|
|
failed_files.append(QFileInfo(file).fileName());
|
|
|
|
detected_base_install = true;
|
|
|
|
break;
|
2020-07-01 20:15:57 +00:00
|
|
|
}
|
|
|
|
|
2020-07-05 13:29:39 +00:00
|
|
|
--remaining;
|
2020-07-01 20:15:57 +00:00
|
|
|
}
|
2020-04-17 03:27:38 +00:00
|
|
|
|
2020-07-05 13:29:39 +00:00
|
|
|
install_progress->close();
|
2020-07-01 20:15:57 +00:00
|
|
|
|
2021-05-16 04:24:06 +00:00
|
|
|
if (detected_base_install) {
|
|
|
|
QMessageBox::warning(
|
|
|
|
this, tr("Install Results"),
|
|
|
|
tr("To avoid possible conflicts, we discourage users from installing base games to the "
|
|
|
|
"NAND.\nPlease, only use this feature to install updates and DLC."));
|
|
|
|
}
|
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
const QString install_results =
|
2020-07-28 01:02:08 +00:00
|
|
|
(new_files.isEmpty() ? QString{}
|
2020-07-01 20:15:57 +00:00
|
|
|
: tr("%n file(s) were newly installed\n", "", new_files.size())) +
|
|
|
|
(overwritten_files.isEmpty()
|
2020-07-28 01:02:08 +00:00
|
|
|
? QString{}
|
2020-07-01 20:15:57 +00:00
|
|
|
: tr("%n file(s) were overwritten\n", "", overwritten_files.size())) +
|
2020-07-28 01:02:08 +00:00
|
|
|
(failed_files.isEmpty() ? QString{}
|
2020-07-01 20:15:57 +00:00
|
|
|
: tr("%n file(s) failed to install\n", "", failed_files.size()));
|
|
|
|
|
|
|
|
QMessageBox::information(this, tr("Install Results"), install_results);
|
2021-06-19 07:43:16 +00:00
|
|
|
Common::FS::RemoveDirRecursively(Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir) /
|
|
|
|
"game_list");
|
2020-07-20 14:30:56 +00:00
|
|
|
game_list->PopulateAsync(UISettings::values.game_dirs);
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Install_File_NAND->setEnabled(true);
|
2020-07-01 20:15:57 +00:00
|
|
|
}
|
|
|
|
|
2020-07-05 13:29:39 +00:00
|
|
|
InstallResult GMainWindow::InstallNSPXCI(const QString& filename) {
|
|
|
|
const auto qt_raw_copy = [this](const FileSys::VirtualFile& src,
|
|
|
|
const FileSys::VirtualFile& dest, std::size_t block_size) {
|
2020-04-17 03:27:38 +00:00
|
|
|
if (src == nullptr || dest == nullptr) {
|
2018-08-10 19:07:06 +00:00
|
|
|
return false;
|
2020-04-17 03:27:38 +00:00
|
|
|
}
|
|
|
|
if (!dest->Resize(src->GetSize())) {
|
2018-08-10 19:07:06 +00:00
|
|
|
return false;
|
2020-04-17 03:27:38 +00:00
|
|
|
}
|
2018-08-10 19:07:06 +00:00
|
|
|
|
2023-06-11 15:43:04 +00:00
|
|
|
std::vector<u8> buffer(1_MiB);
|
2018-08-10 19:07:06 +00:00
|
|
|
|
2018-09-15 13:21:06 +00:00
|
|
|
for (std::size_t i = 0; i < src->GetSize(); i += buffer.size()) {
|
2020-07-05 13:29:39 +00:00
|
|
|
if (install_progress->wasCanceled()) {
|
2018-08-10 19:07:06 +00:00
|
|
|
dest->Resize(0);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-07-05 13:29:39 +00:00
|
|
|
emit UpdateInstallProgress();
|
|
|
|
|
2018-08-10 19:07:06 +00:00
|
|
|
const auto read = src->Read(buffer.data(), buffer.size(), i);
|
|
|
|
dest->Write(buffer.data(), read, i);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
std::shared_ptr<FileSys::NSP> nsp;
|
|
|
|
if (filename.endsWith(QStringLiteral("nsp"), Qt::CaseInsensitive)) {
|
|
|
|
nsp = std::make_shared<FileSys::NSP>(
|
|
|
|
vfs->OpenFile(filename.toStdString(), FileSys::Mode::Read));
|
|
|
|
if (nsp->IsExtractedType()) {
|
|
|
|
return InstallResult::Failure;
|
2020-04-17 03:27:38 +00:00
|
|
|
}
|
2020-07-01 20:15:57 +00:00
|
|
|
} else {
|
|
|
|
const auto xci = std::make_shared<FileSys::XCI>(
|
|
|
|
vfs->OpenFile(filename.toStdString(), FileSys::Mode::Read));
|
|
|
|
nsp = xci->GetSecurePartitionNSP();
|
|
|
|
}
|
2018-08-12 03:01:38 +00:00
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
if (nsp->GetStatus() != Loader::ResultStatus::Success) {
|
|
|
|
return InstallResult::Failure;
|
|
|
|
}
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto res = system->GetFileSystemController().GetUserNANDContents()->InstallEntry(
|
2021-09-03 01:40:55 +00:00
|
|
|
*nsp, true, qt_raw_copy);
|
2021-05-16 04:24:06 +00:00
|
|
|
switch (res) {
|
|
|
|
case FileSys::InstallResult::Success:
|
2020-07-01 20:15:57 +00:00
|
|
|
return InstallResult::Success;
|
2021-05-16 04:24:06 +00:00
|
|
|
case FileSys::InstallResult::OverwriteExisting:
|
2020-07-05 13:29:39 +00:00
|
|
|
return InstallResult::Overwrite;
|
2021-05-16 04:24:06 +00:00
|
|
|
case FileSys::InstallResult::ErrorBaseInstall:
|
|
|
|
return InstallResult::BaseInstallAttempted;
|
|
|
|
default:
|
2020-07-01 20:15:57 +00:00
|
|
|
return InstallResult::Failure;
|
|
|
|
}
|
|
|
|
}
|
2018-08-12 03:01:38 +00:00
|
|
|
|
2020-07-05 13:29:39 +00:00
|
|
|
InstallResult GMainWindow::InstallNCA(const QString& filename) {
|
|
|
|
const auto qt_raw_copy = [this](const FileSys::VirtualFile& src,
|
|
|
|
const FileSys::VirtualFile& dest, std::size_t block_size) {
|
2020-07-01 20:15:57 +00:00
|
|
|
if (src == nullptr || dest == nullptr) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (!dest->Resize(src->GetSize())) {
|
|
|
|
return false;
|
|
|
|
}
|
2018-08-12 03:01:38 +00:00
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
std::array<u8, 0x1000> buffer{};
|
2018-08-25 15:50:04 +00:00
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
for (std::size_t i = 0; i < src->GetSize(); i += buffer.size()) {
|
2020-07-05 13:29:39 +00:00
|
|
|
if (install_progress->wasCanceled()) {
|
2020-07-01 20:15:57 +00:00
|
|
|
dest->Resize(0);
|
|
|
|
return false;
|
2020-04-17 03:27:38 +00:00
|
|
|
}
|
2018-08-10 01:33:13 +00:00
|
|
|
|
2020-07-05 13:29:39 +00:00
|
|
|
emit UpdateInstallProgress();
|
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
const auto read = src->Read(buffer.data(), buffer.size(), i);
|
|
|
|
dest->Write(buffer.data(), read, i);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
};
|
2018-09-27 13:19:53 +00:00
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
const auto nca =
|
|
|
|
std::make_shared<FileSys::NCA>(vfs->OpenFile(filename.toStdString(), FileSys::Mode::Read));
|
|
|
|
const auto id = nca->GetStatus();
|
2018-08-16 14:37:56 +00:00
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
// Game updates necessary are missing base RomFS
|
|
|
|
if (id != Loader::ResultStatus::Success &&
|
|
|
|
id != Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
|
|
|
|
return InstallResult::Failure;
|
|
|
|
}
|
2020-04-17 03:27:38 +00:00
|
|
|
|
2020-07-01 20:15:57 +00:00
|
|
|
const QStringList tt_options{tr("System Application"),
|
|
|
|
tr("System Archive"),
|
|
|
|
tr("System Application Update"),
|
|
|
|
tr("Firmware Package (Type A)"),
|
|
|
|
tr("Firmware Package (Type B)"),
|
|
|
|
tr("Game"),
|
|
|
|
tr("Game Update"),
|
|
|
|
tr("Game DLC"),
|
|
|
|
tr("Delta Title")};
|
|
|
|
bool ok;
|
|
|
|
const auto item = QInputDialog::getItem(
|
|
|
|
this, tr("Select NCA Install Type..."),
|
|
|
|
tr("Please select the type of title you would like to install this NCA as:\n(In "
|
|
|
|
"most instances, the default 'Game' is fine.)"),
|
|
|
|
tt_options, 5, false, &ok);
|
|
|
|
|
|
|
|
auto index = tt_options.indexOf(item);
|
|
|
|
if (!ok || index == -1) {
|
|
|
|
QMessageBox::warning(this, tr("Failed to Install"),
|
|
|
|
tr("The title type you selected for the NCA is invalid."));
|
|
|
|
return InstallResult::Failure;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If index is equal to or past Game, add the jump in TitleType.
|
|
|
|
if (index >= 5) {
|
|
|
|
index += static_cast<size_t>(FileSys::TitleType::Application) -
|
|
|
|
static_cast<size_t>(FileSys::TitleType::FirmwarePackageB);
|
|
|
|
}
|
|
|
|
|
2021-10-15 19:57:25 +00:00
|
|
|
const bool is_application = index >= static_cast<s32>(FileSys::TitleType::Application);
|
2021-10-14 18:32:19 +00:00
|
|
|
const auto& fs_controller = system->GetFileSystemController();
|
2021-10-15 19:57:25 +00:00
|
|
|
auto* registered_cache = is_application ? fs_controller.GetUserNANDContents()
|
|
|
|
: fs_controller.GetSystemNANDContents();
|
2020-04-17 03:27:38 +00:00
|
|
|
|
2021-10-15 19:57:25 +00:00
|
|
|
const auto res = registered_cache->InstallEntry(*nca, static_cast<FileSys::TitleType>(index),
|
|
|
|
true, qt_raw_copy);
|
2020-07-01 20:15:57 +00:00
|
|
|
if (res == FileSys::InstallResult::Success) {
|
|
|
|
return InstallResult::Success;
|
2020-07-12 16:28:18 +00:00
|
|
|
} else if (res == FileSys::InstallResult::OverwriteExisting) {
|
2020-07-05 13:29:39 +00:00
|
|
|
return InstallResult::Overwrite;
|
2020-07-01 20:15:57 +00:00
|
|
|
} else {
|
|
|
|
return InstallResult::Failure;
|
2018-08-10 01:33:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-28 16:43:18 +00:00
|
|
|
void GMainWindow::OnMenuRecentFile() {
|
|
|
|
QAction* action = qobject_cast<QAction*>(sender());
|
|
|
|
assert(action);
|
|
|
|
|
2018-08-06 18:12:57 +00:00
|
|
|
const QString filename = action->data().toString();
|
|
|
|
if (QFileInfo::exists(filename)) {
|
2017-02-17 06:32:22 +00:00
|
|
|
BootGame(filename);
|
2015-07-28 16:43:18 +00:00
|
|
|
} else {
|
|
|
|
// Display an error message and remove the file from the list.
|
2016-09-18 00:38:01 +00:00
|
|
|
QMessageBox::information(this, tr("File not found"),
|
|
|
|
tr("File \"%1\" not found").arg(filename));
|
2015-07-28 16:43:18 +00:00
|
|
|
|
2016-01-24 20:23:55 +00:00
|
|
|
UISettings::values.recent_files.removeOne(filename);
|
2015-08-17 20:50:52 +00:00
|
|
|
UpdateRecentFiles();
|
2015-07-28 16:43:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnStartGame() {
|
2019-09-03 21:00:34 +00:00
|
|
|
PreventOSSleep();
|
|
|
|
|
2015-04-28 23:03:01 +00:00
|
|
|
emu_thread->SetRunning(true);
|
2018-11-11 21:39:25 +00:00
|
|
|
|
2021-11-25 02:27:25 +00:00
|
|
|
UpdateMenuState();
|
2021-11-22 01:28:47 +00:00
|
|
|
OnTasStateChanged();
|
2018-09-16 18:05:51 +00:00
|
|
|
|
|
|
|
discord_rpc->Update();
|
2021-11-25 02:27:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnRestartGame() {
|
|
|
|
if (!system->IsPoweredOn()) {
|
|
|
|
return;
|
|
|
|
}
|
2023-02-17 03:16:28 +00:00
|
|
|
// Make a copy since ShutdownGame edits game_path
|
|
|
|
const auto current_game = QString(current_game_path);
|
|
|
|
ShutdownGame();
|
|
|
|
BootGame(current_game);
|
2014-04-01 02:26:50 +00:00
|
|
|
}
|
|
|
|
|
2015-07-28 16:43:18 +00:00
|
|
|
void GMainWindow::OnPauseGame() {
|
2015-04-28 23:03:01 +00:00
|
|
|
emu_thread->SetRunning(false);
|
2021-11-25 02:27:25 +00:00
|
|
|
UpdateMenuState();
|
2019-09-03 21:00:34 +00:00
|
|
|
AllowOSSleep();
|
2014-04-01 02:26:50 +00:00
|
|
|
}
|
|
|
|
|
2021-11-25 02:27:25 +00:00
|
|
|
void GMainWindow::OnPauseContinueGame() {
|
|
|
|
if (emulation_running) {
|
|
|
|
if (emu_thread->IsRunning()) {
|
|
|
|
OnPauseGame();
|
|
|
|
} else {
|
2022-07-15 01:42:56 +00:00
|
|
|
RequestGameResume();
|
2021-11-25 02:27:25 +00:00
|
|
|
OnStartGame();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-17 03:31:14 +00:00
|
|
|
void GMainWindow::OnStopGame() {
|
2021-10-14 18:32:19 +00:00
|
|
|
if (system->GetExitLock() && !ConfirmForceLockedExit()) {
|
2019-09-22 02:46:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-12-24 22:31:34 +00:00
|
|
|
if (OnShutdownBegin()) {
|
|
|
|
OnShutdownBeginDialog();
|
2023-01-06 23:50:01 +00:00
|
|
|
} else {
|
|
|
|
OnEmulationStopped();
|
2022-12-24 22:31:34 +00:00
|
|
|
}
|
2014-04-01 02:26:50 +00:00
|
|
|
}
|
|
|
|
|
2019-01-17 07:01:00 +00:00
|
|
|
void GMainWindow::OnLoadComplete() {
|
2019-01-21 16:20:16 +00:00
|
|
|
loading_screen->OnLoadComplete();
|
2019-01-17 07:01:00 +00:00
|
|
|
}
|
|
|
|
|
2020-11-24 23:18:29 +00:00
|
|
|
void GMainWindow::OnExecuteProgram(std::size_t program_index) {
|
|
|
|
ShutdownGame();
|
2021-07-20 05:10:05 +00:00
|
|
|
BootGame(last_filename_booted, 0, program_index);
|
2020-11-24 23:18:29 +00:00
|
|
|
}
|
|
|
|
|
2021-09-26 03:18:14 +00:00
|
|
|
void GMainWindow::OnExit() {
|
|
|
|
OnStopGame();
|
|
|
|
}
|
|
|
|
|
2022-09-09 20:29:22 +00:00
|
|
|
void GMainWindow::OnSaveConfig() {
|
|
|
|
system->ApplySettings();
|
|
|
|
config->Save();
|
|
|
|
}
|
|
|
|
|
2021-03-26 10:07:27 +00:00
|
|
|
void GMainWindow::ErrorDisplayDisplayError(QString error_code, QString error_text) {
|
2023-03-25 17:29:08 +00:00
|
|
|
error_applet = new OverlayDialog(render_window, *system, error_code, error_text, QString{},
|
|
|
|
tr("OK"), Qt::AlignLeft | Qt::AlignVCenter);
|
|
|
|
SCOPE_EXIT({
|
|
|
|
error_applet->deleteLater();
|
|
|
|
error_applet = nullptr;
|
|
|
|
});
|
|
|
|
error_applet->exec();
|
2021-03-20 11:57:31 +00:00
|
|
|
|
2019-03-11 23:45:22 +00:00
|
|
|
emit ErrorDisplayFinished();
|
|
|
|
}
|
|
|
|
|
2023-03-25 17:29:08 +00:00
|
|
|
void GMainWindow::ErrorDisplayRequestExit() {
|
|
|
|
if (error_applet) {
|
|
|
|
error_applet->reject();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-16 18:05:51 +00:00
|
|
|
void GMainWindow::OnMenuReportCompatibility() {
|
2022-11-21 16:31:18 +00:00
|
|
|
#if defined(ARCHITECTURE_x86_64) && !defined(__APPLE__)
|
2022-10-26 13:03:55 +00:00
|
|
|
const auto& caps = Common::GetCPUCaps();
|
|
|
|
const bool has_fma = caps.fma || caps.fma4;
|
|
|
|
const auto processor_count = std::thread::hardware_concurrency();
|
|
|
|
const bool has_4threads = processor_count == 0 || processor_count >= 4;
|
2022-11-11 18:15:52 +00:00
|
|
|
const bool has_8gb_ram = Common::GetMemInfo().TotalPhysicalMemory >= 8_GiB;
|
2022-10-26 13:03:55 +00:00
|
|
|
const bool has_broken_vulkan = UISettings::values.has_broken_vulkan;
|
|
|
|
|
|
|
|
if (!has_fma || !has_4threads || !has_8gb_ram || has_broken_vulkan) {
|
|
|
|
QMessageBox::critical(this, tr("Hardware requirements not met"),
|
|
|
|
tr("Your system does not meet the recommended hardware requirements. "
|
|
|
|
"Compatibility reporting has been disabled."));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-06-28 19:58:16 +00:00
|
|
|
if (!Settings::values.yuzu_token.GetValue().empty() &&
|
|
|
|
!Settings::values.yuzu_username.GetValue().empty()) {
|
2021-10-14 18:32:19 +00:00
|
|
|
CompatDB compatdb{system->TelemetrySession(), this};
|
2018-09-16 18:05:51 +00:00
|
|
|
compatdb.exec();
|
|
|
|
} else {
|
|
|
|
QMessageBox::critical(
|
|
|
|
this, tr("Missing yuzu Account"),
|
|
|
|
tr("In order to submit a game compatibility test case, you must link your yuzu "
|
|
|
|
"account.<br><br/>To link your yuzu account, go to Emulation > Configuration "
|
|
|
|
"> "
|
|
|
|
"Web."));
|
|
|
|
}
|
2022-11-21 16:31:18 +00:00
|
|
|
#else
|
|
|
|
QMessageBox::critical(this, tr("Hardware requirements not met"),
|
|
|
|
tr("Your system does not meet the recommended hardware requirements. "
|
|
|
|
"Compatibility reporting has been disabled."));
|
|
|
|
#endif
|
2018-09-16 18:05:51 +00:00
|
|
|
}
|
|
|
|
|
2020-06-25 21:32:43 +00:00
|
|
|
void GMainWindow::OpenURL(const QUrl& url) {
|
2020-06-25 21:02:33 +00:00
|
|
|
const bool open = QDesktopServices::openUrl(url);
|
2020-06-21 04:09:28 +00:00
|
|
|
if (!open) {
|
|
|
|
QMessageBox::warning(this, tr("Error opening URL"),
|
2020-06-25 21:31:01 +00:00
|
|
|
tr("Unable to open the URL \"%1\".").arg(url.toString()));
|
2020-06-21 04:09:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-25 21:02:33 +00:00
|
|
|
void GMainWindow::OnOpenModsPage() {
|
2020-06-25 21:31:01 +00:00
|
|
|
OpenURL(QUrl(QStringLiteral("https://github.com/yuzu-emu/yuzu/wiki/Switch-Mods")));
|
2020-06-25 21:02:33 +00:00
|
|
|
}
|
|
|
|
|
2020-06-26 16:50:28 +00:00
|
|
|
void GMainWindow::OnOpenQuickstartGuide() {
|
2020-06-25 21:31:01 +00:00
|
|
|
OpenURL(QUrl(QStringLiteral("https://yuzu-emu.org/help/quickstart/")));
|
2020-06-25 21:02:33 +00:00
|
|
|
}
|
|
|
|
|
2020-06-27 00:14:29 +00:00
|
|
|
void GMainWindow::OnOpenFAQ() {
|
2020-06-25 21:31:01 +00:00
|
|
|
OpenURL(QUrl(QStringLiteral("https://yuzu-emu.org/wiki/faq/")));
|
2020-06-25 21:02:33 +00:00
|
|
|
}
|
|
|
|
|
2018-01-16 14:50:33 +00:00
|
|
|
void GMainWindow::ToggleFullscreen() {
|
|
|
|
if (!emulation_running) {
|
|
|
|
return;
|
|
|
|
}
|
2021-10-15 19:27:18 +00:00
|
|
|
if (ui->action_Fullscreen->isChecked()) {
|
2018-01-16 14:59:30 +00:00
|
|
|
ShowFullscreen();
|
2018-01-16 14:50:33 +00:00
|
|
|
} else {
|
2018-01-16 14:59:30 +00:00
|
|
|
HideFullscreen();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-05 22:03:03 +00:00
|
|
|
// We're going to return the screen that the given window has the most pixels on
|
|
|
|
static QScreen* GuessCurrentScreen(QWidget* window) {
|
|
|
|
const QList<QScreen*> screens = QGuiApplication::screens();
|
|
|
|
return *std::max_element(
|
|
|
|
screens.cbegin(), screens.cend(), [window](const QScreen* left, const QScreen* right) {
|
|
|
|
const QSize left_size = left->geometry().intersected(window->geometry()).size();
|
|
|
|
const QSize right_size = right->geometry().intersected(window->geometry()).size();
|
|
|
|
return (left_size.height() * left_size.width()) <
|
|
|
|
(right_size.height() * right_size.width());
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2022-12-13 18:17:19 +00:00
|
|
|
bool GMainWindow::UsingExclusiveFullscreen() {
|
|
|
|
return Settings::values.fullscreen_mode.GetValue() == Settings::FullscreenMode::Exclusive ||
|
2022-12-16 13:47:22 +00:00
|
|
|
QGuiApplication::platformName() == QStringLiteral("wayland") ||
|
|
|
|
QGuiApplication::platformName() == QStringLiteral("wayland-egl");
|
2022-12-13 18:17:19 +00:00
|
|
|
}
|
|
|
|
|
2018-01-16 14:59:30 +00:00
|
|
|
void GMainWindow::ShowFullscreen() {
|
2022-12-13 18:17:19 +00:00
|
|
|
const auto show_fullscreen = [this](QWidget* window) {
|
|
|
|
if (UsingExclusiveFullscreen()) {
|
2021-12-19 07:02:09 +00:00
|
|
|
window->showFullScreen();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
window->hide();
|
|
|
|
window->setWindowFlags(window->windowFlags() | Qt::FramelessWindowHint);
|
2022-06-05 22:03:03 +00:00
|
|
|
const auto screen_geometry = GuessCurrentScreen(window)->geometry();
|
2021-12-19 07:02:09 +00:00
|
|
|
window->setGeometry(screen_geometry.x(), screen_geometry.y(), screen_geometry.width(),
|
2023-02-14 21:29:35 +00:00
|
|
|
screen_geometry.height() + 1);
|
2021-12-19 07:02:09 +00:00
|
|
|
window->raise();
|
|
|
|
window->showNormal();
|
|
|
|
};
|
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
if (ui->action_Single_Window_Mode->isChecked()) {
|
2018-01-16 14:59:30 +00:00
|
|
|
UISettings::values.geometry = saveGeometry();
|
2021-04-02 10:46:32 +00:00
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->menubar->hide();
|
2018-01-16 14:59:30 +00:00
|
|
|
statusBar()->hide();
|
2021-04-02 10:46:32 +00:00
|
|
|
|
2021-12-19 07:02:09 +00:00
|
|
|
show_fullscreen(this);
|
2018-01-16 14:59:30 +00:00
|
|
|
} else {
|
|
|
|
UISettings::values.renderwindow_geometry = render_window->saveGeometry();
|
2021-12-19 07:02:09 +00:00
|
|
|
show_fullscreen(render_window);
|
2018-01-16 14:59:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::HideFullscreen() {
|
2021-10-15 19:27:18 +00:00
|
|
|
if (ui->action_Single_Window_Mode->isChecked()) {
|
2022-12-13 18:17:19 +00:00
|
|
|
if (UsingExclusiveFullscreen()) {
|
2021-04-02 10:46:32 +00:00
|
|
|
showNormal();
|
|
|
|
restoreGeometry(UISettings::values.geometry);
|
|
|
|
} else {
|
|
|
|
hide();
|
|
|
|
setWindowFlags(windowFlags() & ~Qt::FramelessWindowHint);
|
|
|
|
restoreGeometry(UISettings::values.geometry);
|
|
|
|
raise();
|
|
|
|
show();
|
|
|
|
}
|
|
|
|
|
2021-10-15 19:27:18 +00:00
|
|
|
statusBar()->setVisible(ui->action_Show_Status_Bar->isChecked());
|
|
|
|
ui->menubar->show();
|
2018-01-16 14:59:30 +00:00
|
|
|
} else {
|
2022-12-13 18:17:19 +00:00
|
|
|
if (UsingExclusiveFullscreen()) {
|
2021-04-02 10:46:32 +00:00
|
|
|
render_window->showNormal();
|
|
|
|
render_window->restoreGeometry(UISettings::values.renderwindow_geometry);
|
|
|
|
} else {
|
|
|
|
render_window->hide();
|
|
|
|
render_window->setWindowFlags(windowFlags() & ~Qt::FramelessWindowHint);
|
|
|
|
render_window->restoreGeometry(UISettings::values.renderwindow_geometry);
|
|
|
|
render_window->raise();
|
|
|
|
render_window->show();
|
|
|
|
}
|
2018-01-16 14:50:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-16 22:35:09 +00:00
|
|
|
void GMainWindow::ToggleWindowMode() {
|
2021-10-15 19:27:18 +00:00
|
|
|
if (ui->action_Single_Window_Mode->isChecked()) {
|
2015-04-16 22:35:09 +00:00
|
|
|
// Render in the main window...
|
2014-04-22 03:15:17 +00:00
|
|
|
render_window->BackupGeometry();
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->horizontalLayout->addWidget(render_window);
|
2020-03-26 18:36:49 +00:00
|
|
|
render_window->setFocusPolicy(Qt::StrongFocus);
|
2015-09-01 01:30:06 +00:00
|
|
|
if (emulation_running) {
|
|
|
|
render_window->setVisible(true);
|
|
|
|
render_window->setFocus();
|
2015-10-06 19:20:26 +00:00
|
|
|
game_list->hide();
|
2015-09-01 01:30:06 +00:00
|
|
|
}
|
2015-04-16 22:35:09 +00:00
|
|
|
|
|
|
|
} else {
|
|
|
|
// Render in a separate window...
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->horizontalLayout->removeWidget(render_window);
|
2015-04-16 22:35:09 +00:00
|
|
|
render_window->setParent(nullptr);
|
|
|
|
render_window->setFocusPolicy(Qt::NoFocus);
|
2015-09-01 01:30:06 +00:00
|
|
|
if (emulation_running) {
|
|
|
|
render_window->setVisible(true);
|
|
|
|
render_window->RestoreGeometry();
|
2015-09-01 04:35:33 +00:00
|
|
|
game_list->show();
|
2015-09-01 01:30:06 +00:00
|
|
|
}
|
2014-04-01 02:26:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-11 01:04:58 +00:00
|
|
|
void GMainWindow::ResetWindowSize(u32 width, u32 height) {
|
2020-05-15 20:22:27 +00:00
|
|
|
const auto aspect_ratio = Layout::EmulationAspectRatio(
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
static_cast<Layout::AspectRatio>(Settings::values.aspect_ratio.GetValue()),
|
2021-10-11 01:04:58 +00:00
|
|
|
static_cast<float>(height) / width);
|
2021-10-15 19:27:18 +00:00
|
|
|
if (!ui->action_Single_Window_Mode->isChecked()) {
|
2021-10-11 01:04:58 +00:00
|
|
|
render_window->resize(height / aspect_ratio, height);
|
2020-05-15 20:22:27 +00:00
|
|
|
} else {
|
2021-10-15 19:27:18 +00:00
|
|
|
const bool show_status_bar = ui->action_Show_Status_Bar->isChecked();
|
2021-10-11 01:04:58 +00:00
|
|
|
const auto status_bar_height = show_status_bar ? statusBar()->height() : 0;
|
|
|
|
resize(height / aspect_ratio, height + menuBar()->height() + status_bar_height);
|
2020-05-15 20:22:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-11 01:04:58 +00:00
|
|
|
void GMainWindow::ResetWindowSize720() {
|
|
|
|
ResetWindowSize(Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height);
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::ResetWindowSize900() {
|
|
|
|
ResetWindowSize(1600U, 900U);
|
|
|
|
}
|
|
|
|
|
2020-12-09 18:53:43 +00:00
|
|
|
void GMainWindow::ResetWindowSize1080() {
|
2021-10-11 01:04:58 +00:00
|
|
|
ResetWindowSize(Layout::ScreenDocked::Width, Layout::ScreenDocked::Height);
|
2020-12-09 18:53:43 +00:00
|
|
|
}
|
|
|
|
|
2015-07-28 16:43:18 +00:00
|
|
|
void GMainWindow::OnConfigure() {
|
2019-05-26 04:39:23 +00:00
|
|
|
const auto old_theme = UISettings::values.theme;
|
2021-06-28 21:32:24 +00:00
|
|
|
const bool old_discord_presence = UISettings::values.enable_discord_presence.GetValue();
|
2023-06-03 15:17:03 +00:00
|
|
|
const auto old_language_index = Settings::values.language_index.GetValue();
|
2018-11-04 00:38:39 +00:00
|
|
|
|
2021-09-03 01:40:55 +00:00
|
|
|
Settings::SetConfiguringGlobal(true);
|
2023-05-28 21:46:02 +00:00
|
|
|
ConfigureDialog configure_dialog(this, hotkey_registry, input_subsystem.get(),
|
|
|
|
vk_device_records, *system,
|
2021-12-25 19:27:52 +00:00
|
|
|
!multiplayer_state->IsHostingPublicRoom());
|
2020-01-25 23:26:07 +00:00
|
|
|
connect(&configure_dialog, &ConfigureDialog::LanguageChanged, this,
|
|
|
|
&GMainWindow::OnLanguageChanged);
|
|
|
|
|
2019-05-26 04:39:23 +00:00
|
|
|
const auto result = configure_dialog.exec();
|
2021-05-26 00:49:42 +00:00
|
|
|
if (result != QDialog::Accepted && !UISettings::values.configuration_applied &&
|
|
|
|
!UISettings::values.reset_to_defaults) {
|
|
|
|
// Runs if the user hit Cancel or closed the window, and did not ever press the Apply button
|
|
|
|
// or `Reset to Defaults` button
|
2019-05-26 04:39:23 +00:00
|
|
|
return;
|
2021-05-17 20:13:39 +00:00
|
|
|
} else if (result == QDialog::Accepted) {
|
2021-05-26 00:49:42 +00:00
|
|
|
// Only apply new changes if user hit Okay
|
|
|
|
// This is here to avoid applying changes if the user hit Apply, made some changes, then hit
|
|
|
|
// Cancel
|
2021-05-17 20:13:39 +00:00
|
|
|
configure_dialog.ApplyConfiguration();
|
2021-05-26 00:49:42 +00:00
|
|
|
} else if (UISettings::values.reset_to_defaults) {
|
|
|
|
LOG_INFO(Frontend, "Resetting all settings to defaults");
|
|
|
|
if (!Common::FS::RemoveFile(config->GetConfigFilePath())) {
|
|
|
|
LOG_WARNING(Frontend, "Failed to remove configuration file");
|
|
|
|
}
|
|
|
|
if (!Common::FS::RemoveDirContentsRecursively(
|
|
|
|
Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir) / "custom")) {
|
|
|
|
LOG_WARNING(Frontend, "Failed to remove custom configuration files");
|
|
|
|
}
|
|
|
|
if (!Common::FS::RemoveDirRecursively(
|
|
|
|
Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir) / "game_list")) {
|
|
|
|
LOG_WARNING(Frontend, "Failed to remove game metadata cache files");
|
|
|
|
}
|
|
|
|
|
2021-05-26 02:14:55 +00:00
|
|
|
// Explicitly save the game directories, since reinitializing config does not explicitly do
|
|
|
|
// so.
|
|
|
|
QVector<UISettings::GameDir> old_game_dirs = std::move(UISettings::values.game_dirs);
|
|
|
|
QVector<u64> old_favorited_ids = std::move(UISettings::values.favorited_ids);
|
2021-05-26 00:49:42 +00:00
|
|
|
|
|
|
|
Settings::values.disabled_addons.clear();
|
2021-05-26 00:48:02 +00:00
|
|
|
|
2022-07-10 15:29:10 +00:00
|
|
|
config = std::make_unique<Config>();
|
2021-05-26 00:49:42 +00:00
|
|
|
UISettings::values.reset_to_defaults = false;
|
|
|
|
|
2021-05-26 02:14:55 +00:00
|
|
|
UISettings::values.game_dirs = std::move(old_game_dirs);
|
|
|
|
UISettings::values.favorited_ids = std::move(old_favorited_ids);
|
2021-05-26 00:49:42 +00:00
|
|
|
|
|
|
|
InitializeRecentFileMenuActions();
|
|
|
|
|
|
|
|
SetDefaultUIGeometry();
|
|
|
|
RestoreUIState();
|
|
|
|
|
|
|
|
ShowTelemetryCallout();
|
2019-05-26 04:39:23 +00:00
|
|
|
}
|
|
|
|
InitializeHotkeys();
|
2021-05-26 00:48:02 +00:00
|
|
|
|
2019-05-26 04:39:23 +00:00
|
|
|
if (UISettings::values.theme != old_theme) {
|
|
|
|
UpdateUITheme();
|
|
|
|
}
|
2021-06-28 21:32:24 +00:00
|
|
|
if (UISettings::values.enable_discord_presence.GetValue() != old_discord_presence) {
|
|
|
|
SetDiscordEnabled(UISettings::values.enable_discord_presence.GetValue());
|
2019-05-26 04:39:23 +00:00
|
|
|
}
|
2021-12-25 19:27:52 +00:00
|
|
|
|
|
|
|
if (!multiplayer_state->IsHostingPublicRoom()) {
|
|
|
|
multiplayer_state->UpdateCredentials();
|
|
|
|
}
|
|
|
|
|
2019-05-01 21:21:04 +00:00
|
|
|
emit UpdateThemedIcons();
|
2019-05-26 04:39:23 +00:00
|
|
|
|
|
|
|
const auto reload = UISettings::values.is_game_list_reload_pending.exchange(false);
|
2023-06-03 15:17:03 +00:00
|
|
|
if (reload || Settings::values.language_index.GetValue() != old_language_index) {
|
2019-05-01 21:21:04 +00:00
|
|
|
game_list->PopulateAsync(UISettings::values.game_dirs);
|
2016-01-24 17:34:05 +00:00
|
|
|
}
|
2019-05-26 04:39:23 +00:00
|
|
|
|
2021-05-17 20:13:39 +00:00
|
|
|
UISettings::values.configuration_applied = false;
|
|
|
|
|
2019-05-26 04:39:23 +00:00
|
|
|
config->Save();
|
2020-01-28 22:59:30 +00:00
|
|
|
|
2021-02-03 18:34:25 +00:00
|
|
|
if ((UISettings::values.hide_mouse || Settings::values.mouse_panning) && emulation_running) {
|
2020-12-30 19:41:14 +00:00
|
|
|
render_window->installEventFilter(render_window);
|
|
|
|
render_window->setAttribute(Qt::WA_Hover, true);
|
2020-04-11 02:22:50 +00:00
|
|
|
} else {
|
2020-12-30 19:41:14 +00:00
|
|
|
render_window->removeEventFilter(render_window);
|
|
|
|
render_window->setAttribute(Qt::WA_Hover, false);
|
2020-04-11 02:22:50 +00:00
|
|
|
}
|
|
|
|
|
2021-02-24 02:39:02 +00:00
|
|
|
if (UISettings::values.hide_mouse) {
|
|
|
|
mouse_hide_timer.start();
|
|
|
|
}
|
|
|
|
|
2022-06-19 04:34:28 +00:00
|
|
|
// Restart camera config
|
|
|
|
if (emulation_running) {
|
|
|
|
render_window->FinalizeCamera();
|
|
|
|
render_window->InitializeCamera();
|
|
|
|
}
|
|
|
|
|
2022-05-30 02:26:27 +00:00
|
|
|
if (!UISettings::values.has_broken_vulkan) {
|
|
|
|
renderer_status_button->setEnabled(!emulation_running);
|
|
|
|
}
|
|
|
|
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
UpdateStatusButtons();
|
2021-11-04 19:08:30 +00:00
|
|
|
controller_dialog->refreshConfiguration();
|
2022-07-10 15:29:10 +00:00
|
|
|
system->ApplySettings();
|
2014-04-01 02:26:50 +00:00
|
|
|
}
|
|
|
|
|
2021-06-19 19:38:49 +00:00
|
|
|
void GMainWindow::OnConfigureTas() {
|
|
|
|
ConfigureTasDialog dialog(this);
|
|
|
|
const auto result = dialog.exec();
|
|
|
|
|
|
|
|
if (result != QDialog::Accepted && !UISettings::values.configuration_applied) {
|
2021-10-14 18:32:19 +00:00
|
|
|
Settings::RestoreGlobalState(system->IsPoweredOn());
|
2021-06-19 19:38:49 +00:00
|
|
|
return;
|
|
|
|
} else if (result == QDialog::Accepted) {
|
|
|
|
dialog.ApplyConfiguration();
|
2023-02-16 16:53:42 +00:00
|
|
|
OnSaveConfig();
|
2021-06-19 19:38:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-22 01:28:47 +00:00
|
|
|
void GMainWindow::OnTasStartStop() {
|
|
|
|
if (!emulation_running) {
|
|
|
|
return;
|
|
|
|
}
|
2021-11-15 23:57:41 +00:00
|
|
|
|
|
|
|
// Disable system buttons to prevent TAS from executing a hotkey
|
|
|
|
auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
|
|
|
|
controller->ResetSystemButtons();
|
|
|
|
|
2021-11-22 01:28:47 +00:00
|
|
|
input_subsystem->GetTas()->StartStop();
|
|
|
|
OnTasStateChanged();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnTasRecord() {
|
|
|
|
if (!emulation_running) {
|
|
|
|
return;
|
|
|
|
}
|
2021-11-15 23:57:41 +00:00
|
|
|
if (is_tas_recording_dialog_active) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Disable system buttons to prevent TAS from recording a hotkey
|
|
|
|
auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
|
|
|
|
controller->ResetSystemButtons();
|
|
|
|
|
2021-11-22 02:07:37 +00:00
|
|
|
const bool is_recording = input_subsystem->GetTas()->Record();
|
2021-11-22 01:28:47 +00:00
|
|
|
if (!is_recording) {
|
2021-11-15 23:57:41 +00:00
|
|
|
is_tas_recording_dialog_active = true;
|
|
|
|
ControllerNavigation* controller_navigation =
|
|
|
|
new ControllerNavigation(system->HIDCore(), this);
|
|
|
|
// Use QMessageBox instead of question so we can link controller navigation
|
|
|
|
QMessageBox* box_dialog = new QMessageBox();
|
|
|
|
box_dialog->setWindowTitle(tr("TAS Recording"));
|
|
|
|
box_dialog->setText(tr("Overwrite file of player 1?"));
|
|
|
|
box_dialog->setStandardButtons(QMessageBox::Yes | QMessageBox::No);
|
|
|
|
box_dialog->setDefaultButton(QMessageBox::Yes);
|
|
|
|
connect(controller_navigation, &ControllerNavigation::TriggerKeyboardEvent,
|
|
|
|
[box_dialog](Qt::Key key) {
|
|
|
|
QKeyEvent* event = new QKeyEvent(QEvent::KeyPress, key, Qt::NoModifier);
|
|
|
|
QCoreApplication::postEvent(box_dialog, event);
|
|
|
|
});
|
|
|
|
int res = box_dialog->exec();
|
|
|
|
controller_navigation->UnloadController();
|
2021-11-22 01:28:47 +00:00
|
|
|
input_subsystem->GetTas()->SaveRecording(res == QMessageBox::Yes);
|
2021-11-15 23:57:41 +00:00
|
|
|
is_tas_recording_dialog_active = false;
|
2021-11-22 01:28:47 +00:00
|
|
|
}
|
|
|
|
OnTasStateChanged();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnTasReset() {
|
|
|
|
input_subsystem->GetTas()->Reset();
|
|
|
|
}
|
|
|
|
|
2022-02-07 02:27:38 +00:00
|
|
|
void GMainWindow::OnToggleDockedMode() {
|
|
|
|
const bool is_docked = Settings::values.use_docked_mode.GetValue();
|
|
|
|
auto* player_1 = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
|
|
|
|
auto* handheld = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
|
|
|
|
|
|
|
|
if (!is_docked && handheld->IsConnected()) {
|
|
|
|
QMessageBox::warning(this, tr("Invalid config detected"),
|
|
|
|
tr("Handheld controller can't be used on docked mode. Pro "
|
|
|
|
"controller will be selected."));
|
|
|
|
handheld->Disconnect();
|
|
|
|
player_1->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
|
|
|
|
player_1->Connect();
|
|
|
|
controller_dialog->refreshConfiguration();
|
|
|
|
}
|
|
|
|
|
|
|
|
Settings::values.use_docked_mode.SetValue(!is_docked);
|
2022-06-01 07:59:58 +00:00
|
|
|
UpdateDockedButton();
|
2022-02-07 02:27:38 +00:00
|
|
|
OnDockedModeChanged(is_docked, !is_docked, *system);
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnToggleGpuAccuracy() {
|
|
|
|
switch (Settings::values.gpu_accuracy.GetValue()) {
|
|
|
|
case Settings::GPUAccuracy::High: {
|
|
|
|
Settings::values.gpu_accuracy.SetValue(Settings::GPUAccuracy::Normal);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Settings::GPUAccuracy::Normal:
|
|
|
|
case Settings::GPUAccuracy::Extreme:
|
|
|
|
default: {
|
|
|
|
Settings::values.gpu_accuracy.SetValue(Settings::GPUAccuracy::High);
|
2022-11-11 12:12:37 +00:00
|
|
|
break;
|
2022-02-07 02:27:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
system->ApplySettings();
|
|
|
|
UpdateGPUAccuracyButton();
|
|
|
|
}
|
|
|
|
|
2023-01-19 14:13:23 +00:00
|
|
|
void GMainWindow::OnMute() {
|
|
|
|
Settings::values.audio_muted = !Settings::values.audio_muted;
|
|
|
|
UpdateVolumeUI();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnDecreaseVolume() {
|
|
|
|
Settings::values.audio_muted = false;
|
|
|
|
const auto current_volume = static_cast<s32>(Settings::values.volume.GetValue());
|
|
|
|
int step = 5;
|
|
|
|
if (current_volume <= 30) {
|
|
|
|
step = 2;
|
|
|
|
}
|
|
|
|
if (current_volume <= 6) {
|
|
|
|
step = 1;
|
|
|
|
}
|
|
|
|
Settings::values.volume.SetValue(std::max(current_volume - step, 0));
|
|
|
|
UpdateVolumeUI();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnIncreaseVolume() {
|
|
|
|
Settings::values.audio_muted = false;
|
|
|
|
const auto current_volume = static_cast<s32>(Settings::values.volume.GetValue());
|
|
|
|
int step = 5;
|
|
|
|
if (current_volume < 30) {
|
|
|
|
step = 2;
|
|
|
|
}
|
|
|
|
if (current_volume < 6) {
|
|
|
|
step = 1;
|
|
|
|
}
|
|
|
|
Settings::values.volume.SetValue(current_volume + step);
|
|
|
|
UpdateVolumeUI();
|
|
|
|
}
|
|
|
|
|
2022-02-07 02:27:38 +00:00
|
|
|
void GMainWindow::OnToggleAdaptingFilter() {
|
|
|
|
auto filter = Settings::values.scaling_filter.GetValue();
|
|
|
|
if (filter == Settings::ScalingFilter::LastFilter) {
|
|
|
|
filter = Settings::ScalingFilter::NearestNeighbor;
|
|
|
|
} else {
|
|
|
|
filter = static_cast<Settings::ScalingFilter>(static_cast<u32>(filter) + 1);
|
|
|
|
}
|
|
|
|
Settings::values.scaling_filter.SetValue(filter);
|
|
|
|
filter_status_button->setChecked(true);
|
|
|
|
UpdateFilterText();
|
|
|
|
}
|
|
|
|
|
2022-11-28 01:37:37 +00:00
|
|
|
void GMainWindow::OnToggleGraphicsAPI() {
|
|
|
|
auto api = Settings::values.renderer_backend.GetValue();
|
|
|
|
if (api == Settings::RendererBackend::OpenGL) {
|
|
|
|
api = Settings::RendererBackend::Vulkan;
|
|
|
|
} else {
|
|
|
|
api = Settings::RendererBackend::OpenGL;
|
|
|
|
}
|
|
|
|
Settings::values.renderer_backend.SetValue(api);
|
|
|
|
renderer_status_button->setChecked(api == Settings::RendererBackend::Vulkan);
|
|
|
|
UpdateAPIText();
|
|
|
|
}
|
|
|
|
|
2020-08-11 18:57:29 +00:00
|
|
|
void GMainWindow::OnConfigurePerGame() {
|
2023-02-13 16:21:43 +00:00
|
|
|
const u64 title_id = system->GetApplicationProcessProgramID();
|
2022-05-26 23:57:35 +00:00
|
|
|
OpenPerGameConfiguration(title_id, current_game_path.toStdString());
|
2020-08-11 18:57:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OpenPerGameConfiguration(u64 title_id, const std::string& file_name) {
|
|
|
|
const auto v_file = Core::GetGameFileFromPath(vfs, file_name);
|
|
|
|
|
2021-09-03 01:40:55 +00:00
|
|
|
Settings::SetConfiguringGlobal(false);
|
2023-05-28 21:46:02 +00:00
|
|
|
ConfigurePerGame dialog(this, title_id, file_name, vk_device_records, *system);
|
2020-08-11 18:57:29 +00:00
|
|
|
dialog.LoadFromFile(v_file);
|
2020-11-27 15:50:48 +00:00
|
|
|
const auto result = dialog.exec();
|
2021-05-17 20:13:39 +00:00
|
|
|
|
|
|
|
if (result != QDialog::Accepted && !UISettings::values.configuration_applied) {
|
2021-10-14 18:32:19 +00:00
|
|
|
Settings::RestoreGlobalState(system->IsPoweredOn());
|
2021-05-17 20:13:39 +00:00
|
|
|
return;
|
|
|
|
} else if (result == QDialog::Accepted) {
|
2020-08-11 18:57:29 +00:00
|
|
|
dialog.ApplyConfiguration();
|
2021-05-17 20:13:39 +00:00
|
|
|
}
|
2020-08-11 18:57:29 +00:00
|
|
|
|
2021-05-17 20:13:39 +00:00
|
|
|
const auto reload = UISettings::values.is_game_list_reload_pending.exchange(false);
|
|
|
|
if (reload) {
|
|
|
|
game_list->PopulateAsync(UISettings::values.game_dirs);
|
|
|
|
}
|
2020-08-11 18:57:29 +00:00
|
|
|
|
2021-05-17 20:13:39 +00:00
|
|
|
// Do not cause the global config to write local settings into the config file
|
2021-10-14 18:32:19 +00:00
|
|
|
const bool is_powered_on = system->IsPoweredOn();
|
2021-05-17 20:13:39 +00:00
|
|
|
Settings::RestoreGlobalState(is_powered_on);
|
2022-11-18 00:23:48 +00:00
|
|
|
system->HIDCore().ReloadInputDevices();
|
2020-08-11 18:57:29 +00:00
|
|
|
|
2021-05-17 20:13:39 +00:00
|
|
|
UISettings::values.configuration_applied = false;
|
|
|
|
|
|
|
|
if (!is_powered_on) {
|
|
|
|
config->Save();
|
2020-08-11 18:57:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-29 03:02:29 +00:00
|
|
|
bool GMainWindow::CreateShortcut(const std::string& shortcut_path, const std::string& title,
|
|
|
|
const std::string& comment, const std::string& icon_path,
|
|
|
|
const std::string& command, const std::string& arguments,
|
|
|
|
const std::string& categories, const std::string& keywords) {
|
|
|
|
#if defined(__linux__) || defined(__FreeBSD__)
|
2023-03-12 03:10:38 +00:00
|
|
|
// This desktop file template was writing referencing
|
2021-07-29 03:02:29 +00:00
|
|
|
// https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html
|
|
|
|
std::string shortcut_contents{};
|
|
|
|
shortcut_contents.append("[Desktop Entry]\n");
|
|
|
|
shortcut_contents.append("Type=Application\n");
|
|
|
|
shortcut_contents.append("Version=1.0\n");
|
|
|
|
shortcut_contents.append(fmt::format("Name={:s}\n", title));
|
|
|
|
shortcut_contents.append(fmt::format("Comment={:s}\n", comment));
|
|
|
|
shortcut_contents.append(fmt::format("Icon={:s}\n", icon_path));
|
|
|
|
shortcut_contents.append(fmt::format("TryExec={:s}\n", command));
|
|
|
|
shortcut_contents.append(fmt::format("Exec={:s} {:s}\n", command, arguments));
|
|
|
|
shortcut_contents.append(fmt::format("Categories={:s}\n", categories));
|
|
|
|
shortcut_contents.append(fmt::format("Keywords={:s}\n", keywords));
|
|
|
|
|
|
|
|
std::ofstream shortcut_stream(shortcut_path);
|
|
|
|
if (!shortcut_stream.is_open()) {
|
|
|
|
LOG_WARNING(Common, "Failed to create file {:s}", shortcut_path);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
shortcut_stream << shortcut_contents;
|
|
|
|
shortcut_stream.close();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
#endif
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-10-23 23:28:17 +00:00
|
|
|
void GMainWindow::OnLoadAmiibo() {
|
2021-11-25 02:27:25 +00:00
|
|
|
if (emu_thread == nullptr || !emu_thread->IsRunning()) {
|
|
|
|
return;
|
|
|
|
}
|
2021-11-15 23:57:41 +00:00
|
|
|
if (is_amiibo_file_select_active) {
|
|
|
|
return;
|
|
|
|
}
|
2021-11-25 02:27:25 +00:00
|
|
|
|
2022-09-25 01:31:54 +00:00
|
|
|
auto* virtual_amiibo = input_subsystem->GetVirtualAmiibo();
|
|
|
|
|
|
|
|
// Remove amiibo if one is connected
|
2023-06-17 03:57:21 +00:00
|
|
|
if (virtual_amiibo->GetCurrentState() == InputCommon::VirtualAmiibo::State::TagNearby) {
|
2022-09-25 01:31:54 +00:00
|
|
|
virtual_amiibo->CloseAmiibo();
|
2022-02-20 07:58:34 +00:00
|
|
|
QMessageBox::warning(this, tr("Amiibo"), tr("The current amiibo has been removed"));
|
2022-02-08 03:39:39 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-09-25 01:31:54 +00:00
|
|
|
if (virtual_amiibo->GetCurrentState() != InputCommon::VirtualAmiibo::State::WaitingForAmiibo) {
|
2022-02-08 03:39:39 +00:00
|
|
|
QMessageBox::warning(this, tr("Error"), tr("The current game is not looking for amiibos"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-11-15 23:57:41 +00:00
|
|
|
is_amiibo_file_select_active = true;
|
2019-05-24 23:44:06 +00:00
|
|
|
const QString extensions{QStringLiteral("*.bin")};
|
2018-10-23 23:28:17 +00:00
|
|
|
const QString file_filter = tr("Amiibo File (%1);; All Files (*.*)").arg(extensions);
|
2019-05-24 23:44:06 +00:00
|
|
|
const QString filename = QFileDialog::getOpenFileName(this, tr("Load Amiibo"), {}, file_filter);
|
2021-11-15 23:57:41 +00:00
|
|
|
is_amiibo_file_select_active = false;
|
2018-10-24 13:37:29 +00:00
|
|
|
|
|
|
|
if (filename.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-11-02 18:22:36 +00:00
|
|
|
LoadAmiibo(filename);
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::LoadAmiibo(const QString& filename) {
|
2022-09-25 01:31:54 +00:00
|
|
|
auto* virtual_amiibo = input_subsystem->GetVirtualAmiibo();
|
|
|
|
const QString title = tr("Error loading Amiibo data");
|
2022-02-20 07:58:34 +00:00
|
|
|
// Remove amiibo if one is connected
|
2023-06-17 03:57:21 +00:00
|
|
|
if (virtual_amiibo->GetCurrentState() == InputCommon::VirtualAmiibo::State::TagNearby) {
|
2022-09-25 01:31:54 +00:00
|
|
|
virtual_amiibo->CloseAmiibo();
|
2022-02-20 07:58:34 +00:00
|
|
|
QMessageBox::warning(this, tr("Amiibo"), tr("The current amiibo has been removed"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-09-25 01:31:54 +00:00
|
|
|
switch (virtual_amiibo->LoadAmiibo(filename.toStdString())) {
|
|
|
|
case InputCommon::VirtualAmiibo::Info::NotAnAmiibo:
|
|
|
|
QMessageBox::warning(this, title, tr("The selected file is not a valid amiibo"));
|
|
|
|
break;
|
|
|
|
case InputCommon::VirtualAmiibo::Info::UnableToLoad:
|
|
|
|
QMessageBox::warning(this, title, tr("The selected file is already on use"));
|
|
|
|
break;
|
|
|
|
case InputCommon::VirtualAmiibo::Info::WrongDeviceState:
|
|
|
|
QMessageBox::warning(this, title, tr("The current game is not looking for amiibos"));
|
|
|
|
break;
|
|
|
|
case InputCommon::VirtualAmiibo::Info::Unknown:
|
2022-10-15 21:04:42 +00:00
|
|
|
QMessageBox::warning(this, title, tr("An unknown error occurred"));
|
2022-09-25 01:31:54 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2018-10-23 23:28:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-02 02:05:44 +00:00
|
|
|
void GMainWindow::OnOpenYuzuFolder() {
|
|
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(
|
2021-05-25 23:32:56 +00:00
|
|
|
QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::YuzuDir))));
|
2018-11-02 02:05:44 +00:00
|
|
|
}
|
|
|
|
|
2018-01-14 18:15:45 +00:00
|
|
|
void GMainWindow::OnAbout() {
|
|
|
|
AboutDialog aboutDialog(this);
|
|
|
|
aboutDialog.exec();
|
|
|
|
}
|
|
|
|
|
2017-04-30 02:04:39 +00:00
|
|
|
void GMainWindow::OnToggleFilterBar() {
|
2021-10-15 19:27:18 +00:00
|
|
|
game_list->SetFilterVisible(ui->action_Show_Filter_Bar->isChecked());
|
|
|
|
if (ui->action_Show_Filter_Bar->isChecked()) {
|
2020-09-23 15:28:08 +00:00
|
|
|
game_list->SetFilterFocus();
|
2017-04-30 02:04:39 +00:00
|
|
|
} else {
|
2020-09-23 15:28:08 +00:00
|
|
|
game_list->ClearFilter();
|
2017-04-30 02:04:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-15 23:57:41 +00:00
|
|
|
void GMainWindow::OnToggleStatusBar() {
|
|
|
|
statusBar()->setVisible(ui->action_Show_Status_Bar->isChecked());
|
|
|
|
}
|
|
|
|
|
2018-08-31 06:16:16 +00:00
|
|
|
void GMainWindow::OnCaptureScreenshot() {
|
2021-11-25 02:27:25 +00:00
|
|
|
if (emu_thread == nullptr || !emu_thread->IsRunning()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-02-13 16:21:43 +00:00
|
|
|
const u64 title_id = system->GetApplicationProcessProgramID();
|
2020-07-07 17:47:08 +00:00
|
|
|
const auto screenshot_path =
|
2021-05-25 23:32:56 +00:00
|
|
|
QString::fromStdString(Common::FS::GetYuzuPathString(Common::FS::YuzuPath::ScreenshotsDir));
|
2020-07-07 17:47:08 +00:00
|
|
|
const auto date =
|
|
|
|
QDateTime::currentDateTime().toString(QStringLiteral("yyyy-MM-dd_hh-mm-ss-zzz"));
|
2021-07-25 18:24:08 +00:00
|
|
|
QString filename = QStringLiteral("%1/%2_%3.png")
|
2020-07-07 17:47:08 +00:00
|
|
|
.arg(screenshot_path)
|
|
|
|
.arg(title_id, 16, 16, QLatin1Char{'0'})
|
|
|
|
.arg(date);
|
2020-07-07 03:30:49 +00:00
|
|
|
|
2021-02-12 22:21:44 +00:00
|
|
|
if (!Common::FS::CreateDir(screenshot_path.toStdString())) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-07-07 03:30:49 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
if (UISettings::values.enable_screenshot_save_as) {
|
2021-08-07 20:45:29 +00:00
|
|
|
OnPauseGame();
|
2020-07-07 03:30:49 +00:00
|
|
|
filename = QFileDialog::getSaveFileName(this, tr("Capture Screenshot"), filename,
|
|
|
|
tr("PNG Image (*.png)"));
|
2021-08-07 20:45:29 +00:00
|
|
|
OnStartGame();
|
2020-07-07 03:30:49 +00:00
|
|
|
if (filename.isEmpty()) {
|
|
|
|
return;
|
2019-01-20 03:14:19 +00:00
|
|
|
}
|
2018-08-31 06:16:16 +00:00
|
|
|
}
|
2020-07-07 03:30:49 +00:00
|
|
|
#endif
|
2021-09-10 05:28:02 +00:00
|
|
|
render_window->CaptureScreenshot(filename);
|
2018-08-31 06:16:16 +00:00
|
|
|
}
|
|
|
|
|
2020-09-27 18:20:22 +00:00
|
|
|
// TODO: Written 2020-10-01: Remove per-game config migration code when it is irrelevant
|
|
|
|
void GMainWindow::MigrateConfigFiles() {
|
2021-05-25 23:32:56 +00:00
|
|
|
const auto config_dir_fs_path = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir);
|
|
|
|
const QDir config_dir =
|
|
|
|
QDir(QString::fromStdString(Common::FS::PathToUTF8String(config_dir_fs_path)));
|
2020-09-27 18:20:22 +00:00
|
|
|
const QStringList config_dir_list = config_dir.entryList(QStringList(QStringLiteral("*.ini")));
|
|
|
|
|
2021-05-25 23:32:56 +00:00
|
|
|
if (!Common::FS::CreateDirs(config_dir_fs_path / "custom")) {
|
|
|
|
LOG_ERROR(Frontend, "Failed to create new config file directory");
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto it = config_dir_list.constBegin(); it != config_dir_list.constEnd(); ++it) {
|
2020-09-27 18:20:22 +00:00
|
|
|
const auto filename = it->toStdString();
|
|
|
|
if (filename.find_first_not_of("0123456789abcdefACBDEF", 0) < 16) {
|
|
|
|
continue;
|
|
|
|
}
|
2021-05-25 23:32:56 +00:00
|
|
|
const auto origin = config_dir_fs_path / filename;
|
|
|
|
const auto destination = config_dir_fs_path / "custom" / filename;
|
2022-08-07 21:01:11 +00:00
|
|
|
LOG_INFO(Frontend, "Migrating config file from {} to {}", origin.string(),
|
|
|
|
destination.string());
|
2021-05-25 23:32:56 +00:00
|
|
|
if (!Common::FS::RenameFile(origin, destination)) {
|
2020-09-27 18:20:22 +00:00
|
|
|
// Delete the old config file if one already exists in the new location.
|
2021-06-19 07:43:16 +00:00
|
|
|
Common::FS::RemoveFile(origin);
|
2020-09-27 18:20:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-20 21:26:55 +00:00
|
|
|
void GMainWindow::UpdateWindowTitle(std::string_view title_name, std::string_view title_version,
|
|
|
|
std::string_view gpu_vendor) {
|
2019-10-05 04:10:04 +00:00
|
|
|
const auto branch_name = std::string(Common::g_scm_branch);
|
|
|
|
const auto description = std::string(Common::g_scm_desc);
|
|
|
|
const auto build_id = std::string(Common::g_build_id);
|
|
|
|
|
2021-05-15 20:55:30 +00:00
|
|
|
const auto yuzu_title = fmt::format("yuzu | {}-{}", branch_name, description);
|
2021-06-23 13:59:56 +00:00
|
|
|
const auto override_title =
|
|
|
|
fmt::format(fmt::runtime(std::string(Common::g_title_bar_format_idle)), build_id);
|
2021-05-15 20:55:30 +00:00
|
|
|
const auto window_title = override_title.empty() ? yuzu_title : override_title;
|
2019-05-09 05:41:33 +00:00
|
|
|
|
2020-06-08 21:58:04 +00:00
|
|
|
if (title_name.empty()) {
|
2021-05-15 20:55:30 +00:00
|
|
|
setWindowTitle(QString::fromStdString(window_title));
|
2019-05-09 05:41:33 +00:00
|
|
|
} else {
|
2021-09-30 22:54:21 +00:00
|
|
|
const auto run_title = [window_title, title_name, title_version, gpu_vendor]() {
|
|
|
|
if (title_version.empty()) {
|
|
|
|
return fmt::format("{} | {} | {}", window_title, title_name, gpu_vendor);
|
|
|
|
}
|
|
|
|
return fmt::format("{} | {} | {} | {}", window_title, title_name, title_version,
|
|
|
|
gpu_vendor);
|
|
|
|
}();
|
2021-05-15 20:55:30 +00:00
|
|
|
setWindowTitle(QString::fromStdString(run_title));
|
2019-05-09 05:41:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-21 18:21:47 +00:00
|
|
|
std::string GMainWindow::CreateTASFramesString(
|
|
|
|
std::array<size_t, InputCommon::TasInput::PLAYER_NUMBER> frames) const {
|
|
|
|
std::string string = "";
|
|
|
|
size_t maxPlayerIndex = 0;
|
|
|
|
for (size_t i = 0; i < frames.size(); i++) {
|
|
|
|
if (frames[i] != 0) {
|
|
|
|
if (maxPlayerIndex != 0)
|
|
|
|
string += ", ";
|
|
|
|
while (maxPlayerIndex++ != i)
|
|
|
|
string += "0, ";
|
|
|
|
string += std::to_string(frames[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return string;
|
|
|
|
}
|
|
|
|
|
2021-06-19 22:04:34 +00:00
|
|
|
QString GMainWindow::GetTasStateDescription() const {
|
|
|
|
auto [tas_status, current_tas_frame, total_tas_frames] = input_subsystem->GetTas()->GetStatus();
|
2022-01-21 18:21:47 +00:00
|
|
|
std::string tas_frames_string = CreateTASFramesString(total_tas_frames);
|
2021-06-19 22:04:34 +00:00
|
|
|
switch (tas_status) {
|
2021-10-21 04:18:04 +00:00
|
|
|
case InputCommon::TasInput::TasState::Running:
|
2022-01-21 18:21:47 +00:00
|
|
|
return tr("TAS state: Running %1/%2")
|
|
|
|
.arg(current_tas_frame)
|
|
|
|
.arg(QString::fromStdString(tas_frames_string));
|
2021-09-21 00:39:08 +00:00
|
|
|
case InputCommon::TasInput::TasState::Recording:
|
2022-01-21 18:21:47 +00:00
|
|
|
return tr("TAS state: Recording %1").arg(total_tas_frames[0]);
|
2021-09-21 00:39:08 +00:00
|
|
|
case InputCommon::TasInput::TasState::Stopped:
|
2022-01-21 18:21:47 +00:00
|
|
|
return tr("TAS state: Idle %1/%2")
|
|
|
|
.arg(current_tas_frame)
|
|
|
|
.arg(QString::fromStdString(tas_frames_string));
|
2021-06-19 19:38:49 +00:00
|
|
|
default:
|
2021-06-27 19:02:38 +00:00
|
|
|
return tr("TAS State: Invalid");
|
2021-06-18 14:32:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-22 01:28:47 +00:00
|
|
|
void GMainWindow::OnTasStateChanged() {
|
|
|
|
bool is_running = false;
|
|
|
|
bool is_recording = false;
|
|
|
|
if (emulation_running) {
|
2021-11-22 04:37:50 +00:00
|
|
|
const InputCommon::TasInput::TasState tas_status =
|
|
|
|
std::get<0>(input_subsystem->GetTas()->GetStatus());
|
|
|
|
is_running = tas_status == InputCommon::TasInput::TasState::Running;
|
|
|
|
is_recording = tas_status == InputCommon::TasInput::TasState::Recording;
|
2021-11-22 01:28:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ui->action_TAS_Start->setText(is_running ? tr("&Stop Running") : tr("&Start"));
|
|
|
|
ui->action_TAS_Record->setText(is_recording ? tr("Stop R&ecording") : tr("R&ecord"));
|
|
|
|
|
|
|
|
ui->action_TAS_Start->setEnabled(emulation_running);
|
|
|
|
ui->action_TAS_Record->setEnabled(emulation_running);
|
|
|
|
ui->action_TAS_Reset->setEnabled(emulation_running);
|
|
|
|
}
|
|
|
|
|
2017-02-19 22:34:47 +00:00
|
|
|
void GMainWindow::UpdateStatusBar() {
|
2022-05-30 23:35:01 +00:00
|
|
|
if (emu_thread == nullptr || !system->IsPoweredOn()) {
|
2017-02-19 22:34:47 +00:00
|
|
|
status_bar_update_timer.stop();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-06-19 19:38:49 +00:00
|
|
|
if (Settings::values.tas_enable) {
|
2021-06-19 22:04:34 +00:00
|
|
|
tas_label->setText(GetTasStateDescription());
|
2021-06-19 19:38:49 +00:00
|
|
|
} else {
|
|
|
|
tas_label->clear();
|
|
|
|
}
|
2021-06-18 14:32:46 +00:00
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
auto results = system->GetAndResetPerfStats();
|
|
|
|
auto& shader_notify = system->GPU().ShaderNotify();
|
2021-06-06 03:11:36 +00:00
|
|
|
const int shaders_building = shader_notify.ShadersBuilding();
|
2020-07-10 03:36:38 +00:00
|
|
|
|
2021-06-06 03:11:36 +00:00
|
|
|
if (shaders_building > 0) {
|
|
|
|
shader_building_label->setText(tr("Building: %n shader(s)", "", shaders_building));
|
2020-07-10 03:36:38 +00:00
|
|
|
shader_building_label->setVisible(true);
|
|
|
|
} else {
|
|
|
|
shader_building_label->setVisible(false);
|
|
|
|
}
|
2017-02-19 22:34:47 +00:00
|
|
|
|
2021-07-26 05:58:02 +00:00
|
|
|
const auto res_info = Settings::values.resolution_info;
|
|
|
|
const auto res_scale = res_info.up_factor;
|
|
|
|
res_scale_label->setText(
|
|
|
|
tr("Scale: %1x", "%1 is the resolution scaling factor").arg(res_scale));
|
|
|
|
|
2021-07-22 23:56:21 +00:00
|
|
|
if (Settings::values.use_speed_limit.GetValue()) {
|
2018-08-20 23:14:06 +00:00
|
|
|
emu_speed_label->setText(tr("Speed: %1% / %2%")
|
|
|
|
.arg(results.emulation_speed * 100.0, 0, 'f', 0)
|
2021-07-22 23:56:21 +00:00
|
|
|
.arg(Settings::values.speed_limit.GetValue()));
|
2018-08-20 23:14:06 +00:00
|
|
|
} else {
|
|
|
|
emu_speed_label->setText(tr("Speed: %1%").arg(results.emulation_speed * 100.0, 0, 'f', 0));
|
|
|
|
}
|
2022-07-16 05:14:00 +00:00
|
|
|
if (!Settings::values.use_speed_limit) {
|
2021-07-08 23:53:42 +00:00
|
|
|
game_fps_label->setText(
|
2022-04-18 21:21:02 +00:00
|
|
|
tr("Game: %1 FPS (Unlocked)").arg(std::round(results.average_game_fps), 0, 'f', 0));
|
2021-07-08 23:53:42 +00:00
|
|
|
} else {
|
2022-04-18 21:21:02 +00:00
|
|
|
game_fps_label->setText(
|
|
|
|
tr("Game: %1 FPS").arg(std::round(results.average_game_fps), 0, 'f', 0));
|
2021-07-08 23:53:42 +00:00
|
|
|
}
|
2017-02-19 22:34:47 +00:00
|
|
|
emu_frametime_label->setText(tr("Frame: %1 ms").arg(results.frametime * 1000.0, 0, 'f', 2));
|
|
|
|
|
2021-07-26 05:58:02 +00:00
|
|
|
res_scale_label->setVisible(true);
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
emu_speed_label->setVisible(!Settings::values.use_multi_core.GetValue());
|
2017-02-19 22:34:47 +00:00
|
|
|
game_fps_label->setVisible(true);
|
|
|
|
emu_frametime_label->setVisible(true);
|
|
|
|
}
|
|
|
|
|
2021-07-08 21:21:08 +00:00
|
|
|
void GMainWindow::UpdateGPUAccuracyButton() {
|
2023-05-16 19:17:54 +00:00
|
|
|
const auto gpu_accuracy = Settings::values.gpu_accuracy.GetValue();
|
|
|
|
const auto gpu_accuracy_text = Config::gpu_accuracy_texts_map.find(gpu_accuracy)->second;
|
|
|
|
gpu_accuracy_button->setText(gpu_accuracy_text.toUpper());
|
|
|
|
gpu_accuracy_button->setChecked(gpu_accuracy != Settings::GPUAccuracy::Normal);
|
2021-07-08 21:21:08 +00:00
|
|
|
}
|
|
|
|
|
2022-06-01 07:59:58 +00:00
|
|
|
void GMainWindow::UpdateDockedButton() {
|
|
|
|
const bool is_docked = Settings::values.use_docked_mode.GetValue();
|
|
|
|
dock_status_button->setChecked(is_docked);
|
2023-05-16 19:17:54 +00:00
|
|
|
dock_status_button->setText(
|
|
|
|
Config::use_docked_mode_texts_map.find(is_docked)->second.toUpper());
|
2022-06-01 07:59:58 +00:00
|
|
|
}
|
|
|
|
|
2022-11-28 01:37:37 +00:00
|
|
|
void GMainWindow::UpdateAPIText() {
|
|
|
|
const auto api = Settings::values.renderer_backend.GetValue();
|
2023-05-16 19:17:54 +00:00
|
|
|
const auto renderer_status_text = Config::renderer_backend_texts_map.find(api)->second;
|
2023-06-04 18:00:53 +00:00
|
|
|
renderer_status_button->setText(
|
|
|
|
api == Settings::RendererBackend::OpenGL
|
|
|
|
? tr("%1 %2").arg(
|
|
|
|
renderer_status_text.toUpper(),
|
|
|
|
Config::shader_backend_texts_map.find(Settings::values.shader_backend.GetValue())
|
|
|
|
->second)
|
|
|
|
: renderer_status_text.toUpper());
|
2022-11-28 01:37:37 +00:00
|
|
|
}
|
|
|
|
|
2021-10-21 00:05:16 +00:00
|
|
|
void GMainWindow::UpdateFilterText() {
|
|
|
|
const auto filter = Settings::values.scaling_filter.GetValue();
|
2023-05-16 19:17:54 +00:00
|
|
|
const auto filter_text = Config::scaling_filter_texts_map.find(filter)->second;
|
|
|
|
filter_status_button->setText(filter == Settings::ScalingFilter::Fsr ? tr("FSR")
|
|
|
|
: filter_text.toUpper());
|
2021-10-21 00:05:16 +00:00
|
|
|
}
|
|
|
|
|
2021-10-22 20:56:08 +00:00
|
|
|
void GMainWindow::UpdateAAText() {
|
|
|
|
const auto aa_mode = Settings::values.anti_aliasing.GetValue();
|
2023-05-16 19:17:54 +00:00
|
|
|
const auto aa_text = Config::anti_aliasing_texts_map.find(aa_mode)->second;
|
|
|
|
aa_status_button->setText(aa_mode == Settings::AntiAliasing::None
|
|
|
|
? QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "NO AA"))
|
|
|
|
: aa_text.toUpper());
|
2021-10-22 20:56:08 +00:00
|
|
|
}
|
|
|
|
|
2023-01-19 14:13:23 +00:00
|
|
|
void GMainWindow::UpdateVolumeUI() {
|
|
|
|
const auto volume_value = static_cast<int>(Settings::values.volume.GetValue());
|
|
|
|
volume_slider->setValue(volume_value);
|
|
|
|
if (Settings::values.audio_muted) {
|
|
|
|
volume_button->setChecked(false);
|
2023-02-03 23:00:20 +00:00
|
|
|
volume_button->setText(tr("VOLUME: MUTE"));
|
2023-01-19 14:13:23 +00:00
|
|
|
} else {
|
|
|
|
volume_button->setChecked(true);
|
|
|
|
volume_button->setText(tr("VOLUME: %1%", "Volume percentage (e.g. 50%)").arg(volume_value));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
void GMainWindow::UpdateStatusButtons() {
|
|
|
|
renderer_status_button->setChecked(Settings::values.renderer_backend.GetValue() ==
|
|
|
|
Settings::RendererBackend::Vulkan);
|
2022-11-28 01:37:37 +00:00
|
|
|
UpdateAPIText();
|
2021-07-08 21:21:08 +00:00
|
|
|
UpdateGPUAccuracyButton();
|
2022-06-01 07:59:58 +00:00
|
|
|
UpdateDockedButton();
|
2021-10-21 00:05:16 +00:00
|
|
|
UpdateFilterText();
|
2021-10-22 20:56:08 +00:00
|
|
|
UpdateAAText();
|
2023-01-19 14:13:23 +00:00
|
|
|
UpdateVolumeUI();
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
}
|
|
|
|
|
2020-12-22 07:29:30 +00:00
|
|
|
void GMainWindow::UpdateUISettings() {
|
2021-10-15 19:27:18 +00:00
|
|
|
if (!ui->action_Fullscreen->isChecked()) {
|
2020-12-22 07:29:30 +00:00
|
|
|
UISettings::values.geometry = saveGeometry();
|
|
|
|
UISettings::values.renderwindow_geometry = render_window->saveGeometry();
|
|
|
|
}
|
|
|
|
UISettings::values.state = saveState();
|
|
|
|
#if MICROPROFILE_ENABLED
|
|
|
|
UISettings::values.microprofile_geometry = microProfileDialog->saveGeometry();
|
|
|
|
UISettings::values.microprofile_visible = microProfileDialog->isVisible();
|
|
|
|
#endif
|
2021-10-15 19:27:18 +00:00
|
|
|
UISettings::values.single_window_mode = ui->action_Single_Window_Mode->isChecked();
|
|
|
|
UISettings::values.fullscreen = ui->action_Fullscreen->isChecked();
|
|
|
|
UISettings::values.display_titlebar = ui->action_Display_Dock_Widget_Headers->isChecked();
|
|
|
|
UISettings::values.show_filter_bar = ui->action_Show_Filter_Bar->isChecked();
|
|
|
|
UISettings::values.show_status_bar = ui->action_Show_Status_Bar->isChecked();
|
2020-12-22 07:29:30 +00:00
|
|
|
UISettings::values.first_start = false;
|
|
|
|
}
|
|
|
|
|
2022-11-27 01:08:44 +00:00
|
|
|
void GMainWindow::UpdateInputDrivers() {
|
|
|
|
if (!input_subsystem) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
input_subsystem->PumpEvents();
|
|
|
|
}
|
|
|
|
|
2020-04-11 02:22:50 +00:00
|
|
|
void GMainWindow::HideMouseCursor() {
|
2021-02-24 02:39:02 +00:00
|
|
|
if (emu_thread == nullptr && UISettings::values.hide_mouse) {
|
2020-04-11 02:22:50 +00:00
|
|
|
mouse_hide_timer.stop();
|
|
|
|
ShowMouseCursor();
|
|
|
|
return;
|
|
|
|
}
|
2020-12-30 19:41:14 +00:00
|
|
|
render_window->setCursor(QCursor(Qt::BlankCursor));
|
2020-04-11 02:22:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::ShowMouseCursor() {
|
2020-12-30 19:41:14 +00:00
|
|
|
render_window->unsetCursor();
|
2021-02-24 02:39:02 +00:00
|
|
|
if (emu_thread != nullptr && UISettings::values.hide_mouse) {
|
2020-04-11 02:22:50 +00:00
|
|
|
mouse_hide_timer.start();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-19 20:22:51 +00:00
|
|
|
void GMainWindow::CenterMouseCursor() {
|
|
|
|
if (emu_thread == nullptr || !Settings::values.mouse_panning) {
|
|
|
|
mouse_center_timer.stop();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!this->isActiveWindow()) {
|
|
|
|
mouse_center_timer.stop();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const int center_x = render_window->width() / 2;
|
|
|
|
const int center_y = render_window->height() / 2;
|
|
|
|
|
2022-05-12 14:03:37 +00:00
|
|
|
QCursor::setPos(mapToGlobal(QPoint{center_x, center_y}));
|
2022-04-19 20:22:51 +00:00
|
|
|
}
|
|
|
|
|
2020-12-30 19:41:14 +00:00
|
|
|
void GMainWindow::OnMouseActivity() {
|
2021-02-03 18:34:25 +00:00
|
|
|
if (!Settings::values.mouse_panning) {
|
|
|
|
ShowMouseCursor();
|
|
|
|
}
|
2022-04-19 20:22:51 +00:00
|
|
|
mouse_center_timer.stop();
|
2020-04-11 02:22:50 +00:00
|
|
|
}
|
|
|
|
|
2018-09-29 15:48:51 +00:00
|
|
|
void GMainWindow::OnReinitializeKeys(ReinitializeKeyBehavior behavior) {
|
|
|
|
if (behavior == ReinitializeKeyBehavior::Warning) {
|
2018-09-24 01:35:32 +00:00
|
|
|
const auto res = QMessageBox::information(
|
|
|
|
this, tr("Confirm Key Rederivation"),
|
2020-07-10 03:36:38 +00:00
|
|
|
tr("You are about to force rederive all of your keys. \nIf you do not know what "
|
|
|
|
"this "
|
|
|
|
"means or what you are doing, \nthis is a potentially destructive action. "
|
|
|
|
"\nPlease "
|
|
|
|
"make sure this is what you want \nand optionally make backups.\n\nThis will "
|
|
|
|
"delete "
|
2019-01-17 07:01:00 +00:00
|
|
|
"your autogenerated key files and re-run the key derivation module."),
|
2018-09-24 01:35:32 +00:00
|
|
|
QMessageBox::StandardButtons{QMessageBox::Ok, QMessageBox::Cancel});
|
|
|
|
|
|
|
|
if (res == QMessageBox::Cancel)
|
|
|
|
return;
|
|
|
|
|
2021-05-25 23:32:56 +00:00
|
|
|
const auto keys_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::KeysDir);
|
|
|
|
|
2021-06-19 07:43:16 +00:00
|
|
|
Common::FS::RemoveFile(keys_dir / "prod.keys_autogenerated");
|
|
|
|
Common::FS::RemoveFile(keys_dir / "console.keys_autogenerated");
|
|
|
|
Common::FS::RemoveFile(keys_dir / "title.keys_autogenerated");
|
2018-09-24 01:35:32 +00:00
|
|
|
}
|
|
|
|
|
2020-07-01 04:28:49 +00:00
|
|
|
Core::Crypto::KeyManager& keys = Core::Crypto::KeyManager::Instance();
|
2023-05-01 03:28:31 +00:00
|
|
|
bool all_keys_present{true};
|
|
|
|
|
2018-09-24 01:35:32 +00:00
|
|
|
if (keys.BaseDeriveNecessary()) {
|
2021-05-25 23:32:56 +00:00
|
|
|
Core::Crypto::PartitionDataManager pdm{vfs->OpenDirectory("", FileSys::Mode::Read)};
|
2018-09-24 01:35:32 +00:00
|
|
|
|
2018-09-29 15:48:51 +00:00
|
|
|
const auto function = [this, &keys, &pdm] {
|
2018-09-24 01:35:32 +00:00
|
|
|
keys.PopulateFromPartitionData(pdm);
|
2020-09-14 20:47:25 +00:00
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
system->GetFileSystemController().CreateFactories(*vfs);
|
|
|
|
keys.DeriveETicket(pdm, system->GetContentProvider());
|
2018-09-24 01:35:32 +00:00
|
|
|
};
|
|
|
|
|
2018-09-29 15:48:51 +00:00
|
|
|
QString errors;
|
2019-05-24 23:44:06 +00:00
|
|
|
if (!pdm.HasFuses()) {
|
2020-04-14 00:56:22 +00:00
|
|
|
errors += tr("Missing fuses");
|
2019-05-24 23:44:06 +00:00
|
|
|
}
|
|
|
|
if (!pdm.HasBoot0()) {
|
2020-04-14 00:56:22 +00:00
|
|
|
errors += tr(" - Missing BOOT0");
|
2019-05-24 23:44:06 +00:00
|
|
|
}
|
|
|
|
if (!pdm.HasPackage2()) {
|
2020-04-14 00:56:22 +00:00
|
|
|
errors += tr(" - Missing BCPKG2-1-Normal-Main");
|
2019-05-24 23:44:06 +00:00
|
|
|
}
|
|
|
|
if (!pdm.HasProdInfo()) {
|
2020-04-14 00:56:22 +00:00
|
|
|
errors += tr(" - Missing PRODINFO");
|
2019-05-24 23:44:06 +00:00
|
|
|
}
|
2018-09-29 15:48:51 +00:00
|
|
|
if (!errors.isEmpty()) {
|
2023-05-01 03:28:31 +00:00
|
|
|
all_keys_present = false;
|
2018-09-24 01:35:32 +00:00
|
|
|
QMessageBox::warning(
|
2020-04-14 00:56:22 +00:00
|
|
|
this, tr("Derivation Components Missing"),
|
2021-11-16 06:53:28 +00:00
|
|
|
tr("Encryption keys are missing. "
|
2020-04-14 00:56:22 +00:00
|
|
|
"<br>Please follow <a href='https://yuzu-emu.org/help/quickstart/'>the yuzu "
|
2021-11-16 06:53:28 +00:00
|
|
|
"quickstart guide</a> to get all your keys, firmware and "
|
2020-04-14 00:56:22 +00:00
|
|
|
"games.<br><br><small>(%1)</small>")
|
|
|
|
.arg(errors));
|
2018-09-24 01:35:32 +00:00
|
|
|
}
|
|
|
|
|
2021-02-14 08:20:41 +00:00
|
|
|
QProgressDialog prog(this);
|
2018-09-24 01:35:32 +00:00
|
|
|
prog.setRange(0, 0);
|
|
|
|
prog.setLabelText(tr("Deriving keys...\nThis may take up to a minute depending \non your "
|
|
|
|
"system's performance."));
|
|
|
|
prog.setWindowTitle(tr("Deriving Keys"));
|
|
|
|
|
|
|
|
prog.show();
|
|
|
|
|
|
|
|
auto future = QtConcurrent::run(function);
|
|
|
|
while (!future.isFinished()) {
|
|
|
|
QCoreApplication::processEvents();
|
|
|
|
}
|
|
|
|
|
|
|
|
prog.close();
|
|
|
|
}
|
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
system->GetFileSystemController().CreateFactories(*vfs);
|
2018-09-24 01:35:32 +00:00
|
|
|
|
2023-05-01 03:28:31 +00:00
|
|
|
if (all_keys_present && !this->CheckSystemArchiveDecryption()) {
|
|
|
|
LOG_WARNING(Frontend, "Mii model decryption failed");
|
|
|
|
QMessageBox::warning(
|
|
|
|
this, tr("System Archive Decryption Failed"),
|
|
|
|
tr("Encryption keys failed to decrypt firmware. "
|
|
|
|
"<br>Please follow <a href='https://yuzu-emu.org/help/quickstart/'>the yuzu "
|
|
|
|
"quickstart guide</a> to get all your keys, firmware and "
|
|
|
|
"games."));
|
|
|
|
}
|
|
|
|
|
2018-09-29 15:48:51 +00:00
|
|
|
if (behavior == ReinitializeKeyBehavior::Warning) {
|
2019-05-01 21:21:04 +00:00
|
|
|
game_list->PopulateAsync(UISettings::values.game_dirs);
|
2018-09-24 01:35:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-05-01 03:28:31 +00:00
|
|
|
bool GMainWindow::CheckSystemArchiveDecryption() {
|
|
|
|
constexpr u64 MiiModelId = 0x0100000000000802;
|
|
|
|
|
|
|
|
auto bis_system = system->GetFileSystemController().GetSystemNANDContents();
|
|
|
|
if (!bis_system) {
|
|
|
|
// Not having system BIS files is not an error.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto mii_nca = bis_system->GetEntry(MiiModelId, FileSys::ContentRecordType::Data);
|
|
|
|
if (!mii_nca) {
|
|
|
|
// Not having the Mii model is not an error.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return whether we are able to decrypt the RomFS of the Mii model.
|
|
|
|
return mii_nca->GetRomFS().get() != nullptr;
|
|
|
|
}
|
|
|
|
|
2019-03-04 17:40:53 +00:00
|
|
|
std::optional<u64> GMainWindow::SelectRomFSDumpTarget(const FileSys::ContentProvider& installed,
|
|
|
|
u64 program_id) {
|
2018-10-17 22:27:23 +00:00
|
|
|
const auto dlc_entries =
|
|
|
|
installed.ListEntriesFilter(FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
|
2019-03-04 17:40:53 +00:00
|
|
|
std::vector<FileSys::ContentProviderEntry> dlc_match;
|
2018-10-17 22:27:23 +00:00
|
|
|
dlc_match.reserve(dlc_entries.size());
|
|
|
|
std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
|
2019-03-04 17:40:53 +00:00
|
|
|
[&program_id, &installed](const FileSys::ContentProviderEntry& entry) {
|
2020-12-04 06:41:21 +00:00
|
|
|
return FileSys::GetBaseTitleID(entry.title_id) == program_id &&
|
2018-10-17 22:27:23 +00:00
|
|
|
installed.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
|
|
|
|
});
|
|
|
|
|
|
|
|
std::vector<u64> romfs_tids;
|
|
|
|
romfs_tids.push_back(program_id);
|
2019-05-24 23:44:06 +00:00
|
|
|
for (const auto& entry : dlc_match) {
|
2018-10-17 22:27:23 +00:00
|
|
|
romfs_tids.push_back(entry.title_id);
|
2019-05-24 23:44:06 +00:00
|
|
|
}
|
2018-10-17 22:27:23 +00:00
|
|
|
|
|
|
|
if (romfs_tids.size() > 1) {
|
2019-05-24 23:44:06 +00:00
|
|
|
QStringList list{QStringLiteral("Base")};
|
|
|
|
for (std::size_t i = 1; i < romfs_tids.size(); ++i) {
|
2018-10-17 22:27:23 +00:00
|
|
|
list.push_back(QStringLiteral("DLC %1").arg(romfs_tids[i] & 0x7FF));
|
2019-05-24 23:44:06 +00:00
|
|
|
}
|
2018-10-17 22:27:23 +00:00
|
|
|
|
|
|
|
bool ok;
|
|
|
|
const auto res = QInputDialog::getItem(
|
|
|
|
this, tr("Select RomFS Dump Target"),
|
|
|
|
tr("Please select which RomFS you would like to dump."), list, 0, false, &ok);
|
|
|
|
if (!ok) {
|
2018-10-30 04:03:25 +00:00
|
|
|
return {};
|
2018-10-17 22:27:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return romfs_tids[list.indexOf(res)];
|
|
|
|
}
|
|
|
|
|
|
|
|
return program_id;
|
|
|
|
}
|
|
|
|
|
2016-01-10 12:31:20 +00:00
|
|
|
bool GMainWindow::ConfirmClose() {
|
2021-09-12 02:36:03 +00:00
|
|
|
if (emu_thread == nullptr || !UISettings::values.confirm_before_closing) {
|
2016-01-13 17:40:41 +00:00
|
|
|
return true;
|
2021-09-12 02:36:03 +00:00
|
|
|
}
|
|
|
|
const auto text = tr("Are you sure you want to close yuzu?");
|
|
|
|
const auto answer = QMessageBox::question(this, tr("yuzu"), text);
|
2017-03-09 01:21:31 +00:00
|
|
|
return answer != QMessageBox::No;
|
2016-01-10 12:31:20 +00:00
|
|
|
}
|
|
|
|
|
2015-07-28 16:43:18 +00:00
|
|
|
void GMainWindow::closeEvent(QCloseEvent* event) {
|
2016-01-10 12:31:20 +00:00
|
|
|
if (!ConfirmClose()) {
|
|
|
|
event->ignore();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-12-22 07:29:30 +00:00
|
|
|
UpdateUISettings();
|
2016-01-24 20:23:55 +00:00
|
|
|
game_list->SaveInterfaceLayout();
|
2018-08-07 04:43:07 +00:00
|
|
|
hotkey_registry.SaveHotkeys();
|
2021-11-28 05:26:51 +00:00
|
|
|
|
|
|
|
// Unload controllers early
|
2021-10-16 00:07:47 +00:00
|
|
|
controller_dialog->UnloadController();
|
2021-11-28 05:26:51 +00:00
|
|
|
game_list->UnloadController();
|
2014-04-01 02:26:50 +00:00
|
|
|
|
2015-05-13 03:14:24 +00:00
|
|
|
// Shutdown session if the emu thread is active...
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
if (emu_thread != nullptr) {
|
2015-05-13 03:14:24 +00:00
|
|
|
ShutdownGame();
|
configuration: implement per-game configurations (#4098)
* Switch game settings to use a pointer
In order to add full per-game settings, we need to be able to tell yuzu to switch
to using either the global or game configuration. Using a pointer makes it easier
to switch.
* configuration: add new UI without changing existing funcitonality
The new UI also adds General, System, Graphics, Advanced Graphics,
and Audio tabs, but as yet they do nothing. This commit keeps yuzu
to the same functionality as originally branched.
* configuration: Rename files
These weren't included in the last commit. Now they are.
* configuration: setup global configuration checkbox
Global config checkbox now enables/disables the appropriate tabs in the game
properties dialog. The use global configuration setting is now saved to the
config, defaulting to true. This also addresses some changes requested in the PR.
* configuration: swap to per-game config memory for properties dialog
Does not set memory going in-game. Swaps to game values when opening the
properties dialog, then swaps back when closing it. Uses a `memcpy` to swap.
Also implements saving config files, limited to certain groups of configurations
so as to not risk setting unsafe configurations.
* configuration: change config interfaces to use config-specific pointers
When a game is booted, we need to be able to open the configuration dialogs
without changing the settings pointer in the game's emualtion. A new pointer
specific to just the configuration dialogs can be used to separate changes
to just those config dialogs without affecting the emulation.
* configuration: boot a game using per-game settings
Swaps values where needed to boot a game.
* configuration: user correct config during emulation
Creates a new pointer specifically for modifying the configuration while
emulation is in progress. Both the regular configuration dialog and the game
properties dialog now use the pointer Settings::config_values to focus edits to
the correct struct.
* settings: split Settings::values into two different structs
By splitting the settings into two mutually exclusive structs, it becomes easier,
as a developer, to determine how to use the Settings structs after per-game
configurations is merged. Other benefits include only duplicating the required
settings in memory.
* settings: move use_docked_mode to Controls group
`use_docked_mode` is set in the input settings and cannot be accessed from the
system settings. Grouping it with system settings causes it to be saved with
per-game settings, which may make transferring configs more difficult later on,
especially since docked mode cannot be set from within the game properties
dialog.
* configuration: Fix the other yuzu executables and a regression
In main.cpp, we have to get the title ID before the ROM is loaded, else the
renderer will reflect only the global settings and now the user's game specific
settings.
* settings: use a template to duplicate memory for each setting
Replaces the type of each variable in the Settings::Values struct with a new
class that allows basic data reading and writing. The new struct
Settings::Setting duplicates the data in memory and can manage global overrides
per each setting.
* configuration: correct add-ons config and swap settings when apropriate
Any add-ons interaction happens directly through the global values struct.
Swapping bewteen structs now also includes copying the necessary global configs
that cannot be changed nor saved in per-game settings. General and System config
menus now update based on whether it is viewing the global or per-game settings.
* settings: restore old values struct
No longer needed with the Settings::Setting class template.
* configuration: implement hierarchical game properties dialog
This sets the apropriate global or local data in each setting.
* clang format
* clang format take 2
can the docker container save this?
* address comments and style issues
* config: read and write settings with global awareness
Adds new functions to read and write settings while keeping the global state in
focus. Files now generated per-game are much smaller since often they only need
address the global state.
* settings: restore global state when necessary
Upon closing a game or the game properties dialog, we need to restore all global
settings to the original global state so that we can properly open the
configuration dialog or boot a different game.
* configuration: guard setting values incorrectly
This disables setting values while a game is running if the setting is
overwritten by a per game setting.
* config: don't write local settings in the global config
Simple guards to prevent writing the wrong settings in the wrong files.
* configuration: add comments, assume less, and clang format
No longer assumes that a disabled UI element means the global state is turned
off, instead opting to directly answer that question. Still however assumes a
game is running if it is in that state.
* configuration: fix a logic error
Should not be negated
* restore settings' global state regardless of accept/cancel
Fixes loading a properties dialog and causing the global config dialog to show
local settings.
* fix more logic errors
Fixed the frame limit would set the global setting from the game properties
dialog. Also strengthened the Settings::Setting member variables and simplified
the logic in config reading (ReadSettingGlobal).
* fix another logic error
In my efforts to guard RestoreGlobalState, I accidentally negated the IsPowered
condition.
* configure_audio: set toggle_stretched_audio to tristate
* fixed custom rtc and rng seed overwriting the global value
* clang format
* rebased
* clang format take 4
* address my own review
Basically revert unintended changes
* settings: literal instead of casting
"No need to cast, use 1U instead"
Thanks, Morph!
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
* Revert "settings: literal instead of casting
"
This reverts commit 95e992a87c898f3e882ffdb415bb0ef9f80f613f.
* main: fix status buttons reporting wrong settings after stop emulation
* settings: Log UseDockedMode in the Controls group
This should have happened when use_docked_mode was moved over to the controls group
internally. This just reflects this in the log.
* main: load settings if the file has a title id
In other words, don't exit if the loader has trouble getting a title id.
* use a zero
* settings: initalize resolution factor with constructor instead of casting
* Revert "settings: initalize resolution factor with constructor instead of casting"
This reverts commit 54c35ecb46a29953842614620f9b7de1aa9d5dc8.
* configure_graphics: guard device selector when Vulkan is global
Prevents the user from editing the device selector if Vulkan is the global
renderer backend. Also resets the vulkan_device variable when the users
switches back-and-forth between global and Vulkan.
* address reviewer concerns
Changes function variables to const wherever they don't need to be changed. Sets Settings::Setting to final as it should not be inherited from. Sets ConfigurationShared::use_global_text to static.
Co-Authored-By: VolcaEM <volcaem@users.noreply.github.com>
* main: load per-game settings after LoadROM
This prevents `Restart Emulation` from restoring the global settings *after* the per-game settings were applied. Thanks to BSoDGamingYT for finding this bug.
* Revert "main: load per-game settings after LoadROM"
This reverts commit 9d0d48c52d2dcf3bfb1806cc8fa7d5a271a8a804.
* main: only restore global settings when necessary
Loading the per-game settings cannot happen after the ROM is loaded, so we have to specify when to restore the global state. Again thanks to BSoD for finding the bug.
* configuration_shared: address reviewer concerns except operator overrides
Dropping operator override usage in next commit.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
* settings: Drop operator overrides from Setting template
Requires using GetValue and SetValue explicitly. Also reverts a change that broke title ID formatting in the game properties dialog.
* complete rebase
* configuration_shared: translate "Use global configuration"
Uses ConfigurePerGame to do so, since its usage, at least as of now, corresponds with ConfigurationShared.
* configure_per_game: address reviewer concern
As far as I understand, it prevents the program from unnecessarily copying strings.
Co-Authored-By: LC <lioncash@users.noreply.github.com>
Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com>
Co-authored-by: VolcaEM <volcaem@users.noreply.github.com>
Co-authored-by: LC <lioncash@users.noreply.github.com>
2020-07-10 02:42:09 +00:00
|
|
|
}
|
|
|
|
|
2014-04-01 02:26:50 +00:00
|
|
|
render_window->close();
|
2021-12-25 19:27:52 +00:00
|
|
|
multiplayer_state->Close();
|
2022-11-18 00:23:48 +00:00
|
|
|
system->HIDCore().UnloadInputDevices();
|
2022-08-03 17:45:13 +00:00
|
|
|
system->GetRoomNetwork().Shutdown();
|
2014-04-01 02:26:50 +00:00
|
|
|
|
|
|
|
QWidget::closeEvent(event);
|
|
|
|
}
|
|
|
|
|
2020-02-17 20:49:52 +00:00
|
|
|
static bool IsSingleFileDropEvent(const QMimeData* mime) {
|
|
|
|
return mime->hasUrls() && mime->urls().length() == 1;
|
2020-01-21 19:40:53 +00:00
|
|
|
}
|
|
|
|
|
2020-02-17 20:49:52 +00:00
|
|
|
void GMainWindow::AcceptDropEvent(QDropEvent* event) {
|
|
|
|
if (IsSingleFileDropEvent(event->mimeData())) {
|
|
|
|
event->setDropAction(Qt::DropAction::LinkAction);
|
|
|
|
event->accept();
|
2020-01-21 19:40:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-17 20:49:52 +00:00
|
|
|
bool GMainWindow::DropAction(QDropEvent* event) {
|
|
|
|
if (!IsSingleFileDropEvent(event->mimeData())) {
|
|
|
|
return false;
|
2019-11-02 18:22:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const QMimeData* mime_data = event->mimeData();
|
2020-02-17 20:49:52 +00:00
|
|
|
const QString& filename = mime_data->urls().at(0).toLocalFile();
|
2019-11-02 18:22:36 +00:00
|
|
|
|
|
|
|
if (emulation_running && QFileInfo(filename).suffix() == QStringLiteral("bin")) {
|
2020-02-17 20:49:52 +00:00
|
|
|
// Amiibo
|
2019-11-02 18:22:36 +00:00
|
|
|
LoadAmiibo(filename);
|
|
|
|
} else {
|
2020-02-17 20:49:52 +00:00
|
|
|
// Game
|
2019-11-02 18:22:36 +00:00
|
|
|
if (ConfirmChangeGame()) {
|
|
|
|
BootGame(filename);
|
|
|
|
}
|
2017-02-16 03:23:30 +00:00
|
|
|
}
|
2020-02-17 20:49:52 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::dropEvent(QDropEvent* event) {
|
|
|
|
DropAction(event);
|
2017-02-16 03:23:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::dragEnterEvent(QDragEnterEvent* event) {
|
2020-02-17 20:49:52 +00:00
|
|
|
AcceptDropEvent(event);
|
2017-02-16 03:23:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::dragMoveEvent(QDragMoveEvent* event) {
|
2020-02-17 20:49:52 +00:00
|
|
|
AcceptDropEvent(event);
|
2017-02-16 03:23:30 +00:00
|
|
|
}
|
|
|
|
|
2022-04-19 20:22:51 +00:00
|
|
|
void GMainWindow::leaveEvent(QEvent* event) {
|
|
|
|
if (Settings::values.mouse_panning) {
|
|
|
|
const QRect& rect = geometry();
|
|
|
|
QPoint position = QCursor::pos();
|
|
|
|
|
|
|
|
qint32 x = qBound(rect.left(), position.x(), rect.right());
|
|
|
|
qint32 y = qBound(rect.top(), position.y(), rect.bottom());
|
|
|
|
// Only start the timer if the mouse has left the window bound.
|
|
|
|
// The leave event is also triggered when the window looses focus.
|
|
|
|
if (x != position.x() || y != position.y()) {
|
|
|
|
mouse_center_timer.start();
|
|
|
|
}
|
|
|
|
event->accept();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-16 03:23:30 +00:00
|
|
|
bool GMainWindow::ConfirmChangeGame() {
|
|
|
|
if (emu_thread == nullptr)
|
|
|
|
return true;
|
|
|
|
|
2019-09-22 14:02:07 +00:00
|
|
|
const auto answer = QMessageBox::question(
|
2018-01-13 23:49:16 +00:00
|
|
|
this, tr("yuzu"),
|
2017-02-16 03:23:30 +00:00
|
|
|
tr("Are you sure you want to stop the emulation? Any unsaved progress will be lost."),
|
|
|
|
QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
|
|
|
|
return answer != QMessageBox::No;
|
|
|
|
}
|
|
|
|
|
2019-09-22 02:46:53 +00:00
|
|
|
bool GMainWindow::ConfirmForceLockedExit() {
|
2021-09-12 02:36:03 +00:00
|
|
|
if (emu_thread == nullptr || !UISettings::values.confirm_before_closing) {
|
2019-09-22 02:46:53 +00:00
|
|
|
return true;
|
2021-09-12 02:36:03 +00:00
|
|
|
}
|
|
|
|
const auto text = tr("The currently running application has requested yuzu to not exit.\n\n"
|
|
|
|
"Would you like to bypass this and exit anyway?");
|
2019-09-22 02:46:53 +00:00
|
|
|
|
2021-09-12 02:36:03 +00:00
|
|
|
const auto answer = QMessageBox::question(this, tr("yuzu"), text);
|
2019-09-22 02:46:53 +00:00
|
|
|
return answer != QMessageBox::No;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::RequestGameExit() {
|
2022-12-22 00:55:01 +00:00
|
|
|
if (!system->IsPoweredOn()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-10-14 18:32:19 +00:00
|
|
|
auto& sm{system->ServiceManager()};
|
2019-09-22 02:46:53 +00:00
|
|
|
auto applet_oe = sm.GetService<Service::AM::AppletOE>("appletOE");
|
|
|
|
auto applet_ae = sm.GetService<Service::AM::AppletAE>("appletAE");
|
|
|
|
bool has_signalled = false;
|
|
|
|
|
|
|
|
if (applet_oe != nullptr) {
|
|
|
|
applet_oe->GetMessageQueue()->RequestExit();
|
|
|
|
has_signalled = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (applet_ae != nullptr && !has_signalled) {
|
|
|
|
applet_ae->GetMessageQueue()->RequestExit();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-15 01:42:56 +00:00
|
|
|
void GMainWindow::RequestGameResume() {
|
|
|
|
auto& sm{system->ServiceManager()};
|
|
|
|
auto applet_oe = sm.GetService<Service::AM::AppletOE>("appletOE");
|
|
|
|
auto applet_ae = sm.GetService<Service::AM::AppletAE>("appletAE");
|
|
|
|
|
|
|
|
if (applet_oe != nullptr) {
|
|
|
|
applet_oe->GetMessageQueue()->RequestResume();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (applet_ae != nullptr) {
|
|
|
|
applet_ae->GetMessageQueue()->RequestResume();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-30 02:04:39 +00:00
|
|
|
void GMainWindow::filterBarSetChecked(bool state) {
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->action_Show_Filter_Bar->setChecked(state);
|
2017-04-30 02:04:39 +00:00
|
|
|
emit(OnToggleFilterBar());
|
|
|
|
}
|
|
|
|
|
2022-07-28 14:50:20 +00:00
|
|
|
static void AdjustLinkColor() {
|
|
|
|
QPalette new_pal(qApp->palette());
|
|
|
|
if (UISettings::IsDarkTheme()) {
|
|
|
|
new_pal.setColor(QPalette::Link, QColor(0, 190, 255, 255));
|
|
|
|
} else {
|
|
|
|
new_pal.setColor(QPalette::Link, QColor(0, 140, 200, 255));
|
|
|
|
}
|
|
|
|
if (qApp->palette().color(QPalette::Link) != new_pal.color(QPalette::Link)) {
|
|
|
|
qApp->setPalette(new_pal);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-30 09:50:10 +00:00
|
|
|
void GMainWindow::UpdateUITheme() {
|
2022-07-28 14:50:20 +00:00
|
|
|
const QString default_theme =
|
|
|
|
QString::fromUtf8(UISettings::themes[static_cast<size_t>(Config::default_theme)].second);
|
2021-11-14 03:14:30 +00:00
|
|
|
QString current_theme = UISettings::values.theme;
|
2019-05-24 23:44:06 +00:00
|
|
|
|
2021-11-14 03:14:30 +00:00
|
|
|
if (current_theme.isEmpty()) {
|
|
|
|
current_theme = default_theme;
|
|
|
|
}
|
|
|
|
|
2022-07-28 14:50:20 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
QIcon::setThemeName(current_theme);
|
|
|
|
AdjustLinkColor();
|
|
|
|
#else
|
|
|
|
if (current_theme == QStringLiteral("default") || current_theme == QStringLiteral("colorful")) {
|
|
|
|
QIcon::setThemeName(current_theme == QStringLiteral("colorful") ? current_theme
|
|
|
|
: startup_icon_theme);
|
2022-11-28 13:40:38 +00:00
|
|
|
QIcon::setThemeSearchPaths(QStringList(default_theme_paths));
|
2022-08-12 13:10:18 +00:00
|
|
|
if (CheckDarkMode()) {
|
2022-07-28 14:50:20 +00:00
|
|
|
current_theme = QStringLiteral("default_dark");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
QIcon::setThemeName(current_theme);
|
|
|
|
QIcon::setThemeSearchPaths(QStringList(QStringLiteral(":/icons")));
|
|
|
|
AdjustLinkColor();
|
|
|
|
}
|
|
|
|
#endif
|
2021-11-14 03:14:30 +00:00
|
|
|
if (current_theme != default_theme) {
|
|
|
|
QString theme_uri{QStringLiteral(":%1/style.qss").arg(current_theme)};
|
2020-01-28 22:59:30 +00:00
|
|
|
QFile f(theme_uri);
|
2021-11-14 03:14:30 +00:00
|
|
|
if (!f.open(QFile::ReadOnly | QFile::Text)) {
|
|
|
|
LOG_ERROR(Frontend, "Unable to open style \"{}\", fallback to the default theme",
|
|
|
|
UISettings::values.theme.toStdString());
|
|
|
|
current_theme = default_theme;
|
2020-01-28 22:59:30 +00:00
|
|
|
}
|
2021-11-14 03:14:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QString theme_uri{QStringLiteral(":%1/style.qss").arg(current_theme)};
|
|
|
|
QFile f(theme_uri);
|
|
|
|
if (f.open(QFile::ReadOnly | QFile::Text)) {
|
|
|
|
QTextStream ts(&f);
|
|
|
|
qApp->setStyleSheet(ts.readAll());
|
|
|
|
setStyleSheet(ts.readAll());
|
2019-05-24 23:44:06 +00:00
|
|
|
} else {
|
2021-11-14 03:14:30 +00:00
|
|
|
LOG_ERROR(Frontend, "Unable to set style \"{}\", stylesheet file not found",
|
|
|
|
UISettings::values.theme.toStdString());
|
|
|
|
qApp->setStyleSheet({});
|
|
|
|
setStyleSheet({});
|
2018-03-30 09:50:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-25 23:26:07 +00:00
|
|
|
void GMainWindow::LoadTranslation() {
|
|
|
|
bool loaded;
|
|
|
|
|
|
|
|
if (UISettings::values.language.isEmpty()) {
|
|
|
|
// If the selected language is empty, use system locale
|
|
|
|
loaded = translator.load(QLocale(), {}, {}, QStringLiteral(":/languages/"));
|
|
|
|
} else {
|
|
|
|
// Otherwise load from the specified file
|
|
|
|
loaded = translator.load(UISettings::values.language, QStringLiteral(":/languages/"));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (loaded) {
|
|
|
|
qApp->installTranslator(&translator);
|
|
|
|
} else {
|
|
|
|
UISettings::values.language = QStringLiteral("en");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GMainWindow::OnLanguageChanged(const QString& locale) {
|
|
|
|
if (UISettings::values.language != QStringLiteral("en")) {
|
|
|
|
qApp->removeTranslator(&translator);
|
|
|
|
}
|
|
|
|
|
|
|
|
UISettings::values.language = locale;
|
|
|
|
LoadTranslation();
|
2021-10-15 19:27:18 +00:00
|
|
|
ui->retranslateUi(this);
|
2021-12-25 19:27:52 +00:00
|
|
|
multiplayer_state->retranslateUi();
|
2020-01-25 23:26:07 +00:00
|
|
|
UpdateWindowTitle();
|
|
|
|
}
|
|
|
|
|
2018-10-13 14:10:27 +00:00
|
|
|
void GMainWindow::SetDiscordEnabled([[maybe_unused]] bool state) {
|
2018-09-16 18:05:51 +00:00
|
|
|
#ifdef USE_DISCORD_PRESENCE
|
|
|
|
if (state) {
|
2021-10-14 18:32:19 +00:00
|
|
|
discord_rpc = std::make_unique<DiscordRPC::DiscordImpl>(*system);
|
2018-09-16 18:05:51 +00:00
|
|
|
} else {
|
|
|
|
discord_rpc = std::make_unique<DiscordRPC::NullImpl>();
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
discord_rpc = std::make_unique<DiscordRPC::NullImpl>();
|
|
|
|
#endif
|
|
|
|
discord_rpc->Update();
|
|
|
|
}
|
|
|
|
|
2022-07-28 14:50:20 +00:00
|
|
|
void GMainWindow::changeEvent(QEvent* event) {
|
2022-11-04 12:12:46 +00:00
|
|
|
#ifdef __unix__
|
2022-07-28 14:50:20 +00:00
|
|
|
// PaletteChange event appears to only reach so far into the GUI, explicitly asking to
|
|
|
|
// UpdateUITheme is a decent work around
|
|
|
|
if (event->type() == QEvent::PaletteChange) {
|
|
|
|
const QPalette test_palette(qApp->palette());
|
|
|
|
const QString current_theme = UISettings::values.theme;
|
|
|
|
// Keeping eye on QPalette::Window to avoid looping. QPalette::Text might be useful too
|
|
|
|
static QColor last_window_color;
|
|
|
|
const QColor window_color = test_palette.color(QPalette::Active, QPalette::Window);
|
|
|
|
if (last_window_color != window_color && (current_theme == QStringLiteral("default") ||
|
|
|
|
current_theme == QStringLiteral("colorful"))) {
|
|
|
|
UpdateUITheme();
|
|
|
|
}
|
|
|
|
last_window_color = window_color;
|
|
|
|
}
|
2022-11-04 12:12:46 +00:00
|
|
|
#endif // __unix__
|
2022-07-28 14:50:20 +00:00
|
|
|
QWidget::changeEvent(event);
|
|
|
|
}
|
|
|
|
|
2014-04-01 02:26:50 +00:00
|
|
|
#ifdef main
|
|
|
|
#undef main
|
|
|
|
#endif
|
|
|
|
|
2023-01-26 02:16:04 +00:00
|
|
|
static void SetHighDPIAttributes() {
|
2023-01-26 02:16:04 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
// For Windows, we want to avoid scaling artifacts on fractional scaling ratios.
|
|
|
|
// This is done by setting the optimal scaling policy for the primary screen.
|
|
|
|
|
2023-01-26 02:16:04 +00:00
|
|
|
// Create a temporary QApplication.
|
|
|
|
int temp_argc = 0;
|
|
|
|
char** temp_argv = nullptr;
|
|
|
|
QApplication temp{temp_argc, temp_argv};
|
|
|
|
|
|
|
|
// Get the current screen geometry.
|
|
|
|
const QScreen* primary_screen = QGuiApplication::primaryScreen();
|
|
|
|
if (primary_screen == nullptr) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QRect screen_rect = primary_screen->geometry();
|
|
|
|
const int real_width = screen_rect.width();
|
|
|
|
const int real_height = screen_rect.height();
|
|
|
|
const float real_ratio = primary_screen->logicalDotsPerInch() / 96.0f;
|
|
|
|
|
|
|
|
// Recommended minimum width and height for proper window fit.
|
|
|
|
// Any screen with a lower resolution than this will still have a scale of 1.
|
|
|
|
constexpr float minimum_width = 1350.0f;
|
|
|
|
constexpr float minimum_height = 900.0f;
|
|
|
|
|
|
|
|
const float width_ratio = std::max(1.0f, real_width / minimum_width);
|
|
|
|
const float height_ratio = std::max(1.0f, real_height / minimum_height);
|
|
|
|
|
|
|
|
// Get the lower of the 2 ratios and truncate, this is the maximum integer scale.
|
|
|
|
const float max_ratio = std::trunc(std::min(width_ratio, height_ratio));
|
|
|
|
|
|
|
|
if (max_ratio > real_ratio) {
|
|
|
|
QApplication::setHighDpiScaleFactorRoundingPolicy(
|
|
|
|
Qt::HighDpiScaleFactorRoundingPolicy::Round);
|
|
|
|
} else {
|
|
|
|
QApplication::setHighDpiScaleFactorRoundingPolicy(
|
|
|
|
Qt::HighDpiScaleFactorRoundingPolicy::Floor);
|
|
|
|
}
|
2023-01-26 02:16:04 +00:00
|
|
|
#else
|
|
|
|
// Other OSes should be better than Windows at fractional scaling.
|
|
|
|
QApplication::setHighDpiScaleFactorRoundingPolicy(
|
|
|
|
Qt::HighDpiScaleFactorRoundingPolicy::PassThrough);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
|
|
|
|
QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
|
2023-01-26 02:16:04 +00:00
|
|
|
}
|
|
|
|
|
2015-07-28 16:43:18 +00:00
|
|
|
int main(int argc, char* argv[]) {
|
2022-07-10 15:29:10 +00:00
|
|
|
std::unique_ptr<Config> config = std::make_unique<Config>();
|
2022-07-10 20:10:35 +00:00
|
|
|
bool has_broken_vulkan = false;
|
2022-07-10 15:29:10 +00:00
|
|
|
bool is_child = false;
|
|
|
|
if (CheckEnvVars(&is_child)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef YUZU_DBGHELP
|
|
|
|
PROCESS_INFORMATION pi;
|
2022-07-30 14:23:14 +00:00
|
|
|
if (!is_child && Settings::values.create_crash_dumps.GetValue() &&
|
|
|
|
MiniDump::SpawnDebuggee(argv[0], pi)) {
|
2022-07-13 16:14:48 +00:00
|
|
|
// Delete the config object so that it doesn't save when the program exits
|
2022-07-10 15:29:10 +00:00
|
|
|
config.reset(nullptr);
|
2022-07-30 14:23:14 +00:00
|
|
|
MiniDump::DebugDebuggee(pi);
|
2022-07-10 15:29:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2022-09-19 18:46:12 +00:00
|
|
|
if (StartupChecks(argv[0], &has_broken_vulkan,
|
|
|
|
Settings::values.perform_vulkan_check.GetValue())) {
|
2022-07-10 18:08:20 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-09-16 18:05:51 +00:00
|
|
|
Common::DetachedTasks detached_tasks;
|
2015-08-17 21:25:21 +00:00
|
|
|
MicroProfileOnThreadCreate("Frontend");
|
2016-09-18 00:38:01 +00:00
|
|
|
SCOPE_EXIT({ MicroProfileShutdown(); });
|
2015-08-17 21:25:21 +00:00
|
|
|
|
2021-01-20 23:09:57 +00:00
|
|
|
Common::ConfigureNvidiaEnvironmentFlags();
|
|
|
|
|
2015-07-26 15:13:02 +00:00
|
|
|
// Init settings params
|
2019-05-24 23:44:06 +00:00
|
|
|
QCoreApplication::setOrganizationName(QStringLiteral("yuzu team"));
|
|
|
|
QCoreApplication::setApplicationName(QStringLiteral("yuzu"));
|
2015-07-26 15:13:02 +00:00
|
|
|
|
2021-05-25 23:32:56 +00:00
|
|
|
#ifdef _WIN32
|
2022-01-09 19:34:46 +00:00
|
|
|
// Increases the maximum open file limit to 8192
|
|
|
|
_setmaxstdio(8192);
|
2021-05-25 23:32:56 +00:00
|
|
|
#endif
|
|
|
|
|
2019-08-11 10:28:07 +00:00
|
|
|
#ifdef __APPLE__
|
2019-09-05 01:40:49 +00:00
|
|
|
// If you start a bundle (binary) on OSX without the Terminal, the working directory is "/".
|
2020-07-10 03:36:38 +00:00
|
|
|
// But since we require the working directory to be the executable path for the location of
|
|
|
|
// the user folder in the Qt Frontend, we need to cd into that working directory
|
2021-05-25 23:32:56 +00:00
|
|
|
const auto bin_path = Common::FS::GetBundleDirectory() / "..";
|
|
|
|
chdir(Common::FS::PathToUTF8String(bin_path).c_str());
|
2019-08-11 10:28:07 +00:00
|
|
|
#endif
|
|
|
|
|
2021-03-07 15:56:22 +00:00
|
|
|
#ifdef __linux__
|
|
|
|
// Set the DISPLAY variable in order to open web browsers
|
|
|
|
// TODO (lat9nq): Find a better solution for AppImages to start external applications
|
|
|
|
if (QString::fromLocal8Bit(qgetenv("DISPLAY")).isEmpty()) {
|
|
|
|
qputenv("DISPLAY", ":0");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2023-01-26 02:16:04 +00:00
|
|
|
SetHighDPIAttributes();
|
|
|
|
|
2023-01-25 23:45:22 +00:00
|
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
|
|
// Disables the "?" button on all dialogs. Disabled by default on Qt6.
|
2023-01-25 06:11:20 +00:00
|
|
|
QCoreApplication::setAttribute(Qt::AA_DisableWindowContextHelpButton);
|
2023-01-25 23:45:22 +00:00
|
|
|
#endif
|
2023-01-25 06:11:20 +00:00
|
|
|
|
2019-01-12 04:06:34 +00:00
|
|
|
// Enables the core to make the qt created contexts current on std::threads
|
|
|
|
QCoreApplication::setAttribute(Qt::AA_DontCheckOpenGLContextThreadAffinity);
|
2023-01-26 02:16:04 +00:00
|
|
|
|
2014-04-01 02:26:50 +00:00
|
|
|
QApplication app(argc, argv);
|
2014-12-06 22:00:08 +00:00
|
|
|
|
Qt: work around Qt5's font choice for Chinese
On Windows there are currently two fonts used.
The first, does the Menu, QTreeView and Tooltips
Second is Everything else which is a default font.
From inspecting QApplication::font() at runtime
Windows 10 English: QFont(MS Shell Dlg 2,8.25,-1,5,50,0,0,0,0,0)
Windows 11 Japanese: MS UI Gothic,9 ,-1,5,50,0,0,0,0,0
Windows 11 Traditional Chinese: PMingLiU,9 ,-1,5,50,0,0,0,0,0
Windows 11 Simplified Chinese: SimSun,9 ,-1,5,50,0,0,0,0,0
Windows 11 Korean: Gulim,9 ,-1,5,50,0,0,0,0,0
I initially investigated dynamically changing the font when
the UI language is English, but this was getting quite messy
Qt6 makes changes to default font in some situations, so this
PR is being narrowed in scope to only effect Chinese font choices.
This change only effects rendering of Latin/Cyrillic characters.
2022-10-01 22:27:23 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
OverrideWindowsFont();
|
|
|
|
#endif
|
|
|
|
|
2022-08-04 00:31:57 +00:00
|
|
|
// Workaround for QTBUG-85409, for Suzhou numerals the number 1 is actually \u3021
|
|
|
|
// so we can see if we get \u3008 instead
|
|
|
|
// TL;DR all other number formats are consecutive in unicode code points
|
|
|
|
// This bug is fixed in Qt6, specifically 6.0.0-alpha1
|
2022-08-31 10:10:34 +00:00
|
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
2022-08-04 00:31:57 +00:00
|
|
|
const QLocale locale = QLocale::system();
|
|
|
|
if (QStringLiteral("\u3008") == locale.toString(1)) {
|
|
|
|
QLocale::setDefault(QLocale::system().name());
|
|
|
|
}
|
2022-08-31 10:10:34 +00:00
|
|
|
#endif
|
2022-08-04 00:31:57 +00:00
|
|
|
|
2016-09-18 00:38:01 +00:00
|
|
|
// Qt changes the locale and causes issues in float conversion using std::to_string() when
|
|
|
|
// generating shaders
|
2016-03-06 13:04:47 +00:00
|
|
|
setlocale(LC_ALL, "C");
|
|
|
|
|
2022-07-10 15:29:10 +00:00
|
|
|
GMainWindow main_window{std::move(config), has_broken_vulkan};
|
2014-12-06 22:00:08 +00:00
|
|
|
// After settings have been loaded by GMainWindow, apply the filter
|
2014-04-01 02:26:50 +00:00
|
|
|
main_window.show();
|
2018-07-10 10:02:14 +00:00
|
|
|
|
2019-09-26 12:54:31 +00:00
|
|
|
QObject::connect(&app, &QGuiApplication::applicationStateChanged, &main_window,
|
|
|
|
&GMainWindow::OnAppFocusStateChanged);
|
|
|
|
|
2018-09-16 18:05:51 +00:00
|
|
|
int result = app.exec();
|
|
|
|
detached_tasks.WaitForAllTasks();
|
|
|
|
return result;
|
2014-04-01 02:26:50 +00:00
|
|
|
}
|