Merge pull request #11889 from t895/ini-lib

configuration: Unify config handling across frontends

src/yuzu/configuration/config.h

@@ -1,179 +0,0 @@
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include <string>
-#include <QMetaType>
-#include <QVariant>
-#include "common/settings.h"
-#include "common/settings_enums.h"
-#include "yuzu/uisettings.h"
-
-class QSettings;
-
-namespace Core {
-class System;
-}
-
-class Config {
-public:
-    enum class ConfigType {
-        GlobalConfig,
-        PerGameConfig,
-        InputProfile,
-    };
-
-    explicit Config(const std::string& config_name = "qt-config",
-                    ConfigType config_type = ConfigType::GlobalConfig);
-    ~Config();
-
-    void Reload();
-    void Save();
-
-    void ReadControlPlayerValue(std::size_t player_index);
-    void SaveControlPlayerValue(std::size_t player_index);
-    void ClearControlPlayerValues();
-
-    const std::string& GetConfigFilePath() const;
-
-    static const std::array<int, Settings::NativeButton::NumButtons> default_buttons;
-    static const std::array<int, Settings::NativeMotion::NumMotions> default_motions;
-    static const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> default_analogs;
-    static const std::array<int, 2> default_stick_mod;
-    static const std::array<int, 2> default_ringcon_analogs;
-    static const std::array<int, Settings::NativeMouseButton::NumMouseButtons>
-        default_mouse_buttons;
-    static const std::array<int, Settings::NativeKeyboard::NumKeyboardKeys> default_keyboard_keys;
-    static const std::array<int, Settings::NativeKeyboard::NumKeyboardMods> default_keyboard_mods;
-    static const std::array<UISettings::Shortcut, 23> default_hotkeys;
-
-    static const std::map<Settings::AntiAliasing, QString> anti_aliasing_texts_map;
-    static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map;
-    static const std::map<Settings::ConsoleMode, QString> use_docked_mode_texts_map;
-    static const std::map<Settings::GpuAccuracy, QString> gpu_accuracy_texts_map;
-    static const std::map<Settings::RendererBackend, QString> renderer_backend_texts_map;
-    static const std::map<Settings::ShaderBackend, QString> shader_backend_texts_map;
-
-    static constexpr UISettings::Theme default_theme{
-#ifdef _WIN32
-        UISettings::Theme::DarkColorful
-#else
-        UISettings::Theme::DefaultColorful
-#endif
-    };
-
-private:
-    void Initialize(const std::string& config_name);
-    bool IsCustomConfig();
-
-    void ReadValues();
-    void ReadPlayerValue(std::size_t player_index);
-    void ReadDebugValues();
-    void ReadKeyboardValues();
-    void ReadMouseValues();
-    void ReadTouchscreenValues();
-    void ReadMotionTouchValues();
-    void ReadHidbusValues();
-    void ReadIrCameraValues();
-
-    // Read functions bases off the respective config section names.
-    void ReadAudioValues();
-    void ReadControlValues();
-    void ReadCoreValues();
-    void ReadDataStorageValues();
-    void ReadDebuggingValues();
-    void ReadServiceValues();
-    void ReadDisabledAddOnValues();
-    void ReadMiscellaneousValues();
-    void ReadPathValues();
-    void ReadCpuValues();
-    void ReadRendererValues();
-    void ReadScreenshotValues();
-    void ReadShortcutValues();
-    void ReadSystemValues();
-    void ReadUIValues();
-    void ReadUIGamelistValues();
-    void ReadUILayoutValues();
-    void ReadWebServiceValues();
-    void ReadMultiplayerValues();
-    void ReadNetworkValues();
-
-    void SaveValues();
-    void SavePlayerValue(std::size_t player_index);
-    void SaveDebugValues();
-    void SaveMouseValues();
-    void SaveTouchscreenValues();
-    void SaveMotionTouchValues();
-    void SaveHidbusValues();
-    void SaveIrCameraValues();
-
-    // Save functions based off the respective config section names.
-    void SaveAudioValues();
-    void SaveControlValues();
-    void SaveCoreValues();
-    void SaveDataStorageValues();
-    void SaveDebuggingValues();
-    void SaveNetworkValues();
-    void SaveDisabledAddOnValues();
-    void SaveMiscellaneousValues();
-    void SavePathValues();
-    void SaveCpuValues();
-    void SaveRendererValues();
-    void SaveScreenshotValues();
-    void SaveShortcutValues();
-    void SaveSystemValues();
-    void SaveUIValues();
-    void SaveUIGamelistValues();
-    void SaveUILayoutValues();
-    void SaveWebServiceValues();
-    void SaveMultiplayerValues();
-
-    /**
-     * Reads a setting from the qt_config.
-     *
-     * @param name The setting's identifier
-     * @param default_value The value to use when the setting is not already present in the config
-     */
-    QVariant ReadSetting(const QString& name) const;
-    QVariant ReadSetting(const QString& name, const QVariant& default_value) const;
-
-    /**
-     * Writes a setting to the qt_config.
-     *
-     * @param name The setting's idetentifier
-     * @param value Value of the setting
-     * @param default_value Default of the setting if not present in qt_config
-     * @param use_global Specifies if the custom or global config should be in use, for custom
-     * configs
-     */
-    void WriteSetting(const QString& name, const QVariant& value);
-    void WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value);
-    void WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value,
-                      bool use_global);
-
-    void ReadCategory(Settings::Category category);
-    void WriteCategory(Settings::Category category);
-    void ReadSettingGeneric(Settings::BasicSetting* const setting);
-    void WriteSettingGeneric(Settings::BasicSetting* const setting) const;
-
-    const ConfigType type;
-    std::unique_ptr<QSettings> qt_config;
-    std::string qt_config_loc;
-    const bool global;
-};
-
-// These metatype declarations cannot be in common/settings.h because core is devoid of QT
-Q_DECLARE_METATYPE(Settings::CpuAccuracy);
-Q_DECLARE_METATYPE(Settings::GpuAccuracy);
-Q_DECLARE_METATYPE(Settings::FullscreenMode);
-Q_DECLARE_METATYPE(Settings::NvdecEmulation);
-Q_DECLARE_METATYPE(Settings::ResolutionSetup);
-Q_DECLARE_METATYPE(Settings::ScalingFilter);
-Q_DECLARE_METATYPE(Settings::AntiAliasing);
-Q_DECLARE_METATYPE(Settings::RendererBackend);
-Q_DECLARE_METATYPE(Settings::ShaderBackend);
-Q_DECLARE_METATYPE(Settings::AstcRecompression);
-Q_DECLARE_METATYPE(Settings::AstcDecodeMode);

