ShuriZma
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Qt: Remove usage of QString where possible for settings

This commit is contained in:
Connor McLaughlin 2020-07-21 19:49:04 +10:00
parent eb7da791ea
commit 68d98af497
31 changed files with 336 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
android/app/src/cpp/android_host_interface.cpp
View File

@ -101,11 +101,26 @@ void AndroidHostInterface::ReportMessage(const char* message)
HostInterface::ReportMessage(message); HostInterface::ReportMessage(message);
} }
std::string AndroidHostInterface::GetSettingValue(const char* section, const char* key, const char* default_value) std::string AndroidHostInterface::GetStringSettingValue(const char* section, const char* key, const char* default_value)
{ {
return m_settings_interface.GetStringValue(section, key, default_value); return m_settings_interface.GetStringValue(section, key, default_value);
} }
bool AndroidHostInterface::GetBoolSettingValue(const char* section, const char* key, bool default_value /* = false */)
{
return m_settings_interface.GetBoolValue(section, key, default_value);
}
int AndroidHostInterface::GetIntSettingValue(const char* section, const char* key, int default_value /* = 0 */)
{
return m_settings_interface.GetIntValue(section, key, default_value);
}
float AndroidHostInterface::GetFloatSettingValue(const char* section, const char* key, float default_value /* = 0.0f */)
{
return m_settings_interface.GetFloatValue(section, key, default_value);
}
void AndroidHostInterface::SetUserDirectory() void AndroidHostInterface::SetUserDirectory()
{ {
// TODO: Should this be customizable or use an API-determined path? // TODO: Should this be customizable or use an API-determined path?

5
android/app/src/cpp/android_host_interface.h
View File

@ -29,7 +29,10 @@ public:
void ReportError(const char* message) override; void ReportError(const char* message) override;
void ReportMessage(const char* message) override; void ReportMessage(const char* message) override;
std::string GetSettingValue(const char* section, const char* key, const char* default_value = "") override; std::string GetStringSettingValue(const char* section, const char* key, const char* default_value = "") override;
bool GetBoolSettingValue(const char* section, const char* key, bool default_value = false) override;
int GetIntSettingValue(const char* section, const char* key, int default_value = 0) override;
float GetFloatSettingValue(const char* section, const char* key, float default_value = 0.0f) override;
bool IsEmulationThreadRunning() const { return m_emulation_thread.joinable(); } bool IsEmulationThreadRunning() const { return m_emulation_thread.joinable(); }
bool StartEmulationThread(ANativeWindow* initial_surface, SystemBootParameters boot_params); bool StartEmulationThread(ANativeWindow* initial_surface, SystemBootParameters boot_params);

2
src/core/analog_controller.cpp
View File

@ -491,5 +491,5 @@ Controller::SettingList AnalogController::StaticGetSettings()
void AnalogController::LoadSettings(HostInterface* host_interface, const char* section) void AnalogController::LoadSettings(HostInterface* host_interface, const char* section)
{ {
Controller::LoadSettings(host_interface, section); Controller::LoadSettings(host_interface, section);
m_auto_enable_analog = host_interface->GetBooleanSettingValue(section, "AutoEnableAnalog", false); m_auto_enable_analog = host_interface->GetBoolSettingValue(section, "AutoEnableAnalog", false);
} }

12
src/core/host_interface.cpp
View File

@ -572,9 +572,9 @@ std::string HostInterface::GetGameMemoryCardPath(const char* game_code, u32 slot
return GetUserDirectoryRelativePath("memcards/%s_%d.mcd", game_code, slot + 1); return GetUserDirectoryRelativePath("memcards/%s_%d.mcd", game_code, slot + 1);
} }
bool HostInterface::GetBooleanSettingValue(const char* section, const char* key, bool default_value /*= false*/) bool HostInterface::GetBoolSettingValue(const char* section, const char* key, bool default_value /*= false*/)
{ {
std::string value = GetSettingValue(section, key, ""); std::string value = GetStringSettingValue(section, key, "");
if (value.empty()) if (value.empty())
return default_value; return default_value;
@ -582,19 +582,19 @@ bool HostInterface::GetBooleanSettingValue(const char* section, const char* key,
return bool_value.value_or(default_value); return bool_value.value_or(default_value);
} }
s32 HostInterface::GetIntegerSettingValue(const char* section, const char* key, s32 default_value /*= 0*/) int HostInterface::GetIntSettingValue(const char* section, const char* key, int default_value /*= 0*/)
{ {
std::string value = GetSettingValue(section, key, ""); std::string value = GetStringSettingValue(section, key, "");
if (value.empty()) if (value.empty())
return default_value; return default_value;
std::optional<s32> int_value = StringUtil::FromChars<s32>(value); std::optional<int> int_value = StringUtil::FromChars<int>(value);
return int_value.value_or(default_value); return int_value.value_or(default_value);
} }
float HostInterface::GetFloatSettingValue(const char* section, const char* key, float default_value /*= 0.0f*/) float HostInterface::GetFloatSettingValue(const char* section, const char* key, float default_value /*= 0.0f*/)
{ {
std::string value = GetSettingValue(section, key, ""); std::string value = GetStringSettingValue(section, key, "");
if (value.empty()) if (value.empty())
return default_value; return default_value;

8
src/core/host_interface.h
View File

@ -107,16 +107,16 @@ public:
virtual std::string GetShaderCacheBasePath() const; virtual std::string GetShaderCacheBasePath() const;
/// Returns a setting value from the configuration. /// Returns a setting value from the configuration.
virtual std::string GetSettingValue(const char* section, const char* key, const char* default_value = "") = 0; virtual std::string GetStringSettingValue(const char* section, const char* key, const char* default_value = "") = 0;
/// Returns a boolean setting from the configuration. /// Returns a boolean setting from the configuration.
bool GetBooleanSettingValue(const char* section, const char* key, bool default_value = false); virtual bool GetBoolSettingValue(const char* section, const char* key, bool default_value = false);
/// Returns an integer setting from the configuration. /// Returns an integer setting from the configuration.
s32 GetIntegerSettingValue(const char* section, const char* key, s32 default_value = 0); virtual int GetIntSettingValue(const char* section, const char* key, int default_value = 0);
/// Returns a float setting from the configuration. /// Returns a float setting from the configuration.
float GetFloatSettingValue(const char* section, const char* key, float default_value = 0.0f); virtual float GetFloatSettingValue(const char* section, const char* key, float default_value = 0.0f);
protected: protected:
virtual bool AcquireHostDisplay() = 0; virtual bool AcquireHostDisplay() = 0;

2
src/core/namco_guncon.cpp
View File

@ -238,7 +238,7 @@ void NamcoGunCon::LoadSettings(HostInterface* host_interface, const char* sectio
{ {
Controller::LoadSettings(host_interface, section); Controller::LoadSettings(host_interface, section);
std::string path = host_interface->GetSettingValue(section, "CrosshairImagePath"); std::string path = host_interface->GetStringSettingValue(section, "CrosshairImagePath");
if (path != m_crosshair_image_path) if (path != m_crosshair_image_path)
{ {
m_crosshair_image_path = std::move(path); m_crosshair_image_path = std::move(path);

3
src/core/settings.h
View File

@ -4,7 +4,6 @@
#include <array> #include <array>
#include <optional> #include <optional>
#include <string> #include <string>
#include <string_view>
#include <vector> #include <vector>
class SettingsInterface class SettingsInterface
@ -23,7 +22,7 @@ public:
virtual void SetStringValue(const char* section, const char* key, const char* value) = 0; virtual void SetStringValue(const char* section, const char* key, const char* value) = 0;
virtual std::vector<std::string> GetStringList(const char* section, const char* key) = 0; virtual std::vector<std::string> GetStringList(const char* section, const char* key) = 0;
virtual void SetStringList(const char* section, const char* key, const std::vector<std::string_view>& items) = 0; virtual void SetStringList(const char* section, const char* key, const std::vector<std::string>& items) = 0;
virtual bool RemoveFromStringList(const char* section, const char* key, const char* item) = 0; virtual bool RemoveFromStringList(const char* section, const char* key, const char* item) = 0;
virtual bool AddToStringList(const char* section, const char* key, const char* item) = 0; virtual bool AddToStringList(const char* section, const char* key, const char* item) = 0;

4
src/duckstation-libretro/libretro_host_interface.cpp
View File

@ -145,8 +145,8 @@ std::string LibretroHostInterface::GetShaderCacheBasePath() const
return std::string(); return std::string();
} }
std::string LibretroHostInterface::GetSettingValue(const char* section, const char* key, std::string LibretroHostInterface::GetStringSettingValue(const char* section, const char* key,
const char* default_value /*= ""*/) const char* default_value /*= ""*/)
{ {
TinyString name; TinyString name;
name.Format("%s.%s", section, key); name.Format("%s.%s", section, key);

2
src/duckstation-libretro/libretro_host_interface.h
View File

@ -27,7 +27,7 @@ public:
std::string GetSharedMemoryCardPath(u32 slot) const override; std::string GetSharedMemoryCardPath(u32 slot) const override;
std::string GetGameMemoryCardPath(const char* game_code, u32 slot) const override; std::string GetGameMemoryCardPath(const char* game_code, u32 slot) const override;
std::string GetShaderCacheBasePath() const override; std::string GetShaderCacheBasePath() const override;
std::string GetSettingValue(const char* section, const char* key, const char* default_value = "") override; std::string GetStringSettingValue(const char* section, const char* key, const char* default_value = "") override;
// Called by frontend // Called by frontend
void retro_get_system_av_info(struct retro_system_av_info* info); void retro_get_system_av_info(struct retro_system_av_info* info);

2
src/duckstation-libretro/libretro_settings_interface.cpp
View File

@ -93,7 +93,7 @@ std::vector<std::string> LibretroSettingsInterface::GetStringList(const char* se
} }
void LibretroSettingsInterface::SetStringList(const char* section, const char* key, void LibretroSettingsInterface::SetStringList(const char* section, const char* key,
const std::vector<std::string_view>& items) const std::vector<std::string>& items)
{ {
Log_ErrorPrintf("SetStringList(\"%s\", \"%s\") not implemented", section, key); Log_ErrorPrintf("SetStringList(\"%s\", \"%s\") not implemented", section, key);
} }

2
src/duckstation-libretro/libretro_settings_interface.h
View File

@ -17,7 +17,7 @@ public:
void SetStringValue(const char* section, const char* key, const char* value) override; void SetStringValue(const char* section, const char* key, const char* value) override;
std::vector<std::string> GetStringList(const char* section, const char* key) override; std::vector<std::string> GetStringList(const char* section, const char* key) override;
void SetStringList(const char* section, const char* key, const std::vector<std::string_view>& items) override; void SetStringList(const char* section, const char* key, const std::vector<std::string>& items) override;
bool RemoveFromStringList(const char* section, const char* key, const char* item) override; bool RemoveFromStringList(const char* section, const char* key, const char* item) override;
bool AddToStringList(const char* section, const char* key, const char* item) override; bool AddToStringList(const char* section, const char* key, const char* item) override;

33
src/duckstation-qt/advancedsettingswidget.cpp
View File

@ -9,29 +9,20 @@ AdvancedSettingsWidget::AdvancedSettingsWidget(QtHostInterface* host_interface,
for (u32 i = 0; i < static_cast<u32>(LOGLEVEL_COUNT); i++) for (u32 i = 0; i < static_cast<u32>(LOGLEVEL_COUNT); i++)
m_ui.logLevel->addItem(tr(Settings::GetLogLevelDisplayName(static_cast<LOGLEVEL>(i)))); m_ui.logLevel->addItem(tr(Settings::GetLogLevelDisplayName(static_cast<LOGLEVEL>(i))));
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.logLevel, QStringLiteral("Logging"), SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.logLevel, "Logging", "LogLevel",
QStringLiteral("LogLevel"), &Settings::ParseLogLevelName, &Settings::ParseLogLevelName, &Settings::GetLogLevelName,
&Settings::GetLogLevelName, Settings::DEFAULT_LOG_LEVEL); Settings::DEFAULT_LOG_LEVEL);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, m_ui.logFilter, QStringLiteral("Logging"), SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, m_ui.logFilter, "Logging", "LogFilter");
QStringLiteral("LogFilter")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToConsole, "Logging", "LogToConsole");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToConsole, QStringLiteral("Logging"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToDebug, "Logging", "LogToDebug");
QStringLiteral("LogToConsole")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToWindow, "Logging", "LogToWindow");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToDebug, QStringLiteral("Logging"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToFile, "Logging", "LogToFile");
QStringLiteral("LogToDebug"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToWindow, QStringLiteral("Logging"),
QStringLiteral("LogToWindow"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToFile, QStringLiteral("Logging"),
QStringLiteral("LogToFile"));
// Tweaks/Hacks section // Tweaks/Hacks section
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.dmaMaxSliceTicks, QStringLiteral("Hacks"), SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.dmaMaxSliceTicks, "Hacks", "DMAMaxSliceTicks");
QStringLiteral("DMAMaxSliceTicks")); SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.dmaHaltTicks, "Hacks", "DMAHaltTicks");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.dmaHaltTicks, QStringLiteral("Hacks"), SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.gpuFIFOSize, "Hacks", "GPUFIFOSize");
QStringLiteral("DMAHaltTicks")); SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.gpuMaxRunAhead, "Hacks", "GPUMaxRunAhead");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.gpuFIFOSize, QStringLiteral("Hacks"),
QStringLiteral("GPUFIFOSize"));
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.gpuMaxRunAhead, QStringLiteral("Hacks"),
QStringLiteral("GPUMaxRunAhead"));
connect(m_ui.resetToDefaultButton, &QPushButton::clicked, this, &AdvancedSettingsWidget::onResetToDefaultClicked); connect(m_ui.resetToDefaultButton, &QPushButton::clicked, this, &AdvancedSettingsWidget::onResetToDefaultClicked);
} }

