coreprotocol.h - mozsearch

qt/qtwayland/tests/auto/client/shared/coreprotocol.h

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2018 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#ifndef MOCKCOMPOSITOR_COREPROTOCOL_H

#define MOCKCOMPOSITOR_COREPROTOCOL_H

#include "corecompositor.h"

#include <QtCore/qpointer.h>

#include <qwayland-server-wayland.h>

namespace MockCompositor {

class WlCompositor;

class WlShell;

class WlShellSurface;

class Output;

class Pointer;

class Touch;

class Keyboard;

class CursorRole;

class ShmPool;

class ShmBuffer;

class DataDevice;

class Buffer : public QObject, public QtWaylandServer::wl_buffer

    Q_OBJECT

public:

    explicit Buffer(wl_client *client, int id, int version)

        : QtWaylandServer::wl_buffer(client, id, version)

    virtual QSize size() const = 0;

    bool m_destroyed = false;

protected:

    void buffer_destroy_resource(Resource *resource) override

        Q_UNUSED(resource);

        m_destroyed = true;

        // The client side resource has been destroyed, but we keep this object because it may be

        // be used as a reference by e.g. surface for the currently committed buffer so it's not

        // yet safe to free it.

        //TODO: The memory should be freed by its factory

    void buffer_destroy(Resource *resource) override { wl_resource_destroy(resource->handle); }

};

class Callback : public QObject, public QtWaylandServer::wl_callback

    Q_OBJECT

public:

    explicit Callback(wl_client *client, int id, int version = 1)

        : QtWaylandServer::wl_callback(client, id, version)

    ~Callback() override { if (!m_destroyed) wl_resource_destroy(resource()->handle); }

    void send_done(uint32_t data) = delete; // use state-tracking method below instead

    void sendDone(uint data) { Q_ASSERT(!m_done); QtWaylandServer::wl_callback::send_done(data); m_done = true; }

    void sendDoneAndDestroy(uint data) { sendDone(data); wl_resource_destroy(resource()->handle); }

    bool m_done = false;

    bool m_destroyed = false;

protected:

    void callback_destroy_resource(Resource *resource) override { Q_UNUSED(resource); m_destroyed = true; }

};

class SurfaceRole : public QObject {

    Q_OBJECT

};

class Surface : public QObject, public QtWaylandServer::wl_surface

    Q_OBJECT

public:

    explicit Surface(WlCompositor *wlCompositor, wl_client *client, int id, int version);

    ~Surface() override;

    void sendFrameCallbacks();

    void sendEnter(Output *output);

    void send_enter(::wl_resource *output) = delete;

    void sendLeave(Output *output);

    void send_leave(::wl_resource *output) = delete;

    void map();

    void unmap();

    bool isMapped() const { return m_mapped; }

    WlShellSurface *wlShellSurface() const { return m_wlShellSurface; }

    WlCompositor *m_wlCompositor;

    struct PerCommitData {

        Callback *frame = nullptr;

        QPoint attachOffset;

        bool attached = false;

};

    struct DoubleBufferedState {

        PerCommitData commitSpecific;

        Buffer *buffer = nullptr;

        uint configureSerial = 0;

        int bufferScale = 1;

    } m_pending, m_committed;

    QList<DoubleBufferedState *> m_commits;

    QList<Callback *> m_waitingFrameCallbacks;

    QList<Output *> m_outputs;

    SurfaceRole *m_role = nullptr;

    WlShellSurface *m_wlShellSurface = nullptr;

    bool m_mapped = false;

    QList<wl_resource *> m_frameCallbackList;

    wl_resource *m_buffer = nullptr;

    QImage m_image; // checking backingStore

    bool m_wlshell = false;

signals:

    void attach(void *buffer, QPoint offset);

    void commit();

    void bufferCommitted();

