diff --git a/src/kcms/tabbox/kwintabboxconfigform.cpp b/src/kcms/tabbox/kwintabboxconfigform.cpp
index 190cd1203d..4ef8f8817f 100644
--- a/src/kcms/tabbox/kwintabboxconfigform.cpp
+++ b/src/kcms/tabbox/kwintabboxconfigform.cpp
@@ -4,27 +4,26 @@
 
     SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org>
     SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com>
+    SPDX-FileCopyrightText: 2023 Ismael Asensio <isma.af@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "kwintabboxconfigform.h"
+#include "kwintabboxsettings.h"
 #include "ui_main.h"
 
-#include <QDebug>
-
 #include <KActionCollection>
 #include <KGlobalAccel>
-#include <KShortcutsEditor>
 
 namespace KWin
 {
 
 using namespace TabBox;
 
-KWinTabBoxConfigForm::KWinTabBoxConfigForm(TabboxType type, QWidget *parent)
+KWinTabBoxConfigForm::KWinTabBoxConfigForm(TabboxType type, TabBoxSettings *config, QWidget *parent)
     : QWidget(parent)
-    , m_type(type)
+    , m_config(config)
     , ui(new Ui::KWinTabBoxConfigForm)
 {
     ui->setupUi(this);
@@ -36,6 +35,8 @@ KWinTabBoxConfigForm::KWinTabBoxConfigForm(TabboxType type, QWidget *parent)
         ui->screenFilter->hide();
     }
 
+    connect(this, &KWinTabBoxConfigForm::configChanged, this, &KWinTabBoxConfigForm::updateDefaultIndicators);
+
     connect(ui->effectConfigButton, &QPushButton::clicked, this, &KWinTabBoxConfigForm::effectConfigButtonClicked);
 
     connect(ui->kcfg_ShowTabBox, &QAbstractButton::clicked, this, &KWinTabBoxConfigForm::tabBoxToggled);
@@ -81,17 +82,19 @@ KWinTabBoxConfigForm::KWinTabBoxConfigForm(TabboxType type, QWidget *parent)
     m_actionCollection->setConfigGroup("Navigation");
     m_actionCollection->setConfigGlobal(true);
 
-    if (TabboxType::Main == m_type) {
+    if (TabboxType::Main == 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) {
+    } else if (TabboxType::Alternative == 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);
     }
+
+    updateUiFromConfig();
 }
 
 KWinTabBoxConfigForm::~KWinTabBoxConfigForm()
@@ -99,6 +102,11 @@ KWinTabBoxConfigForm::~KWinTabBoxConfigForm()
     delete ui;
 }
 