src/yuzu/configuration/configure_camera.cpp

@@ -10,10 +10,10 @@
 #include <QStandardItemModel>
 #include <QTimer>
 
+#include "common/settings.h"
 #include "input_common/drivers/camera.h"
 #include "input_common/main.h"
 #include "ui_configure_camera.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_camera.h"
 
 ConfigureCamera::ConfigureCamera(QWidget* parent, InputCommon::InputSubsystem* input_subsystem_)

src/yuzu/configuration/configure_dialog.cpp

@@ -8,7 +8,6 @@
 #include "core/core.h"
 #include "ui_configure.h"
 #include "vk_device_info.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_audio.h"
 #include "yuzu/configuration/configure_cpu.h"
 #include "yuzu/configuration/configure_debug_tab.h"

src/yuzu/configuration/configure_hotkeys.cpp

@@ -9,10 +9,11 @@
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
 
+#include "frontend_common/config.h"
 #include "ui_configure_hotkeys.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_hotkeys.h"
 #include "yuzu/hotkeys.h"
+#include "yuzu/uisettings.h"
 #include "yuzu/util/sequence_dialog/sequence_dialog.h"
 
 constexpr int name_column = 0;
@@ -62,18 +63,21 @@ ConfigureHotkeys::~ConfigureHotkeys() = default;
 
 void ConfigureHotkeys::Populate(const HotkeyRegistry& registry) {
     for (const auto& group : registry.hotkey_groups) {
+        QString parent_item_data = QString::fromStdString(group.first);
         auto* parent_item =
-            new QStandardItem(QCoreApplication::translate("Hotkeys", qPrintable(group.first)));
+            new QStandardItem(QCoreApplication::translate("Hotkeys", qPrintable(parent_item_data)));
         parent_item->setEditable(false);
-        parent_item->setData(group.first);
+        parent_item->setData(parent_item_data);
         for (const auto& hotkey : group.second) {
-            auto* action =
-                new QStandardItem(QCoreApplication::translate("Hotkeys", qPrintable(hotkey.first)));
+            QString hotkey_action_data = QString::fromStdString(hotkey.first);
+            auto* action = new QStandardItem(
+                QCoreApplication::translate("Hotkeys", qPrintable(hotkey_action_data)));
             auto* keyseq =
                 new QStandardItem(hotkey.second.keyseq.toString(QKeySequence::NativeText));
-            auto* controller_keyseq = new QStandardItem(hotkey.second.controller_keyseq);
+            auto* controller_keyseq =
+                new QStandardItem(QString::fromStdString(hotkey.second.controller_keyseq));
             action->setEditable(false);
-            action->setData(hotkey.first);
+            action->setData(hotkey_action_data);
             keyseq->setEditable(false);
             controller_keyseq->setEditable(false);
             parent_item->appendRow({action, keyseq, controller_keyseq});
@@ -301,13 +305,13 @@ void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) {
             const QStandardItem* controller_keyseq =
                 parent->child(key_column_id, controller_column);
             for (auto& [group, sub_actions] : registry.hotkey_groups) {
-                if (group != parent->data())
+                if (group != parent->data().toString().toStdString())
                     continue;
                 for (auto& [action_name, hotkey] : sub_actions) {
-                    if (action_name != action->data())
+                    if (action_name != action->data().toString().toStdString())
                         continue;
                     hotkey.keyseq = QKeySequence(keyseq->text());
-                    hotkey.controller_keyseq = controller_keyseq->text();
+                    hotkey.controller_keyseq = controller_keyseq->text().toStdString();
                 }
             }
         }
@@ -319,7 +323,7 @@ void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) {
 void ConfigureHotkeys::RestoreDefaults() {
     for (int r = 0; r < model->rowCount(); ++r) {
         const QStandardItem* parent = model->item(r, 0);
-        const int hotkey_size = static_cast<int>(Config::default_hotkeys.size());
+        const int hotkey_size = static_cast<int>(UISettings::default_hotkeys.size());
 
         if (hotkey_size != parent->rowCount()) {
             QMessageBox::warning(this, tr("Invalid hotkey settings"),
@@ -330,10 +334,11 @@ void ConfigureHotkeys::RestoreDefaults() {
         for (int r2 = 0; r2 < parent->rowCount(); ++r2) {
             model->item(r, 0)
                 ->child(r2, hotkey_column)
-                ->setText(Config::default_hotkeys[r2].shortcut.keyseq);
+                ->setText(QString::fromStdString(UISettings::default_hotkeys[r2].shortcut.keyseq));
             model->item(r, 0)
                 ->child(r2, controller_column)
-                ->setText(Config::default_hotkeys[r2].shortcut.controller_keyseq);
+                ->setText(QString::fromStdString(
+                    UISettings::default_hotkeys[r2].shortcut.controller_keyseq));
         }
     }
 }
@@ -379,7 +384,7 @@ void ConfigureHotkeys::PopupContextMenu(const QPoint& menu_location) {
 
 void ConfigureHotkeys::RestoreControllerHotkey(QModelIndex index) {
     const QString& default_key_sequence =
-        Config::default_hotkeys[index.row()].shortcut.controller_keyseq;
+        QString::fromStdString(UISettings::default_hotkeys[index.row()].shortcut.controller_keyseq);
     const auto [key_sequence_used, used_action] = IsUsedControllerKey(default_key_sequence);
 
     if (key_sequence_used && default_key_sequence != model->data(index).toString()) {
@@ -393,7 +398,8 @@ void ConfigureHotkeys::RestoreControllerHotkey(QModelIndex index) {
 
 void ConfigureHotkeys::RestoreHotkey(QModelIndex index) {
     const QKeySequence& default_key_sequence = QKeySequence::fromString(
-        Config::default_hotkeys[index.row()].shortcut.keyseq, QKeySequence::NativeText);
+        QString::fromStdString(UISettings::default_hotkeys[index.row()].shortcut.keyseq),
+        QKeySequence::NativeText);
     const auto [key_sequence_used, used_action] = IsUsedKey(default_key_sequence);
 
     if (key_sequence_used && default_key_sequence != QKeySequence(model->data(index).toString())) {

src/yuzu/configuration/configure_input_per_game.cpp

@@ -5,12 +5,12 @@
 #include "core/core.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
+#include "frontend_common/config.h"
 #include "ui_configure_input_per_game.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_input_per_game.h"
 #include "yuzu/configuration/input_profiles.h"
 
-ConfigureInputPerGame::ConfigureInputPerGame(Core::System& system_, Config* config_,
+ConfigureInputPerGame::ConfigureInputPerGame(Core::System& system_, QtConfig* config_,
                                              QWidget* parent)
     : QWidget(parent), ui(std::make_unique<Ui::ConfigureInputPerGame>()),
       profiles(std::make_unique<InputProfiles>()), system{system_}, config{config_} {
@@ -110,6 +110,6 @@ void ConfigureInputPerGame::SaveConfiguration() {
     // Clear all controls from the config in case the user reverted back to globals
     config->ClearControlPlayerValues();
     for (size_t index = 0; index < Settings::values.players.GetValue().size(); ++index) {
-        config->SaveControlPlayerValue(index);
+        config->SaveQtControlPlayerValues(index);
     }
 }

src/yuzu/configuration/configure_input_per_game.h

@@ -9,6 +9,7 @@
 
 #include "ui_configure_input_per_game.h"
 #include "yuzu/configuration/input_profiles.h"
+#include "yuzu/configuration/qt_config.h"
 
 class QComboBox;
 
@@ -22,7 +23,7 @@ class ConfigureInputPerGame : public QWidget {
     Q_OBJECT
 
 public:
-    explicit ConfigureInputPerGame(Core::System& system_, Config* config_,
+    explicit ConfigureInputPerGame(Core::System& system_, QtConfig* config_,
                                    QWidget* parent = nullptr);
 
     /// Load and Save configurations to settings file.
@@ -41,5 +42,5 @@ private:
     std::array<QComboBox*, 8> profile_comboboxes;
 
     Core::System& system;
-    Config* config;
+    QtConfig* config;
 };

src/yuzu/configuration/configure_input_player.cpp

@@ -12,15 +12,16 @@
 #include <QTimer>
 #include "common/assert.h"
 #include "common/param_package.h"
+#include "configuration/qt_config.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
 #include "core/hid/hid_types.h"
+#include "frontend_common/config.h"
 #include "input_common/drivers/keyboard.h"
 #include "input_common/drivers/mouse.h"
 #include "input_common/main.h"
 #include "ui_configure_input_player.h"
 #include "yuzu/bootmanager.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_input_player.h"
 #include "yuzu/configuration/configure_input_player_widget.h"
 #include "yuzu/configuration/configure_mouse_panning.h"
@@ -1397,25 +1398,25 @@ void ConfigureInputPlayer::UpdateMappingWithDefaults() {
         for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; ++button_id) {
             emulated_controller->SetButtonParam(
                 button_id, Common::ParamPackage{InputCommon::GenerateKeyboardParam(
-                               Config::default_buttons[button_id])});
+                               QtConfig::default_buttons[button_id])});
         }
         for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; ++analog_id) {
             Common::ParamPackage analog_param{};
             for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; ++sub_button_id) {
                 Common::ParamPackage params{InputCommon::GenerateKeyboardParam(
-                    Config::default_analogs[analog_id][sub_button_id])};
+                    QtConfig::default_analogs[analog_id][sub_button_id])};
                 SetAnalogParam(params, analog_param, analog_sub_buttons[sub_button_id]);
             }
 
             analog_param.Set("modifier", InputCommon::GenerateKeyboardParam(
-                                             Config::default_stick_mod[analog_id]));
+                                             QtConfig::default_stick_mod[analog_id]));
             emulated_controller->SetStickParam(analog_id, analog_param);
         }
 
         for (int motion_id = 0; motion_id < Settings::NativeMotion::NumMotions; ++motion_id) {
             emulated_controller->SetMotionParam(
                 motion_id, Common::ParamPackage{InputCommon::GenerateKeyboardParam(
-                               Config::default_motions[motion_id])});
+                               QtConfig::default_motions[motion_id])});
         }
 
         // If mouse is selected we want to override with mappings from the driver

src/yuzu/configuration/configure_per_game.cpp

@@ -25,8 +25,8 @@
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/xts_archive.h"
 #include "core/loader/loader.h"
+#include "frontend_common/config.h"
 #include "ui_configure_per_game.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_audio.h"
 #include "yuzu/configuration/configure_cpu.h"
@@ -50,8 +50,7 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::st
     const auto file_path = std::filesystem::path(Common::FS::ToU8String(file_name));
     const auto config_file_name = title_id == 0 ? Common::FS::PathToUTF8String(file_path.filename())
                                                 : fmt::format("{:016X}", title_id);
-    game_config = std::make_unique<Config>(config_file_name, Config::ConfigType::PerGameConfig);
-
+    game_config = std::make_unique<QtConfig>(config_file_name, Config::ConfigType::PerGameConfig);
     addons_tab = std::make_unique<ConfigurePerGameAddons>(system_, this);
     audio_tab = std::make_unique<ConfigureAudio>(system_, tab_group, *builder, this);
     cpu_tab = std::make_unique<ConfigureCpu>(system_, tab_group, *builder, this);
@@ -108,7 +107,7 @@ void ConfigurePerGame::ApplyConfiguration() {
     system.ApplySettings();
     Settings::LogSettings();
 
-    game_config->Save();
+    game_config->SaveAllValues();
 }
 
 void ConfigurePerGame::changeEvent(QEvent* event) {

src/yuzu/configuration/configure_per_game.h

@@ -12,9 +12,10 @@
 
 #include "configuration/shared_widget.h"
 #include "core/file_sys/vfs_types.h"
+#include "frontend_common/config.h"
 #include "vk_device_info.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configuration_shared.h"
+#include "yuzu/configuration/qt_config.h"
 #include "yuzu/configuration/shared_translation.h"
 
 namespace Core {
@@ -72,7 +73,7 @@ private:
 
     QGraphicsScene* scene;
 
-    std::unique_ptr<Config> game_config;
+    std::unique_ptr<QtConfig> game_config;
 
     Core::System& system;
     std::unique_ptr<ConfigurationShared::Builder> builder;

src/yuzu/configuration/configure_per_game_addons.cpp

@@ -19,7 +19,6 @@
 #include "core/file_sys/xts_archive.h"
 #include "core/loader/loader.h"
 #include "ui_configure_per_game_addons.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_input.h"
 #include "yuzu/configuration/configure_per_game_addons.h"
 #include "yuzu/uisettings.h"

src/yuzu/configuration/configure_ringcon.cpp

@@ -8,6 +8,7 @@
 #include <QTimer>
 #include <fmt/format.h>
 
+#include "configuration/qt_config.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
 #include "input_common/drivers/keyboard.h"
@@ -15,7 +16,6 @@
 #include "input_common/main.h"
 #include "ui_configure_ringcon.h"
 #include "yuzu/bootmanager.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_ringcon.h"
 
 const std::array<std::string, ConfigureRingController::ANALOG_SUB_BUTTONS_NUM>
@@ -270,7 +270,7 @@ void ConfigureRingController::LoadConfiguration() {
 
 void ConfigureRingController::RestoreDefaults() {
     const std::string default_ring_string = InputCommon::GenerateAnalogParamFromKeys(
-        0, 0, Config::default_ringcon_analogs[0], Config::default_ringcon_analogs[1], 0, 0.05f);
+        0, 0, QtConfig::default_ringcon_analogs[0], QtConfig::default_ringcon_analogs[1], 0, 0.05f);
     emulated_controller->SetRingParam(Common::ParamPackage(default_ring_string));
     UpdateUI();
 }

src/yuzu/configuration/configure_system.cpp

@@ -16,7 +16,6 @@
 #include "core/core.h"
 #include "core/hle/service/time/time_manager.h"
 #include "ui_configure_system.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_system.h"
 #include "yuzu/configuration/shared_widget.h"

src/yuzu/configuration/configure_touchscreen_advanced.cpp

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <memory>
+#include "common/settings.h"
 #include "ui_configure_touchscreen_advanced.h"
-#include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_touchscreen_advanced.h"
 
 ConfigureTouchscreenAdvanced::ConfigureTouchscreenAdvanced(QWidget* parent)

src/yuzu/configuration/configure_ui.cpp

@@ -164,7 +164,7 @@ ConfigureUi::~ConfigureUi() = default;
 
 void ConfigureUi::ApplyConfiguration() {
     UISettings::values.theme =
-        ui->theme_combobox->itemData(ui->theme_combobox->currentIndex()).toString();
+        ui->theme_combobox->itemData(ui->theme_combobox->currentIndex()).toString().toStdString();
     UISettings::values.show_add_ons = ui->show_add_ons->isChecked();
     UISettings::values.show_compat = ui->show_compat->isChecked();
     UISettings::values.show_size = ui->show_size->isChecked();
@@ -191,9 +191,10 @@ void ConfigureUi::RequestGameListUpdate() {
 }
 
 void ConfigureUi::SetConfiguration() {
-    ui->theme_combobox->setCurrentIndex(ui->theme_combobox->findData(UISettings::values.theme));
+    ui->theme_combobox->setCurrentIndex(
+        ui->theme_combobox->findData(QString::fromStdString(UISettings::values.theme)));
     ui->language_combobox->setCurrentIndex(
-        ui->language_combobox->findData(UISettings::values.language));
+        ui->language_combobox->findData(QString::fromStdString(UISettings::values.language)));
     ui->show_add_ons->setChecked(UISettings::values.show_add_ons.GetValue());
     ui->show_compat->setChecked(UISettings::values.show_compat.GetValue());
     ui->show_size->setChecked(UISettings::values.show_size.GetValue());

src/yuzu/configuration/input_profiles.cpp

@@ -5,7 +5,7 @@
 
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
-#include "yuzu/configuration/config.h"
+#include "frontend_common/config.h"
 #include "yuzu/configuration/input_profiles.h"
 
 namespace FS = Common::FS;
@@ -44,7 +44,7 @@ InputProfiles::InputProfiles() {
             if (IsINI(filename) && IsProfileNameValid(name_without_ext)) {
                 map_profiles.insert_or_assign(
                     name_without_ext,
-                    std::make_unique<Config>(name_without_ext, Config::ConfigType::InputProfile));
+                    std::make_unique<QtConfig>(name_without_ext, Config::ConfigType::InputProfile));
             }
 
             return true;
@@ -85,7 +85,7 @@ bool InputProfiles::CreateProfile(const std::string& profile_name, std::size_t p
     }
 
     map_profiles.insert_or_assign(
-        profile_name, std::make_unique<Config>(profile_name, Config::ConfigType::InputProfile));
+        profile_name, std::make_unique<QtConfig>(profile_name, Config::ConfigType::InputProfile));
 
     return SaveProfile(profile_name, player_index);
 }
@@ -113,7 +113,7 @@ bool InputProfiles::LoadProfile(const std::string& profile_name, std::size_t pla
         return false;
     }
 
-    map_profiles[profile_name]->ReadControlPlayerValue(player_index);
+    map_profiles[profile_name]->ReadQtControlPlayerValues(player_index);
     return true;
 }
 
@@ -122,7 +122,7 @@ bool InputProfiles::SaveProfile(const std::string& profile_name, std::size_t pla
         return false;
     }
 
-    map_profiles[profile_name]->SaveControlPlayerValue(player_index);
+    map_profiles[profile_name]->SaveQtControlPlayerValues(player_index);
     return true;
 }
 

