diff --git a/kcmkwin/kwintabbox/kwintabboxconfigform.cpp b/kcmkwin/kwintabbox/kwintabboxconfigform.cpp
index cdd6a4eb4..b9e7c75ef 100644
--- a/kcmkwin/kwintabbox/kwintabboxconfigform.cpp
+++ b/kcmkwin/kwintabbox/kwintabboxconfigform.cpp
@@ -1,353 +1,407 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2009 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2020 Cyril Rossi <cyril.rossi@enioka.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 "kwintabboxconfigform.h"
 #include "ui_main.h"
 
 #include <QDebug>
 
 #include <KActionCollection>
 #include <KGlobalAccel>
 #include <KShortcutsEditor>
 
 
 namespace KWin
 {
 
 using namespace TabBox;
 
 KWinTabBoxConfigForm::KWinTabBoxConfigForm(TabboxType type, QWidget *parent)
     : QWidget(parent)
     , m_type(type)
     , ui(new Ui::KWinTabBoxConfigForm)
 {
     ui->setupUi(this);
 
     ui->effectConfigButton->setIcon(QIcon::fromTheme(QStringLiteral("view-preview")));
 
     if (QApplication::screens().count() < 2) {
         ui->filterScreens->hide();
         ui->screenFilter->hide();
     }
 
     connect(ui->effectConfigButton, &QPushButton::clicked, this, &KWinTabBoxConfigForm::effectConfigButtonClicked);
 
     connect(ui->kcfg_ShowTabBox, SIGNAL(clicked(bool)), SLOT(tabBoxToggled(bool)));
 
     connect(ui->filterScreens, SIGNAL(clicked(bool)), SLOT(onFilterScreen()));
     connect(ui->currentScreen, SIGNAL(clicked(bool)), SLOT(onFilterScreen()));
     connect(ui->otherScreens, SIGNAL(clicked(bool)), SLOT(onFilterScreen()));
 
     connect(ui->filterDesktops, SIGNAL(clicked(bool)), SLOT(onFilterDesktop()));
     connect(ui->currentDesktop, SIGNAL(clicked(bool)), SLOT(onFilterDesktop()));
     connect(ui->otherDesktops, SIGNAL(clicked(bool)), SLOT(onFilterDesktop()));
 
     connect(ui->filterActivities, SIGNAL(clicked(bool)), SLOT(onFilterActivites()));
     connect(ui->currentActivity, SIGNAL(clicked(bool)), SLOT(onFilterActivites()));
     connect(ui->otherActivities, SIGNAL(clicked(bool)), SLOT(onFilterActivites()));
 
     connect(ui->filterMinimization, SIGNAL(clicked(bool)), SLOT(onFilterMinimization()));
     connect(ui->visibleWindows, SIGNAL(clicked(bool)), SLOT(onFilterMinimization()));
     connect(ui->hiddenWindows, SIGNAL(clicked(bool)), SLOT(onFilterMinimization()));
 
     connect(ui->oneAppWindow, SIGNAL(clicked(bool)), SLOT(onApplicationMode()));
     connect(ui->showDesktop, SIGNAL(clicked(bool)), SLOT(onShowDesktopMode()));
 
     connect(ui->switchingModeCombo, SIGNAL(currentIndexChanged(int)), SLOT(onSwitchingMode()));
     connect(ui->effectCombo, SIGNAL(currentIndexChanged(int)), SLOT(onEffectCombo()));
 
     auto addShortcut = [this](const char *name, KKeySequenceWidget *widget, const QKeySequence &sequence = QKeySequence()) {
         QAction *a = m_actionCollection->addAction(name);
         a->setProperty("isConfigurationAction", true);
         widget->setProperty("shortcutAction", name);
         a->setText(i18n(name));
         KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << sequence);
         connect(widget, SIGNAL(keySequenceChanged(QKeySequence)), this, SLOT(shortcutChanged(QKeySequence)));
     };
 
     // Shortcut config. The shortcut belongs to the component "kwin"!
     m_actionCollection = new KActionCollection(this, QStringLiteral("kwin"));
     m_actionCollection->setComponentDisplayName(i18n("KWin"));
     m_actionCollection->setConfigGroup("Navigation");
     m_actionCollection->setConfigGlobal(true);
 
     if (TabboxType::Main == m_type) {
         addShortcut("Walk Through Windows", ui->scAll, Qt::ALT + Qt::Key_Tab);
         addShortcut("Walk Through Windows (Reverse)", ui->scAllReverse, Qt::ALT + Qt::SHIFT + Qt::Key_Backtab);
         addShortcut("Walk Through Windows of Current Application", ui->scCurrent, Qt::ALT + Qt::Key_QuoteLeft);
         addShortcut("Walk Through Windows of Current Application (Reverse)", ui->scCurrentReverse, Qt::ALT + Qt::Key_AsciiTilde);
     } else if (TabboxType::Alternative == m_type) {
         addShortcut("Walk Through Windows Alternative", ui->scAll);
         addShortcut("Walk Through Windows Alternative (Reverse)", ui->scAllReverse);
         addShortcut("Walk Through Windows of Current Application Alternative", ui->scCurrent);
         addShortcut("Walk Through Windows of Current Application Alternative (Reverse)", ui->scCurrentReverse);
     }
 }
 
 KWinTabBoxConfigForm::~KWinTabBoxConfigForm()
 {
     delete ui;
 }
 
 bool KWinTabBoxConfigForm::highlightWindows() const
 {
     return ui->kcfg_HighlightWindows->isChecked();
 }
 
 bool KWinTabBoxConfigForm::showTabBox() const
 {
     return ui->kcfg_ShowTabBox->isChecked();
 }
 
 int KWinTabBoxConfigForm::filterScreen() const
 {
     if (ui->filterScreens->isChecked()) {
         return ui->currentScreen->isChecked() ? TabBoxConfig::OnlyCurrentScreenClients : TabBoxConfig::ExcludeCurrentScreenClients;
     } else {
         return TabBoxConfig::IgnoreMultiScreen;
     }
 }
 
 int KWinTabBoxConfigForm::filterDesktop() const
 {
     if (ui->filterDesktops->isChecked()) {
         return ui->currentDesktop->isChecked() ? TabBoxConfig::OnlyCurrentDesktopClients : TabBoxConfig::ExcludeCurrentDesktopClients;
     } else {
         return TabBoxConfig::AllDesktopsClients;
     }
 }
 
 int KWinTabBoxConfigForm::filterActivities() const
 {
     if (ui->filterActivities->isChecked()) {
         return ui->currentActivity->isChecked() ? TabBoxConfig::OnlyCurrentActivityClients : TabBoxConfig::ExcludeCurrentActivityClients;
     } else {
         return TabBoxConfig::AllActivitiesClients;
     }
 }
 
 int KWinTabBoxConfigForm::filterMinimization() const
 {
     if (ui->filterMinimization->isChecked()) {
         return ui->visibleWindows->isChecked() ? TabBoxConfig::ExcludeMinimizedClients : TabBoxConfig::OnlyMinimizedClients;
     } else {
         return TabBoxConfig::IgnoreMinimizedStatus;
     }
 }
 
 int KWinTabBoxConfigForm::applicationMode() const
 {
     return ui->oneAppWindow->isChecked() ? TabBoxConfig::OneWindowPerApplication : TabBoxConfig::AllWindowsAllApplications;
 }
 
 int KWinTabBoxConfigForm::showDesktopMode() const
 {
     return ui->showDesktop->isChecked() ? TabBoxConfig::ShowDesktopClient : TabBoxConfig::DoNotShowDesktopClient;
 }
 
 int KWinTabBoxConfigForm::switchingMode() const
 {
     return ui->switchingModeCombo->currentIndex();
 }
 
 QString KWinTabBoxConfigForm::layoutName() const
 {
     return ui->effectCombo->currentData().toString();
 }
 
 void KWinTabBoxConfigForm::setFilterScreen(TabBox::TabBoxConfig::ClientMultiScreenMode mode)
 {
     ui->filterScreens->setChecked(mode != TabBoxConfig::IgnoreMultiScreen);
     ui->currentScreen->setChecked(mode == TabBoxConfig::OnlyCurrentScreenClients);
     ui->otherScreens->setChecked(mode == TabBoxConfig::ExcludeCurrentScreenClients);
 }
 
 void KWinTabBoxConfigForm::setFilterDesktop(TabBox::TabBoxConfig::ClientDesktopMode mode)
 {
     ui->filterDesktops->setChecked(mode != TabBoxConfig::AllDesktopsClients);
     ui->currentDesktop->setChecked(mode == TabBoxConfig::OnlyCurrentDesktopClients);
     ui->otherDesktops->setChecked(mode == TabBoxConfig::ExcludeCurrentDesktopClients);
 }
 
 void KWinTabBoxConfigForm::setFilterActivities(TabBox::TabBoxConfig::ClientActivitiesMode mode)
 {
     ui->filterActivities->setChecked(mode != TabBoxConfig::AllActivitiesClients);
     ui->currentActivity->setChecked(mode == TabBoxConfig::OnlyCurrentActivityClients);
     ui->otherActivities->setChecked(mode == TabBoxConfig::ExcludeCurrentActivityClients);
 }
 
 void KWinTabBoxConfigForm::setFilterMinimization(TabBox::TabBoxConfig::ClientMinimizedMode mode)
 {
     ui->filterMinimization->setChecked(mode != TabBoxConfig::IgnoreMinimizedStatus);
     ui->visibleWindows->setChecked(mode == TabBoxConfig::ExcludeMinimizedClients);
     ui->hiddenWindows->setChecked(mode == TabBoxConfig::OnlyMinimizedClients);
 }
 
 void KWinTabBoxConfigForm::setApplicationMode(TabBox::TabBoxConfig::ClientApplicationsMode mode)
 {
     ui->oneAppWindow->setChecked(mode == TabBoxConfig::OneWindowPerApplication);
 }
 
 void KWinTabBoxConfigForm::setShowDesktopMode(TabBox::TabBoxConfig::ShowDesktopMode mode)
 {
     ui->showDesktop->setChecked(mode == TabBoxConfig::ShowDesktopClient);
 }
 
 void KWinTabBoxConfigForm::setSwitchingModeChanged(TabBox::TabBoxConfig::ClientSwitchingMode mode)
 {
     ui->switchingModeCombo->setCurrentIndex(mode);
 }
 
 void KWinTabBoxConfigForm::setLayoutName(const QString &layoutName)
 {
     ui->effectCombo->setCurrentIndex(ui->effectCombo->findData(layoutName));
 }
 
 void KWinTabBoxConfigForm::setEffectComboModel(QStandardItemModel *model)
 {
     int index = ui->effectCombo->currentIndex();
     QVariant data = ui->effectCombo->itemData(index);
 
     ui->effectCombo->setModel(model);
 
     if (data.isValid()) {
         ui->effectCombo->setCurrentIndex(ui->effectCombo->findData(data));
     } else if (index != -1) {
         ui->effectCombo->setCurrentIndex(index);
     }
 }
 
 QVariant KWinTabBoxConfigForm::effectComboCurrentData(int role) const
 {
     return ui->effectCombo->currentData(role);
 }
 
 void KWinTabBoxConfigForm::loadShortcuts()
 {
     auto loadShortcut = [this](KKeySequenceWidget *widget) {
         QString actionName = widget->property("shortcutAction").toString();
         qDebug() << "load shortcut for " << actionName;
         if (QAction *action = m_actionCollection->action(actionName)) {
             auto shortcuts = KGlobalAccel::self()->shortcut(action);
             if (!shortcuts.isEmpty()) {
                 widget->setKeySequence(shortcuts.first());
             }
         }
     };
 
     loadShortcut(ui->scAll);
     loadShortcut(ui->scAllReverse);
     loadShortcut(ui->scCurrent);
     loadShortcut(ui->scCurrentReverse);
 }
 
 void KWinTabBoxConfigForm::resetShortcuts()
 {
     QString action;
     auto resetShortcut = [this](KKeySequenceWidget *widget, const QKeySequence &sequence = QKeySequence()) {
         const QString action = widget->property("shortcutAction").toString();
         QAction *a = m_actionCollection->action(action);
         KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << sequence, KGlobalAccel::NoAutoloading);
     };
     if (TabboxType::Main == m_type) {
         resetShortcut(ui->scAll, Qt::ALT + Qt::Key_Tab);
         resetShortcut(ui->scAllReverse, Qt::ALT + Qt::SHIFT + Qt::Key_Backtab);
         resetShortcut(ui->scCurrent, Qt::ALT + Qt::Key_QuoteLeft);
         resetShortcut(ui->scCurrentReverse, Qt::ALT + Qt::Key_AsciiTilde);
     } else if (TabboxType::Alternative == m_type) {
         resetShortcut(ui->scAll);
         resetShortcut(ui->scAllReverse);
         resetShortcut(ui->scCurrent);
         resetShortcut(ui->scCurrentReverse);
     }
     m_actionCollection->writeSettings();
 }
 