21
src/duckstation-qt/audiosettingswidget.cpp
View File

@ -11,19 +11,14 @@ AudioSettingsWidget::AudioSettingsWidget(QtHostInterface* host_interface, QWidge
for (u32 i = 0; i < static_cast<u32>(AudioBackend::Count); i++) for (u32 i = 0; i < static_cast<u32>(AudioBackend::Count); i++)
m_ui.audioBackend->addItem(tr(Settings::GetAudioBackendDisplayName(static_cast<AudioBackend>(i)))); m_ui.audioBackend->addItem(tr(Settings::GetAudioBackendDisplayName(static_cast<AudioBackend>(i))));
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.audioBackend, QStringLiteral("Audio"), SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.audioBackend, "Audio", "Backend",
QStringLiteral("Backend"), &Settings::ParseAudioBackend, &Settings::ParseAudioBackend, &Settings::GetAudioBackendName,
&Settings::GetAudioBackendName, Settings::DEFAULT_AUDIO_BACKEND); Settings::DEFAULT_AUDIO_BACKEND);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.syncToOutput, QStringLiteral("Audio"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.syncToOutput, "Audio", "Sync");
QStringLiteral("Sync")); SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.bufferSize, "Audio", "BufferSize");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.bufferSize, QStringLiteral("Audio"), SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.volume, "Audio", "OutputVolume");
QStringLiteral("BufferSize")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.muted, "Audio", "OutputMuted");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.volume, QStringLiteral("Audio"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.startDumpingOnBoot, "Audio", "DumpOnBoot");
QStringLiteral("OutputVolume"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.muted, QStringLiteral("Audio"),
QStringLiteral("OutputMuted"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.startDumpingOnBoot, QStringLiteral("Audio"),
QStringLiteral("DumpOnBoot"));
connect(m_ui.bufferSize, &QSlider::valueChanged, this, &AudioSettingsWidget::updateBufferingLabel); connect(m_ui.bufferSize, &QSlider::valueChanged, this, &AudioSettingsWidget::updateBufferingLabel);
connect(m_ui.volume, &QSlider::valueChanged, this, &AudioSettingsWidget::updateVolumeLabel); connect(m_ui.volume, &QSlider::valueChanged, this, &AudioSettingsWidget::updateVolumeLabel);

29
src/duckstation-qt/consolesettingswidget.cpp
View File

@ -15,22 +15,17 @@ ConsoleSettingsWidget::ConsoleSettingsWidget(QtHostInterface* host_interface, QW
for (u32 i = 0; i < static_cast<u32>(CPUExecutionMode::Count); i++) for (u32 i = 0; i < static_cast<u32>(CPUExecutionMode::Count); i++)
m_ui.cpuExecutionMode->addItem(tr(Settings::GetCPUExecutionModeDisplayName(static_cast<CPUExecutionMode>(i)))); m_ui.cpuExecutionMode->addItem(tr(Settings::GetCPUExecutionModeDisplayName(static_cast<CPUExecutionMode>(i))));
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.region, QStringLiteral("Console"), SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.region, "Console", "Region",
QStringLiteral("Region"), &Settings::ParseConsoleRegionName, &Settings::ParseConsoleRegionName, &Settings::GetConsoleRegionName,
&Settings::GetConsoleRegionName, Settings::DEFAULT_CONSOLE_REGION); Settings::DEFAULT_CONSOLE_REGION);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, m_ui.biosPath, QStringLiteral("BIOS"), SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, m_ui.biosPath, "BIOS", "Path");
QStringLiteral("Path")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.enableTTYOutput, "BIOS", "PatchTTYEnable");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.enableTTYOutput, QStringLiteral("BIOS"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.fastBoot, "BIOS", "PatchFastBoot");
QStringLiteral("PatchTTYEnable")); SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.cpuExecutionMode, "CPU", "ExecutionMode",
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.fastBoot, QStringLiteral("BIOS"), &Settings::ParseCPUExecutionMode, &Settings::GetCPUExecutionModeName,
QStringLiteral("PatchFastBoot")); Settings::DEFAULT_CPU_EXECUTION_MODE);
SettingWidgetBinder::BindWidgetToEnumSetting( SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.cdromReadThread, "CDROM", "ReadThread");
m_host_interface, m_ui.cpuExecutionMode, QStringLiteral("CPU"), QStringLiteral("ExecutionMode"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.cdromRegionCheck, "CDROM", "RegionCheck");
&Settings::ParseCPUExecutionMode, &Settings::GetCPUExecutionModeName, Settings::DEFAULT_CPU_EXECUTION_MODE);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.cdromReadThread, QStringLiteral("CDROM"),
QStringLiteral("ReadThread"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.cdromRegionCheck, QStringLiteral("CDROM"),
QStringLiteral("RegionCheck"));
connect(m_ui.biosPathBrowse, &QPushButton::pressed, this, &ConsoleSettingsWidget::onBrowseBIOSPathButtonClicked); connect(m_ui.biosPathBrowse, &QPushButton::pressed, this, &ConsoleSettingsWidget::onBrowseBIOSPathButtonClicked);
} }
@ -45,6 +40,6 @@ void ConsoleSettingsWidget::onBrowseBIOSPathButtonClicked()
m_ui.biosPath->setText(path); m_ui.biosPath->setText(path);
m_host_interface->putSettingValue(QStringLiteral("BIOS"), QStringLiteral("Path"), path); m_host_interface->SetStringSettingValue("BIOS", "Path", path.toUtf8().constData());
m_host_interface->applySettings(); m_host_interface->applySettings();
} }

69
src/duckstation-qt/controllersettingswidget.cpp
View File

