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);
}
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);
}
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()
{
// 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 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 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)
{
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);
}
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())
return default_value;
@ -582,19 +582,19 @@ bool HostInterface::GetBooleanSettingValue(const char* section, const char* key,
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())
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);
}
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())
return default_value;

8
src/core/host_interface.h
View File

@ -107,16 +107,16 @@ public:
virtual std::string GetShaderCacheBasePath() const;
/// 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.
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.
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.
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:
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);
std::string path = host_interface->GetSettingValue(section, "CrosshairImagePath");
std::string path = host_interface->GetStringSettingValue(section, "CrosshairImagePath");
if (path != m_crosshair_image_path)
{
m_crosshair_image_path = std::move(path);

3
src/core/settings.h
View File

@ -4,7 +4,6 @@
#include <array>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
class SettingsInterface
@ -23,7 +22,7 @@ public:
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 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 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();
}
std::string LibretroHostInterface::GetSettingValue(const char* section, const char* key,
const char* default_value /*= ""*/)
std::string LibretroHostInterface::GetStringSettingValue(const char* section, const char* key,
const char* default_value /*= ""*/)
{
TinyString name;
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 GetGameMemoryCardPath(const char* game_code, u32 slot) 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
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,
const std::vector<std::string_view>& items)
const std::vector<std::string>& items)
{
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;
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 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++)
m_ui.logLevel->addItem(tr(Settings::GetLogLevelDisplayName(static_cast<LOGLEVEL>(i))));
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.logLevel, QStringLiteral("Logging"),
QStringLiteral("LogLevel"), &Settings::ParseLogLevelName,
&Settings::GetLogLevelName, Settings::DEFAULT_LOG_LEVEL);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, m_ui.logFilter, QStringLiteral("Logging"),
QStringLiteral("LogFilter"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToConsole, QStringLiteral("Logging"),
QStringLiteral("LogToConsole"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToDebug, QStringLiteral("Logging"),
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"));
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.logLevel, "Logging", "LogLevel",
&Settings::ParseLogLevelName, &Settings::GetLogLevelName,
Settings::DEFAULT_LOG_LEVEL);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, m_ui.logFilter, "Logging", "LogFilter");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToConsole, "Logging", "LogToConsole");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToDebug, "Logging", "LogToDebug");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToWindow, "Logging", "LogToWindow");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.logToFile, "Logging", "LogToFile");
// Tweaks/Hacks section
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.dmaMaxSliceTicks, QStringLiteral("Hacks"),
QStringLiteral("DMAMaxSliceTicks"));
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.dmaHaltTicks, QStringLiteral("Hacks"),
QStringLiteral("DMAHaltTicks"));
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.gpuFIFOSize, QStringLiteral("Hacks"),
QStringLiteral("GPUFIFOSize"));
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.gpuMaxRunAhead, QStringLiteral("Hacks"),
QStringLiteral("GPUMaxRunAhead"));
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.dmaMaxSliceTicks, "Hacks", "DMAMaxSliceTicks");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.dmaHaltTicks, "Hacks", "DMAHaltTicks");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.gpuFIFOSize, "Hacks", "GPUFIFOSize");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.gpuMaxRunAhead, "Hacks", "GPUMaxRunAhead");
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++)
m_ui.audioBackend->addItem(tr(Settings::GetAudioBackendDisplayName(static_cast<AudioBackend>(i))));
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.audioBackend, QStringLiteral("Audio"),
QStringLiteral("Backend"), &Settings::ParseAudioBackend,
&Settings::GetAudioBackendName, Settings::DEFAULT_AUDIO_BACKEND);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.syncToOutput, QStringLiteral("Audio"),
QStringLiteral("Sync"));
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.bufferSize, QStringLiteral("Audio"),
QStringLiteral("BufferSize"));
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.volume, QStringLiteral("Audio"),
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"));
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.audioBackend, "Audio", "Backend",
&Settings::ParseAudioBackend, &Settings::GetAudioBackendName,
Settings::DEFAULT_AUDIO_BACKEND);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.syncToOutput, "Audio", "Sync");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.bufferSize, "Audio", "BufferSize");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.volume, "Audio", "OutputVolume");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.muted, "Audio", "OutputMuted");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.startDumpingOnBoot, "Audio", "DumpOnBoot");
connect(m_ui.bufferSize, &QSlider::valueChanged, this, &AudioSettingsWidget::updateBufferingLabel);
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++)
m_ui.cpuExecutionMode->addItem(tr(Settings::GetCPUExecutionModeDisplayName(static_cast<CPUExecutionMode>(i))));
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.region, QStringLiteral("Console"),
QStringLiteral("Region"), &Settings::ParseConsoleRegionName,
&Settings::GetConsoleRegionName, Settings::DEFAULT_CONSOLE_REGION);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, m_ui.biosPath, QStringLiteral("BIOS"),
QStringLiteral("Path"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.enableTTYOutput, QStringLiteral("BIOS"),
QStringLiteral("PatchTTYEnable"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.fastBoot, QStringLiteral("BIOS"),
QStringLiteral("PatchFastBoot"));
SettingWidgetBinder::BindWidgetToEnumSetting(
m_host_interface, m_ui.cpuExecutionMode, QStringLiteral("CPU"), QStringLiteral("ExecutionMode"),
&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"));
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.region, "Console", "Region",
&Settings::ParseConsoleRegionName, &Settings::GetConsoleRegionName,
Settings::DEFAULT_CONSOLE_REGION);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, m_ui.biosPath, "BIOS", "Path");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.enableTTYOutput, "BIOS", "PatchTTYEnable");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.fastBoot, "BIOS", "PatchFastBoot");
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.cpuExecutionMode, "CPU", "ExecutionMode",
&Settings::ParseCPUExecutionMode, &Settings::GetCPUExecutionModeName,
Settings::DEFAULT_CPU_EXECUTION_MODE);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.cdromReadThread, "CDROM", "ReadThread");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.cdromRegionCheck, "CDROM", "RegionCheck");
connect(m_ui.biosPathBrowse, &QPushButton::pressed, this, &ConsoleSettingsWidget::onBrowseBIOSPathButtonClicked);
}
@ -45,6 +40,6 @@ void ConsoleSettingsWidget::onBrowseBIOSPathButtonClicked()
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();
}

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

