AutotileState.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>
#include <optional>
 
namespace PhosphorCompositor {
 
struct BorderState
{
    QHash<QString, QSet<QString>> borderlessWindowsByScreen;
    QHash<QString, QSet<QString>> tiledWindowsByScreen;
    QHash<QString, QRect> zoneGeometries;
    bool hideTitleBars = false;
    bool showBorder = false;
    int width = 2;
    int radius = 0;
    QColor color;
    QColor inactiveColor;
};
 
namespace AutotileStateHelpers {
 
// ═══════════════════════════════════════════════════════════════════════════════
// Saved geometry helpers (pure QHash operations)
// ═══════════════════════════════════════════════════════════════════════════════
 
inline QString findSavedGeometryKey(const QHash<QString, QRectF>& savedGeometries, const QString& windowId)
{
    auto it = savedGeometries.constFind(windowId);
    if (it != savedGeometries.constEnd()) {
        return it.key();
    }
    return QString();
}
 
inline bool hasSavedGeometryForWindow(const QHash<QString, QRectF>& savedGeometries, const QString& windowId)
{
    return !findSavedGeometryKey(savedGeometries, windowId).isEmpty();
}
 
// ═══════════════════════════════════════════════════════════════════════════════
// Border state accessors (pure data queries)
// ═══════════════════════════════════════════════════════════════════════════════
 
inline bool isBorderlessWindow(const BorderState& border, const QString& windowId)
{
    for (auto it = border.borderlessWindowsByScreen.constBegin(); it != border.borderlessWindowsByScreen.constEnd();
         ++it) {
        if (it.value().contains(windowId)) {
            return true;
        }
    }
    return false;
}
 
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)
{
    if (!border.showBorder)
        return false;
    return isBorderlessWindow(border, windowId) || isTiledWindow(border, windowId);
}
 
inline bool shouldApplyBorderInset(const BorderState& border, const QString& windowId)
{
    return border.hideTitleBars && border.width > 0 && isBorderlessWindow(border, windowId);
}
 
inline std::optional<QRect> borderZoneGeometry(const BorderState& border, const QString& windowId)
{
    auto it = border.zoneGeometries.constFind(windowId);
    if (it != border.zoneGeometries.constEnd()) {
        return it.value();
    }
    return std::nullopt;
}
 
inline QVector<QRect> allBorderZoneGeometries(const BorderState& border)
{
    QVector<QRect> result;
    result.reserve(border.zoneGeometries.size());
    for (auto it = border.zoneGeometries.constBegin(); it != border.zoneGeometries.constEnd(); ++it) {
        result.append(it.value());
    }
    return result;
}
 
inline QRect applyBorderInset(const QRect& geo, int borderWidth)
{
    return geo.adjusted(borderWidth, borderWidth, -borderWidth, -borderWidth);
}
 
inline bool shouldInsetForBorder(const BorderState& border, const QString& windowId, const QRect& geo)
{
    return shouldApplyBorderInset(border, windowId) && geo.width() > border.width * 2
        && geo.height() > border.width * 2;
}
 
// ═══════════════════════════════════════════════════════════════════════════════
// 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, const QString& screenId, 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.borderlessWindowsByScreen.begin(); it != border.borderlessWindowsByScreen.end();) {
        it.value().remove(windowId);
        if (it.value().isEmpty()) {
            it = border.borderlessWindowsByScreen.erase(it);
        } else {
            ++it;
        }
    }
    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;
        }
    }
    border.zoneGeometries.remove(windowId);
 
    if (!screenId.isEmpty()) {
        auto it = state.preAutotileGeometries.find(screenId);
        if (it != state.preAutotileGeometries.end()) {
            it->remove(windowId);
        }
    }
}
 
// ═══════════════════════════════════════════════════════════════════════════════
// Per-screen BorderState mutators
// ═══════════════════════════════════════════════════════════════════════════════
 
inline void addBorderlessOnScreen(BorderState& border, const QString& screenId, const QString& windowId)
{
    border.borderlessWindowsByScreen[screenId].insert(windowId);
}
 
inline void addTiledOnScreen(BorderState& border, const QString& screenId, const QString& windowId)
{
    border.tiledWindowsByScreen[screenId].insert(windowId);
}
 
inline bool removeBorderlessOnScreen(BorderState& border, const QString& screenId, const QString& windowId)
{
    auto it = border.borderlessWindowsByScreen.find(screenId);
    if (it == border.borderlessWindowsByScreen.end()) {
        return false;
    }
    const bool removed = it.value().remove(windowId);
    if (it.value().isEmpty()) {
        border.borderlessWindowsByScreen.erase(it);
    }
    return removed;
}
 
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 bool removeFromAllScreens(BorderState& border, const QString& windowId)
{
    bool any = false;
    for (auto it = border.borderlessWindowsByScreen.begin(); it != border.borderlessWindowsByScreen.end();) {
        if (it.value().remove(windowId)) {
            any = true;
        }
        if (it.value().isEmpty()) {
            it = border.borderlessWindowsByScreen.erase(it);
        } else {
            ++it;
        }
    }
    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 QSet<QString> borderlessOnScreen(const BorderState& border, const QString& screenId)
{
    return border.borderlessWindowsByScreen.value(screenId);
}
 
inline QVector<QPair<QString, QString>> allBorderlessPairs(const BorderState& border)
{
    QVector<QPair<QString, QString>> result;
    for (auto it = border.borderlessWindowsByScreen.constBegin(); it != border.borderlessWindowsByScreen.constEnd();
         ++it) {
        for (const QString& wid : it.value()) {
            result.append({wid, it.key()});
        }
    }
    return result;
}
 
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