diff --git a/effects/desktopgrid/desktopgrid_config.cpp b/effects/desktopgrid/desktopgrid_config.cpp
index 3bf771cfe..23f6e2572 100644
--- a/effects/desktopgrid/desktopgrid_config.cpp
+++ b/effects/desktopgrid/desktopgrid_config.cpp
@@ -1,140 +1,140 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2007 Rivo Laks <rivolaks@hot.ee>
 Copyright (C) 2008 Lucas Murray <lmurray@undefinedfire.com>
 
 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) any later version.
 
 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 <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "desktopgrid_config.h"
 // KConfigSkeleton
 #include "desktopgridconfig.h"
 #include <config-kwin.h>
 #include <kwineffects_interface.h>
 
 #include <QAction>
 
 #include <kconfiggroup.h>
 #include <KActionCollection>
 #include <KAboutData>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KPluginFactory>
 
 #include <QVBoxLayout>
 
 K_PLUGIN_FACTORY_WITH_JSON(DesktopGridEffectConfigFactory,
                            "desktopgrid_config.json",
                            registerPlugin<KWin::DesktopGridEffectConfig>();)
 
 namespace KWin
 {
 
 DesktopGridEffectConfigForm::DesktopGridEffectConfigForm(QWidget* parent) : QWidget(parent)
 {
     setupUi(this);
 }
 
 DesktopGridEffectConfig::DesktopGridEffectConfig(QWidget* parent, const QVariantList& args)
     :   KCModule(KAboutData::pluginData(QStringLiteral("desktopgrid")), parent, args)
 {
     m_ui = new DesktopGridEffectConfigForm(this);
 
     QVBoxLayout* layout = new QVBoxLayout(this);
 
     layout->addWidget(m_ui);
 
     // Shortcut config. The shortcut belongs to the component "kwin"!
     m_actionCollection = new KActionCollection(this, QStringLiteral("kwin"));
 
     m_actionCollection->setComponentDisplayName(i18n("KWin"));
     m_actionCollection->setConfigGroup(QStringLiteral("DesktopGrid"));
     m_actionCollection->setConfigGlobal(true);
 
     QAction* a = m_actionCollection->addAction(QStringLiteral("ShowDesktopGrid"));
     a->setText(i18n("Show Desktop Grid"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::CTRL + Qt::Key_F8);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::CTRL + Qt::Key_F8);
 
     m_ui->shortcutEditor->addCollection(m_actionCollection);
 
 
     m_ui->desktopNameAlignmentCombo->addItem(i18nc("Desktop name alignment:", "Disabled"), QVariant(Qt::Alignment()));
     m_ui->desktopNameAlignmentCombo->addItem(i18n("Top"), QVariant(Qt::AlignHCenter | Qt::AlignTop));
     m_ui->desktopNameAlignmentCombo->addItem(i18n("Top-Right"), QVariant(Qt::AlignRight | Qt::AlignTop));
     m_ui->desktopNameAlignmentCombo->addItem(i18n("Right"), QVariant(Qt::AlignRight | Qt::AlignVCenter));
     m_ui->desktopNameAlignmentCombo->addItem(i18n("Bottom-Right"), QVariant(Qt::AlignRight | Qt::AlignBottom));
     m_ui->desktopNameAlignmentCombo->addItem(i18n("Bottom"), QVariant(Qt::AlignHCenter | Qt::AlignBottom));
     m_ui->desktopNameAlignmentCombo->addItem(i18n("Bottom-Left"), QVariant(Qt::AlignLeft | Qt::AlignBottom));
     m_ui->desktopNameAlignmentCombo->addItem(i18n("Left"), QVariant(Qt::AlignLeft | Qt::AlignVCenter));
     m_ui->desktopNameAlignmentCombo->addItem(i18n("Top-Left"), QVariant(Qt::AlignLeft | Qt::AlignTop));
     m_ui->desktopNameAlignmentCombo->addItem(i18n("Center"), QVariant(Qt::AlignCenter));
 
     DesktopGridConfig::instance(KWIN_CONFIG);
     addConfig(DesktopGridConfig::self(), m_ui);
     connect(m_ui->kcfg_LayoutMode, qOverload<int>(&KComboBox::currentIndexChanged), this, &DesktopGridEffectConfig::layoutSelectionChanged);
-    connect(m_ui->desktopNameAlignmentCombo, qOverload<int>(&KComboBox::currentIndexChanged), this, qOverload<>(&DesktopGridEffectConfig::changed));
-    connect(m_ui->shortcutEditor, &KShortcutsEditor::keyChange, this, qOverload<>(&DesktopGridEffectConfig::changed));
+    connect(m_ui->desktopNameAlignmentCombo, qOverload<int>(&KComboBox::currentIndexChanged), this, &DesktopGridEffectConfig::markAsChanged);
+    connect(m_ui->shortcutEditor, &KShortcutsEditor::keyChange, this, &DesktopGridEffectConfig::markAsChanged);
 
     load();
     layoutSelectionChanged();
 }
 
 DesktopGridEffectConfig::~DesktopGridEffectConfig()
 {
     // If save() is called undoChanges() has no effect
     m_ui->shortcutEditor->undoChanges();
 }
 
 void DesktopGridEffectConfig::save()
 {
     m_ui->shortcutEditor->save();
     DesktopGridConfig::setDesktopNameAlignment(m_ui->desktopNameAlignmentCombo->itemData(m_ui->desktopNameAlignmentCombo->currentIndex()).toInt());
     KCModule::save();
 
     OrgKdeKwinEffectsInterface interface(QStringLiteral("org.kde.KWin"),
                                          QStringLiteral("/Effects"),
                                          QDBusConnection::sessionBus());
     interface.reconfigureEffect(QStringLiteral("desktopgrid"));
 }
 
 void DesktopGridEffectConfig::load()
 {
     KCModule::load();
     m_ui->desktopNameAlignmentCombo->setCurrentIndex(m_ui->desktopNameAlignmentCombo->findData(QVariant(DesktopGridConfig::desktopNameAlignment())));
 }
 
 void DesktopGridEffectConfig::layoutSelectionChanged()
 {
     if (m_ui->kcfg_LayoutMode->currentIndex() == DesktopGridEffect::LayoutCustom) {
         m_ui->layoutRowsLabel->setEnabled(true);
         m_ui->kcfg_CustomLayoutRows->setEnabled(true);
     } else {
         m_ui->layoutRowsLabel->setEnabled(false);
         m_ui->kcfg_CustomLayoutRows->setEnabled(false);
     }
 }
 
 void DesktopGridEffectConfig::defaults()
 {
     KCModule::defaults();
     m_ui->desktopNameAlignmentCombo->setCurrentIndex(0);
 }
 
 } // namespace
 
 #include "desktopgrid_config.moc"