+void KWinTabBoxConfigForm::setHighlightWindowsEnabled(bool enabled)
+{
+    m_isHighlightWindowsEnabled = enabled;
+    ui->kcfg_HighlightWindows->setEnabled(m_isHighlightWindowsEnabled);
+}
+
+void KWinTabBoxConfigForm::setFilterScreenEnabled(bool enabled)
+{
+    ui->filterScreens->setEnabled(enabled);
+    ui->currentScreen->setEnabled(enabled);
+    ui->otherScreens->setEnabled(enabled);
+}
+
+void KWinTabBoxConfigForm::setFilterDesktopEnabled(bool enabled)
+{
+    ui->filterDesktops->setEnabled(enabled);
+    ui->currentDesktop->setEnabled(enabled);
+    ui->otherDesktops->setEnabled(enabled);
+}
+
+void KWinTabBoxConfigForm::setFilterActivitiesEnabled(bool enabled)
+{
+    ui->filterActivities->setEnabled(enabled);
+    ui->currentActivity->setEnabled(enabled);
+    ui->otherActivities->setEnabled(enabled);
+}
+
+void KWinTabBoxConfigForm::setFilterMinimizationEnabled(bool enabled)
+{
+    ui->filterMinimization->setEnabled(enabled);
+    ui->visibleWindows->setEnabled(enabled);
+    ui->hiddenWindows->setEnabled(enabled);
+}
+
+void KWinTabBoxConfigForm::setApplicationModeEnabled(bool enabled)
+{
+    ui->oneAppWindow->setEnabled(enabled);
+}
+
+void KWinTabBoxConfigForm::setShowDesktopModeEnabled(bool enabled)
+{
+    ui->showDesktop->setEnabled(enabled);
+}
+
+void KWinTabBoxConfigForm::setSwitchingModeEnabled(bool enabled)
+{
+    ui->switchingModeCombo->setEnabled(enabled);
+}
+
+void KWinTabBoxConfigForm::setLayoutNameEnabled(bool enabled)
+{
+    ui->effectCombo->setEnabled(enabled);
+}
+
 void KWinTabBoxConfigForm::tabBoxToggled(bool on)
 {
     // Highlight Windows options is availabled if no TabBox effect is selected
     // or if Tabbox is not builtin effet.
     on = !on || ui->effectCombo->currentData(AddonEffect).toBool();
-    ui->kcfg_HighlightWindows->setEnabled(on);
+    ui->kcfg_HighlightWindows->setEnabled(on && m_isHighlightWindowsEnabled);
 }
 
 void KWinTabBoxConfigForm::onFilterScreen()
 {
     emit filterScreenChanged(filterScreen());
 }
 
 void KWinTabBoxConfigForm::onFilterDesktop()
 {
     emit filterDesktopChanged(filterDesktop());
 }
 
 void KWinTabBoxConfigForm::onFilterActivites()
 {
     emit filterActivitiesChanged(filterActivities());
 }
 
 void KWinTabBoxConfigForm::onFilterMinimization()
 {
     emit filterMinimizationChanged(filterMinimization());
 }
 
 void KWin::KWinTabBoxConfigForm::onApplicationMode()
 {
     emit applicationModeChanged(applicationMode());
 }
 
 void KWinTabBoxConfigForm::onShowDesktopMode()
 {
     emit showDesktopModeChanged(showDesktopMode());
 }
 
 void KWinTabBoxConfigForm::onSwitchingMode()
 {
     emit switchingModeChanged(switchingMode());
 }
 
 void KWinTabBoxConfigForm::onEffectCombo()
 {
     const bool isAddonEffect = ui->effectCombo->currentData(AddonEffect).toBool();
     ui->effectConfigButton->setIcon(QIcon::fromTheme(isAddonEffect ? "view-preview" : "configure"));
     if (!ui->kcfg_ShowTabBox->isChecked()) {
         return;
     }
-    ui->kcfg_HighlightWindows->setEnabled(isAddonEffect);
+    ui->kcfg_HighlightWindows->setEnabled(isAddonEffect && m_isHighlightWindowsEnabled);
 
     emit layoutNameChanged(layoutName());
 }
 
 void KWinTabBoxConfigForm::shortcutChanged(const QKeySequence &seq)
 {
     QString action;
     if (sender()) {
         action = sender()->property("shortcutAction").toString();
     }
     if (action.isEmpty()) {
         return;
     }
     QAction *a = m_actionCollection->action(action);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << seq, KGlobalAccel::NoAutoloading);
     m_actionCollection->writeSettings();
 }
 
 } // namespace
