TilingState.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <QColor>
#include <QHash>
#include <QPair>
#include <QRect>
#include <QRectF>
#include <QSet>
#include <QString>
#include <QVector>
 
namespace PhosphorCompositor {
 
struct BorderState
{
    QHash<QString, QSet<QString>> tiledWindowsByScreen;
};
 
namespace TilingStateHelpers {
 
// ═══════════════════════════════════════════════════════════════════════════════
// Border state accessors (pure data queries)
// ═══════════════════════════════════════════════════════════════════════════════
 
inline QString screenForTiledWindow(const BorderState& border, const QString& windowId)
{
    for (auto it = border.tiledWindowsByScreen.constBegin(); it != border.tiledWindowsByScreen.constEnd(); ++it) {
        if (it.value().contains(windowId)) {
            return it.key();
        }
    }
    return QString();
}
 
// Deliberately its OWN loop rather than screenForTiledWindow(...).isEmpty():
// membership must stay a pure "is it in any bucket" test. Routing it through
// the screen lookup would make a window held under an empty screen key read as
// untiled, and this predicate has far more callers than that refactor is worth.
inline bool isTiledWindow(const BorderState& border, const QString& windowId)
{
    for (auto it = border.tiledWindowsByScreen.constBegin(); it != border.tiledWindowsByScreen.constEnd(); ++it) {
        if (it.value().contains(windowId)) {
            return true;
        }
    }
    return false;
}
 
// ═══════════════════════════════════════════════════════════════════════════════
// Window closed cleanup (pure state bookkeeping)
// ═══════════════════════════════════════════════════════════════════════════════
 
struct TilingWindowState
{
    QSet<QString>& notifiedWindows;
    QHash<QString, QString>& notifiedWindowScreens;
    QSet<QString>& minimizeFloatedWindows;
    QHash<QString, QRect>& tileTargetZones;
    QHash<QString, QRect>& centeredWaylandZones;
    QSet<QString>& monocleMaximizedWindows;
    QHash<QString, QHash<QString, QRectF>>& preTileGeometries;
};
 
inline void cleanupClosedWindowState(const QString& windowId, BorderState& border, TilingWindowState& state)
{
    state.notifiedWindows.remove(windowId);
    state.notifiedWindowScreens.remove(windowId);
    state.minimizeFloatedWindows.remove(windowId);
    state.tileTargetZones.remove(windowId);
    state.centeredWaylandZones.remove(windowId);
    state.monocleMaximizedWindows.remove(windowId);
    // Closed windows must be removed from every screen bucket — the effect
    // may have stale entries if the window crossed screens before closing.
    for (auto it = border.tiledWindowsByScreen.begin(); it != border.tiledWindowsByScreen.end();) {
        it.value().remove(windowId);
        if (it.value().isEmpty()) {
            it = border.tiledWindowsByScreen.erase(it);
        } else {
            ++it;
        }
    }
 
    // Sweep the pre-tile geometry out of EVERY screen bucket — the same
    // cross-screen-stale scenario the tiled sweep above defends against
    // (the window crossed screens before closing) would otherwise leak a
    // geometry entry in the old screen's bucket forever.
    for (auto it = state.preTileGeometries.begin(); it != state.preTileGeometries.end();) {
        it->remove(windowId);
        if (it->isEmpty()) {
            it = state.preTileGeometries.erase(it);
        } else {
            ++it;
        }
    }
}
 
// ═══════════════════════════════════════════════════════════════════════════════
// Per-screen BorderState mutators
// ═══════════════════════════════════════════════════════════════════════════════
 
inline void addTiledOnScreen(BorderState& border, const QString& screenId, const QString& windowId)
{
    border.tiledWindowsByScreen[screenId].insert(windowId);
}
 
inline bool removeTiledOnScreen(BorderState& border, const QString& screenId, const QString& windowId)
{
    auto it = border.tiledWindowsByScreen.find(screenId);
    if (it == border.tiledWindowsByScreen.end()) {
        return false;
    }
    const bool removed = it.value().remove(windowId);
    if (it.value().isEmpty()) {
        border.tiledWindowsByScreen.erase(it);
    }
    return removed;
}
 
inline void removeFromOtherScreens(BorderState& border, const QString& windowId, const QString& keepScreenId)
{
    for (auto it = border.tiledWindowsByScreen.begin(); it != border.tiledWindowsByScreen.end();) {
        if (it.key() != keepScreenId) {
            it.value().remove(windowId);
        }
        // The keep-bucket exclusion below is defensive symmetry only: this
        // function never mutates the keep bucket, so an empty keep bucket
        // could only pre-exist (and every other mutator erases empty
        // buckets on the way out).
        if (it.value().isEmpty() && it.key() != keepScreenId) {
            it = border.tiledWindowsByScreen.erase(it);
        } else {
            ++it;
        }
    }
}
 
inline bool removeFromAllScreens(BorderState& border, const QString& windowId)
{
    bool any = false;
    for (auto it = border.tiledWindowsByScreen.begin(); it != border.tiledWindowsByScreen.end();) {
        if (it.value().remove(windowId)) {
            any = true;
        }
        if (it.value().isEmpty()) {
            it = border.tiledWindowsByScreen.erase(it);
        } else {
            ++it;
        }
    }
    return any;
}
 
inline QSet<QString> tiledOnScreen(const BorderState& border, const QString& screenId)
{
    return border.tiledWindowsByScreen.value(screenId);
}
 
} // namespace TilingStateHelpers
} // namespace PhosphorCompositor