LayoutRegistry.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorZones/AssignmentEntry.h>
#include <PhosphorZones/IZoneLayoutRegistry.h>
#include <PhosphorZones/Layout.h>
#include <PhosphorZones/LayoutSettingsStore.h>
 
#include <PhosphorWindowRules/RuleEvaluator.h>
#include <PhosphorWindowRules/WindowRuleStore.h>
 
#include <QHash>
#include <QPair>
#include <QString>
#include <QUuid>
#include <functional>
#include <memory>
#include <optional>
 
namespace PhosphorZones {
 
struct CombinedAssignmentKey
{
    QString screenId;
    int virtualDesktop = 0;
    QString activity;
 
    bool operator==(const CombinedAssignmentKey& other) const
    {
        return screenId == other.screenId && virtualDesktop == other.virtualDesktop && activity == other.activity;
    }
};
 
inline size_t qHash(const CombinedAssignmentKey& key, size_t seed = 0) noexcept
{
    return qHashMulti(seed, key.screenId, key.virtualDesktop, key.activity);
}
 
class PHOSPHORZONES_EXPORT LayoutRegistry : public IZoneLayoutRegistry
{
    Q_OBJECT
 
    Q_PROPERTY(int layoutCount READ layoutCount NOTIFY layoutsChanged)
    // `activeLayout` Q_PROPERTY moved to IZoneLayoutRegistry alongside its
    // NOTIFY signal so the contract is visible to interface consumers.
    Q_PROPERTY(QString layoutDirectory READ layoutDirectory WRITE setLayoutDirectory NOTIFY layoutDirectoryChanged)
 
public:
    LayoutRegistry(PhosphorWindowRules::WindowRuleStore* ruleStore, QString layoutSubdirectory,
                   QObject* parent = nullptr);
    ~LayoutRegistry() override;
 
    // ─── IZoneLayoutRegistry ──────────────────────────────────────────────
 
    int layoutCount() const override
    {
        return m_layouts.size();
    }
    QVector<Layout*> layouts() const override
    {
        return m_layouts;
    }
    Layout* layout(int index) const override;
    Layout* layoutById(const QUuid& id) const override;
    Layout* layoutByName(const QString& name) const override;
 
    Q_INVOKABLE void addLayout(Layout* layout) override;
    Q_INVOKABLE void removeLayout(Layout* layout) override;
    Q_INVOKABLE void removeLayoutById(const QUuid& id) override;
    Q_INVOKABLE Layout* duplicateLayout(Layout* source) override;
 
    Layout* activeLayout() const override
    {
        return m_activeLayout;
    }
    Q_INVOKABLE void setActiveLayout(Layout* layout) override;
    Q_INVOKABLE void setActiveLayoutById(const QUuid& id) override;
 
    // ─── Layout persistence (disk JSON) ───────────────────────────────────
 
    QString layoutDirectory() const
    {
        return m_layoutDirectory;
    }
    void setLayoutDirectory(const QString& directory);
 
    Q_INVOKABLE void loadLayouts();
    Q_INVOKABLE void saveLayouts();
    void saveLayout(Layout* layout);
 
    Q_INVOKABLE void importLayout(const QString& filePath);
    Q_INVOKABLE void exportLayout(Layout* layout, const QString& filePath);
 
    // ─── Assignment persistence (via config backend) ──────────────────────
 
    Q_INVOKABLE void loadAssignments();
    Q_INVOKABLE void saveAssignments();
 
    // ─── Default-layout resolution ────────────────────────────────────────
 
    Q_INVOKABLE Layout* defaultLayout() const override;
 
    void setDefaultLayoutIdProvider(std::function<QString()> provider);
 
    void setDefaultAutotileAlgorithmProvider(std::function<QString()> provider);
 
    void setSnappingPreferredProvider(std::function<bool()> provider);
 
    void setDefaultAssignmentSuppressedProvider(std::function<bool()> provider);
 
    bool snappingPreferred() const;
 
    // ─── Assignments (per-context routing) ────────────────────────────────
 
    Layout* previousLayout() const
    {
        return m_previousLayout;
    }
 
    Q_INVOKABLE void assignLayout(const QString& screenId, int virtualDesktop, const QString& activity, Layout* layout);
    Q_INVOKABLE void assignLayoutById(const QString& screenId, int virtualDesktop, const QString& activity,
                                      const QString& layoutId);
 
    void setAssignmentEntryDirect(const QString& screenId, int virtualDesktop, const QString& activity,
                                  const AssignmentEntry& entry);
 
