TilingState.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include "AutotileConstants.h"
#include <PhosphorEngine/IPlacementState.h>
#include <phosphortiles_export.h>
#include <QObject>
#include <QJsonObject>
#include <QRect>
#include <QSet>
#include <QString>
#include <QStringList>
#include <QVector>
 
#include <functional>
#include <memory>
 
namespace PhosphorTiles {
 
class SplitTree;
struct SplitNode;
 
class PHOSPHORTILES_EXPORT TilingState : public QObject, public PhosphorEngine::IPlacementState
{
    Q_OBJECT
 
    Q_PROPERTY(QString screenId READ screenId CONSTANT)
    Q_PROPERTY(int windowCount READ windowCount NOTIFY windowCountChanged)
    Q_PROPERTY(int tiledWindowCount READ tiledWindowCount NOTIFY windowCountChanged)
    Q_PROPERTY(int masterCount READ masterCount WRITE setMasterCount NOTIFY masterCountChanged)
    Q_PROPERTY(qreal splitRatio READ splitRatio WRITE setSplitRatio NOTIFY splitRatioChanged)
 
public:
    explicit TilingState(const QString& screenId, QObject* parent = nullptr);
    ~TilingState() override;
 
    // Prevent copying (QObject rule)
    TilingState(const TilingState&) = delete;
    TilingState& operator=(const TilingState&) = delete;
 
    QString screenId() const override;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Window Order Management
    // ═══════════════════════════════════════════════════════════════════════
 
    int windowCount() const override;
 
    int tiledWindowCount() const override;
 
    QStringList windowOrder() const;
 
    QStringList tiledWindows() const;
 
    bool addWindow(const QString& windowId, int position = -1);
 
    bool removeWindow(const QString& windowId);
 
    bool moveWindow(int fromIndex, int toIndex);
 
    bool swapWindows(int index1, int index2);
 
    bool swapWindowsById(const QString& windowId1, const QString& windowId2);
 
    int windowIndex(const QString& windowId) const;
 
    bool containsWindow(const QString& windowId) const override;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Master Management
    // ═══════════════════════════════════════════════════════════════════════
 
    int masterCount() const override;
 
    void setMasterCount(int count);
 
    bool isMaster(const QString& windowId) const;
 
    QStringList masterWindows() const;
 
    QStringList stackWindows() const;
 
    bool promoteToMaster(const QString& windowId);
 
    bool moveToFront(const QString& windowId);
 
    bool insertAfterFocused(const QString& windowId);
 
    bool moveToPosition(const QString& windowId, int position);
 
    int windowPosition(const QString& windowId) const;
 
    int tiledWindowIndex(const QString& windowId) const;
 
    bool moveToTiledPosition(const QString& windowId, int tiledPosition);
 
    bool rotateWindows(bool clockwise = true);
 
    // ═══════════════════════════════════════════════════════════════════════
    // Split Ratio
    // ═══════════════════════════════════════════════════════════════════════
 
    qreal splitRatio() const;
 
    void setSplitRatio(qreal ratio);
 
    void increaseSplitRatio(qreal delta = 0.05);
 
    void decreaseSplitRatio(qreal delta = 0.05);
 
    // ═══════════════════════════════════════════════════════════════════════
    // Per-Window Floating State
    // ═══════════════════════════════════════════════════════════════════════
 
    bool isFloating(const QString& windowId) const override;
 
    void setFloating(const QString& windowId, bool floating);
 
    bool toggleFloating(const QString& windowId);
 
    QStringList floatingWindows() const override;
 
    // ═══════════════════════════════════════════════════════════════════════
    // IPlacementState
    // ═══════════════════════════════════════════════════════════════════════
 
    QStringList managedWindows() const override;
    QString placementIdForWindow(const QString& windowId) const override;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Focus Tracking
    // ═══════════════════════════════════════════════════════════════════════
 
    QString focusedWindow() const;
 
    void setFocusedWindow(const QString& windowId);
 
    int focusedTiledIndex() const;
 
    QString lastTiledFocus() const;
    QString lastFloatingFocus() const;
 
    bool floatingHasFocus() const;
 
    void clear();
 
    // ═══════════════════════════════════════════════════════════════════════
    // Calculated Zone Storage
    // ═══════════════════════════════════════════════════════════════════════
 
    void setCalculatedZones(const QVector<QRect>& zones);
 
    QVector<QRect> calculatedZones() const;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Split Tree (persistent BSP tree for memory-based algorithms)
    // ═══════════════════════════════════════════════════════════════════════
 
    SplitTree* splitTree() const;
 
    void setSplitTree(std::unique_ptr<SplitTree> tree);
 
    void clearSplitTree();
 
    std::unique_ptr<SplitTree> takeSplitTree();
 
    void rebuildSplitTree();
 
    // ═══════════════════════════════════════════════════════════════════════
    // Script state (opaque persistent bag for scripted algorithms)
    // ═══════════════════════════════════════════════════════════════════════
 
    QJsonObject scriptState() const;
 
    void setScriptState(const QJsonObject& state);
 
    static QJsonObject sanitizeScriptState(const QJsonObject& state);
 
Q_SIGNALS:
    void windowCountChanged();
 
    void windowOrderChanged();
 
    void masterCountChanged();
 
    void splitRatioChanged();
 
    void floatingChanged(const QString& windowId, bool floating);
 
    void focusedWindowChanged();
 
    void stateChanged();
 
private:
    QString m_screenId;
    QStringList m_windowOrder;
    QSet<QString> m_floatingWindows;
    QString m_focusedWindow;
    QString m_lastTiledFocus;
    QString m_lastFloatingFocus;
    int m_masterCount = AutotileDefaults::DefaultMasterCount;
    qreal m_splitRatio = AutotileDefaults::DefaultSplitRatio;
    QVector<QRect> m_calculatedZones;
    std::unique_ptr<SplitTree> m_splitTree;
    QJsonObject m_scriptState; 
 
    // Helper to emit stateChanged after other signals
    void notifyStateChanged();
 
    void forEachTiledWindow(const std::function<bool(const QString& windowId, int tiledIndex)>& func) const;
 
    // ── Clamping helpers (DRY: shared by the setters and the script-state sanitizer) ──
    static int clampMasterCount(int value);
    static qreal clampSplitRatio(qreal value);
 
    // ── Tree synchronization helpers (SRP/DRY: single place for null-check + op) ──
    void syncTreeInsert(const QString& windowId, int position = -1);
    void syncTreeRemove(const QString& windowId);
    void syncTreeSwap(const QString& idA, const QString& idB);
    void syncTreeLazyCreate();
};
 
} // namespace PhosphorTiles