VirtualScreen.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorIdentity/VirtualScreenId.h>
 
#include <QHash>
#include <QRect>
#include <QRectF>
#include <QSet>
#include <QString>
#include <QVector>
 
#include <algorithm>
#include <utility>
 
namespace Phosphor::Screens {
 
struct VirtualScreenDef
{
    QString id; 
    QString physicalScreenId; 
    QString displayName; 
    QRectF region; 
    int index = 0; 
 
    static constexpr qreal Tolerance = 1e-3;
 
    QRect absoluteGeometry(const QRect& physicalGeometry) const
    {
        int left = physicalGeometry.x() + qRound(region.x() * physicalGeometry.width());
        int top = physicalGeometry.y() + qRound(region.y() * physicalGeometry.height());
        int right = physicalGeometry.x() + qRound((region.x() + region.width()) * physicalGeometry.width());
        int bottom = physicalGeometry.y() + qRound((region.y() + region.height()) * physicalGeometry.height());
        // Clamp to physical screen bounds to prevent tolerance overshoot.
        right = qMin(right, physicalGeometry.x() + physicalGeometry.width());
        bottom = qMin(bottom, physicalGeometry.y() + physicalGeometry.height());
        // Prevent degenerate geometry when tolerance overshoot pushes left/top
        // past right/bottom. Apply BEFORE the floor clamp so the floor clamp
        // has the final word on minimum origin.
        left = qMin(left, right - 1);
        top = qMin(top, bottom - 1);
        left = qMax(left, physicalGeometry.x());
        top = qMax(top, physicalGeometry.y());
        int w = qMax(1, right - left);
        int h = qMax(1, bottom - top);
        return QRect(left, top, w, h);
    }
 
    bool operator==(const VirtualScreenDef&) const = default;
 
    bool approxEqual(const VirtualScreenDef& other) const
    {
        return id == other.id && physicalScreenId == other.physicalScreenId && displayName == other.displayName
            && index == other.index && qAbs(region.x() - other.region.x()) < Tolerance
            && qAbs(region.y() - other.region.y()) < Tolerance
            && qAbs(region.width() - other.region.width()) < Tolerance
            && qAbs(region.height() - other.region.height()) < Tolerance;
    }
 
    bool isValid() const
    {
        return PhosphorIdentity::VirtualScreenId::isVirtual(id) && !physicalScreenId.isEmpty() && index >= 0
            && region.x() >= -Tolerance && region.y() >= -Tolerance && region.width() > 0 && region.height() > 0
            && region.x() + region.width() <= 1.0 + Tolerance && region.y() + region.height() <= 1.0 + Tolerance;
    }
 
    struct PhysicalEdges
    {
        bool left = true;
        bool top = true;
        bool right = true;
        bool bottom = true;
    };
    PhysicalEdges physicalEdges() const
    {
        return {region.left() < Tolerance, region.top() < Tolerance, region.right() > (1.0 - Tolerance),
                region.bottom() > (1.0 - Tolerance)};
    }
};
 
struct VirtualScreenConfig
{
    QString physicalScreenId;
    QVector<VirtualScreenDef> screens;
 
    bool hasSubdivisions() const
    {
        return screens.size() > 1;
    }
    bool isEmpty() const
    {
        return screens.isEmpty();
    }
 
    bool operator==(const VirtualScreenConfig&) const = default;
 
    bool approxEqual(const VirtualScreenConfig& other) const
    {
        if (physicalScreenId != other.physicalScreenId || screens.size() != other.screens.size()) {
            return false;
        }
        for (int i = 0; i < screens.size(); ++i) {
            if (!screens[i].approxEqual(other.screens[i])) {
                return false;
            }
        }
        return true;
    }
 
