Differential D26858 Diff 74217 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 "resource_p.h"
22​#include "seat_interface.h"
23​#include "display.h"
24​#include "surface_interface.h"
25​
26​#include <QHash>
27​#include "qwayland-server-tablet-unstable-v2.h"
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​ const uint32_t m_vendorId;
46​ const uint32_t m_productId;
47​ const QString m_name;
48​ const QStringList m_paths;
49​};
50​
51​TabletInterface::TabletInterface(uint32_t vendorId, uint32_t productId,
52​ const QString &name, const QStringList &paths,
53​ QObject* parent)
zzagUnsubmitted
Done

Align pointers to right.

zzag: Align pointers to right.
54​ : QObject(parent)
55​ , d(new Private(vendorId, productId, name, paths))
56​{
57​}
58​
59​TabletInterface::~TabletInterface() = default;
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​
61​wl_resource * TabletInterface::resourceForSurface(SurfaceInterface* surface)
62​{
63​ auto *client = surface->client();
64​ const auto r = d->resourceMap().value(*client);
zzagUnsubmitted
Done

No auto.

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

Add braces.

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

Put a single space before *.

Display * const m_display;
zzag: Put a single space before `*`. ```lang=cpp Display * const m_display; ```
367​ QHash<SeatInterface*, TabletSeatInterface*> m_seats;
368​};
369​
370​TabletManagerInterface::TabletManagerInterface(Display *display, QObject *parent)
zzagUnsubmitted
Not Done

The opening brace must be on its own line.

zzag: The opening brace must be on its own line.
371​ : QObject(parent)
zzagUnsubmitted
Not Done
SeatInterface *seat = SeatInterface::get(seat_resource);
zzag: ```lang=cpp SeatInterface *seat = SeatInterface::get(seat_resource); ```
372​ , d(new Private(display, this))
373​{
374​}
375​
376​TabletSeatInterface* TabletManagerInterface::seat(SeatInterface* seat) const
377​{
378​ return d->get(seat);
379​}
380​
381​TabletManagerInterface::~TabletManagerInterface() = default;