diff --git a/kcmkwin/kwintabbox/kwintabboxconfigform.h b/kcmkwin/kwintabbox/kwintabboxconfigform.h
index 08fabde5f..1eaaa174d 100644
--- a/kcmkwin/kwintabbox/kwintabboxconfigform.h
+++ b/kcmkwin/kwintabbox/kwintabboxconfigform.h
@@ -1,122 +1,133 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2009 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2020 Cyril Rossi <cyril.rossi@enioka.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/>.
 *********************************************************************/
 
 #ifndef __KWINTABBOXCONFIGFORM_H__
 #define __KWINTABBOXCONFIGFORM_H__
 
 #include <QWidget>
 #include <QStandardItemModel>
 
 #include "tabboxconfig.h"
 
 class KShortcutsEditor;
 class KActionCollection;
 
 namespace Ui
 {
 class KWinTabBoxConfigForm;
 }
 
 namespace KWin
 {
 
 class KWinTabBoxConfigForm : public QWidget
 {
     Q_OBJECT
 
 public:
     enum class TabboxType
     {
         Main,
         Alternative,
     };
 
 
     enum EffectComboRole
     {
         LayoutPath = Qt::UserRole + 1,
         AddonEffect, // i.e not builtin effects
     };
 
     explicit KWinTabBoxConfigForm(TabboxType type, QWidget *parent = nullptr);
     ~KWinTabBoxConfigForm() override;
 
     bool highlightWindows() const;
     bool showTabBox() const;
     int filterScreen() const;
     int filterDesktop() const;
     int filterActivities() const;
     int filterMinimization() const;
     int applicationMode() const;
     int showDesktopMode() const;
     int switchingMode() const;
     QString layoutName() const;
 
     void setFilterScreen(TabBox::TabBoxConfig::ClientMultiScreenMode mode);
     void setFilterDesktop(TabBox::TabBoxConfig::ClientDesktopMode mode);
     void setFilterActivities(TabBox::TabBoxConfig::ClientActivitiesMode mode);
     void setFilterMinimization(TabBox::TabBoxConfig::ClientMinimizedMode mode);
     void setApplicationMode(TabBox::TabBoxConfig::ClientApplicationsMode mode);
     void setShowDesktopMode(TabBox::TabBoxConfig::ShowDesktopMode mode);
     void setSwitchingModeChanged(TabBox::TabBoxConfig::ClientSwitchingMode mode);
     void setLayoutName(const QString &layoutName);
 
     // EffectCombo Data Model
     void setEffectComboModel(QStandardItemModel *model);
     QVariant effectComboCurrentData(int role = Qt::UserRole) const;
 
     void loadShortcuts();
     void resetShortcuts();
 
+    void setHighlightWindowsEnabled(bool enabled);
+    void setFilterScreenEnabled(bool enabled);
+    void setFilterDesktopEnabled(bool enabled);
+    void setFilterActivitiesEnabled(bool enabled);
+    void setFilterMinimizationEnabled(bool enabled);
+    void setApplicationModeEnabled(bool enabled);
+    void setShowDesktopModeEnabled(bool enabled);
+    void setSwitchingModeEnabled(bool enabled);
+    void setLayoutNameEnabled(bool enabled);
+
 Q_SIGNALS:
     void filterScreenChanged(int value);
     void filterDesktopChanged(int value);
     void filterActivitiesChanged(int value);
     void filterMinimizationChanged(int value);
     void applicationModeChanged(int value);
     void showDesktopModeChanged(int value);
     void switchingModeChanged(int value);
     void layoutNameChanged(const QString &layoutName);
     void effectConfigButtonClicked();
 
 private Q_SLOTS:
     void tabBoxToggled(bool on);
     void onFilterScreen();
     void onFilterDesktop();
     void onFilterActivites();
     void onFilterMinimization();
     void onApplicationMode();
     void onShowDesktopMode();
     void onSwitchingMode();
     void onEffectCombo();
     void shortcutChanged(const QKeySequence &seq);
 
 private:
     KActionCollection *m_actionCollection = nullptr;
     KShortcutsEditor *m_editor = nullptr;
 
+    bool m_isHighlightWindowsEnabled = true;
     TabboxType m_type;
     Ui::KWinTabBoxConfigForm *ui;
 };
 
 } // namespace
 
 #endif
