#include <QtWaylandClient/private/qwayland-wayland.h>

QT_BEGIN_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_GCC("-Wmissing-field-initializers")

namespace QtWayland {

static inline void *wlRegistryBind(struct ::wl_registry *registry, uint32_t name, const struct ::wl_interface *interface, uint32_t version)
{
    const uint32_t bindOpCode = 0;
#if (WAYLAND_VERSION_MAJOR == 1 && WAYLAND_VERSION_MINOR > 10) || WAYLAND_VERSION_MAJOR > 1
    return (void *) wl_proxy_marshal_constructor_versioned((struct wl_proxy *) registry,
        bindOpCode, interface, version, name, interface->name, version, nullptr);
#else
    return (void *) wl_proxy_marshal_constructor((struct wl_proxy *) registry,
        bindOpCode, interface, name, interface->name, version, nullptr);
#endif
}

    wl_registry::wl_registry(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_registry::wl_registry(struct ::wl_registry *obj)
        : m_wl_registry(obj)
    {
        init_listener();
    }

    wl_registry::wl_registry()
        : m_wl_registry(nullptr)
    {
    }

    wl_registry::~wl_registry()
    {
    }

    void wl_registry::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_registry = static_cast<struct ::wl_registry *>(wlRegistryBind(registry, id, &wl_registry_interface, version));
        init_listener();
    }

    void wl_registry::init(struct ::wl_registry *obj)
    {
        m_wl_registry = obj;
        init_listener();
    }