protected:

    void surface_destroy_resource(Resource *resource) override;

    void surface_destroy(Resource *resource) override;

    void surface_attach(Resource *resource, wl_resource *buffer, int32_t x, int32_t y) override;

    void surface_set_buffer_scale(Resource *resource, int32_t scale) override;

    void surface_commit(Resource *resource) override;

    void surface_frame(Resource *resource, uint32_t callback) override;

    void surface_offset(Resource *resource, int32_t x, int32_t y) override;

};

class Region : public QtWaylandServer::wl_region

public:

    explicit Region(wl_client *client, int id, int version)

        : QtWaylandServer::wl_region(client, id, version)

    void region_destroy_resource(Resource *resource) override

        Q_UNUSED(resource);

        delete this;

};

class WlCompositor : public Global, public QtWaylandServer::wl_compositor

    Q_OBJECT

public:

    explicit WlCompositor(CoreCompositor *compositor, int version = 6)

        : QtWaylandServer::wl_compositor(compositor->m_display, version)

        , m_compositor(compositor)

{}

    bool isClean() override;

    QString dirtyMessage() override;

    QList<Surface *> m_surfaces;

    CoreCompositor *m_compositor = nullptr;

signals:

    void surfaceCreated(Surface *surface);

protected:

    void compositor_create_surface(Resource *resource, uint32_t id) override

        auto *surface = new Surface(this, resource->client(), id, resource->version());

        m_surfaces.append(surface);

        emit surfaceCreated(surface);

    void compositor_create_region(Resource *resource, uint32_t id) override

        new Region(resource->client(), id, resource->version());

};

class WlShell : public Global, public QtWaylandServer::wl_shell

    Q_OBJECT

public:

    explicit WlShell(CoreCompositor *compositor, int version = 1);

    QList<WlShellSurface *> m_wlShellSurfaces;

    CoreCompositor *m_compositor = nullptr;

signals:

    void wlShellSurfaceCreated(WlShellSurface *wlShellSurface);

protected:

    void shell_get_shell_surface(Resource *resource, uint32_t id, ::wl_resource *surface) override;

};

class WlShellSurfaceRole : public SurfaceRole

    Q_OBJECT

};

class WlShellSurface : public QObject, public QtWaylandServer::wl_shell_surface

    Q_OBJECT

public:

    explicit WlShellSurface(WlShell *wlShell, wl_client *client, int id, Surface *surface);

    ~WlShellSurface() override;

    void sendConfigure(uint32_t edges, int32_t width, int32_t height);

    void send_configure(uint32_t edges, int32_t width, int32_t height) = delete;

    void shell_surface_destroy_resource(Resource *) override { delete this; }

    WlShell *m_wlShell = nullptr;

    Surface *m_surface = nullptr;

};

class Subsurface;

class SubCompositor : public Global, public QtWaylandServer::wl_subcompositor

    Q_OBJECT

public:

    explicit SubCompositor(CoreCompositor *compositor, int version = 1)

        : QtWaylandServer::wl_subcompositor(compositor->m_display, version)

{}

    QList<Subsurface *> m_subsurfaces;

signals:

    void subsurfaceCreated(Subsurface *subsurface);

protected:

    void subcompositor_get_subsurface(Resource *resource, uint32_t id,

                                      ::wl_resource *surfaceResource,

                                      ::wl_resource *parent) override;

};

class SubSurfaceRole : public SurfaceRole

    Q_OBJECT

};

class Subsurface : public QObject, public QtWaylandServer::wl_subsurface

    Q_OBJECT

public:

    explicit Subsurface(SubCompositor *subCompositor, wl_client *client, int id, int version)

        : QtWaylandServer::wl_subsurface(client, id, version), m_subcompositor(subCompositor)

    ~Subsurface()

        m_subcompositor->m_subsurfaces.removeOne(this);

        qDebug() << m_subcompositor->m_subsurfaces;

    void subsurface_destroy(Resource *resource) override { wl_resource_destroy(resource->handle); }

    void subsurface_destroy_resource(Resource *resource) override

        Q_UNUSED(resource)

        delete this;

private:

    SubCompositor *m_subcompositor;

};

struct OutputMode {

    explicit OutputMode() = default;