diff --git a/kcmkwin/kwintabbox/main.cpp b/kcmkwin/kwintabbox/main.cpp
index 20897de92..794a01f7a 100644
--- a/kcmkwin/kwintabbox/main.cpp
+++ b/kcmkwin/kwintabbox/main.cpp
@@ -1,474 +1,490 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2009 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2020 Cyril Rossi <cyril.rossi@enioka.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 "main.h"
 #include <effect_builtins.h>
 #include <kwin_effects_interface.h>
 
 // Qt
 #include <QtDBus>
 #include <QDesktopWidget>
 #include <QDialogButtonBox>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QVBoxLayout>
 #include <QSpacerItem>
 #include <QTabWidget>
 #include <QStandardPaths>
 #include <QPointer>
 #include <QStandardItemModel>
 
 // KDE
 #include <KCModuleProxy>
 #include <KLocalizedString>
 #include <KPluginFactory>
 #include <KPluginTrader>
 #include <KTitleWidget>
 #include <KServiceTypeTrader>
 #include <KNewStuff3/KNS3/DownloadDialog>
 // Plasma
 #include <KPackage/Package>
 #include <KPackage/PackageLoader>
 
 // own
 #include "kwintabboxconfigform.h"
 #include "layoutpreview.h"
 #include "kwintabboxsettings.h"
 #include "kwinswitcheffectsettings.h"
 #include "kwinpluginssettings.h"
 
 K_PLUGIN_FACTORY(KWinTabBoxConfigFactory, registerPlugin<KWin::KWinTabBoxConfig>();)
 
 namespace KWin
 {
 
 using namespace TabBox;
 
 
 KWinTabBoxConfig::KWinTabBoxConfig(QWidget* parent, const QVariantList& args)
     : KCModule(parent, args)
     , m_config(KSharedConfig::openConfig("kwinrc"))
     , m_tabBoxConfig(new TabBoxSettings(QStringLiteral("TabBox"), this))
     , m_tabBoxAlternativeConfig(new TabBoxSettings(QStringLiteral("TabBoxAlternative"), this))
     , m_coverSwitchConfig(new SwitchEffectSettings(QStringLiteral("Effect-CoverSwitch"), this))
     , m_flipSwitchConfig(new SwitchEffectSettings(QStringLiteral("Effect-FlipSwitch"), this))
     , m_pluginsConfig(new PluginsSettings(this))
 {
     QTabWidget* tabWidget = new QTabWidget(this);
     m_primaryTabBoxUi = new KWinTabBoxConfigForm(KWinTabBoxConfigForm::TabboxType::Main, tabWidget);
     m_alternativeTabBoxUi = new KWinTabBoxConfigForm(KWinTabBoxConfigForm::TabboxType::Alternative, tabWidget);
     tabWidget->addTab(m_primaryTabBoxUi, i18n("Main"));
     tabWidget->addTab(m_alternativeTabBoxUi, i18n("Alternative"));
 
     QPushButton* ghnsButton = new QPushButton(QIcon::fromTheme(QStringLiteral("get-hot-new-stuff")), i18n("Get New Task Switchers..."));
     connect(ghnsButton, SIGNAL(clicked(bool)), SLOT(slotGHNS()));
 
     QHBoxLayout* buttonBar = new QHBoxLayout();
     QSpacerItem* buttonBarSpacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
     buttonBar->addItem(buttonBarSpacer);
     buttonBar->addWidget(ghnsButton);
 
     QVBoxLayout* layout = new QVBoxLayout(this);
     KTitleWidget* infoLabel = new KTitleWidget(tabWidget);
     infoLabel->setText(i18n("Focus policy settings limit the functionality of navigating through windows."),
                        KTitleWidget::InfoMessage);
     infoLabel->setPixmap(KTitleWidget::InfoMessage, KTitleWidget::ImageLeft);
     layout->addWidget(infoLabel,0);
     layout->addWidget(tabWidget,1);
     layout->addLayout(buttonBar);
     setLayout(layout);
 
     addConfig(m_tabBoxConfig, m_primaryTabBoxUi);
     addConfig(m_tabBoxAlternativeConfig, m_alternativeTabBoxUi);
 
-    createConnections(m_primaryTabBoxUi, m_tabBoxConfig);
-    createConnections(m_alternativeTabBoxUi, m_tabBoxAlternativeConfig);
+    createConnections(m_primaryTabBoxUi);
+    createConnections(m_alternativeTabBoxUi);
 
     initLayoutLists();
 
     // check focus policy - we don't offer configs for unreasonable focus policies
     KConfigGroup config(m_config, "Windows");
     QString policy = config.readEntry("FocusPolicy", "ClickToFocus");
     if ((policy == "FocusUnderMouse") || (policy == "FocusStrictlyUnderMouse")) {
         tabWidget->setEnabled(false);
         infoLabel->show();
     } else {
         infoLabel->hide();
     }
+
+    setEnabledUi(m_primaryTabBoxUi, m_tabBoxConfig);
+    setEnabledUi(m_alternativeTabBoxUi, m_tabBoxAlternativeConfig);
 }
 
 KWinTabBoxConfig::~KWinTabBoxConfig()
 {
 }
 
 static QList<KPackage::Package> availableLnFPackages()
 {
     QList<KPackage::Package> packages;
     QStringList paths;
     const QStringList dataPaths = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation);
 
     for (const QString &path : dataPaths) {
         QDir dir(path + QLatin1String("/plasma/look-and-feel"));
         paths << dir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot);
     }
 
     const auto &p = paths;
     for (const QString &path : p) {
         KPackage::Package pkg = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/LookAndFeel"));
         pkg.setPath(path);
         pkg.setFallbackPackage(KPackage::Package());
         if (!pkg.filePath("defaults").isEmpty()) {
             KSharedConfigPtr conf = KSharedConfig::openConfig(pkg.filePath("defaults"));
             KConfigGroup cg = KConfigGroup(conf, "kwinrc");
             cg = KConfigGroup(&cg, "WindowSwitcher");
             if (!cg.readEntry("LayoutName", QString()).isEmpty()) {
                 packages << pkg;
             }
         }
     }
 
     return packages;
 }
 
 void KWinTabBoxConfig::initLayoutLists()
 {
     // search the effect names
     m_coverSwitch = BuiltInEffects::effectData(BuiltInEffect::CoverSwitch).name;
     m_flipSwitch = BuiltInEffects::effectData(BuiltInEffect::FlipSwitch).name;
 
     QList<KPluginMetaData> offers = KPackage::PackageLoader::self()->listPackages("KWin/WindowSwitcher");
     QStringList layoutNames, layoutPlugins, layoutPaths;
 
     const auto lnfPackages = availableLnFPackages();
     for (const auto &package : lnfPackages) {
         const auto &metaData = package.metadata();
         layoutNames << metaData.name();
         layoutPlugins << metaData.pluginId();
         layoutPaths << package.filePath("windowswitcher", QStringLiteral("WindowSwitcher.qml"));
     }
 
     for (const auto &offer : offers) {
         const QString pluginName = offer.pluginId();
         if (offer.value("X-Plasma-API") != "declarativeappletscript") {
             continue;
         }
         //we don't have a proper servicetype
         if (offer.value("X-KWin-Exclude-Listing") == QStringLiteral("true")) {
             continue;
         }
         const QString scriptName = offer.value("X-Plasma-MainScript");
         const QString scriptFile = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                                           QLatin1String("kwin/tabbox/") + pluginName + QLatin1String("/contents/")
                                                           + scriptName);
         if (scriptFile.isNull()) {
             continue;
         }
 
         layoutNames << offer.name();
         layoutPlugins << pluginName;
         layoutPaths << scriptFile;
     }
 
 
     KWinTabBoxConfigForm *ui[2] = { m_primaryTabBoxUi, m_alternativeTabBoxUi };
     for (int i=0; i<2; ++i) {
         QStandardItemModel *model = new QStandardItemModel;
 
         QStandardItem *coverItem = new QStandardItem(BuiltInEffects::effectData(BuiltInEffect::CoverSwitch).displayName);
         coverItem->setData(m_coverSwitch, Qt::UserRole);
         coverItem->setData(false, KWinTabBoxConfigForm::AddonEffect);
         model->appendRow(coverItem);
 
         QStandardItem *flipItem = new QStandardItem(BuiltInEffects::effectData(BuiltInEffect::FlipSwitch).displayName);
         flipItem->setData(m_flipSwitch, Qt::UserRole);
         flipItem->setData(false, KWinTabBoxConfigForm::AddonEffect);
         model->appendRow(flipItem);
 
         for (int j = 0; j < layoutNames.count(); ++j) {
             QStandardItem *item = new QStandardItem(layoutNames[j]);
             item->setData(layoutPlugins[j], Qt::UserRole);
             item->setData(layoutPaths[j], KWinTabBoxConfigForm::LayoutPath);
             item->setData(true, KWinTabBoxConfigForm::AddonEffect);
             model->appendRow(item);
         }
         model->sort(0);
         ui[i]->setEffectComboModel(model);
     }
 }
 