src/yuzu/configuration/input_profiles.h

@@ -6,6 +6,8 @@
 #include <string>
 #include <unordered_map>
 
+#include "configuration/qt_config.h"
+
 namespace Core {
 class System;
 }
@@ -30,5 +32,5 @@ public:
 private:
     bool ProfileExistsInMap(const std::string& profile_name) const;
 
-    std::unordered_map<std::string, std::unique_ptr<Config>> map_profiles;
+    std::unordered_map<std::string, std::unique_ptr<QtConfig>> map_profiles;
 };

src/yuzu/configuration/qt_config.cpp

@@ -0,0 +1,549 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "input_common/main.h"
+#include "qt_config.h"
+#include "uisettings.h"
+
+const std::array<int, Settings::NativeButton::NumButtons> QtConfig::default_buttons = {
+    Qt::Key_C,    Qt::Key_X, Qt::Key_V,    Qt::Key_Z,  Qt::Key_F,
+    Qt::Key_G,    Qt::Key_Q, Qt::Key_E,    Qt::Key_R,  Qt::Key_T,
+    Qt::Key_M,    Qt::Key_N, Qt::Key_Left, Qt::Key_Up, Qt::Key_Right,
+    Qt::Key_Down, Qt::Key_Q, Qt::Key_E,    0,          0,
+    Qt::Key_Q,    Qt::Key_E,
+};
+
+const std::array<int, Settings::NativeMotion::NumMotions> QtConfig::default_motions = {
+    Qt::Key_7,
+    Qt::Key_8,
+};
+
+const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> QtConfig::default_analogs{{
+    {
+        Qt::Key_W,
+        Qt::Key_S,
+        Qt::Key_A,
+        Qt::Key_D,
+    },
+    {
+        Qt::Key_I,
+        Qt::Key_K,
+        Qt::Key_J,
+        Qt::Key_L,
+    },
+}};
+
+const std::array<int, 2> QtConfig::default_stick_mod = {
+    Qt::Key_Shift,
+    0,
+};
+
+const std::array<int, 2> QtConfig::default_ringcon_analogs{{
+    Qt::Key_A,
+    Qt::Key_D,
+}};
+
+QtConfig::QtConfig(const std::string& config_name, const ConfigType config_type)
+    : Config(config_type) {
+    Initialize(config_name);
+    if (config_type != ConfigType::InputProfile) {
+        ReadQtValues();
+        SaveQtValues();
+    }
+}
+
+QtConfig::~QtConfig() {
+    if (global) {
+        QtConfig::SaveAllValues();
+    }
+}
+
+void QtConfig::ReloadAllValues() {
+    Reload();
+    ReadQtValues();
+    SaveQtValues();
+}
+
+void QtConfig::SaveAllValues() {
+    Save();
+    SaveQtValues();
+}
+
+void QtConfig::ReadQtValues() {
+    if (global) {
+        ReadUIValues();
+    }
+    ReadQtControlValues();
+}
+
+void QtConfig::ReadQtPlayerValues(const std::size_t player_index) {
+    std::string player_prefix;
+    if (type != ConfigType::InputProfile) {
+        player_prefix.append("player_").append(ToString(player_index)).append("_");
+    }
+
+    auto& player = Settings::values.players.GetValue()[player_index];
+    if (IsCustomConfig()) {
+        const auto profile_name =
+            ReadStringSetting(std::string(player_prefix).append("profile_name"));
+        if (profile_name.empty()) {
+            // Use the global input config
+            player = Settings::values.players.GetValue(true)[player_index];
+            return;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        auto& player_buttons = player.buttons[i];
+
+        player_buttons = ReadStringSetting(
+            std::string(player_prefix).append(Settings::NativeButton::mapping[i]), default_param);
+        if (player_buttons.empty()) {
+            player_buttons = default_param;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        auto& player_analogs = player.analogs[i];
+
+        player_analogs = ReadStringSetting(
+            std::string(player_prefix).append(Settings::NativeAnalog::mapping[i]), default_param);
+        if (player_analogs.empty()) {
+            player_analogs = default_param;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
+        auto& player_motions = player.motions[i];
+
+        player_motions = ReadStringSetting(
+            std::string(player_prefix).append(Settings::NativeMotion::mapping[i]), default_param);
+        if (player_motions.empty()) {
+            player_motions = default_param;
+        }
+    }
+}
+
+void QtConfig::ReadHidbusValues() {
+    const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+        0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
+    auto& ringcon_analogs = Settings::values.ringcon_analogs;
+
+    ringcon_analogs = ReadStringSetting(std::string("ring_controller"), default_param);
+    if (ringcon_analogs.empty()) {
+        ringcon_analogs = default_param;
+    }
+}
+
+void QtConfig::ReadDebugControlValues() {
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        auto& debug_pad_buttons = Settings::values.debug_pad_buttons[i];
+
+        debug_pad_buttons = ReadStringSetting(
+            std::string("debug_pad_").append(Settings::NativeButton::mapping[i]), default_param);
+        if (debug_pad_buttons.empty()) {
+            debug_pad_buttons = default_param;
+        }
+    }
+
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        auto& debug_pad_analogs = Settings::values.debug_pad_analogs[i];
+
+        debug_pad_analogs = ReadStringSetting(
+            std::string("debug_pad_").append(Settings::NativeAnalog::mapping[i]), default_param);
+        if (debug_pad_analogs.empty()) {
+            debug_pad_analogs = default_param;
+        }
+    }
+}
+
+void QtConfig::ReadQtControlValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    Settings::values.players.SetGlobal(!IsCustomConfig());
+    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
+        ReadQtPlayerValues(p);
+    }
+    if (IsCustomConfig()) {
+        EndGroup();
+        return;
+    }
+    ReadDebugControlValues();
+    ReadHidbusValues();
+
+    EndGroup();
+}
+
+void QtConfig::ReadPathValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Paths));
+
+    UISettings::values.roms_path = ReadStringSetting(std::string("romsPath"));
+    UISettings::values.symbols_path = ReadStringSetting(std::string("symbolsPath"));
+    UISettings::values.game_dir_deprecated =
+        ReadStringSetting(std::string("gameListRootDir"), std::string("."));
+    UISettings::values.game_dir_deprecated_deepscan =
+        ReadBooleanSetting(std::string("gameListDeepScan"), std::make_optional(false));
+
+    const int gamedirs_size = BeginArray(std::string("gamedirs"));
+    for (int i = 0; i < gamedirs_size; ++i) {
+        SetArrayIndex(i);
+        UISettings::GameDir game_dir;
+        game_dir.path = ReadStringSetting(std::string("path"));
+        game_dir.deep_scan =
+            ReadBooleanSetting(std::string("deep_scan"), std::make_optional(false));
+        game_dir.expanded = ReadBooleanSetting(std::string("expanded"), std::make_optional(true));
+        UISettings::values.game_dirs.append(game_dir);
+    }
+    EndArray();
+
+    // Create NAND and SD card directories if empty, these are not removable through the UI,
+    // also carries over old game list settings if present
+    if (UISettings::values.game_dirs.empty()) {
+        UISettings::GameDir game_dir;
+        game_dir.path = std::string("SDMC");
+        game_dir.expanded = true;
+        UISettings::values.game_dirs.append(game_dir);
+        game_dir.path = std::string("UserNAND");
+        UISettings::values.game_dirs.append(game_dir);
+        game_dir.path = std::string("SysNAND");
+        UISettings::values.game_dirs.append(game_dir);
+        if (UISettings::values.game_dir_deprecated != std::string(".")) {
+            game_dir.path = UISettings::values.game_dir_deprecated;
+            game_dir.deep_scan = UISettings::values.game_dir_deprecated_deepscan;
+            UISettings::values.game_dirs.append(game_dir);
+        }
+    }
+    UISettings::values.recent_files =
+        QString::fromStdString(ReadStringSetting(std::string("recentFiles")))
+            .split(QStringLiteral(", "), Qt::SkipEmptyParts, Qt::CaseSensitive);
+    UISettings::values.language = ReadStringSetting(std::string("language"), std::string(""));
+
+    EndGroup();
+}
+
+void QtConfig::ReadShortcutValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Shortcuts));
+
+    for (const auto& [name, group, shortcut] : UISettings::default_hotkeys) {
+        BeginGroup(group);
+        BeginGroup(name);
+
+        // No longer using ReadSetting for shortcut.second as it inaccurately returns a value of 1
+        // for WidgetWithChildrenShortcut which is a value of 3. Needed to fix shortcuts the open
+        // a file dialog in windowed mode
+        UISettings::values.shortcuts.push_back(
+            {name,
+             group,
+             {ReadStringSetting(std::string("KeySeq"), shortcut.keyseq),
+              ReadStringSetting(std::string("Controller_KeySeq"), shortcut.controller_keyseq),
+              shortcut.context,
+              ReadBooleanSetting(std::string("Repeat"), std::optional(shortcut.repeat))}});
+
+        EndGroup(); // name
+        EndGroup(); // group
+    }
+
+    EndGroup();
+}
+
+void QtConfig::ReadUIValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Ui));
+
+    UISettings::values.theme = ReadStringSetting(
+        std::string("theme"),
+        std::string(UISettings::themes[static_cast<size_t>(UISettings::default_theme)].second));
+
+    ReadUIGamelistValues();
+    ReadUILayoutValues();
+    ReadPathValues();
+    ReadScreenshotValues();
+    ReadShortcutValues();
+    ReadMultiplayerValues();
+
+    ReadCategory(Settings::Category::Ui);
+    ReadCategory(Settings::Category::UiGeneral);
+
+    EndGroup();
+}
+
+void QtConfig::ReadUIGamelistValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::UiGameList));
+
+    ReadCategory(Settings::Category::UiGameList);
+
+    const int favorites_size = BeginArray("favorites");
+    for (int i = 0; i < favorites_size; i++) {
+        SetArrayIndex(i);
+        UISettings::values.favorited_ids.append(
+            ReadUnsignedIntegerSetting(std::string("program_id")));
+    }
+    EndArray();
+
+    EndGroup();
+}
+
+void QtConfig::ReadUILayoutValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::UiGameList));
+
+    ReadCategory(Settings::Category::UiLayout);
+
+    EndGroup();
+}
+
+void QtConfig::ReadMultiplayerValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Multiplayer));
+
+    ReadCategory(Settings::Category::Multiplayer);
+
+    // Read ban list back
+    int size = BeginArray(std::string("username_ban_list"));
+    UISettings::values.multiplayer_ban_list.first.resize(size);
+    for (int i = 0; i < size; ++i) {
+        SetArrayIndex(i);
+        UISettings::values.multiplayer_ban_list.first[i] =
+            ReadStringSetting(std::string("username"), std::string(""));
+    }
+    EndArray();
+
+    size = BeginArray(std::string("ip_ban_list"));
+    UISettings::values.multiplayer_ban_list.second.resize(size);
+    for (int i = 0; i < size; ++i) {
+        UISettings::values.multiplayer_ban_list.second[i] =
+            ReadStringSetting("username", std::string(""));
+    }
+    EndArray();
+
+    EndGroup();
+}
+
+void QtConfig::SaveQtValues() {
+    if (global) {
+        SaveUIValues();
+    }
+    SaveQtControlValues();
+
+    WriteToIni();
+}
+
+void QtConfig::SaveQtPlayerValues(const std::size_t player_index) {
+    std::string player_prefix;
+    if (type != ConfigType::InputProfile) {
+        player_prefix = std::string("player_").append(ToString(player_index)).append("_");
+    }
+
+    const auto& player = Settings::values.players.GetValue()[player_index];
+    if (IsCustomConfig() && player.profile_name.empty()) {
+        // No custom profile selected
+        return;
+    }
+
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        WriteSetting(std::string(player_prefix).append(Settings::NativeButton::mapping[i]),
+                     player.buttons[i], std::make_optional(default_param));
+    }
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        WriteSetting(std::string(player_prefix).append(Settings::NativeAnalog::mapping[i]),
+                     player.analogs[i], std::make_optional(default_param));
+    }
+    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
+        WriteSetting(std::string(player_prefix).append(Settings::NativeMotion::mapping[i]),
+                     player.motions[i], std::make_optional(default_param));
+    }
+}
+
+void QtConfig::SaveDebugControlValues() {
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
+        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
+        WriteSetting(std::string("debug_pad_").append(Settings::NativeButton::mapping[i]),
+                     Settings::values.debug_pad_buttons[i], std::make_optional(default_param));
+    }
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
+        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
+            default_analogs[i][3], default_stick_mod[i], 0.5f);
+        WriteSetting(std::string("debug_pad_").append(Settings::NativeAnalog::mapping[i]),
+                     Settings::values.debug_pad_analogs[i], std::make_optional(default_param));
+    }
+}
+
+void QtConfig::SaveHidbusValues() {
+    const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
+        0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
+    WriteSetting(std::string("ring_controller"), Settings::values.ringcon_analogs,
+                 std::make_optional(default_param));
+}
+
+void QtConfig::SaveQtControlValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    Settings::values.players.SetGlobal(!IsCustomConfig());
+    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
+        SaveQtPlayerValues(p);
+    }
+    if (IsCustomConfig()) {
+        EndGroup();
+        return;
+    }
+    SaveDebugControlValues();
+    SaveHidbusValues();
+
+    EndGroup();
+}
+
+void QtConfig::SavePathValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Paths));
+
+    WriteSetting(std::string("romsPath"), UISettings::values.roms_path);
+    WriteSetting(std::string("symbolsPath"), UISettings::values.symbols_path);
+    BeginArray(std::string("gamedirs"));
+    for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {
+        SetArrayIndex(i);
+        const auto& game_dir = UISettings::values.game_dirs[i];
+        WriteSetting(std::string("path"), game_dir.path);
+        WriteSetting(std::string("deep_scan"), game_dir.deep_scan, std::make_optional(false));
+        WriteSetting(std::string("expanded"), game_dir.expanded, std::make_optional(true));
+    }
+    EndArray();
+
+    WriteSetting(std::string("recentFiles"),
+                 UISettings::values.recent_files.join(QStringLiteral(", ")).toStdString());
+    WriteSetting(std::string("language"), UISettings::values.language);
+
+    EndGroup();
+}
+
+void QtConfig::SaveShortcutValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Shortcuts));
+
+    // Lengths of UISettings::values.shortcuts & default_hotkeys are same.
+    // However, their ordering must also be the same.
+    for (std::size_t i = 0; i < UISettings::default_hotkeys.size(); i++) {
+        const auto& [name, group, shortcut] = UISettings::values.shortcuts[i];
+        const auto& default_hotkey = UISettings::default_hotkeys[i].shortcut;
+
+        BeginGroup(group);
+        BeginGroup(name);
+
+        WriteSetting(std::string("KeySeq"), shortcut.keyseq,
+                     std::make_optional(default_hotkey.keyseq));
+        WriteSetting(std::string("Controller_KeySeq"), shortcut.controller_keyseq,
+                     std::make_optional(default_hotkey.controller_keyseq));
+        WriteSetting(std::string("Context"), shortcut.context,
+                     std::make_optional(default_hotkey.context));
+        WriteSetting(std::string("Repeat"), shortcut.repeat,
+                     std::make_optional(default_hotkey.repeat));
+
+        EndGroup(); // name
+        EndGroup(); // group
+    }
+
+    EndGroup();
+}
+
+void QtConfig::SaveUIValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Ui));
+
+    WriteCategory(Settings::Category::Ui);
+    WriteCategory(Settings::Category::UiGeneral);
+
+    WriteSetting(std::string("theme"), UISettings::values.theme,
+                 std::make_optional(std::string(
+                     UISettings::themes[static_cast<size_t>(UISettings::default_theme)].second)));
+
+    SaveUIGamelistValues();
+    SaveUILayoutValues();
+    SavePathValues();
+    SaveScreenshotValues();
+    SaveShortcutValues();
+    SaveMultiplayerValues();
+
+    EndGroup();
+}
+
+void QtConfig::SaveUIGamelistValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::UiGameList));
+
+    WriteCategory(Settings::Category::UiGameList);
+
+    BeginArray(std::string("favorites"));
+    for (int i = 0; i < UISettings::values.favorited_ids.size(); i++) {
+        SetArrayIndex(i);
+        WriteSetting(std::string("program_id"), UISettings::values.favorited_ids[i]);
+    }
+    EndArray(); // favorites
+
+    EndGroup();
+}
+
+void QtConfig::SaveUILayoutValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::UiLayout));
+
+    WriteCategory(Settings::Category::UiLayout);
+
+    EndGroup();
+}
+
+void QtConfig::SaveMultiplayerValues() {
+    BeginGroup(std::string("Multiplayer"));
+
+    WriteCategory(Settings::Category::Multiplayer);
+
+    // Write ban list
+    BeginArray(std::string("username_ban_list"));
+    for (std::size_t i = 0; i < UISettings::values.multiplayer_ban_list.first.size(); ++i) {
+        SetArrayIndex(static_cast<int>(i));
+        WriteSetting(std::string("username"), UISettings::values.multiplayer_ban_list.first[i]);
+    }
+    EndArray(); // username_ban_list
+
+    BeginArray(std::string("ip_ban_list"));
+    for (std::size_t i = 0; i < UISettings::values.multiplayer_ban_list.second.size(); ++i) {
+        SetArrayIndex(static_cast<int>(i));
+        WriteSetting(std::string("ip"), UISettings::values.multiplayer_ban_list.second[i]);
+    }
+    EndArray(); // ip_ban_list
+
+    EndGroup();
+}
+
+std::vector<Settings::BasicSetting*>& QtConfig::FindRelevantList(Settings::Category category) {
+    auto& map = Settings::values.linkage.by_category;
+    if (map.contains(category)) {
+        return Settings::values.linkage.by_category[category];
+    }
+    return UISettings::values.linkage.by_category[category];
+}
+
+void QtConfig::ReadQtControlPlayerValues(std::size_t player_index) {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    ReadPlayerValues(player_index);
+    ReadQtPlayerValues(player_index);
+
+    EndGroup();
+}
+
+void QtConfig::SaveQtControlPlayerValues(std::size_t player_index) {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    SavePlayerValues(player_index);
+    SaveQtPlayerValues(player_index);
+
+    EndGroup();
+
+    WriteToIni();
+}

