AutotileState.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorCompositor/DecorationDefaults.h>
 
#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;
    // Defaults shared with the daemon's ConfigDefaults via DecorationDefaults
    // so the effect's pre-settings-load rendering can't drift from what the
    // daemon would persist.
    bool hideTitleBars = DecorationDefaults::HideTitleBars;
    bool showBorder = DecorationDefaults::ShowBorder;
    int width = DecorationDefaults::BorderWidth;
    int radius = DecorationDefaults::BorderRadius;
    QColor color;
    QColor inactiveColor;
};
 
namespace AutotileStateHelpers {
 
// ═══════════════════════════════════════════════════════════════════════════════
// Border state accessors (pure data queries)
// ═══════════════════════════════════════════════════════════════════════════════
 
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;
}
 
inline bool shouldShowBorderForWindow(const BorderState& border, const QString& windowId)
{
    return border.showBorder && isTiledWindow(border, windowId);
}
 
// ═══════════════════════════════════════════════════════════════════════════════
// Window closed cleanup (pure state bookkeeping)
// ═══════════════════════════════════════════════════════════════════════════════
 
struct AutotileWindowState
{
    QSet<QString>& notifiedWindows;
    QHash<QString, QString>& notifiedWindowScreens;
    QSet<QString>& minimizeFloatedWindows;
    QHash<QString, QRect>& autotileTargetZones;
    QHash<QString, QRect>& centeredWaylandZones;
    QSet<QString>& monocleMaximizedWindows;
    QHash<QString, QHash<QString, QRectF>>& preAutotileGeometries;
};
 
inline void cleanupClosedWindowState(const QString& windowId, BorderState& border, AutotileWindowState& state)
{
    state.notifiedWindows.remove(windowId);
    state.notifiedWindowScreens.remove(windowId);
    state.minimizeFloatedWindows.remove(windowId);
    state.autotileTargetZones.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-autotile 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.preAutotileGeometries.begin(); it != state.preAutotileGeometries.end();) {
        it->remove(windowId);
        if (it->isEmpty()) {
            it = state.preAutotileGeometries.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);
}
 
inline QVector<QPair<QString, QString>> allTiledPairs(const BorderState& border)
{
    QVector<QPair<QString, QString>> result;
    for (auto it = border.tiledWindowsByScreen.constBegin(); it != border.tiledWindowsByScreen.constEnd(); ++it) {
        for (const QString& wid : it.value()) {
            result.append({wid, it.key()});
        }
    }
    return result;
}
 
} // namespace AutotileStateHelpers
} // namespace PhosphorCompositor