SnapState.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <phosphorsnapengine_export.h>
#include <PhosphorEngine/IPlacementState.h>
#include <PhosphorEngine/IWindowRegistry.h>
 
#include <QHash>
#include <QObject>
#include <QSet>
#include <QString>
#include <QStringList>
 
#include <optional>
 
namespace PhosphorSnapEngine {
 
class PHOSPHORSNAPENGINE_EXPORT SnapState : public QObject, public PhosphorEngine::IPlacementState
{
    Q_OBJECT
 
public:
    explicit SnapState(const QString& screenId, QObject* parent = nullptr);
    ~SnapState() override;
 
    SnapState(const SnapState&) = delete;
    SnapState& operator=(const SnapState&) = delete;
 
    void setWindowRegistry(PhosphorEngine::IWindowRegistry* registry)
    {
        m_windowRegistry = registry;
    }
 
    // ═══════════════════════════════════════════════════════════════════════════
    // IPlacementState
    // ═══════════════════════════════════════════════════════════════════════════
 
    QString screenId() const override;
    int windowCount() const override;
    QStringList managedWindows() const override;
    bool containsWindow(const QString& windowId) const override;
    bool isFloating(const QString& windowId) const override;
    QStringList floatingWindows() const override;
    QString placementIdForWindow(const QString& windowId) const override;
 
    // ═══════════════════════════════════════════════════════════════════════════
    // Zone Assignment CRUD
    // ═══════════════════════════════════════════════════════════════════════════
 
    void assignWindowToZone(const QString& windowId, const QString& zoneId, const QString& screenId,
                            int virtualDesktop);
    void assignWindowToZones(const QString& windowId, const QStringList& zoneIds, const QString& screenId,
                             int virtualDesktop);
    struct UnassignResult
    {
        bool wasAssigned = false;
        bool lastUsedZoneCleared = false;
    };
    UnassignResult unassignWindow(const QString& windowId);
    bool clearScreenAndDesktop(const QString& windowId);
 
    QString zoneForWindow(const QString& windowId) const;
    QStringList zonesForWindow(const QString& windowId) const;
    QStringList windowsInZone(const QString& zoneId) const;
    QStringList snappedWindows() const;
    bool isWindowSnapped(const QString& windowId) const;
 
    void noteFocused(const QString& windowId);
    QString lastSnappedFocus() const
    {
        return m_lastSnappedFocus;
    }
    QString lastFloatingFocus() const
    {
        return m_lastFloatingFocus;
    }
 
    QString screenForWindow(const QString& windowId) const;
 
    void recordResidence(const QString& windowId, const QString& screenId, int virtualDesktop);
    int desktopForWindow(const QString& windowId) const;
 
    bool reassignDesktop(const QString& windowId, int virtualDesktop);
 
    QStringList windowsOnScreenAndDesktop(const QString& screenId, int virtualDesktop) const;
 
    const QHash<QString, QString>& screenAssignments() const
    {
        return m_windowScreenAssignments;
    }
    const QHash<QString, int>& desktopAssignments() const
    {
        return m_windowDesktopAssignments;
    }
    void setScreenAssignments(const QHash<QString, QString>& s)
    {
        if (m_windowScreenAssignments == s) {
            return;
        }
        m_windowScreenAssignments = s;
        Q_EMIT stateChanged();
    }
 
    // ═══════════════════════════════════════════════════════════════════════════
    // Floating State
    // ═══════════════════════════════════════════════════════════════════════════
 
    void setFloating(const QString& windowId, bool floating);
 
    void setFloatingOnScreen(const QString& windowId, const QString& screenId, int virtualDesktop);
 
    UnassignResult unsnapForFloat(const QString& windowId);
    QString preFloatZone(const QString& windowId) const;
    QStringList preFloatZones(const QString& windowId) const;
    QString preFloatScreen(const QString& windowId) const;
    bool clearPreFloatZone(const QString& windowId);
    void addPreFloatZone(const QString& windowId, const QStringList& zoneIds);
    void addPreFloatScreen(const QString& windowId, const QString& screenId);
 
    const QHash<QString, QStringList>& preFloatZoneAssignments() const
    {
        return m_preFloatZoneAssignments;
    }
    const QHash<QString, QString>& preFloatScreenAssignments() const
    {
        return m_preFloatScreenAssignments;
    }
    void setPreFloatScreenAssignments(const QHash<QString, QString>& a)
    {
        if (m_preFloatScreenAssignments == a) {
            return;
        }
        m_preFloatScreenAssignments = a;
        Q_EMIT stateChanged();
    }
 
    // ═══════════════════════════════════════════════════════════════════════════
    // Window Lifecycle
    // ═══════════════════════════════════════════════════════════════════════════
 
    void windowClosed(const QString& windowId);
    bool isEmpty() const;
    void clear();
 
