WindowPlacement.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorEngine/EngineTypes.h>
 
#include <QHash>
#include <QJsonArray>
#include <QJsonObject>
#include <QLatin1String>
#include <QRect>
#include <QString>
#include <QStringList>
 
#include <utility>
 
namespace PhosphorEngine {
 
struct EngineSlot
{
    QString state; 
    QStringList zoneIds; 
    int order = -1; 
 
    bool operator==(const EngineSlot& o) const
    {
        return state == o.state && zoneIds == o.zoneIds && order == o.order;
    }
    bool operator!=(const EngineSlot& o) const
    {
        return !(*this == o);
    }
    bool isEmpty() const
    {
        return state.isEmpty();
    }
};
 
struct WindowPlacement
{
    // ── Identity (the two store keys) ──
    QString windowId; 
    QString appId; 
 
    // ── Context (the universal restore + disabled-context gate) ──
    QString screenId; 
    int virtualDesktop = 0;
    QString activity; 
    WindowKind kind = WindowKind::Unknown;
 
    // ── Per-engine managed state, keyed by engineId() ──
    QHash<QString, EngineSlot> engines;
 
    // ── Shared free/float geometry, keyed by screenId ──
    QHash<QString, QRect> freeGeometryByScreen;
 
    // ── Recency (most-recent-wins ordering; stamped by the store) ──
    quint64 sequence = 0;
 
    bool isValid() const
    {
        return !windowId.isEmpty() && !appId.isEmpty();
    }
 
    EngineSlot slotFor(const QString& engineId) const
    {
        return engines.value(engineId);
    }
 
    QRect freeGeometryFor(const QString& screenId) const
    {
        return freeGeometryByScreen.value(screenId);
    }
 
    QString anyFreeGeometryScreenId() const
    {
        QString best;
        for (auto it = freeGeometryByScreen.constBegin(); it != freeGeometryByScreen.constEnd(); ++it) {
            if (it.value().isValid() && (best.isEmpty() || it.key() < best)) {
                best = it.key();
            }
        }
        return best;
    }
 
    QRect anyFreeGeometry() const
    {
        return freeGeometryByScreen.value(anyFreeGeometryScreenId());
    }
 
    bool hasRestorableContent() const
    {
        if (anyFreeGeometry().isValid()) {
            return true;
        }
        for (auto it = engines.constBegin(); it != engines.constEnd(); ++it) {
            const EngineSlot& s = it.value();
            if (s.state == stateSnapped() || s.state == stateTiled()) {
                return true;
            }
            if (!s.zoneIds.isEmpty() || s.order >= 0) {
                return true;
            }
        }
        return false;
    }
 
    bool sameContentAs(const WindowPlacement& o) const
    {
        return windowId == o.windowId && appId == o.appId && screenId == o.screenId
            && virtualDesktop == o.virtualDesktop && activity == o.activity && kind == o.kind && engines == o.engines
            && freeGeometryByScreen == o.freeGeometryByScreen;
    }
 
    static QLatin1String snapEngineId()
    {
        return QLatin1String("snap");
    }
    static QLatin1String autotileEngineId()
    {
        return QLatin1String("autotile");
    }
    static QLatin1String scrollingEngineId()
    {
        return QLatin1String("scrolling");
    }
 
    static QLatin1String stateFree()
    {
        return QLatin1String("free");
    }
    static QLatin1String stateFloating()
    {
        return QLatin1String("floating");
    }
    static QLatin1String stateSnapped()
    {
        return QLatin1String("snapped");
    }
    static QLatin1String stateTiled()
    {
        return QLatin1String("tiled");
    }
    static QLatin1String stateReleased()
    {
        return QLatin1String("released");
    }
 