+TabBoxSettings *KWinTabBoxConfigForm::config() const
+{
+    return m_config;
+}
+
 bool KWinTabBoxConfigForm::highlightWindows() const
 {
     return ui->kcfg_HighlightWindows->isChecked();
@@ -220,21 +228,18 @@ void KWinTabBoxConfigForm::setSwitchingModeChanged(TabBox::TabBoxConfig::ClientS
 
 void KWinTabBoxConfigForm::setLayoutName(const QString &layoutName)
 {
-    ui->effectCombo->setCurrentIndex(ui->effectCombo->findData(layoutName));
+    const int index = ui->effectCombo->findData(layoutName);
+    if (index >= 0) {
+        ui->effectCombo->setCurrentIndex(index);
+    }
 }
 
 void KWinTabBoxConfigForm::setEffectComboModel(QStandardItemModel *model)
 {
-    int index = ui->effectCombo->currentIndex();
-    QVariant data = ui->effectCombo->itemData(index);
-
+    // We don't want to lose the config layout when resetting the combo model
+    const QString layout = m_config->layoutName();
     ui->effectCombo->setModel(model);
-
-    if (data.isValid()) {
-        ui->effectCombo->setCurrentIndex(ui->effectCombo->findData(data));
-    } else if (index != -1) {
-        ui->effectCombo->setCurrentIndex(index);
-    }
+    setLayoutName(layout);
 }
 
 QVariant KWinTabBoxConfigForm::effectComboCurrentData(int role) const
@@ -298,129 +303,6 @@ bool KWinTabBoxConfigForm::isShortcutsDefault() const
     return true;
 }
 
-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::setOrderMinimizedModeEnabled(bool enabled)
-{
-    ui->orderMinimized->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::setFilterScreenDefaultIndicatorVisible(bool visible)
-{
-    setDefaultIndicatorVisible(ui->filterScreens, visible);
-    setDefaultIndicatorVisible(ui->currentScreen, visible);
-    setDefaultIndicatorVisible(ui->otherScreens, visible);
-}
-
-void KWinTabBoxConfigForm::setFilterDesktopDefaultIndicatorVisible(bool visible)
-{
-    setDefaultIndicatorVisible(ui->filterDesktops, visible);
-    setDefaultIndicatorVisible(ui->currentDesktop, visible);
-    setDefaultIndicatorVisible(ui->otherDesktops, visible);
-}
-
-void KWinTabBoxConfigForm::setFilterActivitiesDefaultIndicatorVisible(bool visible)
-{
-    setDefaultIndicatorVisible(ui->filterActivities, visible);
-    setDefaultIndicatorVisible(ui->currentActivity, visible);
-    setDefaultIndicatorVisible(ui->otherActivities, visible);
-}
-
-void KWinTabBoxConfigForm::setFilterMinimizationDefaultIndicatorVisible(bool visible)
-{
-    setDefaultIndicatorVisible(ui->filterMinimization, visible);
-    setDefaultIndicatorVisible(ui->visibleWindows, visible);
-    setDefaultIndicatorVisible(ui->hiddenWindows, visible);
-}
-
-void KWinTabBoxConfigForm::setApplicationModeDefaultIndicatorVisible(bool visible)
-{
-    setDefaultIndicatorVisible(ui->oneAppWindow, visible);
-}
-
-void KWinTabBoxConfigForm::setOrderMinimizedDefaultIndicatorVisible(bool visible)
-{
-    setDefaultIndicatorVisible(ui->orderMinimized, visible);
-}
-
-void KWinTabBoxConfigForm::setShowDesktopModeDefaultIndicatorVisible(bool visible)
-{
-    setDefaultIndicatorVisible(ui->showDesktop, visible);
-}
-
-void KWinTabBoxConfigForm::setSwitchingModeDefaultIndicatorVisible(bool visible)
-{
-    setDefaultIndicatorVisible(ui->switchingModeCombo, visible);
-}
-
-void KWinTabBoxConfigForm::setLayoutNameDefaultIndicatorVisible(bool visible)
-{
-    setDefaultIndicatorVisible(ui->effectCombo, visible);
-}
-
-void KWinTabBoxConfigForm::setShortcutsDefaultIndicatorVisible(bool visible)
-{
-    for (const auto &widget : {ui->scAll, ui->scAllReverse, ui->scCurrent, ui->scCurrentReverse}) {
-        const QString actionName = widget->property("shortcutAction").toString();
-        QAction *action = m_actionCollection->action(actionName);
-        const bool isDefault = (action->shortcut() == m_actionCollection->defaultShortcut(action));
-
-        setDefaultIndicatorVisible(widget, visible && !isDefault);
-    }
-}
-
 void KWinTabBoxConfigForm::tabBoxToggled(bool on)
 {
     // Highlight Windows options is availabled if no TabBox effect is selected
@@ -431,42 +313,50 @@ void KWinTabBoxConfigForm::tabBoxToggled(bool on)
 
 void KWinTabBoxConfigForm::onFilterScreen()
 {
-    Q_EMIT filterScreenChanged(filterScreen());
+    m_config->setMultiScreenMode(filterScreen());
+    Q_EMIT configChanged();
 }
 
 void KWinTabBoxConfigForm::onFilterDesktop()
 {
-    Q_EMIT filterDesktopChanged(filterDesktop());
+    m_config->setDesktopMode(filterDesktop());
+    Q_EMIT configChanged();
 }
 
 void KWinTabBoxConfigForm::onFilterActivites()
 {
-    Q_EMIT filterActivitiesChanged(filterActivities());
+    m_config->setActivitiesMode(filterActivities());
+    Q_EMIT configChanged();
 }
 
 void KWinTabBoxConfigForm::onFilterMinimization()
 {
-    Q_EMIT filterMinimizationChanged(filterMinimization());
+    m_config->setMinimizedMode(filterMinimization());
+    Q_EMIT configChanged();
 }
 
 void KWin::KWinTabBoxConfigForm::onApplicationMode()
 {
-    Q_EMIT applicationModeChanged(applicationMode());
+    m_config->setApplicationsMode(applicationMode());
+    Q_EMIT configChanged();
 }
 
 void KWinTabBoxConfigForm::onOrderMinimizedMode()
 {
-    Q_EMIT orderMinimizedModeChanged(orderMinimizedMode());
+    m_config->setOrderMinimizedMode(orderMinimizedMode());
+    Q_EMIT configChanged();
 }
 
 void KWinTabBoxConfigForm::onShowDesktopMode()
 {
-    Q_EMIT showDesktopModeChanged(showDesktopMode());
+    m_config->setShowDesktopMode(showDesktopMode());
+    Q_EMIT configChanged();
 }
 
 void KWinTabBoxConfigForm::onSwitchingMode()
 {
-    Q_EMIT switchingModeChanged(switchingMode());
+    m_config->setSwitchingMode(switchingMode());
+    Q_EMIT configChanged();
 }
 
 void KWinTabBoxConfigForm::onEffectCombo()
@@ -478,7 +368,8 @@ void KWinTabBoxConfigForm::onEffectCombo()
     }
     ui->kcfg_HighlightWindows->setEnabled(isAddonEffect && m_isHighlightWindowsEnabled);
 
-    Q_EMIT layoutNameChanged(layoutName());
+    m_config->setLayoutName(layoutName());
+    Q_EMIT configChanged();
 }
 
 void KWinTabBoxConfigForm::onShortcutChanged(const QKeySequence &seq)
@@ -493,13 +384,88 @@ void KWinTabBoxConfigForm::onShortcutChanged(const QKeySequence &seq)
     QAction *action = m_actionCollection->action(actionName);
     action->setShortcut(seq);
 
-    Q_EMIT shortcutChanged();
+    Q_EMIT configChanged();
 }
 