@ -1,4 +1,5 @@
#include "controllersettingswidget.h"
#include "common/string_util.h"
#include "core/controller.h"
#include "core/settings.h"
#include "inputbindingwidgets.h"
@ -46,7 +47,7 @@ void ControllerSettingsWidget::onProfileLoaded()
{
ControllerType ctype = Settings::ParseControllerTypeName(
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())
.c_str())
.value_or(ControllerType::None);
@ -87,12 +88,10 @@ void ControllerSettingsWidget::createPortSettingsUi(int index, PortSettingsUI* u
ui->controller_type->addItem(
QString::fromUtf8(Settings::GetControllerTypeDisplayName(static_cast<ControllerType>(i))));
}
ControllerType ctype = Settings::ParseControllerTypeName(
m_host_interface
->GetSettingValue(QStringLiteral("Controller%1").arg(index + 1).toStdString().c_str(),
QStringLiteral("Type").toStdString().c_str())
.c_str())
.value_or(ControllerType::None);
ControllerType ctype =
Settings::ParseControllerTypeName(
m_host_interface->GetStringSettingValue(TinyString::FromFormat("Controller%d", index + 1), "Type").c_str())
.value_or(ControllerType::None);
ui->controller_type->setCurrentIndex(static_cast<int>(ctype));
connect(ui->controller_type, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
[this, index]() { onControllerTypeChanged(index); });
@ -194,12 +193,11 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
current_column += 2;
}
const QString button_name_q = QString::fromStdString(button_name);
const QString section_name = QStringLiteral("Controller%1").arg(index + 1);
const QString key_name = QStringLiteral("Button%1").arg(button_name_q);
QLabel* label = new QLabel(button_name_q, ui->bindings_container);
InputButtonBindingWidget* button =
new InputButtonBindingWidget(m_host_interface, section_name, key_name, ui->bindings_container);
std::string section_name = StringUtil::StdStringFromFormat("Controller%d", index + 1);
std::string key_name = StringUtil::StdStringFromFormat("Button%s", button_name.c_str());
QLabel* label = new QLabel(QString::fromStdString(button_name), ui->bindings_container);
InputButtonBindingWidget* button = new InputButtonBindingWidget(m_host_interface, std::move(section_name),
std::move(key_name), ui->bindings_container);
layout->addWidget(label, start_row + current_row, current_column);
layout->addWidget(button, start_row + current_row, current_column + 1);
@ -232,12 +230,11 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
current_column += 2;
}
const QString axis_name_q = QString::fromStdString(axis_name);
const QString section_name = QStringLiteral("Controller%1").arg(index + 1);
const QString key_name = QStringLiteral("Axis%1").arg(axis_name_q);
QLabel* label = new QLabel(axis_name_q, ui->bindings_container);
InputAxisBindingWidget* button =
new InputAxisBindingWidget(m_host_interface, section_name, key_name, ui->bindings_container);
std::string section_name = StringUtil::StdStringFromFormat("Controller%d", index + 1);
std::string key_name = StringUtil::StdStringFromFormat("Axis%s", axis_name.c_str());
QLabel* label = new QLabel(QString::fromStdString(axis_name), ui->bindings_container);
InputAxisBindingWidget* button = new InputAxisBindingWidget(m_host_interface, std::move(section_name),
std::move(key_name), ui->bindings_container);
layout->addWidget(label, start_row + current_row, current_column);
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);
const QString section_name = QStringLiteral("Controller%1").arg(index + 1);
const QString key_name = QStringLiteral("Rumble");
std::string section_name = StringUtil::StdStringFromFormat("Controller%d", index + 1);
QLabel* label = new QLabel(tr("Rumble"), ui->bindings_container);
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(button, start_row, 1);
@ -283,8 +279,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
for (const SettingInfo& si : settings)
{
const QString section_name = QStringLiteral("Controller%1").arg(index + 1);
const QString key_name = QStringLiteral("%1").arg(si.key);
std::string section_name = StringUtil::StdStringFromFormat("Controller%d", index + 1);
std::string key_name = si.key;
const QString setting_tooltip = si.description ? QString::fromUtf8(si.description) : "";
switch (si.type)
@ -293,8 +289,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
{
QCheckBox* cb = new QCheckBox(tr(si.visible_name), ui->bindings_container);
cb->setToolTip(setting_tooltip);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, cb, section_name, key_name,
si.BooleanDefaultValue());
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, cb, std::move(section_name),
std::move(key_name), si.BooleanDefaultValue());
layout->addWidget(cb, start_row, 0, 1, 4);
start_row++;
}
@ -307,8 +303,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
sb->setMinimum(si.IntegerMinValue());
sb->setMaximum(si.IntegerMaxValue());
sb->setSingleStep(si.IntegerStepValue());
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, sb, section_name, key_name,
si.IntegerDefaultValue());
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, sb, std::move(section_name),
std::move(key_name), si.IntegerDefaultValue());
layout->addWidget(new QLabel(tr(si.visible_name), ui->bindings_container), start_row, 0);
layout->addWidget(sb, start_row, 1, 1, 3);
start_row++;
@ -322,8 +318,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
sb->setMinimum(si.FloatMinValue());
sb->setMaximum(si.FloatMaxValue());
sb->setSingleStep(si.FloatStepValue());
SettingWidgetBinder::BindWidgetToFloatSetting(m_host_interface, sb, section_name, key_name,
si.FloatDefaultValue());
SettingWidgetBinder::BindWidgetToFloatSetting(m_host_interface, sb, std::move(section_name),
std::move(key_name), si.FloatDefaultValue());
layout->addWidget(new QLabel(tr(si.visible_name), ui->bindings_container), start_row, 0);
layout->addWidget(sb, start_row, 1, 1, 3);
start_row++;
@ -334,8 +330,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
{
QLineEdit* le = new QLineEdit(ui->bindings_container);
le->setToolTip(setting_tooltip);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, le, section_name, key_name,
QString::fromUtf8(si.StringDefaultValue()));
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, le, std::move(section_name),
std::move(key_name), si.StringDefaultValue());
layout->addWidget(new QLabel(tr(si.visible_name), ui->bindings_container), start_row, 0);
layout->addWidget(le, start_row, 1, 1, 3);
start_row++;
@ -347,8 +343,8 @@ void ControllerSettingsWidget::createPortBindingSettingsUi(int index, PortSettin
QLineEdit* le = new QLineEdit(ui->bindings_container);
le->setToolTip(setting_tooltip);
QPushButton* browse_button = new QPushButton(tr("Browse..."), ui->bindings_container);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, le, section_name, key_name,
QString::fromUtf8(si.StringDefaultValue()));
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, le, std::move(section_name),
std::move(key_name), si.StringDefaultValue());
connect(browse_button, &QPushButton::clicked, [this, le]() {
QString path = QFileDialog::getOpenFileName(this, tr("Select File"));
if (!path.isEmpty())
@ -382,9 +378,8 @@ void ControllerSettingsWidget::onControllerTypeChanged(int index)
if (type_index < 0 || type_index >= static_cast<int>(ControllerType::Count))
return;
m_host_interface->putSettingValue(
QStringLiteral("Controller%1").arg(index + 1), QStringLiteral("Type"),
QString::fromStdString(Settings::GetControllerTypeName(static_cast<ControllerType>(type_index))));
m_host_interface->SetStringSettingValue(TinyString::FromFormat("Controller%d", index + 1), "Type",
Settings::GetControllerTypeName(static_cast<ControllerType>(type_index)));
m_host_interface->applySettings();
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()
{
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)
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)
m_entries.push_back({QString::fromStdString(entry), true});
}
void saveToSettings()
{
QStringList paths;
QStringList recursive_paths;
std::vector<std::string> paths;
std::vector<std::string> recursive_paths;
for (const Entry& entry : m_entries)
{
if (entry.recursive)
recursive_paths.push_back(entry.path);
recursive_paths.push_back(entry.path.toStdString());
else
paths.push_back(entry.path);
paths.push_back(entry.path.toStdString());
}
if (paths.empty())
m_host_interface->removeSettingValue("GameList", "Paths");
m_host_interface->RemoveSettingValue("GameList", "Paths");
else
m_host_interface->putSettingValue(QStringLiteral("GameList"), QStringLiteral("Paths"), paths);
m_host_interface->SetStringListSettingValue("GameList", "Paths", paths);
if (recursive_paths.empty())
m_host_interface->removeSettingValue("GameList", "RecursivePaths");
m_host_interface->RemoveSettingValue("GameList", "RecursivePaths");
else
m_host_interface->putSettingValue(QStringLiteral("GameList"), QStringLiteral("RecursivePaths"), recursive_paths);
m_host_interface->SetStringListSettingValue("GameList", "RecursivePaths", recursive_paths);
}
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});
}
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()
@ -390,9 +390,8 @@ void GameListWidget::loadTableViewColumnVisibilitySettings()
for (int column = 0; column < GameListModel::Column_Count; column++)
{
const bool visible = m_host_interface->GetBooleanSettingValue(
"GameListTableView", getColumnVisibilitySettingsKeyName(column).toStdString().c_str(),
DEFAULT_VISIBILITY[column]);
const bool visible = m_host_interface->GetBoolSettingValue(
"GameListTableView", getColumnVisibilitySettingsKeyName(column), DEFAULT_VISIBILITY[column]);
m_table_view->setColumnHidden(column, !visible);
}
}
@ -402,14 +401,14 @@ void GameListWidget::saveTableViewColumnVisibilitySettings()
for (int column = 0; column < GameListModel::Column_Count; 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)
{
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()
@ -418,10 +417,10 @@ void GameListWidget::loadTableViewColumnSortSettings()
const bool DEFAULT_SORT_DESCENDING = false;
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);
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);
}
@ -432,11 +431,11 @@ void GameListWidget::saveTableViewColumnSortSettings()
if (sort_column >= 0 && sort_column < GameListModel::Column_Count)
{
m_host_interface->putSettingValue(QStringLiteral("GameListTableView"), QStringLiteral("SortColumn"),
QString::fromUtf8(GameListModel::s_column_names[sort_column]));
m_host_interface->SetStringSettingValue("GameListTableView", "SortColumn",
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

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

@ -7,33 +7,26 @@ GeneralSettingsWidget::GeneralSettingsWidget(QtHostInterface* host_interface, QW
{
m_ui.setupUi(this);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.pauseOnStart, QStringLiteral("Main"),
QStringLiteral("StartPaused"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.startFullscreen, QStringLiteral("Main"),
QStringLiteral("StartFullscreen"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.renderToMain, QStringLiteral("Main"),
QStringLiteral("RenderToMainWindow"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.saveStateOnExit, QStringLiteral("Main"),
QStringLiteral("SaveStateOnExit"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.confirmPowerOff, QStringLiteral("Main"),
QStringLiteral("ConfirmPowerOff"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.loadDevicesFromSaveStates, QStringLiteral("Main"),
QStringLiteral("LoadDevicesFromSaveStates"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showOSDMessages, QStringLiteral("Display"),
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.pauseOnStart, "Main", "StartPaused", false);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.startFullscreen, "Main", "StartFullscreen",
false);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.renderToMain, "Main", "RenderToMainWindow", true);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.saveStateOnExit, "Main", "SaveStateOnExit", true);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.confirmPowerOff, "Main", "ConfirmPowerOff", true);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.loadDevicesFromSaveStates, "Main",
"LoadDevicesFromSaveStates", false);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showOSDMessages, "Display", "ShowOSDMessages",
true);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showFPS, "Display", "ShowFPS", false);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showVPS, "Display", "ShowVPS", false);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.showSpeed, "Display", "ShowSpeed", false);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.enableSpeedLimiter, QStringLiteral("Main"),
QStringLiteral("SpeedLimiterEnabled"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.increaseTimerResolution, QStringLiteral("Main"),
QStringLiteral("IncreaseTimerResolution"));
SettingWidgetBinder::BindWidgetToNormalizedSetting(m_host_interface, m_ui.emulationSpeed, QStringLiteral("Main"),
QStringLiteral("EmulationSpeed"), 100.0f);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.enableSpeedLimiter, "Main", "SpeedLimiterEnabled",
true);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.increaseTimerResolution, "Main",
"IncreaseTimerResolution", true);
SettingWidgetBinder::BindWidgetToNormalizedSetting(m_host_interface, m_ui.emulationSpeed, "Main", "EmulationSpeed",
100.0f, 1.0f);
connect(m_ui.enableSpeedLimiter, &QCheckBox::stateChanged, this,
&GeneralSettingsWidget::onEnableSpeedLimiterStateChanged);
@ -85,8 +78,8 @@ GeneralSettingsWidget::GeneralSettingsWidget(QtHostInterface* host_interface, QW
#ifdef WITH_DISCORD_PRESENCE
{
QCheckBox* enableDiscordPresence = new QCheckBox(tr("Enable Discord Presence"), m_ui.groupBox_4);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, enableDiscordPresence, QStringLiteral("Main"),
QStringLiteral("EnableDiscordPresence"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, enableDiscordPresence, "Main",
"EnableDiscordPresence");
m_ui.formLayout_4->addWidget(enableDiscordPresence, m_ui.formLayout_4->rowCount(), 0);
dialog->registerWidgetHelp(enableDiscordPresence, "Enable Discord Presence", "Unchecked",
"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);
setupAdditionalUi();
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.renderer, QStringLiteral("GPU"),
QStringLiteral("Renderer"), &Settings::ParseRendererName,
&Settings::GetRendererName, Settings::DEFAULT_GPU_RENDERER);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.useDebugDevice, QStringLiteral("GPU"),
QStringLiteral("UseDebugDevice"));
SettingWidgetBinder::BindWidgetToEnumSetting(
m_host_interface, m_ui.displayAspectRatio, QStringLiteral("Display"), QStringLiteral("AspectRatio"),
&Settings::ParseDisplayAspectRatio, &Settings::GetDisplayAspectRatioName, Settings::DEFAULT_DISPLAY_ASPECT_RATIO);
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.displayCropMode, QStringLiteral("Display"),
QStringLiteral("CropMode"), &Settings::ParseDisplayCropMode,
&Settings::GetDisplayCropModeName, Settings::DEFAULT_DISPLAY_CROP_MODE);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.displayLinearFiltering, QStringLiteral("Display"),
QStringLiteral("LinearFiltering"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.displayIntegerScaling, QStringLiteral("Display"),
QStringLiteral("IntegerScaling"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.vsync, QStringLiteral("Display"),
QStringLiteral("VSync"));
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.resolutionScale, QStringLiteral("GPU"),
QStringLiteral("ResolutionScale"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.trueColor, QStringLiteral("GPU"),
QStringLiteral("TrueColor"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.scaledDithering, QStringLiteral("GPU"),
QStringLiteral("ScaledDithering"));
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"));
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.renderer, "GPU", "Renderer",
&Settings::ParseRendererName, &Settings::GetRendererName,
Settings::DEFAULT_GPU_RENDERER);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.useDebugDevice, "GPU", "UseDebugDevice");
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.displayAspectRatio, "Display", "AspectRatio",
&Settings::ParseDisplayAspectRatio, &Settings::GetDisplayAspectRatioName,
Settings::DEFAULT_DISPLAY_ASPECT_RATIO);
SettingWidgetBinder::BindWidgetToEnumSetting(m_host_interface, m_ui.displayCropMode, "Display", "CropMode",
&Settings::ParseDisplayCropMode, &Settings::GetDisplayCropModeName,
Settings::DEFAULT_DISPLAY_CROP_MODE);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.displayLinearFiltering, "Display",
"LinearFiltering");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.displayIntegerScaling, "Display",
"IntegerScaling");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.vsync, "Display", "VSync");
SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.resolutionScale, "GPU", "ResolutionScale");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.trueColor, "GPU", "TrueColor");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.scaledDithering, "GPU", "ScaledDithering");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.disableInterlacing, "GPU", "DisableInterlacing");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.forceNTSCTimings, "GPU", "ForceNTSCTimings");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.linearTextureFiltering, "GPU",
"TextureFiltering");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.widescreenHack, "GPU", "WidescreenHack");
connect(m_ui.resolutionScale, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&GPUSettingsWidget::updateScaledDitheringEnabled);
@ -174,7 +166,7 @@ void GPUSettingsWidget::populateGPUAdapters()
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);
@ -201,9 +193,9 @@ void GPUSettingsWidget::onGPUAdapterIndexChanged()
if (m_ui.adapter->currentIndex() == 0)
{
// default
m_host_interface->removeSettingValue("GPU", "Adapter");
m_host_interface->RemoveSettingValue("GPU", "Adapter");
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;
const int target_row = layout->count() / 2;
const QString section_name = QStringLiteral("Hotkeys");
const QString key_name = QStringLiteral("%1").arg(hi.name.GetCharArray());
std::string section_name("Hotkeys");
std::string key_name(hi.name.GetCharArray());
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 "common/bitutils.h"
#include "common/string_util.h"
#include "core/settings.h"
#include "frontend-common/controller_interface.h"
#include "qthostinterface.h"
@ -9,14 +10,13 @@
#include <QtGui/QMouseEvent>
#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)
: QPushButton(parent), m_host_interface(host_interface),
m_section_name(std::move(section_name)), m_key_name(std::move(key_name))
: QPushButton(parent), m_host_interface(host_interface), m_section_name(std::move(section_name)),
m_key_name(std::move(key_name))
{
m_current_binding_value = QString::fromStdString(
m_host_interface->GetSettingValue(m_section_name.toStdString().c_str(), m_key_name.toStdString().c_str()));
setText(m_current_binding_value);
m_current_binding_value = m_host_interface->GetStringSettingValue(m_section_name.c_str(), m_key_name.c_str());
setText(QString::fromStdString(m_current_binding_value));
setMinimumWidth(150);
setMaximumWidth(150);
@ -63,10 +63,10 @@ void InputBindingWidget::mouseReleaseEvent(QMouseEvent* e)
void InputBindingWidget::setNewBinding()
{
if (m_new_binding_value.isEmpty())
if (m_new_binding_value.empty())
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_current_binding_value = std::move(m_new_binding_value);
@ -76,16 +76,15 @@ void InputBindingWidget::setNewBinding()
void InputBindingWidget::clearBinding()
{
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();
setText(m_current_binding_value);
setText(QString::fromStdString(m_current_binding_value));
}
void InputBindingWidget::reloadBinding()
{
m_current_binding_value = QString::fromStdString(m_host_interface->GetSettingValue(m_section_name.toStdString().c_str(),
m_key_name.toStdString().c_str()));
setText(m_current_binding_value);
m_current_binding_value = m_host_interface->GetStringSettingValue(m_section_name.c_str(), m_key_name.c_str());
setText(QString::fromStdString(m_current_binding_value));
}
void InputBindingWidget::onClicked()
@ -126,7 +125,7 @@ void InputBindingWidget::startListeningForInput(u32 timeout_in_seconds)
void InputBindingWidget::stopListeningForInput()
{
setText(m_current_binding_value);
setText(QString::fromStdString(m_current_binding_value));
delete m_input_listen_timer;
m_input_listen_timer = nullptr;
@ -139,9 +138,9 @@ void InputBindingWidget::stopListeningForInput()
m_is_binding_all = false;
}
InputButtonBindingWidget::InputButtonBindingWidget(QtHostInterface* host_interface, QString section_name,
QString key_name, QWidget* parent)
: InputBindingWidget(host_interface, section_name, key_name, parent)
InputButtonBindingWidget::InputButtonBindingWidget(QtHostInterface* host_interface, std::string section_name,
std::string key_name, QWidget* 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));
if (!binding.isEmpty())
m_new_binding_value = QStringLiteral("Keyboard/%1").arg(binding);
m_new_binding_value = QStringLiteral("Keyboard/%1").arg(binding).toStdString();
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_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();
stopListeningForInput();
return true;
@ -224,14 +223,14 @@ void InputButtonBindingWidget::unhookControllerInput()
void InputButtonBindingWidget::bindToControllerAxis(int controller_index, int axis_index, bool positive)
{
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();
stopListeningForInput();
}
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();
stopListeningForInput();
}
@ -248,9 +247,9 @@ void InputButtonBindingWidget::stopListeningForInput()
InputBindingWidget::stopListeningForInput();
}
InputAxisBindingWidget::InputAxisBindingWidget(QtHostInterface* host_interface, QString section_name, QString key_name,
QWidget* parent)
: InputBindingWidget(host_interface, section_name, key_name, parent)
InputAxisBindingWidget::InputAxisBindingWidget(QtHostInterface* host_interface, std::string section_name,
std::string key_name, QWidget* 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)
{
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();
stopListeningForInput();
}
@ -310,9 +309,9 @@ void InputAxisBindingWidget::stopListeningForInput()
InputBindingWidget::stopListeningForInput();
}
InputRumbleBindingWidget::InputRumbleBindingWidget(QtHostInterface* host_interface, QString section_name,
QString key_name, QWidget* parent)
: InputBindingWidget(host_interface, section_name, key_name, parent)
InputRumbleBindingWidget::InputRumbleBindingWidget(QtHostInterface* host_interface, std::string section_name,
std::string key_name, QWidget* 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)
{
m_new_binding_value = QStringLiteral("Controller%1").arg(controller_index);
m_new_binding_value = StringUtil::StdStringFromFormat("Controller%d", controller_index);
setNewBinding();
stopListeningForInput();
}

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