src/yuzu/configuration/qt_config.h

@@ -0,0 +1,55 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QMetaType>
+
+#include "frontend_common/config.h"
+
+class QtConfig final : public Config {
+public:
+    explicit QtConfig(const std::string& config_name = "qt-config",
+                      ConfigType config_type = ConfigType::GlobalConfig);
+    ~QtConfig() override;
+
+    void ReloadAllValues() override;
+    void SaveAllValues() override;
+
+    void ReadQtControlPlayerValues(std::size_t player_index);
+    void SaveQtControlPlayerValues(std::size_t player_index);
+
+protected:
+    void ReadQtValues();
+    void ReadQtPlayerValues(std::size_t player_index);
+    void ReadQtControlValues();
+    void ReadHidbusValues() override;
+    void ReadDebugControlValues() override;
+    void ReadPathValues() override;
+    void ReadShortcutValues() override;
+    void ReadUIValues() override;
+    void ReadUIGamelistValues() override;
+    void ReadUILayoutValues() override;
+    void ReadMultiplayerValues() override;
+
+    void SaveQtValues();
+    void SaveQtPlayerValues(std::size_t player_index);
+    void SaveQtControlValues();
+    void SaveHidbusValues() override;
+    void SaveDebugControlValues() override;
+    void SavePathValues() override;
+    void SaveShortcutValues() override;
+    void SaveUIValues() override;
+    void SaveUIGamelistValues() override;
+    void SaveUILayoutValues() override;
+    void SaveMultiplayerValues() override;
+
+    std::vector<Settings::BasicSetting*>& FindRelevantList(Settings::Category category) override;
+
+public:
+    static const std::array<int, Settings::NativeButton::NumButtons> default_buttons;
+    static const std::array<int, Settings::NativeMotion::NumMotions> default_motions;
+    static const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> default_analogs;
+    static const std::array<int, 2> default_stick_mod;
+    static const std::array<int, 2> default_ringcon_analogs;
+};