-void KWinTabBoxConfigForm::setDefaultIndicatorVisible(QWidget *widget, bool visible)
+void KWinTabBoxConfigForm::updateUiFromConfig()
 {
-    widget->setProperty("_kde_highlight_neutral", visible);
-    widget->update();
+    setFilterScreen(static_cast<TabBoxConfig::ClientMultiScreenMode>(m_config->multiScreenMode()));
+    setFilterDesktop(static_cast<TabBoxConfig::ClientDesktopMode>(m_config->desktopMode()));
+    setFilterActivities(static_cast<TabBoxConfig::ClientActivitiesMode>(m_config->activitiesMode()));
+    setFilterMinimization(static_cast<TabBoxConfig::ClientMinimizedMode>(m_config->minimizedMode()));
+    setApplicationMode(static_cast<TabBoxConfig::ClientApplicationsMode>(m_config->applicationsMode()));
+    setOrderMinimizedMode(static_cast<TabBoxConfig::OrderMinimizedMode>(m_config->orderMinimizedMode()));
+    setShowDesktopMode(static_cast<TabBoxConfig::ShowDesktopMode>(m_config->showDesktopMode()));
+    setSwitchingModeChanged(static_cast<TabBoxConfig::ClientSwitchingMode>(m_config->switchingMode()));
+    setLayoutName(m_config->layoutName());
+
+    updateDefaultIndicators();
+}
+
+void KWinTabBoxConfigForm::setEnabledUi()
+{
+    m_isHighlightWindowsEnabled = !m_config->isHighlightWindowsImmutable();
+    ui->kcfg_HighlightWindows->setEnabled(!m_config->isHighlightWindowsImmutable());
+
+    ui->filterScreens->setEnabled(!m_config->isMultiScreenModeImmutable());
+    ui->currentScreen->setEnabled(!m_config->isMultiScreenModeImmutable());
+    ui->otherScreens->setEnabled(!m_config->isMultiScreenModeImmutable());
+
+    ui->filterDesktops->setEnabled(!m_config->isDesktopModeImmutable());
+    ui->currentDesktop->setEnabled(!m_config->isDesktopModeImmutable());
+    ui->otherDesktops->setEnabled(!m_config->isDesktopModeImmutable());
+
+    ui->filterActivities->setEnabled(!m_config->isActivitiesModeImmutable());
+    ui->currentActivity->setEnabled(!m_config->isActivitiesModeImmutable());
+    ui->otherActivities->setEnabled(!m_config->isActivitiesModeImmutable());
+
+    ui->filterMinimization->setEnabled(!m_config->isMinimizedModeImmutable());
+    ui->visibleWindows->setEnabled(!m_config->isMinimizedModeImmutable());
+    ui->hiddenWindows->setEnabled(!m_config->isMinimizedModeImmutable());
+
+    ui->oneAppWindow->setEnabled(!m_config->isApplicationsModeImmutable());
+    ui->orderMinimized->setEnabled(!m_config->isOrderMinimizedModeImmutable());
+    ui->showDesktop->setEnabled(!m_config->isShowDesktopModeImmutable());
+    ui->switchingModeCombo->setEnabled(!m_config->isSwitchingModeImmutable());
+    ui->effectCombo->setEnabled(!m_config->isLayoutNameImmutable());
+}
+
+void KWinTabBoxConfigForm::setDefaultIndicatorVisible(bool show)
+{
+    m_showDefaultIndicator = show;
+    updateDefaultIndicators();
+}
+
+void KWinTabBoxConfigForm::updateDefaultIndicators()
+{
+    applyDefaultIndicator({ui->filterScreens, ui->currentScreen, ui->otherScreens},
+                          m_config->multiScreenMode() == m_config->defaultMultiScreenModeValue());
+    applyDefaultIndicator({ui->filterDesktops, ui->currentDesktop, ui->otherDesktops},
+                          m_config->desktopMode() == m_config->defaultDesktopModeValue());
+    applyDefaultIndicator({ui->filterActivities, ui->currentActivity, ui->otherActivities},
+                          m_config->activitiesMode() == m_config->defaultActivitiesModeValue());
+    applyDefaultIndicator({ui->filterMinimization, ui->visibleWindows, ui->hiddenWindows},
+                          m_config->minimizedMode() == m_config->defaultMinimizedModeValue());
+    applyDefaultIndicator({ui->oneAppWindow}, m_config->applicationsMode() == m_config->defaultApplicationsModeValue());
+    applyDefaultIndicator({ui->orderMinimized}, m_config->orderMinimizedMode() == m_config->defaultOrderMinimizedModeValue());
+    applyDefaultIndicator({ui->showDesktop}, m_config->showDesktopMode() == m_config->defaultShowDesktopModeValue());
+    applyDefaultIndicator({ui->switchingModeCombo}, m_config->switchingMode() == m_config->defaultSwitchingModeValue());
+    applyDefaultIndicator({ui->effectCombo}, m_config->layoutName() == m_config->defaultLayoutNameValue());
+
+    for (const auto &widget : {ui->scAll, ui->scAllReverse, ui->scCurrent, ui->scCurrentReverse}) {
+        const QString actionName = widget->property("shortcutAction").toString();
+        QAction *action = m_actionCollection->action(actionName);
+        const bool isDefault = (action->shortcut() == m_actionCollection->defaultShortcut(action));
+        applyDefaultIndicator({widget}, isDefault);
+    }
+}
+
+void KWinTabBoxConfigForm::applyDefaultIndicator(QList<QWidget *> widgets, bool isDefault)
+{
+    for (auto widget : widgets) {
+        widget->setProperty("_kde_highlight_neutral", m_showDefaultIndicator && !isDefault);
+        widget->update();
+    }
 }
 
 } // namespace
