compositor.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2011 Arthur Arlt <a.arlt@stud.uni-heidelberg.de>
    SPDX-FileCopyrightText: 2012 Martin Gräßlin <mgraesslin@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
#pragma once
 
#include <kwin_export.h>
#include <xcb/xcb.h>
 
#include <QHash>
#include <QObject>
#include <QRegion>
#include <QTimer>
#include <memory>
 
namespace KWin
{
 
class Output;
class CursorScene;
class RenderBackend;
class RenderLayer;
class RenderLoop;
class RenderTarget;
class WorkspaceScene;
class Window;
class OutputFrame;
 
class KWIN_EXPORT Compositor : public QObject
{
    Q_OBJECT
public:
    enum class State {
        On = 0,
        Off,
        Starting,
        Stopping
    };
 
    ~Compositor() override;
    static Compositor *self();
 
    virtual void reinitialize();
 
    bool isActive();
 
    WorkspaceScene *scene() const
    {
        return m_scene.get();
    }
    CursorScene *cursorScene() const
    {
        return m_cursorScene.get();
    }
    RenderBackend *backend() const
    {
        return m_backend.get();
    }
 
    static bool compositing()
    {
        return s_compositor != nullptr && s_compositor->isActive();
    }
 
    // for delayed supportproperty management of effects
    void keepSupportProperty(xcb_atom_t atom);
    void removeSupportProperty(xcb_atom_t atom);
 
    virtual bool compositingPossible() const;
    virtual QString compositingNotPossibleReason() const;
    virtual bool openGLCompositingIsBroken() const;
 
    virtual void inhibit(Window *window);
    virtual void uninhibit(Window *window);
 
Q_SIGNALS:
    void compositingToggled(bool active);
    void aboutToDestroy();
    void aboutToToggleCompositing();
    void sceneCreated();
 
protected:
    explicit Compositor(QObject *parent = nullptr);
 
    virtual void start() = 0;
    virtual void stop() = 0;
 
    static Compositor *s_compositor;
 
protected Q_SLOTS:
    virtual void composite(RenderLoop *renderLoop);
 
private Q_SLOTS:
    void handleFrameRequested(RenderLoop *renderLoop);
 
protected:
    void deleteUnusedSupportProperties();
 
    Output *findOutput(RenderLoop *loop) const;
 
    void addSuperLayer(RenderLayer *layer);
    void removeSuperLayer(RenderLayer *layer);
 
    void prePaintPass(RenderLayer *layer, QRegion *damage);
    void postPaintPass(RenderLayer *layer);
    void paintPass(RenderLayer *layer, const RenderTarget &renderTarget, const QRegion &region);
    void framePass(RenderLayer *layer, OutputFrame *frame);
 
    State m_state = State::Off;
    QList<xcb_atom_t> m_unusedSupportProperties;
    QTimer m_unusedSupportPropertyTimer;
    std::unique_ptr<WorkspaceScene> m_scene;
    std::unique_ptr<CursorScene> m_cursorScene;
    std::unique_ptr<RenderBackend> m_backend;
    QHash<RenderLoop *, RenderLayer *> m_superlayers;
};
 
} // namespace KWin