File indexing completed on 2024-05-12 05:32:30

 /*
     SPDX-FileCopyrightText: 2019 Aleix Pol Gonzalez <aleixpol@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "tablet_v2.h"
 #include "clientconnection.h"
 #include "display.h"
 #include "seat.h"
 #include "surface.h"
 #include "utils/resource.h"
 
 #include "qwayland-server-tablet-unstable-v2.h"
 
 #include <QHash>
 #include <QPointer>
 #include <ranges>
 
 namespace KWin
 {
 static int s_version = 1;
 
 class TabletV2InterfacePrivate : public QtWaylandServer::zwp_tablet_v2
 {
 public:
     TabletV2InterfacePrivate(TabletV2Interface *q, uint32_t vendorId, uint32_t productId, const QString &name, const QStringList &paths)
         : zwp_tablet_v2()
         , q(q)
         , m_vendorId(vendorId)
         , m_productId(productId)
         , m_name(name)
         , m_paths(paths)
     {
     }
 
     wl_resource *resourceForSurface(SurfaceInterface *surface) const
     {
         ClientConnection *client = surface->client();
         Resource *r = resourceMap().value(*client);
         return r ? r->handle : nullptr;
     }
 
     TabletV2Interface *const q;
     TabletPadV2Interface *m_pad = nullptr;
     const uint32_t m_vendorId;
     const uint32_t m_productId;
     const QString m_name;
     const QStringList m_paths;
 };
 
 TabletV2Interface::TabletV2Interface(uint32_t vendorId, uint32_t productId, const QString &name, const QStringList &paths, QObject *parent)
     : QObject(parent)
     , d(new TabletV2InterfacePrivate(this, vendorId, productId, name, paths))
 {
 }
 
 TabletV2Interface::~TabletV2Interface()
 {
     const auto tabletResources = d->resourceMap();
     for (TabletV2InterfacePrivate::Resource *resource : tabletResources) {
         d->send_removed(resource->handle);
     }
 }
 
 bool TabletV2Interface::isSurfaceSupported(SurfaceInterface *surface) const
 {
     return d->resourceForSurface(surface);
 }
 
 TabletPadV2Interface *TabletV2Interface::pad() const
 {
     return d->m_pad;
 }
 
 class TabletSurfaceCursorV2Private
 {
 public:
     TabletSurfaceCursorV2Private(TabletSurfaceCursorV2 *q)
         : q(q)
     {
     }
 
     void update(quint32 serial, SurfaceInterface *surface, const QPoint &hotspot)
     {
         const bool diff = m_serial != serial || m_surface != surface || m_hotspot != hotspot;
         if (diff) {
             m_serial = serial;
             m_surface = surface;
             m_hotspot = hotspot;
 
             Q_EMIT q->changed();
         }
     }
 
     TabletSurfaceCursorV2 *const q;
 
     quint32 m_serial = 0;
     QPointer<SurfaceInterface> m_surface;
     QPoint m_hotspot;
 };
 
 TabletSurfaceCursorV2::TabletSurfaceCursorV2()
     : QObject()
     , d(new TabletSurfaceCursorV2Private(this))
 {
 }
 
 TabletSurfaceCursorV2::~TabletSurfaceCursorV2() = default;
 
 QPoint TabletSurfaceCursorV2::hotspot() const
 {
     return d->m_hotspot;
 }
 
 quint32 TabletSurfaceCursorV2::enteredSerial() const
 {
     return d->m_serial;
 }
 
 SurfaceInterface *TabletSurfaceCursorV2::surface() const
 {
     return d->m_surface;
 }
 
 class TabletToolV2InterfacePrivate : public QtWaylandServer::zwp_tablet_tool_v2
 {
 public:
     TabletToolV2InterfacePrivate(TabletToolV2Interface *q,
                                  Display *display,
                                  TabletToolV2Interface::Type type,
                                  uint32_t hsh,
                                  uint32_t hsl,
                                  uint32_t hih,
                                  uint32_t hil,
                                  const QList<TabletToolV2Interface::Capability> &capabilities)
         : zwp_tablet_tool_v2()
         , m_display(display)
         , m_type(type)
         , m_hardwareSerialHigh(hsh)
         , m_hardwareSerialLow(hsl)
         , m_hardwareIdHigh(hih)
         , m_hardwareIdLow(hil)
         , m_capabilities(capabilities)
         , q(q)
     {
     }
 
     std::ranges::subrange<QMultiMap<struct ::wl_client *, Resource *>::const_iterator> targetResources() const
     {
         if (!m_surface)
             return {};
 
         ClientConnection *client = m_surface->client();
         const auto [start, end] = resourceMap().equal_range(*client);
         return std::ranges::subrange(start, end);
     }
 
     quint64 hardwareId() const
     {
         return quint64(quint64(m_hardwareIdHigh) << 32) + m_hardwareIdLow;
     }
     quint64 hardwareSerial() const
     {
         return quint64(quint64(m_hardwareSerialHigh) << 32) + m_hardwareSerialLow;
     }
 
     void zwp_tablet_tool_v2_bind_resource(QtWaylandServer::zwp_tablet_tool_v2::Resource *resource) override
     {
         TabletSurfaceCursorV2 *&c = m_cursors[resource->client()];
         if (!c)
             c = new TabletSurfaceCursorV2;
     }
 
     void zwp_tablet_tool_v2_set_cursor(Resource *resource, uint32_t serial, struct ::wl_resource *_surface, int32_t hotspot_x, int32_t hotspot_y) override
     {
         SurfaceInterface *surface = SurfaceInterface::get(_surface);
         if (surface) {
             static SurfaceRole cursorRole(QByteArrayLiteral("tablet_cursor_v2"));
             if (const SurfaceRole *role = surface->role()) {
                 if (role != &cursorRole) {
                     wl_resource_post_error(resource->handle, 0,
                                            "the wl_surface already has a role assigned %s", role->name().constData());
                     return;
                 }
             } else {
                 surface->setRole(&cursorRole);
             }
         }
 
         TabletSurfaceCursorV2 *c = m_cursors[resource->client()];
         c->d->update(serial, surface, {hotspot_x, hotspot_y});
         const auto resources = targetResources();
         if (std::any_of(resources.begin(), resources.end(), [resource](const Resource *res) {
                 return res->handle == resource->handle;
             })) {
             Q_EMIT q->cursorChanged(c);
         }
     }
 
     void zwp_tablet_tool_v2_destroy_resource(Resource *resource) override
     {
         if (!resourceMap().contains(resource->client())) {
             delete m_cursors.take(resource->client());
         }
         if (m_removed && resourceMap().isEmpty()) {
             delete q;
         }
     }
 
     void zwp_tablet_tool_v2_destroy(Resource *resource) override
     {
         wl_resource_destroy(resource->handle);
     }
 
     Display *const m_display;
     quint32 m_proximitySerial = 0;
     std::optional<quint32> m_downSerial;
     bool m_cleanup = false;
     bool m_removed = false;
     QPointer<SurfaceInterface> m_surface;
     QPointer<TabletV2Interface> m_lastTablet;
     const uint32_t m_type;
     const uint32_t m_hardwareSerialHigh, m_hardwareSerialLow;
     const uint32_t m_hardwareIdHigh, m_hardwareIdLow;
     const QList<TabletToolV2Interface::Capability> m_capabilities;
     QHash<wl_client *, TabletSurfaceCursorV2 *> m_cursors;
     TabletToolV2Interface *const q;
 };
 
 TabletToolV2Interface::TabletToolV2Interface(Display *display,
                                              Type type,
                                              uint32_t hsh,
                                              uint32_t hsl,
                                              uint32_t hih,
                                              uint32_t hil,
                                              const QList<Capability> &capabilities)
     : d(new TabletToolV2InterfacePrivate(this, display, type, hsh, hsl, hih, hil, capabilities))
 {
 }
 
 TabletToolV2Interface::~TabletToolV2Interface()
 {
     const auto toolResources = d->resourceMap();
     for (TabletToolV2InterfacePrivate::Resource *resource : toolResources) {
         d->send_removed(resource->handle);
     }
 }
 
 TabletToolV2Interface *TabletToolV2Interface::get(wl_resource *resource)
 {
     if (TabletToolV2InterfacePrivate *tabletToolPrivate = resource_cast<TabletToolV2InterfacePrivate *>(resource)) {
         return tabletToolPrivate->q;
     }
     return nullptr;
 }
 
 bool TabletToolV2Interface::hasCapability(Capability capability) const
 {
     return d->m_capabilities.contains(capability);
 }
 
 SurfaceInterface *TabletToolV2Interface::currentSurface() const
 {
     return d->m_surface;
 }
 
 void TabletToolV2Interface::setCurrentSurface(SurfaceInterface *surface)
 {
     if (d->m_surface == surface)
         return;
 
     TabletV2Interface *const lastTablet = d->m_lastTablet;
     if (d->m_surface && d->resourceMap().contains(*d->m_surface->client())) {
         sendProximityOut();
         sendFrame(0);
     }
 
     d->m_surface = surface;
 
     if (lastTablet && lastTablet->d->resourceForSurface(surface)) {
         sendProximityIn(lastTablet);
     } else {
         d->m_lastTablet = lastTablet;
     }
 
     if (surface != nullptr) {
         if (auto *const cursor = d->m_cursors.value(*surface->client())) {
             Q_EMIT cursorChanged(cursor);
         }
     }
 }
 
 quint32 TabletToolV2Interface::proximitySerial() const
 {
     return d->m_proximitySerial;
 }
 
 std::optional<quint32> TabletToolV2Interface::downSerial() const
 {
     return d->m_downSerial;
 }
 
 bool TabletToolV2Interface::isClientSupported() const
 {
     return d->m_surface && !d->targetResources().empty();
 }
 
 void TabletToolV2Interface::sendButton(uint32_t button, bool pressed)
 {
     const auto serial = d->m_display->nextSerial();
     for (auto *resource : d->targetResources()) {
         d->send_button(resource->handle,
                        serial,
                        button,
                        pressed ? QtWaylandServer::zwp_tablet_tool_v2::button_state_pressed : QtWaylandServer::zwp_tablet_tool_v2::button_state_released);
     }
 }
 
 void TabletToolV2Interface::sendMotion(const QPointF &pos)
 {
     const QPointF surfacePos = d->m_surface->toSurfaceLocal(pos);
     for (auto *resource : d->targetResources()) {
         d->send_motion(resource->handle, wl_fixed_from_double(surfacePos.x()), wl_fixed_from_double(surfacePos.y()));
     }
 }
 
 void TabletToolV2Interface::sendDistance(uint32_t distance)
 {
     for (auto *resource : d->targetResources()) {
         d->send_distance(resource->handle, distance);
     }
 }
 
 void TabletToolV2Interface::sendFrame(uint32_t time)
 {
     for (auto *resource : d->targetResources()) {
         d->send_frame(resource->handle, time);
     }
 
     if (d->m_cleanup) {
         d->m_surface = nullptr;
         d->m_lastTablet = nullptr;
         d->m_cleanup = false;
     }
 }
 
 void TabletToolV2Interface::sendPressure(uint32_t pressure)
 {
     for (auto *resource : d->targetResources()) {
         d->send_pressure(resource->handle, pressure);
     }
 }
 
 void TabletToolV2Interface::sendRotation(qreal rotation)
 {
     for (auto *resource : d->targetResources()) {
         d->send_rotation(resource->handle, wl_fixed_from_double(rotation));
     }
 }
 
 void TabletToolV2Interface::sendSlider(int32_t position)
 {
     for (auto *resource : d->targetResources()) {
         d->send_slider(resource->handle, position);
     }
 }
 
 void TabletToolV2Interface::sendTilt(qreal degreesX, qreal degreesY)
 {
     for (auto *resource : d->targetResources()) {
         d->send_tilt(resource->handle, wl_fixed_from_double(degreesX), wl_fixed_from_double(degreesY));
     }
 }
 
 void TabletToolV2Interface::sendWheel(int32_t degrees, int32_t clicks)
 {
     for (auto *resource : d->targetResources()) {
         d->send_wheel(resource->handle, degrees, clicks);
     }
 }
 
 void TabletToolV2Interface::sendProximityIn(TabletV2Interface *tablet)
 {
     wl_resource *tabletResource = tablet->d->resourceForSurface(d->m_surface);
     const auto serial = d->m_display->nextSerial();
     for (auto *resource : d->targetResources()) {
         d->send_proximity_in(resource->handle, serial, tabletResource, d->m_surface->resource());
     }
     d->m_proximitySerial = serial;
     d->m_lastTablet = tablet;
 }
 
 void TabletToolV2Interface::sendProximityOut()
 {
     for (auto *resource : d->targetResources()) {
         d->send_proximity_out(resource->handle);
     }
     d->m_cleanup = true;
 }
 
 void TabletToolV2Interface::sendDown()
 {
     const auto serial = d->m_display->nextSerial();
     for (auto *resource : d->targetResources()) {
         d->send_down(resource->handle, serial);
     }
     d->m_downSerial = serial;
 }
 
 void TabletToolV2Interface::sendUp()
 {
     for (auto *resource : d->targetResources()) {
         d->send_up(resource->handle);
     }
     d->m_downSerial.reset();
 }
 
 class TabletPadRingV2InterfacePrivate : public QtWaylandServer::zwp_tablet_pad_ring_v2
 {
 public:
     TabletPadRingV2InterfacePrivate(TabletPadRingV2Interface *q)
         : zwp_tablet_pad_ring_v2()
         , q(q)
     {
     }
 
     std::ranges::subrange<QMultiMap<struct ::wl_client *, Resource *>::const_iterator> resourcesForSurface(SurfaceInterface *surface) const
     {
         ClientConnection *client = surface->client();
         const auto [start, end] = resourceMap().equal_range(*client);
         return std::ranges::subrange(start, end);
     }
 
     void zwp_tablet_pad_ring_v2_destroy(Resource *resource) override
     {
         wl_resource_destroy(resource->handle);
     }
     TabletPadRingV2Interface *const q;
     TabletPadV2Interface *m_pad;
 };
 
 TabletPadRingV2Interface::TabletPadRingV2Interface(TabletPadV2Interface *parent)
     : QObject(parent)
     , d(new TabletPadRingV2InterfacePrivate(this))
 {
     d->m_pad = parent;
 }
 
 TabletPadRingV2Interface::~TabletPadRingV2Interface() = default;
 
 void TabletPadRingV2Interface::sendAngle(qreal angle)
 {
     for (auto *resource : d->resourcesForSurface(d->m_pad->currentSurface())) {
         d->send_angle(resource->handle, wl_fixed_from_double(angle));
     }
 }
 
 void TabletPadRingV2Interface::sendFrame(quint32 time)
 {
     for (auto *resource : d->resourcesForSurface(d->m_pad->currentSurface())) {
         d->send_frame(resource->handle, time);
     }
 }
 
 void TabletPadRingV2Interface::sendSource(Source source)
 {
     for (auto *resource : d->resourcesForSurface(d->m_pad->currentSurface())) {
         d->send_source(resource->handle, source);
     }
 }
 
 void TabletPadRingV2Interface::sendStop()
 {
     for (auto *resource : d->resourcesForSurface(d->m_pad->currentSurface())) {
         d->send_stop(resource->handle);
     }
 }
 
 class TabletPadStripV2InterfacePrivate : public QtWaylandServer::zwp_tablet_pad_strip_v2
 {
 public:
     TabletPadStripV2InterfacePrivate(TabletPadStripV2Interface *q)
         : zwp_tablet_pad_strip_v2()
         , q(q)
     {
     }
 
     std::ranges::subrange<QMultiMap<struct ::wl_client *, Resource *>::const_iterator> resourcesForSurface(SurfaceInterface *surface) const
     {
         ClientConnection *client = surface->client();
         const auto [start, end] = resourceMap().equal_range(*client);
         return std::ranges::subrange(start, end);
     }
 
     void zwp_tablet_pad_strip_v2_destroy(Resource *resource) override
     {
         wl_resource_destroy(resource->handle);
     }
     TabletPadV2Interface *m_pad = nullptr;
     TabletPadStripV2Interface *const q;
 };
 
 TabletPadStripV2Interface::TabletPadStripV2Interface(TabletPadV2Interface *parent)
     : QObject(parent)
     , d(new TabletPadStripV2InterfacePrivate(this))
 {
     d->m_pad = parent;
 }
 
 TabletPadStripV2Interface::~TabletPadStripV2Interface() = default;
 
 void TabletPadStripV2Interface::sendFrame(quint32 time)
 {
     for (auto *resource : d->resourcesForSurface(d->m_pad->currentSurface())) {
         d->send_frame(resource->handle, time);
     }
 }
 
 void TabletPadStripV2Interface::sendPosition(quint32 position)
 {
     for (auto *resource : d->resourcesForSurface(d->m_pad->currentSurface())) {
         d->send_position(resource->handle, position);
     }
 }
 
 void TabletPadStripV2Interface::sendSource(Source source)
 {
     for (auto *resource : d->resourcesForSurface(d->m_pad->currentSurface())) {
         d->send_source(resource->handle, source);
     }
 }
 
 void TabletPadStripV2Interface::sendStop()
 {
     for (auto *resource : d->resourcesForSurface(d->m_pad->currentSurface())) {
         d->send_stop(resource->handle);
     }
 }
 
 class TabletPadGroupV2InterfacePrivate : public QtWaylandServer::zwp_tablet_pad_group_v2
 {
 public:
     TabletPadGroupV2InterfacePrivate(quint32 currentMode, TabletPadGroupV2Interface *q)
         : zwp_tablet_pad_group_v2()
         , q(q)
         , m_currentMode(currentMode)
     {
     }
 
     std::ranges::subrange<QMultiMap<struct ::wl_client *, Resource *>::const_iterator> resourcesForSurface(SurfaceInterface *surface) const
     {
         ClientConnection *client = surface->client();
         const auto [start, end] = resourceMap().equal_range(*client);
         return std::ranges::subrange(start, end);
     }
 
     void zwp_tablet_pad_group_v2_destroy(Resource *resource) override
     {
         wl_resource_destroy(resource->handle);
     }
 
     TabletPadGroupV2Interface *const q;
     TabletPadV2Interface *m_pad = nullptr;
     quint32 m_currentMode;
 };
 
 TabletPadGroupV2Interface::TabletPadGroupV2Interface(quint32 currentMode, TabletPadV2Interface *parent)
     : QObject(parent)
     , d(new TabletPadGroupV2InterfacePrivate(currentMode, this))
 {
     d->m_pad = parent;
 }
 
 TabletPadGroupV2Interface::~TabletPadGroupV2Interface() = default;
 
 void TabletPadGroupV2Interface::sendModeSwitch(quint32 time, quint32 serial, quint32 mode)
 {
     d->m_currentMode = mode;
     for (auto *resource : d->resourcesForSurface(d->m_pad->currentSurface())) {
         d->send_mode_switch(resource->handle, time, serial, mode);
     }
 }
 
 class TabletPadV2InterfacePrivate : public QtWaylandServer::zwp_tablet_pad_v2
 {
 public:
     TabletPadV2InterfacePrivate(const QString &path,
                                 quint32 buttons,
                                 quint32 rings,
                                 quint32 strips,
                                 quint32 modes,
                                 quint32 currentMode,
                                 Display *display,
                                 TabletPadV2Interface *q)
         : zwp_tablet_pad_v2()
         , q(q)
         , m_path(path)
         , m_buttons(buttons)
         , m_modes(modes)
         , m_padGroup(new TabletPadGroupV2Interface(currentMode, q))
         , m_display(display)
     {
         for (uint i = 0; i < buttons; ++i) {
             m_buttons[i] = i;
         }
 
         m_rings.reserve(rings);
         for (quint32 i = 0; i < rings; ++i) {
             m_rings += new TabletPadRingV2Interface(q);
         }
 
         m_strips.reserve(strips);
         for (quint32 i = 0; i < strips; ++i) {
             m_strips += new TabletPadStripV2Interface(q);
         }
     }
 
     ~TabletPadV2InterfacePrivate() override
     {
         qDeleteAll(m_rings);
         qDeleteAll(m_strips);
     }
 
     void zwp_tablet_pad_v2_destroy(Resource *resource) override
     {
         wl_resource_destroy(resource->handle);
     }
 
     void zwp_tablet_pad_v2_set_feedback(Resource *resource, quint32 button, const QString &description, quint32 serial) override
     {
         Q_EMIT q->feedback(m_display->getConnection(resource->client()), button, description, serial);
     }
 
     std::ranges::subrange<QMultiMap<struct ::wl_client *, Resource *>::const_iterator> resourcesForSurface(SurfaceInterface *surface) const
     {
         ClientConnection *client = surface->client();
         const auto [start, end] = resourceMap().equal_range(*client);
         return std::ranges::subrange(start, end);
     }
 
     TabletPadV2Interface *const q;
 
     const QString m_path;
     QList<quint32> m_buttons;
     const int m_modes;
 
     QList<TabletPadRingV2Interface *> m_rings;
     QList<TabletPadStripV2Interface *> m_strips;
     TabletPadGroupV2Interface *const m_padGroup;
     TabletSeatV2Interface *m_seat = nullptr;
     QPointer<SurfaceInterface> m_currentSurface;
     Display *const m_display;
 };
 
 TabletPadV2Interface::TabletPadV2Interface(const QString &path,
                                            quint32 buttons,
                                            quint32 rings,
                                            quint32 strips,
                                            quint32 modes,
                                            quint32 currentMode,
                                            Display *display,
                                            TabletSeatV2Interface *parent)
     : QObject(parent)
     , d(new TabletPadV2InterfacePrivate(path, buttons, rings, strips, modes, currentMode, display, this))
 {
     d->m_seat = parent;
 }
 
 TabletPadV2Interface::~TabletPadV2Interface()
 {
     const auto tabletPadResources = d->resourceMap();
     for (TabletPadV2InterfacePrivate::Resource *resource : tabletPadResources) {
         d->send_removed(resource->handle);
     }
 }
 
 void TabletPadV2Interface::sendButton(std::chrono::microseconds time, quint32 button, bool pressed)
 {
     const auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
     for (auto *resource : d->resourcesForSurface(currentSurface())) {
         d->send_button(resource->handle, milliseconds, button, pressed);
     }
 }
 
 TabletPadRingV2Interface *TabletPadV2Interface::ring(uint at) const
 {
     return d->m_rings[at];
 }
 
 TabletPadStripV2Interface *TabletPadV2Interface::strip(uint at) const
 {
     return d->m_strips[at];
 }
 
 void TabletPadV2Interface::setCurrentSurface(SurfaceInterface *surface, TabletV2Interface *tablet)
 {
     if (surface == d->m_currentSurface) {
         return;
     }
 
     if (d->m_currentSurface) {
         auto serial = d->m_display->nextSerial();
         for (auto *resource : d->resourcesForSurface(d->m_currentSurface)) {
             d->send_leave(resource->handle, serial, d->m_currentSurface->resource());
         }
     }
 
     d->m_currentSurface = surface;
     if (surface) {
         wl_resource *tabletResource = tablet->d->resourceForSurface(surface);
 
         auto serial = d->m_display->nextSerial();
         for (auto *resource : d->resourcesForSurface(surface)) {
             d->send_enter(resource->handle, serial, tabletResource, surface->resource());
         }
         d->m_padGroup->sendModeSwitch(0, d->m_display->nextSerial(), d->m_padGroup->d->m_currentMode);
     }
 }
 
 SurfaceInterface *TabletPadV2Interface::currentSurface() const
 {
     return d->m_currentSurface;
 }
 
 class TabletSeatV2InterfacePrivate : public QtWaylandServer::zwp_tablet_seat_v2
 {
 public:
     TabletSeatV2InterfacePrivate(Display *display, TabletSeatV2Interface *q)
         : zwp_tablet_seat_v2()
         , q(q)
         , m_display(display)
     {
     }
 
     void zwp_tablet_seat_v2_bind_resource(Resource *resource) override
     {
         for (auto tablet : std::as_const(m_tablets)) {
             sendTabletAdded(resource, tablet);
         }
 
         for (auto pad : std::as_const(m_pads)) {
             sendPadAdded(resource, pad);
         }
 
         for (const auto &tools : std::as_const(m_tools)) {
             for (auto *tool : tools) {
                 sendToolAdded(resource, tool);
             }
         }
     }
 
     void zwp_tablet_seat_v2_destroy(Resource *resource) override
     {
         wl_resource_destroy(resource->handle);
     }
 
     void sendToolAdded(Resource *resource, TabletToolV2Interface *tool)
     {
         wl_resource *toolResource = tool->d->add(resource->client(), resource->version())->handle;
         send_tool_added(resource->handle, toolResource);
 
         tool->d->send_type(toolResource, tool->d->m_type);
         tool->d->send_hardware_serial(toolResource, tool->d->m_hardwareSerialHigh, tool->d->m_hardwareSerialLow);
         tool->d->send_hardware_id_wacom(toolResource, tool->d->m_hardwareIdHigh, tool->d->m_hardwareIdLow);
         for (uint32_t cap : std::as_const(tool->d->m_capabilities)) {
             tool->d->send_capability(toolResource, cap);
         }
         tool->d->send_done(toolResource);
     }
     void sendTabletAdded(Resource *resource, TabletV2Interface *tablet)
     {
         wl_resource *tabletResource = tablet->d->add(resource->client(), resource->version())->handle;
         send_tablet_added(resource->handle, tabletResource);
 
         tablet->d->send_name(tabletResource, tablet->d->m_name);
         if (tablet->d->m_vendorId && tablet->d->m_productId) {
             tablet->d->send_id(tabletResource, tablet->d->m_vendorId, tablet->d->m_productId);
         }
         for (const QString &path : std::as_const(tablet->d->m_paths)) {
             tablet->d->send_path(tabletResource, path);
         }
         tablet->d->send_done(tabletResource);
     }
 
     void sendPadAdded(Resource *resource, TabletPadV2Interface *pad)
     {
         wl_resource *tabletResource = pad->d->add(resource->client(), resource->version())->handle;
         send_pad_added(resource->handle, tabletResource);
 
         pad->d->send_buttons(tabletResource, pad->d->m_buttons.size());
         pad->d->send_path(tabletResource, pad->d->m_path);
 
         auto groupResource = pad->d->m_padGroup->d->add(resource->client(), resource->version());
         pad->d->send_group(tabletResource, groupResource->handle);
         pad->d->m_padGroup->d->send_modes(groupResource->handle, pad->d->m_modes);
 
         pad->d->m_padGroup->d->send_buttons(
             groupResource->handle,
             QByteArray::fromRawData(reinterpret_cast<const char *>(pad->d->m_buttons.data()), pad->d->m_buttons.size() * sizeof(quint32)));
 
         for (auto ring : std::as_const(pad->d->m_rings)) {
             auto ringResource = ring->d->add(resource->client(), resource->version());
             pad->d->m_padGroup->d->send_ring(groupResource->handle, ringResource->handle);
         }
 
         for (auto strip : std::as_const(pad->d->m_strips)) {
             auto stripResource = strip->d->add(resource->client(), resource->version());
             pad->d->m_padGroup->d->send_strip(groupResource->handle, stripResource->handle);
         }
         pad->d->m_padGroup->d->send_done(groupResource->handle);
         pad->d->send_done(tabletResource);
     }
 
     TabletSeatV2Interface *const q;
     QHash<QString, QList<TabletToolV2Interface *>> m_tools;
     QHash<QString, TabletV2Interface *> m_tablets;
     QHash<QString, TabletPadV2Interface *> m_pads;
     Display *const m_display;
 };
 
 TabletSeatV2Interface::TabletSeatV2Interface(Display *display, QObject *parent)
     : QObject(parent)
     , d(new TabletSeatV2InterfacePrivate(display, this))
 {
 }
 
 TabletSeatV2Interface::~TabletSeatV2Interface() = default;
 
 TabletToolV2Interface *TabletSeatV2Interface::addTool(TabletToolV2Interface::Type type,
                                                       quint64 hardwareSerial,
                                                       quint64 hardwareId,
                                                       const QList<TabletToolV2Interface::Capability> &capabilities,
                                                       const QString &deviceSysName)
 {
     constexpr auto MAX_UINT_32 = std::numeric_limits<quint32>::max();
     auto tool = new TabletToolV2Interface(d->m_display,
                                           type,
                                           hardwareSerial >> 32,
                                           hardwareSerial & MAX_UINT_32,
                                           hardwareId >> 32,
                                           hardwareId & MAX_UINT_32,
                                           capabilities);
     for (QtWaylandServer::zwp_tablet_seat_v2::Resource *resource : d->resourceMap()) {
         d->sendToolAdded(resource, tool);
     }
 
     d->m_tools[deviceSysName].append(tool);
     return tool;
 }
 
 TabletV2Interface *
 TabletSeatV2Interface::addTablet(uint32_t vendorId, uint32_t productId, const QString &sysname, const QString &name, const QStringList &paths)
 {
     Q_ASSERT(!d->m_tablets.contains(sysname));
 
     auto iface = new TabletV2Interface(vendorId, productId, name, paths, this);
 
     for (QtWaylandServer::zwp_tablet_seat_v2::Resource *r : d->resourceMap()) {
         d->sendTabletAdded(r, iface);
     }
 
     d->m_tablets[sysname] = iface;
     return iface;
 }
 
 TabletPadV2Interface *TabletSeatV2Interface::addTabletPad(const QString &sysname,
                                                           const QString &name,
                                                           const QStringList &paths,
                                                           quint32 buttons,
                                                           quint32 rings,
                                                           quint32 strips,
                                                           quint32 modes,
                                                           quint32 currentMode,
                                                           TabletV2Interface *tablet)
 {
     auto iface = new TabletPadV2Interface(paths.at(0), buttons, rings, strips, modes, currentMode, d->m_display, this);
     iface->d->m_seat = this;
     for (auto r : d->resourceMap()) {
         d->sendPadAdded(r, iface);
     }
 
     tablet->d->m_pad = iface;
 
     d->m_pads[sysname] = iface;
     return iface;
 }
 
 void TabletSeatV2Interface::removeDevice(const QString &sysname)
 {
     delete d->m_tablets.take(sysname);
     delete d->m_pads.take(sysname);
 
     qDeleteAll(d->m_tools.take(sysname));
 }
 
 TabletToolV2Interface *TabletSeatV2Interface::toolByHardwareId(quint64 hardwareId) const
 {
     for (const auto &tools : std::as_const(d->m_tools)) {
         for (TabletToolV2Interface *tool : tools) {
             if (tool->d->hardwareId() == hardwareId) {
                 return tool;
             }
         }
     }
     return nullptr;
 }
 
 TabletToolV2Interface *TabletSeatV2Interface::toolByHardwareSerial(quint64 hardwareSerial, TabletToolV2Interface::Type type) const
 {
     for (const auto &tools : std::as_const(d->m_tools)) {
         for (TabletToolV2Interface *tool : tools) {
             if (tool->d->hardwareSerial() == hardwareSerial && tool->d->m_type == type) {
                 return tool;
             }
         }
     }
     return nullptr;
 }
 
 TabletPadV2Interface *TabletSeatV2Interface::padByName(const QString &name) const
 {
     Q_ASSERT(d->m_pads.contains(name));
     return d->m_pads.value(name);
 }
 
 class TabletManagerV2InterfacePrivate : public QtWaylandServer::zwp_tablet_manager_v2
 {
 public:
     TabletManagerV2InterfacePrivate(Display *display, TabletManagerV2Interface *q)
         : zwp_tablet_manager_v2(*display, s_version)
         , q(q)
         , m_display(display)
     {
     }
 
     void zwp_tablet_manager_v2_get_tablet_seat(Resource *resource, uint32_t tablet_seat, struct ::wl_resource *seat_resource) override
     {
         SeatInterface *seat = SeatInterface::get(seat_resource);
         TabletSeatV2Interface *tsi = get(seat);
         tsi->d->add(resource->client(), tablet_seat, s_version);
     }
 
     TabletSeatV2Interface *get(SeatInterface *seat)
     {
         TabletSeatV2Interface *&tabletSeat = m_seats[seat];
         if (!tabletSeat) {
             tabletSeat = new TabletSeatV2Interface(m_display, q);
         }
         return tabletSeat;
     }
 
     TabletManagerV2Interface *const q;
     Display *const m_display;
     QHash<SeatInterface *, TabletSeatV2Interface *> m_seats;
 };
 
 TabletManagerV2Interface::TabletManagerV2Interface(Display *display, QObject *parent)
     : QObject(parent)
     , d(new TabletManagerV2InterfacePrivate(display, this))
 {
 }
 
 TabletSeatV2Interface *TabletManagerV2Interface::seat(SeatInterface *seat) const
 {
     return d->get(seat);
 }
 
 bool TabletSeatV2Interface::isClientSupported(ClientConnection *client) const
 {
     return d->resourceMap().value(*client);
 }
 
 bool TabletSeatV2Interface::hasImplicitGrab(quint32 serial) const
 {
     return std::any_of(d->m_tools.cbegin(), d->m_tools.cend(), [serial](const auto &tools) {
         return std::any_of(tools.cbegin(), tools.cend(), [serial](const auto tool) {
             return tool->downSerial() == serial;
         });
     });
 }
 
 TabletManagerV2Interface::~TabletManagerV2Interface() = default;
 
 } // namespace KWin
 
 #include "moc_tablet_v2.cpp"