diff --git a/src/kcms/tabbox/kwintabboxconfigform.h b/src/kcms/tabbox/kwintabboxconfigform.h
index 98caafecaf..e9c76df739 100644
--- a/src/kcms/tabbox/kwintabboxconfigform.h
+++ b/src/kcms/tabbox/kwintabboxconfigform.h
@@ -4,6 +4,7 @@
 
     SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org>
     SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com>
+    SPDX-FileCopyrightText: 2023 Ismael Asensio <isma.af@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
@@ -15,7 +16,6 @@
 
 #include "tabboxconfig.h"
 
-class KShortcutsEditor;
 class KActionCollection;
 
 namespace Ui
@@ -26,6 +26,11 @@ class KWinTabBoxConfigForm;
 namespace KWin
 {
 
+namespace TabBox
+{
+class TabBoxSettings;
+}
+
 class KWinTabBoxConfigForm : public QWidget
 {
     Q_OBJECT
@@ -41,30 +46,14 @@ public:
         AddonEffect, // i.e not builtin effects
     };
 
-    explicit KWinTabBoxConfigForm(TabboxType type, QWidget *parent = nullptr);
+    explicit KWinTabBoxConfigForm(TabboxType type, TabBox::TabBoxSettings *config, QWidget *parent = nullptr);
     ~KWinTabBoxConfigForm() override;
 
+    TabBox::TabBoxSettings *config() const;
     bool highlightWindows() const;
-    bool showTabBox() const;
-    int filterScreen() const;
-    int filterDesktop() const;
-    int filterActivities() const;
-    int filterMinimization() const;
-    int applicationMode() const;
-    int orderMinimizedMode() 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 setOrderMinimizedMode(TabBox::TabBoxConfig::OrderMinimizedMode mode);
-    void setShowDesktopMode(TabBox::TabBoxConfig::ShowDesktopMode mode);
-    void setSwitchingModeChanged(TabBox::TabBoxConfig::ClientSwitchingMode mode);
-    void setLayoutName(const QString &layoutName);
+    void updateUiFromConfig();
+    void setDefaultIndicatorVisible(bool visible);
 
     // EffectCombo Data Model
     void setEffectComboModel(QStandardItemModel *model);
@@ -76,40 +65,9 @@ public:
     bool isShortcutsChanged() const;
     bool isShortcutsDefault() const;
 
-    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 setOrderMinimizedModeEnabled(bool enabled);
-    void setShowDesktopModeEnabled(bool enabled);
-    void setSwitchingModeEnabled(bool enabled);
-    void setLayoutNameEnabled(bool enabled);
-
-    void setFilterScreenDefaultIndicatorVisible(bool visible);
-    void setFilterDesktopDefaultIndicatorVisible(bool visible);
-    void setFilterActivitiesDefaultIndicatorVisible(bool visible);
-    void setFilterMinimizationDefaultIndicatorVisible(bool visible);
-    void setApplicationModeDefaultIndicatorVisible(bool visible);
-    void setOrderMinimizedDefaultIndicatorVisible(bool visible);
-    void setShowDesktopModeDefaultIndicatorVisible(bool visible);
-    void setSwitchingModeDefaultIndicatorVisible(bool visible);
-    void setLayoutNameDefaultIndicatorVisible(bool visible);
-    void setShortcutsDefaultIndicatorVisible(bool visible);
-
 Q_SIGNALS:
-    void filterScreenChanged(int value);
-    void filterDesktopChanged(int value);
-    void filterActivitiesChanged(int value);
-    void filterMinimizationChanged(int value);
-    void applicationModeChanged(int value);
-    void orderMinimizedModeChanged(int value);
-    void showDesktopModeChanged(int value);
-    void switchingModeChanged(int value);
-    void layoutNameChanged(const QString &layoutName);
+    void configChanged();
     void effectConfigButtonClicked();
-    void shortcutChanged();
 
 private Q_SLOTS:
     void tabBoxToggled(bool on);
@@ -123,14 +81,41 @@ private Q_SLOTS:
     void onSwitchingMode();
     void onEffectCombo();
     void onShortcutChanged(const QKeySequence &seq);
+    void updateDefaultIndicators();
 
 private:
-    void setDefaultIndicatorVisible(QWidget *widget, bool visible);
+    void setEnabledUi();
+    void applyDefaultIndicator(QList<QWidget *> widgets, bool visible);
 
+    // UI property getters
+    bool showTabBox() const;
+    int filterScreen() const;
+    int filterDesktop() const;
+    int filterActivities() const;
+    int filterMinimization() const;
+    int applicationMode() const;
+    int orderMinimizedMode() const;
+    int showDesktopMode() const;
+    int switchingMode() const;
+    QString layoutName() const;
+
+    // UI property setters
+    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 setOrderMinimizedMode(TabBox::TabBoxConfig::OrderMinimizedMode mode);
+    void setShowDesktopMode(TabBox::TabBoxConfig::ShowDesktopMode mode);
+    void setSwitchingModeChanged(TabBox::TabBoxConfig::ClientSwitchingMode mode);
+    void setLayoutName(const QString &layoutName);
+
+private:
     KActionCollection *m_actionCollection = nullptr;
+    TabBox::TabBoxSettings *m_config = nullptr;
+    bool m_showDefaultIndicator = false;
 
     bool m_isHighlightWindowsEnabled = true;
-    TabboxType m_type;
     Ui::KWinTabBoxConfigForm *ui;
 };
 