@ -11,7 +11,7 @@ class InputBindingWidget : public QPushButton
Q_OBJECT
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();
ALWAYS_INLINE InputBindingWidget* getNextWidget() const { return m_next_widget; }
@ -43,10 +43,10 @@ protected:
void setNewBinding();
QtHostInterface* m_host_interface;
QString m_section_name;
QString m_key_name;
QString m_current_binding_value;
QString m_new_binding_value;
std::string m_section_name;
std::string m_key_name;
std::string m_current_binding_value;
std::string m_new_binding_value;
QTimer* m_input_listen_timer = nullptr;
u32 m_input_listen_remaining_seconds = 0;
@ -59,7 +59,7 @@ class InputButtonBindingWidget : public InputBindingWidget
Q_OBJECT
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();
protected:
@ -81,7 +81,7 @@ class InputAxisBindingWidget : public InputBindingWidget
Q_OBJECT
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();
private Q_SLOTS:
@ -99,7 +99,7 @@ class InputRumbleBindingWidget : public InputBindingWidget
Q_OBJECT
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();
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);
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);
}
@ -433,8 +433,7 @@ void MainWindow::setupAdditionalUi()
QAction* action = m_ui.menuCPUExecutionMode->addAction(tr(Settings::GetCPUExecutionModeDisplayName(mode)));
action->setCheckable(true);
connect(action, &QAction::triggered, [this, mode]() {
m_host_interface->putSettingValue(QStringLiteral("CPU"), QStringLiteral("ExecutionMode"),
QString(Settings::GetCPUExecutionModeName(mode)));
m_host_interface->SetStringSettingValue("CPU", "ExecutionMode", Settings::GetCPUExecutionModeName(mode));
m_host_interface->applySettings();
updateDebugMenuCPUExecutionMode();
});
@ -447,8 +446,7 @@ void MainWindow::setupAdditionalUi()
QAction* action = m_ui.menuRenderer->addAction(tr(Settings::GetRendererDisplayName(renderer)));
action->setCheckable(true);
connect(action, &QAction::triggered, [this, renderer]() {
m_host_interface->putSettingValue(QStringLiteral("GPU"), QStringLiteral("Renderer"),
QString(Settings::GetRendererName(renderer)));
m_host_interface->SetStringSettingValue("GPU", "Renderer", Settings::GetRendererName(renderer));
m_host_interface->applySettings();
updateDebugMenuGPURenderer();
});
@ -607,28 +605,25 @@ void MainWindow::connectSignals()
m_host_interface->populateSaveStateMenus(nullptr, m_ui.menuLoadState, m_ui.menuSaveState);
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugDumpCPUtoVRAMCopies,
QStringLiteral("Debug"), QStringLiteral("DumpCPUToVRAMCopies"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugDumpVRAMtoCPUCopies,
QStringLiteral("Debug"), QStringLiteral("DumpVRAMToCPUCopies"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugDumpCPUtoVRAMCopies, "Debug",
"DumpCPUToVRAMCopies");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugDumpVRAMtoCPUCopies, "Debug",
"DumpVRAMToCPUCopies");
connect(m_ui.actionDumpAudio, &QAction::toggled, [this](bool checked) {
if (checked)
m_host_interface->startDumpingAudio();
else
m_host_interface->stopDumpingAudio();
});
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowVRAM, QStringLiteral("Debug"),
QStringLiteral("ShowVRAM"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowGPUState, QStringLiteral("Debug"),
QStringLiteral("ShowGPUState"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowCDROMState,
QStringLiteral("Debug"), QStringLiteral("ShowCDROMState"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowSPUState, QStringLiteral("Debug"),
QStringLiteral("ShowSPUState"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowTimersState,
QStringLiteral("Debug"), QStringLiteral("ShowTimersState"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowMDECState, QStringLiteral("Debug"),
QStringLiteral("ShowMDECState"));
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowVRAM, "Debug", "ShowVRAM");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowGPUState, "Debug", "ShowGPUState");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowCDROMState, "Debug",
"ShowCDROMState");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowSPUState, "Debug", "ShowSPUState");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowTimersState, "Debug",
"ShowTimersState");
SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.actionDebugShowMDECState, "Debug",
"ShowMDECState");
addThemeToMenu(tr("Default"), QStringLiteral("default"));
addThemeToMenu(tr("DarkFusion"), QStringLiteral("darkfusion"));
@ -645,13 +640,13 @@ void MainWindow::addThemeToMenu(const QString& name, const QString& key)
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();
}
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"))
{
qApp->setStyle(m_unthemed_style_name);
@ -742,7 +737,7 @@ void MainWindow::doSettings(SettingsDialog::Category category)
void MainWindow::updateDebugMenuCPUExecutionMode()
{
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())
return;
@ -759,7 +754,7 @@ void MainWindow::updateDebugMenuGPURenderer()
{
// update the menu with the new selected 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())
return;

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

@ -1,4 +1,5 @@
#include "memorycardsettingswidget.h"
#include "common/string_util.h"
#include "core/controller.h"
#include "core/settings.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;
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);
ui->layout->addWidget(new QLabel(tr("Memory Card Type:"), ui->container));
ui->layout->addWidget(ui->memory_card_type);
QHBoxLayout* memory_card_layout = new QHBoxLayout();
ui->memory_card_path = new QLineEdit(ui->container);
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, ui->memory_card_path,
QStringLiteral("MemoryCards"), QStringLiteral("Card%1Path").arg(index + 1));
SettingWidgetBinder::BindWidgetToStringSetting(m_host_interface, ui->memory_card_path, "MemoryCards",
StringUtil::StdStringFromFormat("Card%dPath", index + 1));
memory_card_layout->addWidget(ui->memory_card_path);
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);
}
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);
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);
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);
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);
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);
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);
m_settings_interface->SetStringValue(section.toStdString().c_str(), key.toStdString().c_str(),
value.toStdString().c_str());
m_settings_interface->SetStringValue(section, key, value);
}
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::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);
m_settings_interface->SetStringList(section, key, values);
}
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);
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 <QtCore/QByteArray>
#include <QtCore/QObject>
#include <QtCore/QString>
#include <QtCore/QSettings>
#include <QtCore/QString>
#include <QtCore/QThread>
#include <atomic>
#include <functional>
@ -51,14 +51,17 @@ public:
bool parseCommandLineParameters(int argc, char* argv[], std::unique_ptr<SystemBootParameters>* out_boot_params);
/// Thread-safe settings access.
std::string GetSettingValue(const char* section, const char* key, const char* default_value = "") override;
std::vector<std::string> GetStringList(const char* section, const char* key);
void putSettingValue(const QString& section, const QString& key, const bool& value);
void putSettingValue(const QString& section, const QString& key, const int& value);
void putSettingValue(const QString& section, const QString& key, const float& value);
void putSettingValue(const QString& section, const QString& key, const QString& value);
void putSettingValue(const QString& section, const QString& key, const QStringList& list);
void removeSettingValue(const char* section, const char* key);
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;
std::vector<std::string> GetSettingStringList(const char* section, const char* key);
void SetBoolSettingValue(const char* section, const char* key, bool value);
void SetIntSettingValue(const char* section, const char* key, int value);
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 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.
template<typename WidgetType>
void BindWidgetToBoolSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name,
const QString& key_name, bool default_value = false)
void BindWidgetToBoolSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
bool default_value = false)
{
using Accessor = SettingAccessor<WidgetType>;
bool value =
hi->GetBooleanSettingValue(section_name.toStdString().c_str(), key_name.toStdString().c_str(), default_value);
bool value = hi->GetBoolSettingValue(section.c_str(), key.c_str(), default_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);
hi->putSettingValue(section_name, key_name, new_value);
hi->SetBoolSettingValue(section.c_str(), key.c_str(), new_value);
hi->applySettings();
});
}
template<typename WidgetType>
void BindWidgetToIntSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name,
const QString& key_name, int default_value = 0)
void BindWidgetToIntSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
int default_value = 0)
{
using Accessor = SettingAccessor<WidgetType>;
s32 value = hi->GetIntegerSettingValue(section_name.toStdString().c_str(), key_name.toStdString().c_str(),
static_cast<s32>(default_value));
s32 value = hi->GetIntSettingValue(section.c_str(), key.c_str(), static_cast<s32>(default_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);
hi->putSettingValue(section_name, key_name, new_value);
hi->SetIntSettingValue(section.c_str(), key.c_str(), new_value);
hi->applySettings();
});
}
template<typename WidgetType>
void BindWidgetToFloatSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name,
const QString& key_name, float default_value = 0.0f)
void BindWidgetToFloatSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
float default_value = 0.0f)
{
using Accessor = SettingAccessor<WidgetType>;
float value =
hi->GetFloatSettingValue(section_name.toStdString().c_str(), key_name.toStdString().c_str(), default_value);
float value = hi->GetFloatSettingValue(section.c_str(), key.c_str(), default_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);
hi->putSettingValue(section_name, key_name, new_value);
hi->SetFloatSettingValue(section.c_str(), key.c_str(), new_value);
hi->applySettings();
});
}
template<typename WidgetType>
void BindWidgetToNormalizedSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name,
const QString& key_name, float range, float default_value = 0.0f)
void BindWidgetToNormalizedSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
float range, float default_value = 0.0f)
{
using Accessor = SettingAccessor<WidgetType>;
float value =
hi->GetFloatSettingValue(section_name.toStdString().c_str(), key_name.toStdString().c_str(), default_value);
float value = hi->GetFloatSettingValue(section.c_str(), key.c_str(), default_value);
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);
hi->putSettingValue(section_name, key_name, new_value);
hi->SetFloatSettingValue(section.c_str(), key.c_str(), new_value);
hi->applySettings();
});
}
template<typename WidgetType>
void BindWidgetToStringSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name,
const QString& key_name, const QString& default_value = QString())
void BindWidgetToStringSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
std::string default_value = std::string())
{
using Accessor = SettingAccessor<WidgetType>;
std::string value = hi->GetSettingValue(section_name.toStdString().c_str(), key_name.toStdString().c_str(),
default_value.toStdString().c_str());
std::string value = hi->GetStringSettingValue(section.c_str(), key.c_str(), default_value.c_str());
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);
hi->putSettingValue(section_name, key_name, new_value);
hi->SetStringSettingValue(section.c_str(), key.c_str(), new_value.toUtf8().constData());
hi->applySettings();
});
}
template<typename WidgetType, typename DataType>
void BindWidgetToEnumSetting(QtHostInterface* hi, WidgetType* widget, const QString& section_name,
const QString& key_name, std::optional<DataType> (*from_string_function)(const char* str),
void BindWidgetToEnumSetting(QtHostInterface* hi, WidgetType* widget, std::string section, std::string key,
std::optional<DataType> (*from_string_function)(const char* str),
const char* (*to_string_function)(DataType value), DataType default_value)
{
using Accessor = SettingAccessor<WidgetType>;
using UnderlyingType = std::underlying_type_t<DataType>;
// TODO: Clean this up?
const std::string old_setting_string_value = hi->GetSettingValue(
section_name.toStdString().c_str(), key_name.toStdString().c_str(), to_string_function(default_value));
const std::string old_setting_string_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());
if (old_setting_value.has_value())
Accessor::setIntValue(widget, static_cast<int>(static_cast<UnderlyingType>(old_setting_value.value())));
else
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 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();
});
}

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

@ -424,11 +424,27 @@ void SDLHostInterface::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);
}
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()
{
// 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;
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();

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;
}
void INISettingsInterface::SetStringList(const char* section, const char* key,
const std::vector<std::string_view>& items)
void INISettingsInterface::SetStringList(const char* section, const char* key, const std::vector<std::string>& items)
{
m_dirty = true;
m_ini.Delete(section, key);
for (const std::string_view& sv : items)
m_ini.SetValue(section, key, std::string(sv).c_str(), nullptr, false);
for (const std::string& sv : items)
m_ini.SetValue(section, key, sv.c_str(), nullptr, false);
}
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;
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 AddToStringList(const char* section, const char* key, const char* item) override;