Differential D26858 Diff 74473 src/server/tablet_interface.cpp

Changeset View

Standalone View

View Options

src/server/tablet_interface.cpp

  • This file was added.
1​/********************************************************************
2​Copyright 2019 Aleix Pol Gonzalez <aleixpol@kde.org>
3​
4​This library is free software; you can redistribute it and/or
5​modify it under the terms of the GNU Lesser General Public
6​License as published by the Free Software Foundation; either
7​version 2.1 of the License, or (at your option) version 3, or any
8​later version accepted by the membership of KDE e.V. (or its
9​successor approved by the membership of KDE e.V.), which shall
10​act as a proxy defined in Section 6 of version 3 of the license.
11​
12​This library is distributed in the hope that it will be useful,
13​but WITHOUT ANY WARRANTY; without even the implied warranty of
14​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15​Lesser General Public License for more details.
16​
17​You should have received a copy of the GNU Lesser General Public
18​License along with this library. If not, see <http://www.gnu.org/licenses/>.
19​*********************************************************************/
20​#include "tablet_interface.h"
21​#include "display.h"
22​#include "resource_p.h"
23​#include "seat_interface.h"
24​#include "surface_interface.h"
25​
26​#include "qwayland-server-tablet-unstable-v2.h"
27​#include <QHash>
28​
29​using namespace KWayland;
30​using namespace Server;
31​
32​static int s_version = 1;
33​
34​class TabletInterface::Private : public QtWaylandServer::zwp_tablet_v2
35​{
36​public:
37​ Private(uint32_t vendorId, uint32_t productId, const QString name, const QStringList &paths)
38​ : zwp_tablet_v2()
39​ , m_vendorId(vendorId)
40​ , m_productId(productId)
41​ , m_name(name)
42​ , m_paths(paths)
43​ {
44​ }
45​
46​ wl_resource *resourceForSurface(SurfaceInterface *surface) const
47​ {
48​ ClientConnection *client = surface->client();
49​ QtWaylandServer::zwp_tablet_v2::Resource *r = resourceMap().value(*client);
50​ return r ? r->handle : nullptr;
51​ }
52​
53​ const uint32_t m_vendorId;
54​ const uint32_t m_productId;
zzagUnsubmitted
Done

Align pointers to right.

zzag: Align pointers to right.
55​ const QString m_name;
56​ const QStringList m_paths;
57​};
58​
59​TabletInterface::TabletInterface(uint32_t vendorId, uint32_t productId,
davidedmundsonUnsubmitted
Not Done

This is still potentially crashy:
if all clients remove their tablet support we would have a dangling pointer in m_tablets.

Personally I would remove this delete q, and have the lifespan of TabletInterface managed up to TabletSeatInterface::removeTablet or TabletSeatInterface::~TabletSeatInterface()

even if it has no resources.

davidedmundson: This is still potentially crashy: if all clients remove their tablet support we would have a…
davidedmundsonUnsubmitted
Not Done

or if we do want to keep the TabletInterface around till clients gracefully remove their side
we should have some sort of if (resourcesMap.isEmpty() && isRemoved) {delete q}

davidedmundson: or if we do want to keep the TabletInterface around till clients gracefully remove their side…
60​ const QString &name, const QStringList &paths,
61​ QObject *parent)
62​ : QObject(parent)
63​ , d(new Private(vendorId, productId, name, paths))
64​{
zzagUnsubmitted
Done

No auto.

zzag: No `auto`.
65​}
66​
67​TabletInterface::~TabletInterface() = default;
68​
69​bool TabletInterface::isSurfaceSupported(SurfaceInterface *surface) const
70​{
71​ return d->resourceForSurface(surface);
72​}
73​
74​class TabletToolInterface::Private : public QtWaylandServer::zwp_tablet_tool_v2
75​{
76​public:
77​ Private(Display *display, Type type, uint32_t hsh, uint32_t hsl, uint32_t hih,
78​ uint32_t hil, const QVector<Capability>& capabilities)
79​ : zwp_tablet_tool_v2()
80​ , m_display(display)
81​ , m_type(type)
82​ , m_hardwareSerialHigh(hsh)
83​ , m_hardwareSerialLow(hsl)
84​ , m_hardwareIdHigh(hih)
85​ , m_hardwareIdLow(hil)
86​ , m_capabilities(capabilities)
87​ {
88​ }
89​
90​ Display *const m_display;
91​
92​ wl_resource *targetResource()
93​ {
94​ ClientConnection *client = m_surface->client();
95​ const Resource *r = resourceMap().value(*client);
96​ return r ? r->handle : nullptr;
97​ }
98​
99​ quint64 hardwareSerial() const
100​ {
101​ return quint64(quint64(m_hardwareIdHigh) << 32) + m_hardwareIdLow;
102​ }
103​
104​ bool m_cleanup = false;
105​ QPointer<SurfaceInterface> m_surface;
106​ QPointer<TabletInterface> m_lastTablet;
107​ const uint32_t m_type;
108​ const uint32_t m_hardwareSerialHigh, m_hardwareSerialLow;
109​ const uint32_t m_hardwareIdHigh, m_hardwareIdLow;
110​ const QVector<Capability> m_capabilities;
111​};
112​
113​TabletToolInterface::TabletToolInterface(Display *display, Type type, uint32_t hsh,
114​ uint32_t hsl, uint32_t hih, uint32_t hil,
115​ const QVector<Capability>& capabilities,
116​ QObject *parent)
117​ : QObject(parent)
118​ , d(new Private(display, type, hsh, hsl, hih, hil, capabilities))
119​{
120​}
121​
122​TabletToolInterface::~TabletToolInterface() = default;
123​
124​void TabletToolInterface::setCurrentSurface(SurfaceInterface *surface)
125​{
126​ if (d->m_surface == surface)
127​ return;
128​
129​ TabletInterface *const lastTablet = d->m_lastTablet;
130​ if (d->m_surface && d->resourceMap().contains(*d->m_surface->client())) {
131​ sendProximityOut();
132​ sendFrame(0);
133​ }
134​
135​ d->m_surface = surface;
136​
137​ if (lastTablet && lastTablet->d->resourceForSurface(surface)) {
138​ sendProximityIn(lastTablet);
139​ } else {
140​ d->m_lastTablet = lastTablet;
141​ }
142​}
143​
144​bool TabletToolInterface::isClientSupported() const
145​{
146​ return d->m_surface && d->targetResource();
147​}
148​
149​void TabletToolInterface::sendButton(uint32_t button, bool pressed)
150​{
151​ d->send_button(d->targetResource(), d->m_display->nextSerial(), button,
152​ pressed ? QtWaylandServer::zwp_tablet_tool_v2::button_state_pressed
153​ : QtWaylandServer::zwp_tablet_tool_v2::button_state_released);
154​}
155​
156​void TabletToolInterface::sendMotion(const QPointF &pos)
157​{
158​ d->send_motion(d->targetResource(), wl_fixed_from_double(pos.x()),
159​ wl_fixed_from_double(pos.y()));
160​}
161​
162​void TabletToolInterface::sendDistance(uint32_t distance)
163​{
164​ d->send_distance(d->targetResource(), distance);
165​}
166​
167​void TabletToolInterface::sendFrame(uint32_t time)
168​{
169​ d->send_frame(d->targetResource(), time);
170​
171​ if (d->m_cleanup) {
172​ d->m_surface = nullptr;
173​ d->m_lastTablet = nullptr;
174​ d->m_cleanup = false;
175​ }
176​}
177​
178​void TabletToolInterface::sendPressure(uint32_t pressure)
179​{
180​ d->send_pressure(d->targetResource(), pressure);
181​}
182​
183​void TabletToolInterface::sendRotation(qreal rotation)
184​{
185​ d->send_rotation(d->targetResource(), wl_fixed_from_double(rotation));
186​}
187​
188​void TabletToolInterface::sendSlider(int32_t position)
189​{
190​ d->send_slider(d->targetResource(), position);
191​}
192​
193​void TabletToolInterface::sendTilt(qreal degreesX, qreal degreesY)
194​{
195​ d->send_tilt(d->targetResource(), wl_fixed_from_double(degreesX),
196​ wl_fixed_from_double(degreesY));
197​}
198​
199​void TabletToolInterface::sendWheel(int32_t degrees, int32_t clicks)
200​{
201​ d->send_wheel(d->targetResource(), degrees, clicks);
202​}
203​
204​void TabletToolInterface::sendProximityIn(TabletInterface *tablet)
205​{
206​ wl_resource* tabletResource = tablet->d->resourceForSurface(d->m_surface);
207​ d->send_proximity_in(d->targetResource(), d->m_display->nextSerial(),
208​ tabletResource, d->m_surface->resource());
209​ d->m_lastTablet = tablet;
210​}
211​
212​void TabletToolInterface::sendProximityOut()
213​{
214​ d->send_proximity_out(d->targetResource());
215​ d->m_cleanup = true;
216​}
217​
218​void TabletToolInterface::sendDown()
219​{
220​ d->send_down(d->targetResource(), d->m_display->nextSerial());
221​}
222​
223​void TabletToolInterface::sendUp()
224​{
225​ d->send_up(d->targetResource());
226​}
227​
228​void TabletToolInterface::sendRemoved()
229​{
230​ for (QtWaylandServer::zwp_tablet_tool_v2::Resource *resource : d->resourceMap()) {
231​ d->send_removed(resource->handle);
232​ }
233​}
234​
235​class TabletSeatInterface::Private : public QtWaylandServer::zwp_tablet_seat_v2
236​{
237​public:
238​ Private(Display *display, TabletSeatInterface *q)
zzagUnsubmitted
Done

Add braces.

zzag: Add braces.
239​ : zwp_tablet_seat_v2()
240​ , q(q)
241​ , m_display(display)
242​ {
243​ }
244​
245​ void zwp_tablet_seat_v2_bind_resource(Resource *resource) override
246​ {
247​ for (auto iface : qAsConst(m_tablets)) {
248​ sendTabletAdded(resource, iface);
249​ }
250​
251​ for (auto *tool : qAsConst(m_tools)) {
252​ sendToolAdded(resource, tool);
253​ }
254​ }
255​
256​ void sendToolAdded(Resource *resource, TabletToolInterface *tool)
257​ {
258​ wl_resource *toolResource = tool->d->add(resource->client(), resource->version())->handle;
259​ send_tool_added(resource->handle, toolResource);
260​
261​ tool->d->send_type(toolResource, tool->d->m_type);
262​ tool->d->send_hardware_serial(toolResource, tool->d->m_hardwareSerialHigh,
263​ tool->d->m_hardwareSerialLow);
264​ tool->d->send_hardware_id_wacom(toolResource, tool->d->m_hardwareIdHigh,
265​ tool->d->m_hardwareIdLow);
266​ for (uint32_t cap : qAsConst(tool->d->m_capabilities)) {
267​ tool->d->send_capability(toolResource, cap);
268​ }
269​ tool->d->send_done(toolResource);
270​ }
271​ void sendTabletAdded(Resource *resource, TabletInterface *tablet)
272​ {
273​ wl_resource *tabletResource = tablet->d->add(resource->client(), resource->version())->handle;
274​ send_tablet_added(resource->handle, tabletResource);
275​
276​ tablet->d->send_name(tabletResource, tablet->d->m_name);
277​ if (tablet->d->m_vendorId && tablet->d->m_productId) {
278​ tablet->d->send_id(tabletResource, tablet->d->m_vendorId, tablet->d->m_productId);
279​ }
280​ for (const QString &path : qAsConst(tablet->d->m_paths)) {
281​ tablet->d->send_path(tabletResource, path);
282​ }
283​ tablet->d->send_done(tabletResource);
284​ }
285​
286​ TabletSeatInterface *const q;
287​ QVector<TabletToolInterface *> m_tools;
288​ QHash<QString, TabletInterface *> m_tablets;
289​ Display *const m_display;
290​};
291​
292​TabletSeatInterface::TabletSeatInterface(Display *display, QObject *parent)
293​ : QObject(parent)
294​ , d(new Private(display, this))
295​{
296​}
297​
298​TabletSeatInterface::~TabletSeatInterface() = default;
299​
300​TabletToolInterface *TabletSeatInterface::addTool(TabletToolInterface::Type type,
301​ quint64 hardwareSerial,
302​ quint64 hardwareId,
303​ const QVector<TabletToolInterface::Capability> &capabilities)
304​{
305​ constexpr auto MAX_UINT_32 = std::numeric_limits<quint32>::max();
306​ auto tool = new TabletToolInterface(d->m_display,
307​ type, hardwareSerial >> 32, hardwareSerial & MAX_UINT_32,
308​ hardwareId >> 32, hardwareId & MAX_UINT_32, capabilities, this);
309​ for (QtWaylandServer::zwp_tablet_seat_v2::Resource *resource : d->resourceMap()) {
310​ d->sendToolAdded(resource, tool);
311​ }
312​
313​ d->m_tools.append(tool);
314​ QObject::connect(tool, &QObject::destroyed, this, [this](QObject *object) {
315​ auto tti = static_cast<TabletToolInterface *>(object);
316​ tti->d->send_removed();
317​ d->m_tools.removeAll(tti);
318​ });
319​ return tool;
320​}
321​
322​TabletInterface *TabletSeatInterface::addTablet(uint32_t vendorId, uint32_t productId,
323​ const QString &sysname,
324​ const QString &name,
325​ const QStringList &paths)
326​{
327​ auto iface = new TabletInterface(vendorId, productId, name, paths, this);
328​
329​ for (QtWaylandServer::zwp_tablet_seat_v2::Resource *r : d->resourceMap()) {
330​ d->sendTabletAdded(r, iface);
331​ }
332​
333​ d->m_tablets[sysname] = iface;
334​ return iface;
335​}
336​
337​void TabletSeatInterface::removeTablet(const QString &sysname)
338​{
339​ auto t = d->m_tablets.take(sysname);
340​ t->d->send_removed();
341​ delete t;
342​}
343​
344​TabletToolInterface *TabletSeatInterface::toolByHardwareId(quint64 serialId) const
345​{
346​ for (TabletToolInterface *tool : d->m_tools) {
347​ if (tool->d->hardwareSerial() == serialId)
davidedmundsonUnsubmitted
Not Done

We're mixing up hardwareId and hardwareSerial

this method is called toolByHardwareId calls an internal method called hardwareSerial

Yet ultimately does check:
m_hardwareIdHigh

comparing it against a serial

davidedmundson: We're mixing up hardwareId and hardwareSerial this method is called toolByHardwareId calls an…
348​ return tool;
349​ }
350​ return nullptr;
351​}
352​
353​TabletInterface *TabletSeatInterface::tabletByName(const QString &name) const
354​{
355​ return d->m_tablets.value(name);
356​}
357​
358​class TabletManagerInterface::Private : public QtWaylandServer::zwp_tablet_manager_v2
359​{
360​public:
361​ Private(Display *display, TabletManagerInterface *q)
362​ : zwp_tablet_manager_v2(*display, s_version)
363​ , q(q)
364​ , m_display(display)
365​ {
366​ }
367​
zzagUnsubmitted
Done

Put a single space before *.

Display * const m_display;
zzag: Put a single space before `*`. ```lang=cpp Display * const m_display; ```
368​ void zwp_tablet_manager_v2_get_tablet_seat(Resource *resource, uint32_t tablet_seat,
369​ struct ::wl_resource *seat_resource) override {
zzagUnsubmitted
Not Done

The opening brace must be on its own line.

zzag: The opening brace must be on its own line.
370​ SeatInterface* seat = SeatInterface::get(seat_resource);
zzagUnsubmitted
Not Done
SeatInterface *seat = SeatInterface::get(seat_resource);
zzag: ```lang=cpp SeatInterface *seat = SeatInterface::get(seat_resource); ```
371​ TabletSeatInterface *tsi = get(seat);
372​ tsi->d->add(resource->client(), tablet_seat, s_version);
373​ }
374​
375​ TabletSeatInterface *get(SeatInterface *seat)
376​ {
377​ TabletSeatInterface *&tabletSeat = m_seats[seat];
378​ if (!tabletSeat) {
379​ tabletSeat = new TabletSeatInterface(m_display, q);
380​ }
381​ return tabletSeat;
382​ }
383​
384​ TabletManagerInterface *const q;
385​ Display *const m_display;
386​ QHash<SeatInterface *, TabletSeatInterface *> m_seats;
387​};
388​
389​TabletManagerInterface::TabletManagerInterface(Display *display, QObject *parent)
390​ : QObject(parent)
391​ , d(new Private(display, this))
392​{
393​}
394​
395​TabletSeatInterface *TabletManagerInterface::seat(SeatInterface *seat) const
396​{
397​ return d->get(seat);
398​}
399​
400​TabletManagerInterface::~TabletManagerInterface() = default;