@ -1,4 +1,5 @@
#include "controllersettingswidget.h" #include "controllersettingswidget.h"
#include "common/string_util.h"
#include "core/controller.h" #include "core/controller.h"
#include "core/settings.h" #include "core/settings.h"
#include "inputbindingwidgets.h" #include "inputbindingwidgets.h"
@ -46,7 +47,7 @@ void ControllerSettingsWidget::onProfileLoaded()
{ {
ControllerType ctype = Settings::ParseControllerTypeName( ControllerType ctype = Settings::ParseControllerTypeName(
m_host_interface m_host_interface
->GetSettingValue(QStringLiteral("Controller%1").arg(i + 1).toStdString().c_str(), ->GetStringSettingValue(QStringLiteral("Controller%1").arg(i + 1).toStdString().c_str(),
QStringLiteral("Type").toStdString().c_str()) QStringLiteral("Type").toStdString().c_str())
.c_str()) .c_str())
.value_or(ControllerType::None); .value_or(ControllerType::None);
@ -87,12 +88,10 @@ void ControllerSettingsWidget::createPortSettingsUi(int index, PortSettingsUI* u
ui->controller_type->addItem( ui->controller_type->addItem(
QString::fromUtf8(Settings::GetControllerTypeDisplayName(static_cast<ControllerType>(i)))); QString::fromUtf8(Settings::GetControllerTypeDisplayName(static_cast<ControllerType>(i))));
} }
ControllerType ctype = Settings::ParseControllerTypeName( ControllerType ctype =
m_host_interface Settings::ParseControllerTypeName(
->GetSettingValue(QStringLiteral("Controller%1").arg(index + 1).toStdString().c_str(), m_host_interface->GetStringSettingValue(TinyString::FromFormat("Controller%d", index + 1), "Type").c_str())
QStringLiteral("Type").toStdString().c_str()) .value_or(ControllerType::None);
.c_str())
.value_or(ControllerType::None);
ui->controller_type->setCurrentIndex(static_cast<int>(ctype)); ui->controller_type->setCurrentIndex(static_cast<int>(ctype));
connect(ui->controller_type, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), connect(ui->controller_type, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
[this, index]() { onControllerTypeChanged(index); }); [this, index]() { onControllerTypeChanged(index); });
@ -194,12 +193,11 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
current_column += 2; current_column += 2;
} }
const QString button_name_q = QString::fromStdString(button_name); std::string section_name = StringUtil::StdStringFromFormat("Controller%d", index + 1);
const QString section_name = QStringLiteral("Controller%1").arg(index + 1); std::string key_name = StringUtil::StdStringFromFormat("Button%s", button_name.c_str());
const QString key_name = QStringLiteral("Button%1").arg(button_name_q); QLabel* label = new QLabel(QString::fromStdString(button_name), ui->bindings_container);
QLabel* label = new QLabel(button_name_q, ui->bindings_container); InputButtonBindingWidget* button = new InputButtonBindingWidget(m_host_interface, std::move(section_name),
InputButtonBindingWidget* button = std::move(key_name), ui->bindings_container);
new InputButtonBindingWidget(m_host_interface, section_name, key_name, ui->bindings_container);
layout->addWidget(label, start_row + current_row, current_column); layout->addWidget(label, start_row + current_row, current_column);
layout->addWidget(button, start_row + current_row, current_column + 1); layout->addWidget(button, start_row + current_row, current_column + 1);
@ -232,12 +230,11 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
current_column += 2; current_column += 2;
} }
const QString axis_name_q = QString::fromStdString(axis_name); std::string section_name = StringUtil::StdStringFromFormat("Controller%d", index + 1);
const QString section_name = QStringLiteral("Controller%1").arg(index + 1); std::string key_name = StringUtil::StdStringFromFormat("Axis%s", axis_name.c_str());
const QString key_name = QStringLiteral("Axis%1").arg(axis_name_q); QLabel* label = new QLabel(QString::fromStdString(axis_name), ui->bindings_container);
QLabel* label = new QLabel(axis_name_q, ui->bindings_container); InputAxisBindingWidget* button = new InputAxisBindingWidget(m_host_interface, std::move(section_name),
InputAxisBindingWidget* button = std::move(key_name), ui->bindings_container);
new InputAxisBindingWidget(m_host_interface, section_name, key_name, ui->bindings_container);
layout->addWidget(label, start_row + current_row, current_column); layout->addWidget(label, start_row + current_row, current_column);
layout->addWidget(button, start_row + current_row, current_column + 1); layout->addWidget(button, start_row + current_row, current_column + 1);
@ -258,11 +255,10 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
{ {
layout->addWidget(QtUtils::CreateHorizontalLine(ui->widget), start_row++, 0, 1, 4); layout->addWidget(QtUtils::CreateHorizontalLine(ui->widget), start_row++, 0, 1, 4);
const QString section_name = QStringLiteral("Controller%1").arg(index + 1); std::string section_name = StringUtil::StdStringFromFormat("Controller%d", index + 1);
const QString key_name = QStringLiteral("Rumble");
QLabel* label = new QLabel(tr("Rumble"), ui->bindings_container); QLabel* label = new QLabel(tr("Rumble"), ui->bindings_container);
InputRumbleBindingWidget* button = InputRumbleBindingWidget* button =
new InputRumbleBindingWidget(m_host_interface, section_name, key_name, ui->bindings_container); new InputRumbleBindingWidget(m_host_interface, std::move(section_name), "Rumble", ui->bindings_container);
layout->addWidget(label, start_row, 0); layout->addWidget(label, start_row, 0);
layout->addWidget(button, start_row, 1); layout->addWidget(button, start_row, 1);
@ -283,8 +279,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
for (const SettingInfo& si : settings) for (const SettingInfo& si : settings)
{ {
const QString section_name = QStringLiteral("Controller%1").arg(index + 1); std::string section_name = StringUtil::StdStringFromFormat("Controller%d", index + 1);
const QString key_name = QStringLiteral("%1").arg(si.key); std::string key_name = si.key;
const QString setting_tooltip = si.description ? QString::fromUtf8(si.description) : ""; const QString setting_tooltip = si.description ? QString::fromUtf8(si.description) : "";
switch (si.type) switch (si.type)
@ -293,8 +289,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
{ {
QCheckBox* cb = new QCheckBox(tr(si.visible_name), ui->bindings_container); QCheckBox* cb = new QCheckBox(tr(si.visible_name), ui->bindings_container);
cb->setToolTip(setting_tooltip); cb->setToolTip(setting_tooltip);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, cb, section_name, key_name, SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, cb, std::move(section_name),
si.BooleanDefaultValue()); std::move(key_name), si.BooleanDefaultValue());
layout->addWidget(cb, start_row, 0, 1, 4); layout->addWidget(cb, start_row, 0, 1, 4);
start_row++; start_row++;
} }
@ -307,8 +303,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
sb->setMinimum(si.IntegerMinValue()); sb->setMinimum(si.IntegerMinValue());
sb->setMaximum(si.IntegerMaxValue()); sb->setMaximum(si.IntegerMaxValue());
sb->setSingleStep(si.IntegerStepValue()); sb->setSingleStep(si.IntegerStepValue());
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, sb, section_name, key_name, SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, sb, std::move(section_name),
si.IntegerDefaultValue()); std::move(key_name), si.IntegerDefaultValue());
layout->addWidget(new QLabel(tr(si.visible_name), ui->bindings_container), start_row, 0); layout->addWidget(new QLabel(tr(si.visible_name), ui->bindings_container), start_row, 0);
layout->addWidget(sb, start_row, 1, 1, 3); layout->addWidget(sb, start_row, 1, 1, 3);
start_row++; start_row++;
@ -322,8 +318,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
sb->setMinimum(si.FloatMinValue()); sb->setMinimum(si.FloatMinValue());
sb->setMaximum(si.FloatMaxValue()); sb->setMaximum(si.FloatMaxValue());
sb->setSingleStep(si.FloatStepValue()); sb->setSingleStep(si.FloatStepValue());
SettingWidgetBinder::BindWidgetToFloatSetting(m_host_interface, sb, section_name, key_name, SettingWidgetBinder::BindWidgetToFloatSetting(m_host_interface, sb, std::move(section_name),
si.FloatDefaultValue()); std::move(key_name), si.FloatDefaultValue());
layout->addWidget(new QLabel(tr(si.visible_name), ui->bindings_container), start_row, 0); layout->addWidget(new QLabel(tr(si.visible_name), ui->bindings_container), start_row, 0);
layout->addWidget(sb, start_row, 1, 1, 3); layout->addWidget(sb, start_row, 1, 1, 3);
start_row++; start_row++;
@ -334,8 +330,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
{ {
QLineEdit* le = new QLineEdit(ui->bindings_container); QLineEdit* le = new QLineEdit(ui->bindings_container);
le->setToolTip(setting_tooltip); le->setToolTip(setting_tooltip);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, le, section_name, key_name, SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, le, std::move(section_name),
QString::fromUtf8(si.StringDefaultValue())); std::move(key_name), si.StringDefaultValue());
layout->addWidget(new QLabel(tr(si.visible_name), ui->bindings_container), start_row, 0); layout->addWidget(new QLabel(tr(si.visible_name), ui->bindings_container), start_row, 0);
layout->addWidget(le, start_row, 1, 1, 3); layout->addWidget(le, start_row, 1, 1, 3);
start_row++; start_row++;
@ -347,8 +343,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
QLineEdit* le = new QLineEdit(ui->bindings_container); QLineEdit* le = new QLineEdit(ui->bindings_container);
le->setToolTip(setting_tooltip); le->setToolTip(setting_tooltip);
QPushButton* browse_button = new QPushButton(tr("Browse..."), ui->bindings_container); QPushButton* browse_button = new QPushButton(tr("Browse..."), ui->bindings_container);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, le, section_name, key_name, SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, le, std::move(section_name),
QString::fromUtf8(si.StringDefaultValue())); std::move(key_name), si.StringDefaultValue());
connect(browse_button, &QPushButton::clicked, [this, le]() { connect(browse_button, &QPushButton::clicked, [this, le]() {
QString path = QFileDialog::getOpenFileName(this, tr("Select File")); QString path = QFileDialog::getOpenFileName(this, tr("Select File"));
if (!path.isEmpty()) if (!path.isEmpty())
@ -382,9 +378,8 @@ void ControllerSettingsWidget::onControllerTypeChanged(int index)
if (type_index < 0 || type_index >= static_cast<int>(ControllerType::Count)) if (type_index < 0 || type_index >= static_cast<int>(ControllerType::Count))
return; return;
m_host_interface->putSettingValue( m_host_interface->SetStringSettingValue(TinyString::FromFormat("Controller%d", index + 1), "Type",
QStringLiteral("Controller%1").arg(index + 1), QStringLiteral("Type"), Settings::GetControllerTypeName(static_cast<ControllerType>(type_index)));
QString::fromStdString(Settings::GetControllerTypeName(static_cast<ControllerType>(type_index))));
m_host_interface->applySettings(); m_host_interface->applySettings();
createPortBindingSettingsUi(index, &m_port_ui[index], static_cast<ControllerType>(type_index)); createPortBindingSettingsUi(index, &m_port_ui[index], static_cast<ControllerType>(type_index));

20
src/duckstation-qt/gamelistsettingswidget.cpp
View File

@ -154,37 +154,37 @@ public:
void loadFromSettings() void loadFromSettings()
{ {
std::vector<std::string> path_list = m_host_interface->GetStringList("GameList", "Paths"); std::vector<std::string> path_list = m_host_interface->GetSettingStringList("GameList", "Paths");
for (std::string& entry : path_list) for (std::string& entry : path_list)
m_entries.push_back({QString::fromStdString(entry), false}); m_entries.push_back({QString::fromStdString(entry), false});
path_list = m_host_interface->GetStringList("GameList", "RecursivePaths"); path_list = m_host_interface->GetSettingStringList("GameList", "RecursivePaths");
for (std::string& entry : path_list) for (std::string& entry : path_list)
m_entries.push_back({QString::fromStdString(entry), true}); m_entries.push_back({QString::fromStdString(entry), true});
} }
void saveToSettings() void saveToSettings()
{ {
QStringList paths; std::vector<std::string> paths;
QStringList recursive_paths; std::vector<std::string> recursive_paths;
for (const Entry& entry : m_entries) for (const Entry& entry : m_entries)
{ {
if (entry.recursive) if (entry.recursive)
recursive_paths.push_back(entry.path); recursive_paths.push_back(entry.path.toStdString());
else else
paths.push_back(entry.path); paths.push_back(entry.path.toStdString());
} }
if (paths.empty()) if (paths.empty())
m_host_interface->removeSettingValue("GameList", "Paths"); m_host_interface->RemoveSettingValue("GameList", "Paths");
else else
m_host_interface->putSettingValue(QStringLiteral("GameList"), QStringLiteral("Paths"), paths); m_host_interface->SetStringListSettingValue("GameList", "Paths", paths);
if (recursive_paths.empty()) if (recursive_paths.empty())
m_host_interface->removeSettingValue("GameList", "RecursivePaths"); m_host_interface->RemoveSettingValue("GameList", "RecursivePaths");
else else
m_host_interface->putSettingValue(QStringLiteral("GameList"), QStringLiteral("RecursivePaths"), recursive_paths); m_host_interface->SetStringListSettingValue("GameList", "RecursivePaths", recursive_paths);
} }
private: private:

23
src/duckstation-qt/gamelistwidget.cpp
View File

@ -378,9 +378,9 @@ void GameListWidget::resizeTableViewColumnsToFit()
QtUtils::ResizeColumnsForTableView(m_table_view, {32, 80, -1, -1, 100, 60, 100}); QtUtils::ResizeColumnsForTableView(m_table_view, {32, 80, -1, -1, 100, 60, 100});
} }
static QString getColumnVisibilitySettingsKeyName(int column) static TinyString getColumnVisibilitySettingsKeyName(int column)
{ {
return QStringLiteral("Show%1").arg(GameListModel::s_column_names[column]); return TinyString::FromFormat("Show%s", GameListModel::s_column_names[column]);
} }
void GameListWidget::loadTableViewColumnVisibilitySettings() void GameListWidget::loadTableViewColumnVisibilitySettings()
@ -390,9 +390,8 @@ void GameListWidget::loadTableViewColumnVisibilitySettings()
for (int column = 0; column < GameListModel::Column_Count; column++) for (int column = 0; column < GameListModel::Column_Count; column++)
{ {
const bool visible = m_host_interface->GetBooleanSettingValue( const bool visible = m_host_interface->GetBoolSettingValue(
"GameListTableView", getColumnVisibilitySettingsKeyName(column).toStdString().c_str(), "GameListTableView", getColumnVisibilitySettingsKeyName(column), DEFAULT_VISIBILITY[column]);
DEFAULT_VISIBILITY[column]);
m_table_view->setColumnHidden(column, !visible); m_table_view->setColumnHidden(column, !visible);
} }
} }
@ -402,14 +401,14 @@ void GameListWidget::saveTableViewColumnVisibilitySettings()
for (int column = 0; column < GameListModel::Column_Count; column++) for (int column = 0; column < GameListModel::Column_Count; column++)
{ {
const bool visible = !m_table_view->isColumnHidden(column); const bool visible = !m_table_view->isColumnHidden(column);
m_host_interface->putSettingValue(QStringLiteral("GameListTableView"), getColumnVisibilitySettingsKeyName(column), visible); m_host_interface->SetBoolSettingValue("GameListTableView", getColumnVisibilitySettingsKeyName(column), visible);
} }
} }
void GameListWidget::saveTableViewColumnVisibilitySettings(int column) void GameListWidget::saveTableViewColumnVisibilitySettings(int column)
{ {
const bool visible = !m_table_view->isColumnHidden(column); const bool visible = !m_table_view->isColumnHidden(column);
m_host_interface->putSettingValue(QStringLiteral("GameListTableView"), getColumnVisibilitySettingsKeyName(column), visible); m_host_interface->SetBoolSettingValue("GameListTableView", getColumnVisibilitySettingsKeyName(column), visible);
} }
void GameListWidget::loadTableViewColumnSortSettings() void GameListWidget::loadTableViewColumnSortSettings()
@ -418,10 +417,10 @@ void GameListWidget::loadTableViewColumnSortSettings()
const bool DEFAULT_SORT_DESCENDING = false; const bool DEFAULT_SORT_DESCENDING = false;
const GameListModel::Column sort_column = const GameListModel::Column sort_column =
GameListModel::getColumnIdForName(m_host_interface->GetSettingValue("GameListTableView", "SortColumn")) GameListModel::getColumnIdForName(m_host_interface->GetStringSettingValue("GameListTableView", "SortColumn"))
.value_or(DEFAULT_SORT_COLUMN); .value_or(DEFAULT_SORT_COLUMN);
const bool sort_descending = const bool sort_descending =
m_host_interface->GetBooleanSettingValue("GameListTableView", "SortDescending", DEFAULT_SORT_DESCENDING); m_host_interface->GetBoolSettingValue("GameListTableView", "SortDescending", DEFAULT_SORT_DESCENDING);
m_table_sort_model->sort(sort_column, sort_descending ? Qt::DescendingOrder : Qt::AscendingOrder); m_table_sort_model->sort(sort_column, sort_descending ? Qt::DescendingOrder : Qt::AscendingOrder);
} }
@ -432,11 +431,11 @@ void GameListWidget::saveTableViewColumnSortSettings()
if (sort_column >= 0 && sort_column < GameListModel::Column_Count) if (sort_column >= 0 && sort_column < GameListModel::Column_Count)
{ {
m_host_interface->putSettingValue(QStringLiteral("GameListTableView"), QStringLiteral("SortColumn"), m_host_interface->SetStringSettingValue("GameListTableView", "SortColumn",
QString::fromUtf8(GameListModel::s_column_names[sort_column])); GameListModel::s_column_names[sort_column]);
} }
m_host_interface->putSettingValue(QStringLiteral("GameListTableView"), QStringLiteral("SortDescending"), sort_descending); m_host_interface->SetBoolSettingValue("GameListTableView", "SortDescending", sort_descending);
} }
const GameListEntry* GameListWidget::getSelectedEntry() const const GameListEntry* GameListWidget::getSelectedEntry() const

