File indexing completed on 2024-04-21 14:55:54

 /* This file is part of the KDE libraries
    Copyright (C) 2000, 2006 David Faure <faure@kde.org>
    Copyright 2008 Friedrich W. H. Kossebau <kossebau@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library 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
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "kglobalsettings.h"
 
 #include <ktoolbar.h>
 #include <kconfig.h>
 #include <kcolorscheme.h>
 
 //#include <kstyle.h>
 
 #include <QColor>
 #include <QCursor>
 #include <QDesktopWidget>
 #include <QDir>
 #include <QFont>
 #include <QFontDatabase>
 #include <QFontInfo>
 #include <QKeySequence>
 #include <QPixmap>
 #include <QPixmapCache>
 #include <QApplication>
 #include <QDBusConnection>
 #include <QStyleFactory>
 #include <QDebug>
 #include <qstandardpaths.h>
 
 // next two needed so we can set their palettes
 #include <QDBusMessage>
 #include <QToolTip>
 #include <QUrl>
 #include <QWhatsThis>
 
 #ifdef Q_OS_WIN
 #include <windows.h>
 
 static QRgb qt_colorref2qrgb(COLORREF col)
 {
     return qRgb(GetRValue(col), GetGValue(col), GetBValue(col));
 }
 #endif
 #include <config-kdelibs4support.h>
 #if HAVE_X11
 #include <X11/Xlib.h>
 #ifdef HAVE_XCURSOR // TODO NOT DEFINED ANYMORE. Can we drop X cursor themes?
 #include <X11/Xcursor/Xcursor.h>
 #endif
 //#include "fixx11h.h"
 #include <QX11Info>
 #endif
 
 #include <stdlib.h>
 #include <kconfiggroup.h>
 #include <kiconloader.h>
 
 //static QColor *_buttonBackground = 0;
 static KGlobalSettings::GraphicEffects _graphicEffects = KGlobalSettings::NoEffects;
 
 class Q_DECL_HIDDEN KGlobalSettings::Private
 {
 public:
     Private(KGlobalSettings *q)
     : q(q), activated(false), paletteCreated(false), mMouseSettings(nullptr), mLargeFont(nullptr)
 #if HAVE_X11
         , isX11(QX11Info::isPlatformX11())
 #endif
     {
         kdeFullSession = !qgetenv("KDE_FULL_SESSION").isEmpty();
     }
 
     QPalette createApplicationPalette(const KSharedConfigPtr &config);
     QPalette createNewApplicationPalette(const KSharedConfigPtr &config);
     void _k_slotNotifyChange(int, int);
     void _k_slotIconChange(int);
 
     void propagateQtSettings();
     void kdisplaySetPalette();
     void kdisplaySetStyle();
     void kdisplaySetFont();
     void applyGUIStyle();
     void dropMouseSettingsCache();
     KGlobalSettings::KMouseSettings &mouseSettings();
 
     /**
      * @internal
      *
      * Ensures that cursors are loaded from the theme KDE is configured
      * to use. Note that calling this function doesn't cause existing
      * cursors to be reloaded. Reloading already created cursors is
      * handled by the KCM when a cursor theme is applied.
      *
      * It is not necessary to call this function when KGlobalSettings
      * is initialized.
      */
     void applyCursorTheme();
 
     static void reloadStyleSettings();
 
     QFont largeFont(const QString &text);
 
     KGlobalSettings *q;
     bool activated;
     bool paletteCreated;
     bool kdeFullSession;
     QPalette applicationPalette;
     KGlobalSettings::KMouseSettings *mMouseSettings;
     QFont *mLargeFont;
 #if HAVE_X11
     bool isX11;
 #endif
 };
 
 // class for access to KGlobalSettings constructor
 class KGlobalSettingsSingleton
 {
 public:
     KGlobalSettings object;
 };
 
 Q_GLOBAL_STATIC(KGlobalSettingsSingleton, s_self)
 
 KGlobalSettings *KGlobalSettings::self()
 {
     return &s_self()->object;
 }
 
 KGlobalSettings::KGlobalSettings()
     : QObject(nullptr), d(new Private(this))
 {
     connect(this, SIGNAL(kdisplayFontChanged()), SIGNAL(appearanceChanged()));
 }
 
 KGlobalSettings::~KGlobalSettings()
 {
     delete d;
 }
 
 void KGlobalSettings::activate()
 {
     activate(ApplySettings | ListenForChanges);
 }
 
 void KGlobalSettings::activate(ActivateOptions options)
 {
     if (!d->activated) {
         d->activated = true;
 
         if (options & ListenForChanges) {
             QDBusConnection::sessionBus().connect(QString(), "/KGlobalSettings", "org.kde.KGlobalSettings",
                                                   "notifyChange", this, SLOT(_k_slotNotifyChange(int,int)));
             QDBusConnection::sessionBus().connect(QString(), "/KIconLoader", "org.kde.KIconLoader",
                                                   "iconChanged", this, SLOT(_k_slotIconChange(int)));
             QDBusConnection::sessionBus().connect(QString(), "/KDEPlatformTheme", "org.kde.KDEPlatformTheme",
                                                   "refreshFonts", this, SLOT(kdisplayFontChanged()));
         }
 
         if (options & ApplySettings) {
             d->kdisplaySetStyle(); // implies palette setup
             d->propagateQtSettings();
         }
     }
 }
 
 // Qt5 TODO: implement QPlatformIntegration::styleHint so that it reads a Qt or KDE setting,
 // so that apps can just use QApplication::startDragDistance().
 int KGlobalSettings::dndEventDelay()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "General");
     return g.readEntry("StartDragDist", QApplication::startDragDistance());
 }
 
 bool KGlobalSettings::singleClick()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "KDE");
     return g.readEntry("SingleClick", KDE_DEFAULT_SINGLECLICK);
 }
 
 bool KGlobalSettings::changeCursorOverIcon()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "KDE");
     return g.readEntry("ChangeCursor", KDE_DEFAULT_CHANGECURSOR);
 }
 
 int KGlobalSettings::autoSelectDelay()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "KDE");
     return g.readEntry("AutoSelectDelay", KDE_DEFAULT_AUTOSELECTDELAY);
 }
 
 KGlobalSettings::Completion KGlobalSettings::completionMode()
 {
     int completion;
     KConfigGroup g(KSharedConfig::openConfig(), "General");
     completion = g.readEntry("completionMode", -1);
     if ((completion < (int) CompletionNone) ||
             (completion > (int) CompletionPopupAuto)) {
         completion = (int) CompletionPopup; // Default
     }
     return (Completion) completion;
 }
 
 bool KGlobalSettings::showContextMenusOnPress()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "ContextMenus");
     return g.readEntry("ShowOnPress", true);
 }
 
 // NOTE: keep this in sync with kdebase/workspace/kcontrol/colors/colorscm.cpp
 QColor KGlobalSettings::inactiveTitleColor()
 {
 #ifdef Q_OS_WIN
     return qt_colorref2qrgb(GetSysColor(COLOR_INACTIVECAPTION));
 #else
     KConfigGroup g(KSharedConfig::openConfig(), "WM");
     return g.readEntry("inactiveBackground", QColor(224, 223, 222));
 #endif
 }
 
 // NOTE: keep this in sync with kdebase/workspace/kcontrol/colors/colorscm.cpp
 QColor KGlobalSettings::inactiveTextColor()
 {
 #ifdef Q_OS_WIN
     return qt_colorref2qrgb(GetSysColor(COLOR_INACTIVECAPTIONTEXT));
 #else
     KConfigGroup g(KSharedConfig::openConfig(), "WM");
     return g.readEntry("inactiveForeground", QColor(75, 71, 67));
 #endif
 }
 
 // NOTE: keep this in sync with kdebase/workspace/kcontrol/colors/colorscm.cpp
 QColor KGlobalSettings::activeTitleColor()
 {
 #ifdef Q_OS_WIN
     return qt_colorref2qrgb(GetSysColor(COLOR_ACTIVECAPTION));
 #else
     KConfigGroup g(KSharedConfig::openConfig(), "WM");
     return g.readEntry("activeBackground", QColor(48, 174, 232));
 #endif
 }
 
 // NOTE: keep this in sync with kdebase/workspace/kcontrol/colors/colorscm.cpp
 QColor KGlobalSettings::activeTextColor()
 {
 #ifdef Q_OS_WIN
     return qt_colorref2qrgb(GetSysColor(COLOR_CAPTIONTEXT));
 #else
     KConfigGroup g(KSharedConfig::openConfig(), "WM");
     return g.readEntry("activeForeground", QColor(255, 255, 255));
 #endif
 }
 
 int KGlobalSettings::contrast()
 {
     return KColorScheme::contrast();
 }
 
 qreal KGlobalSettings::contrastF(const KSharedConfigPtr &config)
 {
     return KColorScheme::contrastF(config);
 }
 
 bool KGlobalSettings::shadeSortColumn()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "General");
     return g.readEntry("shadeSortColumn", KDE_DEFAULT_SHADE_SORT_COLUMN);
 }
 
 bool KGlobalSettings::allowDefaultBackgroundImages()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "General");
     return g.readEntry("allowDefaultBackgroundImages", KDE_DEFAULT_ALLOW_DEFAULT_BACKGROUND_IMAGES);
 }
 
 //inspired in old KGlobalSettingsData code
 QFont constructFontFromConfig(const char *groupKey, const char *configKey)
 {
     const KConfigGroup configGroup(KSharedConfig::openConfig(), groupKey);
     QFont ret;
     ret.setStyleHint(QFont::SansSerif);
     ret = configGroup.readEntry(configKey, ret);
     return ret;
 }
 
 QFont KGlobalSettings::generalFont()
 {
     return QFontDatabase::systemFont(QFontDatabase::GeneralFont);
 }
 QFont KGlobalSettings::fixedFont()
 {
     return QFontDatabase::systemFont(QFontDatabase::FixedFont);
 }
 QFont KGlobalSettings::windowTitleFont()
 {
     return QFontDatabase::systemFont(QFontDatabase::TitleFont);
 }
 QFont KGlobalSettings::smallestReadableFont()
 {
     return QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont);
 }
 QFont KGlobalSettings::toolBarFont()
 {
     return constructFontFromConfig("General", "toolBarFont");
 }
 QFont KGlobalSettings::menuFont()
 {
     return constructFontFromConfig("General", "menuFont");
 }
 QFont KGlobalSettings::taskbarFont()
 {
     return constructFontFromConfig("General", "taskbarFont");
 }
 
 QFont KGlobalSettings::Private::largeFont(const QString &text)
 {
     QFontDatabase db;
     QStringList fam = db.families();
 
     // Move a bunch of preferred fonts to the front.
     // most preferred last
     static const char *const PreferredFontNames[] = {
         "Arial",
         "Sans Serif",
         "Verdana",
         "Tahoma",
         "Lucida Sans",
         "Lucidux Sans",
         "Nimbus Sans",
         "Gothic I"
     };
     static const unsigned int PreferredFontNamesCount = sizeof(PreferredFontNames) / sizeof(const char *);
     for (unsigned int i = 0; i < PreferredFontNamesCount; ++i) {
         const QString fontName(PreferredFontNames[i]);
         if (fam.removeAll(fontName) > 0) {
             fam.prepend(fontName);
         }
     }
 
     if (mLargeFont) {
         fam.prepend(mLargeFont->family());
         delete mLargeFont;
     }
 
     for (QStringList::ConstIterator it = fam.constBegin();
             it != fam.constEnd(); ++it) {
         if (db.isSmoothlyScalable(*it) && !db.isFixedPitch(*it)) {
             QFont font(*it);
             font.setPixelSize(75);
             QFontMetrics metrics(font);
             int h = metrics.height();
             if ((h < 60) || (h > 90)) {
                 continue;
             }
 
             bool ok = true;
             for (int i = 0; i < text.length(); i++) {
                 if (!metrics.inFont(text[i])) {
                     ok = false;
                     break;
                 }
             }
             if (!ok) {
                 continue;
             }
 
             font.setPointSize(48);
             mLargeFont = new QFont(font);
             return *mLargeFont;
         }
     }
     mLargeFont = new QFont(q->generalFont());
     mLargeFont->setPointSize(48);
     return *mLargeFont;
 }
 
 QFont KGlobalSettings::largeFont(const QString &text)
 {
     return self()->d->largeFont(text);
 }
 
 KGlobalSettings::KMouseSettings &KGlobalSettings::Private::mouseSettings()
 {
     if (!mMouseSettings) {
         mMouseSettings = new KGlobalSettings::KMouseSettings;
         KGlobalSettings::KMouseSettings &s = *mMouseSettings; // for convenience
 
 #ifndef Q_OS_WIN
         KConfigGroup g(KSharedConfig::openConfig(), "Mouse");
         QString setting = g.readEntry("MouseButtonMapping");
         if (setting == "RightHanded") {
             s.handed = KGlobalSettings::KMouseSettings::RightHanded;
         } else if (setting == "LeftHanded") {
             s.handed = KGlobalSettings::KMouseSettings::LeftHanded;
         } else {
 #if HAVE_X11
         if (isX11) {
             // get settings from X server
             // This is a simplified version of the code in input/mouse.cpp
             // Keep in sync !
             s.handed = KGlobalSettings::KMouseSettings::RightHanded;
             unsigned char map[20];
             int num_buttons = XGetPointerMapping(QX11Info::display(), map, 20);
             if (num_buttons == 2) {
                 if ((int)map[0] == 1 && (int)map[1] == 2) {
                     s.handed = KGlobalSettings::KMouseSettings::RightHanded;
                 } else if ((int)map[0] == 2 && (int)map[1] == 1) {
                     s.handed = KGlobalSettings::KMouseSettings::LeftHanded;
                 }
             } else if (num_buttons >= 3) {
                 if ((int)map[0] == 1 && (int)map[2] == 3) {
                     s.handed = KGlobalSettings::KMouseSettings::RightHanded;
                 } else if ((int)map[0] == 3 && (int)map[2] == 1) {
                     s.handed = KGlobalSettings::KMouseSettings::LeftHanded;
                 }
             }
         }
 #else
             // FIXME: Implement on other platforms
 #endif
         }
 #endif //Q_OS_WIN
     }
 #ifdef Q_OS_WIN
     //not cached
 #ifndef _WIN32_WCE
     mMouseSettings->handed = (GetSystemMetrics(SM_SWAPBUTTON) ?
                               KGlobalSettings::KMouseSettings::LeftHanded :
                               KGlobalSettings::KMouseSettings::RightHanded);
 #else
 // There is no mice under wince
     mMouseSettings->handed = KGlobalSettings::KMouseSettings::RightHanded;
 #endif
 #endif
     return *mMouseSettings;
 }
 // KDE5: make this a const return?
 KGlobalSettings::KMouseSettings &KGlobalSettings::mouseSettings()
 {
     return self()->d->mouseSettings();
 }
 
 QString KGlobalSettings::desktopPath()
 {
     QString path = QStandardPaths::writableLocation(QStandardPaths::DesktopLocation);
     return path.isEmpty() ? QDir::homePath() : path;
 }
 
 // This was the KDE-specific autostart folder in KDEHOME.
 // KDE 5 : re-evaluate this, I'd say the xdg autostart spec supersedes this, and is sufficient
 // (since there's a GUI for creating the necessary desktop files)
 #if 0
 QString KGlobalSettings::autostartPath()
 {
     QString s_autostartPath;
     KConfigGroup g(KSharedConfig::openConfig(), "Paths");
     s_autostartPath = KGlobal::dirs()->localkdedir() + "Autostart/";
     s_autostartPath = g.readPathEntry("Autostart", s_autostartPath);
     s_autostartPath = QDir::cleanPath(s_autostartPath);
     if (!s_autostartPath.endsWith('/')) {
         s_autostartPath.append(QLatin1Char('/'));
     }
     return s_autostartPath;
 }
 #endif
 
 QString KGlobalSettings::documentPath()
 {
     QString path = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
     return path.isEmpty() ? QDir::homePath() : path;
 }
 
 QString KGlobalSettings::downloadPath()
 {
     QString path = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation);
     return path.isEmpty() ? QDir::homePath() : path;
 }
 
 QString KGlobalSettings::videosPath()
 {
     QString path = QStandardPaths::writableLocation(QStandardPaths::MoviesLocation);
     return path.isEmpty() ? QDir::homePath() : path;
 }
 
 QString KGlobalSettings::picturesPath()
 {
     QString path = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
     return path.isEmpty() ? QDir::homePath() : path;
 }
 
 QString KGlobalSettings::musicPath()
 {
     QString path = QStandardPaths::writableLocation(QStandardPaths::MusicLocation);
     return path.isEmpty() ? QDir::homePath() : path;
 }
 
 bool KGlobalSettings::isMultiHead()
 {
 #ifdef Q_OS_WIN
     return GetSystemMetrics(SM_CMONITORS) > 1;
 #else
     QByteArray multiHead = qgetenv("KDE_MULTIHEAD");
     if (!multiHead.isEmpty()) {
         return (multiHead.toLower() == "true");
     }
     return false;
 #endif
 }
 
 bool KGlobalSettings::wheelMouseZooms()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "KDE");
     return g.readEntry("WheelMouseZooms", KDE_DEFAULT_WHEEL_ZOOM);
 }
 
 QRect KGlobalSettings::splashScreenDesktopGeometry()
 {
     return QApplication::desktop()->screenGeometry(QCursor::pos());
 }
 
 QRect KGlobalSettings::desktopGeometry(const QPoint &point)
 {
     return QApplication::desktop()->screenGeometry(point);
 }
 
 QRect KGlobalSettings::desktopGeometry(const QWidget *w)
 {
     return QApplication::desktop()->screenGeometry(w);
 }
 
 bool KGlobalSettings::showIconsOnPushButtons()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "KDE");
     return g.readEntry("ShowIconsOnPushButtons",
                        KDE_DEFAULT_ICON_ON_PUSHBUTTON);
 }
 
 bool KGlobalSettings::naturalSorting()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "KDE");
     return g.readEntry("NaturalSorting",
                        KDE_DEFAULT_NATURAL_SORTING);
 }
 
 KGlobalSettings::GraphicEffects KGlobalSettings::graphicEffectsLevel()
 {
     // This variable stores whether _graphicEffects has the default value because it has not been
     // loaded yet, or if it has been loaded from the user settings or defaults and contains a valid
     // value.
     static bool _graphicEffectsInitialized = false;
 
     if (!_graphicEffectsInitialized) {
         _graphicEffectsInitialized = true;
         Private::reloadStyleSettings();
     }
 
     return _graphicEffects;
 }
 
 KGlobalSettings::GraphicEffects KGlobalSettings::graphicEffectsLevelDefault()
 {
     // For now, let always enable animations by default. The plan is to make
     // this code a bit smarter. (ereslibre)
 
     return ComplexAnimationEffects;
 }
 
 #ifndef KDELIBS4SUPPORT_NO_DEPRECATED
 bool KGlobalSettings::showFilePreview(const QUrl &url)
 {
     KConfigGroup g(KSharedConfig::openConfig(), "PreviewSettings");
     bool defaultSetting = url.isLocalFile(); // ## incorrect, use KProtocolInfo::showFilePreview instead
     return g.readEntry(url.scheme(), defaultSetting);
 }
 #endif
 
 bool KGlobalSettings::opaqueResize()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "KDE");
     return g.readEntry("OpaqueResize", KDE_DEFAULT_OPAQUE_RESIZE);
 }
 
 int KGlobalSettings::buttonLayout()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "KDE");
     return g.readEntry("ButtonLayout", KDE_DEFAULT_BUTTON_LAYOUT);
 }
 
 #if 0 // HAVE_X11 && QT_VERSION >= QT_VERSION_CHECK(5,0,0)
 // Taken from Qt-4.x qt_x11_apply_settings_in_all_apps since Qt5 doesn't have it anymore.
 // TODO: evaluate if this is still needed
 // TODO: if yes, this code should be an invokable method of the qxcb platform plugin?
 // TODO: it looks like the handling code for this in QPA is missing, too...
 static void x11_apply_settings_in_all_apps()
 {
     QByteArray stamp;
     QDataStream s(&stamp, QIODevice::WriteOnly);
     s << QDateTime::currentDateTime();
 
     QByteArray settings_atom_name("_QT_SETTINGS_TIMESTAMP_");
     settings_atom_name += XDisplayString(QX11Info::display());
 
     xcb_connection_t *xcb_conn = QX11Info::connection();
     xcb_intern_atom_cookie_t cookie = xcb_intern_atom(xcb_conn, false, settings_atom_name.size(), settings_atom_name.constData());
     xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(xcb_conn, cookie, 0);
     xcb_atom_t atom = reply->atom;
     free(reply);
 
     xcb_change_property(xcb_conn, XCB_PROP_MODE_REPLACE, QX11Info::appRootWindow(), atom, XCB_ATOM_ATOM,
                         8, stamp.size(), (const void *)stamp.constData());
 
     //XChangeProperty(QX11Info::display(), QX11Info::appRootWindow(0),
     //ATOM(_QT_SETTINGS_TIMESTAMP), ATOM(_QT_SETTINGS_TIMESTAMP), 8,
     //PropModeReplace, (unsigned char *)stamp.data(), stamp.size());
 }
 #endif
 
 void KGlobalSettings::emitChange(ChangeType changeType, int arg)
 {
     switch (changeType) {
     case IconChanged:
         KIconLoader::emitChange(KIconLoader::Group(arg));
         break;
     case ToolbarStyleChanged:
         KToolBar::emitToolbarStyleChanged();
         break;
     case FontChanged:
         self()->d->kdisplaySetFont();
         break;
     default: {
         QDBusMessage message = QDBusMessage::createSignal("/KGlobalSettings", "org.kde.KGlobalSettings", "notifyChange");
         QList<QVariant> args;
         args.append(static_cast<int>(changeType));
         args.append(arg);
         message.setArguments(args);
         QDBusConnection::sessionBus().send(message);
     }   break;
 
     }
 }
 
 void KGlobalSettings::Private::_k_slotIconChange(int arg)
 {
     _k_slotNotifyChange(IconChanged, arg);
 }
 
 void KGlobalSettings::Private::_k_slotNotifyChange(int changeType, int arg)
 {
     switch (changeType) {
     case StyleChanged:
         if (activated) {
             KSharedConfig::openConfig()->reparseConfiguration();
             kdisplaySetStyle();
         }
         break;
 
     case ToolbarStyleChanged:
         KSharedConfig::openConfig()->reparseConfiguration();
         emit q->toolbarAppearanceChanged(arg);
         break;
 
     case PaletteChanged:
         if (activated) {
             KSharedConfig::openConfig()->reparseConfiguration();
             paletteCreated = false;
             kdisplaySetPalette();
         }
         break;
 
     case FontChanged:
         Q_ASSERT(false && "shouldn't get here now...");
         break;
 
     case SettingsChanged: {
         KSharedConfig::openConfig()->reparseConfiguration();
         SettingsCategory category = static_cast<SettingsCategory>(arg);
         if (category == SETTINGS_QT) {
             if (activated) {
                 propagateQtSettings();
             }
         } else {
             switch (category) {
             case SETTINGS_STYLE:
                 reloadStyleSettings();
                 break;
             case SETTINGS_MOUSE:
                 self()->d->dropMouseSettingsCache();
                 break;
             case SETTINGS_LOCALE:
                 // QT5 TODO REPLACEMENT ? KLocale::global()->reparseConfiguration();
                 break;
             default:
                 break;
             }
             emit q->settingsChanged(category);
         }
         break;
     }
     case IconChanged:
         QPixmapCache::clear();
         KSharedConfig::openConfig()->reparseConfiguration();
         emit q->iconChanged(arg);
         break;
 
     case CursorChanged:
         applyCursorTheme();
         break;
 
     case BlockShortcuts:
         // FIXME KAccel port
         //KGlobalAccel::blockShortcuts(arg);
         emit q->blockShortcuts(arg); // see kwin
         break;
 
     case NaturalSortingChanged:
         emit q->naturalSortingChanged();
         break;
 
     default:
         qWarning() << "Unknown type of change in KGlobalSettings::slotNotifyChange: " << changeType;
     }
 }
 
 // Set by KApplication
 QString kde_overrideStyle;
 
 void KGlobalSettings::Private::applyGUIStyle()
 {
 #if 0 // Disabled for KF5. TODO Qt5: check that the KDE style is correctly applied.
     //Platform plugin only loaded on X11 systems
 #if HAVE_X11
     if (!kde_overrideStyle.isEmpty()) {
         const QLatin1String currentStyleName(qApp->style()->metaObject()->className());
         if (0 != kde_overrideStyle.compare(currentStyleName, Qt::CaseInsensitive) &&
                 0 != (QString(kde_overrideStyle + QLatin1String("Style"))).compare(currentStyleName, Qt::CaseInsensitive)) {
             qApp->setStyle(kde_overrideStyle);
         }
     } else {
         emit q->kdisplayStyleChanged();
     }
 #else
     const QLatin1String currentStyleName(qApp->style()->metaObject()->className());
 
     if (kde_overrideStyle.isEmpty()) {
         const QString &defaultStyle = KStyle::defaultStyle();
         const KConfigGroup pConfig(KSharedConfig::openConfig(), "General");
         const QString &styleStr = pConfig.readEntry("widgetStyle", defaultStyle);
 
         if (styleStr.isEmpty() ||
                 // check whether we already use the correct style to return then
                 // (workaround for Qt misbehavior to avoid double style initialization)
                 0 == (QString(styleStr + QLatin1String("Style"))).compare(currentStyleName, Qt::CaseInsensitive) ||
                 0 == styleStr.compare(currentStyleName, Qt::CaseInsensitive)) {
             return;
         }
 
         QStyle *sp = QStyleFactory::create(styleStr);
         if (sp && currentStyleName == sp->metaObject()->className()) {
             delete sp;
             return;
         }
 
         // If there is no default style available, try falling back any available style
         if (!sp && styleStr != defaultStyle) {
             sp = QStyleFactory::create(defaultStyle);
         }
         if (!sp) {
             sp = QStyleFactory::create(QStyleFactory::keys().first());
         }
         qApp->setStyle(sp);
     } else if (0 != kde_overrideStyle.compare(currentStyleName, Qt::CaseInsensitive) &&
                0 != (QString(kde_overrideStyle + QLatin1String("Style"))).compare(currentStyleName, Qt::CaseInsensitive)) {
         qApp->setStyle(kde_overrideStyle);
     }
     emit q->kdisplayStyleChanged();
 #endif //HAVE_X11
 #endif
 }
 
 QPalette KGlobalSettings::createApplicationPalette(const KSharedConfigPtr &config)
 {
     return self()->d->createApplicationPalette(config);
 }
 
 QPalette KGlobalSettings::createNewApplicationPalette(const KSharedConfigPtr &config)
 {
     return self()->d->createNewApplicationPalette(config);
 }
 
 QPalette KGlobalSettings::Private::createApplicationPalette(const KSharedConfigPtr &config)
 {
     // This method is typically called once by KQGuiPlatformPlugin::palette and once again
     // by kdisplaySetPalette(), so we cache the palette to save time.
     if (config == KSharedConfig::openConfig() && paletteCreated) {
         return applicationPalette;
     }
     return createNewApplicationPalette(config);
 }
 
 QPalette KGlobalSettings::Private::createNewApplicationPalette(const KSharedConfigPtr &config)
 {
     QPalette palette = KColorScheme::createApplicationPalette(config);
 
     if (config == KSharedConfig::openConfig()) {
         paletteCreated = true;
         applicationPalette = palette;
     }
 
     return palette;
 }
 
 void KGlobalSettings::Private::kdisplaySetPalette()
 {
 #if !defined(Q_OS_WINCE)
     if (!kdeFullSession) {
         return;
     }
 
     QApplication::setPalette(q->createApplicationPalette());
     emit q->kdisplayPaletteChanged();
     emit q->appearanceChanged();
 #endif
 }
 
 void KGlobalSettings::Private::kdisplaySetFont()
 {
 #if !defined(Q_OS_WINCE)
     if (!kdeFullSession) {
         return;
     }
 
     QDBusMessage message = QDBusMessage::createSignal("/KDEPlatformTheme", "org.kde.KDEPlatformTheme", "refreshFonts");
     QDBusConnection::sessionBus().send(message);
     emit q->kdisplayFontChanged();
 #endif
 }
 
 void KGlobalSettings::Private::kdisplaySetStyle()
 {
     applyGUIStyle();
 
     // Reread palette from config file.
     kdisplaySetPalette();
 }
 
 void KGlobalSettings::Private::reloadStyleSettings()
 {
     KConfigGroup g(KSharedConfig::openConfig(), "KDE-Global GUI Settings");
 
     // Asking for hasKey we do not ask for graphicEffectsLevelDefault() that can
     // contain some very slow code. If we can save that time, do it. (ereslibre)
 
     if (g.hasKey("GraphicEffectsLevel")) {
         _graphicEffects = ((GraphicEffects) g.readEntry("GraphicEffectsLevel", QVariant((int) NoEffects)).toInt());
 
         return;
     }
 
     _graphicEffects = KGlobalSettings::graphicEffectsLevelDefault();
 }
 
 void KGlobalSettings::Private::applyCursorTheme()
 {
 #if HAVE_X11 && defined(HAVE_XCURSOR)
     if (!isX11) {
         return;
     }
     KConfig config("kcminputrc");
     KConfigGroup g(&config, "Mouse");
 
     QString theme = g.readEntry("cursorTheme", QString());
     int size      = g.readEntry("cursorSize", -1);
 
     // Default cursor size is 16 points
     if (size == -1) {
         QApplication *app = static_cast<QApplication *>(QApplication::instance());
         size = app->desktop()->screen(0)->logicalDpiY() * 16 / 72;
     }
 
     // Note that in X11R7.1 and earlier, calling XcursorSetTheme()
     // with a NULL theme would cause Xcursor to use "default", but
     // in 7.2 and later it will cause it to revert to the theme that
     // was configured when the application was started.
     XcursorSetTheme(QX11Info::display(), theme.isNull() ?
                     "default" : QFile::encodeName(theme));
     XcursorSetDefaultSize(QX11Info::display(), size);
 
     emit q->cursorChanged();
 #endif
 }
 
 void KGlobalSettings::Private::propagateQtSettings()
 {
     KConfigGroup cg(KSharedConfig::openConfig(), "KDE");
 
 #ifndef Q_OS_WIN
     int num = cg.readEntry("CursorBlinkRate", QApplication::cursorFlashTime());
     if ((num != 0) && (num < 200)) {
         num = 200;
     }
     if (num > 2000) {
         num = 2000;
     }
     QApplication::setCursorFlashTime(num);
 #else
     int num;
 #endif
     num = cg.readEntry("DoubleClickInterval", QApplication::doubleClickInterval());
     QApplication::setDoubleClickInterval(num);
     num = cg.readEntry("StartDragTime", QApplication::startDragTime());
     QApplication::setStartDragTime(num);
     num = cg.readEntry("StartDragDist", QApplication::startDragDistance());
     QApplication::setStartDragDistance(num);
     num = cg.readEntry("WheelScrollLines", QApplication::wheelScrollLines());
     QApplication::setWheelScrollLines(num);
     bool showIcons = cg.readEntry("ShowIconsInMenuItems", !QApplication::testAttribute(Qt::AA_DontShowIconsInMenus));
     QApplication::setAttribute(Qt::AA_DontShowIconsInMenus, !showIcons);
 
     // KDE5: this seems fairly pointless
     emit q->settingsChanged(SETTINGS_QT);
 }
 
 void KGlobalSettings::Private::dropMouseSettingsCache()
 {
 #ifndef Q_OS_WIN
     delete self()->d->mMouseSettings;
     self()->d->mMouseSettings = nullptr;
 #endif
 }
 
 #include "moc_kglobalsettings.cpp"