diff --git a/effects/mouseclick/mouseclick_config.cpp b/effects/mouseclick/mouseclick_config.cpp
index 014825f3b..f9be52e49 100644
--- a/effects/mouseclick/mouseclick_config.cpp
+++ b/effects/mouseclick/mouseclick_config.cpp
@@ -1,94 +1,94 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2012 Filip Wieladek <wattos@gmail.com>
 
 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) any later version.
 
 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 <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "mouseclick_config.h"
 // KConfigSkeleton
 #include "mouseclickconfig.h"
 #include <config-kwin.h>
 #include <kwineffects_interface.h>
 
 #include <QAction>
 
 #include <KActionCollection>
 #include <KAboutData>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KPluginFactory>
 
 #include <QWidget>
 
 K_PLUGIN_FACTORY_WITH_JSON(MouseClickEffectConfigFactory,
                            "mouseclick_config.json",
                            registerPlugin<KWin::MouseClickEffectConfig>();)
 
 namespace KWin
 {
 
 MouseClickEffectConfigForm::MouseClickEffectConfigForm(QWidget* parent) : QWidget(parent)
 {
     setupUi(this);
 }
 
 MouseClickEffectConfig::MouseClickEffectConfig(QWidget* parent, const QVariantList& args) :
     KCModule(KAboutData::pluginData(QStringLiteral("mouseclick")), parent, args)
 {
     m_ui = new MouseClickEffectConfigForm(this);
 
     QVBoxLayout* layout = new QVBoxLayout(this);
     layout->addWidget(m_ui);
 
-    connect(m_ui->editor, &KShortcutsEditor::keyChange, this, qOverload<>(&MouseClickEffectConfig::changed));
+    connect(m_ui->editor, &KShortcutsEditor::keyChange, this, &MouseClickEffectConfig::markAsChanged);
 
     // Shortcut config. The shortcut belongs to the component "kwin"!
     m_actionCollection = new KActionCollection(this, QStringLiteral("kwin"));
     m_actionCollection->setComponentDisplayName(i18n("KWin"));
 
     QAction* a = m_actionCollection->addAction(QStringLiteral("ToggleMouseClick"));
     a->setText(i18n("Toggle Mouse Click Effect"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Asterisk);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Asterisk);
 
     m_ui->editor->addCollection(m_actionCollection);
 
     MouseClickConfig::instance(KWIN_CONFIG);
     addConfig(MouseClickConfig::self(), m_ui);
     load();
 }
 
 MouseClickEffectConfig::~MouseClickEffectConfig()
 {
     // Undo (only) unsaved changes to global key shortcuts
     m_ui->editor->undoChanges();
 }
 
 void MouseClickEffectConfig::save()
 {
     KCModule::save();
     m_ui->editor->save();   // undo() will restore to this state from now on
     OrgKdeKwinEffectsInterface interface(QStringLiteral("org.kde.KWin"),
                                          QStringLiteral("/Effects"),
                                          QDBusConnection::sessionBus());
     interface.reconfigureEffect(QStringLiteral("mouseclick"));
 }
 
 } // namespace
 
 #include "mouseclick_config.moc"
