WindowRegistry.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorEngine/IWindowRegistry.h>
#include <PhosphorProtocol/WindowTypeEnum.h>
#include <phosphorengine_export.h>
#include <QHash>
#include <QMultiHash>
#include <QObject>
#include <QSet>
#include <QString>
#include <QStringList>
#include <optional>
 
namespace PhosphorEngine {
 
struct WindowMetadata
{
    QString appId;
    QString desktopFile;
    QString title;
    QString windowRole{}; 
    int pid = 0; 
    int virtualDesktop = 0; 
    QList<int> virtualDesktops{};
    QString activity{}; 
    PhosphorProtocol::WindowType windowType = PhosphorProtocol::WindowType::Unknown;
 
    // ── Extended window properties. The kwin-effect snapshots these at metadata-push
    // time so the daemon's window-rule resolvers (shouldFloatByRule /
    // shouldRestoreFloatedPosition) can match the same KWin-property / geometry
    // fields the effect path resolves live. std::optional so an absent value (the
    // compositor could not report it — e.g. no underlying KWin::Window) leaves the
    // corresponding WindowQuery field disengaged, keeping a predicate over it inert,
    // mirroring window_query.cpp's engage-only-when-known contract. ──
    std::optional<bool> isMinimized{}; 
    std::optional<bool> isDemandingAttention{}; 
    std::optional<bool> isFullscreen{};
    std::optional<bool> isSticky{}; 
    std::optional<bool> isMaximized{}; 
    std::optional<bool> isFocused{}; 
    std::optional<bool> isTransient{}; 
    std::optional<bool> isNotification{}; 
    std::optional<bool> keepAbove{};
    std::optional<bool> keepBelow{};
    std::optional<bool> skipTaskbar{};
    std::optional<bool> skipPager{};
    std::optional<bool> skipSwitcher{};
    std::optional<bool> isModal{};
    std::optional<bool> hasDecoration{}; 
    std::optional<bool> isResizable{};
    std::optional<bool> isMovable{}; 
    std::optional<bool> isMaximizable{}; 
    std::optional<int> width{}; 
    std::optional<int> height{}; 
    std::optional<int> positionX{}; 
    std::optional<int> positionY{}; 
    std::optional<QString> captionNormal{}; 
 
    bool operator==(const WindowMetadata& other) const
    {
        return appId == other.appId && desktopFile == other.desktopFile && title == other.title
            && windowRole == other.windowRole && pid == other.pid && virtualDesktop == other.virtualDesktop
            && virtualDesktops == other.virtualDesktops && activity == other.activity && windowType == other.windowType
            && isMinimized == other.isMinimized && isDemandingAttention == other.isDemandingAttention
            && isFullscreen == other.isFullscreen && isSticky == other.isSticky && isMaximized == other.isMaximized
            && isFocused == other.isFocused && isTransient == other.isTransient
            && isNotification == other.isNotification && keepAbove == other.keepAbove && keepBelow == other.keepBelow
            && skipTaskbar == other.skipTaskbar && skipPager == other.skipPager && skipSwitcher == other.skipSwitcher
            && isModal == other.isModal && hasDecoration == other.hasDecoration && isResizable == other.isResizable
            && isMovable == other.isMovable && isMaximizable == other.isMaximizable && width == other.width
            && height == other.height && positionX == other.positionX && positionY == other.positionY
            && captionNormal == other.captionNormal;
    }
    bool operator!=(const WindowMetadata& other) const
    {
        return !(*this == other);
    }
};
 
class PHOSPHORENGINE_EXPORT WindowRegistry : public QObject, public IWindowRegistry
{
    Q_OBJECT
 
public:
    explicit WindowRegistry(QObject* parent = nullptr);
    ~WindowRegistry() override;
 
    void upsert(const QString& instanceId, const WindowMetadata& metadata);
    void remove(const QString& instanceId);
 
    std::optional<WindowMetadata> metadata(const QString& instanceId) const;
    struct WindowContext
    {
        int virtualDesktop = 0;
        QList<int> virtualDesktops;
        QString activity;
 
        int effectiveDesktop(int screenCurrentDesktop) const
        {
            if (virtualDesktops.size() > 1 && virtualDesktops.contains(screenCurrentDesktop)) {
                return screenCurrentDesktop;
            }
            return virtualDesktop > 0 ? virtualDesktop : screenCurrentDesktop;
        }
 
        QString effectiveActivity(const QString& currentActivity) const
        {
            return activity.isEmpty() ? currentActivity : activity;
        }
    };
    std::optional<WindowContext> windowContext(const QString& instanceId) const;
    Q_INVOKABLE QString appIdFor(const QString& instanceId) const override;
    bool isMinimized(const QString& windowId) const;
    std::optional<bool> minimizedState(const QString& windowId) const override;
    QStringList instancesWithAppId(const QString& appId) const;
    bool contains(const QString& instanceId) const;
    int size() const;
    void clear();
 
    Q_INVOKABLE QString canonicalizeWindowId(const QString& rawWindowId) override;
    Q_INVOKABLE QString canonicalizeForLookup(const QString& rawWindowId) const override;
 
    int pruneStaleInstances(const QSet<QString>& aliveInstanceIds);
 
Q_SIGNALS:
    void windowAppeared(const QString& instanceId);
    void metadataChanged(const QString& instanceId, const WindowMetadata& oldMetadata,
                         const WindowMetadata& newMetadata);
    void windowDisappeared(const QString& instanceId);
 
private:
    QHash<QString, WindowMetadata> m_records;
    QMultiHash<QString, QString> m_appIdIndex;
    QHash<QString, QString> m_canonicalByInstance;
    QSet<QString> m_disappearingInstances;
    QHash<QString, WindowMetadata> m_pendingUpserts;
    int m_clearing = 0;
 
    void indexInsert(const QString& instanceId, const QString& appId);
    void indexRemove(const QString& instanceId, const QString& appId);
};
 
} // namespace PhosphorEngine