OpenPunk/citra
1
0
Fork 0
mirror of https://github.com/citra-emu/citra.git synced 2024-11-28 05:30:05 +00:00
Code Issues Projects Releases Wiki Activity
d37b0476ad
citra/src/citra_qt/configuration/config.cpp

1123 lines
51 KiB
C++
Raw Normal View History

Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-13 00:06:13 +00:00
// Copyright 2014 Citra Emulator Project
License change
2014-12-17 05:38:14 +00:00
// Licensed under GPLv2 or any later version
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-13 00:06:13 +00:00
// Refer to the license.txt file included.
if to clamp
2018-12-29 13:39:30 +00:00
#include <algorithm>
citra-qt: Add base support for hotkey reconfiguration + UI (whole of PR citra-emu/citra#3786) * Adds a new Hotkeys tab in the Controls group. * Right click to reconfigure. * See the original PR for more details & screenshots.
2018-05-22 19:30:36 +00:00
#include <array>
citra-qt: service: add convenient LLE service module configuration (#3967) * citra-qt: service: add convenient LLE service module configuration * fix SDL settings * unexpose AttemptLLE * static * fix array includes * use default with writesetting
2018-08-09 19:10:11 +00:00
#include <unordered_map>
citra-qt: Add base support for hotkey reconfiguration + UI (whole of PR citra-emu/citra#3786) * Adds a new Hotkeys tab in the Controls group. * Right click to reconfigure. * See the original PR for more details & screenshots.
2018-05-22 19:30:36 +00:00
#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 15:21:23 +00:00
#include <QSettings>
citra-qt: Move config dialog code to its own directory
2016-12-22 04:49:36 +00:00
#include "citra_qt/configuration/config.h"
Remove qt5_wrap_ui macro usage
2019-08-15 04:38:54 +00:00
#include "citra_qt/uisettings.h"
citra_qt: Reorganize headers
2015-09-11 04:23:00 +00:00
#include "common/file_util.h"
service/mic: actually use the specified device
2019-11-01 18:33:06 +00:00
#include "core/frontend/mic.h"
citra-qt: service: add convenient LLE service module configuration (#3967) * citra-qt: service: add convenient LLE service module configuration * fix SDL settings * unexpose AttemptLLE * static * fix array includes * use default with writesetting
2018-08-09 19:10:11 +00:00
#include "core/hle/service/service.h"
InputCommon: add Keyboard
2017-01-21 09:53:03 +00:00
#include "input_common/main.h"
Input: UDP Client to provide motion and touch controls An implementation of the cemuhook motion/touch protocol, this adds the ability for users to connect several different devices to citra to send direct motion and touch data to citra.
2018-01-18 15:43:17 +00:00
#include "input_common/udp/client.h"
Citra-qt: Add multiplayer ui
2018-01-19 13:42:21 +00:00
#include "network/network.h"
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-13 00:06:13 +00: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 19:52:42 +00: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-13 00:06:13 +00: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-24 01:49:50 +00: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-13 00:06:13 +00:00
Reload();
}
yuzu/configuration/config: Use a std::unique_ptr for qt_config instead of a raw pointer Same behavior, less code.
2018-10-24 01:49:50 +00:00
Config::~Config() {
Save();
}
InputCommon: add Keyboard
2017-01-21 09:53:03 +00:00
const std::array<int, Settings::NativeButton::NumButtons> Config::default_buttons = {
Added GPIO14 button and UI config buttons
2018-12-28 23:13:37 +00:00
Qt::Key_A, Qt::Key_S, Qt::Key_Z, Qt::Key_X, Qt::Key_T, Qt::Key_G,
Qt::Key_F, Qt::Key_H, Qt::Key_Q, Qt::Key_W, Qt::Key_M, Qt::Key_N,
Qt::Key_O, Qt::Key_P, Qt::Key_1, Qt::Key_2, Qt::Key_B,
Move input values into an array
2015-06-20 03:34:45 +00:00
};
InputCommon: add AnalogFromButton
2017-01-21 11:04:00 +00:00
const std::array<std::array<int, 5>, Settings::NativeAnalog::NumAnalogs> Config::default_analogs{{
{
Update the entire application to use the new clang format style
2018-03-09 17:54:43 +00:00
Qt::Key_Up,
Qt::Key_Down,
Qt::Key_Left,
Qt::Key_Right,
Qt::Key_D,
InputCommon: add AnalogFromButton
2017-01-21 11:04:00 +00:00
},
{
Update the entire application to use the new clang format style
2018-03-09 17:54:43 +00:00
Qt::Key_I,
Qt::Key_K,
Qt::Key_J,
Qt::Key_L,
Qt::Key_D,
InputCommon: add AnalogFromButton
2017-01-21 11:04:00 +00:00
},
}};
citra-qt: Add /default parsing for hotkeys. Also minor code cleanups.
2018-12-30 10:09:16 +00:00
// This shouldn't have anything except static initializers (no functions). So
yuzu/configuration/config: Specify string conversions explicitly Allows the configuration code to build successfully with implicit string conversions disabled. Also makes default_hotkeys internally linked: Given the array is a private static array, we can just make it internally linked to hide it from external code. This also allows us to remove an inclusion within the header.
2019-07-25 21:34:05 +00:00
// QKeySequence(...).toString() is NOT ALLOWED HERE.
citra-qt: Add /default parsing for hotkeys. Also minor code cleanups.
2018-12-30 10:09:16 +00:00
// 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.
yuzu/configuration/config: Specify string conversions explicitly Allows the configuration code to build successfully with implicit string conversions disabled. Also makes default_hotkeys internally linked: Given the array is a private static array, we can just make it internally linked to hide it from external code. This also allows us to remove an inclusion within the header.
2019-07-25 21:34:05 +00:00
// clang-format off
Set hotkey for screen rotation
2020-01-08 21:33:37 +00:00
const std::array<UISettings::Shortcut, 21> default_hotkeys{
yuzu/configuration/config: Specify string conversions explicitly Allows the configuration code to build successfully with implicit string conversions disabled. Also makes default_hotkeys internally linked: Given the array is a private static array, we can just make it internally linked to hide it from external code. This also allows us to remove an inclusion within the header.
2019-07-25 21:34:05 +00:00
{{QStringLiteral("Advance Frame"), QStringLiteral("Main Window"), {QStringLiteral("\\"), Qt::ApplicationShortcut}},
{QStringLiteral("Capture Screenshot"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+P"), Qt::ApplicationShortcut}},
{QStringLiteral("Continue/Pause Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F4"), Qt::WindowShortcut}},
{QStringLiteral("Decrease Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("-"), Qt::ApplicationShortcut}},
{QStringLiteral("Exit Citra"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Q"), Qt::WindowShortcut}},
{QStringLiteral("Exit Fullscreen"), QStringLiteral("Main Window"), {QStringLiteral("Esc"), Qt::WindowShortcut}},
{QStringLiteral("Fullscreen"), QStringLiteral("Main Window"), {QStringLiteral("F11"), Qt::WindowShortcut}},
{QStringLiteral("Increase Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("+"), Qt::ApplicationShortcut}},
{QStringLiteral("Load Amiibo"), QStringLiteral("Main Window"), {QStringLiteral("F2"), Qt::ApplicationShortcut}},
{QStringLiteral("Load File"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+O"), Qt::WindowShortcut}},
{QStringLiteral("Remove Amiibo"), QStringLiteral("Main Window"), {QStringLiteral("F3"), Qt::ApplicationShortcut}},
{QStringLiteral("Restart Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F6"), Qt::WindowShortcut}},
Set hotkey for screen rotation
2020-01-08 21:33:37 +00:00
{QStringLiteral("Rotate Screens Upright"), QStringLiteral("Main Window"), {QStringLiteral("F8"), Qt::WindowShortcut}},
yuzu/configuration/config: Specify string conversions explicitly Allows the configuration code to build successfully with implicit string conversions disabled. Also makes default_hotkeys internally linked: Given the array is a private static array, we can just make it internally linked to hide it from external code. This also allows us to remove an inclusion within the header.
2019-07-25 21:34:05 +00:00
{QStringLiteral("Stop Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F5"), Qt::WindowShortcut}},
{QStringLiteral("Swap Screens"), QStringLiteral("Main Window"), {QStringLiteral("F9"), Qt::WindowShortcut}},
{QStringLiteral("Toggle Filter Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"), Qt::WindowShortcut}},
{QStringLiteral("Toggle Frame Advancing"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+A"), Qt::ApplicationShortcut}},
{QStringLiteral("Toggle Screen Layout"), QStringLiteral("Main Window"), {QStringLiteral("F10"), Qt::WindowShortcut}},
{QStringLiteral("Toggle Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"), Qt::ApplicationShortcut}},
texture dump hotkey (ctrl+d) address more comments
2019-08-17 23:43:40 +00:00
{QStringLiteral("Toggle Status Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"), Qt::WindowShortcut}},
{QStringLiteral("Toggle Texture Dumping"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+D"), Qt::ApplicationShortcut}}}};
yuzu/configuration/config: Specify string conversions explicitly Allows the configuration code to build successfully with implicit string conversions disabled. Also makes default_hotkeys internally linked: Given the array is a private static array, we can just make it internally linked to hide it from external code. This also allows us to remove an inclusion within the header.
2019-07-25 21:34:05 +00:00
// clang-format on
citra-qt: Add /default parsing for hotkeys. Also minor code cleanups.
2018-12-30 10:09:16 +00:00
Merge Config::ReadXYZs
2014-11-15 19:56:18 +00:00
void Config::ReadValues() {
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
ReadControlValues();
ReadCoreValues();
ReadRendererValues();
ReadLayoutValues();
ReadAudioValues();
ReadCameraValues();
ReadDataStorageValues();
ReadSystemValues();
ReadMiscellaneousValues();
ReadDebuggingValues();
ReadWebServiceValues();
citra, citra_qt: Add video dumping config read/write The default values are VP9/libvorbis just like before. The default configuration is provided for VP9
2020-01-29 06:57:16 +00:00
ReadVideoDumpingValues();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
ReadUIValues();
citra_qt/configuration: add missing Read/SaveUtilityValues
2019-11-11 00:26:03 +00:00
ReadUtilityValues();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::ReadAudioValues() {
qt_config->beginGroup(QStringLiteral("Audio"));
Settings::values.enable_dsp_lle = ReadSetting(QStringLiteral("enable_dsp_lle"), false).toBool();
Settings::values.enable_dsp_lle_multithread =
ReadSetting(QStringLiteral("enable_dsp_lle_multithread"), false).toBool();
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();
Settings::values.mic_input_type = static_cast<Settings::MicInputType>(
ReadSetting(QStringLiteral("mic_input_type"), 0).toInt());
Settings::values.mic_input_device =
Port yuzu commit: "yuzu/CMakeLists: Disable implicit QString co… (#5074) * yuzu/CMakeLists: Disable implicit QString conversions Now that all of our code is compilable with implicit QString conversions, we can enforce it at compile-time by disabling them. Co-Authored-By: Mat M. <lioncash@users.noreply.github.com> * citra_qt: Remove lots of implicit QString conversions Co-authored-by: Mat M. <mathew1800@gmail.com>
2020-02-11 12:12:09 +00:00
ReadSetting(QStringLiteral("mic_input_device"),
QString::fromUtf8(Frontend::Mic::default_device_name))
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
.toString()
.toStdString();
qt_config->endGroup();
}
void Config::ReadCameraValues() {
using namespace Service::CAM;
qt_config->beginGroup(QStringLiteral("Camera"));
Settings::values.camera_name[OuterRightCamera] =
ReadSetting(QStringLiteral("camera_outer_right_name"), QStringLiteral("blank"))
.toString()
.toStdString();
Settings::values.camera_config[OuterRightCamera] =
ReadSetting(QStringLiteral("camera_outer_right_config"), QString{})
.toString()
.toStdString();
Settings::values.camera_flip[OuterRightCamera] =
ReadSetting(QStringLiteral("camera_outer_right_flip"), 0).toInt();
Settings::values.camera_name[InnerCamera] =
ReadSetting(QStringLiteral("camera_inner_name"), QStringLiteral("blank"))
.toString()
.toStdString();
Settings::values.camera_config[InnerCamera] =
ReadSetting(QStringLiteral("camera_inner_config"), QString{}).toString().toStdString();
Settings::values.camera_flip[InnerCamera] =
ReadSetting(QStringLiteral("camera_inner_flip"), 0).toInt();
Settings::values.camera_name[OuterLeftCamera] =
ReadSetting(QStringLiteral("camera_outer_left_name"), QStringLiteral("blank"))
.toString()
.toStdString();
Settings::values.camera_config[OuterLeftCamera] =
ReadSetting(QStringLiteral("camera_outer_left_config"), QString{}).toString().toStdString();
Settings::values.camera_flip[OuterLeftCamera] =
ReadSetting(QStringLiteral("camera_outer_left_flip"), 0).toInt();
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
qt_config->endGroup();
}
void Config::ReadControlValues() {
qt_config->beginGroup(QStringLiteral("Controls"));
Settings::values.current_input_profile_index =
ReadSetting(QStringLiteral("profile"), 0).toInt();
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
const auto append_profile = [this] {
Settings::InputProfile profile;
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
profile.name =
ReadSetting(QStringLiteral("name"), QStringLiteral("default")).toString().toStdString();
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
profile.buttons[i] = ReadSetting(QString::fromUtf8(Settings::NativeButton::mapping[i]),
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
QString::fromStdString(default_param))
.toString()
.toStdString();
Update src/citra_qt/configuration/config.cpp Co-Authored-By: valentinvanelslande <valentinvanelslandeacnl@gmail.com>
2018-12-29 13:14:37 +00:00
if (profile.buttons[i].empty())
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
profile.buttons[i] = default_param;
}
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
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 (#4855) 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-11-07 16:33:41 +00:00
profile.analogs[i] = ReadSetting(QString::fromUtf8(Settings::NativeAnalog::mapping[i]),
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
QString::fromStdString(default_param))
.toString()
.toStdString();
if (profile.analogs[i].empty())
profile.analogs[i] = default_param;
}
profile.motion_device =
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
ReadSetting(QStringLiteral("motion_device"),
QStringLiteral(
"engine:motion_emu,update_period:100,sensitivity:0.01,tilt_clamp:90.0"))
InputCommon: add Keyboard
2017-01-21 09:53:03 +00:00
.toString()
.toStdString();
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
profile.touch_device =
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
ReadSetting(QStringLiteral("touch_device"), QStringLiteral("engine:emu_window"))
.toString()
.toStdString();
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
profile.udp_input_address =
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
ReadSetting(QStringLiteral("udp_input_address"),
QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR))
InputCommon: add AnalogFromButton
2017-01-21 11:04:00 +00:00
.toString()
.toStdString();
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
profile.udp_input_port = static_cast<u16>(
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
ReadSetting(QStringLiteral("udp_input_port"), InputCommon::CemuhookUDP::DEFAULT_PORT)
.toInt());
profile.udp_pad_index =
static_cast<u8>(ReadSetting(QStringLiteral("udp_pad_index"), 0).toUInt());
another fix
2018-12-29 02:15:18 +00:00
Settings::values.input_profiles.emplace_back(std::move(profile));
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
};
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
int num_input_profiles = qt_config->beginReadArray(QStringLiteral("profiles"));
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
fixes
2018-12-29 02:13:57 +00:00
for (int i = 0; i < num_input_profiles; ++i) {
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
qt_config->setArrayIndex(i);
append_profile();
InputCommon: add AnalogFromButton
2017-01-21 11:04:00 +00:00
}
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
qt_config->endArray();
Input: UDP Client to provide motion and touch controls An implementation of the cemuhook motion/touch protocol, this adds the ability for users to connect several different devices to citra to send direct motion and touch data to citra.
2018-01-18 15:43:17 +00:00
fixes
2018-12-29 02:13:57 +00:00
// create a input profile if no input profiles exist, with the default or old settings
if (num_input_profiles == 0) {
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
append_profile();
fix regression
2018-12-29 21:23:33 +00:00
num_input_profiles = 1;
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
}
if to clamp
2018-12-29 13:39:30 +00:00
// ensure that the current input profile index is valid.
Settings::values.current_input_profile_index =
std::clamp(Settings::values.current_input_profile_index, 0, num_input_profiles - 1);
clang-format; address one comment
2018-12-29 04:31:55 +00:00
Settings::LoadProfile(Settings::values.current_input_profile_index);
Input: UDP Client to provide motion and touch controls An implementation of the cemuhook motion/touch protocol, this adds the ability for users to connect several different devices to citra to send direct motion and touch data to citra.
2018-01-18 15:43:17 +00:00
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-13 00:06:13 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
Merge Config::ReadXYZs
2014-11-15 19:56:18 +00:00
add texture dumping as a config entry
2019-04-03 00:57:13 +00:00
void Config::ReadUtilityValues() {
yuzu/main: Specify string conversions explicitly
2019-11-20 21:34:39 +00:00
qt_config->beginGroup(QStringLiteral("Utility"));
fix crashes, add custom texture cache, load textures from load directory
2019-08-06 12:43:24 +00:00
yuzu/main: Specify string conversions explicitly
2019-11-20 21:34:39 +00:00
Settings::values.dump_textures = ReadSetting(QStringLiteral("dump_textures"), false).toBool();
Settings::values.custom_textures =
ReadSetting(QStringLiteral("custom_textures"), false).toBool();
Settings::values.preload_textures =
ReadSetting(QStringLiteral("preload_textures"), false).toBool();
Settings::values.use_disk_shader_cache =
ReadSetting(QStringLiteral("use_disk_shader_cache"), true).toBool();
fix crashes, add custom texture cache, load textures from load directory
2019-08-06 12:43:24 +00:00
add texture dumping as a config entry
2019-04-03 00:57:13 +00:00
qt_config->endGroup();
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
void Config::ReadCoreValues() {
qt_config->beginGroup(QStringLiteral("Core"));
Merge Config::ReadXYZs
2014-11-15 19:56:18 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
Settings::values.use_cpu_jit = ReadSetting(QStringLiteral("use_cpu_jit"), true).toBool();
Add CPU Clock Frequency slider This slider affects the number of cycles that the guest cpu emulation reports that have passed since the last time slice. This option scales the result returned by a percentage that the user selects. In some games underclocking the CPU can give a major speedup. Exposing this as an option will give users something to toy with for performance, while also potentially enhancing games that experience lag on the real console
2019-12-16 05:04:33 +00:00
Settings::values.cpu_clock_percentage =
ReadSetting(QStringLiteral("cpu_clock_percentage"), 100).toInt();
INI hw/sw renderer toggle
2015-05-03 19:34:48 +00:00
Audio: Add sink selection to configuration files
2016-04-27 12:53:23 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
Audio: Add sink selection to configuration files
2016-04-27 12:53:23 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
void Config::ReadDataStorageValues() {
qt_config->beginGroup(QStringLiteral("Data Storage"));
CAM: implement basic camera functions with a blank camera
2016-12-21 18:05:56 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
Settings::values.use_virtual_sd = ReadSetting(QStringLiteral("use_virtual_sd"), true).toBool();
Merge Config::ReadXYZs
2014-11-15 19:56:18 +00:00
Services: Stub some functions
2015-01-31 23:11:51 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
Services: Stub some functions
2015-01-31 23:11:51 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
void Config::ReadDebuggingValues() {
qt_config->beginGroup(QStringLiteral("Debugging"));
Implement gdbstub
2015-09-02 12:56:38 +00:00
Address review comments
2019-08-15 03:03:11 +00:00
// Intentionally not using the QT default setting as this is intended to be changed in the ini
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
Settings::values.record_frame_times =
qt_config->value(QStringLiteral("record_frame_times"), false).toBool();
Settings::values.use_gdbstub = ReadSetting(QStringLiteral("use_gdbstub"), false).toBool();
Settings::values.gdbstub_port = ReadSetting(QStringLiteral("gdbstub_port"), 24689).toInt();
citra-qt: service: add convenient LLE service module configuration (#3967) * citra-qt: service: add convenient LLE service module configuration * fix SDL settings * unexpose AttemptLLE * static * fix array includes * use default with writesetting
2018-08-09 19:10:11 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
qt_config->beginGroup(QStringLiteral("LLE"));
citra-qt: service: add convenient LLE service module configuration (#3967) * citra-qt: service: add convenient LLE service module configuration * fix SDL settings * unexpose AttemptLLE * static * fix array includes * use default with writesetting
2018-08-09 19:10:11 +00:00
for (const auto& service_module : Service::service_module_map) {
bool use_lle = ReadSetting(QString::fromStdString(service_module.name), false).toBool();
Settings::values.lle_modules.emplace(service_module.name, use_lle);
}
qt_config->endGroup();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
settings: Add telemetry endpoint URL.
2017-06-28 02:46:52 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
settings: Add telemetry endpoint URL.
2017-06-28 02:46:52 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
void Config::ReadLayoutValues() {
qt_config->beginGroup(QStringLiteral("Layout"));
Settings::values.render_3d = static_cast<Settings::StereoRenderOption>(
ReadSetting(QStringLiteral("render_3d"), 0).toInt());
Settings::values.factor_3d = ReadSetting(QStringLiteral("factor_3d"), 0).toInt();
Settings::values.pp_shader_name =
ReadSetting(QStringLiteral("pp_shader_name"),
(Settings::values.render_3d == Settings::StereoRenderOption::Anaglyph)
? QStringLiteral("dubois (builtin)")
: QStringLiteral("none (builtin)"))
.toString()
.toStdString();
Settings::values.filter_mode = ReadSetting(QStringLiteral("filter_mode"), true).toBool();
Settings::values.layout_option =
static_cast<Settings::LayoutOption>(ReadSetting(QStringLiteral("layout_option")).toInt());
Settings::values.swap_screen = ReadSetting(QStringLiteral("swap_screen"), false).toBool();
Implementation of screen rotation without use of additional layouts. This is based on what was done using additional layouts, but modified to have a variable to control rotation and making it so Single Screen Layout behaves like Upright Single would, and Default Layout behaves like Upright Double would, when the new variable is used. Large Layout and Side Layout currently ignore the new variable. New variable still currently doesn't have a hotkey.
2019-10-25 23:21:10 +00:00
Settings::values.upright_screen = ReadSetting(QStringLiteral("upright_screen"), false).toBool();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
Settings::values.custom_layout = ReadSetting(QStringLiteral("custom_layout"), false).toBool();
Settings::values.custom_top_left = ReadSetting(QStringLiteral("custom_top_left"), 0).toInt();
Settings::values.custom_top_top = ReadSetting(QStringLiteral("custom_top_top"), 0).toInt();
Settings::values.custom_top_right =
ReadSetting(QStringLiteral("custom_top_right"), 400).toInt();
Settings::values.custom_top_bottom =
ReadSetting(QStringLiteral("custom_top_bottom"), 240).toInt();
Settings::values.custom_bottom_left =
ReadSetting(QStringLiteral("custom_bottom_left"), 40).toInt();
Settings::values.custom_bottom_top =
ReadSetting(QStringLiteral("custom_bottom_top"), 240).toInt();
Settings::values.custom_bottom_right =
ReadSetting(QStringLiteral("custom_bottom_right"), 360).toInt();
Settings::values.custom_bottom_bottom =
ReadSetting(QStringLiteral("custom_bottom_bottom"), 480).toInt();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
Qt updater integration, based on QtAutoUpdater
2017-08-19 05:05:49 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::ReadMiscellaneousValues() {
qt_config->beginGroup(QStringLiteral("Miscellaneous"));
Settings::values.log_filter =
ReadSetting(QStringLiteral("log_filter"), QStringLiteral("*:Info"))
.toString()
.toStdString();
Qt updater integration, based on QtAutoUpdater
2017-08-19 05:05:49 +00:00
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
void Config::ReadMultiplayerValues() {
qt_config->beginGroup(QStringLiteral("Multiplayer"));
UISettings::values.nickname = ReadSetting(QStringLiteral("nickname"), QString{}).toString();
UISettings::values.ip = ReadSetting(QStringLiteral("ip"), QString{}).toString();
UISettings::values.port =
ReadSetting(QStringLiteral("port"), Network::DefaultRoomPort).toString();
UISettings::values.room_nickname =
ReadSetting(QStringLiteral("room_nickname"), QString{}).toString();
UISettings::values.room_name = ReadSetting(QStringLiteral("room_name"), QString{}).toString();
UISettings::values.room_port =
ReadSetting(QStringLiteral("room_port"), QStringLiteral("24872")).toString();
bool ok;
UISettings::values.host_type = ReadSetting(QStringLiteral("host_type"), 0).toUInt(&ok);
if (!ok) {
UISettings::values.host_type = 0;
citra_qt: Add Game List configuration This adds a Game List configuration group box which is similar to yuzu's, with features including icon size setting, row 1/2 text, and ability to hide invalid titles (those without a valid SMDH). I also added a UI tab and moved the language and theme settings there.
2018-09-23 03:22:44 +00:00
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
UISettings::values.max_player = ReadSetting(QStringLiteral("max_player"), 8).toUInt();
UISettings::values.game_id = ReadSetting(QStringLiteral("game_id"), 0).toULongLong();
UISettings::values.room_description =
ReadSetting(QStringLiteral("room_description"), QString{}).toString();
// Read ban list back
int size = qt_config->beginReadArray(QStringLiteral("username_ban_list"));
UISettings::values.ban_list.first.resize(size);
for (int i = 0; i < size; ++i) {
qt_config->setArrayIndex(i);
UISettings::values.ban_list.first[i] =
ReadSetting(QStringLiteral("username")).toString().toStdString();
citra_qt: Add Game List configuration This adds a Game List configuration group box which is similar to yuzu's, with features including icon size setting, row 1/2 text, and ability to hide invalid titles (those without a valid SMDH). I also added a UI tab and moved the language and theme settings there.
2018-09-23 03:22:44 +00:00
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
qt_config->endArray();
size = qt_config->beginReadArray(QStringLiteral("ip_ban_list"));
UISettings::values.ban_list.second.resize(size);
for (int i = 0; i < size; ++i) {
qt_config->setArrayIndex(i);
UISettings::values.ban_list.second[i] =
ReadSetting(QStringLiteral("ip")).toString().toStdString();
citra_qt: Add Game List configuration This adds a Game List configuration group box which is similar to yuzu's, with features including icon size setting, row 1/2 text, and ability to hide invalid titles (those without a valid SMDH). I also added a UI tab and moved the language and theme settings there.
2018-09-23 03:22:44 +00:00
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
qt_config->endArray();
citra_qt: Add Game List configuration This adds a Game List configuration group box which is similar to yuzu's, with features including icon size setting, row 1/2 text, and ability to hide invalid titles (those without a valid SMDH). I also added a UI tab and moved the language and theme settings there.
2018-09-23 03:22:44 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
citra_qt: Add Game List configuration This adds a Game List configuration group box which is similar to yuzu's, with features including icon size setting, row 1/2 text, and ability to hide invalid titles (those without a valid SMDH). I also added a UI tab and moved the language and theme settings there.
2018-09-23 03:22:44 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00: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.movie_record_path =
ReadSetting(QStringLiteral("movieRecordPath")).toString();
UISettings::values.movie_playback_path =
ReadSetting(QStringLiteral("moviePlaybackPath")).toString();
UISettings::values.screenshot_path = ReadSetting(QStringLiteral("screenshotPath")).toString();
UISettings::values.video_dumping_path =
ReadSetting(QStringLiteral("videoDumpingPath")).toString();
UISettings::values.game_dir_deprecated =
ReadSetting(QStringLiteral("gameListRootDir"), QStringLiteral(".")).toString();
citra_qt: support multiple game directories
2018-04-20 00:56:24 +00:00
UISettings::values.game_dir_deprecated_deepscan =
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
ReadSetting(QStringLiteral("gameListDeepScan"), false).toBool();
int size = qt_config->beginReadArray(QStringLiteral("gamedirs"));
citra_qt: support multiple game directories
2018-04-20 00:56:24 +00:00
for (int i = 0; i < size; ++i) {
qt_config->setArrayIndex(i);
UISettings::GameDir game_dir;
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
game_dir.path = ReadSetting(QStringLiteral("path")).toString();
game_dir.deep_scan = ReadSetting(QStringLiteral("deep_scan"), false).toBool();
game_dir.expanded = ReadSetting(QStringLiteral("expanded"), true).toBool();
citra_qt: support multiple game directories
2018-04-20 00:56:24 +00:00
UISettings::values.game_dirs.append(game_dir);
}
qt_config->endArray();
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
// create NAND and SD card directories if empty, these are not removable through the UI,
// also carries over old game list settings if present
citra_qt: support multiple game directories
2018-04-20 00:56:24 +00:00
if (UISettings::values.game_dirs.isEmpty()) {
UISettings::GameDir game_dir;
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
game_dir.path = QStringLiteral("INSTALLED");
citra_qt: support multiple game directories
2018-04-20 00:56:24 +00:00
game_dir.expanded = true;
UISettings::values.game_dirs.append(game_dir);
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
game_dir.path = QStringLiteral("SYSTEM");
citra_qt: support multiple game directories
2018-04-20 00:56:24 +00:00
UISettings::values.game_dirs.append(game_dir);
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
if (UISettings::values.game_dir_deprecated != QStringLiteral(".")) {
citra_qt: support multiple game directories
2018-04-20 00:56:24 +00:00
game_dir.path = UISettings::values.game_dir_deprecated;
game_dir.deep_scan = UISettings::values.game_dir_deprecated_deepscan;
UISettings::values.game_dirs.append(game_dir);
}
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
UISettings::values.recent_files = ReadSetting(QStringLiteral("recentFiles")).toStringList();
UISettings::values.language = ReadSetting(QStringLiteral("language"), QString{}).toString();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::ReadRendererValues() {
qt_config->beginGroup(QStringLiteral("Renderer"));
Settings::values.use_hw_renderer =
ReadSetting(QStringLiteral("use_hw_renderer"), true).toBool();
#ifdef __APPLE__
// Hardware shader is broken on macos thanks to poor drivers.
// We still want to provide this option for test/development purposes, but disable it by
// default.
Settings::values.use_hw_shader = ReadSetting(QStringLiteral("use_hw_shader"), false).toBool();
#else
Settings::values.use_hw_shader = ReadSetting(QStringLiteral("use_hw_shader"), true).toBool();
#endif
Settings::values.shaders_accurate_mul =
ReadSetting(QStringLiteral("shaders_accurate_mul"), false).toBool();
Settings::values.use_shader_jit = ReadSetting(QStringLiteral("use_shader_jit"), true).toBool();
Reintroduce a vsync option for people with really bad drivers
2019-12-15 22:42:05 +00:00
Settings::values.use_vsync_new = ReadSetting(QStringLiteral("use_vsync_new"), true).toBool();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
Settings::values.resolution_factor =
static_cast<u16>(ReadSetting(QStringLiteral("resolution_factor"), 1).toInt());
Settings::values.use_frame_limit =
ReadSetting(QStringLiteral("use_frame_limit"), true).toBool();
Settings::values.frame_limit = ReadSetting(QStringLiteral("frame_limit"), 100).toInt();
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();
video_core: add texture filtering (#5017) video_core: add texture filtering
2020-03-16 14:42:05 +00:00
Settings::values.texture_filter_name =
ReadSetting(QStringLiteral("texture_filter_name"), QStringLiteral("none"))
.toString()
.toStdString();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
qt_config->endGroup();
}
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 20:23:55 +00:00
citra-qt: Add /default parsing for hotkeys. Also minor code cleanups.
2018-12-30 10:09:16 +00: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 20:23:55 +00:00
qt_config->beginGroup(group);
citra-qt: Add /default parsing for hotkeys. Also minor code cleanups.
2018-12-30 10:09:16 +00:00
qt_config->beginGroup(name);
citra-qt: Add base support for hotkey reconfiguration + UI (whole of PR citra-emu/citra#3786) * Adds a new Hotkeys tab in the Controls group. * Right click to reconfigure. * See the original PR for more details & screenshots.
2018-05-22 19:30:36 +00:00
UISettings::values.shortcuts.push_back(
citra-qt: Add /default parsing for hotkeys. Also minor code cleanups.
2018-12-30 10:09:16 +00:00
{name,
group,
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
{ReadSetting(QStringLiteral("KeySeq"), keyseq).toString(),
ReadSetting(QStringLiteral("Context"), context).toInt()}});
citra-qt: Add base support for hotkey reconfiguration + UI (whole of PR citra-emu/citra#3786) * Adds a new Hotkeys tab in the Controls group. * Right click to reconfigure. * See the original PR for more details & screenshots.
2018-05-22 19:30:36 +00:00
qt_config->endGroup();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
qt_config->endGroup();
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::ReadSystemValues() {
qt_config->beginGroup(QStringLiteral("System"));
citra_qt/system: Add N3DS mode checkbox and enable it by default
2020-02-28 01:56:24 +00:00
Settings::values.is_new_3ds = ReadSetting(QStringLiteral("is_new_3ds"), true).toBool();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
Settings::values.region_value =
ReadSetting(QStringLiteral("region_value"), Settings::REGION_VALUE_AUTO_SELECT).toInt();
Settings::values.init_clock = static_cast<Settings::InitClock>(
ReadSetting(QStringLiteral("init_clock"), static_cast<u32>(Settings::InitClock::SystemTime))
.toInt());
Settings::values.init_time =
ReadSetting(QStringLiteral("init_time"), 946681277ULL).toULongLong();
qt_config->endGroup();
}
citra, citra_qt: Add video dumping config read/write The default values are VP9/libvorbis just like before. The default configuration is provided for VP9
2020-01-29 06:57:16 +00:00
// Options for variable bit rate live streaming taken from here:
// https://developers.google.com/media/vp9/live-encoding
const QString DEFAULT_VIDEO_ENCODER_OPTIONS =
QStringLiteral("quality:realtime,speed:6,tile-columns:4,frame-parallel:1,threads:8,row-mt:1");
const QString DEFAULT_AUDIO_ENCODER_OPTIONS = QString{};
void Config::ReadVideoDumpingValues() {
qt_config->beginGroup(QStringLiteral("VideoDumping"));
Settings::values.output_format =
ReadSetting(QStringLiteral("output_format"), QStringLiteral("webm"))
.toString()
.toStdString();
Settings::values.format_options =
ReadSetting(QStringLiteral("format_options")).toString().toStdString();
Settings::values.video_encoder =
ReadSetting(QStringLiteral("video_encoder"), QStringLiteral("libvpx-vp9"))
.toString()
.toStdString();
Settings::values.video_encoder_options =
ReadSetting(QStringLiteral("video_encoder_options"), DEFAULT_VIDEO_ENCODER_OPTIONS)
.toString()
.toStdString();
Settings::values.video_bitrate =
ReadSetting(QStringLiteral("video_bitrate"), 2500000).toULongLong();
Settings::values.audio_encoder =
ReadSetting(QStringLiteral("audio_encoder"), QStringLiteral("libvorbis"))
.toString()
.toStdString();
Settings::values.audio_encoder_options =
ReadSetting(QStringLiteral("audio_encoder_options"), DEFAULT_AUDIO_ENCODER_OPTIONS)
.toString()
.toStdString();
Settings::values.audio_bitrate =
ReadSetting(QStringLiteral("audio_bitrate"), 64000).toULongLong();
qt_config->endGroup();
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
void Config::ReadUIValues() {
qt_config->beginGroup(QStringLiteral("UI"));
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
UISettings::values.theme =
ReadSetting(QStringLiteral("theme"), QString::fromUtf8(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());
ReadUpdaterValues();
ReadUILayoutValues();
ReadUIGameListValues();
ReadPathValues();
ReadShortcutValues();
ReadMultiplayerValues();
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();
Naming changes and clang format
2019-09-14 21:14:23 +00:00
UISettings::values.pause_when_in_background =
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
ReadSetting(QStringLiteral("pauseWhenInBackground"), false).toBool();
qt_config->endGroup();
}
void Config::ReadUIGameListValues() {
qt_config->beginGroup(QStringLiteral("GameList"));
auto icon_size = UISettings::GameListIconSize{
ReadSetting(QStringLiteral("iconSize"),
static_cast<int>(UISettings::GameListIconSize::LargeIcon))
.toInt()};
if (icon_size < UISettings::GameListIconSize::NoIcon ||
icon_size > UISettings::GameListIconSize::LargeIcon) {
icon_size = UISettings::GameListIconSize::LargeIcon;
Address more review comments * Make Validation a singleton instead * Wording changes for error messages * Smart pointers for Ui members * Other minor nitpicks
2018-04-18 05:06:02 +00:00
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
UISettings::values.game_list_icon_size = icon_size;
UISettings::GameListText row_1 = UISettings::GameListText{
ReadSetting(QStringLiteral("row1"), static_cast<int>(UISettings::GameListText::TitleName))
.toInt()};
if (row_1 <= UISettings::GameListText::NoText || row_1 >= UISettings::GameListText::ListEnd) {
row_1 = UISettings::GameListText::TitleName;
citra_qt: Save ban list for room hosting
2018-11-24 08:22:49 +00:00
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
UISettings::values.game_list_row_1 = row_1;
UISettings::GameListText row_2 = UISettings::GameListText{
ReadSetting(QStringLiteral("row2"), static_cast<int>(UISettings::GameListText::FileName))
.toInt()};
if (row_2 < UISettings::GameListText::NoText || row_2 >= UISettings::GameListText::ListEnd) {
row_2 = UISettings::GameListText::FileName;
citra_qt: Save ban list for room hosting
2018-11-24 08:22:49 +00:00
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
UISettings::values.game_list_row_2 = row_2;
UISettings::values.game_list_hide_no_icon =
ReadSetting(QStringLiteral("hideNoIcon"), false).toBool();
UISettings::values.game_list_single_line_mode =
ReadSetting(QStringLiteral("singleLineMode"), false).toBool();
Citra-qt: Add multiplayer ui
2018-01-19 13:42:21 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
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::ReadUpdaterValues() {
qt_config->beginGroup(QStringLiteral("Updater"));
UISettings::values.check_for_update_on_start =
ReadSetting(QStringLiteral("check_for_update_on_start"), true).toBool();
UISettings::values.update_on_close =
ReadSetting(QStringLiteral("update_on_close"), 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.citra-emu.org"))
.toString()
.toStdString();
Settings::values.citra_username =
ReadSetting(QStringLiteral("citra_username")).toString().toStdString();
Settings::values.citra_token =
ReadSetting(QStringLiteral("citra_token")).toString().toStdString();
Citra-qt: Add multiplayer ui
2018-01-19 13:42:21 +00:00
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
qt_config->endGroup();
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-13 00:06:13 +00:00
}
Merge Config::ReadXYZs
2014-11-15 19:56:18 +00:00
void Config::SaveValues() {
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
SaveControlValues();
SaveCoreValues();
SaveRendererValues();
SaveLayoutValues();
SaveAudioValues();
SaveCameraValues();
SaveDataStorageValues();
SaveSystemValues();
SaveMiscellaneousValues();
SaveDebuggingValues();
SaveWebServiceValues();
citra, citra_qt: Add video dumping config read/write The default values are VP9/libvorbis just like before. The default configuration is provided for VP9
2020-01-29 06:57:16 +00:00
SaveVideoDumpingValues();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
SaveUIValues();
citra_qt/configuration: add missing Read/SaveUtilityValues
2019-11-11 00:26:03 +00:00
SaveUtilityValues();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::SaveAudioValues() {
qt_config->beginGroup(QStringLiteral("Audio"));
WriteSetting(QStringLiteral("enable_dsp_lle"), Settings::values.enable_dsp_lle, false);
WriteSetting(QStringLiteral("enable_dsp_lle_multithread"),
Settings::values.enable_dsp_lle_multithread, false);
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);
WriteSetting(QStringLiteral("mic_input_device"),
QString::fromStdString(Settings::values.mic_input_device),
Port yuzu commit: "yuzu/CMakeLists: Disable implicit QString co… (#5074) * yuzu/CMakeLists: Disable implicit QString conversions Now that all of our code is compilable with implicit QString conversions, we can enforce it at compile-time by disabling them. Co-Authored-By: Mat M. <lioncash@users.noreply.github.com> * citra_qt: Remove lots of implicit QString conversions Co-authored-by: Mat M. <mathew1800@gmail.com>
2020-02-11 12:12:09 +00:00
QString::fromUtf8(Frontend::Mic::default_device_name));
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("mic_input_type"),
static_cast<int>(Settings::values.mic_input_type), 0);
qt_config->endGroup();
}
void Config::SaveCameraValues() {
using namespace Service::CAM;
qt_config->beginGroup(QStringLiteral("Camera"));
WriteSetting(QStringLiteral("camera_outer_right_name"),
QString::fromStdString(Settings::values.camera_name[OuterRightCamera]),
QStringLiteral("blank"));
WriteSetting(QStringLiteral("camera_outer_right_config"),
QString::fromStdString(Settings::values.camera_config[OuterRightCamera]),
QString{});
WriteSetting(QStringLiteral("camera_outer_right_flip"),
Settings::values.camera_flip[OuterRightCamera], 0);
WriteSetting(QStringLiteral("camera_inner_name"),
QString::fromStdString(Settings::values.camera_name[InnerCamera]),
QStringLiteral("blank"));
WriteSetting(QStringLiteral("camera_inner_config"),
QString::fromStdString(Settings::values.camera_config[InnerCamera]), QString{});
WriteSetting(QStringLiteral("camera_inner_flip"), Settings::values.camera_flip[InnerCamera], 0);
WriteSetting(QStringLiteral("camera_outer_left_name"),
QString::fromStdString(Settings::values.camera_name[OuterLeftCamera]),
QStringLiteral("blank"));
WriteSetting(QStringLiteral("camera_outer_left_config"),
QString::fromStdString(Settings::values.camera_config[OuterLeftCamera]),
QString{});
WriteSetting(QStringLiteral("camera_outer_left_flip"),
Settings::values.camera_flip[OuterLeftCamera], 0);
qt_config->endGroup();
}
void Config::SaveControlValues() {
qt_config->beginGroup(QStringLiteral("Controls"));
WriteSetting(QStringLiteral("profile"), Settings::values.current_input_profile_index, 0);
qt_config->beginWriteArray(QStringLiteral("profiles"));
more fixes
2018-12-29 02:14:44 +00:00
for (std::size_t p = 0; p < Settings::values.input_profiles.size(); ++p) {
fixes
2018-12-29 02:13:57 +00:00
qt_config->setArrayIndex(static_cast<int>(p));
more fixes
2018-12-29 02:14:44 +00:00
const auto& profile = Settings::values.input_profiles[p];
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("name"), QString::fromStdString(profile.name),
QStringLiteral("default"));
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
WriteSetting(QString::fromStdString(Settings::NativeButton::mapping[i]),
QString::fromStdString(profile.buttons[i]),
QString::fromStdString(default_param));
}
for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
default_analogs[i][3], default_analogs[i][4], 0.5f);
WriteSetting(QString::fromStdString(Settings::NativeAnalog::mapping[i]),
QString::fromStdString(profile.analogs[i]),
QString::fromStdString(default_param));
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(
QStringLiteral("motion_device"), QString::fromStdString(profile.motion_device),
QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01,tilt_clamp:90.0"));
WriteSetting(QStringLiteral("touch_device"), QString::fromStdString(profile.touch_device),
QStringLiteral("engine:emu_window"));
WriteSetting(QStringLiteral("udp_input_address"),
QString::fromStdString(profile.udp_input_address),
QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR));
WriteSetting(QStringLiteral("udp_input_port"), profile.udp_input_port,
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
InputCommon::CemuhookUDP::DEFAULT_PORT);
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("udp_pad_index"), profile.udp_pad_index, 0);
Move input values into an array
2015-06-20 03:34:45 +00:00
}
Add multiple input profile support Only supported in the Qt frontend.
2018-12-29 00:24:56 +00:00
qt_config->endArray();
Use configuration files to enable or disable the new dyncom interpreter.
2014-10-25 19:54:44 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
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-10 02:43:40 +00:00
add texture dumping as a config entry
2019-04-03 00:57:13 +00:00
void Config::SaveUtilityValues() {
yuzu/main: Specify string conversions explicitly
2019-11-20 21:34:39 +00:00
qt_config->beginGroup(QStringLiteral("Utility"));
add texture dumping as a config entry
2019-04-03 00:57:13 +00:00
yuzu/main: Specify string conversions explicitly
2019-11-20 21:34:39 +00:00
WriteSetting(QStringLiteral("dump_textures"), Settings::values.dump_textures, false);
WriteSetting(QStringLiteral("custom_textures"), Settings::values.custom_textures, false);
WriteSetting(QStringLiteral("preload_textures"), Settings::values.preload_textures, false);
WriteSetting(QStringLiteral("use_disk_shader_cache"), Settings::values.use_disk_shader_cache,
true);
add texture dumping as a config entry
2019-04-03 00:57:13 +00:00
qt_config->endGroup();
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
void Config::SaveCoreValues() {
qt_config->beginGroup(QStringLiteral("Core"));
INI hw/sw renderer toggle
2015-05-03 19:34:48 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("use_cpu_jit"), Settings::values.use_cpu_jit, true);
Add CPU Clock Frequency slider This slider affects the number of cycles that the guest cpu emulation reports that have passed since the last time slice. This option scales the result returned by a percentage that the user selects. In some games underclocking the CPU can give a major speedup. Exposing this as an option will give users something to toy with for performance, while also potentially enhancing games that experience lag on the real console
2019-12-16 05:04:33 +00:00
WriteSetting(QStringLiteral("cpu_clock_percentage"), Settings::values.cpu_clock_percentage,
100);
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 22:35:51 +00:00
Audio: Add sink selection to configuration files
2016-04-27 12:53:23 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
Audio: Add sink selection to configuration files
2016-04-27 12:53:23 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
void Config::SaveDataStorageValues() {
qt_config->beginGroup(QStringLiteral("Data Storage"));
WriteSetting(QStringLiteral("use_virtual_sd"), Settings::values.use_virtual_sd, true);
Services: Stub some functions
2015-01-31 23:11:51 +00:00
Add support for disabling log from settings
2014-10-27 21:18:28 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::SaveDebuggingValues() {
qt_config->beginGroup(QStringLiteral("Debugging"));
Implement gdbstub
2015-09-02 12:56:38 +00:00
Address review comments
2019-08-15 03:03:11 +00:00
// Intentionally not using the QT default setting as this is intended to be changed in the ini
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
qt_config->setValue(QStringLiteral("record_frame_times"), Settings::values.record_frame_times);
WriteSetting(QStringLiteral("use_gdbstub"), Settings::values.use_gdbstub, false);
WriteSetting(QStringLiteral("gdbstub_port"), Settings::values.gdbstub_port, 24689);
citra-qt: service: add convenient LLE service module configuration (#3967) * citra-qt: service: add convenient LLE service module configuration * fix SDL settings * unexpose AttemptLLE * static * fix array includes * use default with writesetting
2018-08-09 19:10:11 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
qt_config->beginGroup(QStringLiteral("LLE"));
citra-qt: service: add convenient LLE service module configuration (#3967) * citra-qt: service: add convenient LLE service module configuration * fix SDL settings * unexpose AttemptLLE * static * fix array includes * use default with writesetting
2018-08-09 19:10:11 +00:00
for (const auto& service_module : Settings::values.lle_modules) {
WriteSetting(QString::fromStdString(service_module.first), service_module.second, false);
}
qt_config->endGroup();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
settings: Add telemetry endpoint URL.
2017-06-28 02:46:52 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::SaveLayoutValues() {
qt_config->beginGroup(QStringLiteral("Layout"));
settings: Add telemetry endpoint URL.
2017-06-28 02:46:52 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("render_3d"), static_cast<int>(Settings::values.render_3d), 0);
WriteSetting(QStringLiteral("factor_3d"), Settings::values.factor_3d.load(), 0);
WriteSetting(QStringLiteral("pp_shader_name"),
QString::fromStdString(Settings::values.pp_shader_name),
(Settings::values.render_3d == Settings::StereoRenderOption::Anaglyph)
? QStringLiteral("dubois (builtin)")
: QStringLiteral("none (builtin)"));
WriteSetting(QStringLiteral("filter_mode"), Settings::values.filter_mode, true);
WriteSetting(QStringLiteral("layout_option"), static_cast<int>(Settings::values.layout_option));
WriteSetting(QStringLiteral("swap_screen"), Settings::values.swap_screen, false);
Implementation of screen rotation without use of additional layouts. This is based on what was done using additional layouts, but modified to have a variable to control rotation and making it so Single Screen Layout behaves like Upright Single would, and Default Layout behaves like Upright Double would, when the new variable is used. Large Layout and Side Layout currently ignore the new variable. New variable still currently doesn't have a hotkey.
2019-10-25 23:21:10 +00:00
WriteSetting(QStringLiteral("upright_screen"), Settings::values.upright_screen, false);
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("custom_layout"), Settings::values.custom_layout, false);
WriteSetting(QStringLiteral("custom_top_left"), Settings::values.custom_top_left, 0);
WriteSetting(QStringLiteral("custom_top_top"), Settings::values.custom_top_top, 0);
WriteSetting(QStringLiteral("custom_top_right"), Settings::values.custom_top_right, 400);
WriteSetting(QStringLiteral("custom_top_bottom"), Settings::values.custom_top_bottom, 240);
WriteSetting(QStringLiteral("custom_bottom_left"), Settings::values.custom_bottom_left, 40);
WriteSetting(QStringLiteral("custom_bottom_top"), Settings::values.custom_bottom_top, 240);
WriteSetting(QStringLiteral("custom_bottom_right"), Settings::values.custom_bottom_right, 360);
WriteSetting(QStringLiteral("custom_bottom_bottom"), Settings::values.custom_bottom_bottom,
480);
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
Qt updater integration, based on QtAutoUpdater
2017-08-19 05:05:49 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::SaveMiscellaneousValues() {
qt_config->beginGroup(QStringLiteral("Miscellaneous"));
WriteSetting(QStringLiteral("log_filter"), QString::fromStdString(Settings::values.log_filter),
QStringLiteral("*:Info"));
Qt updater integration, based on QtAutoUpdater
2017-08-19 05:05:49 +00:00
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::SaveMultiplayerValues() {
qt_config->beginGroup(QStringLiteral("Multiplayer"));
WriteSetting(QStringLiteral("nickname"), UISettings::values.nickname, QString{});
WriteSetting(QStringLiteral("ip"), UISettings::values.ip, QString{});
WriteSetting(QStringLiteral("port"), UISettings::values.port, Network::DefaultRoomPort);
WriteSetting(QStringLiteral("room_nickname"), UISettings::values.room_nickname, QString{});
WriteSetting(QStringLiteral("room_name"), UISettings::values.room_name, QString{});
WriteSetting(QStringLiteral("room_port"), UISettings::values.room_port,
QStringLiteral("24872"));
WriteSetting(QStringLiteral("host_type"), UISettings::values.host_type, 0);
WriteSetting(QStringLiteral("max_player"), UISettings::values.max_player, 8);
WriteSetting(QStringLiteral("game_id"), UISettings::values.game_id, 0);
WriteSetting(QStringLiteral("room_description"), UISettings::values.room_description,
QString{});
// Write ban list
qt_config->beginWriteArray(QStringLiteral("username_ban_list"));
for (std::size_t i = 0; i < UISettings::values.ban_list.first.size(); ++i) {
qt_config->setArrayIndex(i);
WriteSetting(QStringLiteral("username"),
QString::fromStdString(UISettings::values.ban_list.first[i]));
}
qt_config->endArray();
qt_config->beginWriteArray(QStringLiteral("ip_ban_list"));
for (std::size_t i = 0; i < UISettings::values.ban_list.second.size(); ++i) {
qt_config->setArrayIndex(i);
WriteSetting(QStringLiteral("ip"),
QString::fromStdString(UISettings::values.ban_list.second[i]));
}
qt_config->endArray();
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
citra_qt: Add Game List configuration This adds a Game List configuration group box which is similar to yuzu's, with features including icon size setting, row 1/2 text, and ability to hide invalid titles (those without a valid SMDH). I also added a UI tab and moved the language and theme settings there.
2018-09-23 03:22:44 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::SavePathValues() {
qt_config->beginGroup(QStringLiteral("Paths"));
citra_qt: Add Game List configuration This adds a Game List configuration group box which is similar to yuzu's, with features including icon size setting, row 1/2 text, and ability to hide invalid titles (those without a valid SMDH). I also added a UI tab and moved the language and theme settings there.
2018-09-23 03:22:44 +00:00
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("romsPath"), UISettings::values.roms_path);
WriteSetting(QStringLiteral("symbolsPath"), UISettings::values.symbols_path);
WriteSetting(QStringLiteral("movieRecordPath"), UISettings::values.movie_record_path);
WriteSetting(QStringLiteral("moviePlaybackPath"), UISettings::values.movie_playback_path);
WriteSetting(QStringLiteral("screenshotPath"), UISettings::values.screenshot_path);
WriteSetting(QStringLiteral("videoDumpingPath"), UISettings::values.video_dumping_path);
qt_config->beginWriteArray(QStringLiteral("gamedirs"));
citra_qt: support multiple game directories
2018-04-20 00:56:24 +00:00
for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {
qt_config->setArrayIndex(i);
Backport changes from yuzu-emu/yuzu#2444
2019-09-22 15:27:01 +00:00
const auto& game_dir = UISettings::values.game_dirs[i];
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("path"), game_dir.path);
WriteSetting(QStringLiteral("deep_scan"), game_dir.deep_scan, false);
WriteSetting(QStringLiteral("expanded"), game_dir.expanded, true);
citra_qt: support multiple game directories
2018-04-20 00:56:24 +00:00
}
qt_config->endArray();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("recentFiles"), UISettings::values.recent_files);
WriteSetting(QStringLiteral("language"), UISettings::values.language, QString{});
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::SaveRendererValues() {
qt_config->beginGroup(QStringLiteral("Renderer"));
WriteSetting(QStringLiteral("use_hw_renderer"), Settings::values.use_hw_renderer, true);
#ifdef __APPLE__
// Hardware shader is broken on macos thanks to poor drivers.
// We still want to provide this option for test/development purposes, but disable it by
// default.
WriteSetting(QStringLiteral("use_hw_shader"), Settings::values.use_hw_shader, false);
#else
WriteSetting(QStringLiteral("use_hw_shader"), Settings::values.use_hw_shader, true);
#endif
WriteSetting(QStringLiteral("shaders_accurate_mul"), Settings::values.shaders_accurate_mul,
false);
WriteSetting(QStringLiteral("use_shader_jit"), Settings::values.use_shader_jit, true);
Reintroduce a vsync option for people with really bad drivers
2019-12-15 22:42:05 +00:00
WriteSetting(QStringLiteral("use_vsync_new"), Settings::values.use_vsync_new, true);
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("resolution_factor"), Settings::values.resolution_factor, 1);
WriteSetting(QStringLiteral("use_frame_limit"), Settings::values.use_frame_limit, true);
WriteSetting(QStringLiteral("frame_limit"), Settings::values.frame_limit, 100);
// Cast to double because Qt's written float values are not human-readable
WriteSetting(QStringLiteral("bg_red"), (double)Settings::values.bg_red, 0.0);
WriteSetting(QStringLiteral("bg_green"), (double)Settings::values.bg_green, 0.0);
WriteSetting(QStringLiteral("bg_blue"), (double)Settings::values.bg_blue, 0.0);
video_core: add texture filtering (#5017) video_core: add texture filtering
2020-03-16 14:42:05 +00:00
WriteSetting(QStringLiteral("texture_filter_name"),
QString::fromStdString(Settings::values.texture_filter_name),
QStringLiteral("none"));
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
qt_config->endGroup();
}
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 20:23:55 +00:00
citra-qt: Add /default parsing for hotkeys. Also minor code cleanups.
2018-12-30 10:09:16 +00: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++) {
auto [name, group, shortcut] = UISettings::values.shortcuts[i];
qt_config->beginGroup(group);
qt_config->beginGroup(name);
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("KeySeq"), shortcut.first, default_hotkeys[i].shortcut.first);
WriteSetting(QStringLiteral("Context"), shortcut.second,
default_hotkeys[i].shortcut.second);
citra-qt: Add base support for hotkey reconfiguration + UI (whole of PR citra-emu/citra#3786) * Adds a new Hotkeys tab in the Controls group. * Right click to reconfigure. * See the original PR for more details & screenshots.
2018-05-22 19:30:36 +00: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 20:23:55 +00:00
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
void Config::SaveSystemValues() {
qt_config->beginGroup(QStringLiteral("System"));
citra_qt/system: Add N3DS mode checkbox and enable it by default
2020-02-28 01:56:24 +00:00
WriteSetting(QStringLiteral("is_new_3ds"), Settings::values.is_new_3ds, true);
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
WriteSetting(QStringLiteral("region_value"), Settings::values.region_value,
Settings::REGION_VALUE_AUTO_SELECT);
WriteSetting(QStringLiteral("init_clock"), static_cast<u32>(Settings::values.init_clock),
static_cast<u32>(Settings::InitClock::SystemTime));
WriteSetting(QStringLiteral("init_time"),
static_cast<unsigned long long>(Settings::values.init_time), 946681277ULL);
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
Citra-qt: Add multiplayer ui
2018-01-19 13:42:21 +00:00
qt_config->endGroup();
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
}
citra, citra_qt: Add video dumping config read/write The default values are VP9/libvorbis just like before. The default configuration is provided for VP9
2020-01-29 06:57:16 +00:00
void Config::SaveVideoDumpingValues() {
qt_config->beginGroup(QStringLiteral("VideoDumping"));
WriteSetting(QStringLiteral("output_format"),
QString::fromStdString(Settings::values.output_format), QStringLiteral("webm"));
WriteSetting(QStringLiteral("format_options"),
QString::fromStdString(Settings::values.format_options));
WriteSetting(QStringLiteral("video_encoder"),
QString::fromStdString(Settings::values.video_encoder),
QStringLiteral("libvpx-vp9"));
WriteSetting(QStringLiteral("video_encoder_options"),
QString::fromStdString(Settings::values.video_encoder_options),
DEFAULT_VIDEO_ENCODER_OPTIONS);
WriteSetting(QStringLiteral("video_bitrate"),
static_cast<unsigned long long>(Settings::values.video_bitrate), 2500000);
WriteSetting(QStringLiteral("audio_encoder"),
QString::fromStdString(Settings::values.audio_encoder),
QStringLiteral("libvorbis"));
WriteSetting(QStringLiteral("audio_encoder_options"),
QString::fromStdString(Settings::values.audio_encoder_options),
DEFAULT_AUDIO_ENCODER_OPTIONS);
WriteSetting(QStringLiteral("audio_bitrate"),
static_cast<unsigned long long>(Settings::values.audio_bitrate), 64000);
qt_config->endGroup();
}
configuration/config: Move config loading and saving to functions based off groups (#4855) 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-11-07 16:33:41 +00:00
void Config::SaveUIValues() {
qt_config->beginGroup(QStringLiteral("UI"));
WriteSetting(QStringLiteral("theme"), UISettings::values.theme,
QString::fromUtf8(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);
SaveUpdaterValues();
SaveUILayoutValues();
SaveUIGameListValues();
SavePathValues();
SaveShortcutValues();
SaveMultiplayerValues();
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("pauseWhenInBackground"),
UISettings::values.pause_when_in_background, false);
qt_config->endGroup();
}
void Config::SaveUIGameListValues() {
qt_config->beginGroup(QStringLiteral("GameList"));
WriteSetting(QStringLiteral("iconSize"),
static_cast<int>(UISettings::values.game_list_icon_size), 2);
WriteSetting(QStringLiteral("row1"), static_cast<int>(UISettings::values.game_list_row_1), 2);
WriteSetting(QStringLiteral("row2"), static_cast<int>(UISettings::values.game_list_row_2), 0);
WriteSetting(QStringLiteral("hideNoIcon"), UISettings::values.game_list_hide_no_icon, false);
WriteSetting(QStringLiteral("singleLineMode"), UISettings::values.game_list_single_line_mode,
false);
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);
qt_config->endGroup();
}
void Config::SaveUpdaterValues() {
qt_config->beginGroup(QStringLiteral("Updater"));
WriteSetting(QStringLiteral("check_for_update_on_start"),
UISettings::values.check_for_update_on_start, true);
WriteSetting(QStringLiteral("update_on_close"), UISettings::values.update_on_close, false);
qt_config->endGroup();
}
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.citra-emu.org"));
WriteSetting(QStringLiteral("citra_username"),
QString::fromStdString(Settings::values.citra_username));
WriteSetting(QStringLiteral("citra_token"),
QString::fromStdString(Settings::values.citra_token));
Citra-qt: Add multiplayer ui
2018-01-19 13:42:21 +00:00
Whole config is handled by Config class. This also means : we have only one config file, now
2016-01-24 20:23:55 +00:00
qt_config->endGroup();
Add support for disabling log from settings
2014-10-27 21:18:28 +00:00
}
citra_qt/config: backport minor changes from yuzu
2019-02-05 21:09:02 +00:00
QVariant Config::ReadSetting(const QString& name) const {
citra_qt: Settings (configuration) rework
2018-07-09 12:07:59 +00:00
return qt_config->value(name);
}
citra_qt/config: backport minor changes from yuzu
2019-02-05 21:09:02 +00:00
QVariant Config::ReadSetting(const QString& name, const QVariant& default_value) const {
citra_qt: Settings (configuration) rework
2018-07-09 12:07:59 +00:00
QVariant result;
Port yuzu commit: "yuzu/CMakeLists: Disable implicit QString co… (#5074) * yuzu/CMakeLists: Disable implicit QString conversions Now that all of our code is compilable with implicit QString conversions, we can enforce it at compile-time by disabling them. Co-Authored-By: Mat M. <lioncash@users.noreply.github.com> * citra_qt: Remove lots of implicit QString conversions Co-authored-by: Mat M. <mathew1800@gmail.com>
2020-02-11 12:12:09 +00:00
if (qt_config->value(name + QStringLiteral("/default"), false).toBool()) {
citra_qt: Settings (configuration) rework
2018-07-09 12:07:59 +00: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) {
Port yuzu commit: "yuzu/CMakeLists: Disable implicit QString co… (#5074) * yuzu/CMakeLists: Disable implicit QString conversions Now that all of our code is compilable with implicit QString conversions, we can enforce it at compile-time by disabling them. Co-Authored-By: Mat M. <lioncash@users.noreply.github.com> * citra_qt: Remove lots of implicit QString conversions Co-authored-by: Mat M. <mathew1800@gmail.com>
2020-02-11 12:12:09 +00:00
qt_config->setValue(name + QStringLiteral("/default"), value == default_value);
citra_qt: Settings (configuration) rework
2018-07-09 12:07:59 +00:00
qt_config->setValue(name, value);
}
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-13 00:06:13 +00:00
void Config::Reload() {
Merge Config::ReadXYZs
2014-11-15 19:56:18 +00:00
ReadValues();
citra_qt: Settings (configuration) rework
2018-07-09 12:07:59 +00:00
// To apply default value changes
SaveValues();
CitraQt: Apply config at startup
2016-04-11 12:38:42 +00:00
Settings::Apply();
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-13 00:06:13 +00:00
}
void Config::Save() {
Merge Config::ReadXYZs
2014-11-15 19:56:18 +00:00
SaveValues();
Added configuration file system. Uses QSettings on citra-qt, and inih on citra-cli.
2014-09-13 00:06:13 +00:00
}
Reference in New Issue Copy Permalink