diff --git a/src/kcms/tabbox/main.cpp b/src/kcms/tabbox/main.cpp
index 7e38117b48..461efb93ee 100644
--- a/src/kcms/tabbox/main.cpp
+++ b/src/kcms/tabbox/main.cpp
@@ -4,6 +4,7 @@
 
     SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org>
     SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com>
+    SPDX-FileCopyrightText: 2023 Ismael Asensio <isma.af@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
@@ -53,8 +54,8 @@ KWinTabBoxConfig::KWinTabBoxConfig(QWidget *parent, const QVariantList &args)
     , m_data(new KWinTabboxData(this))
 {
     QTabWidget *tabWidget = new QTabWidget(this);
-    m_primaryTabBoxUi = new KWinTabBoxConfigForm(KWinTabBoxConfigForm::TabboxType::Main, tabWidget);
-    m_alternativeTabBoxUi = new KWinTabBoxConfigForm(KWinTabBoxConfigForm::TabboxType::Alternative, tabWidget);
+    m_primaryTabBoxUi = new KWinTabBoxConfigForm(KWinTabBoxConfigForm::TabboxType::Main, m_data->tabBoxConfig(), tabWidget);
+    m_alternativeTabBoxUi = new KWinTabBoxConfigForm(KWinTabBoxConfigForm::TabboxType::Alternative, m_data->tabBoxAlternativeConfig(), tabWidget);
     tabWidget->addTab(m_primaryTabBoxUi, i18n("Main"));
     tabWidget->addTab(m_alternativeTabBoxUi, i18n("Alternative"));
 
@@ -85,7 +86,6 @@ KWinTabBoxConfig::KWinTabBoxConfig(QWidget *parent, const QVariantList &args)
 
     initLayoutLists();
 
-    connect(this, &KWinTabBoxConfig::defaultsIndicatorsVisibleChanged, this, &KWinTabBoxConfig::updateDefaultIndicator);
     createConnections(m_primaryTabBoxUi);
     createConnections(m_alternativeTabBoxUi);
 
@@ -98,9 +98,6 @@ KWinTabBoxConfig::KWinTabBoxConfig(QWidget *parent, const QVariantList &args)
     } else {
         infoLabel->hide();
     }
