surface.h

Go to the documentation of this file.

/*
    SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
    SPDX-FileCopyrightText: 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
#pragma once
 
#include "core/colorspace.h"
#include "core/output.h"
#include "core/renderbackend.h"
 
#include <QObject>
#include <QRegion>
 
struct wl_resource;
 
namespace KWin
{
 
class GraphicsBuffer;
class BlurInterface;
class ClientConnection;
class ConfinedPointerV1Interface;
class ContrastInterface;
class CompositorInterface;
class LinuxDmaBufV1Feedback;
class LockedPointerV1Interface;
class OutputInterface;
class ShadowInterface;
class SlideInterface;
class SubSurfaceInterface;
class SurfaceInterfacePrivate;
class Transaction;
 
class KWIN_EXPORT SurfaceRole
{
public:
    explicit SurfaceRole(const QByteArray &name);
 
    QByteArray name() const;
 
private:
    QByteArray m_name;
};
 
class KWIN_EXPORT SurfaceInterface : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QRegion opaque READ opaque NOTIFY opaqueChanged)
    Q_PROPERTY(QRegion input READ input NOTIFY inputChanged)
    Q_PROPERTY(QSizeF size READ size NOTIFY sizeChanged)
public:
    explicit SurfaceInterface(CompositorInterface *compositor, wl_resource *resource);
    ~SurfaceInterface() override;
 
    uint32_t id() const;
    ClientConnection *client() const;
    wl_resource *resource() const;
    CompositorInterface *compositor() const;
 
    SurfaceRole *role() const;
    void setRole(SurfaceRole *role);
 
    QPointF mapToChild(SurfaceInterface *child, const QPointF &point) const;
 
    void frameRendered(quint32 msec);
    bool hasFrameCallbacks() const;
 
    std::unique_ptr<PresentationFeedback> takePresentationFeedback(Output *output);
 
    QRegion opaque() const;
    QRegion input() const;
    QRegion bufferDamage() const;
    QRectF bufferSourceBox() const;
    OutputTransform bufferTransform() const;
    GraphicsBuffer *buffer() const;
    QPoint offset() const;
    QSizeF size() const;
    QRectF boundingRect() const;
    QSize bufferSize() const;
 
    SubSurfaceInterface *subSurface() const;
    QList<SubSurfaceInterface *> below() const;
    QList<SubSurfaceInterface *> above() const;
 
    ShadowInterface *shadow() const;
 
    BlurInterface *blur() const;
 
    SlideInterface *slideOnShowHide() const;
 
    ContrastInterface *contrast() const;
 
    bool isMapped() const;
 
    SurfaceInterface *surfaceAt(const QPointF &position);
 
    SurfaceInterface *inputSurfaceAt(const QPointF &position);
 
    void setOutputs(const QList<OutputInterface *> &outputs, OutputInterface *primaryOutput);
 
    QList<OutputInterface *> outputs() const;
 
    ConfinedPointerV1Interface *confinedPointer() const;
 
    LockedPointerV1Interface *lockedPointer() const;
 
    bool inhibitsIdle() const;
 
    LinuxDmaBufV1Feedback *dmabufFeedbackV1() const;
 
    ContentType contentType() const;
 
    static SurfaceInterface *get(wl_resource *native);
    static SurfaceInterface *get(quint32 id, const ClientConnection *client);
 
    qreal scaleOverride() const;
    QPoint toSurfaceLocal(const QPoint &point) const;
    QPointF toSurfaceLocal(const QPointF &point) const;
 
    PresentationModeHint presentationModeHint() const;
 
    void setPreferredBufferScale(qreal scale);
 
    void setPreferredBufferTransform(OutputTransform transform);
 
    Transaction *firstTransaction() const;
    void setFirstTransaction(Transaction *transaction);
 
    Transaction *lastTransaction() const;
    void setLastTransaction(Transaction *transaction);
 
    const ColorDescription &colorDescription() const;
 
    void setPreferredColorDescription(const ColorDescription &descr);
 
    void traverseTree(std::function<void(SurfaceInterface *surface)> callback);
 
Q_SIGNALS:
    void aboutToBeDestroyed();
    void damaged(const QRegion &);
    void opaqueChanged(const QRegion &);
    void inputChanged(const QRegion &);
    void bufferTransformChanged(KWin::OutputTransform);
    void bufferSourceBoxChanged();
    void bufferSizeChanged();
    void mapped();
    void unmapped();
    void sizeChanged();
    void shadowChanged();
    void blurChanged();
    void slideOnShowHideChanged();
    void contrastChanged();
    void childSubSurfaceAdded(SubSurfaceInterface *subSurface);
    void childSubSurfaceRemoved(SubSurfaceInterface *subSurface);
    void childSubSurfacesChanged();
 
    void pointerConstraintsChanged();
 
    void inhibitsIdleChanged();
 
    void colorDescriptionChanged();
    void presentationModeHintChanged();
 
    void committed();
 
    void stateStashed(quint32 serial);
 
    void stateApplied(quint32 serial);
 
private:
    std::unique_ptr<SurfaceInterfacePrivate> d;
    friend class SurfaceInterfacePrivate;
};
 
template<typename Commit>
class SurfaceExtension : public QObject
{
public:
    explicit SurfaceExtension(SurfaceInterface *surface)
    {
        connect(surface, &SurfaceInterface::stateStashed, this, &SurfaceExtension::stashState);
        connect(surface, &SurfaceInterface::stateApplied, this, &SurfaceExtension::applyState);
    }
 
    virtual void apply(Commit *commit) = 0;
 
    Commit pending;
    QMap<quint32, Commit> stashed;
 
private:
    void stashState(quint32 serial)
    {
        Commit stash = std::exchange(pending, Commit{});
        stashed.insert(serial, stash);
    }
 
    void applyState(quint32 serial)
    {
        if (!stashed.isEmpty()) {
            if (stashed.firstKey() == serial) {
                Commit stash = stashed.take(serial);
                apply(&stash);
            }
            return;
        }
 
        apply(&pending);
        pending = Commit{};
    }
};
 
} // namespace KWin
 
Q_DECLARE_METATYPE(KWin::SurfaceInterface *)