Differential D26858 Diff 77861 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(TabletInterface* q, uint32_t vendorId, uint32_t productId, const QString name, const QStringList &paths)
38​ : zwp_tablet_v2()
39​ , q(q)
40​ , m_vendorId(vendorId)
41​ , m_productId(productId)
42​ , m_name(name)
43​ , m_paths(paths)
44​ {
45​ }
46​
47​ wl_resource *resourceForSurface(SurfaceInterface *surface) const
48​ {
49​ ClientConnection *client = surface->client();
50​ QtWaylandServer::zwp_tablet_v2::Resource *r = resourceMap().value(*client);
51​ return r ? r->handle : nullptr;
52​ }
53​
54​ void zwp_tablet_v2_destroy_resource(QtWaylandServer::zwp_tablet_v2::Resource * resource) override
zzagUnsubmitted
Done

Align pointers to right.

zzag: Align pointers to right.
55​ {
56​ delete q;
57​ }
58​
59​ TabletInterface *const q;
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 uint32_t m_vendorId;
61​ const uint32_t m_productId;
62​ const QString m_name;
63​ const QStringList m_paths;
64​};
zzagUnsubmitted
Done

No auto.

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

Add braces.

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

Put a single space before *.

Display * const m_display;
zzag: Put a single space before `*`. ```lang=cpp Display * const m_display; ```
368​ }
369​ return nullptr;
370​}
zzagUnsubmitted
Not Done

The opening brace must be on its own line.

zzag: The opening brace must be on its own line.
371​
zzagUnsubmitted
Not Done
SeatInterface *seat = SeatInterface::get(seat_resource);
zzag: ```lang=cpp SeatInterface *seat = SeatInterface::get(seat_resource); ```
372​TabletToolInterface *TabletSeatInterface::toolByHardwareSerial(quint64 hardwareSerial) const
373​{
374​ for (TabletToolInterface *tool : d->m_tools) {
375​ if (tool->d->hardwareSerial() == hardwareSerial)
376​ return tool;
377​ }
378​ return nullptr;
379​}
380​
381​TabletInterface *TabletSeatInterface::tabletByName(const QString &name) const
382​{
383​ return d->m_tablets.value(name);
384​}
385​
386​class TabletManagerInterface::Private : public QtWaylandServer::zwp_tablet_manager_v2
387​{
388​public:
389​ Private(Display *display, TabletManagerInterface *q)
390​ : zwp_tablet_manager_v2(*display, s_version)
391​ , q(q)
392​ , m_display(display)
393​ {
394​ }
395​
396​ void zwp_tablet_manager_v2_get_tablet_seat(Resource *resource, uint32_t tablet_seat,
397​ struct ::wl_resource *seat_resource) override {
398​ SeatInterface* seat = SeatInterface::get(seat_resource);
399​ TabletSeatInterface *tsi = get(seat);
400​ tsi->d->add(resource->client(), tablet_seat, s_version);
401​ }
402​
403​ TabletSeatInterface *get(SeatInterface *seat)
404​ {
405​ TabletSeatInterface *&tabletSeat = m_seats[seat];
406​ if (!tabletSeat) {
407​ tabletSeat = new TabletSeatInterface(m_display, q);
408​ }
409​ return tabletSeat;
410​ }
411​
412​ TabletManagerInterface *const q;
413​ Display *const m_display;
414​ QHash<SeatInterface *, TabletSeatInterface *> m_seats;
415​};
416​
417​TabletManagerInterface::TabletManagerInterface(Display *display, QObject *parent)
418​ : QObject(parent)
419​ , d(new Private(display, this))
420​{
421​}
422​
423​TabletSeatInterface *TabletManagerInterface::seat(SeatInterface *seat) const
424​{
425​ return d->get(seat);
426​}
427​
428​TabletManagerInterface::~TabletManagerInterface() = default;