-
-    setEnabledUi(m_primaryTabBoxUi, m_data->tabBoxConfig());
-    setEnabledUi(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
 }
 
 KWinTabBoxConfig::~KWinTabBoxConfig()
@@ -187,106 +184,27 @@ void KWinTabBoxConfig::initLayoutLists()
     m_alternativeTabBoxUi->setEffectComboModel(model);
 }
 
-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->setOrderMinimizedModeEnabled(!config->isOrderMinimizedModeImmutable());
-    form->setShowDesktopModeEnabled(!config->isShowDesktopModeImmutable());
-    form->setSwitchingModeEnabled(!config->isSwitchingModeImmutable());
-    form->setLayoutNameEnabled(!config->isLayoutNameImmutable());
-}
-
 void KWinTabBoxConfig::createConnections(KWinTabBoxConfigForm *form)
 {
     connect(form, &KWinTabBoxConfigForm::effectConfigButtonClicked, this, &KWinTabBoxConfig::configureEffectClicked);
+    connect(form, &KWinTabBoxConfigForm::configChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
 
-    connect(form, &KWinTabBoxConfigForm::filterScreenChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
-    connect(form, &KWinTabBoxConfigForm::filterDesktopChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
-    connect(form, &KWinTabBoxConfigForm::filterActivitiesChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
-    connect(form, &KWinTabBoxConfigForm::filterMinimizationChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
-    connect(form, &KWinTabBoxConfigForm::applicationModeChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
-    connect(form, &KWinTabBoxConfigForm::orderMinimizedModeChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
-    connect(form, &KWinTabBoxConfigForm::showDesktopModeChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
-    connect(form, &KWinTabBoxConfigForm::switchingModeChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
-    connect(form, &KWinTabBoxConfigForm::layoutNameChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
-    connect(form, &KWinTabBoxConfigForm::shortcutChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
+    connect(this, &KWinTabBoxConfig::defaultsIndicatorsVisibleChanged, form, &KWinTabBoxConfigForm::setDefaultIndicatorVisible);
 }
 
 void KWinTabBoxConfig::updateUnmanagedState()
 {
     bool isNeedSave = false;
-    isNeedSave |= updateUnmanagedIsNeedSave(m_primaryTabBoxUi, m_data->tabBoxConfig());
-    isNeedSave |= updateUnmanagedIsNeedSave(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
+    isNeedSave |= m_data->tabBoxConfig()->isSaveNeeded() || m_primaryTabBoxUi->isShortcutsChanged();
+    isNeedSave |= m_data->tabBoxAlternativeConfig()->isSaveNeeded() || m_alternativeTabBoxUi->isShortcutsChanged();
 
     unmanagedWidgetChangeState(isNeedSave);
 
     bool isDefault = true;
-    isDefault &= updateUnmanagedIsDefault(m_primaryTabBoxUi, m_data->tabBoxConfig());
-    isDefault &= updateUnmanagedIsDefault(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
+    isDefault &= m_data->tabBoxConfig()->isDefaults() && m_primaryTabBoxUi->isShortcutsDefault();
+    isDefault &= m_data->tabBoxAlternativeConfig()->isDefaults() && m_alternativeTabBoxUi->isShortcutsDefault();
 
     unmanagedWidgetDefaultState(isDefault);
-
-    updateDefaultIndicator();
-}
-
-void KWinTabBoxConfig::updateDefaultIndicator()
-{
-    const bool visible = defaultsIndicatorsVisible();
-    updateUiDefaultIndicator(visible, m_primaryTabBoxUi, m_data->tabBoxConfig());
-    updateUiDefaultIndicator(visible, m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
-}
-
-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->orderMinimizedMode() != config->orderMinimizedMode();
-    isNeedSave |= form->showDesktopMode() != config->showDesktopMode();
-    isNeedSave |= form->switchingMode() != config->switchingMode();
-    isNeedSave |= form->layoutName() != config->layoutName();
-    isNeedSave |= form->isShortcutsChanged();
-
-    return isNeedSave;
-}
-
-bool KWinTabBoxConfig::updateUnmanagedIsDefault(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->orderMinimizedMode() == config->defaultOrderMinimizedModeValue();
-    isDefault &= form->showDesktopMode() == config->defaultShowDesktopModeValue();
-    isDefault &= form->switchingMode() == config->defaultSwitchingModeValue();
-    isDefault &= form->layoutName() == config->defaultLayoutNameValue();
-    isDefault &= form->isShortcutsDefault();
-
-    return isDefault;
-}
-
-void KWinTabBoxConfig::updateUiDefaultIndicator(bool visible, KWinTabBoxConfigForm *form, const TabBoxSettings *config)
-{
-    form->setFilterScreenDefaultIndicatorVisible(visible && form->filterScreen() != config->defaultMultiScreenModeValue());
-    form->setFilterDesktopDefaultIndicatorVisible(visible && form->filterDesktop() != config->defaultDesktopModeValue());
-    form->setFilterActivitiesDefaultIndicatorVisible(visible && form->filterActivities() != config->defaultActivitiesModeValue());
-    form->setFilterMinimizationDefaultIndicatorVisible(visible && form->filterMinimization() != config->defaultMinimizedModeValue());
-    form->setApplicationModeDefaultIndicatorVisible(visible && form->applicationMode() != config->defaultApplicationsModeValue());
-    form->setOrderMinimizedDefaultIndicatorVisible(visible && form->orderMinimizedMode() != config->defaultOrderMinimizedModeValue());
-    form->setShowDesktopModeDefaultIndicatorVisible(visible && form->showDesktopMode() != config->defaultShowDesktopModeValue());
-    form->setSwitchingModeDefaultIndicatorVisible(visible && form->switchingMode() != config->defaultSwitchingModeValue());
-    form->setLayoutNameDefaultIndicatorVisible(visible && form->layoutName() != config->defaultLayoutNameValue());
-    form->setShortcutsDefaultIndicatorVisible(visible);
 }
 
 void KWinTabBoxConfig::load()
@@ -296,11 +214,11 @@ void KWinTabBoxConfig::load()
     m_data->tabBoxConfig()->load();
     m_data->tabBoxAlternativeConfig()->load();
 
-    updateUiFromConfig(m_primaryTabBoxUi, m_data->tabBoxConfig());
-    updateUiFromConfig(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
-
     m_data->pluginsConfig()->load();
 
+    m_primaryTabBoxUi->updateUiFromConfig();
+    m_alternativeTabBoxUi->updateUiFromConfig();
+
     m_primaryTabBoxUi->loadShortcuts();
     m_alternativeTabBoxUi->loadShortcuts();
 
@@ -316,9 +234,6 @@ void KWinTabBoxConfig::save()
     m_data->pluginsConfig()->setHighlightwindowEnabled(highlightWindows);
     m_data->pluginsConfig()->save();
 
-    updateConfigFromUi(m_primaryTabBoxUi, m_data->tabBoxConfig());
-    updateConfigFromUi(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
-
     m_primaryTabBoxUi->saveShortcuts();
     m_alternativeTabBoxUi->saveShortcuts();
 
@@ -335,8 +250,11 @@ void KWinTabBoxConfig::save()
 
 void KWinTabBoxConfig::defaults()
 {
-    updateUiFromDefaultConfig(m_primaryTabBoxUi, m_data->tabBoxConfig());
-    updateUiFromDefaultConfig(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
+    m_data->tabBoxConfig()->setDefaults();
+    m_data->tabBoxAlternativeConfig()->setDefaults();
+
+    m_primaryTabBoxUi->updateUiFromConfig();
+    m_alternativeTabBoxUi->updateUiFromConfig();
 
     m_primaryTabBoxUi->resetShortcuts();
     m_alternativeTabBoxUi->resetShortcuts();
@@ -344,46 +262,6 @@ void KWinTabBoxConfig::defaults()
     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->setOrderMinimizedMode(static_cast<TabBoxConfig::OrderMinimizedMode>(config->orderMinimizedMode()));
-    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->setOrderMinimizedMode(form->orderMinimizedMode());
-    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->setOrderMinimizedMode(static_cast<TabBoxConfig::OrderMinimizedMode>(config->defaultOrderMinimizedModeValue()));
-    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());
@@ -392,7 +270,7 @@ void KWinTabBoxConfig::configureEffectClicked()
     if (form->effectComboCurrentData(KWinTabBoxConfigForm::AddonEffect).toBool()) {
         // Show the preview for addon effect
         new LayoutPreview(form->effectComboCurrentData(KWinTabBoxConfigForm::LayoutPath).toString(),
-                          form->showDesktopMode(),
+                          form->config()->desktopMode(),
                           this);
     }
 }
diff --git a/src/kcms/tabbox/main.h b/src/kcms/tabbox/main.h
index f5b60af534..904c1e09dc 100644
--- a/src/kcms/tabbox/main.h
+++ b/src/kcms/tabbox/main.h
@@ -4,6 +4,7 @@
 
     SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org>
     SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com>
+    SPDX-FileCopyrightText: 2023 Ismael Asensio <isma.af@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
@@ -38,19 +39,11 @@ public Q_SLOTS:
 
 private Q_SLOTS:
     void updateUnmanagedState();
-    void updateDefaultIndicator();
     void configureEffectClicked();
 
 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 setEnabledUi(KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
     void createConnections(KWinTabBoxConfigForm *form);
-    bool updateUnmanagedIsNeedSave(const KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
-    bool updateUnmanagedIsDefault(KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
-    void updateUiDefaultIndicator(bool visible, KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
 
 private:
     KWinTabBoxConfigForm *m_primaryTabBoxUi = nullptr;