ShellHost.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
// ShellHost - owns the per-screen layer-shell shell-state map and the
// lifecycle bookkeeping (create / destroy / rekey / sync) that any
// multi-slot overlay consumer needs.
//
// Phase 2 foundation: the type holds a `QHash<QString, ShellState>`
// keyed by effective screen id plus a sticky creation-failure set
// (spam-guard for compositors that refuse a shell on a given screen).
// Method moves from OverlayService land in subsequent Phase 2 commits;
// this commit pins the shape of the public type and its accessors so
// the daemon can construct a ShellHost as a member alongside its
// existing per-screen state.
 
#include <PhosphorOverlay/ShellState.h>
#include <PhosphorOverlay/phosphoroverlay_export.h>
 
#include <PhosphorAnimation/SurfaceAnimator.h>
#include <PhosphorLayer/Role.h>
 
#include <QHash>
#include <QObject>
#include <QSet>
#include <QString>
#include <QStringList>
#include <QStringView>
 
#include <functional>
 
class QScreen;
 
namespace PhosphorLayer {
class Surface;
} // namespace PhosphorLayer
 
namespace PhosphorOverlay {
 
[[nodiscard]] PHOSPHOROVERLAY_EXPORT PhosphorLayer::Role makePerInstanceRole(const PhosphorLayer::Role& base,
                                                                             QStringView screenId, quint64 generation);
 
class PHOSPHOROVERLAY_EXPORT ShellHost : public QObject
{
    Q_OBJECT
 
public:
    using SurfaceFactory = std::function<PhosphorLayer::Surface*(const QString& screenId, QScreen* physScreen)>;
 
    using PostCreateCallback = std::function<void(const QString& screenId, ShellState& state)>;
 
    using PreDestroyCallback = std::function<void(const QString& screenId)>;
 
    explicit ShellHost(QObject* parent = nullptr);
    ~ShellHost() override;
 
    void setSurfaceFactory(SurfaceFactory factory);
 
    void setPostCreateCallback(PostCreateCallback callback);
 
    void setPreDestroyCallback(PreDestroyCallback callback);
 
    void setSurfaceAnimator(PhosphorAnimationLayer::SurfaceAnimator* animator);
 
    ShellState* ensureShell(const QString& screenId, QScreen* physScreen);
 
    void destroyShell(const QString& screenId);
 
    void syncSurfaceState(const QString& screenId, bool anyVisible, bool anyInputGrabbing);
 
    bool rekey(const QString& oldKey, const QString& newKey);
 
    void registerConfigForRole(const PhosphorLayer::Role& role, PhosphorAnimationLayer::SurfaceAnimator::Config config);
 
    void hideSlot(const QString& screenId, const QString& slotKey, std::function<void()> completion = {});
 
    ShellState& stateFor(const QString& screenId);
 
    const ShellState* stateFor(const QString& screenId) const;
 
    bool hasState(const QString& screenId) const;
 
    void removeState(const QString& screenId);
 
    QStringList screenIds() const;
 
    void markFailure(const QString& screenId);
    void clearFailure(const QString& screenId);
    bool hasFailure(const QString& screenId) const;
 
    QStringList failureScreenIds() const;
 
private:
    QHash<QString, ShellState*> m_states;
    QSet<QString> m_creationFailed;
    SurfaceFactory m_surfaceFactory;
    PostCreateCallback m_postCreateCallback;
    PreDestroyCallback m_preDestroyCallback;
    PhosphorAnimationLayer::SurfaceAnimator* m_surfaceAnimator = nullptr;
};
 
} // namespace PhosphorOverlay