AspectRatioClass.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <QJsonValue>
#include <QString>
 
#include <cmath>
 
namespace PhosphorLayout {
 
enum class AspectRatioClass {
    Any = 0, 
    Standard = 1, 
    Ultrawide = 2, 
    SuperUltrawide = 3, 
    Portrait = 4 
};
 
namespace ScreenClassification {
 
// Aspect ratio boundary thresholds (width / height).
constexpr qreal PortraitMax = 1.0; 
constexpr qreal UltrawideMin = 1.9; 
constexpr qreal SuperUltrawideMin = 2.8; 
 
inline AspectRatioClass classify(qreal aspectRatio)
{
    // NaN never compares true under <, which would silently fall through every
    // branch and land at SuperUltrawide. Treat non-finite as "no classification"
    // so callers that compute aspect ratios from suspect inputs get a stable
    // sentinel rather than a wildly wrong category.
    if (!std::isfinite(aspectRatio) || aspectRatio <= 0.0) {
        return AspectRatioClass::Any;
    }
    if (aspectRatio < PortraitMax) {
        return AspectRatioClass::Portrait;
    }
    if (aspectRatio < UltrawideMin) {
        return AspectRatioClass::Standard;
    }
    if (aspectRatio < SuperUltrawideMin) {
        return AspectRatioClass::Ultrawide;
    }
    return AspectRatioClass::SuperUltrawide;
}
 
inline AspectRatioClass classify(int width, int height)
{
    if (height <= 0 || width <= 0) {
        return AspectRatioClass::Any;
    }
    return classify(static_cast<qreal>(width) / height);
}
 
inline QString toString(AspectRatioClass cls)
{
    switch (cls) {
    case AspectRatioClass::Any:
        return QStringLiteral("any");
    case AspectRatioClass::Standard:
        return QStringLiteral("standard");
    case AspectRatioClass::Ultrawide:
        return QStringLiteral("ultrawide");
    case AspectRatioClass::SuperUltrawide:
        return QStringLiteral("super-ultrawide");
    case AspectRatioClass::Portrait:
        return QStringLiteral("portrait");
    }
    return QStringLiteral("any");
}
 
inline AspectRatioClass fromString(const QString& str)
{
    if (str == QLatin1String("standard")) {
        return AspectRatioClass::Standard;
    }
    if (str == QLatin1String("ultrawide")) {
        return AspectRatioClass::Ultrawide;
    }
    if (str == QLatin1String("super-ultrawide")) {
        return AspectRatioClass::SuperUltrawide;
    }
    if (str == QLatin1String("portrait")) {
        return AspectRatioClass::Portrait;
    }
    return AspectRatioClass::Any;
}
 
inline AspectRatioClass fromJsonValue(const QJsonValue& value)
{
    if (value.isString()) {
        return fromString(value.toString());
    }
    if (value.isDouble()) {
        const int cls = value.toInt(static_cast<int>(AspectRatioClass::Any));
        if (cls < 0 || cls > static_cast<int>(AspectRatioClass::Portrait)) {
            return AspectRatioClass::Any;
        }
        return static_cast<AspectRatioClass>(cls);
    }
    return AspectRatioClass::Any;
}
 
inline qreal aspectRatioForClass(AspectRatioClass cls, qreal fallback = 16.0 / 9.0)
{
    switch (cls) {
    case AspectRatioClass::Standard:
        return 16.0 / 9.0;
    case AspectRatioClass::Ultrawide:
        return 21.0 / 9.0;
    case AspectRatioClass::SuperUltrawide:
        return 32.0 / 9.0;
    case AspectRatioClass::Portrait:
        return 9.0 / 16.0;
    case AspectRatioClass::Any:
        return fallback;
    }
    // Unreachable under @c -Wswitch (every enumerator handled above). Kept
    // to satisfy compilers that still warn about control reaching the end
    // of a non-void function when the enum-covering switch exits the path.
    return fallback;
}
 
inline bool matches(AspectRatioClass layoutClass, AspectRatioClass screenClass)
{
    if (layoutClass == AspectRatioClass::Any) {
        return true;
    }
    return layoutClass == screenClass;
}
 
} // namespace ScreenClassification
 
} // namespace PhosphorLayout