    QJsonObject toJson() const
    {
        QJsonObject obj;
        obj[QLatin1String("windowId")] = windowId;
        obj[QLatin1String("screen")] = screenId;
        obj[QLatin1String("desktop")] = virtualDesktop;
        if (!activity.isEmpty()) {
            obj[QLatin1String("activity")] = activity;
        }
        obj[QLatin1String("kind")] = static_cast<int>(kind);
 
        QJsonObject eng;
        for (auto it = engines.constBegin(); it != engines.constEnd(); ++it) {
            const EngineSlot& s = it.value();
            if (s.isEmpty()) {
                continue;
            }
            QJsonObject so;
            so[QLatin1String("state")] = s.state;
            if (!s.zoneIds.isEmpty()) {
                QJsonArray z;
                for (const QString& id : s.zoneIds) {
                    z.append(id);
                }
                so[QLatin1String("zoneIds")] = z;
            }
            if (s.order >= 0) {
                so[QLatin1String("order")] = s.order;
            }
            eng[it.key()] = so;
        }
        if (!eng.isEmpty()) {
            obj[QLatin1String("engines")] = eng;
        }
 
        QJsonObject fg;
        for (auto it = freeGeometryByScreen.constBegin(); it != freeGeometryByScreen.constEnd(); ++it) {
            const QRect& g = it.value();
            if (!g.isValid()) {
                continue;
            }
            QJsonObject go;
            go[QLatin1String("x")] = g.x();
            go[QLatin1String("y")] = g.y();
            go[QLatin1String("w")] = g.width();
            go[QLatin1String("h")] = g.height();
            fg[it.key()] = go;
        }
        if (!fg.isEmpty()) {
            obj[QLatin1String("freeGeo")] = fg;
        }
 
        obj[QLatin1String("seq")] = static_cast<double>(sequence);
        return obj;
    }
 
    static WindowPlacement fromJson(const QString& appId, const QJsonObject& obj)
    {
        WindowPlacement p;
        p.appId = appId;
        p.windowId = obj.value(QLatin1String("windowId")).toString();
        p.screenId = obj.value(QLatin1String("screen")).toString();
        p.virtualDesktop = obj.value(QLatin1String("desktop")).toInt();
        p.activity = obj.value(QLatin1String("activity")).toString();
        p.kind = clampWindowKindFromWire(obj.value(QLatin1String("kind")).toInt());
 
        const QJsonObject eng = obj.value(QLatin1String("engines")).toObject();
        for (auto it = eng.constBegin(); it != eng.constEnd(); ++it) {
            const QJsonObject so = it.value().toObject();
            EngineSlot s;
            s.state = so.value(QLatin1String("state")).toString();
            for (const QJsonValue& v : so.value(QLatin1String("zoneIds")).toArray()) {
                const QString z = v.toString();
                if (!z.isEmpty()) {
                    s.zoneIds.append(z);
                }
            }
            s.order = so.value(QLatin1String("order")).toInt(-1);
            if (!s.isEmpty()) {
                p.engines.insert(it.key(), s);
            }
        }
 
        const QJsonObject fg = obj.value(QLatin1String("freeGeo")).toObject();
        for (auto it = fg.constBegin(); it != fg.constEnd(); ++it) {
            const QJsonObject go = it.value().toObject();
            const QRect g(go.value(QLatin1String("x")).toInt(), go.value(QLatin1String("y")).toInt(),
                          go.value(QLatin1String("w")).toInt(), go.value(QLatin1String("h")).toInt());
            if (g.isValid()) {
                p.freeGeometryByScreen.insert(it.key(), g);
            }
        }
 
        p.sequence = static_cast<quint64>(obj.value(QLatin1String("seq")).toDouble());
        return p;
    }
};
 
inline bool hasStableAppIdFor(const QString& appId, const QString& windowId)
{
    return !appId.isEmpty() && appId != windowId;
}
 
inline bool recordContextMatchesLive(const WindowPlacement& p, int liveDesktop, const QString& liveActivity)
{
    if (p.virtualDesktop != 0 && liveDesktop != 0 && p.virtualDesktop != liveDesktop) {
        return false;
    }
    return p.activity.isEmpty() || liveActivity.isEmpty() || p.activity == liveActivity;
}
 
template<typename IsEngineMode>
bool pendingCrossScreenManagedRestore(const WindowPlacement& p, QLatin1String engineId, QLatin1String managedState,
                                      const QString& openingScreenId, IsEngineMode&& isEngineMode)
{
    if (p.slotFor(engineId).state != managedState) {
        return false;
    }
    if (p.screenId.isEmpty() || p.screenId == openingScreenId) {
        return false; // same screen (or unscreened): the opening context's engine owns it
    }
    return isEngineMode(p.screenId, p.virtualDesktop, p.activity);
}
 
template<typename IsSnappingMode>
bool pendingCrossScreenSnapRestore(const WindowPlacement& p, const QString& openingScreenId,
                                   IsSnappingMode&& isSnappingMode)
{
    return pendingCrossScreenManagedRestore(p, WindowPlacement::snapEngineId(), WindowPlacement::stateSnapped(),
                                            openingScreenId, std::forward<IsSnappingMode>(isSnappingMode));
}
 
} // namespace PhosphorEngine