49
src/duckstation-qt/generalsettingswidget.cpp
View File

@ -7,33 +7,26 @@ GeneralSettingsWidget::GeneralSettingsWidget(QtHostInterface* host_interface, QW
{ {
m_ui.setupUi(this); m_ui.setupUi(this);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.pauseOnStart, QStringLiteral("Main"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.pauseOnStart, "Main", "StartPaused", false);
QStringLiteral("StartPaused")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.startFullscreen, "Main", "StartFullscreen",
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.startFullscreen, QStringLiteral("Main"), false);
QStringLiteral("StartFullscreen")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.renderToMain, "Main", "RenderToMainWindow", true);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.renderToMain, QStringLiteral("Main"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.saveStateOnExit, "Main", "SaveStateOnExit", true);
QStringLiteral("RenderToMainWindow")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.confirmPowerOff, "Main", "ConfirmPowerOff", true);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.saveStateOnExit, QStringLiteral("Main"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.loadDevicesFromSaveStates, "Main",
QStringLiteral("SaveStateOnExit")); "LoadDevicesFromSaveStates", false);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.confirmPowerOff, QStringLiteral("Main"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showOSDMessages, "Display", "ShowOSDMessages",
QStringLiteral("ConfirmPowerOff")); true);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.loadDevicesFromSaveStates, QStringLiteral("Main"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showFPS, "Display", "ShowFPS", false);
QStringLiteral("LoadDevicesFromSaveStates")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showVPS, "Display", "ShowVPS", false);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showOSDMessages, QStringLiteral("Display"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showSpeed, "Display", "ShowSpeed", false);
QStringLiteral("ShowOSDMessages"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showFPS, QStringLiteral("Display"),
QStringLiteral("ShowFPS"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showVPS, QStringLiteral("Display"),
QStringLiteral("ShowVPS"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showSpeed, QStringLiteral("Display"),
QStringLiteral("ShowSpeed"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.enableSpeedLimiter, QStringLiteral("Main"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.enableSpeedLimiter, "Main", "SpeedLimiterEnabled",
QStringLiteral("SpeedLimiterEnabled")); true);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.increaseTimerResolution, QStringLiteral("Main"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.increaseTimerResolution, "Main",
QStringLiteral("IncreaseTimerResolution")); "IncreaseTimerResolution", true);
SettingWidgetBinder::BindWidgetToNormalizedSetting(m_host_interface, m_ui.emulationSpeed, QStringLiteral("Main"), SettingWidgetBinder::BindWidgetToNormalizedSetting(m_host_interface, m_ui.emulationSpeed, "Main", "EmulationSpeed",
QStringLiteral("EmulationSpeed"), 100.0f); 100.0f, 1.0f);
connect(m_ui.enableSpeedLimiter, &QCheckBox::stateChanged, this, connect(m_ui.enableSpeedLimiter, &QCheckBox::stateChanged, this,
&GeneralSettingsWidget::onEnableSpeedLimiterStateChanged); &GeneralSettingsWidget::onEnableSpeedLimiterStateChanged);
@ -85,8 +78,8 @@ GeneralSettingsWidget::GeneralSettingsWidget(QtHostInterface* host_interface, QW
#ifdef WITH_DISCORD_PRESENCE #ifdef WITH_DISCORD_PRESENCE
{ {
QCheckBox* enableDiscordPresence = new QCheckBox(tr("Enable Discord Presence"), m_ui.groupBox_4); QCheckBox* enableDiscordPresence = new QCheckBox(tr("Enable Discord Presence"), m_ui.groupBox_4);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, enableDiscordPresence, QStringLiteral("Main"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, enableDiscordPresence, "Main",
QStringLiteral("EnableDiscordPresence")); "EnableDiscordPresence");
m_ui.formLayout_4->addWidget(enableDiscordPresence, m_ui.formLayout_4->rowCount(), 0); m_ui.formLayout_4->addWidget(enableDiscordPresence, m_ui.formLayout_4->rowCount(), 0);
dialog->registerWidgetHelp(enableDiscordPresence, "Enable Discord Presence", "Unchecked", dialog->registerWidgetHelp(enableDiscordPresence, "Enable Discord Presence", "Unchecked",
"Shows the game you are currently playing as part of your profile in Discord."); "Shows the game you are currently playing as part of your profile in Discord.");

60
src/duckstation-qt/gpusettingswidget.cpp
View File

@ -16,37 +16,29 @@ GPUSettingsWidget::GPUSettingsWidget(QtHostInterface* host_interface, QWidget* p
m_ui.setupUi(this); m_ui.setupUi(this);
setupAdditionalUi(); setupAdditionalUi();
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.renderer, QStringLiteral("GPU"), SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.renderer, "GPU", "Renderer",
QStringLiteral("Renderer"), &Settings::ParseRendererName, &Settings::ParseRendererName, &Settings::GetRendererName,
&Settings::GetRendererName, Settings::DEFAULT_GPU_RENDERER); Settings::DEFAULT_GPU_RENDERER);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.useDebugDevice, QStringLiteral("GPU"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.useDebugDevice, "GPU", "UseDebugDevice");
QStringLiteral("UseDebugDevice")); SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.displayAspectRatio, "Display", "AspectRatio",
SettingWidgetBinder::BindWidgetToEnumSetting( &Settings::ParseDisplayAspectRatio, &Settings::GetDisplayAspectRatioName,
m_host_interface, m_ui.displayAspectRatio, QStringLiteral("Display"), QStringLiteral("AspectRatio"), Settings::DEFAULT_DISPLAY_ASPECT_RATIO);
&Settings::ParseDisplayAspectRatio, &Settings::GetDisplayAspectRatioName, Settings::DEFAULT_DISPLAY_ASPECT_RATIO); SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.displayCropMode, "Display", "CropMode",
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.displayCropMode, QStringLiteral("Display"), &Settings::ParseDisplayCropMode, &Settings::GetDisplayCropModeName,
QStringLiteral("CropMode"), &Settings::ParseDisplayCropMode, Settings::DEFAULT_DISPLAY_CROP_MODE);
&Settings::GetDisplayCropModeName, Settings::DEFAULT_DISPLAY_CROP_MODE); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.displayLinearFiltering, "Display",
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.displayLinearFiltering, QStringLiteral("Display"), "LinearFiltering");
QStringLiteral("LinearFiltering")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.displayIntegerScaling, "Display",
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.displayIntegerScaling, QStringLiteral("Display"), "IntegerScaling");
QStringLiteral("IntegerScaling")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.vsync, "Display", "VSync");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.vsync, QStringLiteral("Display"), SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.resolutionScale, "GPU", "ResolutionScale");
QStringLiteral("VSync")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.trueColor, "GPU", "TrueColor");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.resolutionScale, QStringLiteral("GPU"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.scaledDithering, "GPU", "ScaledDithering");
QStringLiteral("ResolutionScale")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.disableInterlacing, "GPU", "DisableInterlacing");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.trueColor, QStringLiteral("GPU"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.forceNTSCTimings, "GPU", "ForceNTSCTimings");
QStringLiteral("TrueColor")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.linearTextureFiltering, "GPU",
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.scaledDithering, QStringLiteral("GPU"), "TextureFiltering");
QStringLiteral("ScaledDithering")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.widescreenHack, "GPU", "WidescreenHack");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.disableInterlacing, QStringLiteral("GPU"),
QStringLiteral("DisableInterlacing"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.forceNTSCTimings, QStringLiteral("GPU"),
QStringLiteral("ForceNTSCTimings"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.linearTextureFiltering, QStringLiteral("GPU"),
QStringLiteral("TextureFiltering"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.widescreenHack, QStringLiteral("GPU"),
QStringLiteral("WidescreenHack"));
connect(m_ui.resolutionScale, QOverload<int>::of(&QComboBox::currentIndexChanged), this, connect(m_ui.resolutionScale, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&GPUSettingsWidget::updateScaledDitheringEnabled); &GPUSettingsWidget::updateScaledDitheringEnabled);
@ -174,7 +166,7 @@ void GPUSettingsWidget::populateGPUAdapters()
break; break;
} }
QString current_value = QString::fromStdString(m_host_interface->GetSettingValue("GPU", "Adapter")); QString current_value = QString::fromStdString(m_host_interface->GetStringSettingValue("GPU", "Adapter"));
QSignalBlocker blocker(m_ui.adapter); QSignalBlocker blocker(m_ui.adapter);
@ -201,9 +193,9 @@ void GPUSettingsWidget::onGPUAdapterIndexChanged()
if (m_ui.adapter->currentIndex() == 0) if (m_ui.adapter->currentIndex() == 0)
{ {
// default // default
m_host_interface->removeSettingValue("GPU", "Adapter"); m_host_interface->RemoveSettingValue("GPU", "Adapter");
return; return;
} }
m_host_interface->putSettingValue(QStringLiteral("GPU"), QStringLiteral("Adapter"), m_ui.adapter->currentText()); m_host_interface->SetStringSettingValue("GPU", "Adapter", m_ui.adapter->currentText().toUtf8().constData());
} }

