fix: restore system layout when user override is deleted from KCM

Layout now tracks its system origin path (systemSourcePath) so that
deleting a user override of a system layout instantly restores the
original without a daemon restart or filesystem scanning.

- Add m_systemSourcePath to Layout, persisted in user JSON
- Capture system path in saveLayout before sourcePath switches to user dir
- Capture system path in loadLayoutsFromDirectory during override detection
- restoreSystemLayout reloads directly from stored path
- Clear m_systemSourcePath in operator= (copies have no system origin)
- Fix pre-existing m_previousLayout dangling pointer on layout removal
- Make KCM deleteLayout synchronous to avoid race with loadLayouts

Co-Authored-By: claude-flow <ruv@ruv.net>

Author: fuddlesworth

kcm/kcm_plasmazones.cpp

@@ -1780,12 +1780,8 @@ void KCMPlasmaZones::createNewLayout()
 
 void KCMPlasmaZones::deleteLayout(const QString& layoutId)
 {
-    QDBusMessage msg =
-        QDBusMessage::createMethodCall(QString(DBus::ServiceName), QString(DBus::ObjectPath),
-                                       QString(DBus::Interface::LayoutManager), QStringLiteral("deleteLayout"));
-    msg << layoutId;
-    watchAsyncDbusCall(QDBusConnection::sessionBus().asyncCall(msg), QStringLiteral("deleteLayout"));
-    QTimer::singleShot(100, this, &KCMPlasmaZones::loadLayouts);
+    callDaemon(QString(DBus::Interface::LayoutManager), QStringLiteral("deleteLayout"), {layoutId});
+    loadLayouts();
 }
 
 void KCMPlasmaZones::duplicateLayout(const QString& layoutId)

src/core/constants.h

@@ -132,6 +132,7 @@ inline constexpr QLatin1String OuterGap{"outerGap"};
 inline constexpr QLatin1String ShowZoneNumbers{"showZoneNumbers"};
 inline constexpr QLatin1String IsBuiltIn{"isBuiltIn"}; // Legacy, for backward compat when loading
 inline constexpr QLatin1String IsSystem{"isSystem"}; // New: determined by source path
+inline constexpr QLatin1String SystemSourcePath{"systemSourcePath"}; // Original system layout path (for user overrides)
 inline constexpr QLatin1String ZoneCount{"zoneCount"};
 inline constexpr QLatin1String Category{"category"}; // LayoutCategory: 0=Manual
 

src/core/layout.cpp

@@ -129,6 +129,7 @@ Layout& Layout::operator=(const Layout& other)
         m_showZoneNumbers = other.m_showZoneNumbers;
         m_defaultOrder = other.m_defaultOrder;
         m_sourcePath.clear(); // Assignment creates a user copy (will be saved to user directory)
+        m_systemSourcePath.clear(); // New copy has no system origin
         m_shaderId = other.m_shaderId;
         m_shaderParams = other.m_shaderParams;
         bool rulesChanged = m_appRules != other.m_appRules;
@@ -559,6 +560,11 @@ QJsonObject Layout::toJson() const
     }
     // Note: isBuiltIn is no longer serialized - it's determined by source path at load time
 
