FloatingCache.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorIdentity/WindowId.h>
 
#include <QSet>
#include <QString>
 
namespace PhosphorCompositor {
 
class FloatingCache
{
public:
    bool isFloating(const QString& windowId) const
    {
        // Instance-specific float — survives appId (class) mutation.
        if (m_byInstance.contains(::PhosphorIdentity::WindowId::extractInstanceId(windowId))) {
            return true;
        }
        // App-wide float — a bare appId matches every instance of that app.
        return m_byAppId.contains(::PhosphorIdentity::WindowId::extractAppId(windowId));
    }
 
    bool setFloating(const QString& windowId, bool floating)
    {
        const QString appId = ::PhosphorIdentity::WindowId::extractAppId(windowId);
        const bool isComposite = (appId != windowId); // bare appId has no separator
        if (isComposite) {
            const QString instanceId = ::PhosphorIdentity::WindowId::extractInstanceId(windowId);
            // A composite with an empty instanceId ("appId|") is malformed: keying
            // it would alias every other empty-instance window onto one wildcard
            // slot. Reject rather than corrupt the cache.
            if (instanceId.isEmpty()) {
                return false;
            }
            if (floating) {
                if (m_byInstance.contains(instanceId)) {
                    return false;
                }
                m_byInstance.insert(instanceId);
                return true;
            }
            const bool removedInstance = m_byInstance.remove(instanceId);
            // Mirror WindowTrackingService::setFloating: an explicit instance
            // unfloat also drops the coarse app-wide fallback. Siblings keep
            // their own instance entries, so this only clears the appId marker.
            const bool removedAppId = m_byAppId.remove(appId);
            return removedInstance || removedAppId;
        }
        // Bare appId keyspace. Reject an empty id (no separator, nothing before
        // it) the same way the composite branch rejects an empty instanceId —
        // an empty key would alias every empty-id window onto one wildcard slot.
        if (windowId.isEmpty()) {
            return false;
        }
        if (floating) {
            if (m_byAppId.contains(windowId)) {
                return false;
            }
            m_byAppId.insert(windowId);
            return true;
        }
        return m_byAppId.remove(windowId);
    }
 
    void clear()
    {
        m_byInstance.clear();
        m_byAppId.clear();
    }
 
    int size() const
    {
        return m_byInstance.size() + m_byAppId.size();
    }
 
    bool insert(const QString& windowId)
    {
        return setFloating(windowId, true);
    }
 
    bool remove(const QString& windowId)
    {
        return setFloating(windowId, false);
    }
 
private:
    QSet<QString> m_byInstance; 
    QSet<QString> m_byAppId; 
};
 
} // namespace PhosphorCompositor