-void KWinTabBoxConfig::createConnections(KWinTabBoxConfigForm *form, TabBoxSettings *config)
+void KWinTabBoxConfig::setEnabledUi(KWinTabBoxConfigForm *form, const TabBoxSettings *config)
+{
+    form->setHighlightWindowsEnabled(!config->isHighlightWindowsImmutable());
+    form->setFilterScreenEnabled(!config->isMultiScreenModeImmutable());
+    form->setFilterDesktopEnabled(!config->isDesktopModeImmutable());
+    form->setFilterActivitiesEnabled(!config->isActivitiesModeImmutable());
+    form->setFilterMinimizationEnabled(!config->isMinimizedModeImmutable());
+    form->setApplicationModeEnabled(!config->isApplicationsModeImmutable());
+    form->setShowDesktopModeEnabled(!config->isShowDesktopModeImmutable());
+    form->setSwitchingModeEnabled(!config->isSwitchingModeImmutable());
+    form->setLayoutNameEnabled(!config->isLayoutNameImmutable());
+}
+
+void KWinTabBoxConfig::createConnections(KWinTabBoxConfigForm *form)
 {
     connect(form, SIGNAL(effectConfigButtonClicked()), this, SLOT(configureEffectClicked()));
 
     connect(form, SIGNAL(filterScreenChanged(int)), this, SLOT(updateUnmanagedState()));
     connect(form, SIGNAL(filterDesktopChanged(int)), this, SLOT(updateUnmanagedState()));
     connect(form, SIGNAL(filterActivitiesChanged(int)), this, SLOT(updateUnmanagedState()));
     connect(form, SIGNAL(filterMinimizationChanged(int)), this, SLOT(updateUnmanagedState()));
     connect(form, SIGNAL(applicationModeChanged(int)), this, SLOT(updateUnmanagedState()));
     connect(form, SIGNAL(showDesktopModeChanged(int)), this, SLOT(updateUnmanagedState()));
     connect(form, SIGNAL(switchingModeChanged(int)), this, SLOT(updateUnmanagedState()));
     connect(form, SIGNAL(layoutNameChanged(QString)), this, SLOT(updateUnmanagedState()));
 }
 
 void KWinTabBoxConfig::updateUnmanagedState()
 {
     bool isNeedSave = false;
     isNeedSave |= updateUnmanagedIsNeedSave(m_primaryTabBoxUi, m_tabBoxConfig);
     isNeedSave |= updateUnmanagedIsNeedSave(m_alternativeTabBoxUi, m_tabBoxAlternativeConfig);
 
     unmanagedWidgetChangeState(isNeedSave);
 
     bool isDefault = true;
     isDefault &= updateUnmanagedIsDefault(m_primaryTabBoxUi, m_tabBoxConfig);
     isDefault &= updateUnmanagedIsDefault(m_alternativeTabBoxUi, m_tabBoxAlternativeConfig);
 
     unmanagedWidgetDefaultState(isDefault);
 }
 
 bool KWinTabBoxConfig::updateUnmanagedIsNeedSave(const KWinTabBoxConfigForm *form, const TabBoxSettings *config)
 {
     bool isNeedSave = false;
     isNeedSave |= form->filterScreen() != config->multiScreenMode();
     isNeedSave |= form->filterDesktop() != config->desktopMode();
     isNeedSave |= form->filterActivities() != config->activitiesMode();
     isNeedSave |= form->filterMinimization() != config->minimizedMode();
     isNeedSave |= form->applicationMode() != config->applicationsMode();
     isNeedSave |= form->showDesktopMode() != config->showDesktopMode();
     isNeedSave |= form->switchingMode() != config->switchingMode();
     isNeedSave |= form->layoutName() != config->layoutName();
 
     return isNeedSave;
 }
 
 bool KWinTabBoxConfig::updateUnmanagedIsDefault(const KWinTabBoxConfigForm *form, const TabBoxSettings *config)
 {
     bool isDefault = true;
     isDefault &= form->filterScreen() == config->defaultMultiScreenModeValue();
     isDefault &= form->filterDesktop() == config->defaultDesktopModeValue();
     isDefault &= form->filterActivities() == config->defaultActivitiesModeValue();
     isDefault &= form->filterMinimization() == config->defaultMinimizedModeValue();
     isDefault &= form->applicationMode() == config->defaultApplicationsModeValue();
     isDefault &= form->showDesktopMode() == config->defaultShowDesktopModeValue();
     isDefault &= form->switchingMode() == config->defaultSwitchingModeValue();
     isDefault &= form->layoutName() == config->defaultLayoutNameValue();
 
     return isDefault;
 }
 
 void KWinTabBoxConfig::load()
 {
     KCModule::load();
 
     m_tabBoxConfig->load();
     m_tabBoxAlternativeConfig->load();
 
     updateUiFromConfig(m_primaryTabBoxUi, m_tabBoxConfig);
     updateUiFromConfig(m_alternativeTabBoxUi , m_tabBoxAlternativeConfig);
 
     m_coverSwitchConfig->load();
     m_flipSwitchConfig->load();
 
     m_pluginsConfig->load();
 
     if (m_pluginsConfig->coverswitchEnabled()) {
         if (m_coverSwitchConfig->tabBox()) {
             m_primaryTabBoxUi->setLayoutName(m_coverSwitch);
         }
         if (m_coverSwitchConfig->tabBoxAlternative()) {
             m_alternativeTabBoxUi->setLayoutName(m_coverSwitch);
         }
     }
     if (m_pluginsConfig->flipswitchEnabled()) {
         if (m_flipSwitchConfig->tabBox()) {
             m_primaryTabBoxUi->setLayoutName(m_flipSwitch);
         }
         if (m_flipSwitchConfig->tabBoxAlternative()) {
             m_alternativeTabBoxUi->setLayoutName(m_flipSwitch);
         }
     }
 
     m_primaryTabBoxUi->loadShortcuts();
     m_alternativeTabBoxUi->loadShortcuts();
 
     updateUnmanagedState();
 }
 
 void KWinTabBoxConfig::save()
 {
     // effects
     const bool highlightWindows = m_primaryTabBoxUi->highlightWindows() || m_alternativeTabBoxUi->highlightWindows();
     const bool coverSwitch = m_primaryTabBoxUi->showTabBox()
             && m_primaryTabBoxUi->effectComboCurrentData().toString() == m_coverSwitch;
     const bool flipSwitch = m_primaryTabBoxUi->showTabBox()
             && m_primaryTabBoxUi->effectComboCurrentData().toString() == m_flipSwitch;
     const bool coverSwitchAlternative = m_alternativeTabBoxUi->showTabBox()
             && m_alternativeTabBoxUi->effectComboCurrentData().toString() == m_coverSwitch;
     const bool flipSwitchAlternative = m_alternativeTabBoxUi->showTabBox()
             && m_alternativeTabBoxUi->effectComboCurrentData().toString() == m_flipSwitch;
 
     // activate effects if not active
     if (coverSwitch || coverSwitchAlternative) {
         m_pluginsConfig->setCoverswitchEnabled(true);
     }
     if (flipSwitch || flipSwitchAlternative) {
         m_pluginsConfig->setFlipswitchEnabled(true);
     }
     if (highlightWindows) {
         m_pluginsConfig->setHighlightwindowEnabled(true);
     }
     m_pluginsConfig->save();
 
     m_coverSwitchConfig->setTabBox(coverSwitch);
     m_coverSwitchConfig->setTabBoxAlternative(coverSwitchAlternative);
     m_coverSwitchConfig->save();
 
     m_flipSwitchConfig->setTabBox(flipSwitch);
     m_flipSwitchConfig->setTabBoxAlternative(flipSwitchAlternative);
     m_flipSwitchConfig->save();
 
     updateConfigFromUi(m_primaryTabBoxUi, m_tabBoxConfig);
     updateConfigFromUi(m_alternativeTabBoxUi, m_tabBoxAlternativeConfig);
 
     m_tabBoxConfig->save();
     m_tabBoxAlternativeConfig->save();
 
     KCModule::save();
     updateUnmanagedState();
 
     // Reload KWin.
     QDBusMessage message = QDBusMessage::createSignal("/KWin", "org.kde.KWin", "reloadConfig");
     QDBusConnection::sessionBus().send(message);
     // and reconfigure the effects
     OrgKdeKwinEffectsInterface interface(QStringLiteral("org.kde.KWin"),
                                              QStringLiteral("/Effects"),
                                              QDBusConnection::sessionBus());
     interface.reconfigureEffect(BuiltInEffects::nameForEffect(BuiltInEffect::CoverSwitch));
     interface.reconfigureEffect(BuiltInEffects::nameForEffect(BuiltInEffect::FlipSwitch));
 }
 
 void KWinTabBoxConfig::defaults()
 {
     m_coverSwitchConfig->setDefaults();
     m_flipSwitchConfig->setDefaults();
 
     updateUiFromDefaultConfig(m_primaryTabBoxUi, m_tabBoxConfig);
     updateUiFromDefaultConfig(m_alternativeTabBoxUi, m_tabBoxAlternativeConfig);
 
     m_primaryTabBoxUi->resetShortcuts();
     m_alternativeTabBoxUi->resetShortcuts();
 
     KCModule::defaults();
     updateUnmanagedState();
 }
 
 void KWinTabBoxConfig::updateUiFromConfig(KWinTabBoxConfigForm *form, const KWin::TabBox::TabBoxSettings *config)
 {
     form->setFilterScreen(static_cast<TabBoxConfig::ClientMultiScreenMode>(config->multiScreenMode()));
     form->setFilterDesktop(static_cast<TabBoxConfig::ClientDesktopMode>(config->desktopMode()));
     form->setFilterActivities(static_cast<TabBoxConfig::ClientActivitiesMode>(config->activitiesMode()));
     form->setFilterMinimization(static_cast<TabBoxConfig::ClientMinimizedMode>(config->minimizedMode()));
     form->setApplicationMode(static_cast<TabBoxConfig::ClientApplicationsMode>(config->applicationsMode()));
     form->setShowDesktopMode(static_cast<TabBoxConfig::ShowDesktopMode>(config->showDesktopMode()));
     form->setSwitchingModeChanged(static_cast<TabBoxConfig::ClientSwitchingMode>(config->switchingMode()));
     form->setLayoutName(config->layoutName());
 }
 
 void KWinTabBoxConfig::updateConfigFromUi(const KWinTabBoxConfigForm *form, TabBoxSettings *config)
 {
     config->setMultiScreenMode(form->filterScreen());
     config->setDesktopMode(form->filterDesktop());
     config->setActivitiesMode(form->filterActivities());
     config->setMinimizedMode(form->filterMinimization());
     config->setApplicationsMode(form->applicationMode());
     config->setShowDesktopMode(form->showDesktopMode());
     config->setSwitchingMode(form->switchingMode());
     config->setLayoutName(form->layoutName());
 }
 
 void KWinTabBoxConfig::updateUiFromDefaultConfig(KWinTabBoxConfigForm *form, const KWin::TabBox::TabBoxSettings *config)
 {
     form->setFilterScreen(static_cast<TabBoxConfig::ClientMultiScreenMode>(config->defaultMultiScreenModeValue()));
     form->setFilterDesktop(static_cast<TabBoxConfig::ClientDesktopMode>(config->defaultDesktopModeValue()));
     form->setFilterActivities(static_cast<TabBoxConfig::ClientActivitiesMode>(config->defaultActivitiesModeValue()));
     form->setFilterMinimization(static_cast<TabBoxConfig::ClientMinimizedMode>(config->defaultMinimizedModeValue()));
     form->setApplicationMode(static_cast<TabBoxConfig::ClientApplicationsMode>(config->defaultApplicationsModeValue()));
     form->setShowDesktopMode(static_cast<TabBoxConfig::ShowDesktopMode>(config->defaultShowDesktopModeValue()));
     form->setSwitchingModeChanged(static_cast<TabBoxConfig::ClientSwitchingMode>(config->defaultSwitchingModeValue()));
     form->setLayoutName(config->defaultLayoutNameValue());
 }
 
 void KWinTabBoxConfig::configureEffectClicked()
 {
     auto form = qobject_cast<KWinTabBoxConfigForm *>(sender());
     Q_ASSERT(form);
 
     if (form->effectComboCurrentData(KWinTabBoxConfigForm::AddonEffect).toBool()) {
         // Show the preview for addon effect
         new LayoutPreview(form->effectComboCurrentData(KWinTabBoxConfigForm::LayoutPath).toString(), this);
     } else {
         // For builtin effect, display a configuration dialog
         QPointer<QDialog> configDialog = new QDialog(this);
         configDialog->setLayout(new QVBoxLayout);
         configDialog->setWindowTitle(form->effectComboCurrentData(Qt::DisplayRole).toString());
         QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel|QDialogButtonBox::RestoreDefaults, configDialog);
         connect(buttonBox, SIGNAL(accepted()), configDialog, SLOT(accept()));
         connect(buttonBox, SIGNAL(rejected()), configDialog, SLOT(reject()));
 
         const QString name = form->effectComboCurrentData().toString();
         KCModule *kcm = KPluginTrader::createInstanceFromQuery<KCModule>(QStringLiteral("kwin/effects/configs/"), QString(),
                                                                          QStringLiteral("'%1' in [X-KDE-ParentComponents]").arg(name),
                                                                          configDialog);
         if (!kcm) {
             delete configDialog;
             return;
         }
 
         connect(buttonBox->button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked, kcm, &KCModule::defaults);
 
         QWidget *showWidget = new QWidget(configDialog);
         QVBoxLayout *layout = new QVBoxLayout;
         showWidget->setLayout(layout);
         layout->addWidget(kcm);
         configDialog->layout()->addWidget(showWidget);
         configDialog->layout()->addWidget(buttonBox);
 
         if (configDialog->exec() == QDialog::Accepted) {
             kcm->save();
         } else {
             kcm->load();
         }
         delete configDialog;
     }
 }
 
 void KWinTabBoxConfig::slotGHNS()
 {
     QPointer<KNS3::DownloadDialog> downloadDialog = new KNS3::DownloadDialog("kwinswitcher.knsrc", this);
     if (downloadDialog->exec() == QDialog::Accepted) {
         if (!downloadDialog->changedEntries().isEmpty()) {
             initLayoutLists();
         }
     }
     delete downloadDialog;
 }
 
 } // namespace
 
 #include "main.moc"