+    // Persist system origin path so user overrides can be restored on deletion
+    if (!m_systemSourcePath.isEmpty()) {
+        json[JsonKeys::SystemSourcePath] = m_systemSourcePath;
+    }
+
     // Shader support - only persist params belonging to the active shader
     if (!ShaderRegistry::isNoneShader(m_shaderId)) {
         json[JsonKeys::ShaderId] = m_shaderId;
@@ -635,6 +641,8 @@ Layout* Layout::fromJson(const QJsonObject& json, QObject* parent)
     layout->m_showZoneNumbers = json[JsonKeys::ShowZoneNumbers].toBool(true);
     layout->m_defaultOrder = json[JsonKeys::DefaultOrder].toInt(999);
     // Note: sourcePath is set by LayoutManager after loading, not from JSON
+    // But systemSourcePath IS persisted in user JSON for system override restoration
+    layout->m_systemSourcePath = json[JsonKeys::SystemSourcePath].toString();
 
     // Shader support
     layout->m_shaderId = json[JsonKeys::ShaderId].toString();

src/core/layout.h

@@ -228,6 +228,12 @@ class PLASMAZONES_EXPORT Layout : public QObject
     // This determines whether the layout can be edited/deleted in place
     bool isSystemLayout() const;
 
+    // Original system layout path — set when a user override replaces a system layout.
+    // Persisted in user JSON so deletion can restore the system original without scanning.
+    QString systemSourcePath() const { return m_systemSourcePath; }
+    void setSystemSourcePath(const QString& path) { m_systemSourcePath = path; }
+    bool hasSystemOrigin() const { return !m_systemSourcePath.isEmpty(); }
+
     // Shader support
     QString shaderId() const
     {
@@ -369,6 +375,7 @@ class PLASMAZONES_EXPORT Layout : public QObject
     int m_outerGapRight = -1;
     bool m_showZoneNumbers = true;
     QString m_sourcePath; // Path where layout was loaded from (empty for new layouts)
+    QString m_systemSourcePath; // Original system path if this is a user override of a system layout
     int m_defaultOrder = 999; // Optional: lower values appear first when choosing default (999 = not set)
     QVector<Zone*> m_zones;
 

src/core/layoutmanager.cpp

@@ -201,47 +201,60 @@ void LayoutManager::removeLayout(Layout* layout)
         return;
     }
 
-    // Store ID and state BEFORE any operations that might invalidate the pointer
+    // Store state BEFORE any operations that might invalidate the pointer
     const QUuid layoutId = layout->id();
     const bool wasActive = (m_activeLayout == layout);
     const QString filePath = layoutFilePath(layoutId);
+    const QString systemPath = layout->systemSourcePath();
 
     // Remove from layouts list
     m_layouts.removeOne(layout);
 
-    // Remove any assignments using stored ID (safe - ID is copied)
-    for (auto it = m_assignments.begin(); it != m_assignments.end();) {
-        if (it.value() == layoutId) {
-            it = m_assignments.erase(it);
-        } else {
-            ++it;
-        }
-    }
+    // Delete user layout file
+    QFile::remove(filePath);
 
-    // Remove from quick shortcuts using stored ID
-    for (auto it = m_quickLayoutShortcuts.begin(); it != m_quickLayoutShortcuts.end();) {
-        if (it.value() == layoutId) {
-            it = m_quickLayoutShortcuts.erase(it);
-        } else {
-            ++it;
-        }
+    // Clear stale pointer before deletion
+    if (m_previousLayout == layout) {
+        m_previousLayout = nullptr;
     }
 
-    // Update active layout if needed
-    if (wasActive) {
-        setActiveLayout(defaultLayout());
-    }
+    Q_EMIT layoutRemoved(layout);
+    layout->deleteLater();
 
-    // Delete layout file (using stored path)
-    QFile::remove(filePath);
+    // If this was a user override of a system layout, restore the system original.
+    // Uses the stored system path — no filesystem scanning needed.
+    Layout* restored = restoreSystemLayout(layoutId, systemPath);
 
-    // Emit signals before deleting
-    Q_EMIT layoutRemoved(layout);
-    Q_EMIT layoutsChanged();
+    if (restored) {
+        // System layout restored — assignments and shortcuts stay valid (same UUID).
+        // If deleted layout was active, activate the restored system layout.
+        if (wasActive) {
+            setActiveLayout(restored);
+        }
+    } else {
+        // Truly deleted — clean up assignments and shortcuts referencing this layout
+        for (auto it = m_assignments.begin(); it != m_assignments.end();) {
+            if (it.value() == layoutId) {
+                it = m_assignments.erase(it);
+            } else {
+                ++it;
+            }
+        }
 
-    // Schedule deletion (safe - we've already removed from all containers)
-    layout->deleteLater();
+        for (auto it = m_quickLayoutShortcuts.begin(); it != m_quickLayoutShortcuts.end();) {
+            if (it.value() == layoutId) {
+                it = m_quickLayoutShortcuts.erase(it);
+            } else {
+                ++it;
+            }
+        }
+
+        if (wasActive) {
+            setActiveLayout(defaultLayout());
+        }
+    }
 
+    Q_EMIT layoutsChanged();
     saveAssignments();
 }
 
@@ -745,6 +758,10 @@ void LayoutManager::loadLayoutsFromDirectory(const QString& directory)
                 // if we find a duplicate, the new one is from user directory and should replace
                 if (!layout->isSystemLayout() && existing->isSystemLayout()) {
                     // User layout overrides system layout - replace the existing one
+                    // Preserve the system origin path so we can restore on deletion
+                    if (layout->systemSourcePath().isEmpty()) {
+                        layout->setSystemSourcePath(existing->sourcePath());
+                    }
                     int index = m_layouts.indexOf(existing);
                     disconnect(existing, &Layout::layoutModified, this, nullptr);
                     m_layouts.replace(index, layout);
@@ -772,6 +789,13 @@ void LayoutManager::saveLayout(Layout* layout)
 
     ensureLayoutDirectory();
 
+    // If this is a system layout being saved to user dir for the first time,
+    // capture the system origin path before toJson/sourcePath changes
+    if (layout->isSystemLayout() && !layout->hasSystemOrigin()) {
+        layout->setSystemSourcePath(layout->sourcePath());
+        qCInfo(lcLayout) << "Captured system origin for" << layout->name() << "from=" << layout->sourcePath();
+    }
+
     const QString filePath = layoutFilePath(layout->id());
     QFile file(filePath);
 
@@ -781,6 +805,7 @@ void LayoutManager::saveLayout(Layout* layout)
         return;
     }
 
+    // toJson() includes systemSourcePath so it persists across daemon restarts
     QJsonDocument doc(layout->toJson());
     const QByteArray data = doc.toJson(QJsonDocument::Indented);
 
@@ -1037,6 +1062,39 @@ void LayoutManager::exportLayout(Layout* layout, const QString& filePath)
     qCInfo(lcLayout) << "Successfully exported layout:" << layout->name() << "to" << filePath;
 }
 