diff --git a/effects/presentwindows/presentwindows_config.cpp b/effects/presentwindows/presentwindows_config.cpp
index edb2af54f..c7a874077 100644
--- a/effects/presentwindows/presentwindows_config.cpp
+++ b/effects/presentwindows/presentwindows_config.cpp
@@ -1,118 +1,118 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2007 Rivo Laks <rivolaks@hot.ee>
 Copyright (C) 2008 Lucas Murray <lmurray@undefinedfire.com>
 
 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) any later version.
 
 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 <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "presentwindows_config.h"
 // KConfigSkeleton
 #include "presentwindowsconfig.h"
 #include <config-kwin.h>
 #include <kwineffects_interface.h>
 #include <QAction>
 
 #include <kconfiggroup.h>
 #include <KActionCollection>
 #include <KAboutData>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KPluginFactory>
 
 #include <QVBoxLayout>
 
 K_PLUGIN_FACTORY_WITH_JSON(PresentWindowsEffectConfigFactory,
                            "presentwindows_config.json",
                            registerPlugin<KWin::PresentWindowsEffectConfig>();)
 
 namespace KWin
 {
 
 PresentWindowsEffectConfigForm::PresentWindowsEffectConfigForm(QWidget* parent) : QWidget(parent)
 {
     setupUi(this);
 }
 
 PresentWindowsEffectConfig::PresentWindowsEffectConfig(QWidget* parent, const QVariantList& args)
     :   KCModule(KAboutData::pluginData(QStringLiteral("presentwindows")), parent, args)
 {
     m_ui = new PresentWindowsEffectConfigForm(this);
 
     QVBoxLayout* layout = new QVBoxLayout(this);
 
     layout->addWidget(m_ui);
 
     // Shortcut config. The shortcut belongs to the component "kwin"!
     m_actionCollection = new KActionCollection(this, QStringLiteral("kwin"));
 
     m_actionCollection->setComponentDisplayName(i18n("KWin"));
     m_actionCollection->setConfigGroup(QStringLiteral("PresentWindows"));
     m_actionCollection->setConfigGlobal(true);
 
     QAction* a = m_actionCollection->addAction(QStringLiteral("ExposeAll"));
     a->setText(i18n("Toggle Present Windows (All desktops)"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::CTRL + Qt::Key_F10 << Qt::Key_LaunchC);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::CTRL + Qt::Key_F10 << Qt::Key_LaunchC);
 
     QAction* b = m_actionCollection->addAction(QStringLiteral("Expose"));
     b->setText(i18n("Toggle Present Windows (Current desktop)"));
     b->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(b, QList<QKeySequence>() << Qt::CTRL + Qt::Key_F9);
     KGlobalAccel::self()->setShortcut(b, QList<QKeySequence>() << Qt::CTRL + Qt::Key_F9);
 
     QAction* c = m_actionCollection->addAction(QStringLiteral("ExposeClass"));
     c->setText(i18n("Toggle Present Windows (Window class)"));
     c->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(c, QList<QKeySequence>() << Qt::CTRL + Qt::Key_F7);
     KGlobalAccel::self()->setShortcut(c, QList<QKeySequence>() << Qt::CTRL + Qt::Key_F7);
 
     m_ui->shortcutEditor->addCollection(m_actionCollection);
 
-    connect(m_ui->shortcutEditor, &KShortcutsEditor::keyChange, this, qOverload<>(&PresentWindowsEffectConfig::changed));
+    connect(m_ui->shortcutEditor, &KShortcutsEditor::keyChange, this, &PresentWindowsEffectConfig::markAsChanged);
 
     PresentWindowsConfig::instance(KWIN_CONFIG);
     addConfig(PresentWindowsConfig::self(), m_ui);
 
     load();
 }
 
 PresentWindowsEffectConfig::~PresentWindowsEffectConfig()
 {
     // If save() is called undoChanges() has no effect
     m_ui->shortcutEditor->undoChanges();
 }
 
 void PresentWindowsEffectConfig::save()
 {
     KCModule::save();
     m_ui->shortcutEditor->save();
     OrgKdeKwinEffectsInterface interface(QStringLiteral("org.kde.KWin"),
                                          QStringLiteral("/Effects"),
                                          QDBusConnection::sessionBus());
     interface.reconfigureEffect(QStringLiteral("presentwindows"));
 }
 
 void PresentWindowsEffectConfig::defaults()
 {
     m_ui->shortcutEditor->allDefault();
     KCModule::defaults();
 }
 
 } // namespace
 
 #include "presentwindows_config.moc"