    void migrateWindowTo(SnapState* target, const QString& windowId, const QString& newScreenId);
 
    bool removeWindowData(const QString& windowId);
 
    // ═══════════════════════════════════════════════════════════════════════════
    // Last-Used Zone Tracking
    //
    // Each per-(screen,desktop,activity) store tracks its OWN last-used zone, so a
    // window opening on monitor A only ever restores to a zone A was last snapped to
    // (never monitor B's). The on-disk `LastUsedZoneId` persists a single id; the
    // facade picks the representative store by lastUsedSeq() (most-recently updated).
    // ═══════════════════════════════════════════════════════════════════════════
 
    void updateLastUsedZone(const QString& zoneId, const QString& screenId, const QString& windowClass,
                            int virtualDesktop);
 
    void restoreLastUsedZone(const QString& zoneId, const QString& screenId, const QString& zoneClass, int desktop);
 
    QString lastUsedZoneId() const
    {
        return m_lastUsedZoneId;
    }
    QString lastUsedScreenId() const
    {
        return m_lastUsedScreenId;
    }
    QString lastUsedZoneClass() const
    {
        return m_lastUsedZoneClass;
    }
    int lastUsedDesktop() const
    {
        return m_lastUsedDesktop;
    }
    quint64 lastUsedSeq() const
    {
        return m_lastUsedSeq;
    }
    void retagLastUsedZoneClass(const QString& newClass)
    {
        if (m_lastUsedZoneClass == newClass) {
            return;
        }
        m_lastUsedZoneClass = newClass;
        Q_EMIT stateChanged();
    }
 
    // ═══════════════════════════════════════════════════════════════════════════
    // Auto-Snap Bookkeeping
    // ═══════════════════════════════════════════════════════════════════════════
 
    void recordSnapIntent(const QString& windowClass, bool wasUserInitiated);
    const QSet<QString>& userSnappedClasses() const
    {
        return m_userSnappedClasses;
    }
    void setUserSnappedClasses(const QSet<QString>& classes)
    {
        if (m_userSnappedClasses == classes) {
            return;
        }
        m_userSnappedClasses = classes;
        Q_EMIT stateChanged();
    }
 
    void markAsAutoSnapped(const QString& windowId);
    bool isAutoSnapped(const QString& windowId) const;
    bool clearAutoSnapped(const QString& windowId);
 
    // ═══════════════════════════════════════════════════════════════════════════
    // Occupied Zone Queries
    // ═══════════════════════════════════════════════════════════════════════════
 
    QSet<QString> buildOccupiedZoneSet(const QString& screenFilter = {}, int desktopFilter = 0) const;
 
    int pruneStaleAssignments(const QSet<QString>& aliveWindowIds);
 
    // ═══════════════════════════════════════════════════════════════════════════
    // State Access (for persistence layer)
    // ═══════════════════════════════════════════════════════════════════════════
 
    const QHash<QString, QStringList>& zoneAssignments() const
    {
        return m_windowZoneAssignments;
    }
 
Q_SIGNALS:
    void windowAssigned(const QString& windowId, const QString& zoneId);
    void windowUnassigned(const QString& windowId);
    void floatingChanged(const QString& windowId, bool floating);
    void stateChanged();
 
private:
    QString canonicalizeForLookup(const QString& rawWindowId) const;
 
    UnassignResult clearZoneAssignment(const QString& windowId, bool preserveScreenAndDesktop);
 
    QSet<QString> allManagedWindowIds() const
    {
        QSet<QString> all;
        all.reserve(m_windowZoneAssignments.size() + m_floatingWindows.size() + m_autoSnappedWindows.size());
        for (auto it = m_windowZoneAssignments.constBegin(); it != m_windowZoneAssignments.constEnd(); ++it) {
            all.insert(it.key());
        }
        all.unite(m_floatingWindows);
        all.unite(m_autoSnappedWindows);
        return all;
    }
 
    QString m_screenId;
 
    PhosphorEngine::IWindowRegistry* m_windowRegistry = nullptr;
 
    QHash<QString, QStringList> m_windowZoneAssignments;
    QHash<QString, QString> m_windowScreenAssignments;
    QHash<QString, int> m_windowDesktopAssignments;
    QSet<QString> m_floatingWindows;
    QHash<QString, QStringList> m_preFloatZoneAssignments;
    QHash<QString, QString> m_preFloatScreenAssignments;
 
    QString m_lastSnappedFocus;
    QString m_lastFloatingFocus;
 
    QString m_lastUsedZoneId;
    QString m_lastUsedScreenId;
    QString m_lastUsedZoneClass;
    int m_lastUsedDesktop = 0;
    quint64 m_lastUsedSeq = 0;
 
    QSet<QString> m_userSnappedClasses;
    QSet<QString> m_autoSnappedWindows;
};
 
} // namespace PhosphorSnapEngine