LuauTileAlgorithm.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include "TileScriptMetadata.h"
#include "TilingAlgorithm.h"
 
#include <phosphortiles_export.h>
 
#include <QString>
#include <QVariantMap>
 
#include <memory>
 
namespace PhosphorScripting {
class LuauEngine;
class LuauWatchdog;
}
 
namespace PhosphorTiles {
 
class SplitNode;
 
class PHOSPHORTILES_EXPORT LuauTileAlgorithm : public TilingAlgorithm
{
    Q_OBJECT
 
public:
    explicit LuauTileAlgorithm(const QString& filePath,
                               std::shared_ptr<PhosphorScripting::LuauWatchdog> watchdog = nullptr,
                               QObject* parent = nullptr);
    LuauTileAlgorithm(const QString& filePath, std::shared_ptr<PhosphorScripting::LuauEngine> sharedEngine,
                      std::shared_ptr<PhosphorScripting::LuauWatchdog> watchdog, QObject* parent = nullptr);
    ~LuauTileAlgorithm() override;
 
    static std::shared_ptr<PhosphorScripting::LuauEngine>
    createSandboxedEngine(std::shared_ptr<PhosphorScripting::LuauWatchdog> watchdog, QString* error = nullptr);
 
    bool isValid() const;
 
    QString filePath() const;
 
    QString id() const;
 
    void setUserScript(bool isUser);
 
    // TilingAlgorithm interface
    QString name() const override;
    QString description() const override;
    QVector<QRect> calculateZones(const TilingParams& params) const override;
    int masterZoneIndex() const override;
    bool supportsMasterCount() const override;
    bool supportsSplitRatio() const override;
    qreal defaultSplitRatio() const override;
    int minimumWindows() const override;
    int defaultMaxWindows() const override;
    bool producesOverlappingZones() const override;
    bool supportsMinSizes() const noexcept override;
    bool supportsMemory() const noexcept override;
    QString zoneNumberDisplay() const noexcept override;
    bool centerLayout() const override;
    bool isScripted() const noexcept override;
    bool isUserScript() const noexcept override;
    void prepareTilingState(TilingState* state) const override;
 
    // Lifecycle hooks (v2)
    bool supportsLifecycleHooks() const noexcept override;
    void onWindowAdded(TilingState* state, int windowIndex) override;
    void onWindowRemoved(TilingState* state, int windowIndex) override;
 
    // Interactive-resize hook (v2) — for non-tree algorithms that persist their
    // own ctx.state (e.g. an aligned grid remembering column widths).
    bool supportsResizeHook() const noexcept override;
    void onWindowResized(TilingState* state, const ResizeEvent& resize) override;
    bool supportsScriptState() const noexcept override;
 
    // Custom parameters (v2)
    bool supportsCustomParams() const noexcept override;
    QVariantList customParamDefList() const override;
    bool hasCustomParam(const QString& name) const override;
 
private:
    bool loadScript(const QString& filePath);
    void cacheMetadataAndOverrides();
 
    QVariantMap buildContext(const TilingParams& params, const QRect& area) const;
    QVariantMap buildStateMap(const TilingState* state, bool includeCountAfterRemoval) const;
 
    // Engine ownership: exactly one of m_ownedEngine / m_sharedEngine is set,
    // and m_engine is a non-owning view of whichever is active. Both are
    // shared_ptr so the active engine survives this object's deferred-delete
    // teardown (see class docs); m_sharedEngine additionally keeps the
    // loader's shared VM alive until this algorithm releases its module.
    std::shared_ptr<PhosphorScripting::LuauEngine> m_ownedEngine;
    std::shared_ptr<PhosphorScripting::LuauEngine> m_sharedEngine;
    PhosphorScripting::LuauEngine* m_engine = nullptr;
    std::shared_ptr<PhosphorScripting::LuauWatchdog> m_watchdog;
    int m_module = -1;
 
    QString m_filePath;
    QString m_scriptId;
    bool m_valid = false;
    bool m_isUserScript = false;
    bool m_hasOnWindowAdded = false;
    bool m_hasOnWindowRemoved = false;
    bool m_hasOnWindowResized = false;
 
    ScriptedHelpers::ScriptMetadata m_metadata;
 
    // Accessor values resolved once at load (override fn → metadata → default).
    int m_cachedMasterZoneIndex = -1;
    int m_cachedMinimumWindows = 1;
    int m_cachedDefaultMaxWindows = 6;
    qreal m_cachedDefaultSplitRatio = AutotileDefaults::DefaultSplitRatio;
    bool m_cachedSupportsMasterCount = false;
    bool m_cachedSupportsSplitRatio = false;
    bool m_cachedProducesOverlappingZones = false;
    bool m_cachedCenterLayout = false;
};
 
} // namespace PhosphorTiles