stuff/suyu
stuff/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-11-30 07:16:24 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
suyu/src/yuzu/configuration/config.cpp

1066 lines
42 KiB
C++
Raw Normal View History

Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-12 20:06:13 -04:00
// Copyright 2014 Citra Emulator Project
License change
2014-12-17 00:38:14 -05:00
// Licensed under GPLv2 or any later version
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-12 20:06:13 -04:00
// Refer to the license.txt file included.
yuzu: Make hotkeys configurable via the GUI * Adds a new Hotkeys tab in the Controls group. * Double-click a Hotkey to rebind it.
2019-02-16 10:19:29 -05:00
#include <array>
#include <QKeySequence>
Remove empty newlines in #include blocks. This makes clang-format useful on those. Also add a bunch of forgotten transitive includes, which otherwise prevented compilation.
2016-09-20 11:21:23 -04:00
#include <QSettings>
citra_qt: Reorganize headers
2015-09-11 00:23:00 -04:00
#include "common/file_util.h"
configure_input: Add ConfigureInputSimple as default input UI config Greatly simplifies the current input UI, while still allowing power users to tweak advanced settings. Adds 'input profiles', which are easy autoconfigurations to make getting started easy and fast. Also has a custom option which brings up the current, full UI.
2018-12-01 11:11:11 -05:00
#include "configure_input_simple.h"
profile_manager: Load user icons, names, and UUIDs from system save
2018-10-10 21:49:20 -04:00
#include "core/hle/service/acc/profile_manager.h"
configure_input: Make None a controller option instead of checkbox
2018-11-04 10:18:59 -05:00
#include "core/hle/service/hid/controllers/npad.h"
InputCommon: add Keyboard
2017-01-21 04:53:03 -05:00
#include "input_common/main.h"
Remove gpu debugger and get yuzu qt to compile
2018-01-11 22:33:56 -05:00
#include "yuzu/configuration/config.h"
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-12 20:06:13 -04:00
Config::Config() {
// TODO: Don't hardcode the path; let the frontend decide where to put the config files.
file_util: Use an enum class for GetUserPath() Instead of using an unsigned int as a parameter and expecting a user to always pass in the correct values, we can just convert the enum into an enum class and use that type as the parameter type instead, which makes the interface more type safe. We also get rid of the bookkeeping "NUM_" element in the enum by just using an unordered map. This function is generally low-frequency in terms of calls (and I'd hope so, considering otherwise would mean we're slamming the disk with IO all the time) so I'd consider this acceptable in this case.
2018-07-21 15:52:42 -04:00
qt_config_loc = FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) + "qt-config.ini";
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-12 20:06:13 -04:00
FileUtil::CreateFullPath(qt_config_loc);
yuzu/configuration/config: Use a std::unique_ptr for qt_config instead of a raw pointer Same behavior, less code.
2018-10-23 21:49:50 -04:00
qt_config =
std::make_unique<QSettings>(QString::fromStdString(qt_config_loc), QSettings::IniFormat);
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-12 20:06:13 -04:00
Reload();
}
yuzu/configuration/config: Use a std::unique_ptr for qt_config instead of a raw pointer Same behavior, less code.
2018-10-23 21:49:50 -04:00
Config::~Config() {
Save();
}
InputCommon: add Keyboard
2017-01-21 04:53:03 -05:00
const std::array<int, Settings::NativeButton::NumButtons> Config::default_buttons = {
clang-format
2018-01-16 13:05:21 -05:00
Qt::Key_A, Qt::Key_S, Qt::Key_Z, Qt::Key_X, Qt::Key_3, Qt::Key_4, Qt::Key_Q,
Qt::Key_W, Qt::Key_1, Qt::Key_2, Qt::Key_N, Qt::Key_M, Qt::Key_F, Qt::Key_T,
Qt::Key_H, Qt::Key_G, Qt::Key_Left, Qt::Key_Up, Qt::Key_Right, Qt::Key_Down, Qt::Key_J,
Qt::Key_I, Qt::Key_L, Qt::Key_K, Qt::Key_D, Qt::Key_C, Qt::Key_B, Qt::Key_V,
Move input values into an array
2015-06-19 23:34:45 -04:00
};
InputCommon: add AnalogFromButton
2017-01-21 06:04:00 -05:00
const std::array<std::array<int, 5>, Settings::NativeAnalog::NumAnalogs> Config::default_analogs{{
{
Format: Run the new clang format on everything
2018-01-20 02:48:02 -05:00
Qt::Key_Up,
Qt::Key_Down,
Qt::Key_Left,
Qt::Key_Right,
Qt::Key_E,
InputCommon: add AnalogFromButton
2017-01-21 06:04:00 -05:00
},
{
Format: Run the new clang format on everything
2018-01-20 02:48:02 -05:00
Qt::Key_I,
Qt::Key_K,
Qt::Key_J,
Qt::Key_L,
Qt::Key_R,
InputCommon: add AnalogFromButton
2017-01-21 06:04:00 -05:00
},
}};
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
const std::array<int, Settings::NativeMouseButton::NumMouseButtons> Config::default_mouse_buttons =
{
Qt::Key_BracketLeft, Qt::Key_BracketRight, Qt::Key_Apostrophe, Qt::Key_Minus, Qt::Key_Equal,
};
const std::array<int, Settings::NativeKeyboard::NumKeyboardKeys> Config::default_keyboard_keys = {
0,
0,
0,
0,
Qt::Key_A,
Qt::Key_B,
Qt::Key_C,
Qt::Key_D,
Qt::Key_E,
Qt::Key_F,
Qt::Key_G,
Qt::Key_H,
Qt::Key_I,
Qt::Key_J,
Qt::Key_K,
Qt::Key_L,
Qt::Key_M,
Qt::Key_N,
Qt::Key_O,
Qt::Key_P,
Qt::Key_Q,
Qt::Key_R,
Qt::Key_S,
Qt::Key_T,
Qt::Key_U,
Qt::Key_V,
Qt::Key_W,
Qt::Key_X,
Qt::Key_Y,
Qt::Key_Z,
Qt::Key_1,
Qt::Key_2,
Qt::Key_3,
Qt::Key_4,
Qt::Key_5,
Qt::Key_6,
Qt::Key_7,
Qt::Key_8,
Qt::Key_9,
Qt::Key_0,
Qt::Key_Enter,
Qt::Key_Escape,
Qt::Key_Backspace,
Qt::Key_Tab,
Qt::Key_Space,
Qt::Key_Minus,
Qt::Key_Equal,
Qt::Key_BracketLeft,
Qt::Key_BracketRight,
Qt::Key_Backslash,
Qt::Key_Dead_Tilde,
Qt::Key_Semicolon,
Qt::Key_Apostrophe,
Qt::Key_Dead_Grave,
Qt::Key_Comma,
Qt::Key_Period,
Qt::Key_Slash,
Qt::Key_CapsLock,
Qt::Key_F1,
Qt::Key_F2,
Qt::Key_F3,
Qt::Key_F4,
Qt::Key_F5,
Qt::Key_F6,
Qt::Key_F7,
Qt::Key_F8,
Qt::Key_F9,
Qt::Key_F10,
Qt::Key_F11,
Qt::Key_F12,
Qt::Key_SysReq,
Qt::Key_ScrollLock,
Qt::Key_Pause,
Qt::Key_Insert,
Qt::Key_Home,
Qt::Key_PageUp,
Qt::Key_Delete,
Qt::Key_End,
Qt::Key_PageDown,
Qt::Key_Right,
Qt::Key_Left,
Qt::Key_Down,
Qt::Key_Up,
Qt::Key_NumLock,
Qt::Key_Slash,
Qt::Key_Asterisk,
Qt::Key_Minus,
Qt::Key_Plus,
Qt::Key_Enter,
Qt::Key_1,
Qt::Key_2,
Qt::Key_3,
Qt::Key_4,
Qt::Key_5,
Qt::Key_6,
Qt::Key_7,
Qt::Key_8,
Qt::Key_9,
Qt::Key_0,
Qt::Key_Period,
0,
0,
Qt::Key_PowerOff,
Qt::Key_Equal,
Qt::Key_F13,
Qt::Key_F14,
Qt::Key_F15,
Qt::Key_F16,
Qt::Key_F17,
Qt::Key_F18,
Qt::Key_F19,
Qt::Key_F20,
Qt::Key_F21,
Qt::Key_F22,
Qt::Key_F23,
Qt::Key_F24,
Qt::Key_Open,
Qt::Key_Help,
Qt::Key_Menu,
0,
Qt::Key_Stop,
Qt::Key_AudioRepeat,
Qt::Key_Undo,
Qt::Key_Cut,
Qt::Key_Copy,
Qt::Key_Paste,
Qt::Key_Find,
Qt::Key_VolumeMute,
Qt::Key_VolumeUp,
Qt::Key_VolumeDown,
Qt::Key_CapsLock,
Qt::Key_NumLock,
Qt::Key_ScrollLock,
Qt::Key_Comma,
Qt::Key_ParenLeft,
Qt::Key_ParenRight,
};
const std::array<int, Settings::NativeKeyboard::NumKeyboardMods> Config::default_keyboard_mods = {
Qt::Key_Control, Qt::Key_Shift, Qt::Key_Alt, Qt::Key_ApplicationLeft,
Qt::Key_Control, Qt::Key_Shift, Qt::Key_AltGr, Qt::Key_ApplicationRight,
};
yuzu: Make hotkeys configurable via the GUI * Adds a new Hotkeys tab in the Controls group. * Double-click a Hotkey to rebind it.
2019-02-16 10:19:29 -05:00
// This shouldn't have anything except static initializers (no functions). So
// QKeySequnce(...).toString() is NOT ALLOWED HERE.
// This must be in alphabetical order according to action name as it must have the same order as
// UISetting::values.shortcuts, which is alphabetically ordered.
const std::array<UISettings::Shortcut, 15> Config::default_hotkeys{
{{"Capture Screenshot", "Main Window", {"Ctrl+P", Qt::ApplicationShortcut}},
{"Continue/Pause Emulation", "Main Window", {"F4", Qt::WindowShortcut}},
{"Decrease Speed Limit", "Main Window", {"-", Qt::ApplicationShortcut}},
{"Exit yuzu", "Main Window", {"Ctrl+Q", Qt::WindowShortcut}},
{"Exit Fullscreen", "Main Window", {"Esc", Qt::WindowShortcut}},
{"Fullscreen", "Main Window", {"F11", Qt::WindowShortcut}},
{"Increase Speed Limit", "Main Window", {"+", Qt::ApplicationShortcut}},
{"Load Amiibo", "Main Window", {"F2", Qt::ApplicationShortcut}},
{"Load File", "Main Window", {"Ctrl+O", Qt::WindowShortcut}},
{"Restart Emulation", "Main Window", {"F6", Qt::WindowShortcut}},
{"Stop Emulation", "Main Window", {"F5", Qt::WindowShortcut}},
{"Toggle Filter Bar", "Main Window", {"Ctrl+F", Qt::WindowShortcut}},
{"Toggle Speed Limit", "Main Window", {"Ctrl+Z", Qt::ApplicationShortcut}},
{"Toggle Status Bar", "Main Window", {"Ctrl+S", Qt::WindowShortcut}},
{"Change Docked Mode", "Main Window", {"F10", Qt::ApplicationShortcut}}}};
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
void Config::ReadPlayerValues() {
for (std::size_t p = 0; p < Settings::values.players.size(); ++p) {
configuration/config: Use an intermediary variable for accessing players Avoids typing the same long accessor just to retrieve player attributes.
2018-12-05 03:41:31 -05:00
auto& player = Settings::values.players[p];
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
player.connected =
ReadSetting(QStringLiteral("player_%1_connected").arg(p), false).toBool();
configuration/config: Use an intermediary variable for accessing players Avoids typing the same long accessor just to retrieve player attributes.
2018-12-05 03:41:31 -05:00
player.type = static_cast<Settings::ControllerType>(
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
qt_config
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
->value(QStringLiteral("player_%1_type").arg(p),
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
static_cast<u8>(Settings::ControllerType::DualJoycon))
.toUInt());
configuration/config: Use an intermediary variable for accessing players Avoids typing the same long accessor just to retrieve player attributes.
2018-12-05 03:41:31 -05:00
player.body_color_left = qt_config
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
->value(QStringLiteral("player_%1_body_color_left").arg(p),
configuration/config: Use an intermediary variable for accessing players Avoids typing the same long accessor just to retrieve player attributes.
2018-12-05 03:41:31 -05:00
Settings::JOYCON_BODY_NEON_BLUE)
.toUInt();
player.body_color_right = qt_config
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
->value(QStringLiteral("player_%1_body_color_right").arg(p),
configuration/config: Use an intermediary variable for accessing players Avoids typing the same long accessor just to retrieve player attributes.
2018-12-05 03:41:31 -05:00
Settings::JOYCON_BODY_NEON_RED)
.toUInt();
player.button_color_left = qt_config
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
->value(QStringLiteral("player_%1_button_color_left").arg(p),
configuration/config: Use an intermediary variable for accessing players Avoids typing the same long accessor just to retrieve player attributes.
2018-12-05 03:41:31 -05:00
Settings::JOYCON_BUTTONS_NEON_BLUE)
.toUInt();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
player.button_color_right =
qt_config
->value(QStringLiteral("player_%1_button_color_right").arg(p),
Settings::JOYCON_BUTTONS_NEON_RED)
.toUInt();
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const std::string default_param =
InputCommon::GenerateKeyboardParam(default_buttons[i]);
auto& player_buttons = player.buttons[i];
player_buttons = qt_config
->value(QStringLiteral("player_%1_").arg(p) +
QString::fromUtf8(Settings::NativeButton::mapping[i]),
QString::fromStdString(default_param))
.toString()
.toStdString();
if (player_buttons.empty()) {
player_buttons = default_param;
}
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
}
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
default_analogs[i][3], default_analogs[i][4], 0.5f);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
auto& player_analogs = player.analogs[i];
player_analogs = qt_config
->value(QStringLiteral("player_%1_").arg(p) +
QString::fromUtf8(Settings::NativeAnalog::mapping[i]),
QString::fromStdString(default_param))
.toString()
.toStdString();
if (player_analogs.empty()) {
player_analogs = default_param;
}
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
}
}
configure_input: Make None a controller option instead of checkbox
2018-11-04 10:18:59 -05:00
std::stable_partition(
Settings::values.players.begin(),
Settings::values.players.begin() +
Service::HID::Controller_NPad::NPadIdToIndex(Service::HID::NPAD_HANDHELD),
[](const auto& player) { return player.connected; });
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
}
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
void Config::ReadDebugValues() {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
Settings::values.debug_pad_enabled =
ReadSetting(QStringLiteral("debug_pad_enabled"), false).toBool();
InputCommon: add Keyboard
2017-01-21 04:53:03 -05:00
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
auto& debug_pad_buttons = Settings::values.debug_pad_buttons[i];
debug_pad_buttons = qt_config
->value(QStringLiteral("debug_pad_") +
QString::fromUtf8(Settings::NativeButton::mapping[i]),
QString::fromStdString(default_param))
.toString()
.toStdString();
if (debug_pad_buttons.empty()) {
debug_pad_buttons = default_param;
}
Move input values into an array
2015-06-19 23:34:45 -04:00
}
InputCommon: add AnalogFromButton
2017-01-21 06:04:00 -05:00
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
InputCommon: add AnalogFromButton
2017-01-21 06:04:00 -05:00
default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
default_analogs[i][3], default_analogs[i][4], 0.5f);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
auto& debug_pad_analogs = Settings::values.debug_pad_analogs[i];
debug_pad_analogs = qt_config
->value(QStringLiteral("debug_pad_") +
QString::fromUtf8(Settings::NativeAnalog::mapping[i]),
QString::fromStdString(default_param))
.toString()
.toStdString();
if (debug_pad_analogs.empty()) {
debug_pad_analogs = default_param;
}
InputCommon: add AnalogFromButton
2017-01-21 06:04:00 -05:00
}
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
}
void Config::ReadKeyboardValues() {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
Settings::values.keyboard_enabled =
ReadSetting(QStringLiteral("keyboard_enabled"), false).toBool();
InputCommon: add AnalogFromButton
2017-01-21 06:04:00 -05:00
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
std::transform(default_keyboard_keys.begin(), default_keyboard_keys.end(),
Settings::values.keyboard_keys.begin(), InputCommon::GenerateKeyboardParam);
std::transform(default_keyboard_mods.begin(), default_keyboard_mods.end(),
Settings::values.keyboard_keys.begin() +
Settings::NativeKeyboard::LeftControlKey,
InputCommon::GenerateKeyboardParam);
std::transform(default_keyboard_mods.begin(), default_keyboard_mods.end(),
Settings::values.keyboard_mods.begin(), InputCommon::GenerateKeyboardParam);
}
void Config::ReadMouseValues() {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
Settings::values.mouse_enabled = ReadSetting(QStringLiteral("mouse_enabled"), false).toBool();
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const std::string default_param =
InputCommon::GenerateKeyboardParam(default_mouse_buttons[i]);
auto& mouse_buttons = Settings::values.mouse_buttons[i];
mouse_buttons = qt_config
->value(QStringLiteral("mouse_") +
QString::fromUtf8(Settings::NativeMouseButton::mapping[i]),
QString::fromStdString(default_param))
.toString()
.toStdString();
if (mouse_buttons.empty()) {
mouse_buttons = default_param;
}
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
}
}
void Config::ReadTouchscreenValues() {
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
Settings::values.touchscreen.enabled = ReadSetting("touchscreen_enabled", true).toBool();
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
Settings::values.touchscreen.device =
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
ReadSetting("touchscreen_device", "engine:emu_window").toString().toStdString();
Settings::values.touchscreen.finger = ReadSetting("touchscreen_finger", 0).toUInt();
Settings::values.touchscreen.rotation_angle = ReadSetting("touchscreen_angle", 0).toUInt();
Settings::values.touchscreen.diameter_x = ReadSetting("touchscreen_diameter_x", 15).toUInt();
Settings::values.touchscreen.diameter_y = ReadSetting("touchscreen_diameter_y", 15).toUInt();
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
}
configure_input: Add ConfigureInputSimple as default input UI config Greatly simplifies the current input UI, while still allowing power users to tweak advanced settings. Adds 'input profiles', which are easy autoconfigurations to make getting started easy and fast. Also has a custom option which brings up the current, full UI.
2018-12-01 11:11:11 -05:00
void Config::ApplyDefaultProfileIfInputInvalid() {
if (!std::any_of(Settings::values.players.begin(), Settings::values.players.end(),
[](const Settings::PlayerInput& in) { return in.connected; })) {
ApplyInputProfileConfiguration(UISettings::values.profile_index);
}
}
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::ReadAudioValues() {
qt_config->beginGroup(QStringLiteral("Audio"));
Settings::values.sink_id = ReadSetting(QStringLiteral("output_engine"), QStringLiteral("auto"))
.toString()
.toStdString();
Settings::values.enable_audio_stretching =
ReadSetting(QStringLiteral("enable_audio_stretching"), true).toBool();
Settings::values.audio_device_id =
ReadSetting(QStringLiteral("output_device"), QStringLiteral("auto"))
.toString()
.toStdString();
Settings::values.volume = ReadSetting(QStringLiteral("volume"), 1).toFloat();
qt_config->endGroup();
}
void Config::ReadControlValues() {
qt_config->beginGroup(QStringLiteral("Controls"));
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
ReadPlayerValues();
ReadDebugValues();
ReadKeyboardValues();
ReadMouseValues();
ReadTouchscreenValues();
Settings::values.motion_device =
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
ReadSetting(QStringLiteral("motion_device"),
QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"))
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
.toString()
.toStdString();
Merge Config::ReadXYZs
2014-11-15 14:56:18 -05:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
Merge Config::ReadXYZs
2014-11-15 14:56:18 -05:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::ReadCoreValues() {
qt_config->beginGroup(QStringLiteral("Core"));
INI hw/sw renderer toggle
2015-05-03 15:34:48 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
Settings::values.use_cpu_jit = ReadSetting(QStringLiteral("use_cpu_jit"), true).toBool();
Settings::values.use_multi_core = ReadSetting(QStringLiteral("use_multi_core"), false).toBool();
Allow the user to set the background clear color during emulation The background color can be seen at the sides of the bottom screen or when the window is wider than normal.
2015-04-03 18:35:51 -04:00
audio_core: Add configuration settings.
2018-07-30 23:57:53 -04:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
void Config::ReadDataStorageValues() {
qt_config->beginGroup(QStringLiteral("Data Storage"));
audio_core: Add configuration settings.
2018-07-30 23:57:53 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
Settings::values.use_virtual_sd = ReadSetting(QStringLiteral("use_virtual_sd"), true).toBool();
settings: Save and load NAND/SD dirs from config
2018-09-01 14:49:07 -04:00
FileUtil::GetUserPath(
FileUtil::UserPath::NANDDir,
qt_config
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
->value(QStringLiteral("nand_directory"),
settings: Save and load NAND/SD dirs from config
2018-09-01 14:49:07 -04:00
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)))
.toString()
.toStdString());
FileUtil::GetUserPath(
FileUtil::UserPath::SDMCDir,
qt_config
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
->value(QStringLiteral("sdmc_directory"),
settings: Save and load NAND/SD dirs from config
2018-09-01 14:49:07 -04:00
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)))
.toString()
.toStdString());
Merge Config::ReadXYZs
2014-11-15 14:56:18 -05:00
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::ReadDebuggingValues() {
qt_config->beginGroup(QStringLiteral("Debugging"));
config: Add setting for whether the system is docked or not.
2018-03-26 22:24:31 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
Settings::values.use_gdbstub = ReadSetting(QStringLiteral("use_gdbstub"), false).toBool();
Settings::values.gdbstub_port = ReadSetting(QStringLiteral("gdbstub_port"), 24689).toInt();
Settings::values.program_args =
ReadSetting(QStringLiteral("program_args"), QStringLiteral("")).toString().toStdString();
Settings::values.dump_exefs = ReadSetting(QStringLiteral("dump_exefs"), false).toBool();
Settings::values.dump_nso = ReadSetting(QStringLiteral("dump_nso"), false).toBool();
Implement gdbstub
2015-09-02 08:56:38 -04:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::ReadDisabledAddOnValues() {
const auto size = qt_config->beginReadArray(QStringLiteral("DisabledAddOns"));
Port web_service from Citra
2018-09-16 14:05:51 -04:00
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
for (int i = 0; i < size; ++i) {
qt_config->setArrayIndex(i);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const auto title_id = ReadSetting(QStringLiteral("title_id"), 0).toULongLong();
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
std::vector<std::string> out;
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const auto d_size = qt_config->beginReadArray(QStringLiteral("disabled"));
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
for (int j = 0; j < d_size; ++j) {
qt_config->setArrayIndex(j);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
out.push_back(
ReadSetting(QStringLiteral("d"), QStringLiteral("")).toString().toStdString());
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
}
qt_config->endArray();
Settings::values.disabled_addons.insert_or_assign(title_id, out);
}
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
qt_config->endArray();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::ReadMiscellaneousValues() {
qt_config->beginGroup(QStringLiteral("Miscellaneous"));
Settings::values.log_filter =
ReadSetting(QStringLiteral("log_filter"), QStringLiteral("*:Info"))
.toString()
.toStdString();
Settings::values.use_dev_keys = ReadSetting(QStringLiteral("use_dev_keys"), false).toBool();
Remove whitespaces
2018-03-30 08:18:35 -04:00
Avoid parsing RomFS to directory in NCA
2018-07-28 12:32:16 -04:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
void Config::ReadPathValues() {
qt_config->beginGroup(QStringLiteral("Paths"));
UISettings::values.roms_path = ReadSetting(QStringLiteral("romsPath")).toString();
UISettings::values.symbols_path = ReadSetting(QStringLiteral("symbolsPath")).toString();
UISettings::values.game_directory_path =
ReadSetting(QStringLiteral("gameListRootDir"), QStringLiteral(".")).toString();
UISettings::values.game_directory_deepscan =
ReadSetting(QStringLiteral("gameListDeepScan"), false).toBool();
UISettings::values.recent_files = ReadSetting(QStringLiteral("recentFiles")).toStringList();
Avoid parsing RomFS to directory in NCA
2018-07-28 12:32:16 -04:00
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
void Config::ReadRendererValues() {
qt_config->beginGroup(QStringLiteral("Renderer"));
Settings::values.resolution_factor =
ReadSetting(QStringLiteral("resolution_factor"), 1.0).toFloat();
Settings::values.use_frame_limit =
ReadSetting(QStringLiteral("use_frame_limit"), true).toBool();
Settings::values.frame_limit = ReadSetting(QStringLiteral("frame_limit"), 100).toInt();
Settings::values.use_compatibility_profile =
ReadSetting(QStringLiteral("use_compatibility_profile"), true).toBool();
Settings::values.use_disk_shader_cache =
ReadSetting(QStringLiteral("use_disk_shader_cache"), true).toBool();
Settings::values.use_accurate_gpu_emulation =
ReadSetting(QStringLiteral("use_accurate_gpu_emulation"), false).toBool();
Settings::values.use_asynchronous_gpu_emulation =
ReadSetting(QStringLiteral("use_asynchronous_gpu_emulation"), false).toBool();
Settings::values.force_30fps_mode =
ReadSetting(QStringLiteral("force_30fps_mode"), false).toBool();
Settings::values.bg_red = ReadSetting(QStringLiteral("bg_red"), 0.0).toFloat();
Settings::values.bg_green = ReadSetting(QStringLiteral("bg_green"), 0.0).toFloat();
Settings::values.bg_blue = ReadSetting(QStringLiteral("bg_blue"), 0.0).toFloat();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
void Config::ReadShortcutValues() {
qt_config->beginGroup(QStringLiteral("Shortcuts"));
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
yuzu: Make hotkeys configurable via the GUI * Adds a new Hotkeys tab in the Controls group. * Double-click a Hotkey to rebind it.
2019-02-16 10:19:29 -05:00
for (auto [name, group, shortcut] : default_hotkeys) {
auto [keyseq, context] = shortcut;
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
qt_config->beginGroup(group);
yuzu: Make hotkeys configurable via the GUI * Adds a new Hotkeys tab in the Controls group. * Double-click a Hotkey to rebind it.
2019-02-16 10:19:29 -05:00
qt_config->beginGroup(name);
UISettings::values.shortcuts.push_back(
{name,
group,
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
{ReadSetting(QStringLiteral("KeySeq"), keyseq).toString(),
ReadSetting(QStringLiteral("Context"), context).toInt()}});
yuzu: Make hotkeys configurable via the GUI * Adds a new Hotkeys tab in the Controls group. * Double-click a Hotkey to rebind it.
2019-02-16 10:19:29 -05:00
qt_config->endGroup();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
qt_config->endGroup();
}
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
qt_config->endGroup();
}
void Config::ReadSystemValues() {
qt_config->beginGroup(QStringLiteral("System"));
Settings::values.use_docked_mode =
ReadSetting(QStringLiteral("use_docked_mode"), false).toBool();
Settings::values.current_user = std::clamp<int>(
ReadSetting(QStringLiteral("current_user"), 0).toInt(), 0, Service::Account::MAX_USERS - 1);
Settings::values.language_index = ReadSetting(QStringLiteral("language_index"), 1).toInt();
const auto rng_seed_enabled = ReadSetting(QStringLiteral("rng_seed_enabled"), false).toBool();
if (rng_seed_enabled) {
Settings::values.rng_seed = ReadSetting(QStringLiteral("rng_seed"), 0).toULongLong();
} else {
Settings::values.rng_seed = std::nullopt;
}
const auto custom_rtc_enabled =
ReadSetting(QStringLiteral("custom_rtc_enabled"), false).toBool();
if (custom_rtc_enabled) {
Settings::values.custom_rtc =
std::chrono::seconds(ReadSetting(QStringLiteral("custom_rtc"), 0).toULongLong());
} else {
Settings::values.custom_rtc = std::nullopt;
}
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::ReadUIValues() {
qt_config->beginGroup(QStringLiteral("UI"));
UISettings::values.theme =
ReadSetting(QStringLiteral("theme"), UISettings::themes[0].second).toString();
UISettings::values.enable_discord_presence =
ReadSetting(QStringLiteral("enable_discord_presence"), true).toBool();
UISettings::values.screenshot_resolution_factor =
static_cast<u16>(ReadSetting(QStringLiteral("screenshot_resolution_factor"), 0).toUInt());
UISettings::values.select_user_on_boot =
ReadSetting(QStringLiteral("select_user_on_boot"), false).toBool();
ReadUIGamelistValues();
ReadUILayoutValues();
ReadPathValues();
ReadShortcutValues();
UISettings::values.single_window_mode =
ReadSetting(QStringLiteral("singleWindowMode"), true).toBool();
UISettings::values.fullscreen = ReadSetting(QStringLiteral("fullscreen"), false).toBool();
UISettings::values.display_titlebar =
ReadSetting(QStringLiteral("displayTitleBars"), true).toBool();
UISettings::values.show_filter_bar =
ReadSetting(QStringLiteral("showFilterBar"), true).toBool();
UISettings::values.show_status_bar =
ReadSetting(QStringLiteral("showStatusBar"), true).toBool();
UISettings::values.confirm_before_closing =
ReadSetting(QStringLiteral("confirmClose"), true).toBool();
UISettings::values.first_start = ReadSetting(QStringLiteral("firstStart"), true).toBool();
UISettings::values.callout_flags = ReadSetting(QStringLiteral("calloutFlags"), 0).toUInt();
UISettings::values.show_console = ReadSetting(QStringLiteral("showConsole"), false).toBool();
UISettings::values.profile_index = ReadSetting(QStringLiteral("profileIndex"), 0).toUInt();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
configure_input: Add ConfigureInputSimple as default input UI config Greatly simplifies the current input UI, while still allowing power users to tweak advanced settings. Adds 'input profiles', which are easy autoconfigurations to make getting started easy and fast. Also has a custom option which brings up the current, full UI.
2018-12-01 11:11:11 -05:00
ApplyDefaultProfileIfInputInvalid();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
qt_config->endGroup();
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-12 20:06:13 -04:00
}
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::ReadUIGamelistValues() {
qt_config->beginGroup("UIGameList");
UISettings::values.show_unknown = ReadSetting(QStringLiteral("show_unknown"), true).toBool();
UISettings::values.show_add_ons = ReadSetting(QStringLiteral("show_add_ons"), true).toBool();
UISettings::values.icon_size = ReadSetting(QStringLiteral("icon_size"), 64).toUInt();
UISettings::values.row_1_text_id = ReadSetting(QStringLiteral("row_1_text_id"), 3).toUInt();
UISettings::values.row_2_text_id = ReadSetting(QStringLiteral("row_2_text_id"), 2).toUInt();
qt_config->endGroup();
}
void Config::ReadUILayoutValues() {
qt_config->beginGroup(QStringLiteral("UILayout"));
UISettings::values.geometry = ReadSetting(QStringLiteral("geometry")).toByteArray();
UISettings::values.state = ReadSetting(QStringLiteral("state")).toByteArray();
UISettings::values.renderwindow_geometry =
ReadSetting(QStringLiteral("geometryRenderWindow")).toByteArray();
UISettings::values.gamelist_header_state =
ReadSetting(QStringLiteral("gameListHeaderState")).toByteArray();
UISettings::values.microprofile_geometry =
ReadSetting(QStringLiteral("microProfileDialogGeometry")).toByteArray();
UISettings::values.microprofile_visible =
ReadSetting(QStringLiteral("microProfileDialogVisible"), false).toBool();
qt_config->endGroup();
}
void Config::ReadWebServiceValues() {
qt_config->beginGroup(QStringLiteral("WebService"));
Settings::values.enable_telemetry =
ReadSetting(QStringLiteral("enable_telemetry"), true).toBool();
Settings::values.web_api_url =
ReadSetting(QStringLiteral("web_api_url"), QStringLiteral("https://api.yuzu-emu.org"))
.toString()
.toStdString();
Settings::values.yuzu_username =
ReadSetting(QStringLiteral("yuzu_username")).toString().toStdString();
Settings::values.yuzu_token =
ReadSetting(QStringLiteral("yuzu_token")).toString().toStdString();
qt_config->endGroup();
}
void Config::ReadValues() {
ReadControlValues();
ReadCoreValues();
ReadRendererValues();
ReadAudioValues();
ReadDataStorageValues();
ReadSystemValues();
ReadMiscellaneousValues();
ReadDebugValues();
ReadWebServiceValues();
ReadDisabledAddOnValues();
ReadUIValues();
}
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
void Config::SavePlayerValues() {
configuration/config: Use an intermediary variable for accessing players Avoids typing the same long accessor just to retrieve player attributes.
2018-12-05 03:41:31 -05:00
for (std::size_t p = 0; p < Settings::values.players.size(); ++p) {
const auto& player = Settings::values.players[p];
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("player_%1_connected").arg(p), player.connected, false);
WriteSetting(QStringLiteral("player_%1_type").arg(p), static_cast<u8>(player.type),
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
static_cast<u8>(Settings::ControllerType::DualJoycon));
configuration/config: Use an intermediary variable for accessing players Avoids typing the same long accessor just to retrieve player attributes.
2018-12-05 03:41:31 -05:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("player_%1_body_color_left").arg(p), player.body_color_left,
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
Settings::JOYCON_BODY_NEON_BLUE);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("player_%1_body_color_right").arg(p), player.body_color_right,
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
Settings::JOYCON_BODY_NEON_RED);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("player_%1_button_color_left").arg(p), player.button_color_left,
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
Settings::JOYCON_BUTTONS_NEON_BLUE);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("player_%1_button_color_right").arg(p),
player.button_color_right, Settings::JOYCON_BUTTONS_NEON_RED);
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const std::string default_param =
InputCommon::GenerateKeyboardParam(default_buttons[i]);
WriteSetting(QStringLiteral("player_%1_").arg(p) +
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
QString::fromStdString(Settings::NativeButton::mapping[i]),
QString::fromStdString(player.buttons[i]),
QString::fromStdString(default_param));
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
}
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
default_analogs[i][3], default_analogs[i][4], 0.5f);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("player_%1_").arg(p) +
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
QString::fromStdString(Settings::NativeAnalog::mapping[i]),
QString::fromStdString(player.analogs[i]),
QString::fromStdString(default_param));
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
}
}
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
}
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
void Config::SaveDebugValues() {
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
WriteSetting("debug_pad_enabled", Settings::values.debug_pad_enabled, false);
InputCommon: add Keyboard
2017-01-21 04:53:03 -05:00
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
WriteSetting(QStringLiteral("debug_pad_") +
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
QString::fromStdString(Settings::NativeButton::mapping[i]),
QString::fromStdString(Settings::values.debug_pad_buttons[i]),
QString::fromStdString(default_param));
InputCommon: add AnalogFromButton
2017-01-21 06:04:00 -05:00
}
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
default_analogs[i][3], default_analogs[i][4], 0.5f);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("debug_pad_") +
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
QString::fromStdString(Settings::NativeAnalog::mapping[i]),
QString::fromStdString(Settings::values.debug_pad_analogs[i]),
QString::fromStdString(default_param));
Move input values into an array
2015-06-19 23:34:45 -04:00
}
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
}
void Config::SaveMouseValues() {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("mouse_enabled"), Settings::values.mouse_enabled, false);
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const std::string default_param =
InputCommon::GenerateKeyboardParam(default_mouse_buttons[i]);
WriteSetting(QStringLiteral("mouse_") +
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
QString::fromStdString(Settings::NativeMouseButton::mapping[i]),
QString::fromStdString(Settings::values.mouse_buttons[i]),
QString::fromStdString(default_param));
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
}
}
yuzu/config: Add (de-)serialization for multiplayer Defaults to full keyboard for keyboard -- It did not seem to be necessary to make the keyboard configurable (besides enabled/disabled).
2018-11-01 21:57:13 -04:00
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
void Config::SaveTouchscreenValues() {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const auto& touchscreen = Settings::values.touchscreen;
WriteSetting(QStringLiteral("touchscreen_enabled"), touchscreen.enabled, true);
WriteSetting(QStringLiteral("touchscreen_device"), QString::fromStdString(touchscreen.device),
QStringLiteral("engine:emu_window"));
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("touchscreen_finger"), touchscreen.finger, 0);
WriteSetting(QStringLiteral("touchscreen_angle"), touchscreen.rotation_angle, 0);
WriteSetting(QStringLiteral("touchscreen_diameter_x"), touchscreen.diameter_x, 15);
WriteSetting(QStringLiteral("touchscreen_diameter_y"), touchscreen.diameter_y, 15);
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
}
void Config::SaveValues() {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
SaveControlValues();
SaveCoreValues();
SaveRendererValues();
SaveAudioValues();
SaveDataStorageValues();
SaveSystemValues();
SaveMiscellaneousValues();
SaveDebuggingValues();
SaveWebServiceValues();
SaveDisabledAddOnValues();
SaveUIValues();
}
void Config::SaveAudioValues() {
qt_config->beginGroup(QStringLiteral("Audio"));
WriteSetting(QStringLiteral("output_engine"), QString::fromStdString(Settings::values.sink_id),
QStringLiteral("auto"));
WriteSetting(QStringLiteral("enable_audio_stretching"),
Settings::values.enable_audio_stretching, true);
WriteSetting(QStringLiteral("output_device"),
QString::fromStdString(Settings::values.audio_device_id), QStringLiteral("auto"));
WriteSetting(QStringLiteral("volume"), Settings::values.volume, 1.0f);
qt_config->endGroup();
}
void Config::SaveControlValues() {
qt_config->beginGroup(QStringLiteral("Controls"));
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
SavePlayerValues();
SaveDebugValues();
SaveMouseValues();
SaveTouchscreenValues();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("motion_device"),
QString::fromStdString(Settings::values.motion_device),
QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"));
WriteSetting(QStringLiteral("keyboard_enabled"), Settings::values.keyboard_enabled, false);
hid: Use player-defined controller type as PREFERRED_CONTROLLER
2018-11-03 12:55:39 -04:00
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-12 20:06:13 -04:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
Use configuration files to enable or disable the new dyncom interpreter.
2014-10-25 15:54:44 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::SaveCoreValues() {
qt_config->beginGroup(QStringLiteral("Core"));
Use config files to store whether SDMC is enabled or not Before, it used to use whether the directory actually existed. As a result, .citra-emu/sdmc was never auto-created (something quite confusing to me until I read through the logs).
2014-10-09 22:43:40 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("use_cpu_jit"), Settings::values.use_cpu_jit, true);
WriteSetting(QStringLiteral("use_multi_core"), Settings::values.use_multi_core, false);
INI hw/sw renderer toggle
2015-05-03 15:34:48 -04:00
Allow the user to set the background clear color during emulation The background color can be seen at the sides of the bottom screen or when the window is wider than normal.
2015-04-03 18:35:51 -04:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
Allow the user to set the background clear color during emulation The background color can be seen at the sides of the bottom screen or when the window is wider than normal.
2015-04-03 18:35:51 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::SaveDataStorageValues() {
qt_config->beginGroup(QStringLiteral("Data Storage"));
audio_core: Add configuration settings.
2018-07-30 23:57:53 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("use_virtual_sd"), Settings::values.use_virtual_sd, true);
WriteSetting(QStringLiteral("nand_directory"),
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)),
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("sdmc_directory"),
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)),
QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)));
settings: Add custom RTC settings Stored as signed seconds since epoch.
2018-12-28 18:35:55 -05:00
config: Add setting for whether the system is docked or not.
2018-03-26 22:24:31 -04:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
config: Add setting for whether the system is docked or not.
2018-03-26 22:24:31 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::SaveDebuggingValues() {
qt_config->beginGroup(QStringLiteral("Debugging"));
Implement gdbstub
2015-09-02 08:56:38 -04:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("use_gdbstub"), Settings::values.use_gdbstub, false);
WriteSetting(QStringLiteral("gdbstub_port"), Settings::values.gdbstub_port, 24689);
WriteSetting(QStringLiteral("program_args"),
QString::fromStdString(Settings::values.program_args), QStringLiteral(""));
WriteSetting(QStringLiteral("dump_exefs"), Settings::values.dump_exefs, false);
WriteSetting(QStringLiteral("dump_nso"), Settings::values.dump_nso, false);
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
Port web_service from Citra
2018-09-16 14:05:51 -04:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
void Config::SaveDisabledAddOnValues() {
qt_config->beginWriteArray(QStringLiteral("DisabledAddOns"));
Port web_service from Citra
2018-09-16 14:05:51 -04:00
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
int i = 0;
for (const auto& elem : Settings::values.disabled_addons) {
qt_config->setArrayIndex(i);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("title_id"), QVariant::fromValue<u64>(elem.first), 0);
qt_config->beginWriteArray(QStringLiteral("disabled"));
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
for (std::size_t j = 0; j < elem.second.size(); ++j) {
yuzu/config: Silence truncation warnings
2018-12-31 19:11:29 -05:00
qt_config->setArrayIndex(static_cast<int>(j));
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("d"), QString::fromStdString(elem.second[j]),
QStringLiteral(""));
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
}
qt_config->endArray();
++i;
}
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
qt_config->endArray();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
config: Store and load disabled add-ons list
2018-11-28 14:00:01 -05:00
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
void Config::SaveMiscellaneousValues() {
qt_config->beginGroup(QStringLiteral("Miscellaneous"));
WriteSetting(QStringLiteral("log_filter"), QString::fromStdString(Settings::values.log_filter),
QStringLiteral("*:Info"));
WriteSetting(QStringLiteral("use_dev_keys"), Settings::values.use_dev_keys, false);
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
Avoid parsing RomFS to directory in NCA
2018-07-28 12:32:16 -04:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
void Config::SavePathValues() {
qt_config->beginGroup(QStringLiteral("Paths"));
WriteSetting(QStringLiteral("romsPath"), UISettings::values.roms_path);
WriteSetting(QStringLiteral("symbolsPath"), UISettings::values.symbols_path);
WriteSetting(QStringLiteral("screenshotPath"), UISettings::values.screenshot_path);
WriteSetting(QStringLiteral("gameListRootDir"), UISettings::values.game_directory_path,
QStringLiteral("."));
WriteSetting(QStringLiteral("gameListDeepScan"), UISettings::values.game_directory_deepscan,
false);
WriteSetting(QStringLiteral("recentFiles"), UISettings::values.recent_files);
Avoid parsing RomFS to directory in NCA
2018-07-28 12:32:16 -04:00
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
void Config::SaveRendererValues() {
qt_config->beginGroup(QStringLiteral("Renderer"));
WriteSetting(QStringLiteral("resolution_factor"),
static_cast<double>(Settings::values.resolution_factor), 1.0);
WriteSetting(QStringLiteral("use_frame_limit"), Settings::values.use_frame_limit, true);
WriteSetting(QStringLiteral("frame_limit"), Settings::values.frame_limit, 100);
WriteSetting(QStringLiteral("use_compatibility_profile"),
Settings::values.use_compatibility_profile, true);
WriteSetting(QStringLiteral("use_disk_shader_cache"), Settings::values.use_disk_shader_cache,
true);
WriteSetting(QStringLiteral("use_accurate_gpu_emulation"),
Settings::values.use_accurate_gpu_emulation, false);
WriteSetting(QStringLiteral("use_asynchronous_gpu_emulation"),
Settings::values.use_asynchronous_gpu_emulation, false);
WriteSetting(QStringLiteral("force_30fps_mode"), Settings::values.force_30fps_mode, false);
// Cast to double because Qt's written float values are not human-readable
WriteSetting(QStringLiteral("bg_red"), static_cast<double>(Settings::values.bg_red), 0.0);
WriteSetting(QStringLiteral("bg_green"), static_cast<double>(Settings::values.bg_green), 0.0);
WriteSetting(QStringLiteral("bg_blue"), static_cast<double>(Settings::values.bg_blue), 0.0);
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
void Config::SaveShortcutValues() {
qt_config->beginGroup(QStringLiteral("Shortcuts"));
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
yuzu: Make hotkeys configurable via the GUI * Adds a new Hotkeys tab in the Controls group. * Double-click a Hotkey to rebind it.
2019-02-16 10:19:29 -05:00
// Lengths of UISettings::values.shortcuts & default_hotkeys are same.
// However, their ordering must also be the same.
for (std::size_t i = 0; i < default_hotkeys.size(); i++) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
const auto [name, group, shortcut] = UISettings::values.shortcuts[i];
const auto& default_hotkey = default_hotkeys[i].shortcut;
yuzu: Make hotkeys configurable via the GUI * Adds a new Hotkeys tab in the Controls group. * Double-click a Hotkey to rebind it.
2019-02-16 10:19:29 -05:00
qt_config->beginGroup(group);
qt_config->beginGroup(name);
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
WriteSetting(QStringLiteral("KeySeq"), shortcut.first, default_hotkey.first);
WriteSetting(QStringLiteral("Context"), shortcut.second, default_hotkey.second);
yuzu: Make hotkeys configurable via the GUI * Adds a new Hotkeys tab in the Controls group. * Double-click a Hotkey to rebind it.
2019-02-16 10:19:29 -05:00
qt_config->endGroup();
qt_config->endGroup();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
}
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
qt_config->endGroup();
}
void Config::SaveSystemValues() {
qt_config->beginGroup(QStringLiteral("System"));
WriteSetting(QStringLiteral("use_docked_mode"), Settings::values.use_docked_mode, false);
WriteSetting(QStringLiteral("current_user"), Settings::values.current_user, 0);
WriteSetting(QStringLiteral("language_index"), Settings::values.language_index, 1);
WriteSetting(QStringLiteral("rng_seed_enabled"), Settings::values.rng_seed.has_value(), false);
WriteSetting(QStringLiteral("rng_seed"), Settings::values.rng_seed.value_or(0), 0);
WriteSetting(QStringLiteral("custom_rtc_enabled"), Settings::values.custom_rtc.has_value(),
false);
WriteSetting(QStringLiteral("custom_rtc"),
QVariant::fromValue<long long>(
Settings::values.custom_rtc.value_or(std::chrono::seconds{}).count()),
0);
qt_config->endGroup();
}
void Config::SaveUIValues() {
qt_config->beginGroup(QStringLiteral("UI"));
WriteSetting(QStringLiteral("theme"), UISettings::values.theme, UISettings::themes[0].second);
WriteSetting(QStringLiteral("enable_discord_presence"),
UISettings::values.enable_discord_presence, true);
WriteSetting(QStringLiteral("screenshot_resolution_factor"),
UISettings::values.screenshot_resolution_factor, 0);
WriteSetting(QStringLiteral("select_user_on_boot"), UISettings::values.select_user_on_boot,
false);
SaveUIGamelistValues();
SaveUILayoutValues();
SavePathValues();
SaveShortcutValues();
WriteSetting(QStringLiteral("singleWindowMode"), UISettings::values.single_window_mode, true);
WriteSetting(QStringLiteral("fullscreen"), UISettings::values.fullscreen, false);
WriteSetting(QStringLiteral("displayTitleBars"), UISettings::values.display_titlebar, true);
WriteSetting(QStringLiteral("showFilterBar"), UISettings::values.show_filter_bar, true);
WriteSetting(QStringLiteral("showStatusBar"), UISettings::values.show_status_bar, true);
WriteSetting(QStringLiteral("confirmClose"), UISettings::values.confirm_before_closing, true);
WriteSetting(QStringLiteral("firstStart"), UISettings::values.first_start, true);
WriteSetting(QStringLiteral("calloutFlags"), UISettings::values.callout_flags, 0);
WriteSetting(QStringLiteral("showConsole"), UISettings::values.show_console, false);
WriteSetting(QStringLiteral("profileIndex"), UISettings::values.profile_index, 0);
qt_config->endGroup();
}
void Config::SaveUIGamelistValues() {
qt_config->beginGroup(QStringLiteral("UIGameList"));
WriteSetting(QStringLiteral("show_unknown"), UISettings::values.show_unknown, true);
WriteSetting(QStringLiteral("show_add_ons"), UISettings::values.show_add_ons, true);
WriteSetting(QStringLiteral("icon_size"), UISettings::values.icon_size, 64);
WriteSetting(QStringLiteral("row_1_text_id"), UISettings::values.row_1_text_id, 3);
WriteSetting(QStringLiteral("row_2_text_id"), UISettings::values.row_2_text_id, 2);
qt_config->endGroup();
}
void Config::SaveUILayoutValues() {
qt_config->beginGroup(QStringLiteral("UILayout"));
WriteSetting(QStringLiteral("geometry"), UISettings::values.geometry);
WriteSetting(QStringLiteral("state"), UISettings::values.state);
WriteSetting(QStringLiteral("geometryRenderWindow"), UISettings::values.renderwindow_geometry);
WriteSetting(QStringLiteral("gameListHeaderState"), UISettings::values.gamelist_header_state);
WriteSetting(QStringLiteral("microProfileDialogGeometry"),
UISettings::values.microprofile_geometry);
WriteSetting(QStringLiteral("microProfileDialogVisible"),
UISettings::values.microprofile_visible, false);
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
}
void Config::SaveWebServiceValues() {
qt_config->beginGroup(QStringLiteral("WebService"));
WriteSetting(QStringLiteral("enable_telemetry"), Settings::values.enable_telemetry, true);
WriteSetting(QStringLiteral("web_api_url"),
QString::fromStdString(Settings::values.web_api_url),
QStringLiteral("https://api.yuzu-emu.org"));
WriteSetting(QStringLiteral("yuzu_username"),
QString::fromStdString(Settings::values.yuzu_username));
WriteSetting(QStringLiteral("yuzu_token"), QString::fromStdString(Settings::values.yuzu_token));
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 15:23:55 -05:00
qt_config->endGroup();
Add support for disabling log from settings
2014-10-27 17:18:28 -04:00
}
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
QVariant Config::ReadSetting(const QString& name) const {
return qt_config->value(name);
}
QVariant Config::ReadSetting(const QString& name, const QVariant& default_value) const {
QVariant result;
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) {
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
result = default_value;
} else {
result = qt_config->value(name, default_value);
}
return result;
}
void Config::WriteSetting(const QString& name, const QVariant& value) {
qt_config->setValue(name, value);
}
void Config::WriteSetting(const QString& name, const QVariant& value,
const QVariant& default_value) {
configuration/config: Move config loading and saving to functions based off groups Over time our config values have grown quite numerous in size. Unfortunately it also makes the single functions we have for loading and saving values more error prone. For example, we were loading the core settings twice when they only should have been loaded once. In another section, a variable was shadowing another variable used to load settings from a completely different section. Finally, in one other case, there was an extraneous endGroup() call used that didn't need to be done. This was essentially dead code and also a bug waiting to happen. This separates the section loading code into its own separate functions. This keeps variables only visible to the code that actually needs it, and makes it much easier to visually see the end of each individual configuration group. It also makes it much easier to visually catch bugs during code review. While we're at it, this also uses QStringLiteral instead of raw string literals, which both avoids constructing a lot of QString instances, but also makes it much easier to disable implicit ASCII to QString and vice-versa in the future via setting QT_NO_CAST_FROM_ASCII and QT_NO_CAST_TO_ASCII as compilation flags.
2019-05-08 23:11:15 -04:00
qt_config->setValue(name + QStringLiteral("/default"), value == default_value);
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
qt_config->setValue(name, value);
}
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-12 20:06:13 -04:00
void Config::Reload() {
Merge Config::ReadXYZs
2014-11-15 14:56:18 -05:00
ReadValues();
citra_qt: Settings (configuration) rework
2018-07-09 08:07:59 -04:00
// To apply default value changes
SaveValues();
CitraQt: Apply config at startup
2016-04-11 08:38:42 -04:00
Settings::Apply();
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-12 20:06:13 -04:00
}
void Config::Save() {
Merge Config::ReadXYZs
2014-11-15 14:56:18 -05:00
SaveValues();
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-12 20:06:13 -04:00
}
Reference in a new issue Copy permalink