+Layout* LayoutManager::restoreSystemLayout(const QUuid& id, const QString& systemPath)
+{
+    if (systemPath.isEmpty() || layoutById(id)) {
+        return nullptr;
+    }
+
+    QFile file(systemPath);
+    if (!file.exists() || !file.open(QIODevice::ReadOnly)) {
+        qCWarning(lcLayout) << "System layout file missing:" << systemPath;
+        return nullptr;
+    }
+
+    QJsonParseError parseError;
+    const auto doc = QJsonDocument::fromJson(file.readAll(), &parseError);
+    if (parseError.error != QJsonParseError::NoError) {
+        qCWarning(lcLayout) << "System layout parse error:" << systemPath << parseError.errorString();
+        return nullptr;
+    }
+
+    auto* layout = Layout::fromJson(doc.object(), this);
+    if (!layout || layout->id() != id) {
+        delete layout;
+        return nullptr;
+    }
+
+    layout->setSourcePath(systemPath);
+    m_layouts.append(layout);
+    connect(layout, &Layout::layoutModified, this, [this, layout]() { saveLayout(layout); });
+    Q_EMIT layoutAdded(layout);
+    qCInfo(lcLayout) << "Restored system layout name=" << layout->name() << "from=" << systemPath;
+    return layout;
+}
+
 void LayoutManager::ensureLayoutDirectory()
 {
     QDir dir(m_layoutDirectory);

src/core/layoutmanager.h

@@ -195,6 +195,7 @@ class PLASMAZONES_EXPORT LayoutManager : public QObject, public ILayoutManager
 private:
     void ensureLayoutDirectory();
     void loadLayoutsFromDirectory(const QString& directory);
+    Layout* restoreSystemLayout(const QUuid& id, const QString& systemPath);
     QString layoutFilePath(const QUuid& id) const;
     Layout* cycleLayoutImpl(const QString& screenId, int direction);
     bool shouldSkipLayoutAssignment(const QUuid& layoutId, const QString& context) const;