8
src/duckstation-qt/hotkeysettingswidget.cpp
View File

@ -61,9 +61,11 @@ void HotkeySettingsWidget::createButtons()
QGridLayout* layout = iter->layout; QGridLayout* layout = iter->layout;
const int target_row = layout->count() / 2; const int target_row = layout->count() / 2;
const QString section_name = QStringLiteral("Hotkeys"); std::string section_name("Hotkeys");
const QString key_name = QStringLiteral("%1").arg(hi.name.GetCharArray()); std::string key_name(hi.name.GetCharArray());
layout->addWidget(new QLabel(QString::fromUtf8(hi.display_name), container), target_row, 0); layout->addWidget(new QLabel(QString::fromUtf8(hi.display_name), container), target_row, 0);
layout->addWidget(new InputButtonBindingWidget(m_host_interface, section_name, key_name, container), target_row, 1); layout->addWidget(
new InputButtonBindingWidget(m_host_interface, std::move(section_name), std::move(key_name), container),
target_row, 1);
} }
} }

57
src/duckstation-qt/inputbindingwidgets.cpp
View File

@ -1,5 +1,6 @@
#include "inputbindingwidgets.h" #include "inputbindingwidgets.h"
#include "common/bitutils.h" #include "common/bitutils.h"
#include "common/string_util.h"
#include "core/settings.h" #include "core/settings.h"
#include "frontend-common/controller_interface.h" #include "frontend-common/controller_interface.h"
#include "qthostinterface.h" #include "qthostinterface.h"
@ -9,14 +10,13 @@
#include <QtGui/QMouseEvent> #include <QtGui/QMouseEvent>
#include <cmath> #include <cmath>
InputBindingWidget::InputBindingWidget(QtHostInterface* host_interface, QString section_name, QString key_name, InputBindingWidget::InputBindingWidget(QtHostInterface* host_interface, std::string section_name, std::string key_name,
QWidget* parent) QWidget* parent)
: QPushButton(parent), m_host_interface(host_interface), : QPushButton(parent), m_host_interface(host_interface), m_section_name(std::move(section_name)),
m_section_name(std::move(section_name)), m_key_name(std::move(key_name)) m_key_name(std::move(key_name))
{ {
m_current_binding_value = QString::fromStdString( m_current_binding_value = m_host_interface->GetStringSettingValue(m_section_name.c_str(), m_key_name.c_str());
m_host_interface->GetSettingValue(m_section_name.toStdString().c_str(), m_key_name.toStdString().c_str())); setText(QString::fromStdString(m_current_binding_value));
setText(m_current_binding_value);
setMinimumWidth(150); setMinimumWidth(150);
setMaximumWidth(150); setMaximumWidth(150);
@ -63,10 +63,10 @@ void InputBindingWidget::mouseReleaseEvent(QMouseEvent* e)
void InputBindingWidget::setNewBinding() void InputBindingWidget::setNewBinding()
{ {
if (m_new_binding_value.isEmpty()) if (m_new_binding_value.empty())
return; return;
m_host_interface->putSettingValue(m_section_name, m_key_name, m_new_binding_value); m_host_interface->SetStringSettingValue(m_section_name.c_str(), m_key_name.c_str(), m_new_binding_value.c_str());
m_host_interface->updateInputMap(); m_host_interface->updateInputMap();
m_current_binding_value = std::move(m_new_binding_value); m_current_binding_value = std::move(m_new_binding_value);
@ -76,16 +76,15 @@ void InputBindingWidget::setNewBinding()
void InputBindingWidget::clearBinding() void InputBindingWidget::clearBinding()
{ {
m_current_binding_value.clear(); m_current_binding_value.clear();
m_host_interface->removeSettingValue(m_section_name.toStdString().c_str(), m_key_name.toStdString().c_str()); m_host_interface->RemoveSettingValue(m_section_name.c_str(), m_key_name.c_str());
m_host_interface->updateInputMap(); m_host_interface->updateInputMap();
setText(m_current_binding_value); setText(QString::fromStdString(m_current_binding_value));
} }
void InputBindingWidget::reloadBinding() void InputBindingWidget::reloadBinding()
{ {
m_current_binding_value = QString::fromStdString(m_host_interface->GetSettingValue(m_section_name.toStdString().c_str(), m_current_binding_value = m_host_interface->GetStringSettingValue(m_section_name.c_str(), m_key_name.c_str());
m_key_name.toStdString().c_str())); setText(QString::fromStdString(m_current_binding_value));
setText(m_current_binding_value);
} }
void InputBindingWidget::onClicked() void InputBindingWidget::onClicked()
@ -126,7 +125,7 @@ void InputBindingWidget::startListeningForInput(u32 timeout_in_seconds)
void InputBindingWidget::stopListeningForInput() void InputBindingWidget::stopListeningForInput()
{ {
setText(m_current_binding_value); setText(QString::fromStdString(m_current_binding_value));
delete m_input_listen_timer; delete m_input_listen_timer;
m_input_listen_timer = nullptr; m_input_listen_timer = nullptr;
@ -139,9 +138,9 @@ void InputBindingWidget::stopListeningForInput()
m_is_binding_all = false; m_is_binding_all = false;
} }
InputButtonBindingWidget::InputButtonBindingWidget(QtHostInterface* host_interface, QString section_name, InputButtonBindingWidget::InputButtonBindingWidget(QtHostInterface* host_interface, std::string section_name,
QString key_name, QWidget* parent) std::string key_name, QWidget* parent)
: InputBindingWidget(host_interface, section_name, key_name, parent) : InputBindingWidget(host_interface, std::move(section_name), std::move(key_name), parent)
{ {
} }
@ -166,7 +165,7 @@ bool InputButtonBindingWidget::eventFilter(QObject* watched, QEvent* event)
{ {
QString binding = QtUtils::KeyEventToString(static_cast<QKeyEvent*>(event)); QString binding = QtUtils::KeyEventToString(static_cast<QKeyEvent*>(event));
if (!binding.isEmpty()) if (!binding.isEmpty())
m_new_binding_value = QStringLiteral("Keyboard/%1").arg(binding); m_new_binding_value = QStringLiteral("Keyboard/%1").arg(binding).toStdString();
return true; return true;
} }
@ -174,7 +173,7 @@ bool InputButtonBindingWidget::eventFilter(QObject* watched, QEvent* event)
{ {
const u32 button_mask = static_cast<u32>(static_cast<const QMouseEvent*>(event)->button()); const u32 button_mask = static_cast<u32>(static_cast<const QMouseEvent*>(event)->button());
const u32 button_index = (button_mask == 0u) ? 0 : CountTrailingZeros(button_mask); const u32 button_index = (button_mask == 0u) ? 0 : CountTrailingZeros(button_mask);
m_new_binding_value = QStringLiteral("Mouse/Button%1").arg(button_index + 1); m_new_binding_value = StringUtil::StdStringFromFormat("Mouse/Button%d", button_index + 1);
setNewBinding(); setNewBinding();
stopListeningForInput(); stopListeningForInput();
return true; return true;
@ -224,14 +223,14 @@ void InputButtonBindingWidget::unhookControllerInput()
void InputButtonBindingWidget::bindToControllerAxis(int controller_index, int axis_index, bool positive) void InputButtonBindingWidget::bindToControllerAxis(int controller_index, int axis_index, bool positive)
{ {
m_new_binding_value = m_new_binding_value =
QStringLiteral("Controller%1/%2Axis%3").arg(controller_index).arg(positive ? '+' : '-').arg(axis_index); StringUtil::StdStringFromFormat("Controller%d/%cAxis%d", controller_index, positive ? '+' : '-', axis_index);
setNewBinding(); setNewBinding();
stopListeningForInput(); stopListeningForInput();
} }
void InputButtonBindingWidget::bindToControllerButton(int controller_index, int button_index) void InputButtonBindingWidget::bindToControllerButton(int controller_index, int button_index)
{ {
m_new_binding_value = QStringLiteral("Controller%1/Button%2").arg(controller_index).arg(button_index); m_new_binding_value = StringUtil::StdStringFromFormat("Controller%d/Button%d", controller_index, button_index);
setNewBinding(); setNewBinding();
stopListeningForInput(); stopListeningForInput();
} }
@ -248,9 +247,9 @@ void InputButtonBindingWidget::stopListeningForInput()
InputBindingWidget::stopListeningForInput(); InputBindingWidget::stopListeningForInput();
} }
InputAxisBindingWidget::InputAxisBindingWidget(QtHostInterface* host_interface, QString section_name, QString key_name, InputAxisBindingWidget::InputAxisBindingWidget(QtHostInterface* host_interface, std::string section_name,
QWidget* parent) std::string key_name, QWidget* parent)
: InputBindingWidget(host_interface, section_name, key_name, parent) : InputBindingWidget(host_interface, std::move(section_name), std::move(key_name), parent)
{ {
} }
@ -293,7 +292,7 @@ void InputAxisBindingWidget::unhookControllerInput()
void InputAxisBindingWidget::bindToControllerAxis(int controller_index, int axis_index) void InputAxisBindingWidget::bindToControllerAxis(int controller_index, int axis_index)
{ {
m_new_binding_value = QStringLiteral("Controller%1/Axis%2").arg(controller_index).arg(axis_index); m_new_binding_value = StringUtil::StdStringFromFormat("Controller%d/Axis%d", controller_index, axis_index);
setNewBinding(); setNewBinding();
stopListeningForInput(); stopListeningForInput();
} }
@ -310,9 +309,9 @@ void InputAxisBindingWidget::stopListeningForInput()
InputBindingWidget::stopListeningForInput(); InputBindingWidget::stopListeningForInput();
} }
InputRumbleBindingWidget::InputRumbleBindingWidget(QtHostInterface* host_interface, QString section_name, InputRumbleBindingWidget::InputRumbleBindingWidget(QtHostInterface* host_interface, std::string section_name,
QString key_name, QWidget* parent) std::string key_name, QWidget* parent)
: InputBindingWidget(host_interface, section_name, key_name, parent) : InputBindingWidget(host_interface, std::move(section_name), std::move(key_name), parent)
{ {
} }
@ -350,7 +349,7 @@ void InputRumbleBindingWidget::unhookControllerInput()
void InputRumbleBindingWidget::bindToControllerRumble(int controller_index) void InputRumbleBindingWidget::bindToControllerRumble(int controller_index)
{ {
m_new_binding_value = QStringLiteral("Controller%1").arg(controller_index); m_new_binding_value = StringUtil::StdStringFromFormat("Controller%d", controller_index);
setNewBinding(); setNewBinding();
stopListeningForInput(); stopListeningForInput();
} }

16
src/duckstation-qt/inputbindingwidgets.h
View File

@ -11,7 +11,7 @@ class InputBindingWidget : public QPushButton
Q_OBJECT Q_OBJECT
public: public:
InputBindingWidget(QtHostInterface* host_interface, QString section_name, QString key_name, QWidget* parent); InputBindingWidget(QtHostInterface* host_interface, std::string section_name, std::string key_name, QWidget* parent);
~InputBindingWidget(); ~InputBindingWidget();
ALWAYS_INLINE InputBindingWidget* getNextWidget() const { return m_next_widget; } ALWAYS_INLINE InputBindingWidget* getNextWidget() const { return m_next_widget; }
@ -43,10 +43,10 @@ protected:
void setNewBinding(); void setNewBinding();
QtHostInterface* m_host_interface; QtHostInterface* m_host_interface;
QString m_section_name; std::string m_section_name;
QString m_key_name; std::string m_key_name;
QString m_current_binding_value; std::string m_current_binding_value;
QString m_new_binding_value; std::string m_new_binding_value;
QTimer* m_input_listen_timer = nullptr; QTimer* m_input_listen_timer = nullptr;
u32 m_input_listen_remaining_seconds = 0; u32 m_input_listen_remaining_seconds = 0;
@ -59,7 +59,7 @@ class InputButtonBindingWidget : public InputBindingWidget
Q_OBJECT Q_OBJECT
public: public:
InputButtonBindingWidget(QtHostInterface* host_interface, QString section_name, QString key_name, QWidget* parent); InputButtonBindingWidget(QtHostInterface* host_interface, std::string section_name, std::string key_name, QWidget* parent);
~InputButtonBindingWidget(); ~InputButtonBindingWidget();
protected: protected:
@ -81,7 +81,7 @@ class InputAxisBindingWidget : public InputBindingWidget
Q_OBJECT Q_OBJECT
public: public:
InputAxisBindingWidget(QtHostInterface* host_interface, QString section_name, QString key_name, QWidget* parent); InputAxisBindingWidget(QtHostInterface* host_interface, std::string section_name, std::string key_name, QWidget* parent);
~InputAxisBindingWidget(); ~InputAxisBindingWidget();
private Q_SLOTS: private Q_SLOTS:
@ -99,7 +99,7 @@ class InputRumbleBindingWidget : public InputBindingWidget
Q_OBJECT Q_OBJECT
public: public:
InputRumbleBindingWidget(QtHostInterface* host_interface, QString section_name, QString key_name, QWidget* parent); InputRumbleBindingWidget(QtHostInterface* host_interface, std::string section_name, std::string key_name, QWidget* parent);
~InputRumbleBindingWidget(); ~InputRumbleBindingWidget();
private Q_SLOTS: private Q_SLOTS:

45
src/duckstation-qt/mainwindow.cpp
View File

@ -337,7 +337,7 @@ void MainWindow::onGameListEntryDoubleClicked(const GameListEntry* entry)
QString path = QString::fromStdString(entry->path); QString path = QString::fromStdString(entry->path);
if (!m_emulation_running) if (!m_emulation_running)
{ {
if (!entry->code.empty() && m_host_interface->GetBooleanSettingValue("General", "SaveStateOnExit", true)) if (!entry->code.empty() && m_host_interface->GetBoolSettingValue("General", "SaveStateOnExit", true))
{ {
m_host_interface->resumeSystemFromState(path, true); m_host_interface->resumeSystemFromState(path, true);
} }
@ -433,8 +433,7 @@ void MainWindow::setupAdditionalUi()
QAction* action = m_ui.menuCPUExecutionMode->addAction(tr(Settings::GetCPUExecutionModeDisplayName(mode))); QAction* action = m_ui.menuCPUExecutionMode->addAction(tr(Settings::GetCPUExecutionModeDisplayName(mode)));
action->setCheckable(true); action->setCheckable(true);
connect(action, &QAction::triggered, [this, mode]() { connect(action, &QAction::triggered, [this, mode]() {
m_host_interface->putSettingValue(QStringLiteral("CPU"), QStringLiteral("ExecutionMode"), m_host_interface->SetStringSettingValue("CPU", "ExecutionMode", Settings::GetCPUExecutionModeName(mode));
QString(Settings::GetCPUExecutionModeName(mode)));
m_host_interface->applySettings(); m_host_interface->applySettings();
updateDebugMenuCPUExecutionMode(); updateDebugMenuCPUExecutionMode();
}); });
@ -447,8 +446,7 @@ void MainWindow::setupAdditionalUi()
QAction* action = m_ui.menuRenderer->addAction(tr(Settings::GetRendererDisplayName(renderer))); QAction* action = m_ui.menuRenderer->addAction(tr(Settings::GetRendererDisplayName(renderer)));
action->setCheckable(true); action->setCheckable(true);
connect(action, &QAction::triggered, [this, renderer]() { connect(action, &QAction::triggered, [this, renderer]() {
m_host_interface->putSettingValue(QStringLiteral("GPU"), QStringLiteral("Renderer"), m_host_interface->SetStringSettingValue("GPU", "Renderer", Settings::GetRendererName(renderer));
QString(Settings::GetRendererName(renderer)));
m_host_interface->applySettings(); m_host_interface->applySettings();
updateDebugMenuGPURenderer(); updateDebugMenuGPURenderer();
}); });
@ -607,28 +605,25 @@ void MainWindow::connectSignals()
m_host_interface->populateSaveStateMenus(nullptr, m_ui.menuLoadState, m_ui.menuSaveState); m_host_interface->populateSaveStateMenus(nullptr, m_ui.menuLoadState, m_ui.menuSaveState);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugDumpCPUtoVRAMCopies, SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugDumpCPUtoVRAMCopies, "Debug",
QStringLiteral("Debug"), QStringLiteral("DumpCPUToVRAMCopies")); "DumpCPUToVRAMCopies");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugDumpVRAMtoCPUCopies, SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugDumpVRAMtoCPUCopies, "Debug",
QStringLiteral("Debug"), QStringLiteral("DumpVRAMToCPUCopies")); "DumpVRAMToCPUCopies");
connect(m_ui.actionDumpAudio, &QAction::toggled, [this](bool checked) { connect(m_ui.actionDumpAudio, &QAction::toggled, [this](bool checked) {
if (checked) if (checked)
m_host_interface->startDumpingAudio(); m_host_interface->startDumpingAudio();
else else
m_host_interface->stopDumpingAudio(); m_host_interface->stopDumpingAudio();
}); });
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowVRAM, QStringLiteral("Debug"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowVRAM, "Debug", "ShowVRAM");
QStringLiteral("ShowVRAM")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowGPUState, "Debug", "ShowGPUState");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowGPUState, QStringLiteral("Debug"), SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowCDROMState, "Debug",
QStringLiteral("ShowGPUState")); "ShowCDROMState");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowCDROMState, SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowSPUState, "Debug", "ShowSPUState");
QStringLiteral("Debug"), QStringLiteral("ShowCDROMState")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowTimersState, "Debug",
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowSPUState, QStringLiteral("Debug"), "ShowTimersState");
QStringLiteral("ShowSPUState")); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowMDECState, "Debug",
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowTimersState, "ShowMDECState");
QStringLiteral("Debug"), QStringLiteral("ShowTimersState"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowMDECState, QStringLiteral("Debug"),
QStringLiteral("ShowMDECState"));
addThemeToMenu(tr("Default"), QStringLiteral("default")); addThemeToMenu(tr("Default"), QStringLiteral("default"));
addThemeToMenu(tr("DarkFusion"), QStringLiteral("darkfusion")); addThemeToMenu(tr("DarkFusion"), QStringLiteral("darkfusion"));
@ -645,13 +640,13 @@ void MainWindow::addThemeToMenu(const QString& name, const QString& key)
void MainWindow::setTheme(const QString& theme) void MainWindow::setTheme(const QString& theme)
{ {
m_host_interface->putSettingValue(QStringLiteral("UI"), QStringLiteral("Theme"), theme); m_host_interface->SetStringSettingValue("UI", "Theme", theme.toUtf8().constData());
updateTheme(); updateTheme();
} }
void MainWindow::updateTheme() void MainWindow::updateTheme()
{ {
QString theme = QString::fromStdString(m_host_interface->GetSettingValue("UI", "Theme", "default")); QString theme = QString::fromStdString(m_host_interface->GetStringSettingValue("UI", "Theme", "default"));
if (theme == QStringLiteral("qdarkstyle")) if (theme == QStringLiteral("qdarkstyle"))
{ {
qApp->setStyle(m_unthemed_style_name); qApp->setStyle(m_unthemed_style_name);
@ -742,7 +737,7 @@ void MainWindow::doSettings(SettingsDialog::Category category)
void MainWindow::updateDebugMenuCPUExecutionMode() void MainWindow::updateDebugMenuCPUExecutionMode()
{ {
std::optional<CPUExecutionMode> current_mode = std::optional<CPUExecutionMode> current_mode =
Settings::ParseCPUExecutionMode(m_host_interface->GetSettingValue("CPU", "ExecutionMode").c_str()); Settings::ParseCPUExecutionMode(m_host_interface->GetStringSettingValue("CPU", "ExecutionMode").c_str());
if (!current_mode.has_value()) if (!current_mode.has_value())
return; return;
@ -759,7 +754,7 @@ void MainWindow::updateDebugMenuGPURenderer()
{ {
// update the menu with the new selected renderer // update the menu with the new selected renderer
std::optional<GPURenderer> current_renderer = std::optional<GPURenderer> current_renderer =
Settings::ParseRendererName(m_host_interface->GetSettingValue("GPU", "Renderer").c_str()); Settings::ParseRendererName(m_host_interface->GetStringSettingValue("GPU", "Renderer").c_str());
if (!current_renderer.has_value()) if (!current_renderer.has_value())
return; return;

7
src/duckstation-qt/memorycardsettingswidget.cpp
View File

@ -1,4 +1,5 @@
#include "memorycardsettingswidget.h" #include "memorycardsettingswidget.h"
#include "common/string_util.h"
#include "core/controller.h" #include "core/controller.h"
#include "core/settings.h" #include "core/settings.h"
#include "inputbindingwidgets.h" #include "inputbindingwidgets.h"
@ -65,15 +66,15 @@ void MemoryCardSettingsWidget::createPortSettingsUi(int index, PortSettingsUI* u
const MemoryCardType default_value = (index == 0) ? MemoryCardType::PerGameTitle : MemoryCardType::None; const MemoryCardType default_value = (index == 0) ? MemoryCardType::PerGameTitle : MemoryCardType::None;
SettingWidgetBinder::BindWidgetToEnumSetting( SettingWidgetBinder::BindWidgetToEnumSetting(
m_host_interface, ui->memory_card_type, QStringLiteral("MemoryCards"), QStringLiteral("Card%1Type").arg(index + 1), m_host_interface, ui->memory_card_type, "MemoryCards", StringUtil::StdStringFromFormat("Card%dType", index + 1),
&Settings::ParseMemoryCardTypeName, &Settings::GetMemoryCardTypeName, default_value); &Settings::ParseMemoryCardTypeName, &Settings::GetMemoryCardTypeName, default_value);
ui->layout->addWidget(new QLabel(tr("Memory Card Type:"), ui->container)); ui->layout->addWidget(new QLabel(tr("Memory Card Type:"), ui->container));
ui->layout->addWidget(ui->memory_card_type); ui->layout->addWidget(ui->memory_card_type);
QHBoxLayout* memory_card_layout = new QHBoxLayout(); QHBoxLayout* memory_card_layout = new QHBoxLayout();
ui->memory_card_path = new QLineEdit(ui->container); ui->memory_card_path = new QLineEdit(ui->container);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, ui->memory_card_path, SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, ui->memory_card_path, "MemoryCards",
QStringLiteral("MemoryCards"), QStringLiteral("Card%1Path").arg(index + 1)); StringUtil::StdStringFromFormat("Card%dPath", index + 1));
memory_card_layout->addWidget(ui->memory_card_path); memory_card_layout->addWidget(ui->memory_card_path);
QPushButton* memory_card_path_browse = new QPushButton(tr("Browse..."), ui->container); QPushButton* memory_card_path_browse = new QPushButton(tr("Browse..."), ui->container);

57
src/duckstation-qt/qthostinterface.cpp
View File

@ -123,59 +123,68 @@ bool QtHostInterface::parseCommandLineParameters(int argc, char* argv[],
return CommonHostInterface::ParseCommandLineParameters(argc, argv, out_boot_params); return CommonHostInterface::ParseCommandLineParameters(argc, argv, out_boot_params);
} }
std::string QtHostInterface::GetSettingValue(const char* section, const char* key, const char* default_value /*= ""*/) std::string QtHostInterface::GetStringSettingValue(const char* section, const char* key, const char* default_value /*= ""*/)
{ {
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex); std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
return m_settings_interface->GetStringValue(section, key, default_value); return m_settings_interface->GetStringValue(section, key, default_value);
} }
std::vector<std::string> QtHostInterface::GetStringList(const char* section, const char* key) bool QtHostInterface::GetBoolSettingValue(const char* section, const char* key, bool default_value /* = false */)
{
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
return m_settings_interface->GetBoolValue(section, key, default_value);
}
int QtHostInterface::GetIntSettingValue(const char* section, const char* key, int default_value /* = 0 */)
{
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
return m_settings_interface->GetIntValue(section, key, default_value);
}
float QtHostInterface::GetFloatSettingValue(const char* section, const char* key, float default_value /* = 0.0f */)
{
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
return m_settings_interface->GetFloatValue(section, key, default_value);
}
std::vector<std::string> QtHostInterface::GetSettingStringList(const char* section, const char* key)
{ {
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex); std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
return m_settings_interface->GetStringList(section, key); return m_settings_interface->GetStringList(section, key);
} }
void QtHostInterface::putSettingValue(const QString& section, const QString& key, const bool& value) void QtHostInterface::SetBoolSettingValue(const char* section, const char* key, bool value)
{ {
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex); std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
m_settings_interface->SetBoolValue(section.toStdString().c_str(), key.toStdString().c_str(), value); m_settings_interface->SetBoolValue(section, key, value);
} }
void QtHostInterface::putSettingValue(const QString& section, const QString& key, const int& value) void QtHostInterface::SetIntSettingValue(const char* section, const char* key, int value)
{ {
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex); std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
m_settings_interface->SetIntValue(section.toStdString().c_str(), key.toStdString().c_str(), value); m_settings_interface->SetIntValue(section, key, value);
} }
void QtHostInterface::putSettingValue(const QString& section, const QString& key, const float& value) void QtHostInterface::SetFloatSettingValue(const char* section, const char* key, float value)
{ {
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex); std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
m_settings_interface->SetFloatValue(section.toStdString().c_str(), key.toStdString().c_str(), value); m_settings_interface->SetFloatValue(section, key, value);
} }
void QtHostInterface::putSettingValue(const QString& section, const QString& key, const QString& value) void QtHostInterface::SetStringSettingValue(const char* section, const char* key, const char* value)
{ {
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex); std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
m_settings_interface->SetStringValue(section.toStdString().c_str(), key.toStdString().c_str(), m_settings_interface->SetStringValue(section, key, value);
value.toStdString().c_str());
} }
void QtHostInterface::putSettingValue(const QString& section, const QString& key, const QStringList& list) void QtHostInterface::SetStringListSettingValue(const char* section, const char* key,
{ const std::vector<std::string>& values)
{
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex); std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
m_settings_interface->SetStringList(section, key, values);
std::vector<std::string> str_list;
for (const QString& qstr : list)
str_list.push_back(qstr.toStdString());
std::vector<std::string_view> strview_list;
for (const std::string& str : str_list)
strview_list.push_back(str);
m_settings_interface->SetStringList(section.toStdString().c_str(), key.toStdString().c_str(), strview_list);
} }
void QtHostInterface::removeSettingValue(const char* section, const char* key) void QtHostInterface::RemoveSettingValue(const char* section, const char* key)
{ {
std::lock_guard<std::recursive_mutex> guard(m_settings_mutex); std::lock_guard<std::recursive_mutex> guard(m_settings_mutex);
m_settings_interface->DeleteValue(section, key); m_settings_interface->DeleteValue(section, key);

21
src/duckstation-qt/qthostinterface.h
View File

@ -5,8 +5,8 @@
#include "frontend-common/common_host_interface.h" #include "frontend-common/common_host_interface.h"
#include <QtCore/QByteArray> #include <QtCore/QByteArray>
#include <QtCore/QObject> #include <QtCore/QObject>
#include <QtCore/QString>
#include <QtCore/QSettings> #include <QtCore/QSettings>
#include <QtCore/QString>
#include <QtCore/QThread> #include <QtCore/QThread>
#include <atomic> #include <atomic>
#include <functional> #include <functional>
@ -51,14 +51,17 @@ public:
bool parseCommandLineParameters(int argc, char* argv[], std::unique_ptr<SystemBootParameters>* out_boot_params); bool parseCommandLineParameters(int argc, char* argv[], std::unique_ptr<SystemBootParameters>* out_boot_params);
/// Thread-safe settings access. /// Thread-safe settings access.
std::string GetSettingValue(const char* section, const char* key, const char* default_value = "") override; std::string GetStringSettingValue(const char* section, const char* key, const char* default_value = "") override;
std::vector<std::string> GetStringList(const char* section, const char* key); bool GetBoolSettingValue(const char* section, const char* key, bool default_value = false) override;
void putSettingValue(const QString& section, const QString& key, const bool& value); int GetIntSettingValue(const char* section, const char* key, int default_value = 0) override;
void putSettingValue(const QString& section, const QString& key, const int& value); float GetFloatSettingValue(const char* section, const char* key, float default_value = 0.0f) override;
void putSettingValue(const QString& section, const QString& key, const float& value); std::vector<std::string> GetSettingStringList(const char* section, const char* key);
void putSettingValue(const QString& section, const QString& key, const QString& value); void SetBoolSettingValue(const char* section, const char* key, bool value);
void putSettingValue(const QString& section, const QString& key, const QStringList& list); void SetIntSettingValue(const char* section, const char* key, int value);
void removeSettingValue(const char* section, const char* key); void SetFloatSettingValue(const char* section, const char* key, float value);
void SetStringSettingValue(const char* section, const char* key, const char* value);
void SetStringListSettingValue(const char* section, const char* key, const std::vector<std::string>& values);
void RemoveSettingValue(const char* section, const char* key);
ALWAYS_INLINE const GameList* getGameList() const { return m_game_list.get(); } ALWAYS_INLINE const GameList* getGameList() const { return m_game_list.get(); }
ALWAYS_INLINE GameList* getGameList() { return m_game_list.get(); } ALWAYS_INLINE GameList* getGameList() { return m_game_list.get(); }

67
src/duckstation-qt/settingwidgetbinder.h
View File

@ -200,116 +200,111 @@ struct SettingAccessor<QAction>
/// Binds a widget's value to a setting, updating it when the value changes. /// Binds a widget's value to a setting, updating it when the value changes.
template<typename WidgetType> template<typename WidgetType>
void BindWidgetToBoolSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name, void BindWidgetToBoolSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
const QString& key_name, bool default_value = false) bool default_value = false)
{ {
using Accessor = SettingAccessor<WidgetType>; using Accessor = SettingAccessor<WidgetType>;
bool value = bool value = hi->GetBoolSettingValue(section.c_str(), key.c_str(), default_value);
hi->GetBooleanSettingValue(section_name.toStdString().c_str(), key_name.toStdString().c_str(), default_value);
Accessor::setBoolValue(widget, value); Accessor::setBoolValue(widget, value);
Accessor::connectValueChanged(widget, [hi, widget, section_name, key_name]() { Accessor::connectValueChanged(widget, [hi, widget, section, key]() {
const bool new_value = Accessor::getBoolValue(widget); const bool new_value = Accessor::getBoolValue(widget);
hi->putSettingValue(section_name, key_name, new_value); hi->SetBoolSettingValue(section.c_str(), key.c_str(), new_value);
hi->applySettings(); hi->applySettings();
}); });
} }
template<typename WidgetType> template<typename WidgetType>
void BindWidgetToIntSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name, void BindWidgetToIntSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
const QString& key_name, int default_value = 0) int default_value = 0)
{ {
using Accessor = SettingAccessor<WidgetType>; using Accessor = SettingAccessor<WidgetType>;
s32 value = hi->GetIntegerSettingValue(section_name.toStdString().c_str(), key_name.toStdString().c_str(), s32 value = hi->GetIntSettingValue(section.c_str(), key.c_str(), static_cast<s32>(default_value));
static_cast<s32>(default_value));
Accessor::setIntValue(widget, static_cast<int>(value)); Accessor::setIntValue(widget, static_cast<int>(value));
Accessor::connectValueChanged(widget, [hi, widget, section_name, key_name]() { Accessor::connectValueChanged(widget, [hi, widget, section, key]() {
const int new_value = Accessor::getIntValue(widget); const int new_value = Accessor::getIntValue(widget);
hi->putSettingValue(section_name, key_name, new_value); hi->SetIntSettingValue(section.c_str(), key.c_str(), new_value);
hi->applySettings(); hi->applySettings();
}); });
} }
template<typename WidgetType> template<typename WidgetType>
void BindWidgetToFloatSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name, void BindWidgetToFloatSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
const QString& key_name, float default_value = 0.0f) float default_value = 0.0f)
{ {
using Accessor = SettingAccessor<WidgetType>; using Accessor = SettingAccessor<WidgetType>;
float value = float value = hi->GetFloatSettingValue(section.c_str(), key.c_str(), default_value);
hi->GetFloatSettingValue(section_name.toStdString().c_str(), key_name.toStdString().c_str(), default_value);
Accessor::setFloatValue(widget, value); Accessor::setFloatValue(widget, value);
Accessor::connectValueChanged(widget, [hi, widget, section_name, key_name]() { Accessor::connectValueChanged(widget, [hi, widget, section, key]() {
const float new_value = Accessor::getFloatValue(widget); const float new_value = Accessor::getFloatValue(widget);
hi->putSettingValue(section_name, key_name, new_value); hi->SetFloatSettingValue(section.c_str(), key.c_str(), new_value);
hi->applySettings(); hi->applySettings();
}); });
} }
template<typename WidgetType> template<typename WidgetType>
void BindWidgetToNormalizedSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name, void BindWidgetToNormalizedSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
const QString& key_name, float range, float default_value = 0.0f) float range, float default_value = 0.0f)
{ {
using Accessor = SettingAccessor<WidgetType>; using Accessor = SettingAccessor<WidgetType>;
float value = float value = hi->GetFloatSettingValue(section.c_str(), key.c_str(), default_value);
hi->GetFloatSettingValue(section_name.toStdString().c_str(), key_name.toStdString().c_str(), default_value);
Accessor::setIntValue(widget, static_cast<int>(value * range)); Accessor::setIntValue(widget, static_cast<int>(value * range));
Accessor::connectValueChanged(widget, [hi, widget, section_name, key_name, range]() { Accessor::connectValueChanged(widget, [hi, widget, section, key, range]() {
const float new_value = (static_cast<float>(Accessor::getIntValue(widget)) / range); const float new_value = (static_cast<float>(Accessor::getIntValue(widget)) / range);
hi->putSettingValue(section_name, key_name, new_value); hi->SetFloatSettingValue(section.c_str(), key.c_str(), new_value);
hi->applySettings(); hi->applySettings();
}); });
} }
template<typename WidgetType> template<typename WidgetType>
void BindWidgetToStringSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name, void BindWidgetToStringSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
const QString& key_name, const QString& default_value = QString()) std::string default_value = std::string())
{ {
using Accessor = SettingAccessor<WidgetType>; using Accessor = SettingAccessor<WidgetType>;
std::string value = hi->GetSettingValue(section_name.toStdString().c_str(), key_name.toStdString().c_str(), std::string value = hi->GetStringSettingValue(section.c_str(), key.c_str(), default_value.c_str());
default_value.toStdString().c_str());
Accessor::setStringValue(widget, QString::fromStdString(value)); Accessor::setStringValue(widget, QString::fromStdString(value));
Accessor::connectValueChanged(widget, [hi, widget, section_name, key_name]() { Accessor::connectValueChanged(widget, [hi, widget, section, key]() {
const QString new_value = Accessor::getStringValue(widget); const QString new_value = Accessor::getStringValue(widget);
hi->putSettingValue(section_name, key_name, new_value); hi->SetStringSettingValue(section.c_str(), key.c_str(), new_value.toUtf8().constData());
hi->applySettings(); hi->applySettings();
}); });
} }
template<typename WidgetType, typename DataType> template<typename WidgetType, typename DataType>
void BindWidgetToEnumSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name, void BindWidgetToEnumSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
const QString& key_name, std::optional<DataType> (*from_string_function)(const char* str), std::optional<DataType> (*from_string_function)(const char* str),
const char* (*to_string_function)(DataType value), DataType default_value) const char* (*to_string_function)(DataType value), DataType default_value)
{ {
using Accessor = SettingAccessor<WidgetType>; using Accessor = SettingAccessor<WidgetType>;
using UnderlyingType = std::underlying_type_t<DataType>; using UnderlyingType = std::underlying_type_t<DataType>;
// TODO: Clean this up? // TODO: Clean this up?
const std::string old_setting_string_value = hi->GetSettingValue( const std::string old_setting_string_value =
section_name.toStdString().c_str(), key_name.toStdString().c_str(), to_string_function(default_value)); hi->GetStringSettingValue(section.c_str(), key.c_str(), to_string_function(default_value));
const std::optional<DataType> old_setting_value = from_string_function(old_setting_string_value.c_str()); const std::optional<DataType> old_setting_value = from_string_function(old_setting_string_value.c_str());
if (old_setting_value.has_value()) if (old_setting_value.has_value())
Accessor::setIntValue(widget, static_cast<int>(static_cast<UnderlyingType>(old_setting_value.value()))); Accessor::setIntValue(widget, static_cast<int>(static_cast<UnderlyingType>(old_setting_value.value())));
else else
Accessor::setIntValue(widget, static_cast<int>(static_cast<UnderlyingType>(default_value))); Accessor::setIntValue(widget, static_cast<int>(static_cast<UnderlyingType>(default_value)));
Accessor::connectValueChanged(widget, [hi, widget, section_name, key_name, to_string_function]() { Accessor::connectValueChanged(widget, [hi, widget, section, key, to_string_function]() {
const DataType value = static_cast<DataType>(static_cast<UnderlyingType>(Accessor::getIntValue(widget))); const DataType value = static_cast<DataType>(static_cast<UnderlyingType>(Accessor::getIntValue(widget)));
const char* string_value = to_string_function(value); const char* string_value = to_string_function(value);
hi->putSettingValue(section_name, key_name, QString::fromLocal8Bit(string_value)); hi->SetStringSettingValue(section.c_str(), key.c_str(), string_value);
hi->applySettings(); hi->applySettings();
}); });
} }

