Mascali
/
suyu
mirror of https://git.suyu.dev/suyu/suyu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add dark mode configuration setting in UI tab 

- Allows to choose "Auto", "Always On" or "Always Off"
  - Dark mode options are only shown if the style does not support theme
- If Auto is chosen, value is retrieved from OS
  - On Windows, the application needs a restart to apply the settings
- Use the default dark palette for Windows, like on Linux
This commit is contained in:
flodavid 2024-02-12 04:01:25 +01:00
parent df9dea3f3d
commit f90d259bc1
10 changed files with 220 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/common/settings.cpp
View File

@ -67,6 +67,7 @@ SWITCHABLE(u8, true);
// Used in UISettings
// TODO see if we can move this to uisettings.cpp
SWITCHABLE(ConfirmStop, true);
SWITCHABLE(DarkModeState, true);
#undef SETTING
#undef SWITCHABLE

1
src/common/settings.h
View File

@ -90,6 +90,7 @@ SWITCHABLE(u8, true);
// Used in UISettings
// TODO see if we can move this to uisettings.h
SWITCHABLE(ConfirmStop, true);
SWITCHABLE(DarkModeState, true);
#undef SETTING
#undef SWITCHABLE

2
src/common/settings_enums.h
View File

@ -155,6 +155,8 @@ ENUM(ConsoleMode, Handheld, Docked);
ENUM(AppletMode, HLE, LLE);
ENUM(DarkModeState, Off, On, Auto);
template <typename Type>
inline std::string CanonicalizeEnum(Type id) {
const auto group = EnumMetadata<Type>::Canonicalizations();

67
src/suyu/configuration/configure_ui.cpp
View File

@ -18,6 +18,7 @@
#include <QString>
#include <QToolButton>
#include <QVariant>
#include <QtGlobal>
#include "common/common_types.h"
#include "common/fs/path_util.h"
@ -29,6 +30,8 @@
#include "suyu/uisettings.h"
#include "ui_configure_ui.h"
using Settings::DarkModeState;
namespace {
constexpr std::array default_game_icon_sizes{
std::make_pair(0, QT_TRANSLATE_NOOP("ConfigureUI", "None")),
@ -153,6 +156,9 @@ ConfigureUi::ConfigureUi(Core::System& system_, QWidget* parent)
&ConfigureUi::RequestGameListUpdate);
connect(ui->row_2_text_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&ConfigureUi::RequestGameListUpdate);
// Update available dark mode options depending on selected style
connect(ui->theme_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&ConfigureUi::UpdateDarkModeOptions);
// Update text ComboBoxes after user interaction.
connect(ui->row_1_text_combobox, QOverload<int>::of(&QComboBox::activated),
@ -185,6 +191,8 @@ ConfigureUi::~ConfigureUi() = default;
void ConfigureUi::ApplyConfiguration() {
UISettings::values.theme =
ui->theme_combobox->itemData(ui->theme_combobox->currentIndex()).toString();
UISettings::values.dark_mode_state =
static_cast<DarkModeState>(ui->dark_mode_combobox->currentData().toUInt());
UISettings::values.show_add_ons = ui->show_add_ons->isChecked();
UISettings::values.show_compat = ui->show_compat->isChecked();
UISettings::values.show_size = ui->show_size->isChecked();
@ -206,12 +214,71 @@ void ConfigureUi::ApplyConfiguration() {
system.ApplySettings();
}
void ConfigureUi::UpdateDarkModeOptions() {
ui->dark_mode_combobox->clear();
QString selected_theme = ui->theme_combobox->currentData().toString();
/* Dark mode option are added according to the modes the current style supports */
bool has_common_style = QFile::exists(selected_theme + QStringLiteral("style.qss"));
bool has_light_style = QFile::exists(selected_theme + QStringLiteral("light.qss"));
bool has_dark_style = QFile::exists(selected_theme + QStringLiteral("dark.qss"));
#ifdef _WIN32
// Indicate which option needs a restart to be applied, depending on current environment
// variable
QByteArray current_qt_qpa = qgetenv("QT_QPA_PLATFORM");
if (current_qt_qpa.contains("darkmode=2")) {
if (has_common_style || (has_dark_style && has_light_style)) {
ui->dark_mode_combobox->addItem(tr("Auto"), QVariant::fromValue(DarkModeState::Auto));
}
if (has_common_style || has_dark_style) {
ui->dark_mode_combobox->addItem(tr("Always On") +
QStringLiteral(" (%1)").arg(tr("Needs restart")),
QVariant::fromValue(DarkModeState::On));
}
if (has_common_style || has_light_style) {
ui->dark_mode_combobox->addItem(tr("Always Off") +
QStringLiteral(" (%1)").arg(tr("Needs restart")),
QVariant::fromValue(DarkModeState::Off));
}
} else {
if (has_common_style || (has_dark_style && has_light_style)) {
ui->dark_mode_combobox->addItem(tr("Auto") +
QStringLiteral(" (%1)").arg(tr("Needs restart")),
QVariant::fromValue(DarkModeState::Auto));
}
if (has_common_style || has_dark_style) {
ui->dark_mode_combobox->addItem(tr("Always On"),
QVariant::fromValue(DarkModeState::On));
}
if (has_common_style || has_light_style) {
ui->dark_mode_combobox->addItem(tr("Always Off"),
QVariant::fromValue(DarkModeState::Off));
}
}
#else
if (has_common_style || (has_dark_style && has_light_style)) {
ui->dark_mode_combobox->addItem(tr("Auto"), QVariant::fromValue(DarkModeState::Auto));
}
if (has_common_style || has_dark_style) {
ui->dark_mode_combobox->addItem(tr("Always On"), QVariant::fromValue(DarkModeState::On));
}
if (has_common_style || has_light_style) {
ui->dark_mode_combobox->addItem(tr("Always Off"), QVariant::fromValue(DarkModeState::Off));
}
#endif
}
void ConfigureUi::RequestGameListUpdate() {
UISettings::values.is_game_list_reload_pending.exchange(true);
}
void ConfigureUi::SetConfiguration() {
ui->theme_combobox->setCurrentIndex(ui->theme_combobox->findData(UISettings::values.theme));
// Dark mode options are populated after the theme is selected, to get the current configuration
UpdateDarkModeOptions();
ui->dark_mode_combobox->setCurrentIndex(
ui->dark_mode_combobox->findData(QVariant::fromValue(UISettings::values.dark_mode_state)));
ui->language_combobox->setCurrentIndex(ui->language_combobox->findData(
QString::fromStdString(UISettings::values.language.GetValue())));
ui->show_add_ons->setChecked(UISettings::values.show_add_ons.GetValue());

1
src/suyu/configuration/configure_ui.h
View File

@ -34,6 +34,7 @@ signals:
void LanguageChanged(const QString& locale);
private:
void UpdateDarkModeOptions();
void RequestGameListUpdate();
void SetConfiguration();

14
src/suyu/configuration/configure_ui.ui
View File

@ -63,6 +63,20 @@
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_6">
<item>
<widget class="QLabel" name="dark_mode_label">
<property name="text">
<string>Dark Mode:</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="dark_mode_combobox"/>
</item>
</layout>
</item>
</layout>
</item>
</layout>

10
src/suyu/configuration/qt_config.cpp
View File

@ -260,8 +260,10 @@ void QtConfig::ReadShortcutValues() {
void QtConfig::ReadUIValues() {
BeginGroup(Settings::TranslateCategory(Settings::Category::Ui));
UISettings::values.theme = QString::fromStdString(
ReadStringSetting(std::string("theme"), std::string(UISettings::default_theme)));
UISettings::values.theme =
QString::fromStdString(ReadStringSetting("theme", std::string(UISettings::default_theme)));
UISettings::values.dark_mode_state = static_cast<DarkModeState>(
ReadIntegerSetting("dark_mode_state", static_cast<int>(DarkModeState::Auto)));
ReadUIGamelistValues();
ReadUILayoutValues();
@ -467,8 +469,10 @@ void QtConfig::SaveUIValues() {
WriteCategory(Settings::Category::Ui);
WriteCategory(Settings::Category::UiGeneral);
WriteStringSetting(std::string("theme"), UISettings::values.theme.toStdString(),
WriteStringSetting("theme", UISettings::values.theme.toStdString(),
std::make_optional(std::string(UISettings::default_theme)));
WriteIntegerSetting("dark_mode_state", static_cast<int>(UISettings::values.dark_mode_state),
std::make_optional(static_cast<int>(DarkModeState::Auto)));
SaveUIGamelistValues();
SaveUILayoutValues();

191
src/suyu/main.cpp
View File

@ -3536,6 +3536,7 @@ void GMainWindow::ResetWindowSize1080() {
void GMainWindow::OnConfigure() {
const QString old_theme = UISettings::values.theme;
DarkModeState old_dark_mode_state = UISettings::values.dark_mode_state;
const bool old_discord_presence = UISettings::values.enable_discord_presence.GetValue();
const auto old_language_index = Settings::values.language_index.GetValue();
#ifdef __unix__
@ -3594,7 +3595,8 @@ void GMainWindow::OnConfigure() {
}
InitializeHotkeys();
if (UISettings::values.theme != old_theme) {
if (UISettings::values.theme != old_theme ||
UISettings::values.dark_mode_state != old_dark_mode_state) {
UpdateUITheme();
}
if (UISettings::values.enable_discord_presence.GetValue() != old_discord_presence) {
@ -4791,13 +4793,11 @@ void GMainWindow::filterBarSetChecked(bool state) {
}
void GMainWindow::UpdateUITheme() {
LOG_DEBUG(Frontend, "Updating UI");
QString default_theme = QString::fromStdString(UISettings::default_theme.data());
const QString default_theme = QString::fromStdString(UISettings::default_theme.data());
QString current_theme = UISettings::values.theme;
if (current_theme.isEmpty()) {
current_theme = default_theme;
}
const bool current_dark_mode = CheckDarkMode();
UpdateIcons(current_theme);
@ -4856,7 +4856,7 @@ bool GMainWindow::TryLoadStylesheet(const QString& theme_uri) {
style_path = theme_uri + QStringLiteral("light.qss");
}
if (!QFile::exists(style_path)) {
LOG_INFO(Frontend, "Themed (light/dark) stylesheet could not be found, using default one");
LOG_DEBUG(Frontend, "No themed (light/dark) stylesheet, using default one");
// Use common stylesheet if themed one does not exist
style_path = theme_uri + QStringLiteral("style.qss");
}
@ -4867,7 +4867,7 @@ bool GMainWindow::TryLoadStylesheet(const QString& theme_uri) {
// Update the color palette before applying the stylesheet
UpdateThemePalette();
LOG_INFO(Frontend, "Loading stylesheet in: {}", theme_uri.toStdString());
LOG_DEBUG(Frontend, "Loading stylesheet in: {}", theme_uri.toStdString());
QTextStream ts_theme(&style_file);
qApp->setStyleSheet(ts_theme.readAll());
setStyleSheet(ts_theme.readAll());
@ -4899,12 +4899,33 @@ void GMainWindow::UpdateThemePalette() {
QPalette themePalette(qApp->palette());
#ifdef _WIN32
QColor dark(25, 25, 25);
QColor darkGray(100, 100, 100);
QColor gray(150, 150, 150);
QColor light(230, 230, 230);
// By default, revert fusion style set for Windows dark theme
QString style;
QString style_name;
if (CheckDarkMode()) {
// We check that the dark mode state is "On" and force a dark palette
if (UISettings::values.dark_mode_state == DarkModeState::On) {
// Set Default Windows Dark palette on Windows platforms to force Dark mode
themePalette.setColor(QPalette::Window, Qt::black);
themePalette.setColor(QPalette::WindowText, Qt::white);
themePalette.setColor(QPalette::Disabled, QPalette::WindowText, QColor(127, 127, 127));
themePalette.setColor(QPalette::Base, Qt::black);
themePalette.setColor(QPalette::AlternateBase, dark);
themePalette.setColor(QPalette::ToolTipBase, Qt::white);
themePalette.setColor(QPalette::ToolTipText, Qt::black);
themePalette.setColor(QPalette::Text, Qt::white);
themePalette.setColor(QPalette::Disabled, QPalette::Text, QColor(127, 127, 127));
themePalette.setColor(QPalette::Dark, QColor(128, 128, 128));
themePalette.setColor(QPalette::Shadow, Qt::white);
themePalette.setColor(QPalette::Button, Qt::black);
themePalette.setColor(QPalette::ButtonText, Qt::white);
themePalette.setColor(QPalette::Disabled, QPalette::ButtonText, QColor(127, 127, 127));
themePalette.setColor(QPalette::BrightText, QColor(192, 192, 192));
themePalette.setColor(QPalette::Link, QColor(0, 140, 200));
themePalette.setColor(QPalette::Highlight, QColor(0, 85, 255));
themePalette.setColor(QPalette::Disabled, QPalette::Highlight, QColor(0, 85, 255));
themePalette.setColor(QPalette::HighlightedText, Qt::white);
themePalette.setColor(QPalette::Disabled, QPalette::HighlightedText, Qt::white);
}
// AlternateBase is kept at rgb(233, 231, 227) or rgb(245, 245, 245) on Windows dark
// palette, fix this. Sometimes, it even is rgb(0, 0, 0), but uses a very light gray for
// alternate rows, do not know why
@ -4915,22 +4936,23 @@ void GMainWindow::UpdateThemePalette() {
alternate_base_modified = true;
}
// Use fusion theme, since its close to windowsvista, but works well with a dark palette
style = QStringLiteral("fusion");
style_name = QStringLiteral("fusion");
} else {
// Reset AlternateBase if it has been modified
if (alternate_base_modified) {
themePalette.setColor(QPalette::AlternateBase, QColor(245, 245, 245));
alternate_base_modified = false;
}
// Reset light palette
themePalette = this->style()->standardPalette();
// Reset Windows theme to the default
style = QStringLiteral("windowsvista");
style_name = QStringLiteral("windowsvista");
}
LOG_DEBUG(Frontend, "Using style: {}", style.toStdString());
qApp->setStyle(style);
LOG_DEBUG(Frontend, "Using style: {}", style_name.toStdString());
qApp->setStyle(style_name);
#else
if (CheckDarkMode()) {
// Set Dark palette on non Windows platforms (that may not have a dark palette)
LOG_INFO(Frontend, "Using custom dark palette");
themePalette.setColor(QPalette::Window, QColor(53, 53, 53));
themePalette.setColor(QPalette::WindowText, Qt::white);
themePalette.setColor(QPalette::Disabled, QPalette::WindowText, QColor(127, 127, 127));
@ -4952,8 +4974,7 @@ void GMainWindow::UpdateThemePalette() {
themePalette.setColor(QPalette::HighlightedText, Qt::white);
themePalette.setColor(QPalette::Disabled, QPalette::HighlightedText, QColor(127, 127, 127));
} else {
LOG_INFO(Frontend, "Using standard palette");
// Reset light palette on non Windows platforms
// Reset light palette
themePalette = this->style()->standardPalette();
}
#endif
@ -5014,61 +5035,72 @@ bool GMainWindow::ListenColorSchemeChange() {
#endif
bool GMainWindow::CheckDarkMode() {
const QPalette current_palette(qApp->palette());
bool is_dark_mode_auto;
#ifdef _WIN32
// Dark mode cannot be changed after the app started on Windows
is_dark_mode_auto = qgetenv("QT_QPA_PLATFORM").contains("darkmode=2");
#else
is_dark_mode_auto = UISettings::values.dark_mode_state == DarkModeState::Auto;
#endif
if (!is_dark_mode_auto) {
return UISettings::values.dark_mode_state == DarkModeState::On;
} else {
const QPalette current_palette(qApp->palette());
#ifdef __unix__
QProcess process;
QStringList gdbus_arguments;
QProcess process;
// Using the freedesktop specifications for checking dark mode
LOG_INFO(Frontend, "Retrieving theme from freedesktop color-scheme...");
gdbus_arguments << QStringLiteral("--dest=org.freedesktop.portal.Desktop")
<< QStringLiteral("--object-path /org/freedesktop/portal/desktop")
<< QStringLiteral("--method org.freedesktop.portal.Settings.Read")
<< QStringLiteral("org.freedesktop.appearance color-scheme");
process.start(QStringLiteral("gdbus call --session"), gdbus_arguments);
process.waitForFinished(1000);
QByteArray dbus_output = process.readAllStandardOutput();
// Using the freedesktop specifications for checking dark mode
LOG_DEBUG(Frontend, "Retrieving theme from freedesktop color-scheme...");
QStringList gdbus_arguments;
gdbus_arguments << QStringLiteral("--dest=org.freedesktop.portal.Desktop")
<< QStringLiteral("--object-path /org/freedesktop/portal/desktop")
<< QStringLiteral("--method org.freedesktop.portal.Settings.Read")
<< QStringLiteral("org.freedesktop.appearance color-scheme");
process.start(QStringLiteral("gdbus call --session"), gdbus_arguments);
process.waitForFinished(1000);
QByteArray dbus_output = process.readAllStandardOutput();
if (!dbus_output.isEmpty()) {
const int systemColorSchema = QString::fromUtf8(dbus_output).trimmed().right(1).toInt();
return systemColorSchema == 1;
}
if (!dbus_output.isEmpty()) {
const int systemColorSchema = QString::fromUtf8(dbus_output).trimmed().right(1).toInt();
return systemColorSchema == 1;
}
// Try alternative for Gnome if the previous one failed
QStringList gsettings_arguments;
gsettings_arguments << QStringLiteral("get")
<< QStringLiteral("org.gnome.desktop.interface")
<< QStringLiteral("color-scheme");
LOG_DEBUG(Frontend, "failed, retrieving theme from gsettings color-scheme...");
process.start(QStringLiteral("gsettings"), gsettings_arguments);
process.waitForFinished(1000);
QByteArray gsettings_output = process.readAllStandardOutput();
// Try older gtk-theme method if the previous one failed
if (gsettings_output.isEmpty()) {
LOG_INFO(Frontend, "failed, retrieving theme from gtk-theme...");
gsettings_arguments.takeLast();
gsettings_arguments << QStringLiteral("gtk-theme");
// Try alternative for Gnome if the previous one failed
QStringList gsettings_arguments;
gsettings_arguments << QStringLiteral("get")
<< QStringLiteral("org.gnome.desktop.interface")
<< QStringLiteral("color-scheme");
LOG_DEBUG(Frontend, "failed, retrieving theme from gsettings color-scheme...");
process.start(QStringLiteral("gsettings"), gsettings_arguments);
process.waitForFinished(1000);
gsettings_output = process.readAllStandardOutput();
}
QByteArray gsettings_output = process.readAllStandardOutput();
// Interpret gsettings value if it succeeded
if (!gsettings_output.isEmpty()) {
QString systeme_theme = QString::fromUtf8(gsettings_output);
LOG_DEBUG(Frontend, "Gsettings output: {}", systeme_theme.toStdString());
return systeme_theme.contains(QStringLiteral("dark"), Qt::CaseInsensitive);
}
LOG_DEBUG(Frontend, "failed, retrieving theme from palette");
// Try older gtk-theme method if the previous one failed
if (gsettings_output.isEmpty()) {
LOG_DEBUG(Frontend, "failed, retrieving theme from gtk-theme...");
gsettings_arguments.takeLast();
gsettings_arguments << QStringLiteral("gtk-theme");
process.start(QStringLiteral("gsettings"), gsettings_arguments);
process.waitForFinished(1000);
gsettings_output = process.readAllStandardOutput();
}
// Interpret gsettings value if it succeeded
if (!gsettings_output.isEmpty()) {
QString systeme_theme = QString::fromUtf8(gsettings_output);
LOG_DEBUG(Frontend, "Gsettings output: {}", systeme_theme.toStdString());
return systeme_theme.contains(QStringLiteral("dark"), Qt::CaseInsensitive);
}
LOG_DEBUG(Frontend, "failed, retrieving theme from palette");
#endif
// Use default method based on palette swap by OS.
// It is the only method on Windows with Qt 5.
// Windows needs QT_QPA_PLATFORM env variable set to windows:darkmode=2 to force palette change
return (current_palette.color(QPalette::WindowText).lightness() >
current_palette.color(QPalette::Window).lightness());
// Use default method based on palette swap by OS. It is the only method on Windows with
// Qt 5. Windows needs QT_QPA_PLATFORM env variable set to windows:darkmode=2 to force
// palette change
return (current_palette.color(QPalette::WindowText).lightness() >
current_palette.color(QPalette::Window).lightness());
}
}
void GMainWindow::changeEvent(QEvent* event) {
@ -5076,9 +5108,9 @@ void GMainWindow::changeEvent(QEvent* event) {
// UpdateUITheme is a decent work around
if (event->type() == QEvent::PaletteChange ||
event->type() == QEvent::ApplicationPaletteChange) {
LOG_INFO(Frontend,
"Window color palette changed by event: {} (QEvent::PaletteChange is: {})",
event->type(), QEvent::PaletteChange);
LOG_DEBUG(Frontend,
"Window color palette changed by event: {} (QEvent::PaletteChange is: {})",
event->type(), QEvent::PaletteChange);
const QPalette test_palette(qApp->palette());
// Keeping eye on QPalette::Window to avoid looping. QPalette::Text might be useful too
const QColor window_color = test_palette.color(QPalette::Active, QPalette::Window);
@ -5270,6 +5302,31 @@ int main(int argc, char* argv[]) {
QCoreApplication::setApplicationName(QStringLiteral("suyu"));
#ifdef _WIN32
QByteArray current_qt_qpa = qgetenv("QT_QPA_PLATFORM");
// Follow dark mode setting, if the "-platform" launch option is not set.
// Otherwise, just follow dark mode for the window decoration (title bar).
if (!current_qt_qpa.contains(":darkmode=")) {
if (UISettings::values.dark_mode_state == DarkModeState::Auto) {
// When setting is Auto, force adapting window decoration and stylesheet palette to use
// Windows theme. Default is darkmode:0, which always uses light palette
if (current_qt_qpa.isEmpty()) {
// Set the value
qputenv("QT_QPA_PLATFORM", QByteArray("windows:darkmode=2"));
} else {
// Concatenate to the existing value
qputenv("QT_QPA_PLATFORM", current_qt_qpa + ",darkmode=2");
}
} else {
// When setting is no Auto, adapt window decoration to the palette used
if (current_qt_qpa.isEmpty()) {
// Set the value
qputenv("QT_QPA_PLATFORM", QByteArray("windows:darkmode=1"));
} else {
// Concatenate to the existing value
qputenv("QT_QPA_PLATFORM", current_qt_qpa + ",darkmode=1");
}
}
}
// Increases the maximum open file limit to 8192
_setmaxstdio(8192);
#endif

4
src/suyu/startup_checks.cpp
View File

@ -6,7 +6,6 @@
#ifdef _WIN32
#include <cstring>
#include <QByteArray>
#include <QtGlobal>
#include <processthreadsapi.h>
#include <windows.h>
#elif defined(SUYU_UNIX)
@ -38,9 +37,6 @@ void CheckVulkan() {
bool CheckEnvVars(bool* is_child) {
#ifdef _WIN32
// Force adapting theme to follow Windows dark mode
qputenv("QT_QPA_PLATFORM", QByteArray("windows:darkmode=2"));
// Check environment variable to see if we are the child
char variable_contents[8];
const DWORD startup_check_var =

3
src/suyu/uisettings.h
View File

@ -18,6 +18,7 @@
using Settings::Category;
using Settings::ConfirmStop;
using Settings::DarkModeState;
using Settings::Setting;
using Settings::SwitchableSetting;
@ -144,6 +145,7 @@ struct Values {
Setting<std::string> language{linkage, {}, "language", Category::Paths};
QString theme;
DarkModeState dark_mode_state;
// Shortcut name <Shortcut, context>
std::vector<Shortcut> shortcuts;
@ -261,3 +263,4 @@ Q_DECLARE_METATYPE(Settings::RendererBackend);
Q_DECLARE_METATYPE(Settings::ShaderBackend);
Q_DECLARE_METATYPE(Settings::AstcRecompression);
Q_DECLARE_METATYPE(Settings::AstcDecodeMode);
Q_DECLARE_METATYPE(Settings::DarkModeState);