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; 
    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> 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<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
            && activity == other.activity && windowType == other.windowType && isMinimized == other.isMinimized
            && 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
            && 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;
    Q_INVOKABLE QString appIdFor(const QString& instanceId) const override;
    QStringList instancesWithAppId(const QString& appId) const;
    bool contains(const QString& instanceId) const;
    QStringList allInstances() const;
    int size() const;
    void clear();
 
    Q_INVOKABLE QString canonicalizeWindowId(const QString& rawWindowId) override;
    Q_INVOKABLE QString canonicalizeForLookup(const QString& rawWindowId) const override;
    void releaseCanonical(const QString& anyWindowId);
 
    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;
 
    void indexInsert(const QString& instanceId, const QString& appId);
    void indexRemove(const QString& instanceId, const QString& appId);
};
 
} // namespace PhosphorEngine