    explicit OutputMode(const QSize &resolution, int refreshRate = 60000)

        : resolution(resolution), refreshRate(refreshRate)

{}

    QSize resolution = QSize(1920, 1080);

    int refreshRate = 60000; // In mHz

    //TODO: flags (they're currently hard-coded)

    // in mm

    QSize physicalSizeForDpi(int dpi) { return (QSizeF(resolution) * 25.4 / dpi).toSize(); }

};

struct OutputData {

    using Subpixel = QtWaylandServer::wl_output::subpixel;

    using Transform = QtWaylandServer::wl_output::transform;

    explicit OutputData() = default;

    // for geometry event

    QPoint position;

    QSize physicalSize = QSize(0, 0); // means unknown physical size

    QString make = "Make";

    QString model = "Model";

    Subpixel subpixel = Subpixel::subpixel_unknown;

    Transform transform = Transform::transform_normal;

    int scale = 1; // for scale event

    OutputMode mode; // for mode event

};

class Output : public Global, public QtWaylandServer::wl_output

    Q_OBJECT

public:

    explicit Output(CoreCompositor *compositor, OutputData data = OutputData(), int version = 2)

        : QtWaylandServer::wl_output(compositor->m_display, version)

        , m_data(std::move(data))

        , m_version(version)

{}

    void send_geometry() = delete;

    void sendGeometry();

    void sendGeometry(Resource *resource); // Sends to only one client

    void send_scale(int32_t factor) = delete;

    void sendScale(int factor);

    void sendScale(Resource *resource); // Sends current scale to only one client

    void sendDone(wl_client *client);

    void sendDone();

    int scale() const { return m_data.scale; }

    OutputData m_data;

    int m_version = 1; // TODO: remove on libwayland upgrade

Q_SIGNALS:

    void outputBound(Resource *resource);

protected:

    void output_bind_resource(Resource *resource) override;

};

class Seat : public Global, public QtWaylandServer::wl_seat

    Q_OBJECT

public:

    explicit Seat(CoreCompositor *compositor, uint capabilities = Seat::capability_pointer | Seat::capability_keyboard | Seat::capability_touch, int version = 9, const QString &seatName = QLatin1String("seat0"));

    ~Seat() override;

    void send_capabilities(Resource *resource, uint capabilities) = delete; // Use wrapper instead

    void send_capabilities(uint capabilities) = delete; // Use wrapper instead

    void setCapabilities(uint capabilities);

    QString m_seatName;

    CoreCompositor *m_compositor = nullptr;

    Pointer* m_pointer = nullptr;

    QList<Pointer *> m_oldPointers;

    Touch* m_touch = nullptr;

    QList<Touch *> m_oldTouchs;

    Keyboard* m_keyboard = nullptr;

    QList<Keyboard *> m_oldKeyboards;

    uint m_capabilities = 0;

protected:

    void seat_bind_resource(Resource *resource) override

        wl_seat::send_capabilities(resource->handle, m_capabilities);

        wl_seat::send_name(resource->handle, m_seatName); // in any normal world this is would be set before capabilities. Weston does it after

    void seat_get_pointer(Resource *resource, uint32_t id) override;

    void seat_get_touch(Resource *resource, uint32_t id) override;

    void seat_get_keyboard(Resource *resource, uint32_t id) override;

//    void seat_release(Resource *resource) override;

};

class Pointer : public QObject, public QtWaylandServer::wl_pointer

    Q_OBJECT

public:

    explicit Pointer(Seat *seat) : m_seat(seat) {}

    Surface *cursorSurface();

    QPointer<CursorRole> m_cursorRole;

    void send_enter() = delete;

    uint sendEnter(Surface *surface, const QPointF &position);

    void send_leave() = delete;

    uint sendLeave(Surface *surface);

    void sendMotion(wl_client *client, const QPointF &position);

    uint sendButton(wl_client *client, uint button, uint state);

    void sendAxis(wl_client *client, axis axis, qreal value);

    void sendAxisDiscrete(wl_client *client, axis axis, int discrete);

    void sendAxisSource(wl_client *client, axis_source source);

    void sendAxisStop(wl_client *client, axis axis);

    void sendFrame(wl_client *client);

    void sendAxisValue120(wl_client *client, axis axis, int value120);

    void sendAxisRelativeDirection(wl_client *client, axis axis, axis_relative_direction direction);

    Seat *m_seat = nullptr;

    QList<uint> m_enterSerials;

    QPoint m_hotspot;

