GapResolution.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorEngine/PerScreenKeys.h>
#include <PhosphorLayoutApi/EdgeGaps.h>
#include <QVariantMap>
#include <optional>
 
namespace PhosphorEngine {
 
namespace GapResolution {
 
template<typename Normalize>
std::optional<int> gapFromOverrideMap(const QVariantMap& map, QLatin1String key, Normalize normalize)
{
    const auto it = map.constFind(key);
    if (it == map.constEnd()) {
        return std::nullopt;
    }
    return normalize(it->toInt());
}
 
template<typename Normalize>
std::optional<::PhosphorLayout::EdgeGaps> outerGapsFromOverrideMap(const QVariantMap& map, int missingSideBase,
                                                                   Normalize normalize)
{
    if (map.isEmpty()) {
        return std::nullopt;
    }
    const auto uniformIt = map.constFind(QString(PerScreenKeys::OuterGap));
    const bool usePerSide = map.value(QString(PerScreenKeys::UsePerSideOuterGap), false).toBool();
    if (usePerSide) {
        const auto topIt = map.constFind(QString(PerScreenKeys::OuterGapTop));
        const auto bottomIt = map.constFind(QString(PerScreenKeys::OuterGapBottom));
        const auto leftIt = map.constFind(QString(PerScreenKeys::OuterGapLeft));
        const auto rightIt = map.constFind(QString(PerScreenKeys::OuterGapRight));
        if (topIt != map.constEnd() || bottomIt != map.constEnd() || leftIt != map.constEnd()
            || rightIt != map.constEnd()) {
            const int base = (uniformIt != map.constEnd()) ? normalize(uniformIt->toInt()) : normalize(missingSideBase);
            return ::PhosphorLayout::EdgeGaps{(topIt != map.constEnd()) ? normalize(topIt->toInt()) : base,
                                              (bottomIt != map.constEnd()) ? normalize(bottomIt->toInt()) : base,
                                              (leftIt != map.constEnd()) ? normalize(leftIt->toInt()) : base,
                                              (rightIt != map.constEnd()) ? normalize(rightIt->toInt()) : base};
        }
    }
    if (uniformIt != map.constEnd()) {
        return ::PhosphorLayout::EdgeGaps::uniform(normalize(uniformIt->toInt()));
    }
    return std::nullopt;
}
 
} // namespace GapResolution
} // namespace PhosphorEngine