    wl_registry *wl_registry::fromObject(struct ::wl_registry *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_registry_listener)
            return nullptr;
        return static_cast<wl_registry *>(wl_registry_get_user_data(object));
    }

    bool wl_registry::isInitialized() const
    {
        return m_wl_registry != nullptr;
    }

    const struct wl_interface *wl_registry::interface()
    {
        return &::wl_registry_interface;
    }

    void *wl_registry::bind(uint32_t name, const struct ::wl_interface *interface, uint32_t version)
    {
        return wl_registry_bind(
            m_wl_registry,
            name,
            interface,
            version);
    }

    void wl_registry::registry_global(uint32_t , const QString &, uint32_t )
    {
    }

    void wl_registry::handle_global(
        void *data,
        struct ::wl_registry *object,
        uint32_t name,
        const char *interface,
        uint32_t version)
    {
        Q_UNUSED(object);
        static_cast<wl_registry *>(data)->registry_global(
            name,
            QString::fromUtf8(interface),
            version);
    }

    void wl_registry::registry_global_remove(uint32_t )
    {
    }

    void wl_registry::handle_global_remove(
        void *data,
        struct ::wl_registry *object,
        uint32_t name)
    {
        Q_UNUSED(object);
        static_cast<wl_registry *>(data)->registry_global_remove(
            name);
    }

    const struct wl_registry_listener wl_registry::m_wl_registry_listener = {
        wl_registry::handle_global,
        wl_registry::handle_global_remove
    };

    void wl_registry::init_listener()
    {
        wl_registry_add_listener(m_wl_registry, &m_wl_registry_listener, this);
    }

    wl_callback::wl_callback(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_callback::wl_callback(struct ::wl_callback *obj)
        : m_wl_callback(obj)
    {
        init_listener();
    }

    wl_callback::wl_callback()
        : m_wl_callback(nullptr)
    {
    }

    wl_callback::~wl_callback()
    {
    }

    void wl_callback::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_callback = static_cast<struct ::wl_callback *>(wlRegistryBind(registry, id, &wl_callback_interface, version));
        init_listener();
    }

    void wl_callback::init(struct ::wl_callback *obj)
    {
        m_wl_callback = obj;
        init_listener();
    }

    wl_callback *wl_callback::fromObject(struct ::wl_callback *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_callback_listener)
            return nullptr;
        return static_cast<wl_callback *>(wl_callback_get_user_data(object));
    }

    bool wl_callback::isInitialized() const
    {
        return m_wl_callback != nullptr;
    }

    const struct wl_interface *wl_callback::interface()
    {
        return &::wl_callback_interface;
    }

    void wl_callback::callback_done(uint32_t )
    {
    }

    void wl_callback::handle_done(
        void *data,
        struct ::wl_callback *object,
        uint32_t callback_data)
    {
        Q_UNUSED(object);
        static_cast<wl_callback *>(data)->callback_done(
            callback_data);
    }

    const struct wl_callback_listener wl_callback::m_wl_callback_listener = {
        wl_callback::handle_done
    };

    void wl_callback::init_listener()
    {
        wl_callback_add_listener(m_wl_callback, &m_wl_callback_listener, this);
    }

    wl_compositor::wl_compositor(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_compositor::wl_compositor(struct ::wl_compositor *obj)
        : m_wl_compositor(obj)
    {
    }

    wl_compositor::wl_compositor()
        : m_wl_compositor(nullptr)
    {
    }

    wl_compositor::~wl_compositor()
    {
    }

    void wl_compositor::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_compositor = static_cast<struct ::wl_compositor *>(wlRegistryBind(registry, id, &wl_compositor_interface, version));
    }

    void wl_compositor::init(struct ::wl_compositor *obj)
    {
        m_wl_compositor = obj;
    }

    wl_compositor *wl_compositor::fromObject(struct ::wl_compositor *object)
    {
        return static_cast<wl_compositor *>(wl_compositor_get_user_data(object));
    }

    bool wl_compositor::isInitialized() const
    {
        return m_wl_compositor != nullptr;
    }

    const struct wl_interface *wl_compositor::interface()
    {
        return &::wl_compositor_interface;
    }

    struct ::wl_surface *wl_compositor::create_surface()
    {
        return wl_compositor_create_surface(
            m_wl_compositor);
    }

    struct ::wl_region *wl_compositor::create_region()
    {
        return wl_compositor_create_region(
            m_wl_compositor);
    }

    wl_shm_pool::wl_shm_pool(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_shm_pool::wl_shm_pool(struct ::wl_shm_pool *obj)
        : m_wl_shm_pool(obj)
    {
    }

    wl_shm_pool::wl_shm_pool()
        : m_wl_shm_pool(nullptr)
    {
    }

    wl_shm_pool::~wl_shm_pool()
    {
    }

    void wl_shm_pool::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_shm_pool = static_cast<struct ::wl_shm_pool *>(wlRegistryBind(registry, id, &wl_shm_pool_interface, version));
    }

    void wl_shm_pool::init(struct ::wl_shm_pool *obj)
    {
        m_wl_shm_pool = obj;
    }

    wl_shm_pool *wl_shm_pool::fromObject(struct ::wl_shm_pool *object)
    {
        return static_cast<wl_shm_pool *>(wl_shm_pool_get_user_data(object));
    }

    bool wl_shm_pool::isInitialized() const
    {
        return m_wl_shm_pool != nullptr;
    }

    const struct wl_interface *wl_shm_pool::interface()
    {
        return &::wl_shm_pool_interface;
    }

    struct ::wl_buffer *wl_shm_pool::create_buffer(int32_t offset, int32_t width, int32_t height, int32_t stride, uint32_t format)
    {
        return wl_shm_pool_create_buffer(
            m_wl_shm_pool,
            offset,
            width,
            height,
            stride,
            format);
    }

    void wl_shm_pool::destroy()
    {
        wl_shm_pool_destroy(
            m_wl_shm_pool);
        m_wl_shm_pool = nullptr;
    }

    void wl_shm_pool::resize(int32_t size)
    {
        wl_shm_pool_resize(
            m_wl_shm_pool,
            size);
    }

    wl_shm::wl_shm(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_shm::wl_shm(struct ::wl_shm *obj)
        : m_wl_shm(obj)
    {
        init_listener();
    }

    wl_shm::wl_shm()
        : m_wl_shm(nullptr)
    {
    }

    wl_shm::~wl_shm()
    {
    }

    void wl_shm::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_shm = static_cast<struct ::wl_shm *>(wlRegistryBind(registry, id, &wl_shm_interface, version));
        init_listener();
    }

    void wl_shm::init(struct ::wl_shm *obj)
    {
        m_wl_shm = obj;
        init_listener();
    }

    wl_shm *wl_shm::fromObject(struct ::wl_shm *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_shm_listener)
            return nullptr;
        return static_cast<wl_shm *>(wl_shm_get_user_data(object));
    }

    bool wl_shm::isInitialized() const
    {
        return m_wl_shm != nullptr;
    }

    const struct wl_interface *wl_shm::interface()
    {
        return &::wl_shm_interface;
    }

    struct ::wl_shm_pool *wl_shm::create_pool(int32_t fd, int32_t size)
    {
        return wl_shm_create_pool(
            m_wl_shm,
            fd,
            size);
    }

    void wl_shm::shm_format(uint32_t )
    {
    }

    void wl_shm::handle_format(
        void *data,
        struct ::wl_shm *object,
        uint32_t format)
    {
        Q_UNUSED(object);
        static_cast<wl_shm *>(data)->shm_format(
            format);
    }

    const struct wl_shm_listener wl_shm::m_wl_shm_listener = {
        wl_shm::handle_format
    };

    void wl_shm::init_listener()
    {
        wl_shm_add_listener(m_wl_shm, &m_wl_shm_listener, this);
    }

    wl_buffer::wl_buffer(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_buffer::wl_buffer(struct ::wl_buffer *obj)
        : m_wl_buffer(obj)
    {
        init_listener();
    }

    wl_buffer::wl_buffer()
        : m_wl_buffer(nullptr)
    {
    }

    wl_buffer::~wl_buffer()
    {
    }

    void wl_buffer::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_buffer = static_cast<struct ::wl_buffer *>(wlRegistryBind(registry, id, &wl_buffer_interface, version));
        init_listener();
    }

    void wl_buffer::init(struct ::wl_buffer *obj)
    {
        m_wl_buffer = obj;
        init_listener();
    }

    wl_buffer *wl_buffer::fromObject(struct ::wl_buffer *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_buffer_listener)
            return nullptr;
        return static_cast<wl_buffer *>(wl_buffer_get_user_data(object));
    }

    bool wl_buffer::isInitialized() const
    {
        return m_wl_buffer != nullptr;
    }

    const struct wl_interface *wl_buffer::interface()
    {
        return &::wl_buffer_interface;
    }

    void wl_buffer::destroy()
    {
        wl_buffer_destroy(
            m_wl_buffer);
        m_wl_buffer = nullptr;
    }

    void wl_buffer::buffer_release()
    {
    }

    void wl_buffer::handle_release(
        void *data,
        struct ::wl_buffer *object)
    {
        Q_UNUSED(object);
        static_cast<wl_buffer *>(data)->buffer_release();
    }

    const struct wl_buffer_listener wl_buffer::m_wl_buffer_listener = {
        wl_buffer::handle_release
    };

    void wl_buffer::init_listener()
    {
        wl_buffer_add_listener(m_wl_buffer, &m_wl_buffer_listener, this);
    }

    wl_data_offer::wl_data_offer(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_data_offer::wl_data_offer(struct ::wl_data_offer *obj)
        : m_wl_data_offer(obj)
    {
        init_listener();
    }

    wl_data_offer::wl_data_offer()
        : m_wl_data_offer(nullptr)
    {
    }

    wl_data_offer::~wl_data_offer()
    {
    }

    void wl_data_offer::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_data_offer = static_cast<struct ::wl_data_offer *>(wlRegistryBind(registry, id, &wl_data_offer_interface, version));
        init_listener();
    }

    void wl_data_offer::init(struct ::wl_data_offer *obj)
    {
        m_wl_data_offer = obj;
        init_listener();
    }

    wl_data_offer *wl_data_offer::fromObject(struct ::wl_data_offer *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_data_offer_listener)
            return nullptr;
        return static_cast<wl_data_offer *>(wl_data_offer_get_user_data(object));
    }

    bool wl_data_offer::isInitialized() const
    {
        return m_wl_data_offer != nullptr;
    }

    const struct wl_interface *wl_data_offer::interface()
    {
        return &::wl_data_offer_interface;
    }

    void wl_data_offer::accept(uint32_t serial, const QString &mime_type)
    {
        wl_data_offer_accept(
            m_wl_data_offer,
            serial,
            mime_type.toUtf8().constData());
    }

    void wl_data_offer::receive(const QString &mime_type, int32_t fd)
    {
        wl_data_offer_receive(
            m_wl_data_offer,
            mime_type.toUtf8().constData(),
            fd);
    }

    void wl_data_offer::destroy()
    {
        wl_data_offer_destroy(
            m_wl_data_offer);
        m_wl_data_offer = nullptr;
    }

    void wl_data_offer::finish()
    {
        wl_data_offer_finish(
            m_wl_data_offer);
    }

    void wl_data_offer::set_actions(uint32_t dnd_actions, uint32_t preferred_action)
    {
        wl_data_offer_set_actions(
            m_wl_data_offer,
            dnd_actions,
            preferred_action);
    }

    void wl_data_offer::data_offer_offer(const QString &)
    {
    }

    void wl_data_offer::handle_offer(
        void *data,
        struct ::wl_data_offer *object,
        const char *mime_type)
    {
        Q_UNUSED(object);
        static_cast<wl_data_offer *>(data)->data_offer_offer(
            QString::fromUtf8(mime_type));
    }

    void wl_data_offer::data_offer_source_actions(uint32_t )
    {
    }

    void wl_data_offer::handle_source_actions(
        void *data,
        struct ::wl_data_offer *object,
        uint32_t source_actions)
    {
        Q_UNUSED(object);
        static_cast<wl_data_offer *>(data)->data_offer_source_actions(
            source_actions);
    }

    void wl_data_offer::data_offer_action(uint32_t )
    {
    }

    void wl_data_offer::handle_action(
        void *data,
        struct ::wl_data_offer *object,
        uint32_t dnd_action)
    {
        Q_UNUSED(object);
        static_cast<wl_data_offer *>(data)->data_offer_action(
            dnd_action);
    }

    const struct wl_data_offer_listener wl_data_offer::m_wl_data_offer_listener = {
        wl_data_offer::handle_offer,
        wl_data_offer::handle_source_actions,
        wl_data_offer::handle_action
    };

    void wl_data_offer::init_listener()
    {
        wl_data_offer_add_listener(m_wl_data_offer, &m_wl_data_offer_listener, this);
    }

    wl_data_source::wl_data_source(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_data_source::wl_data_source(struct ::wl_data_source *obj)
        : m_wl_data_source(obj)
    {
        init_listener();
    }

    wl_data_source::wl_data_source()
        : m_wl_data_source(nullptr)
    {
    }

    wl_data_source::~wl_data_source()
    {
    }

    void wl_data_source::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_data_source = static_cast<struct ::wl_data_source *>(wlRegistryBind(registry, id, &wl_data_source_interface, version));
        init_listener();
    }

    void wl_data_source::init(struct ::wl_data_source *obj)
    {
        m_wl_data_source = obj;
        init_listener();
    }

    wl_data_source *wl_data_source::fromObject(struct ::wl_data_source *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_data_source_listener)
            return nullptr;
        return static_cast<wl_data_source *>(wl_data_source_get_user_data(object));
    }

    bool wl_data_source::isInitialized() const
    {
        return m_wl_data_source != nullptr;
    }

    const struct wl_interface *wl_data_source::interface()
    {
        return &::wl_data_source_interface;
    }

    void wl_data_source::offer(const QString &mime_type)
    {
        wl_data_source_offer(
            m_wl_data_source,
            mime_type.toUtf8().constData());
    }

    void wl_data_source::destroy()
    {
        wl_data_source_destroy(
            m_wl_data_source);
        m_wl_data_source = nullptr;
    }

    void wl_data_source::set_actions(uint32_t dnd_actions)
    {
        wl_data_source_set_actions(
            m_wl_data_source,
            dnd_actions);
    }

    void wl_data_source::data_source_target(const QString &)
    {
    }

    void wl_data_source::handle_target(
        void *data,
        struct ::wl_data_source *object,
        const char *mime_type)
    {
        Q_UNUSED(object);
        static_cast<wl_data_source *>(data)->data_source_target(
            QString::fromUtf8(mime_type));
    }

    void wl_data_source::data_source_send(const QString &, int32_t )
    {
    }

    void wl_data_source::handle_send(
        void *data,
        struct ::wl_data_source *object,
        const char *mime_type,
        int32_t fd)
    {
        Q_UNUSED(object);
        static_cast<wl_data_source *>(data)->data_source_send(
            QString::fromUtf8(mime_type),
            fd);
    }

    void wl_data_source::data_source_cancelled()
    {
    }

    void wl_data_source::handle_cancelled(
        void *data,
        struct ::wl_data_source *object)
    {
        Q_UNUSED(object);
        static_cast<wl_data_source *>(data)->data_source_cancelled();
    }

    void wl_data_source::data_source_dnd_drop_performed()
    {
    }

    void wl_data_source::handle_dnd_drop_performed(
        void *data,
        struct ::wl_data_source *object)
    {
        Q_UNUSED(object);
        static_cast<wl_data_source *>(data)->data_source_dnd_drop_performed();
    }

    void wl_data_source::data_source_dnd_finished()
    {
    }

    void wl_data_source::handle_dnd_finished(
        void *data,
        struct ::wl_data_source *object)
    {
        Q_UNUSED(object);
        static_cast<wl_data_source *>(data)->data_source_dnd_finished();
    }

    void wl_data_source::data_source_action(uint32_t )
    {
    }

    void wl_data_source::handle_action(
        void *data,
        struct ::wl_data_source *object,
        uint32_t dnd_action)
    {
        Q_UNUSED(object);
        static_cast<wl_data_source *>(data)->data_source_action(
            dnd_action);
    }

    const struct wl_data_source_listener wl_data_source::m_wl_data_source_listener = {
        wl_data_source::handle_target,
        wl_data_source::handle_send,
        wl_data_source::handle_cancelled,
        wl_data_source::handle_dnd_drop_performed,
        wl_data_source::handle_dnd_finished,
        wl_data_source::handle_action
    };

    void wl_data_source::init_listener()
    {
        wl_data_source_add_listener(m_wl_data_source, &m_wl_data_source_listener, this);
    }

    wl_data_device::wl_data_device(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_data_device::wl_data_device(struct ::wl_data_device *obj)
        : m_wl_data_device(obj)
    {
        init_listener();
    }

    wl_data_device::wl_data_device()
        : m_wl_data_device(nullptr)
    {
    }

    wl_data_device::~wl_data_device()
    {
    }

    void wl_data_device::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_data_device = static_cast<struct ::wl_data_device *>(wlRegistryBind(registry, id, &wl_data_device_interface, version));
        init_listener();
    }

    void wl_data_device::init(struct ::wl_data_device *obj)
    {
        m_wl_data_device = obj;
        init_listener();
    }

    wl_data_device *wl_data_device::fromObject(struct ::wl_data_device *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_data_device_listener)
            return nullptr;
        return static_cast<wl_data_device *>(wl_data_device_get_user_data(object));
    }

    bool wl_data_device::isInitialized() const
    {
        return m_wl_data_device != nullptr;
    }

    const struct wl_interface *wl_data_device::interface()
    {
        return &::wl_data_device_interface;
    }

    void wl_data_device::start_drag(struct ::wl_data_source *source, struct ::wl_surface *origin, struct ::wl_surface *icon, uint32_t serial)
    {
        wl_data_device_start_drag(
            m_wl_data_device,
            source,
            origin,
            icon,
            serial);
    }

    void wl_data_device::set_selection(struct ::wl_data_source *source, uint32_t serial)
    {
        wl_data_device_set_selection(
            m_wl_data_device,
            source,
            serial);
    }

    void wl_data_device::release()
    {
        wl_data_device_release(
            m_wl_data_device);
        m_wl_data_device = nullptr;
    }

    void wl_data_device::data_device_data_offer(struct ::wl_data_offer *)
    {
    }

    void wl_data_device::handle_data_offer(
        void *data,
        struct ::wl_data_device *object,
        struct ::wl_data_offer *id)
    {
        Q_UNUSED(object);
        static_cast<wl_data_device *>(data)->data_device_data_offer(
            id);
    }

    void wl_data_device::data_device_enter(uint32_t , struct ::wl_surface *, wl_fixed_t , wl_fixed_t , struct ::wl_data_offer *)
    {
    }

    void wl_data_device::handle_enter(
        void *data,
        struct ::wl_data_device *object,
        uint32_t serial,
        struct ::wl_surface *surface,
        wl_fixed_t x,
        wl_fixed_t y,
        struct ::wl_data_offer *id)
    {
        Q_UNUSED(object);
        static_cast<wl_data_device *>(data)->data_device_enter(
            serial,
            surface,
            x,
            y,
            id);
    }

    void wl_data_device::data_device_leave()
    {
    }

    void wl_data_device::handle_leave(
        void *data,
        struct ::wl_data_device *object)
    {
        Q_UNUSED(object);
        static_cast<wl_data_device *>(data)->data_device_leave();
    }

    void wl_data_device::data_device_motion(uint32_t , wl_fixed_t , wl_fixed_t )
    {
    }

    void wl_data_device::handle_motion(
        void *data,
        struct ::wl_data_device *object,
        uint32_t time,
        wl_fixed_t x,
        wl_fixed_t y)
    {
        Q_UNUSED(object);
        static_cast<wl_data_device *>(data)->data_device_motion(
            time,
            x,
            y);
    }

    void wl_data_device::data_device_drop()
    {
    }

    void wl_data_device::handle_drop(
        void *data,
        struct ::wl_data_device *object)
    {
        Q_UNUSED(object);
        static_cast<wl_data_device *>(data)->data_device_drop();
    }

    void wl_data_device::data_device_selection(struct ::wl_data_offer *)
    {
    }

    void wl_data_device::handle_selection(
        void *data,
        struct ::wl_data_device *object,
        struct ::wl_data_offer *id)
    {
        Q_UNUSED(object);
        static_cast<wl_data_device *>(data)->data_device_selection(
            id);
    }

    const struct wl_data_device_listener wl_data_device::m_wl_data_device_listener = {
        wl_data_device::handle_data_offer,
        wl_data_device::handle_enter,
        wl_data_device::handle_leave,
        wl_data_device::handle_motion,
        wl_data_device::handle_drop,
        wl_data_device::handle_selection
    };

    void wl_data_device::init_listener()
    {
        wl_data_device_add_listener(m_wl_data_device, &m_wl_data_device_listener, this);
    }

    wl_data_device_manager::wl_data_device_manager(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_data_device_manager::wl_data_device_manager(struct ::wl_data_device_manager *obj)
        : m_wl_data_device_manager(obj)
    {
    }

    wl_data_device_manager::wl_data_device_manager()
        : m_wl_data_device_manager(nullptr)
    {
    }

    wl_data_device_manager::~wl_data_device_manager()
    {
    }

    void wl_data_device_manager::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_data_device_manager = static_cast<struct ::wl_data_device_manager *>(wlRegistryBind(registry, id, &wl_data_device_manager_interface, version));
    }

    void wl_data_device_manager::init(struct ::wl_data_device_manager *obj)
    {
        m_wl_data_device_manager = obj;
    }

    wl_data_device_manager *wl_data_device_manager::fromObject(struct ::wl_data_device_manager *object)
    {
        return static_cast<wl_data_device_manager *>(wl_data_device_manager_get_user_data(object));
    }

    bool wl_data_device_manager::isInitialized() const
    {
        return m_wl_data_device_manager != nullptr;
    }

    const struct wl_interface *wl_data_device_manager::interface()
    {
        return &::wl_data_device_manager_interface;
    }

    struct ::wl_data_source *wl_data_device_manager::create_data_source()
    {
        return wl_data_device_manager_create_data_source(
            m_wl_data_device_manager);
    }

    struct ::wl_data_device *wl_data_device_manager::get_data_device(struct ::wl_seat *seat)
    {
        return wl_data_device_manager_get_data_device(
            m_wl_data_device_manager,
            seat);
    }

    wl_shell::wl_shell(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_shell::wl_shell(struct ::wl_shell *obj)
        : m_wl_shell(obj)
    {
    }

    wl_shell::wl_shell()
        : m_wl_shell(nullptr)
    {
    }

    wl_shell::~wl_shell()
    {
    }

    void wl_shell::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_shell = static_cast<struct ::wl_shell *>(wlRegistryBind(registry, id, &wl_shell_interface, version));
    }

    void wl_shell::init(struct ::wl_shell *obj)
    {
        m_wl_shell = obj;
    }

    wl_shell *wl_shell::fromObject(struct ::wl_shell *object)
    {
        return static_cast<wl_shell *>(wl_shell_get_user_data(object));
    }

    bool wl_shell::isInitialized() const
    {
        return m_wl_shell != nullptr;
    }

    const struct wl_interface *wl_shell::interface()
    {
        return &::wl_shell_interface;
    }

    struct ::wl_shell_surface *wl_shell::get_shell_surface(struct ::wl_surface *surface)
    {
        return wl_shell_get_shell_surface(
            m_wl_shell,
            surface);
    }

    wl_shell_surface::wl_shell_surface(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_shell_surface::wl_shell_surface(struct ::wl_shell_surface *obj)
        : m_wl_shell_surface(obj)
    {
        init_listener();
    }

    wl_shell_surface::wl_shell_surface()
        : m_wl_shell_surface(nullptr)
    {
    }

    wl_shell_surface::~wl_shell_surface()
    {
    }

    void wl_shell_surface::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_shell_surface = static_cast<struct ::wl_shell_surface *>(wlRegistryBind(registry, id, &wl_shell_surface_interface, version));
        init_listener();
    }

    void wl_shell_surface::init(struct ::wl_shell_surface *obj)
    {
        m_wl_shell_surface = obj;
        init_listener();
    }

    wl_shell_surface *wl_shell_surface::fromObject(struct ::wl_shell_surface *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_shell_surface_listener)
            return nullptr;
        return static_cast<wl_shell_surface *>(wl_shell_surface_get_user_data(object));
    }

    bool wl_shell_surface::isInitialized() const
    {
        return m_wl_shell_surface != nullptr;
    }

    const struct wl_interface *wl_shell_surface::interface()
    {
        return &::wl_shell_surface_interface;
    }

    void wl_shell_surface::pong(uint32_t serial)
    {
        wl_shell_surface_pong(
            m_wl_shell_surface,
            serial);
    }

    void wl_shell_surface::move(struct ::wl_seat *seat, uint32_t serial)
    {
        wl_shell_surface_move(
            m_wl_shell_surface,
            seat,
            serial);
    }

    void wl_shell_surface::resize(struct ::wl_seat *seat, uint32_t serial, uint32_t edges)
    {
        wl_shell_surface_resize(
            m_wl_shell_surface,
            seat,
            serial,
            edges);
    }

    void wl_shell_surface::set_toplevel()
    {
        wl_shell_surface_set_toplevel(
            m_wl_shell_surface);
    }

    void wl_shell_surface::set_transient(struct ::wl_surface *parent, int32_t x, int32_t y, uint32_t flags)
    {
        wl_shell_surface_set_transient(
            m_wl_shell_surface,
            parent,
            x,
            y,
            flags);
    }

    void wl_shell_surface::set_fullscreen(uint32_t method, uint32_t framerate, struct ::wl_output *output)
    {
        wl_shell_surface_set_fullscreen(
            m_wl_shell_surface,
            method,
            framerate,
            output);
    }

    void wl_shell_surface::set_popup(struct ::wl_seat *seat, uint32_t serial, struct ::wl_surface *parent, int32_t x, int32_t y, uint32_t flags)
    {
        wl_shell_surface_set_popup(
            m_wl_shell_surface,
            seat,
            serial,
            parent,
            x,
            y,
            flags);
    }

    void wl_shell_surface::set_maximized(struct ::wl_output *output)
    {
        wl_shell_surface_set_maximized(
            m_wl_shell_surface,
            output);
    }

    void wl_shell_surface::set_title(const QString &title)
    {
        wl_shell_surface_set_title(
            m_wl_shell_surface,
            title.toUtf8().constData());
    }

    void wl_shell_surface::set_class(const QString &class_)
    {
        wl_shell_surface_set_class(
            m_wl_shell_surface,
            class_.toUtf8().constData());
    }

    void wl_shell_surface::shell_surface_ping(uint32_t )
    {
    }

    void wl_shell_surface::handle_ping(
        void *data,
        struct ::wl_shell_surface *object,
        uint32_t serial)
    {
        Q_UNUSED(object);
        static_cast<wl_shell_surface *>(data)->shell_surface_ping(
            serial);
    }

    void wl_shell_surface::shell_surface_configure(uint32_t , int32_t , int32_t )
    {
    }

    void wl_shell_surface::handle_configure(
        void *data,
        struct ::wl_shell_surface *object,
        uint32_t edges,
        int32_t width,
        int32_t height)
    {
        Q_UNUSED(object);
        static_cast<wl_shell_surface *>(data)->shell_surface_configure(
            edges,
            width,
            height);
    }

    void wl_shell_surface::shell_surface_popup_done()
    {
    }

    void wl_shell_surface::handle_popup_done(
        void *data,
        struct ::wl_shell_surface *object)
    {
        Q_UNUSED(object);
        static_cast<wl_shell_surface *>(data)->shell_surface_popup_done();
    }

    const struct wl_shell_surface_listener wl_shell_surface::m_wl_shell_surface_listener = {
        wl_shell_surface::handle_ping,
        wl_shell_surface::handle_configure,
        wl_shell_surface::handle_popup_done
    };

    void wl_shell_surface::init_listener()
    {
        wl_shell_surface_add_listener(m_wl_shell_surface, &m_wl_shell_surface_listener, this);
    }

    wl_surface::wl_surface(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_surface::wl_surface(struct ::wl_surface *obj)
        : m_wl_surface(obj)
    {
        init_listener();
    }

    wl_surface::wl_surface()
        : m_wl_surface(nullptr)
    {
    }

    wl_surface::~wl_surface()
    {
    }

    void wl_surface::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_surface = static_cast<struct ::wl_surface *>(wlRegistryBind(registry, id, &wl_surface_interface, version));
        init_listener();
    }

    void wl_surface::init(struct ::wl_surface *obj)
    {
        m_wl_surface = obj;
        init_listener();
    }

    wl_surface *wl_surface::fromObject(struct ::wl_surface *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_surface_listener)
            return nullptr;
        return static_cast<wl_surface *>(wl_surface_get_user_data(object));
    }

    bool wl_surface::isInitialized() const
    {
        return m_wl_surface != nullptr;
    }

    const struct wl_interface *wl_surface::interface()
    {
        return &::wl_surface_interface;
    }

    void wl_surface::destroy()
    {
        wl_surface_destroy(
            m_wl_surface);
        m_wl_surface = nullptr;
    }

    void wl_surface::attach(struct ::wl_buffer *buffer, int32_t x, int32_t y)
    {
        wl_surface_attach(
            m_wl_surface,
            buffer,
            x,
            y);
    }

    void wl_surface::damage(int32_t x, int32_t y, int32_t width, int32_t height)
    {
        wl_surface_damage(
            m_wl_surface,
            x,
            y,
            width,
            height);
    }

    struct ::wl_callback *wl_surface::frame()
    {
        return wl_surface_frame(
            m_wl_surface);
    }

    void wl_surface::set_opaque_region(struct ::wl_region *region)
    {
        wl_surface_set_opaque_region(
            m_wl_surface,
            region);
    }

    void wl_surface::set_input_region(struct ::wl_region *region)
    {
        wl_surface_set_input_region(
            m_wl_surface,
            region);
    }

    void wl_surface::commit()
    {
        wl_surface_commit(
            m_wl_surface);
    }

    void wl_surface::set_buffer_transform(int32_t transform)
    {
        wl_surface_set_buffer_transform(
            m_wl_surface,
            transform);
    }

    void wl_surface::set_buffer_scale(int32_t scale)
    {
        wl_surface_set_buffer_scale(
            m_wl_surface,
            scale);
    }

    void wl_surface::damage_buffer(int32_t x, int32_t y, int32_t width, int32_t height)
    {
        wl_surface_damage_buffer(
            m_wl_surface,
            x,
            y,
            width,
            height);
    }

    void wl_surface::surface_enter(struct ::wl_output *)
    {
    }

    void wl_surface::handle_enter(
        void *data,
        struct ::wl_surface *object,
        struct ::wl_output *output)
    {
        Q_UNUSED(object);
        static_cast<wl_surface *>(data)->surface_enter(
            output);
    }

    void wl_surface::surface_leave(struct ::wl_output *)
    {
    }

    void wl_surface::handle_leave(
        void *data,
        struct ::wl_surface *object,
        struct ::wl_output *output)
    {
        Q_UNUSED(object);
        static_cast<wl_surface *>(data)->surface_leave(
            output);
    }

    const struct wl_surface_listener wl_surface::m_wl_surface_listener = {
        wl_surface::handle_enter,
        wl_surface::handle_leave
    };

    void wl_surface::init_listener()
    {
        wl_surface_add_listener(m_wl_surface, &m_wl_surface_listener, this);
    }

    wl_seat::wl_seat(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_seat::wl_seat(struct ::wl_seat *obj)
        : m_wl_seat(obj)
    {
        init_listener();
    }

    wl_seat::wl_seat()
        : m_wl_seat(nullptr)
    {
    }

    wl_seat::~wl_seat()
    {
    }

    void wl_seat::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_seat = static_cast<struct ::wl_seat *>(wlRegistryBind(registry, id, &wl_seat_interface, version));
        init_listener();
    }

    void wl_seat::init(struct ::wl_seat *obj)
    {
        m_wl_seat = obj;
        init_listener();
    }

    wl_seat *wl_seat::fromObject(struct ::wl_seat *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_seat_listener)
            return nullptr;
        return static_cast<wl_seat *>(wl_seat_get_user_data(object));
    }

    bool wl_seat::isInitialized() const
    {
        return m_wl_seat != nullptr;
    }

    const struct wl_interface *wl_seat::interface()
    {
        return &::wl_seat_interface;
    }

    struct ::wl_pointer *wl_seat::get_pointer()
    {
        return wl_seat_get_pointer(
            m_wl_seat);
    }

    struct ::wl_keyboard *wl_seat::get_keyboard()
    {
        return wl_seat_get_keyboard(
            m_wl_seat);
    }

    struct ::wl_touch *wl_seat::get_touch()
    {
        return wl_seat_get_touch(
            m_wl_seat);
    }

    void wl_seat::release()
    {
        wl_seat_release(
            m_wl_seat);
        m_wl_seat = nullptr;
    }

    void wl_seat::seat_capabilities(uint32_t )
    {
    }

    void wl_seat::handle_capabilities(
        void *data,
        struct ::wl_seat *object,
        uint32_t capabilities)
    {
        Q_UNUSED(object);
        static_cast<wl_seat *>(data)->seat_capabilities(
            capabilities);
    }

    void wl_seat::seat_name(const QString &)
    {
    }

    void wl_seat::handle_name(
        void *data,
        struct ::wl_seat *object,
        const char *name)
    {
        Q_UNUSED(object);
        static_cast<wl_seat *>(data)->seat_name(
            QString::fromUtf8(name));
    }

    const struct wl_seat_listener wl_seat::m_wl_seat_listener = {
        wl_seat::handle_capabilities,
        wl_seat::handle_name
    };

    void wl_seat::init_listener()
    {
        wl_seat_add_listener(m_wl_seat, &m_wl_seat_listener, this);
    }

    wl_pointer::wl_pointer(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_pointer::wl_pointer(struct ::wl_pointer *obj)
        : m_wl_pointer(obj)
    {
        init_listener();
    }

    wl_pointer::wl_pointer()
        : m_wl_pointer(nullptr)
    {
    }

    wl_pointer::~wl_pointer()
    {
    }

    void wl_pointer::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_pointer = static_cast<struct ::wl_pointer *>(wlRegistryBind(registry, id, &wl_pointer_interface, version));
        init_listener();
    }

    void wl_pointer::init(struct ::wl_pointer *obj)
    {
        m_wl_pointer = obj;
        init_listener();
    }

    wl_pointer *wl_pointer::fromObject(struct ::wl_pointer *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_pointer_listener)
            return nullptr;
        return static_cast<wl_pointer *>(wl_pointer_get_user_data(object));
    }

    bool wl_pointer::isInitialized() const
    {
        return m_wl_pointer != nullptr;
    }

    const struct wl_interface *wl_pointer::interface()
    {
        return &::wl_pointer_interface;
    }

    void wl_pointer::set_cursor(uint32_t serial, struct ::wl_surface *surface, int32_t hotspot_x, int32_t hotspot_y)
    {
        wl_pointer_set_cursor(
            m_wl_pointer,
            serial,
            surface,
            hotspot_x,
            hotspot_y);
    }

    void wl_pointer::release()
    {
        wl_pointer_release(
            m_wl_pointer);
        m_wl_pointer = nullptr;
    }

    void wl_pointer::pointer_enter(uint32_t , struct ::wl_surface *, wl_fixed_t , wl_fixed_t )
    {
    }

    void wl_pointer::handle_enter(
        void *data,
        struct ::wl_pointer *object,
        uint32_t serial,
        struct ::wl_surface *surface,
        wl_fixed_t surface_x,
        wl_fixed_t surface_y)
    {
        Q_UNUSED(object);
        static_cast<wl_pointer *>(data)->pointer_enter(
            serial,
            surface,
            surface_x,
            surface_y);
    }

    void wl_pointer::pointer_leave(uint32_t , struct ::wl_surface *)
    {
    }

    void wl_pointer::handle_leave(
        void *data,
        struct ::wl_pointer *object,
        uint32_t serial,
        struct ::wl_surface *surface)
    {
        Q_UNUSED(object);
        static_cast<wl_pointer *>(data)->pointer_leave(
            serial,
            surface);
    }

    void wl_pointer::pointer_motion(uint32_t , wl_fixed_t , wl_fixed_t )
    {
    }

    void wl_pointer::handle_motion(
        void *data,
        struct ::wl_pointer *object,
        uint32_t time,
        wl_fixed_t surface_x,
        wl_fixed_t surface_y)
    {
        Q_UNUSED(object);
        static_cast<wl_pointer *>(data)->pointer_motion(
            time,
            surface_x,
            surface_y);
    }

    void wl_pointer::pointer_button(uint32_t , uint32_t , uint32_t , uint32_t )
    {
    }

    void wl_pointer::handle_button(
        void *data,
        struct ::wl_pointer *object,
        uint32_t serial,
        uint32_t time,
        uint32_t button,
        uint32_t state)
    {
        Q_UNUSED(object);
        static_cast<wl_pointer *>(data)->pointer_button(
            serial,
            time,
            button,
            state);
    }

    void wl_pointer::pointer_axis(uint32_t , uint32_t , wl_fixed_t )
    {
    }

    void wl_pointer::handle_axis(
        void *data,
        struct ::wl_pointer *object,
        uint32_t time,
        uint32_t axis,
        wl_fixed_t value)
    {
        Q_UNUSED(object);
        static_cast<wl_pointer *>(data)->pointer_axis(
            time,
            axis,
            value);
    }

    void wl_pointer::pointer_frame()
    {
    }

    void wl_pointer::handle_frame(
        void *data,
        struct ::wl_pointer *object)
    {
        Q_UNUSED(object);
        static_cast<wl_pointer *>(data)->pointer_frame();
    }

    void wl_pointer::pointer_axis_source(uint32_t )
    {
    }

    void wl_pointer::handle_axis_source(
        void *data,
        struct ::wl_pointer *object,
        uint32_t axis_source)
    {
        Q_UNUSED(object);
        static_cast<wl_pointer *>(data)->pointer_axis_source(
            axis_source);
    }

    void wl_pointer::pointer_axis_stop(uint32_t , uint32_t )
    {
    }

    void wl_pointer::handle_axis_stop(
        void *data,
        struct ::wl_pointer *object,
        uint32_t time,
        uint32_t axis)
    {
        Q_UNUSED(object);
        static_cast<wl_pointer *>(data)->pointer_axis_stop(
            time,
            axis);
    }

    void wl_pointer::pointer_axis_discrete(uint32_t , int32_t )
    {
    }

    void wl_pointer::handle_axis_discrete(
        void *data,
        struct ::wl_pointer *object,
        uint32_t axis,
        int32_t discrete)
    {
        Q_UNUSED(object);
        static_cast<wl_pointer *>(data)->pointer_axis_discrete(
            axis,
            discrete);
    }

    const struct wl_pointer_listener wl_pointer::m_wl_pointer_listener = {
        wl_pointer::handle_enter,
        wl_pointer::handle_leave,
        wl_pointer::handle_motion,
        wl_pointer::handle_button,
        wl_pointer::handle_axis,
        wl_pointer::handle_frame,
        wl_pointer::handle_axis_source,
        wl_pointer::handle_axis_stop,
        wl_pointer::handle_axis_discrete
    };

    void wl_pointer::init_listener()
    {
        wl_pointer_add_listener(m_wl_pointer, &m_wl_pointer_listener, this);
    }

    wl_keyboard::wl_keyboard(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_keyboard::wl_keyboard(struct ::wl_keyboard *obj)
        : m_wl_keyboard(obj)
    {
        init_listener();
    }

    wl_keyboard::wl_keyboard()
        : m_wl_keyboard(nullptr)
    {
    }

    wl_keyboard::~wl_keyboard()
    {
    }

    void wl_keyboard::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_keyboard = static_cast<struct ::wl_keyboard *>(wlRegistryBind(registry, id, &wl_keyboard_interface, version));
        init_listener();
    }

    void wl_keyboard::init(struct ::wl_keyboard *obj)
    {
        m_wl_keyboard = obj;
        init_listener();
    }

    wl_keyboard *wl_keyboard::fromObject(struct ::wl_keyboard *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_keyboard_listener)
            return nullptr;
        return static_cast<wl_keyboard *>(wl_keyboard_get_user_data(object));
    }

    bool wl_keyboard::isInitialized() const
    {
        return m_wl_keyboard != nullptr;
    }

    const struct wl_interface *wl_keyboard::interface()
    {
        return &::wl_keyboard_interface;
    }

    void wl_keyboard::release()
    {
        wl_keyboard_release(
            m_wl_keyboard);
        m_wl_keyboard = nullptr;
    }

    void wl_keyboard::keyboard_keymap(uint32_t , int32_t , uint32_t )
    {
    }

    void wl_keyboard::handle_keymap(
        void *data,
        struct ::wl_keyboard *object,
        uint32_t format,
        int32_t fd,
        uint32_t size)
    {
        Q_UNUSED(object);
        static_cast<wl_keyboard *>(data)->keyboard_keymap(
            format,
            fd,
            size);
    }

    void wl_keyboard::keyboard_enter(uint32_t , struct ::wl_surface *, wl_array *)
    {
    }

    void wl_keyboard::handle_enter(
        void *data,
        struct ::wl_keyboard *object,
        uint32_t serial,
        struct ::wl_surface *surface,
        wl_array *keys)
    {
        Q_UNUSED(object);
        static_cast<wl_keyboard *>(data)->keyboard_enter(
            serial,
            surface,
            keys);
    }

    void wl_keyboard::keyboard_leave(uint32_t , struct ::wl_surface *)
    {
    }

    void wl_keyboard::handle_leave(
        void *data,
        struct ::wl_keyboard *object,
        uint32_t serial,
        struct ::wl_surface *surface)
    {
        Q_UNUSED(object);
        static_cast<wl_keyboard *>(data)->keyboard_leave(
            serial,
            surface);
    }

    void wl_keyboard::keyboard_key(uint32_t , uint32_t , uint32_t , uint32_t )
    {
    }

    void wl_keyboard::handle_key(
        void *data,
        struct ::wl_keyboard *object,
        uint32_t serial,
        uint32_t time,
        uint32_t key,
        uint32_t state)
    {
        Q_UNUSED(object);
        static_cast<wl_keyboard *>(data)->keyboard_key(
            serial,
            time,
            key,
            state);
    }

    void wl_keyboard::keyboard_modifiers(uint32_t , uint32_t , uint32_t , uint32_t , uint32_t )
    {
    }

    void wl_keyboard::handle_modifiers(
        void *data,
        struct ::wl_keyboard *object,
        uint32_t serial,
        uint32_t mods_depressed,
        uint32_t mods_latched,
        uint32_t mods_locked,
        uint32_t group)
    {
        Q_UNUSED(object);
        static_cast<wl_keyboard *>(data)->keyboard_modifiers(
            serial,
            mods_depressed,
            mods_latched,
            mods_locked,
            group);
    }

    void wl_keyboard::keyboard_repeat_info(int32_t , int32_t )
    {
    }

    void wl_keyboard::handle_repeat_info(
        void *data,
        struct ::wl_keyboard *object,
        int32_t rate,
        int32_t delay)
    {
        Q_UNUSED(object);
        static_cast<wl_keyboard *>(data)->keyboard_repeat_info(
            rate,
            delay);
    }

    const struct wl_keyboard_listener wl_keyboard::m_wl_keyboard_listener = {
        wl_keyboard::handle_keymap,
        wl_keyboard::handle_enter,
        wl_keyboard::handle_leave,
        wl_keyboard::handle_key,
        wl_keyboard::handle_modifiers,
        wl_keyboard::handle_repeat_info
    };

    void wl_keyboard::init_listener()
    {
        wl_keyboard_add_listener(m_wl_keyboard, &m_wl_keyboard_listener, this);
    }

    wl_touch::wl_touch(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_touch::wl_touch(struct ::wl_touch *obj)
        : m_wl_touch(obj)
    {
        init_listener();
    }

    wl_touch::wl_touch()
        : m_wl_touch(nullptr)
    {
    }

    wl_touch::~wl_touch()
    {
    }

    void wl_touch::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_touch = static_cast<struct ::wl_touch *>(wlRegistryBind(registry, id, &wl_touch_interface, version));
        init_listener();
    }

    void wl_touch::init(struct ::wl_touch *obj)
    {
        m_wl_touch = obj;
        init_listener();
    }

    wl_touch *wl_touch::fromObject(struct ::wl_touch *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_touch_listener)
            return nullptr;
        return static_cast<wl_touch *>(wl_touch_get_user_data(object));
    }

    bool wl_touch::isInitialized() const
    {
        return m_wl_touch != nullptr;
    }

    const struct wl_interface *wl_touch::interface()
    {
        return &::wl_touch_interface;
    }

    void wl_touch::release()
    {
        wl_touch_release(
            m_wl_touch);
        m_wl_touch = nullptr;
    }

    void wl_touch::touch_down(uint32_t , uint32_t , struct ::wl_surface *, int32_t , wl_fixed_t , wl_fixed_t )
    {
    }

    void wl_touch::handle_down(
        void *data,
        struct ::wl_touch *object,
        uint32_t serial,
        uint32_t time,
        struct ::wl_surface *surface,
        int32_t id,
        wl_fixed_t x,
        wl_fixed_t y)
    {
        Q_UNUSED(object);
        static_cast<wl_touch *>(data)->touch_down(
            serial,
            time,
            surface,
            id,
            x,
            y);
    }

    void wl_touch::touch_up(uint32_t , uint32_t , int32_t )
    {
    }

    void wl_touch::handle_up(
        void *data,
        struct ::wl_touch *object,
        uint32_t serial,
        uint32_t time,
        int32_t id)
    {
        Q_UNUSED(object);
        static_cast<wl_touch *>(data)->touch_up(
            serial,
            time,
            id);
    }

    void wl_touch::touch_motion(uint32_t , int32_t , wl_fixed_t , wl_fixed_t )
    {
    }

    void wl_touch::handle_motion(
        void *data,
        struct ::wl_touch *object,
        uint32_t time,
        int32_t id,
        wl_fixed_t x,
        wl_fixed_t y)
    {
        Q_UNUSED(object);
        static_cast<wl_touch *>(data)->touch_motion(
            time,
            id,
            x,
            y);
    }

    void wl_touch::touch_frame()
    {
    }

    void wl_touch::handle_frame(
        void *data,
        struct ::wl_touch *object)
    {
        Q_UNUSED(object);
        static_cast<wl_touch *>(data)->touch_frame();
    }

    void wl_touch::touch_cancel()
    {
    }

    void wl_touch::handle_cancel(
        void *data,
        struct ::wl_touch *object)
    {
        Q_UNUSED(object);
        static_cast<wl_touch *>(data)->touch_cancel();
    }

    void wl_touch::touch_shape(int32_t , wl_fixed_t , wl_fixed_t )
    {
    }

    void wl_touch::handle_shape(
        void *data,
        struct ::wl_touch *object,
        int32_t id,
        wl_fixed_t major,
        wl_fixed_t minor)
    {
        Q_UNUSED(object);
        static_cast<wl_touch *>(data)->touch_shape(
            id,
            major,
            minor);
    }

    void wl_touch::touch_orientation(int32_t , wl_fixed_t )
    {
    }

    void wl_touch::handle_orientation(
        void *data,
        struct ::wl_touch *object,
        int32_t id,
        wl_fixed_t orientation)
    {
        Q_UNUSED(object);
        static_cast<wl_touch *>(data)->touch_orientation(
            id,
            orientation);
    }

    const struct wl_touch_listener wl_touch::m_wl_touch_listener = {
        wl_touch::handle_down,
        wl_touch::handle_up,
        wl_touch::handle_motion,
        wl_touch::handle_frame,
        wl_touch::handle_cancel,
        wl_touch::handle_shape,
        wl_touch::handle_orientation
    };

    void wl_touch::init_listener()
    {
        wl_touch_add_listener(m_wl_touch, &m_wl_touch_listener, this);
    }

    wl_output::wl_output(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_output::wl_output(struct ::wl_output *obj)
        : m_wl_output(obj)
    {
        init_listener();
    }

    wl_output::wl_output()
        : m_wl_output(nullptr)
    {
    }

    wl_output::~wl_output()
    {
    }

    void wl_output::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_output = static_cast<struct ::wl_output *>(wlRegistryBind(registry, id, &wl_output_interface, version));
        init_listener();
    }

    void wl_output::init(struct ::wl_output *obj)
    {
        m_wl_output = obj;
        init_listener();
    }

    wl_output *wl_output::fromObject(struct ::wl_output *object)
    {
        if (wl_proxy_get_listener((struct ::wl_proxy *)object) != (void *)&m_wl_output_listener)
            return nullptr;
        return static_cast<wl_output *>(wl_output_get_user_data(object));
    }

    bool wl_output::isInitialized() const
    {
        return m_wl_output != nullptr;
    }

    const struct wl_interface *wl_output::interface()
    {
        return &::wl_output_interface;
    }

    void wl_output::release()
    {
        wl_output_release(
            m_wl_output);
        m_wl_output = nullptr;
    }

    void wl_output::output_geometry(int32_t , int32_t , int32_t , int32_t , int32_t , const QString &, const QString &, int32_t )
    {
    }

    void wl_output::handle_geometry(
        void *data,
        struct ::wl_output *object,
        int32_t x,
        int32_t y,
        int32_t physical_width,
        int32_t physical_height,
        int32_t subpixel,
        const char *make,
        const char *model,
        int32_t transform)
    {
        Q_UNUSED(object);
        static_cast<wl_output *>(data)->output_geometry(
            x,
            y,
            physical_width,
            physical_height,
            subpixel,
            QString::fromUtf8(make),
            QString::fromUtf8(model),
            transform);
    }

    void wl_output::output_mode(uint32_t , int32_t , int32_t , int32_t )
    {
    }

    void wl_output::handle_mode(
        void *data,
        struct ::wl_output *object,
        uint32_t flags,
        int32_t width,
        int32_t height,
        int32_t refresh)
    {
        Q_UNUSED(object);
        static_cast<wl_output *>(data)->output_mode(
            flags,
            width,
            height,
            refresh);
    }

    void wl_output::output_done()
    {
    }

    void wl_output::handle_done(
        void *data,
        struct ::wl_output *object)
    {
        Q_UNUSED(object);
        static_cast<wl_output *>(data)->output_done();
    }

    void wl_output::output_scale(int32_t )
    {
    }

    void wl_output::handle_scale(
        void *data,
        struct ::wl_output *object,
        int32_t factor)
    {
        Q_UNUSED(object);
        static_cast<wl_output *>(data)->output_scale(
            factor);
    }

    const struct wl_output_listener wl_output::m_wl_output_listener = {
        wl_output::handle_geometry,
        wl_output::handle_mode,
        wl_output::handle_done,
        wl_output::handle_scale
    };

    void wl_output::init_listener()
    {
        wl_output_add_listener(m_wl_output, &m_wl_output_listener, this);
    }

    wl_region::wl_region(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_region::wl_region(struct ::wl_region *obj)
        : m_wl_region(obj)
    {
    }

    wl_region::wl_region()
        : m_wl_region(nullptr)
    {
    }

    wl_region::~wl_region()
    {
    }

    void wl_region::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_region = static_cast<struct ::wl_region *>(wlRegistryBind(registry, id, &wl_region_interface, version));
    }

    void wl_region::init(struct ::wl_region *obj)
    {
        m_wl_region = obj;
    }

    wl_region *wl_region::fromObject(struct ::wl_region *object)
    {
        return static_cast<wl_region *>(wl_region_get_user_data(object));
    }

    bool wl_region::isInitialized() const
    {
        return m_wl_region != nullptr;
    }

    const struct wl_interface *wl_region::interface()
    {
        return &::wl_region_interface;
    }

    void wl_region::destroy()
    {
        wl_region_destroy(
            m_wl_region);
        m_wl_region = nullptr;
    }

    void wl_region::add(int32_t x, int32_t y, int32_t width, int32_t height)
    {
        wl_region_add(
            m_wl_region,
            x,
            y,
            width,
            height);
    }

    void wl_region::subtract(int32_t x, int32_t y, int32_t width, int32_t height)
    {
        wl_region_subtract(
            m_wl_region,
            x,
            y,
            width,
            height);
    }

    wl_subcompositor::wl_subcompositor(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_subcompositor::wl_subcompositor(struct ::wl_subcompositor *obj)
        : m_wl_subcompositor(obj)
    {
    }

    wl_subcompositor::wl_subcompositor()
        : m_wl_subcompositor(nullptr)
    {
    }

    wl_subcompositor::~wl_subcompositor()
    {
    }

    void wl_subcompositor::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_subcompositor = static_cast<struct ::wl_subcompositor *>(wlRegistryBind(registry, id, &wl_subcompositor_interface, version));
    }

    void wl_subcompositor::init(struct ::wl_subcompositor *obj)
    {
        m_wl_subcompositor = obj;
    }

    wl_subcompositor *wl_subcompositor::fromObject(struct ::wl_subcompositor *object)
    {
        return static_cast<wl_subcompositor *>(wl_subcompositor_get_user_data(object));
    }

    bool wl_subcompositor::isInitialized() const
    {
        return m_wl_subcompositor != nullptr;
    }

    const struct wl_interface *wl_subcompositor::interface()
    {
        return &::wl_subcompositor_interface;
    }

    void wl_subcompositor::destroy()
    {
        wl_subcompositor_destroy(
            m_wl_subcompositor);
        m_wl_subcompositor = nullptr;
    }

    struct ::wl_subsurface *wl_subcompositor::get_subsurface(struct ::wl_surface *surface, struct ::wl_surface *parent)
    {
        return wl_subcompositor_get_subsurface(
            m_wl_subcompositor,
            surface,
            parent);
    }

    wl_subsurface::wl_subsurface(struct ::wl_registry *registry, int id, int version)
    {
        init(registry, id, version);
    }

    wl_subsurface::wl_subsurface(struct ::wl_subsurface *obj)
        : m_wl_subsurface(obj)
    {
    }

    wl_subsurface::wl_subsurface()
        : m_wl_subsurface(nullptr)
    {
    }

    wl_subsurface::~wl_subsurface()
    {
    }

    void wl_subsurface::init(struct ::wl_registry *registry, int id, int version)
    {
        m_wl_subsurface = static_cast<struct ::wl_subsurface *>(wlRegistryBind(registry, id, &wl_subsurface_interface, version));
    }

    void wl_subsurface::init(struct ::wl_subsurface *obj)
    {
        m_wl_subsurface = obj;
    }

    wl_subsurface *wl_subsurface::fromObject(struct ::wl_subsurface *object)
    {
        return static_cast<wl_subsurface *>(wl_subsurface_get_user_data(object));
    }

    bool wl_subsurface::isInitialized() const
    {
        return m_wl_subsurface != nullptr;
    }

    const struct wl_interface *wl_subsurface::interface()
    {
        return &::wl_subsurface_interface;
    }

    void wl_subsurface::destroy()
    {
        wl_subsurface_destroy(
            m_wl_subsurface);
        m_wl_subsurface = nullptr;
    }

    void wl_subsurface::set_position(int32_t x, int32_t y)
    {
        wl_subsurface_set_position(
            m_wl_subsurface,
            x,
            y);
    }

    void wl_subsurface::place_above(struct ::wl_surface *sibling)
    {
        wl_subsurface_place_above(
            m_wl_subsurface,
            sibling);
    }

    void wl_subsurface::place_below(struct ::wl_surface *sibling)
    {
        wl_subsurface_place_below(
            m_wl_subsurface,
            sibling);
    }

    void wl_subsurface::set_sync()
    {
        wl_subsurface_set_sync(
            m_wl_subsurface);
    }

    void wl_subsurface::set_desync()
    {
        wl_subsurface_set_desync(
            m_wl_subsurface);
    }
}

QT_WARNING_POP
QT_END_NAMESPACE