diff --git a/effects/thumbnailaside/thumbnailaside_config.cpp b/effects/thumbnailaside/thumbnailaside_config.cpp
index 453180b1b..aed7ac571 100644
--- a/effects/thumbnailaside/thumbnailaside_config.cpp
+++ b/effects/thumbnailaside/thumbnailaside_config.cpp
@@ -1,101 +1,101 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2007 Christian Nitschkowski <christian.nitschkowski@kdemail.net>
 
 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) any later version.
 
 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 <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "thumbnailaside_config.h"
 // KConfigSkeleton
 #include "thumbnailasideconfig.h"
 #include <config-kwin.h>
 #include <kwineffects_interface.h>
 
 #include <QAction>
 
 #include <KLocalizedString>
 #include <kconfiggroup.h>
 #include <KActionCollection>
 #include <KAboutData>
 #include <KGlobalAccel>
 #include <KPluginFactory>
 
 #include <QWidget>
 #include <QVBoxLayout>
 
 K_PLUGIN_FACTORY_WITH_JSON(ThumbnailAsideEffectConfigFactory,
                            "thumbnailaside_config.json",
                            registerPlugin<KWin::ThumbnailAsideEffectConfig>();)
 
 namespace KWin
 {
 
 ThumbnailAsideEffectConfigForm::ThumbnailAsideEffectConfigForm(QWidget* parent) : QWidget(parent)
 {
     setupUi(this);
 }
 
 ThumbnailAsideEffectConfig::ThumbnailAsideEffectConfig(QWidget* parent, const QVariantList& args) :
     KCModule(KAboutData::pluginData(QStringLiteral("thumbnailaside")), parent, args)
 {
     m_ui = new ThumbnailAsideEffectConfigForm(this);
 
     QVBoxLayout* layout = new QVBoxLayout(this);
 
     layout->addWidget(m_ui);
 
-    connect(m_ui->editor, &KShortcutsEditor::keyChange, this, qOverload<>(&ThumbnailAsideEffectConfig::changed));
+    connect(m_ui->editor, &KShortcutsEditor::keyChange, this, &ThumbnailAsideEffectConfig::markAsChanged);
 
     ThumbnailAsideConfig::instance(KWIN_CONFIG);
     addConfig(ThumbnailAsideConfig::self(), this);
 
     // Shortcut config. The shortcut belongs to the component "kwin"!
     m_actionCollection = new KActionCollection(this, QStringLiteral("kwin"));
 
     m_actionCollection->setComponentDisplayName(i18n("KWin"));
     m_actionCollection->setConfigGroup(QStringLiteral("ThumbnailAside"));
     m_actionCollection->setConfigGlobal(true);
 
     QAction* a = m_actionCollection->addAction(QStringLiteral("ToggleCurrentThumbnail"));
     a->setText(i18n("Toggle Thumbnail for Current Window"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_T);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_T);
 
     m_ui->editor->addCollection(m_actionCollection);
 
     load();
 }
 
 ThumbnailAsideEffectConfig::~ThumbnailAsideEffectConfig()
 {
     // Undo (only) unsaved changes to global key shortcuts
     m_ui->editor->undoChanges();
 }
 
 void ThumbnailAsideEffectConfig::save()
 {
     KCModule::save();
     m_ui->editor->save();
     OrgKdeKwinEffectsInterface interface(QStringLiteral("org.kde.KWin"),
                                          QStringLiteral("/Effects"),
                                          QDBusConnection::sessionBus());
     interface.reconfigureEffect(QStringLiteral("thumbnailaside"));
 }
 
 } // namespace
 
 #include "thumbnailaside_config.moc"