diff --git a/kcmkwin/kwintabbox/main.h b/kcmkwin/kwintabbox/main.h
index 1cac4bc4b..9bc754f50 100644
--- a/kcmkwin/kwintabbox/main.h
+++ b/kcmkwin/kwintabbox/main.h
@@ -1,86 +1,87 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2009 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2020 Cyril Rossi <cyril.rossi@enioka.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/>.
 *********************************************************************/
 
 #ifndef __MAIN_H__
 #define __MAIN_H__
 
 #include <kcmodule.h>
 #include <ksharedconfig.h>
 #include "tabboxconfig.h"
 
 namespace KWin
 {
 class KWinTabBoxConfigForm;
 enum class BuiltInEffect;
 namespace TabBox
 {
 class TabBoxSettings;
 class SwitchEffectSettings;
 class PluginsSettings;
 }
 
 
 class KWinTabBoxConfig : public KCModule
 {
     Q_OBJECT
 
 public:
     explicit KWinTabBoxConfig(QWidget* parent, const QVariantList& args);
     ~KWinTabBoxConfig() override;
 
 public Q_SLOTS:
     void save() override;
     void load() override;
     void defaults() override;
 
 private Q_SLOTS:
     void updateUnmanagedState();
     void configureEffectClicked();
     void slotGHNS();
 
 private:
     void updateUiFromConfig(KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
     void updateConfigFromUi(const KWinTabBoxConfigForm *form, TabBox::TabBoxSettings *config);
     void updateUiFromDefaultConfig(KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
     void initLayoutLists();
-    void createConnections(KWinTabBoxConfigForm *form, TabBox::TabBoxSettings *config);
+    void setEnabledUi(KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
+    void createConnections(KWinTabBoxConfigForm *form);
     bool updateUnmanagedIsNeedSave(const KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
     bool updateUnmanagedIsDefault(const KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
 
 private:
     KWinTabBoxConfigForm *m_primaryTabBoxUi = nullptr;
     KWinTabBoxConfigForm *m_alternativeTabBoxUi = nullptr;
     KSharedConfigPtr m_config;
 
     TabBox::TabBoxSettings *m_tabBoxConfig;
     TabBox::TabBoxSettings *m_tabBoxAlternativeConfig;
     TabBox::SwitchEffectSettings *m_coverSwitchConfig;
     TabBox::SwitchEffectSettings *m_flipSwitchConfig;
     TabBox::PluginsSettings *m_pluginsConfig;
 
     // Builtin effects' names
     QString m_coverSwitch;
     QString m_flipSwitch;
 };
 
 } // namespace
 
 #endif