18
src/duckstation-sdl/sdl_host_interface.cpp
View File

@ -424,11 +424,27 @@ void SDLHostInterface::Shutdown()
CommonHostInterface::Shutdown(); CommonHostInterface::Shutdown();
} }
std::string SDLHostInterface::GetSettingValue(const char* section, const char* key, const char* default_value /*= ""*/) std::string SDLHostInterface::GetStringSettingValue(const char* section, const char* key,
const char* default_value /*= ""*/)
{ {
return m_settings_interface->GetStringValue(section, key, default_value); return m_settings_interface->GetStringValue(section, key, default_value);
} }
bool SDLHostInterface::GetBoolSettingValue(const char* section, const char* key, bool default_value /* = false */)
{
return m_settings_interface->GetBoolValue(section, key, default_value);
}
int SDLHostInterface::GetIntSettingValue(const char* section, const char* key, int default_value /* = 0 */)
{
return m_settings_interface->GetIntValue(section, key, default_value);
}
float SDLHostInterface::GetFloatSettingValue(const char* section, const char* key, float default_value /* = 0.0f */)
{
return m_settings_interface->GetFloatValue(section, key, default_value);
}
void SDLHostInterface::LoadSettings() void SDLHostInterface::LoadSettings()
{ {
// Settings need to be loaded prior to creating the window for OpenGL bits. // Settings need to be loaded prior to creating the window for OpenGL bits.

5
src/duckstation-sdl/sdl_host_interface.h
View File

@ -34,7 +34,10 @@ public:
bool Initialize() override; bool Initialize() override;
void Shutdown() override; void Shutdown() override;
std::string GetSettingValue(const char* section, const char* key, const char* default_value = "") override; std::string GetStringSettingValue(const char* section, const char* key, const char* default_value = "") override;
bool GetBoolSettingValue(const char* section, const char* key, bool default_value = false) override;
int GetIntSettingValue(const char* section, const char* key, int default_value = 0) override;
float GetFloatSettingValue(const char* section, const char* key, float default_value = 0.0f) override;
void Run(); void Run();

7
src/frontend-common/ini_settings_interface.cpp
View File

@ -98,14 +98,13 @@ std::vector<std::string> INISettingsInterface::GetStringList(const char* section
return ret; return ret;
} }
void INISettingsInterface::SetStringList(const char* section, const char* key, void INISettingsInterface::SetStringList(const char* section, const char* key, const std::vector<std::string>& items)
const std::vector<std::string_view>& items)
{ {
m_dirty = true; m_dirty = true;
m_ini.Delete(section, key); m_ini.Delete(section, key);
for (const std::string_view& sv : items) for (const std::string& sv : items)
m_ini.SetValue(section, key, std::string(sv).c_str(), nullptr, false); m_ini.SetValue(section, key, sv.c_str(), nullptr, false);
} }
bool INISettingsInterface::RemoveFromStringList(const char* section, const char* key, const char* item) bool INISettingsInterface::RemoveFromStringList(const char* section, const char* key, const char* item)

2
src/frontend-common/ini_settings_interface.h
View File

@ -25,7 +25,7 @@ public:
void DeleteValue(const char* section, const char* key) override; void DeleteValue(const char* section, const char* key) override;
std::vector<std::string> GetStringList(const char* section, const char* key) override; std::vector<std::string> GetStringList(const char* section, const char* key) override;
void SetStringList(const char* section, const char* key, const std::vector<std::string_view>& items) override; void SetStringList(const char* section, const char* key, const std::vector<std::string>& items) override;
bool RemoveFromStringList(const char* section, const char* key, const char* item) override; bool RemoveFromStringList(const char* section, const char* key, const char* item) override;
bool AddToStringList(const char* section, const char* key, const char* item) override; bool AddToStringList(const char* section, const char* key, const char* item) override;