diff --git a/kconf_update/gtktheme.cpp b/kconf_update/gtktheme.cpp index bf9993c..3b9e020 100644 --- a/kconf_update/gtktheme.cpp +++ b/kconf_update/gtktheme.cpp @@ -1,56 +1,57 @@ /* * Copyright (C) 2020 Mikhail Zolotukhin * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License or (at your option) version 3 or any later version * accepted by the membership of KDE e.V. (or its successor approved * by the membership of KDE e.V.), which shall act as a proxy * defined in Section 14 of version 3 of the license. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include +#include #include "configeditor.h" void upgradeGtk2Theme(); void upgradeGtk3Theme(); int main() { upgradeGtk2Theme(); upgradeGtk3Theme(); return 0; } void upgradeGtk2Theme() { QString currentGtk2Theme = ConfigEditor::gtk2ConfigValue(QStringLiteral("gtk-theme-name")); if (currentGtk2Theme.isEmpty() || currentGtk2Theme == QStringLiteral("oxygen-gtk") || currentGtk2Theme == QStringLiteral("BreezyGTK") || currentGtk2Theme == QStringLiteral("Orion") ) { ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-theme-name"), QStringLiteral("Breeze")); } } void upgradeGtk3Theme() { QString currentGtk3Theme = ConfigEditor::gtk3ConfigValueSettingsIni(QStringLiteral("gtk-theme-name")); if (currentGtk3Theme.isEmpty() || currentGtk3Theme == QStringLiteral("oxygen-gtk") || currentGtk3Theme == QStringLiteral("BreezyGTK") || currentGtk3Theme == QStringLiteral("Orion") ) { - ConfigEditor::setGtk3ConfigValueDconf(QStringLiteral("gtk-theme"), QStringLiteral("Breeze")); + ConfigEditor::setGtk3ConfigValueGSettings(QStringLiteral("gtk-theme"), QStringLiteral("Breeze")); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-theme-name"), QStringLiteral("Breeze")); - ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Net/ThemeName"), QStringLiteral("Breeze")); + ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Net/ThemeName"), QStringLiteral("Breeze")); } } diff --git a/kded/CMakeLists.txt b/kded/CMakeLists.txt index 75af803..96601c3 100644 --- a/kded/CMakeLists.txt +++ b/kded/CMakeLists.txt @@ -1,31 +1,32 @@ set(kscreen_daemon_SRCS gtkconfig.cpp configeditor.cpp configvalueprovider.cpp themepreviewer.cpp ) add_library(gtkconfig MODULE ${kscreen_daemon_SRCS}) target_compile_definitions(gtkconfig PUBLIC -DQT_NO_SIGNALS_SLOTS_KEYWORDS ) target_include_directories(gtkconfig PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${GTK3_INCLUDE_DIRS} ) target_link_libraries(gtkconfig Qt5::DBus KF5::CoreAddons KF5::ConfigCore KF5::DBusAddons KF5::IconThemes + PkgConfig::GTK+3 PkgConfig::GIO PkgConfig::GObject ) install(TARGETS gtkconfig DESTINATION ${KDE_INSTALL_PLUGINDIR}/kf5/kded) diff --git a/kded/configeditor.cpp b/kded/configeditor.cpp index 3074f70..e044491 100644 --- a/kded/configeditor.cpp +++ b/kded/configeditor.cpp @@ -1,238 +1,235 @@ /* * Copyright (C) 2019 Mikhail Zolotukhin * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License or (at your option) version 3 or any later version * accepted by the membership of KDE e.V. (or its successor approved * by the membership of KDE e.V.), which shall act as a proxy * defined in Section 14 of version 3 of the license. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include #include #include #include #include +#include #include #include #include #include #include #include #include "configeditor.h" -void ConfigEditor::setGtk3ConfigValueDconf(const QString ¶mName, bool paramValue, const QString &category) +void ConfigEditor::setGtk3ConfigValueGSettings(const QString ¶mName, const QVariant ¶mValue, const QString &category) { g_autoptr(GSettings) gsettings = g_settings_new(category.toUtf8().constData()); - g_settings_set_boolean(gsettings, paramName.toUtf8().constData(), paramValue); + + if (paramValue.type() == QVariant::Type::String) { + g_settings_set_string(gsettings, paramName.toUtf8().constData(), paramValue.toString().toUtf8().constData()); + } else if (paramValue.type() == QVariant::Type::Int) { + g_settings_set_int(gsettings, paramName.toUtf8().constData(), paramValue.toInt()); + } else if (paramValue.type() == QVariant::Type::Bool) { + g_settings_set_boolean(gsettings, paramName.toUtf8().constData(), paramValue.toBool()); + } } -void ConfigEditor::setGtk3ConfigValueDconf(const QString ¶mName, const QString ¶mValue, const QString &category) +void ConfigEditor::setGtk3ConfigValueGSettingsAsEnum(const QString& paramName, int paramValue, const QString& category) { g_autoptr(GSettings) gsettings = g_settings_new(category.toUtf8().constData()); - g_settings_set_string(gsettings, paramName.toUtf8().constData(), paramValue.toUtf8().constData()); + g_settings_set_enum(gsettings, paramName.toUtf8().constData(), paramValue); } -void ConfigEditor::setGtk3ConfigValueSettingsIni(const QString ¶mName, const QString ¶mValue) +void ConfigEditor::setGtk3ConfigValueSettingsIni(const QString ¶mName, const QVariant ¶mValue) { QString configLocation = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation); QString gtk3ConfigPath = configLocation + QStringLiteral("/gtk-3.0/settings.ini"); KSharedConfig::Ptr gtk3Config = KSharedConfig::openConfig(gtk3ConfigPath, KConfig::NoGlobals); KConfigGroup group = gtk3Config->group(QStringLiteral("Settings")); group.writeEntry(paramName, paramValue); group.sync(); } -void ConfigEditor::setGtk3ConfigValueXSettingsd(const QString ¶mName, const QString ¶mValue) +void ConfigEditor::setGtk3ConfigValueXSettingsd(const QString ¶mName, const QVariant ¶mValue) { - using qsp = QStandardPaths; - QString configLocation = qsp::writableLocation(qsp::GenericConfigLocation); + QString configLocation = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation); QDir xsettingsdPath = configLocation + QStringLiteral("/xsettingsd"); if (!xsettingsdPath.exists()) { xsettingsdPath.mkpath(QStringLiteral(".")); } QString xSettingsdConfigPath = xsettingsdPath.path() + QStringLiteral("/xsettingsd.conf"); QFile xSettingsdConfig(xSettingsdConfigPath); QString xSettingsdConfigContents = readFileContents(xSettingsdConfig); replaceValueInXSettingsdContents(xSettingsdConfigContents, paramName, paramValue); xSettingsdConfig.remove(); xSettingsdConfig.open(QIODevice::WriteOnly | QIODevice::Text); xSettingsdConfig.write(xSettingsdConfigContents.toUtf8()); reloadXSettingsd(); } -void ConfigEditor::setGtk2ConfigValue(const QString ¶mName, const QString ¶mValue) +void ConfigEditor::setGtk2ConfigValue(const QString ¶mName, const QVariant ¶mValue) { QString gtkrcPath = qEnvironmentVariable("GTK2_RC_FILES", QDir::homePath() + QStringLiteral("/.gtkrc-2.0")); if (gtkrcPath.contains(QStringLiteral(":/"))) { // I.e. env variable contains multiple paths gtkrcPath = QDir::homePath() + QStringLiteral("/.gtkrc-2.0"); } QFile gtkrc(gtkrcPath); QString gtkrcContents = readFileContents(gtkrc); replaceValueInGtkrcContents(gtkrcContents, paramName, paramValue); gtkrc.remove(); gtkrc.open(QIODevice::WriteOnly | QIODevice::Text); gtkrc.write(gtkrcContents.toUtf8()); reloadGtk2Apps(); } QString ConfigEditor::gtk2ConfigValue(const QString& paramName) { QString gtkrcPath = QDir::homePath() + QStringLiteral("/.gtkrc-2.0"); QFile gtkrc(gtkrcPath); if (gtkrc.open(QIODevice::ReadWrite | QIODevice::Text)) { const QRegularExpression regExp(paramName + QStringLiteral("=[^\n]*($|\n)")); while (!gtkrc.atEnd()) { QString line = gtkrc.readLine(); if (line.contains(regExp)) { return line.split('"')[1]; } } } return QString(); } QString ConfigEditor::gtk3ConfigValueSettingsIni(const QString& paramName) { QString configLocation = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation); QString gtk3ConfigPath = configLocation + QStringLiteral("/gtk-3.0/settings.ini"); KSharedConfig::Ptr gtk3Config = KSharedConfig::openConfig(gtk3ConfigPath, KConfig::NoGlobals); KConfigGroup group = gtk3Config->group(QStringLiteral("Settings")); return group.readEntry(paramName); } void ConfigEditor::removeLegacyGtk2Strings() { QString gtkrcPath = QDir::homePath() + QStringLiteral("/.gtkrc-2.0"); QFile gtkrc(gtkrcPath); QString gtkrcContents = readFileContents(gtkrc); // Remove "include" lines // Example: // include "/usr/share/themes/Adwaita-dark/gtk-2.0/gtkrc" static const QRegularExpression includeRegExp(QStringLiteral("include .*\n")); gtkrcContents.remove(includeRegExp); // Remove redundant font config lines // Example: // style "user-font" // { // font_name="Noto Sans Regular" // } // widget_class "*" style "user-font" static const QRegularExpression userFontStyleRegexp(QStringLiteral("style(.|\n)*{(.|\n)*}\nwidget_class.*\"user-font\"")); gtkrcContents.remove(userFontStyleRegexp); gtkrc.remove(); gtkrc.open(QIODevice::WriteOnly | QIODevice::Text); gtkrc.write(gtkrcContents.toUtf8()); reloadGtk2Apps(); } QString ConfigEditor::readFileContents(QFile &file) { if (file.open(QIODevice::ReadWrite | QIODevice::Text)) { return file.readAll(); } else { return QString(); } } -void ConfigEditor::replaceValueInGtkrcContents(QString >krcContents, const QString ¶mName, const QString ¶mValue) +void ConfigEditor::replaceValueInGtkrcContents(QString >krcContents, const QString ¶mName, const QVariant ¶mValue) { const QRegularExpression regExp(paramName + QStringLiteral("=[^\n]*($|\n)")); - static const QStringList nonStringProperties{ - QStringLiteral("gtk-toolbar-style"), - QStringLiteral("gtk-menu-images"), - QStringLiteral("gtk-button-images"), - QStringLiteral("gtk-primary-button-warps-slider"), - QStringLiteral("gtk-enable-animations"), - }; - QString newConfigString; - if (nonStringProperties.contains(paramName)) { - newConfigString = paramName + QStringLiteral("=") + paramValue + QStringLiteral("\n"); + if (paramValue.type() == QVariant::Type::String) { + newConfigString = QStringLiteral("%1=\"%2\"\n").arg(paramName, paramValue.toString()); + } else if (paramValue.type() == QVariant::Type::Bool) { + // GTK2 does not support 'true' and 'false' as values + newConfigString = QStringLiteral("%1=%2\n").arg(paramName, QString::number(paramValue.toInt())); } else { - newConfigString = paramName + QStringLiteral("=\"") + paramValue + QStringLiteral("\"\n"); + newConfigString = QStringLiteral("%1=%2\n").arg(paramName, paramValue.toString()); } if (gtkrcContents.contains(regExp)) { gtkrcContents.replace(regExp, newConfigString); } else { - gtkrcContents = newConfigString + QStringLiteral("\n") + gtkrcContents; + gtkrcContents = newConfigString + gtkrcContents; } } -void ConfigEditor::replaceValueInXSettingsdContents(QString &xSettingsdContents, const QString ¶mName, const QString ¶mValue) +void ConfigEditor::replaceValueInXSettingsdContents(QString &xSettingsdContents, const QString ¶mName, const QVariant ¶mValue) { const QRegularExpression regExp(paramName + QStringLiteral(" [^\n]*($|\n)")); - static const QStringList nonStringProperties{ - QStringLiteral("Gtk/ButtonImages"), - QStringLiteral("Gtk/MenuImages"), - QStringLiteral("Gtk/ToolbarStyle"), - QStringLiteral("Gtk/PrimaryButtonWarpsSlider"), - QStringLiteral("Gtk/EnableAnimations"), - }; - QString newConfigString; - if (nonStringProperties.contains(paramName)) { - newConfigString = paramName + QStringLiteral(" ") + paramValue + QStringLiteral("\n"); + if (paramValue.type() == QVariant::Type::String) { + newConfigString = QStringLiteral("%1 \"%2\"\n").arg(paramName, paramValue.toString()); + } else if (paramValue.type() == QVariant::Type::Bool) { + // XSettigsd does not support 'true' and 'false' as values + newConfigString = QStringLiteral("%1 %2\n").arg(paramName, QString::number(paramValue.toInt())); } else { - newConfigString = paramName + QStringLiteral(" \"") + paramValue + QStringLiteral("\"\n"); + newConfigString = QStringLiteral("%1 %2\n").arg(paramName, paramValue.toString()); } if (xSettingsdContents.contains(regExp)) { xSettingsdContents.replace(regExp, newConfigString); } else { - xSettingsdContents = newConfigString + QStringLiteral("\n") + xSettingsdContents; + xSettingsdContents = newConfigString + xSettingsdContents; } } void ConfigEditor::reloadGtk2Apps() { QProcess::startDetached(QStandardPaths::findExecutable(QStringLiteral("reload_gtk_apps"))); } pid_t ConfigEditor::pidOfXSettingsd() { QProcess pidof; pidof.start(QStringLiteral("pidof"), QStringList() << QStringLiteral("-s") << QStringLiteral("xsettingsd")); pidof.waitForFinished(); QString xsettingsdPid = QString(pidof.readAllStandardOutput()).remove('\n'); return xsettingsdPid.toInt(); } void ConfigEditor::reloadXSettingsd() { pid_t xSettingsdPid = pidOfXSettingsd(); if (xSettingsdPid == 0) { QProcess::startDetached(QStandardPaths::findExecutable(QStringLiteral("xsettingsd"))); } else { kill(xSettingsdPid, SIGHUP); } } diff --git a/kded/configeditor.h b/kded/configeditor.h index 29e4727..4c0a49b 100644 --- a/kded/configeditor.h +++ b/kded/configeditor.h @@ -1,51 +1,52 @@ /* * Copyright (C) 2019 Mikhail Zolotukhin * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License or (at your option) version 3 or any later version * accepted by the membership of KDE e.V. (or its successor approved * by the membership of KDE e.V.), which shall act as a proxy * defined in Section 14 of version 3 of the license. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #pragma once #include #include class QFile; -class QString; +class QVariant; namespace ConfigEditor { - void setGtk2ConfigValue(const QString ¶mName, const QString ¶mValue); - void setGtk3ConfigValueDconf(const QString ¶mName, bool paramValue, const QString &category = QStringLiteral("org.gnome.desktop.interface")); - void setGtk3ConfigValueDconf(const QString ¶mName, const QString ¶mValue, const QString &category = QStringLiteral("org.gnome.desktop.interface")); - void setGtk3ConfigValueSettingsIni(const QString ¶mName, const QString ¶mValue); - void setGtk3ConfigValueXSettingsd(const QString ¶mName, const QString ¶mValue); + void setGtk2ConfigValue(const QString ¶mName, const QVariant ¶mValue); + + void setGtk3ConfigValueGSettings(const QString ¶mName, const QVariant ¶mValue, const QString &category = QStringLiteral("org.gnome.desktop.interface")); + void setGtk3ConfigValueGSettingsAsEnum(const QString ¶mName, int paramValue, const QString &category = QStringLiteral("org.gnome.desktop.interface")); + void setGtk3ConfigValueSettingsIni(const QString ¶mName, const QVariant ¶mValue); + void setGtk3ConfigValueXSettingsd(const QString ¶mName, const QVariant ¶mValue); QString gtk2ConfigValue(const QString& paramName); QString gtk3ConfigValueSettingsIni(const QString& paramName); void removeLegacyGtk2Strings(); - void replaceValueInGtkrcContents(QString >krcContents, const QString ¶mName, const QString ¶mValue); - void replaceValueInXSettingsdContents(QString &xSettingsdContents, const QString ¶mName, const QString ¶mValue); + void replaceValueInGtkrcContents(QString >krcContents, const QString ¶mName, const QVariant ¶mValue); + void replaceValueInXSettingsdContents(QString &xSettingsdContents, const QString ¶mName, const QVariant ¶mValue); QString readFileContents(QFile >krc); void reloadGtk2Apps(); void reloadXSettingsd(); pid_t pidOfXSettingsd(); }; diff --git a/kded/configvalueprovider.cpp b/kded/configvalueprovider.cpp index ff2c2c8..dd8c936 100644 --- a/kded/configvalueprovider.cpp +++ b/kded/configvalueprovider.cpp @@ -1,263 +1,211 @@ /* * Copyright (C) 2019 Mikhail Zolotukhin * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License or (at your option) version 3 or any later version * accepted by the membership of KDE e.V. (or its successor approved * by the membership of KDE e.V.), which shall act as a proxy * defined in Section 14 of version 3 of the license. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include #include #include #include #include #include #include +#include + #include "configvalueprovider.h" ConfigValueProvider::ConfigValueProvider() : kdeglobalsConfig(KSharedConfig::openConfig(QStringLiteral("kdeglobals"))), inputConfig(KSharedConfig::openConfig(QStringLiteral("kcminputrc"))), kwinConfig(KSharedConfig::openConfig(QStringLiteral("kwinrc"))) { } QString ConfigValueProvider::fontName() const { static const QFont defaultFont(QStringLiteral("Noto Sans"), 10); KConfigGroup configGroup = kdeglobalsConfig->group(QStringLiteral("General")); QString fontAsString = configGroup.readEntry(QStringLiteral("font"), defaultFont.toString()); static QFont font; font.fromString(fontAsString); const QString fontStyle = fontStyleHelper(font); return font.family() + QStringLiteral(", ") + fontStyle + ' ' + QString::number(font.pointSize()); } QString ConfigValueProvider::fontStyleHelper(const QFont &font) const { // BUG: 333146 // Since Qt sometimes gives us wrong font style name, // we ought to use this big helper function to construct // the style ourselves. Some fonts will not work auto weight = font.weight(); QString result; if (weight > QFont::Normal) { if (weight >= QFont::Black) { result = QStringLiteral("Black"); } else if (weight >= QFont::ExtraBold) { result = QStringLiteral("Extra Bold"); } else if (weight >= QFont::Bold) { result = QStringLiteral("Bold"); } else if (weight >= QFont::DemiBold) { result = QStringLiteral("Demi Bold"); } else if (weight >= QFont::Medium) { result = QStringLiteral("Medium"); } } else { if (weight <= QFont::Thin) { result = QStringLiteral("Thin"); } else if (weight <= QFont::ExtraLight) { result = QStringLiteral("Extra Light"); } else if (weight <= QFont::Light) { result = QStringLiteral("Light"); } } auto style = font.style(); if (style == QFont::StyleItalic) { result += QLatin1Char(' ') + QStringLiteral("Italic"); } else if (style == QFont::StyleOblique) { result += QLatin1Char(' ') + QStringLiteral("Oblique"); } auto stretch = font.stretch(); if (stretch == QFont::UltraCondensed) { result += QLatin1Char(' ') + QStringLiteral("UltraCondensed"); } else if (stretch == QFont::ExtraCondensed) { result += QLatin1Char(' ') + QStringLiteral("ExtraCondensed"); } else if (stretch == QFont::Condensed) { result += QLatin1Char(' ') + QStringLiteral("Condensed"); } else if (stretch == QFont::SemiCondensed) { result += QLatin1Char(' ') + QStringLiteral("SemiCondensed"); } else if (stretch == QFont::Unstretched) { result += QLatin1Char(' ') + QStringLiteral("Unstretched"); } else if (stretch == QFont::SemiExpanded) { result += QLatin1Char(' ') + QStringLiteral("SemiExpanded"); } else if (stretch == QFont::Expanded) { result += QLatin1Char(' ') + QStringLiteral("Expanded"); } else if (stretch == QFont::ExtraExpanded) { result += QLatin1Char(' ') + QStringLiteral("ExtraExpanded"); } else if (stretch == QFont::UltraExpanded) { result += QLatin1Char(' ') + QStringLiteral("UltraExpanded"); } return result.simplified(); } QString ConfigValueProvider::iconThemeName() const { KConfigGroup configGroup = kdeglobalsConfig->group(QStringLiteral("Icons")); return configGroup.readEntry(QStringLiteral("Theme"), QStringLiteral("breeze")); } QString ConfigValueProvider::cursorThemeName() const { KConfigGroup configGroup = inputConfig->group(QStringLiteral("Mouse")); return configGroup.readEntry(QStringLiteral("cursorTheme"), QStringLiteral("breeze_cursors")); } -QString ConfigValueProvider::iconsOnButtons() const +bool ConfigValueProvider::iconsOnButtons() const { KConfigGroup configGroup = kdeglobalsConfig->group(QStringLiteral("KDE")); - bool kdeConfigValue = configGroup.readEntry(QStringLiteral("ShowIconsOnPushButtons"), true); - - if (kdeConfigValue) { - return QStringLiteral("1"); - } else { - return QStringLiteral("0"); - } + return configGroup.readEntry(QStringLiteral("ShowIconsOnPushButtons"), true); } -QString ConfigValueProvider::iconsInMenus() const +bool ConfigValueProvider::iconsInMenus() const { KConfigGroup configGroup = kdeglobalsConfig->group(QStringLiteral("KDE")); - bool kdeConfigValue = configGroup.readEntry(QStringLiteral("ShowIconsInMenuItems"), true); - - if (kdeConfigValue) { - return QStringLiteral("1"); - } else { - return QStringLiteral("0"); - } + return configGroup.readEntry(QStringLiteral("ShowIconsInMenuItems"), true); } -QString ConfigValueProvider::toolbarStyle(ConfigValueProvider::ToolbarStyleNotation notation) const +int ConfigValueProvider::toolbarStyle() const { KConfigGroup configGroup = kdeglobalsConfig->group(QStringLiteral("Toolbar style")); QString kdeConfigValue = configGroup.readEntry(QStringLiteral("ToolButtonStyle"), "TextBesideIcon"); - return toolbarStyleInDesiredNotation(kdeConfigValue, notation); + + if (kdeConfigValue == QStringLiteral("NoText")) { + return GtkToolbarStyle::GTK_TOOLBAR_ICONS; + } else if (kdeConfigValue == QStringLiteral("TextOnly")) { + return GtkToolbarStyle::GTK_TOOLBAR_TEXT; + } else if (kdeConfigValue == QStringLiteral("TextBesideIcon")) { + return GtkToolbarStyle::GTK_TOOLBAR_BOTH_HORIZ; + } else { + return GtkToolbarStyle::GTK_TOOLBAR_BOTH; + } } -QString ConfigValueProvider::scrollbarBehavior() const +bool ConfigValueProvider::scrollbarBehavior() const { KConfigGroup configGroup = kdeglobalsConfig->group(QStringLiteral("KDE")); bool kdeConfigValue = configGroup.readEntry(QStringLiteral("ScrollbarLeftClickNavigatesByPage"), true); - if (kdeConfigValue) { // GTK setting is inverted - return QStringLiteral("0"); - } else { - return QStringLiteral("1"); - } + return !kdeConfigValue; // GTK setting is inverted } -QString ConfigValueProvider::preferDarkTheme() const +bool ConfigValueProvider::preferDarkTheme() const { KConfigGroup colorsConfigGroup = kdeglobalsConfig->group(QStringLiteral("Colors:Window")); QColor windowBackgroundColor = colorsConfigGroup.readEntry(QStringLiteral("BackgroundNormal"), QColor(239, 240, 241)); const int windowBackgroundGray = qGray(windowBackgroundColor.rgb()); // We use heuristic to determine if current color scheme is dark or not - if (windowBackgroundGray >= 192) { - return QStringLiteral("0"); - } else { - return QStringLiteral("1"); - } + return windowBackgroundGray < 192; } QString ConfigValueProvider::windowDecorationsButtonsOrder() const { KConfigGroup configGroup = kwinConfig->group(QStringLiteral("org.kde.kdecoration2")); QString buttonsOnLeftKdeConfigValue = configGroup.readEntry(QStringLiteral("ButtonsOnLeft"), "MS"); QString buttonsOnRightKdeConfigValue = configGroup.readEntry(QStringLiteral("ButtonsOnRight"), "HIAX"); QString buttonsOnLeftInGtkNotation = windowDecorationButtonsOrderInGtkNotation(buttonsOnLeftKdeConfigValue); QString buttonsOnRightInGtkNotation = windowDecorationButtonsOrderInGtkNotation(buttonsOnRightKdeConfigValue); return buttonsOnLeftInGtkNotation + QStringLiteral(":") + buttonsOnRightInGtkNotation; } -QString ConfigValueProvider::enableAnimations() const +bool ConfigValueProvider::enableAnimations() const { KConfigGroup generalCfg = kdeglobalsConfig->group(QStringLiteral("KDE")); const qreal animationSpeedModifier = qMax(0.0, generalCfg.readEntry("AnimationDurationFactor", 1.0)); - const bool enableAnimations = !qFuzzyIsNull(animationSpeedModifier); - - if (enableAnimations) { - return QStringLiteral("1"); - } else { - return QStringLiteral("0"); - } -} - -QString ConfigValueProvider::toolbarStyleInDesiredNotation(const QString &kdeConfigValue, ConfigValueProvider::ToolbarStyleNotation notation) const -{ - QStringList toolbarStyles {}; - if (notation == ToolbarStyleNotation::SettingsIni) { - toolbarStyles.append({ - QStringLiteral("GTK_TOOLBAR_ICONS"), - QStringLiteral("GTK_TOOLBAR_TEXT"), - QStringLiteral("GTK_TOOLBAR_BOTH_HORIZ"), - QStringLiteral("GTK_TOOLBAR_BOTH") - }); - } else if (notation == ToolbarStyleNotation::Xsettingsd) { - toolbarStyles.append({ - QStringLiteral("0"), - QStringLiteral("1"), - QStringLiteral("3"), - QStringLiteral("2") - }); - } else { - toolbarStyles.append({ - QStringLiteral("icons"), - QStringLiteral("text"), - QStringLiteral("both-horiz"), - QStringLiteral("both") - }); - } - - if (kdeConfigValue == QStringLiteral("NoText")) { - return toolbarStyles[0]; - } else if (kdeConfigValue == QStringLiteral("TextOnly")) { - return toolbarStyles[1]; - } else if (kdeConfigValue == QStringLiteral("TextBesideIcon")) { - return toolbarStyles[2]; - } else { - return toolbarStyles[3]; - } + return !qFuzzyIsNull(animationSpeedModifier); } QString ConfigValueProvider::windowDecorationButtonsOrderInGtkNotation(const QString &kdeConfigValue) const { QString gtkNotation; for (const QChar &buttonAbbreviation : kdeConfigValue) { if (buttonAbbreviation == 'X') { gtkNotation += QStringLiteral("close,"); } else if (buttonAbbreviation == 'I') { gtkNotation += QStringLiteral("minimize,"); } else if (buttonAbbreviation == 'A') { gtkNotation += QStringLiteral("maximize,"); } else if (buttonAbbreviation == 'M') { gtkNotation += QStringLiteral("icon,"); } } gtkNotation.chop(1); return gtkNotation; } diff --git a/kded/configvalueprovider.h b/kded/configvalueprovider.h index 4de23fd..c7ce153 100644 --- a/kded/configvalueprovider.h +++ b/kded/configvalueprovider.h @@ -1,58 +1,51 @@ /* * Copyright (C) 2019 Mikhail Zolotukhin * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License or (at your option) version 3 or any later version * accepted by the membership of KDE e.V. (or its successor approved * by the membership of KDE e.V.), which shall act as a proxy * defined in Section 14 of version 3 of the license. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #pragma once #include class QString; class QFont; class ConfigValueProvider { public: - enum class ToolbarStyleNotation { - Xsettingsd = 0, - SettingsIni, - Dconf - }; - ConfigValueProvider(); QString fontName() const; QString iconThemeName() const; QString cursorThemeName() const; - QString iconsOnButtons() const; - QString iconsInMenus() const; - QString toolbarStyle(ToolbarStyleNotation notation) const; - QString scrollbarBehavior() const; - QString preferDarkTheme() const; + bool iconsOnButtons() const; + bool iconsInMenus() const; + int toolbarStyle() const; + bool scrollbarBehavior() const; + bool preferDarkTheme() const; QString windowDecorationsButtonsOrder() const; - QString enableAnimations() const; + bool enableAnimations() const; private: QString fontStyleHelper(const QFont &font) const; - QString toolbarStyleInDesiredNotation(const QString &kdeConfigValue, ToolbarStyleNotation notation) const; QString windowDecorationButtonsOrderInGtkNotation(const QString &kdeConfigValue) const; KSharedConfigPtr kdeglobalsConfig; KSharedConfigPtr inputConfig; KSharedConfigPtr kwinConfig; }; diff --git a/kded/gtkconfig.cpp b/kded/gtkconfig.cpp index 5d3fb38..7e6392f 100644 --- a/kded/gtkconfig.cpp +++ b/kded/gtkconfig.cpp @@ -1,249 +1,243 @@ /* * Copyright (C) 2019 Mikhail Zolotukhin * Copyright (C) 2019 Nicolas Fella * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License or (at your option) version 3 or any later version * accepted by the membership of KDE e.V. (or its successor approved * by the membership of KDE e.V.), which shall act as a proxy * defined in Section 14 of version 3 of the license. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include #include #include #include #include #include #include #include "gtkconfig.h" #include "configvalueprovider.h" #include "themepreviewer.h" K_PLUGIN_CLASS_WITH_JSON(GtkConfig, "gtkconfig.json") GtkConfig::GtkConfig(QObject *parent, const QVariantList&) : KDEDModule(parent), configValueProvider(new ConfigValueProvider()), themePreviewer(new ThemePreviewer(this)), kdeglobalsConfigWatcher(KConfigWatcher::create(KSharedConfig::openConfig(QStringLiteral("kdeglobals")))), kwinConfigWatcher(KConfigWatcher::create(KSharedConfig::openConfig(QStringLiteral("kwinrc")))), kcminputConfigWatcher(KConfigWatcher::create(KSharedConfig::openConfig(QStringLiteral("kcminputrc")))) { QDBusConnection dbus = QDBusConnection::sessionBus(); dbus.registerService(QStringLiteral("org.kde.GtkConfig")); dbus.registerObject(QStringLiteral("/GtkConfig"), this, QDBusConnection::ExportScriptableSlots); connect(kdeglobalsConfigWatcher.data(), &KConfigWatcher::configChanged, this, &GtkConfig::onKdeglobalsSettingsChange); connect(kwinConfigWatcher.data(), &KConfigWatcher::configChanged, this, &GtkConfig::onKWinSettingsChange); connect(kcminputConfigWatcher.data(), &KConfigWatcher::configChanged, this, &GtkConfig::onKCMInputSettingsChange); ConfigEditor::removeLegacyGtk2Strings(); applyAllSettings(); } GtkConfig::~GtkConfig() { QDBusConnection dbus = QDBusConnection::sessionBus(); dbus.unregisterService(QStringLiteral("org.kde.GtkConfig")); dbus.unregisterObject(QStringLiteral("/GtkConfig")); } void GtkConfig::setGtk2Theme(const QString &themeName) const { ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-theme-name"), themeName); } void GtkConfig::setGtk3Theme(const QString &themeName) const { - ConfigEditor::setGtk3ConfigValueDconf(QStringLiteral("gtk-theme"), themeName); + ConfigEditor::setGtk3ConfigValueGSettings(QStringLiteral("gtk-theme"), themeName); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-theme-name"), themeName); ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Net/ThemeName"), themeName); } QString GtkConfig::gtk2Theme() const { return ConfigEditor::gtk2ConfigValue(QStringLiteral("gtk-theme-name")); } QString GtkConfig::gtk3Theme() const { return ConfigEditor::gtk3ConfigValueSettingsIni(QStringLiteral("gtk-theme-name")); } void GtkConfig::showGtk2ThemePreview(const QString& themeName) const { themePreviewer->showGtk2App(themeName); } void GtkConfig::showGtk3ThemePreview(const QString& themeName) const { themePreviewer->showGtk3App(themeName); } void GtkConfig::setFont() const { const QString configFontName = configValueProvider->fontName(); ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-font-name"), configFontName); - ConfigEditor::setGtk3ConfigValueDconf(QStringLiteral("font-name"), configFontName); + ConfigEditor::setGtk3ConfigValueGSettings(QStringLiteral("font-name"), configFontName); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-font-name"), configFontName); ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Gtk/FontName"), configFontName); } void GtkConfig::setIconTheme() const { const QString iconThemeName = configValueProvider->iconThemeName(); ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-icon-theme-name"), iconThemeName); - ConfigEditor::setGtk3ConfigValueDconf(QStringLiteral("icon-theme"), iconThemeName); + ConfigEditor::setGtk3ConfigValueGSettings(QStringLiteral("icon-theme"), iconThemeName); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-icon-theme-name"), iconThemeName); ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Net/IconThemeName"), iconThemeName); } void GtkConfig::setCursorTheme() const { const QString cursorThemeName = configValueProvider->cursorThemeName(); ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-cursor-theme-name"), cursorThemeName); - ConfigEditor::setGtk3ConfigValueDconf(QStringLiteral("cursor-theme"), cursorThemeName); + ConfigEditor::setGtk3ConfigValueGSettings(QStringLiteral("cursor-theme"), cursorThemeName); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-cursor-theme-name"), cursorThemeName); ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Gtk/CursorThemeName"), cursorThemeName); } void GtkConfig::setIconsOnButtons() const { - const QString iconsOnButtonsConfigValue = configValueProvider->iconsOnButtons(); + const bool iconsOnButtonsConfigValue = configValueProvider->iconsOnButtons(); ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-button-images"), iconsOnButtonsConfigValue); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-button-images"), iconsOnButtonsConfigValue); ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Gtk/ButtonImages"), iconsOnButtonsConfigValue); } void GtkConfig::setIconsInMenus() const { - const QString iconsInMenusConfigValue = configValueProvider->iconsInMenus(); + const bool iconsInMenusConfigValue = configValueProvider->iconsInMenus(); ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-menu-images"), iconsInMenusConfigValue); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-menu-images"), iconsInMenusConfigValue); ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Gtk/MenuImages"), iconsInMenusConfigValue); } void GtkConfig::setToolbarStyle() const { - using ToolbarStyleNotation = ConfigValueProvider::ToolbarStyleNotation; - - QString toolbarStyleSettingsIni = configValueProvider->toolbarStyle(ToolbarStyleNotation::SettingsIni); - QString toolbarStyleDConf = configValueProvider->toolbarStyle(ToolbarStyleNotation::Dconf); - QString toolbarStyleXSettingsd = configValueProvider->toolbarStyle(ToolbarStyleNotation::Xsettingsd); - - ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-toolbar-style"), toolbarStyleSettingsIni); - ConfigEditor::setGtk3ConfigValueDconf(QStringLiteral("toolbar-style"), toolbarStyleDConf); - ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-toolbar-style"), toolbarStyleSettingsIni); - ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Gtk/ToolbarStyle"), toolbarStyleXSettingsd); + const int toolbarStyle = configValueProvider->toolbarStyle(); + ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-toolbar-style"), toolbarStyle); + ConfigEditor::setGtk3ConfigValueGSettingsAsEnum(QStringLiteral("toolbar-style"), toolbarStyle); + ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-toolbar-style"), toolbarStyle); + ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Gtk/ToolbarStyle"), toolbarStyle); } void GtkConfig::setScrollbarBehavior() const { - const QString scrollbarBehavior = configValueProvider->scrollbarBehavior(); + const bool scrollbarBehavior = configValueProvider->scrollbarBehavior(); ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-primary-button-warps-slider"), scrollbarBehavior); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-primary-button-warps-slider"), scrollbarBehavior); ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Gtk/PrimaryButtonWarpsSlider"), scrollbarBehavior); } void GtkConfig::setDarkThemePreference() const { - const QString preferDarkTheme = configValueProvider->preferDarkTheme(); + const bool preferDarkTheme = configValueProvider->preferDarkTheme(); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-application-prefer-dark-theme"), preferDarkTheme); } void GtkConfig::setWindowDecorationsButtonsOrder() const { const QString windowDecorationsButtonOrder = configValueProvider->windowDecorationsButtonsOrder(); - ConfigEditor::setGtk3ConfigValueDconf(QStringLiteral("button-layout"), windowDecorationsButtonOrder, QStringLiteral("org.gnome.desktop.wm.preferences")); + ConfigEditor::setGtk3ConfigValueGSettings(QStringLiteral("button-layout"), windowDecorationsButtonOrder, QStringLiteral("org.gnome.desktop.wm.preferences")); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-decoration-layout"), windowDecorationsButtonOrder); ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Gtk/DecorationLayout"), windowDecorationsButtonOrder); } void GtkConfig::setEnableAnimations() const { - const QString enableAnimations = configValueProvider->enableAnimations(); + const bool enableAnimations = configValueProvider->enableAnimations(); ConfigEditor::setGtk2ConfigValue(QStringLiteral("gtk-enable-animations"), enableAnimations); - // FIXME work with booleans in configValueProvider... - ConfigEditor::setGtk3ConfigValueDconf(QStringLiteral("enable-animations"), enableAnimations == QLatin1String("1")); + ConfigEditor::setGtk3ConfigValueGSettings(QStringLiteral("enable-animations"), enableAnimations); ConfigEditor::setGtk3ConfigValueSettingsIni(QStringLiteral("gtk-enable-animations"), enableAnimations); ConfigEditor::setGtk3ConfigValueXSettingsd(QStringLiteral("Gtk/EnableAnimations"), enableAnimations); } void GtkConfig::applyAllSettings() const { setFont(); setIconTheme(); setCursorTheme(); setIconsOnButtons(); setIconsInMenus(); setToolbarStyle(); setScrollbarBehavior(); setDarkThemePreference(); setWindowDecorationsButtonsOrder(); setEnableAnimations(); } void GtkConfig::onKdeglobalsSettingsChange(const KConfigGroup &group, const QByteArrayList &names) const { if (group.name() == QStringLiteral("KDE")) { if (names.contains(QByteArrayLiteral("AnimationDurationFactor"))) { setEnableAnimations(); } if (names.contains(QByteArrayLiteral("ShowIconsInMenuItems"))) { setIconsInMenus(); } if (names.contains(QByteArrayLiteral("ShowIconsOnPushButtons"))) { setIconsOnButtons(); } if (names.contains(QByteArrayLiteral("ScrollbarLeftClickNavigatesByPage"))) { setScrollbarBehavior(); } } else if (group.name() == QStringLiteral("Icons")) { if (names.contains(QByteArrayLiteral("Theme"))) { setIconTheme(); } } else if (group.name() == QStringLiteral("General")) { if (names.contains(QByteArrayLiteral("font"))) { setFont(); } if (names.contains(QByteArrayLiteral("ColorScheme"))) { setDarkThemePreference(); } } else if (group.name() == QStringLiteral("Toolbar style")) { if (names.contains(QByteArrayLiteral("ToolButtonStyle"))) { setToolbarStyle(); } } } void GtkConfig::onKWinSettingsChange(const KConfigGroup &group, const QByteArrayList &names) const { if (group.name() == QStringLiteral("org.kde.kdecoration2") && (names.contains("ButtonsOnRight") || names.contains("ButtonsOnLeft"))) { setWindowDecorationsButtonsOrder(); } } void GtkConfig::onKCMInputSettingsChange(const KConfigGroup& group, const QByteArrayList& names) const { if (group.name() == QStringLiteral("Mouse") && names.contains("cursorTheme")) { setCursorTheme(); } } #include "gtkconfig.moc"