SplitTree.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <phosphortiles_export.h>
 
#include "AutotileConstants.h"
 
#include <QJsonObject>
#include <QRect>
#include <QString>
#include <QStringList>
#include <QVector>
 
#include <memory>
 
namespace PhosphorTiles {
 
struct PHOSPHORTILES_EXPORT SplitNode
{
    qreal splitRatio = AutotileDefaults::DefaultSplitRatio; 
    bool splitHorizontal = false; 
    std::unique_ptr<SplitNode> first; 
    std::unique_ptr<SplitNode> second; 
    SplitNode* parent = nullptr; 
    QString windowId; 
 
    bool isLeaf() const
    {
        return !first && !second;
    }
};
 
class PHOSPHORTILES_EXPORT SplitTree
{
public:
    enum class Edge {
        Left,
        Right,
        Top,
        Bottom
    };
 
    SplitTree();
 
    SplitTree(SplitTree&& other) noexcept;
 
    SplitTree& operator=(SplitTree&& other) noexcept;
 
    ~SplitTree();
 
    // Non-copyable (unique_ptr members)
    SplitTree(const SplitTree&) = delete;
    SplitTree& operator=(const SplitTree&) = delete;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Queries
    // ═══════════════════════════════════════════════════════════════════════
 
    const SplitNode* root() const noexcept;
    SplitNode* root() noexcept;
 
    bool isEmpty() const noexcept;
 
    int leafCount() const noexcept;
 
    int treeHeight() const noexcept;
 
    const SplitNode* leafForWindow(const QString& windowId) const;
    SplitNode* leafForWindow(const QString& windowId);
 
    QStringList leafOrder() const;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Mutations
    // ═══════════════════════════════════════════════════════════════════════
 
    void insertAtFocused(const QString& windowId, const QString& focusedWindowId, qreal initialRatio = 0.0);
 
    void insertAtEnd(const QString& windowId, qreal initialRatio = 0.0);
 
    void insertAtPosition(const QString& windowId, int position, qreal initialRatio = 0.0);
 
    void remove(const QString& windowId);
 
    void swap(const QString& windowId1, const QString& windowId2);
 
    bool swapLeaves(const QString& a, const QString& b);
 
    void resizeSplit(const QString& windowId, qreal newRatio);
 
    void resizeSplitNode(SplitNode* node, qreal newRatio);
 
    const SplitNode* splitOwningEdge(const QString& windowId, Edge edge) const;
    SplitNode* splitOwningEdge(const QString& windowId, Edge edge);
 
    // ═══════════════════════════════════════════════════════════════════════
    // Geometry
    // ═══════════════════════════════════════════════════════════════════════
 
    QVector<QRect> applyGeometry(const QRect& area, int innerGap) const;
 
    bool rebuildFromOrder(const QStringList& tiledWindows,
                          qreal defaultSplitRatio = AutotileDefaults::DefaultSplitRatio);
 
    // ═══════════════════════════════════════════════════════════════════════
    // Serialization
    // ═══════════════════════════════════════════════════════════════════════
 
    QJsonObject toJson() const;
 
    static std::unique_ptr<SplitTree> fromJson(const QJsonObject& json);
 
private:
    enum class InsertReady {
        Proceed,
        Done,
        Rejected
    };
    static constexpr int MaxRuntimeTreeDepth = AutotileDefaults::MaxRuntimeTreeDepth;
 
    InsertReady prepareInsert(const QString& windowId);
 
    void insertAtEndRaw(const QString& windowId, qreal initialRatio);
 
    void insertAtEndImpl(const QString& windowId, qreal initialRatio);
 
    std::unique_ptr<SplitNode> m_root;
 
    SplitNode* findLeaf(SplitNode* node, const QString& windowId, int depth = 0) const;
    const SplitNode* findLeaf(const SplitNode* node, const QString& windowId, int depth = 0) const;
    SplitNode* leafAtIndex(SplitNode* node, int targetIndex, int& currentIndex, int depth = 0) const;
    const SplitNode* leafAtIndex(const SplitNode* node, int targetIndex, int& currentIndex, int depth = 0) const;
    SplitNode* rightmostLeaf(SplitNode* node) const;
    const SplitNode* rightmostLeaf(const SplitNode* node) const;
    void collectLeafOrder(const SplitNode* node, QStringList& order, int depth = 0) const;
    int countLeaves(const SplitNode* node, int depth = 0) const;
    void applyGeometryRecursive(const SplitNode* node, const QRect& rect, int innerGap, QVector<QRect>& zones,
                                int depth = 0) const;
 
    static int subtreeHeight(const SplitNode* node, int depth = 0);
    static void splitLeaf(SplitNode* leaf, const QString& newId, qreal ratio);
 
    static constexpr int MaxDeserializationDepth = AutotileDefaults::MaxRuntimeTreeDepth;
    static constexpr int MaxDeserializationNodes = 1024; 
 
    static QJsonObject nodeToJson(const SplitNode* node, int depth = 0);
    static std::unique_ptr<SplitNode> nodeFromJson(const QJsonObject& json, SplitNode* parent, int depth,
                                                   int& nodeCount, int& clampedRatios, QSet<QString>& seenIds);
};
 
} // namespace PhosphorTiles