    Q_INVOKABLE Layout* layoutForScreen(const QString& screenId, int virtualDesktop = 0,
                                        const QString& activity = QString()) const override;
 
    Q_INVOKABLE Layout* resolveLayoutForScreen(const QString& screenId) const override
    {
        // Resolve against THIS screen's current virtual desktop (Plasma 6.7
        // per-output virtual desktops, #648). Falls back to the global desktop
        // when the screen has no per-output value, so every caller (all of which
        // already pass a screenId) gets per-screen resolution with no edits.
        return layoutForScreen(screenId, currentVirtualDesktopForScreen(screenId), m_currentActivity);
    }
 
    ContextGapOverride resolveContextGaps(const QString& screenId, int virtualDesktop,
                                          const QString& activity) const override;
 
    bool resolveContextLocked(const QString& screenId, int virtualDesktop, const QString& activity) const override;
 
    std::optional<bool> resolveContextDefaultAssignment(const QString& screenId, int virtualDesktop,
                                                        const QString& activity) const;
 
    ContextOverlayOverride resolveContextOverlay(const QString& screenId, int virtualDesktop,
                                                 const QString& activity) const override;
 
    Q_INVOKABLE void clearAssignment(const QString& screenId, int virtualDesktop = 0,
                                     const QString& activity = QString());
    Q_INVOKABLE bool hasExplicitAssignment(const QString& screenId, int virtualDesktop = 0,
                                           const QString& activity = QString()) const;
 
    Q_INVOKABLE QString assignmentIdForScreen(const QString& screenId, int virtualDesktop = 0,
                                              const QString& activity = QString()) const override;
 
    AssignmentEntry assignmentEntryForScreen(const QString& screenId, int virtualDesktop = 0,
                                             const QString& activity = QString()) const;
 
    AssignmentEntry::Mode modeForScreen(const QString& screenId, int virtualDesktop = 0,
                                        const QString& activity = QString()) const;
 
    bool isContextActiveLayoutSuppressed(const QString& screenId, int virtualDesktop = 0,
                                         const QString& activity = QString()) const override;
 
    bool isDefaultAssignmentSuppressedForContext(const QString& screenId, int virtualDesktop = 0,
                                                 const QString& activity = QString()) const;
 
    QString snappingLayoutForScreen(const QString& screenId, int virtualDesktop = 0,
                                    const QString& activity = QString()) const;
    QString tilingAlgorithmForScreen(const QString& screenId, int virtualDesktop = 0,
                                     const QString& activity = QString()) const override;
 
    void clearAutotileAssignments();
 
    void setAllScreenAssignments(const QHash<QString, QString>& assignments);
    void setAllDesktopAssignments(const QHash<QPair<QString, int>, QString>& assignments);
    void setAllActivityAssignments(const QHash<QPair<QString, QString>, QString>& assignments);
    void setAllCombinedAssignments(const QHash<CombinedAssignmentKey, QString>& assignments);
 
    QHash<QPair<QString, int>, QString> desktopAssignments() const;
    QHash<QPair<QString, QString>, QString> activityAssignments() const;
    QHash<CombinedAssignmentKey, QString> combinedAssignments() const;
 
    // ─── Quick-layout slots (1..9) ────────────────────────────────────────
    //
    // Quick slots are keyed by tiling mode: Snapping slots hold manual-layout
    // UUIDs, Autotile slots hold autotile algorithm IDs. The two sets are
    // independent so the same Meta+Alt+N can map to a zone layout in snapping
    // mode and an autotile algorithm in autotile mode.
 
    static constexpr QLatin1String QuickSlotsSnappingKey{"snapping"};
    static constexpr QLatin1String QuickSlotsAutotileKey{"autotile"};
 
    Q_INVOKABLE Layout* layoutForShortcut(AssignmentEntry::Mode mode, int number) const;
    Q_INVOKABLE void applyQuickLayout(AssignmentEntry::Mode mode, int number, const QString& screenId);
    void setQuickLayoutSlot(AssignmentEntry::Mode mode, int number, const QString& layoutId);
    void setAllQuickLayoutSlots(AssignmentEntry::Mode mode, const QHash<int, QString>& slots);
    QHash<int, QString> quickLayoutSlots(AssignmentEntry::Mode mode) const
    {
        return m_quickLayoutSlots[modeIndex(mode)];
    }
 
    // ─── Layout cycling ───────────────────────────────────────────────────
 