diff --git a/effects/zoom/zoom_config.cpp b/effects/zoom/zoom_config.cpp
index 611ca7ccb..78dafd2bf 100644
--- a/effects/zoom/zoom_config.cpp
+++ b/effects/zoom/zoom_config.cpp
@@ -1,150 +1,150 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2007 Rivo Laks <rivolaks@hot.ee>
 Copyright (C) 2010 Sebastian Sauer <sebsauer@kdab.com>
 
 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) any later version.
 
 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 <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "zoom_config.h"
 // KConfigSkeleton
 #include "zoomconfig.h"
 #include <config-kwin.h>
 #include <kwineffects_interface.h>
 
 #include <QAction>
 
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KActionCollection>
 #include <KAboutData>
 #include <KPluginFactory>
 
 #include <QVBoxLayout>
 
 K_PLUGIN_FACTORY_WITH_JSON(ZoomEffectConfigFactory,
                            "zoom_config.json",
                            registerPlugin<KWin::ZoomEffectConfig>();)
 
 namespace KWin
 {
 
 ZoomEffectConfigForm::ZoomEffectConfigForm(QWidget* parent) : QWidget(parent)
 {
     setupUi(this);
 }
 
 ZoomEffectConfig::ZoomEffectConfig(QWidget* parent, const QVariantList& args) :
     KCModule(KAboutData::pluginData(QStringLiteral("zoom")), parent, args)
 {
     ZoomConfig::instance(KWIN_CONFIG);
     m_ui = new ZoomEffectConfigForm(this);
 
     QVBoxLayout* layout = new QVBoxLayout(this);
     layout->addWidget(m_ui);
 
     addConfig(ZoomConfig::self(), m_ui);
 
-    connect(m_ui->editor, &KShortcutsEditor::keyChange, this, qOverload<>(&ZoomEffectConfig::changed));
+    connect(m_ui->editor, &KShortcutsEditor::keyChange, this, &ZoomEffectConfig::markAsChanged);
 
     // Shortcut config. The shortcut belongs to the component "kwin"!
     KActionCollection *actionCollection = new KActionCollection(this, QStringLiteral("kwin"));
     actionCollection->setComponentDisplayName(i18n("KWin"));
     actionCollection->setConfigGroup(QStringLiteral("Zoom"));
     actionCollection->setConfigGlobal(true);
 
     QAction* a;
     a = actionCollection->addAction(KStandardAction::ZoomIn);
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Equal);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Equal);
 
     a = actionCollection->addAction(KStandardAction::ZoomOut);
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Minus);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Minus);
 
     a = actionCollection->addAction(KStandardAction::ActualSize);
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_0);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_0);
 
     a = actionCollection->addAction(QStringLiteral("MoveZoomLeft"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-previous")));
     a->setText(i18n("Move Left"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Left);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Left);
 
     a = actionCollection->addAction(QStringLiteral("MoveZoomRight"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-next")));
     a->setText(i18n("Move Right"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Right);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Right);
 
     a = actionCollection->addAction(QStringLiteral("MoveZoomUp"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
     a->setText(i18n("Move Up"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Up);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Up);
 
     a = actionCollection->addAction(QStringLiteral("MoveZoomDown"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
     a->setText(i18n("Move Down"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Down);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Down);
 
     a = actionCollection->addAction(QStringLiteral("MoveMouseToFocus"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("view-restore")));
     a->setText(i18n("Move Mouse to Focus"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F5);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F5);
 
     a = actionCollection->addAction(QStringLiteral("MoveMouseToCenter"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("view-restore")));
     a->setText(i18n("Move Mouse to Center"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F6);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F6);
 
     m_ui->editor->addCollection(actionCollection);
 
     load();
 }
 
 ZoomEffectConfig::~ZoomEffectConfig()
 {
     // Undo (only) unsaved changes to global key shortcuts
     m_ui->editor->undoChanges();
 }
 
 void ZoomEffectConfig::save()
 {
     m_ui->editor->save(); // undo() will restore to this state from now on
     KCModule::save();
     OrgKdeKwinEffectsInterface interface(QStringLiteral("org.kde.KWin"),
                                          QStringLiteral("/Effects"),
                                          QDBusConnection::sessionBus());
     interface.reconfigureEffect(QStringLiteral("zoom"));
 }
 
 } // namespace
 
 #include "zoom_config.moc"
diff --git a/kcmkwin/kwincompositing/main.cpp b/kcmkwin/kwincompositing/main.cpp
index 969977fdc..138cfe863 100644
--- a/kcmkwin/kwincompositing/main.cpp
+++ b/kcmkwin/kwincompositing/main.cpp
@@ -1,227 +1,227 @@
 /**************************************************************************
  * KWin - the KDE window manager                                          *
  * This file is part of the KDE project.                                  *
  *                                                                        *
  * Copyright (C) 2013 Antonis Tsiapaliokas <kok3rs@gmail.com>             *
  * Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>                 *
  *                                                                        *
  * 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) any later version.                                    *
  *                                                                        *
  * 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 <http://www.gnu.org/licenses/>.  *
  **************************************************************************/
 
 
 #include "compositing.h"
 #include "ui_compositing.h"
 #include <QAction>
 #include <QApplication>
 #include <QLayout>
 
 #include <kcmodule.h>
 #include <kservice.h>
 
 #include <algorithm>
 #include <functional>
 
 class KWinCompositingSettings : public KCModule
 {
     Q_OBJECT
 public:
     explicit KWinCompositingSettings(QWidget *parent = nullptr, const QVariantList &args = QVariantList());
 
 public Q_SLOTS:
     void load() override;
     void save() override;
     void defaults() override;
 
 private:
     void init();
     KWin::Compositing::Compositing *m_compositing;
     Ui_CompositingForm m_form;
 };
 
 static const QVector<qreal> s_animationMultipliers = {8, 4, 2, 1, 0.5, 0.25, 0.125, 0};
 
 KWinCompositingSettings::KWinCompositingSettings(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args)
     , m_compositing(new KWin::Compositing::Compositing(this))
 {
     m_form.setupUi(this);
     m_form.glCrashedWarning->setIcon(QIcon::fromTheme(QStringLiteral("dialog-warning")));
     QAction *reenableGLAction = new QAction(i18n("Re-enable OpenGL detection"), this);
     connect(reenableGLAction, &QAction::triggered, m_compositing, &KWin::Compositing::Compositing::reenableOpenGLDetection);
     connect(reenableGLAction, &QAction::triggered, m_form.glCrashedWarning, &KMessageWidget::animatedHide);
     m_form.glCrashedWarning->addAction(reenableGLAction);
     m_form.scaleWarning->setIcon(QIcon::fromTheme(QStringLiteral("dialog-warning")));
     m_form.tearingWarning->setIcon(QIcon::fromTheme(QStringLiteral("dialog-warning")));
     m_form.windowThumbnailWarning->setIcon(QIcon::fromTheme(QStringLiteral("dialog-warning")));
 
     m_form.compositingEnabled->setVisible(!m_compositing->compositingRequired());
     m_form.windowsBlockCompositing->setVisible(!m_compositing->compositingRequired());
 
     init();
 }
 
 void KWinCompositingSettings::init()
 {
     using namespace KWin::Compositing;
     auto currentIndexChangedSignal = static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged);
 
-    connect(m_compositing, &Compositing::changed, this, static_cast<void(KCModule::*)()>(&KWinCompositingSettings::changed));
+    connect(m_compositing, &Compositing::changed, this, &KWinCompositingSettings::markAsChanged);
 
     // enabled check box
     m_form.compositingEnabled->setChecked(m_compositing->compositingEnabled());
     connect(m_compositing, &Compositing::compositingEnabledChanged, m_form.compositingEnabled, &QCheckBox::setChecked);
     connect(m_form.compositingEnabled, &QCheckBox::toggled, m_compositing, &Compositing::setCompositingEnabled);
 
     // animation speed
     m_form.animationSpeed->setMaximum(s_animationMultipliers.size() - 1);
     auto setSpeed = [this](const qreal multiplier) {
         auto const it = std::lower_bound(s_animationMultipliers.begin(), s_animationMultipliers.end(), multiplier, std::greater<qreal>());
         const int index = std::distance(s_animationMultipliers.begin(), it);
         m_form.animationSpeed->setValue(index);
     };
     setSpeed(m_compositing->animationSpeed());
     connect(m_compositing, &Compositing::animationSpeedChanged, m_form.animationSpeed, setSpeed);
     connect(m_form.animationSpeed, &QSlider::valueChanged, m_compositing, [this](int index) {
         m_compositing->setAnimationSpeed(s_animationMultipliers[index]);
     });
 
     if (Compositing::isRunningPlasma()) {
         m_form.animationSpeedLabel->hide();
         m_form.animationSpeedControls->hide();
     }
 
     // gl scale filter
     m_form.glScaleFilter->setCurrentIndex(m_compositing->glScaleFilter());
     connect(m_compositing, &Compositing::glScaleFilterChanged, m_form.glScaleFilter, &QComboBox::setCurrentIndex);
     connect(m_form.glScaleFilter, currentIndexChangedSignal, m_compositing, &Compositing::setGlScaleFilter);
     connect(m_form.glScaleFilter, currentIndexChangedSignal,
         [this](int index) {
             if (index == 2) {
                 m_form.scaleWarning->animatedShow();
             } else {
                 m_form.scaleWarning->animatedHide();
             }
         }
     );
 
     // xrender scale filter
     m_form.xrScaleFilter->setCurrentIndex(m_compositing->xrScaleFilter());
     connect(m_compositing, &Compositing::xrScaleFilterChanged, m_form.xrScaleFilter, &QComboBox::setCurrentIndex);
     connect(m_form.xrScaleFilter, currentIndexChangedSignal,
             [this](int index) {
         if (index == 0) {
             m_compositing->setXrScaleFilter(false);
         } else {
             m_compositing->setXrScaleFilter(true);
         }
     });
 
     // tearing prevention
     m_form.tearingPrevention->setCurrentIndex(m_compositing->glSwapStrategy());
     connect(m_compositing, &Compositing::glSwapStrategyChanged, m_form.tearingPrevention, &QComboBox::setCurrentIndex);
     connect(m_form.tearingPrevention, currentIndexChangedSignal, m_compositing, &Compositing::setGlSwapStrategy);
     connect(m_form.tearingPrevention, currentIndexChangedSignal,
         [this](int index) {
             if (index == 2) {
                 // only when cheap - tearing
                 m_form.tearingWarning->setText(i18n("\"Only when cheap\" only prevents tearing for full screen changes like a video."));
                 m_form.tearingWarning->animatedShow();
             } else if (index == 3) {
                 // full screen repaints
                 m_form.tearingWarning->setText(i18n("\"Full screen repaints\" can cause performance problems."));
                 m_form.tearingWarning->animatedShow();
             } else if (index == 4) {
                 // re-use screen content
                 m_form.tearingWarning->setText(i18n("\"Re-use screen content\" causes severe performance problems on MESA drivers."));
                 m_form.tearingWarning->animatedShow();
             } else {
                 m_form.tearingWarning->animatedHide();
             }
         }
     );
 
     // windowThumbnail
     m_form.windowThumbnail->setCurrentIndex(m_compositing->windowThumbnail());
     connect(m_compositing, &Compositing::windowThumbnailChanged, m_form.windowThumbnail, &QComboBox::setCurrentIndex);
     connect(m_form.windowThumbnail, currentIndexChangedSignal, m_compositing, &Compositing::setWindowThumbnail);
     connect(m_form.windowThumbnail, currentIndexChangedSignal,
         [this](int index) {
             if (index == 2) {
                 m_form.windowThumbnailWarning->animatedShow();
             } else {
                 m_form.windowThumbnailWarning->animatedHide();
             }
         }
     );
 
     // windows blocking compositing
     m_form.windowsBlockCompositing->setChecked(m_compositing->windowsBlockCompositing());
     connect(m_compositing, &Compositing::windowsBlockCompositingChanged, m_form.windowsBlockCompositing, &QCheckBox::setChecked);
     connect(m_form.windowsBlockCompositing, &QCheckBox::toggled, m_compositing, &Compositing::setWindowsBlockCompositing);
 
     // compositing type
     CompositingType *type = new CompositingType(this);
     m_form.type->setModel(type);
     auto updateCompositingType = [this, type]() {
         m_form.type->setCurrentIndex(type->indexForCompositingType(m_compositing->compositingType()));
     };
     updateCompositingType();
     connect(m_compositing, &Compositing::compositingTypeChanged,
         [updateCompositingType]() {
             updateCompositingType();
         }
     );
     auto showHideBasedOnType = [this, type]() {
         const int currentType = type->compositingTypeForIndex(m_form.type->currentIndex());
         m_form.glScaleFilter->setVisible(currentType != CompositingType::XRENDER_INDEX);
         m_form.glScaleFilterLabel->setVisible(currentType != CompositingType::XRENDER_INDEX);
         m_form.xrScaleFilter->setVisible(currentType == CompositingType::XRENDER_INDEX);
         m_form.xrScaleFilterLabel->setVisible(currentType == CompositingType::XRENDER_INDEX);
     };
     showHideBasedOnType();
     connect(m_form.type, currentIndexChangedSignal,
         [this, type, showHideBasedOnType]() {
             m_compositing->setCompositingType(type->compositingTypeForIndex(m_form.type->currentIndex()));
             showHideBasedOnType();
         }
     );
 
     if (m_compositing->OpenGLIsUnsafe()) {
         m_form.glCrashedWarning->animatedShow();
     }
 }
 
 void KWinCompositingSettings::load()
 {
     KCModule::load();
     m_compositing->reset();
 }
 
 void KWinCompositingSettings::defaults()
 {
     KCModule::defaults();
     m_compositing->defaults();
 }
 
 void KWinCompositingSettings::save()
 {
     KCModule::save();
     m_compositing->save();
 }
 
 K_PLUGIN_FACTORY(KWinCompositingConfigFactory,
                  registerPlugin<KWinCompositingSettings>("compositing");
                 )
 
 #include "main.moc"