signals:

    void setCursor(uint serial); //TODO: add arguments?

protected:

    void pointer_set_cursor(Resource *resource, uint32_t serial, ::wl_resource *surface, int32_t hotspot_x, int32_t hotspot_y) override;

    //TODO

};

class CursorRole : public SurfaceRole {

    Q_OBJECT

public:

    explicit CursorRole(Surface *surface) // TODO: needs some more args

        : m_surface(surface)

        connect(m_surface, &QObject::destroyed, this, &QObject::deleteLater);

    static CursorRole *fromSurface(Surface *surface) { return qobject_cast<CursorRole *>(surface->m_role); }

    Surface *m_surface = nullptr;

};

class Touch : public QObject, public QtWaylandServer::wl_touch

    Q_OBJECT

public:

    explicit Touch(Seat *seat) : m_seat(seat) {}

    uint sendDown(Surface *surface, const QPointF &position, int id);

    uint sendUp(wl_client *client, int id);

    void sendMotion(wl_client *client, const QPointF &position, int id);

    void sendFrame(wl_client *client);

    void sendCancel(wl_client *client);

    Seat *m_seat = nullptr;

};

class Keyboard : public QObject, public QtWaylandServer::wl_keyboard

    Q_OBJECT

public:

    explicit Keyboard(Seat *seat) : m_seat(seat) {}

    //TODO: Keymap event

    uint sendEnter(Surface *surface);

    uint sendLeave(Surface *surface);

    uint sendKey(wl_client *client, uint key, uint state);

    Seat *m_seat = nullptr;

    Surface *m_enteredSurface = nullptr;

};

class Shm : public Global, public QtWaylandServer::wl_shm

    Q_OBJECT

public:

    explicit Shm(CoreCompositor *compositor, QList<format> formats = {format_argb8888, format_xrgb8888, format_rgb888}, int version = 1);

    bool isClean() override;

    CoreCompositor *m_compositor = nullptr;

    QList<ShmPool *> m_pools;

    const QList<format> m_formats;

protected:

    void shm_create_pool(Resource *resource, uint32_t id, int32_t fd, int32_t size) override;

    void shm_bind_resource(Resource *resource) override

        for (auto format : std::as_const(m_formats))

            send_format(resource->handle, format);

};

class ShmPool : QObject, public QtWaylandServer::wl_shm_pool

    Q_OBJECT

public:

    explicit ShmPool(Shm *shm, wl_client *client, int id, int version = 1);

    Shm *m_shm = nullptr;

    QList<ShmBuffer *> m_buffers;

protected:

    void shm_pool_create_buffer(Resource *resource, uint32_t id, int32_t offset, int32_t width, int32_t height, int32_t stride, uint32_t format) override;

    void shm_pool_destroy_resource(Resource *resource) override;

    void shm_pool_destroy(Resource *resource) override { wl_resource_destroy(resource->handle); }

};

class ShmBuffer : public Buffer

    Q_OBJECT

public:

    static ShmBuffer *fromBuffer(Buffer *buffer) { return qobject_cast<ShmBuffer *>(buffer); }

    explicit ShmBuffer(int offset, const QSize &size, int stride, Shm::format format, wl_client *client, int id, int version = 1)

        : Buffer(client, id, version)

        , m_offset(offset)

        , m_size(size)

        , m_stride(stride)

        , m_format(format)

    QSize size() const override { return m_size; }

    const int m_offset;

    const QSize m_size;

    const int m_stride;

    const Shm::format m_format;

};

} // namespace MockCompositor

#endif // MOCKCOMPOSITOR_COREPROTOCOL_H