    static bool isValid(const VirtualScreenConfig& cfg, const QString& expectedPhysicalScreenId,
                        int maxScreensPerPhysical, QString* error = nullptr)
    {
        auto fail = [&](const QString& msg) {
            if (error)
                *error = msg;
            return false;
        };
 
        // Empty config = removal request. Always valid.
        if (cfg.isEmpty()) {
            return true;
        }
 
        if (!expectedPhysicalScreenId.isEmpty() && cfg.physicalScreenId != expectedPhysicalScreenId) {
            return fail(QStringLiteral("config physicalScreenId '%1' does not match parameter '%2'")
                            .arg(cfg.physicalScreenId, expectedPhysicalScreenId));
        }
 
        if (cfg.screens.size() < 2) {
            return fail(QStringLiteral("need at least 2 screens for subdivision, got %1").arg(cfg.screens.size()));
        }
 
        if (maxScreensPerPhysical > 0 && cfg.screens.size() > maxScreensPerPhysical) {
            return fail(QStringLiteral("too many virtual screens %1 (max %2)")
                            .arg(cfg.screens.size())
                            .arg(maxScreensPerPhysical));
        }
 
        QSet<QString> seenIds;
        QSet<int> seenIndices;
        for (const auto& def : cfg.screens) {
            if (!def.isValid()) {
                return fail(QStringLiteral("invalid VirtualScreenDef id='%1' region=(%2,%3 %4x%5)")
                                .arg(def.id)
                                .arg(def.region.x())
                                .arg(def.region.y())
                                .arg(def.region.width())
                                .arg(def.region.height()));
            }
            if (def.physicalScreenId != cfg.physicalScreenId) {
                return fail(QStringLiteral("def.physicalScreenId '%1' does not match config '%2' for def '%3'")
                                .arg(def.physicalScreenId, cfg.physicalScreenId, def.id));
            }
            const QString expectedId = PhosphorIdentity::VirtualScreenId::make(cfg.physicalScreenId, def.index);
            if (def.id != expectedId) {
                return fail(QStringLiteral("def.id '%1' does not match expected '%2' for index %3")
                                .arg(def.id, expectedId)
                                .arg(def.index));
            }
            if (seenIds.contains(def.id)) {
                return fail(QStringLiteral("duplicate def.id %1").arg(def.id));
            }
            seenIds.insert(def.id);
            if (seenIndices.contains(def.index)) {
                return fail(QStringLiteral("duplicate def.index %1").arg(def.index));
            }
            seenIndices.insert(def.index);
        }
 
        // Pairwise overlap check (tolerance-aware).
        for (int i = 0; i < cfg.screens.size(); ++i) {
            for (int j = i + 1; j < cfg.screens.size(); ++j) {
                const QRectF intersection = cfg.screens[i].region.intersected(cfg.screens[j].region);
                if (intersection.width() > VirtualScreenDef::Tolerance
                    && intersection.height() > VirtualScreenDef::Tolerance) {
                    return fail(QStringLiteral("overlapping regions between '%1' and '%2'")
                                    .arg(cfg.screens[i].id, cfg.screens[j].id));
                }
            }
        }
 
        // Total area must approximately cover the unit square.
        qreal totalArea = 0.0;
        for (const auto& def : cfg.screens) {
            totalArea += def.region.width() * def.region.height();
        }
        const qreal lower = 1.0 - VirtualScreenDef::Tolerance;
        const qreal upper = 1.0 + VirtualScreenDef::Tolerance;
        if (totalArea < lower) {
            return fail(QStringLiteral("insufficient coverage for '%1' — total area %2 < %3")
                            .arg(cfg.physicalScreenId)
                            .arg(totalArea)
                            .arg(lower));
        }
        if (totalArea > upper) {
            return fail(QStringLiteral("excessive coverage for '%1' — total area %2 > %3")
                            .arg(cfg.physicalScreenId)
                            .arg(totalArea)
                            .arg(upper));
        }
 
        return true;
    }
 
    bool swapRegions(const QString& idA, const QString& idB)
    {
        if (idA == idB) {
            return false;
        }
        int indexA = -1;
        int indexB = -1;
        for (int i = 0; i < screens.size(); ++i) {
            if (screens[i].id == idA) {
                indexA = i;
            } else if (screens[i].id == idB) {
                indexB = i;
            }
        }
        if (indexA < 0 || indexB < 0) {
            return false;
        }
        std::swap(screens[indexA].region, screens[indexB].region);
        return true;
    }
 
    bool rotateRegions(const QVector<QString>& orderedIds, bool clockwise)
    {
        if (orderedIds.size() < 2) {
            return false;
        }
        QSet<QString> seenIds;
        seenIds.reserve(orderedIds.size());
        QVector<int> defIndices;
        defIndices.reserve(orderedIds.size());
        for (const auto& id : orderedIds) {
            if (seenIds.contains(id)) {
                return false; // duplicate id in orderedIds
            }
            seenIds.insert(id);
            int found = -1;
            for (int i = 0; i < screens.size(); ++i) {
                if (screens[i].id == id) {
                    found = i;
                    break;
                }
            }
            if (found < 0) {
                return false;
            }
            defIndices.append(found);
        }
        const int n = defIndices.size();
        QVector<QRectF> regions;
        regions.reserve(n);
        for (int idx : defIndices) {
            regions.append(screens[idx].region);
        }
        for (int i = 0; i < n; ++i) {
            const int src = clockwise ? (i + 1) % n : (i - 1 + n) % n;
            screens[defIndices[i]].region = regions[src];
        }
        return true;
    }
};
 
} // namespace Phosphor::Screens