PerScreenConfigResolver.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <phosphortileengine_export.h>
#include <PhosphorEngine/PerScreenKeys.h>
#include <PhosphorLayoutApi/EdgeGaps.h>
#include <PhosphorTiles/AutotileConstants.h>
#include <QHash>
#include <QString>
#include <QVariantMap>
#include <functional>
#include <optional>
 
namespace PhosphorTiles {
class TilingAlgorithm;
}
 
namespace PhosphorTileEngine {
 
namespace PerScreenKeys = PhosphorEngine::PerScreenKeys;
 
class AutotileConfig;
class AutotileEngine;
 
class PHOSPHORTILEENGINE_EXPORT PerScreenConfigResolver
{
public:
    explicit PerScreenConfigResolver(AutotileEngine* engine);
 
    // ═══════════════════════════════════════════════════════════════════════════
    // Per-screen override storage
    // ═══════════════════════════════════════════════════════════════════════════
 
    void applyPerScreenConfig(const QString& screenId, const QVariantMap& overrides);
 
    void clearPerScreenConfig(const QString& screenId);
 
    QVariantMap perScreenOverrides(const QString& screenId) const;
 
    bool hasPerScreenOverride(const QString& screenId, const QString& key) const;
 
    void updatePerScreenOverride(const QString& screenId, const QString& key, const QVariant& value);
 
    void removeOverridesForScreen(const QString& screenId);
 
    void forgetRememberedAlgorithmsForUnknownScreens();
 
    void forgetScreen(const QString& screenId);
 
    void removeOverridesMatching(const std::function<bool(const QString&)>& pred);
 
    void applyGlobalAlgorithmChange(const QString& previousGlobalId, const QString& newGlobalId);
 
    using ContextGapProvider = std::function<QVariantMap(const QString& screenId)>;
    void setContextGapProvider(ContextGapProvider provider)
    {
        m_contextGapProvider = std::move(provider);
    }
 
    // ═══════════════════════════════════════════════════════════════════════════
    // Effective per-screen values (per-screen override → global fallback)
    // ═══════════════════════════════════════════════════════════════════════════
 
    int effectiveInnerGap(const QString& screenId) const;
    ::PhosphorLayout::EdgeGaps effectiveOuterGaps(const QString& screenId) const;
    struct EffectiveGaps
    {
        int inner = 0;
        ::PhosphorLayout::EdgeGaps outer;
    };
    EffectiveGaps effectiveGaps(const QString& screenId) const;
    bool effectiveSmartGaps(const QString& screenId) const;
    bool effectiveRespectMinimumSize(const QString& screenId) const;
    int effectiveMaxWindows(const QString& screenId) const;
    PhosphorTiles::AutotileOverflowBehavior effectiveOverflowBehavior(const QString& screenId) const;
    PhosphorTiles::AutotileInsertPosition effectiveInsertPosition(const QString& screenId) const;
    QVariantMap effectiveCustomParamsOverride(const QString& screenId) const;
    qreal effectiveSplitRatioStep(const QString& screenId) const;
    QString effectiveAlgorithmId(const QString& screenId) const;
    PhosphorTiles::TilingAlgorithm* effectiveAlgorithm(const QString& screenId) const;
 
private:
    std::optional<QVariant> perScreenOverride(const QString& screenId, const QString& key) const;
 
    void wipeStateBagsOnEffectiveAlgorithmChange(const QString& screenId, const QString& oldEffectiveId,
                                                 const QString& newEffectiveId);
 
    bool screenFollowsGlobalAlgorithm(const QString& screenId, const QString& previousGlobalId) const;
 
    static QString algorithmIdFromMap(const QVariantMap& map, const QString& fallback);
 
    QString rememberedAlgorithmId(const QString& screenId, const QVariantMap& previousOverrides) const;
 
    QVariantMap contextGapMap(const QString& screenId) const;
 
    static std::optional<int> contextGapFromMap(const QVariantMap& ctx, QLatin1String key);
 
    int innerGapFromMap(const QString& screenId, const QVariantMap& ctx) const;
    ::PhosphorLayout::EdgeGaps outerGapsFromMap(const QString& screenId, const QVariantMap& ctx) const;
 
    std::optional<::PhosphorLayout::EdgeGaps> contextOuterGapsFromMap(const QVariantMap& ctx) const;
 
    int outerGapBase(const QString& screenId, const QVariantMap& ctx) const;
 
    AutotileEngine* m_engine = nullptr;
    QHash<QString, QVariantMap> m_perScreenOverrides;
    QHash<QString, QString> m_rememberedAlgorithmId;
    ContextGapProvider m_contextGapProvider{};
};
 
} // namespace PhosphorTileEngine