AutotileConfig.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 <PhosphorTiles/AutotileConstants.h>
#include <QHash>
#include <QJsonObject>
#include <QString>
#include <QVariantMap>
 
namespace PhosphorTileEngine {
 
struct AlgorithmSettings
{
    qreal splitRatio = PhosphorTiles::AutotileDefaults::DefaultSplitRatio;
    int masterCount = PhosphorTiles::AutotileDefaults::DefaultMasterCount;
    int maxWindows = PhosphorTiles::AutotileDefaults::DefaultMaxWindows;
    QVariantMap customParams; 
    bool operator==(const AlgorithmSettings& other) const
    {
        if (masterCount != other.masterCount || maxWindows != other.maxWindows
            || !qFuzzyCompare(1.0 + splitRatio, 1.0 + other.splitRatio)) {
            return false;
        }
        if (customParams.size() != other.customParams.size()) {
            return false;
        }
        // Fuzzy-compare numeric custom param values to match splitRatio semantics.
        // After JSON round-trip, numbers may arrive as Int/LongLong rather than Double,
        // so check canConvert<double> rather than requiring exact QMetaType::Double.
        for (auto it = customParams.constBegin(); it != customParams.constEnd(); ++it) {
            auto oit = other.customParams.constFind(it.key());
            if (oit == other.customParams.constEnd()) {
                return false;
            }
            const QVariant& a = it.value();
            const QVariant& b = oit.value();
            const bool aNumeric = PhosphorTiles::AutotileDefaults::isNumericMetaType(a.typeId());
            const bool bNumeric = PhosphorTiles::AutotileDefaults::isNumericMetaType(b.typeId());
            const bool aBool = a.typeId() == QMetaType::Bool;
            const bool bBool = b.typeId() == QMetaType::Bool;
            if (aNumeric && bNumeric) {
                if (!qFuzzyCompare(1.0 + a.toDouble(), 1.0 + b.toDouble())) {
                    return false;
                }
            } else if (aBool && bBool) {
                if (a.toBool() != b.toBool()) {
                    return false;
                }
            } else if (a != b) {
                return false;
            }
        }
        return true;
    }
};
 
struct PHOSPHORTILEENGINE_EXPORT AutotileConfig
{
    // ═══════════════════════════════════════════════════════════════════════
    // Algorithm Selection
    // ═══════════════════════════════════════════════════════════════════════
 
    QString algorithmId = PhosphorTiles::AutotileDefaults::DefaultAlgorithmId;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Master Area Settings
    // ═══════════════════════════════════════════════════════════════════════
 
    qreal splitRatio = PhosphorTiles::AutotileDefaults::DefaultSplitRatio;
    qreal splitRatioStep = PhosphorTiles::AutotileDefaults::DefaultSplitRatioStep;
 
    int masterCount = PhosphorTiles::AutotileDefaults::DefaultMasterCount;
 
    QHash<QString, AlgorithmSettings> savedAlgorithmSettings;
 
    static QHash<QString, AlgorithmSettings> perAlgoFromVariantMap(const QVariantMap& map);
    static QVariantMap perAlgoToVariantMap(const QHash<QString, AlgorithmSettings>& hash);
 
    // ═══════════════════════════════════════════════════════════════════════
    // Gap Settings
    // ═══════════════════════════════════════════════════════════════════════
 
    int innerGap = PhosphorTiles::AutotileDefaults::DefaultInnerGap;
 
    int outerGap = PhosphorTiles::AutotileDefaults::DefaultOuterGap;
 
    bool usePerSideOuterGap = false;
 
    int outerGapTop = PhosphorTiles::AutotileDefaults::DefaultOuterGap;
    int outerGapBottom = PhosphorTiles::AutotileDefaults::DefaultOuterGap;
    int outerGapLeft = PhosphorTiles::AutotileDefaults::DefaultOuterGap;
    int outerGapRight = PhosphorTiles::AutotileDefaults::DefaultOuterGap;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Window Insertion Behavior
    // ═══════════════════════════════════════════════════════════════════════
 
    using InsertPosition = PhosphorTiles::AutotileInsertPosition;
 
    InsertPosition insertPosition = InsertPosition::End;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Focus Behavior
    // ═══════════════════════════════════════════════════════════════════════
 
    bool focusFollowsMouse = false;
 
    bool focusNewWindows = true;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Smart Features
    // ═══════════════════════════════════════════════════════════════════════
 
    bool smartGaps = true;
 
    bool respectMinimumSize = true;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Window Limits
    // ═══════════════════════════════════════════════════════════════════════
 
    int maxWindows = PhosphorTiles::AutotileDefaults::DefaultMaxWindows;
 
    PhosphorTiles::AutotileOverflowBehavior overflowBehavior = PhosphorTiles::AutotileOverflowBehavior::Float;
 
    // ═══════════════════════════════════════════════════════════════════════
    // Comparison and Serialization
    // ═══════════════════════════════════════════════════════════════════════
 
    bool operator==(const AutotileConfig& other) const;
    bool operator!=(const AutotileConfig& other) const;
 
    QJsonObject toJson() const;
 
    static AutotileConfig fromJson(const QJsonObject& json);
 
    static AutotileConfig defaults();
};
 
} // namespace PhosphorTileEngine
 
// Enable use with QVariant
Q_DECLARE_METATYPE(PhosphorTileEngine::AutotileConfig)
Q_DECLARE_METATYPE(PhosphorTileEngine::AutotileConfig::InsertPosition)