src/yuzu/configuration/shared_translation.h

@@ -10,6 +10,7 @@
 #include <vector>
 #include <QString>
 #include "common/common_types.h"
+#include "common/settings.h"
 
 class QWidget;
 
@@ -22,4 +23,46 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent);
 
 std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent);
 
+static const std::map<Settings::AntiAliasing, QString> anti_aliasing_texts_map = {
+    {Settings::AntiAliasing::None, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "None"))},
+    {Settings::AntiAliasing::Fxaa, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FXAA"))},
+    {Settings::AntiAliasing::Smaa, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "SMAA"))},
+};
+
+static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map = {
+    {Settings::ScalingFilter::NearestNeighbor,
+     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Nearest"))},
+    {Settings::ScalingFilter::Bilinear,
+     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bilinear"))},
+    {Settings::ScalingFilter::Bicubic, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bicubic"))},
+    {Settings::ScalingFilter::Gaussian,
+     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Gaussian"))},
+    {Settings::ScalingFilter::ScaleForce,
+     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "ScaleForce"))},
+    {Settings::ScalingFilter::Fsr, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FSR"))},
+};
+
+static const std::map<Settings::ConsoleMode, QString> use_docked_mode_texts_map = {
+    {Settings::ConsoleMode::Docked, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Docked"))},
+    {Settings::ConsoleMode::Handheld, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Handheld"))},
+};
+
+static const std::map<Settings::GpuAccuracy, QString> gpu_accuracy_texts_map = {
+    {Settings::GpuAccuracy::Normal, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Normal"))},
+    {Settings::GpuAccuracy::High, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "High"))},
+    {Settings::GpuAccuracy::Extreme, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Extreme"))},
+};
+
+static const std::map<Settings::RendererBackend, QString> renderer_backend_texts_map = {
+    {Settings::RendererBackend::Vulkan, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Vulkan"))},
+    {Settings::RendererBackend::OpenGL, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "OpenGL"))},
+    {Settings::RendererBackend::Null, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Null"))},
+};
+
+static const std::map<Settings::ShaderBackend, QString> shader_backend_texts_map = {
+    {Settings::ShaderBackend::Glsl, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLSL"))},
+    {Settings::ShaderBackend::Glasm, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "GLASM"))},
+    {Settings::ShaderBackend::SpirV, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "SPIRV"))},
+};
+
 } // namespace ConfigurationShared