    Q_INVOKABLE void cycleToPreviousLayout(const QString& screenId);
    Q_INVOKABLE void cycleToNextLayout(const QString& screenId);
 
    // ─── Built-in layouts ─────────────────────────────────────────────────
 
    Q_INVOKABLE void createBuiltInLayouts();
    QVector<Layout*> builtInLayouts() const;
 
    // ─── Context (desktop / activity) ─────────────────────────────────────
 
    Q_INVOKABLE int currentVirtualDesktop() const override
    {
        return m_currentVirtualDesktop;
    }
    Q_INVOKABLE QString currentActivity() const override
    {
        return m_currentActivity;
    }
    void setCurrentVirtualDesktop(int desktop)
    {
        m_currentVirtualDesktop = desktop;
    }
    int currentVirtualDesktopForScreen(const QString& screenId) const override
    {
        const auto it = m_screenVirtualDesktop.constFind(screenId);
        return it != m_screenVirtualDesktop.constEnd() ? it.value() : m_currentVirtualDesktop;
    }
    void setCurrentVirtualDesktopForScreen(const QString& screenId, int desktop)
    {
        if (!screenId.isEmpty() && desktop >= 1) {
            m_screenVirtualDesktop.insert(screenId, desktop);
        }
    }
    void clearCurrentVirtualDesktopForScreen(const QString& screenId)
    {
        m_screenVirtualDesktop.remove(screenId);
    }
    void setCurrentActivity(const QString& activity)
    {
        m_currentActivity = activity;
    }
 
    // ─── Autotile layout overrides (per-algorithm user overrides) ─────────
 
    void saveAutotileOverrides(const QString& algorithmId, const QJsonObject& overrides);
    QJsonObject loadAutotileOverrides(const QString& algorithmId) const override;
 
    void seedDefaultLayoutSettingsIfFresh(const QJsonObject& defaults);
 
    [[nodiscard]] int contextResolveCacheSize() const
    {
        return static_cast<int>(m_contextResolveCache.size());
    }
 
Q_SIGNALS:
    // layoutAdded / layoutRemoved / activeLayoutChanged / layoutAssigned are
    // inherited from IZoneLayoutRegistry - declared on the interface so
    // consumers that target the contract can connect without depending on
    // the concrete class. Emit sites still live in this TU and reach the
    // inherited signal via Q_OBJECT's metaobject chain.
    void layoutsChanged();
    void layoutDirectoryChanged();
    void layoutsLoaded();
    void layoutsSaved();
 
private:
    void initCommon();
 
    void ensureLayoutDirectory();
    void loadLayoutsFromDirectory(const QString& directory);
    Layout* restoreSystemLayout(const QUuid& id, const QString& systemPath);
    QString layoutFilePath(const QUuid& id) const;
    QString quickLayoutsFilePath() const;
    QString layoutSettingsFilePath() const;
    void readQuickLayouts();
    void writeQuickLayouts();
    static constexpr int modeIndex(AssignmentEntry::Mode mode)
    {
        return mode == AssignmentEntry::Autotile ? 1 : 0;
    }
    Layout* cycleLayoutImpl(const QString& screenId, int direction);
    bool shouldSkipLayoutAssignment(const QString& layoutId, const QString& context) const;
    void emitLayoutAssigned(const QString& screenId, int virtualDesktop, const QString& layoutId);
    void applyLayoutToScreen(const QString& screenId, Layout* layout);
    void migrateLegacyAutotileOverrides();
    Layout* resolveConfiguredDefault() const;
 
    // ─── Rule-backed assignment resolution ────────────────────────────────
    // The unified WindowRuleStore is the single source of truth for every
    // per-context assignment. These helpers translate the legacy
    // AssignmentEntry API onto the rule store + evaluator.
 
    std::optional<AssignmentEntry> resolveAssignmentEntry(const QString& screenId, int virtualDesktop,
                                                          const QString& activity) const;
 
    bool hasExactContextRule(const QString& screenId, int virtualDesktop, const QString& activity) const;
 
    const PhosphorWindowRules::WindowRule* findExactContextRule(const QString& screenId, int virtualDesktop,
                                                                const QString& activity) const;
 
    QUuid exactContextRuleId(const QString& screenId, int virtualDesktop, const QString& activity) const;
 
    void upsertAssignmentRule(const QString& screenId, int virtualDesktop, const QString& activity,
                              const AssignmentEntry& entry);
 
    bool removeAssignmentRule(const QString& screenId, int virtualDesktop, const QString& activity);
 
