diff --git a/kcmkwin/kwinrules/kcmrules.cpp b/kcmkwin/kwinrules/kcmrules.cpp
index e7f11dd7d..56c2a2bc7 100644
--- a/kcmkwin/kwinrules/kcmrules.cpp
+++ b/kcmkwin/kwinrules/kcmrules.cpp
@@ -1,298 +1,299 @@
 /*
  * Copyright (c) 2004 Lubos Lunak <l.lunak@kde.org>
  * Copyright (c) 2020 Ismael Asensio <isma.af@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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "kcmrules.h"
 
 #include <QDBusConnection>
 #include <QDBusMessage>
 
 #include <KAboutData>
 #include <KConfig>
 #include <KLocalizedString>
 #include <KPluginFactory>
 
 
 namespace KWin
 {
 
 KCMKWinRules::KCMKWinRules(QObject *parent, const QVariantList &arguments)
     : KQuickAddons::ConfigModule(parent, arguments)
     , m_ruleBook(new RuleBookSettings(this))
     , m_rulesModel(new RulesModel(this))
 {
     auto about = new KAboutData(QStringLiteral("kcm_kwinrules"),
                                 i18n("Window Rules"),
                                 QStringLiteral("1.0"),
                                 QString(),
                                 KAboutLicense::GPL);
     about->addAuthor(i18n("Ismael Asensio"),
                      i18n("Author"),
                      QStringLiteral("isma.af@gmail.com"));
     setAboutData(about);
 
     setQuickHelp(i18n("<p><h1>Window-specific Settings</h1> Here you can customize window settings specifically only"
                       " for some windows.</p>"
                       " <p>Please note that this configuration will not take effect if you do not use"
                       " KWin as your window manager. If you do use a different window manager, please refer to its documentation"
                       " for how to customize window behavior.</p>"));
 
     connect(m_rulesModel, &RulesModel::descriptionChanged, this, [this]{
         if (m_editingIndex >=0 && m_editingIndex < m_ruleBook->count()) {
             m_rules.at(m_editingIndex)->description = m_rulesModel->description();
             emit ruleBookModelChanged();
         }
     } );
     connect(m_rulesModel, &RulesModel::dataChanged, this, &KCMKWinRules::updateNeedsSave);
 }
 
 KCMKWinRules::~KCMKWinRules() {
     qDeleteAll(m_rules);
 }
 
 
 QStringList KCMKWinRules::ruleBookModel() const
 {
     QStringList ruleDescriptionList;
     for (const Rules *rule : qAsConst(m_rules)) {
         ruleDescriptionList.append(rule->description);
     }
     return ruleDescriptionList;
 }
 
 
 void KCMKWinRules::load()
 {
     m_ruleBook->load();
     m_rules = m_ruleBook->rules();
 
     setNeedsSave(false);
     emit ruleBookModelChanged();
 
     // Check if current index is no longer valid
     if (m_editingIndex >= m_rules.count()) {
         m_editingIndex = -1;
         emit editingIndexChanged();
     }
     // Reset current index for rule editor
     if (m_editingIndex > 0) {
         m_rulesModel->importFromRules(m_rules.at(m_editingIndex));
     }
 }
 
 void KCMKWinRules::save()
 {
     saveCurrentRule();
     m_ruleBook->setRules(m_rules);
     m_ruleBook->save();
 
     // Notify kwin to reload configuration
     QDBusMessage message = QDBusMessage::createSignal("/KWin", "org.kde.KWin", "reloadConfig");
     QDBusConnection::sessionBus().send(message);
 }
 
 void KCMKWinRules::updateNeedsSave()
 {
     setNeedsSave(true);
     emit needsSaveChanged();
 }
 
 void KCMKWinRules::saveCurrentRule()
 {
     if (m_editingIndex < 0) {
         return;
     }
     if (needsSave()) {
         delete(m_rules[m_editingIndex]);
         m_rules[m_editingIndex] = m_rulesModel->exportToRules();
     }
 }
 
 
 int KCMKWinRules::editingIndex() const
 {
     return m_editingIndex;
 }
 
 void KCMKWinRules::editRule(int index)
 {
     if (index < 0 || index >= m_rules.count()) {
         return;
     }
     saveCurrentRule();
 
     m_editingIndex = index;
     m_rulesModel->importFromRules(m_rules.at(m_editingIndex));
 
     emit editingIndexChanged();
     // Set the active page to rules editor (0:RulesList, 1:RulesEditor)
     setCurrentIndex(1);
 }
 
 void KCMKWinRules::setRuleDescription(int index, const QString &description)
 {
     if (index < 0 || index >= m_rules.count()
             || (description == m_rules.at(index)->description)) {
         return;
     }
 
     if (index == m_editingIndex) {
         m_rulesModel->setDescription(description);
         return;
     }
 
     m_rules.at(index)->description = description;
 
     emit ruleBookModelChanged();
     updateNeedsSave();
 }
 
 
 void KCMKWinRules::createRule()
 {
     const int newIndex = m_rules.count();
 
     m_rules.append(new Rules());
     m_ruleBook->setCount(m_rules.count());
 
     emit ruleBookModelChanged();
     updateNeedsSave();
 
     editRule(newIndex);
 }
 
 void KCMKWinRules::removeRule(int index)
 {
     if (index < 0 || index >= m_rules.count()) {
         return;
     }
 
     if (m_editingIndex == index) {
         m_editingIndex = -1;
         emit editingIndexChanged();
     } else if (m_editingIndex > index) {
         m_editingIndex -= 1;
         emit editingIndexChanged();
     }
 
     delete(m_rules.at(index));
     m_rules.removeAt(index);
     m_ruleBook->setCount(m_rules.count());
 
     emit ruleBookModelChanged();
     updateNeedsSave();
 }
 
 void KCMKWinRules::moveRule(int sourceIndex, int destIndex)
 {
     const int lastIndex = m_rules.count() - 1;
     if (sourceIndex == destIndex
             || (sourceIndex < 0 || sourceIndex > lastIndex)
             || (destIndex < 0 || destIndex > lastIndex)) {
         return;
     }
 
     m_rules.move(sourceIndex, destIndex);
 
     if (m_editingIndex == sourceIndex) {
         m_editingIndex = destIndex;
         emit editingIndexChanged();
     } else if (m_editingIndex > sourceIndex && m_editingIndex <= destIndex) {
         m_editingIndex -= 1;
         emit editingIndexChanged();
     } else if (m_editingIndex < sourceIndex && m_editingIndex >= destIndex) {
         m_editingIndex += 1;
         emit editingIndexChanged();
     }
 
     emit ruleBookModelChanged();
 
     updateNeedsSave();
 }
 
 void KCMKWinRules::exportToFile(const QUrl &path, int index)
 {
     Q_ASSERT(index >= 0 && index < m_rules.count());
 
     saveCurrentRule();
 
     const auto config = KSharedConfig::openConfig(path.toLocalFile(), KConfig::SimpleConfig);
     RuleSettings settings(config, m_rules.at(index)->description);
 
     settings.setDefaults();
     m_rules.at(index)->write(&settings);
     settings.save();
 }
 
 void KCMKWinRules::importFromFile(const QUrl &path)
 {
     const auto config = KSharedConfig::openConfig(path.toLocalFile(), KConfig::SimpleConfig);
     const QStringList groups = config->groupList();
     if (groups.isEmpty()) {
         return;
     }
 
     for (const QString &groupName : groups) {
         RuleSettings settings(config, groupName);
 
         const bool remove = settings.deleteRule();
         const QString importDescription = settings.description();
         if (importDescription.isEmpty()) {
             continue;
         }
 
         // Try to find a rule with the same description to replace
         int newIndex = -2;
         for (int index = 0; index < m_rules.count(); index++) {
             if (m_rules.at(index)->description == importDescription) {
                 newIndex = index;
                 break;
             }
         }
 
         if (remove) {
             removeRule(newIndex);
             continue;
         }
 
         Rules *newRule = new Rules(&settings);
 
         if (newIndex < 0) {
             m_rules.append(newRule);
         } else {
             delete m_rules[newIndex];
             m_rules[newIndex] = newRule;
         }
 
         // Reset rule editor if the current rule changed when importing
         if (m_editingIndex == newIndex) {
             m_rulesModel->importFromRules(m_rules.at(m_editingIndex));
         }
     }
 
     m_ruleBook->setCount(m_rules.count());
     emit ruleBookModelChanged();
+    updateNeedsSave();
 }
 
 K_PLUGIN_CLASS_WITH_JSON(KCMKWinRules, "kcm_kwinrules.json");
 
 } // namespace
 
 #include "kcmrules.moc"