    template<typename KeyT, typename DecodeFn, typename ValidFn, typename FamilyFn>
    void applyBatchAssignments(const QHash<KeyT, QString>& assignments, DecodeFn decode, ValidFn valid,
                               FamilyFn familyMatches, int emitDesktop, const QString& emitActivity, const char* label);
 
    bool purgeSnappingLayoutFromAssignments(const QString& layoutId);
 
    AssignmentEntry resolveDefaultAssignmentEntryRaw() const;
 
    AssignmentEntry resolveDefaultAssignmentEntry() const;
 
    AssignmentEntry resolveDefaultAssignmentEntryForContext(const QString& screenId, int virtualDesktop,
                                                            const QString& activity) const;
 
    bool hasMatchingAssignmentRule(const QString& screenId, int virtualDesktop, const QString& activity) const;
 
    struct ContextResolveKey
    {
        QString screenId;
        int virtualDesktop = 0;
        QString activity;
        bool operator==(const ContextResolveKey& other) const noexcept
        {
            return virtualDesktop == other.virtualDesktop && screenId == other.screenId && activity == other.activity;
        }
    };
    friend size_t qHash(const LayoutRegistry::ContextResolveKey& key, size_t seed) noexcept
    {
        // ::qHash routes to the global Qt qHash overloads — without the leading
        // qualifier ADL would pick up @c qHash(LayoutAssignmentKey&) (declared
        // in @c AssignmentEntry.h alongside this header) and fail to convert
        // each field. Mirrors the same pattern @c LayoutAssignmentKey itself uses.
        size_t h = seed;
        h = ::qHash(key.screenId, h);
        h = ::qHash(key.virtualDesktop, h);
        h = ::qHash(key.activity, h);
        return h;
    }
 
    template<typename V, typename ComputeFn>
    V resolveCachedContext(QHash<ContextResolveKey, V>& cache, quint64& cacheRevision, const QString& screenId,
                           int virtualDesktop, const QString& activity, ComputeFn&& compute) const
    {
        const quint64 revision = m_ruleStore->ruleSet().revision();
        if (revision != cacheRevision) {
            cache.clear();
            cacheRevision = revision;
        }
        const ContextResolveKey key{screenId, virtualDesktop, activity};
        const auto cached = cache.constFind(key);
        if (cached != cache.constEnd()) {
            return cached.value();
        }
        V value = compute();
        constexpr qsizetype kMaxEntries = 256;
        if (cache.size() >= kMaxEntries) {
            cache.clear();
        }
        cache.insert(key, value);
        return value;
    }
 
    struct RuleSlotResolution
    {
        std::optional<AssignmentEntry> modeEntry;
        std::optional<QString> snappingLayout;
        std::optional<QString> tilingAlgorithm;
    };
 
    mutable QHash<ContextResolveKey, std::optional<RuleSlotResolution>> m_contextResolveCache;
    mutable quint64 m_contextResolveCacheRevision = 0;
 
    mutable QHash<ContextResolveKey, ContextGapOverride> m_contextGapCache;
    mutable quint64 m_contextGapCacheRevision = 0;
 
    mutable QHash<ContextResolveKey, bool> m_contextLockCache;
    mutable quint64 m_contextLockCacheRevision = 0;
 
    mutable QHash<ContextResolveKey, std::optional<bool>> m_contextDefaultAssignmentCache;
    mutable quint64 m_contextDefaultAssignmentCacheRevision = 0;
 
    mutable QHash<ContextResolveKey, ContextOverlayOverride> m_contextOverlayCache;
    mutable quint64 m_contextOverlayCacheRevision = 0;
 
    std::function<QString()> m_defaultLayoutIdProvider; 
    std::function<QString()> m_defaultAutotileAlgorithmProvider;
    std::function<bool()> m_snappingPreferredProvider;
    std::function<bool()> m_defaultAssignmentSuppressedProvider;
    PhosphorWindowRules::WindowRuleStore* m_ruleStore = nullptr;
    std::unique_ptr<PhosphorWindowRules::RuleEvaluator> m_evaluator;
    QString m_layoutSubdirectory; 
    QString m_layoutDirectory; 
    QVector<Layout*> m_layouts;
    Layout* m_activeLayout = nullptr;
    Layout* m_previousLayout = nullptr; 
    QHash<int, QString> m_quickLayoutSlots[2];
    LayoutSettingsStore m_layoutSettings;
    int m_currentVirtualDesktop = 1;
    QHash<QString, int> m_screenVirtualDesktop;
    QString m_currentActivity;
};
 
} // namespace PhosphorZones