1// Copyright (C) 2020 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qinputdevice.h"
5#include "qinputdevice_p.h"
6#include "qpointingdevice.h"
7#include "qwindowsysteminterface_p.h"
8#include <QCoreApplication>
9#include <QDebug>
10#include <QMutex>
11#include <QScreen>
12
13QT_BEGIN_NAMESPACE
14
15using namespace Qt::StringLiterals;
16
17/*!
18 \class QInputDevice
19 \brief The QInputDevice class describes a device from which a QInputEvent originates.
20 \since 6.0
21 \inmodule QtGui
22
23 Each QInputEvent contains a QInputDevice pointer to allow accessing
24 device-specific properties like type, capabilities and seat. It is the
25 responsibility of the platform or generic plug-ins to discover, create and
26 register an instance of this class corresponding to each available input
27 device, via QWindowSystemInterface::registerInputDevice(), before
28 generating any input event referring to that device.
29
30 Applications do not need to instantiate this class, but can read the
31 instances pointed to by QInputEvent::device() and QInputDevice::devices().
32*/
33
34/*!
35 \enum QInputDevice::Capability
36
37 Indicates what kind of information the input device or its driver can
38 provide.
39
40 \value None
41 No information about input device capabilities available.
42
43 \value Position
44 Indicates that position information is available, meaning that the
45 position() family of functions in the touch points return valid points.
46
47 \value Area
48 Indicates that touch area information is available, meaning that
49 QEventPoint::ellipseDiameters() in the touch points return valid
50 values.
51
52 \value Pressure
53 Indicates that pressure information is available, meaning that
54 QEventPoint::pressure() returns a valid value.
55
56 \value Velocity
57 Indicates that velocity information is available, meaning that
58 QEventPoint::velocity() returns a valid vector.
59
60 \value NormalizedPosition
61 Indicates that the normalized position is available, meaning that
62 QEventPoint::globalPosition() returns a valid value.
63
64 \value MouseEmulation
65 Indicates that the device synthesizes mouse events.
66
67 \value Scroll
68 Indicates that the device has a scroll capability.
69
70 \value [since 6.2] PixelScroll
71 Indicates that the device (usually a
72 \l {QInputDevice::DeviceType::TouchPad}{touchpad})
73 scrolls with \l {QWheelEvent::pixelDelta()}{pixel precision}.
74
75 \value Hover
76 Indicates that the device has a hover capability.
77
78 \value Rotation
79 Indicates that \l {QEventPoint::}{rotation} information is available.
80
81 \value XTilt
82 Indicates that \l {QTabletEvent::xTilt()}{tilt} information is
83 available for the X-axis.
84
85 \value YTilt
86 Indicates that \l {QTabletEvent::yTilt()}{tilt} information is
87 available for the Y-axis.
88
89 \value TangentialPressure
90 Indicates that \l {QTabletEvent::tangentialPressure()}
91 {tangential pressure} information is available.
92
93 \value ZPosition
94 Indicates that position information for the \l {QTabletEvent::z()}
95 {Z-axis} is available.
96
97 \value All
98*/
99
100/*!
101 Creates a new invalid input device instance as a child of \a parent.
102*/
103QInputDevice::QInputDevice(QObject *parent)
104 : QObject(*(new QInputDevicePrivate(QString(), -1, QInputDevice::DeviceType::Unknown)), parent)
105{
106}
107
108QInputDevice::~QInputDevice()
109{
110 QInputDevicePrivate::unregisterDevice(dev: this);
111}
112
113/*!
114 Creates a new input device instance. The given \a name is normally a
115 manufacturer-assigned model name if available, or something else
116 identifiable; \a id is a platform-specific number that will be unique per
117 device (for example the xinput ID on X11); \a type identifies what kind of
118 device. On window systems that are capable of handling input from multiple
119 users or sets of input devices at the same time (such as Wayland or X11),
120 \a seatName identifies the name of the set of devices that will be used
121 together. If the device is a child or slave device (for example one of
122 several mice that can take turns moving the "core pointer"), the master
123 device should be given as the \a parent.
124
125 The platform plugin creates, registers and continues to own each device
126 instance; usually \a parent should be given for memory management purposes
127 even if there is no master for a particular device.
128
129 By default, capabilities() are \c None.
130*/
131QInputDevice::QInputDevice(const QString &name, qint64 id, QInputDevice::DeviceType type,
132 const QString &seatName, QObject *parent)
133 : QObject(*new QInputDevicePrivate(name, id, type, QInputDevice::Capability::None, seatName), parent)
134{
135}
136
137/*!
138 \internal
139*/
140QInputDevice::QInputDevice(QInputDevicePrivate &d, QObject *parent)
141 : QObject(d, parent)
142{
143}
144
145/*!
146 \property QInputDevice::availableVirtualGeometry
147 \brief the region within the virtual desktop that this device can access.
148
149 For example, a \l {QInputDevice::DeviceType}{TouchScreen} input
150 device is fixed in place upon a single physical screen and usually
151 calibrated so that this area is the same as QScreen::geometry(), whereas
152 a \l {QInputDevice::DeviceType}{Mouse} is typically able to access all
153 screens on the virtual desktop.
154
155 Alternatively, a Wacom graphics tablet may be configured so that it is
156 mapped to all screens, or only to the screen where the user prefers to
157 create drawings, or only to the window in which drawing occurs.
158
159 A \l {QInputDevice::DeviceType}{Stylus} device that is integrated
160 with a touchscreen may be physically limited to that screen.
161
162 If the returned rectangle is \l {QRect::isNull()}{null}, it means this device
163 can access the entire virtual desktop.
164*/
165QRect QInputDevice::availableVirtualGeometry() const
166{
167 Q_D(const QInputDevice);
168 return d->availableVirtualGeometry;
169}
170
171/*!
172 Returns the device name.
173
174 This string may be empty. It is however useful on systems that have
175 multiple input devices: it can be used to differentiate from which device a
176 QPointerEvent originates.
177*/
178QString QInputDevice::name() const
179{
180 Q_D(const QInputDevice);
181 return d->name;
182}
183
184/*!
185 Returns the device type.
186*/
187QInputDevice::DeviceType QInputDevice::type() const
188{
189 Q_D(const QInputDevice);
190 return d->deviceType;
191}
192
193/*!
194 Returns the device capabilities.
195*/
196QInputDevice::Capabilities QInputDevice::capabilities() const
197{
198 Q_D(const QInputDevice);
199 return QInputDevice::Capabilities(d->capabilities);
200}
201
202/*!
203 Returns whether the device capabilities include the given \a capability.
204*/
205bool QInputDevice::hasCapability(QInputDevice::Capability capability) const
206{
207 return capabilities().testFlag(flag: capability);
208}
209
210/*!
211 Returns the platform specific system ID (for example xinput ID on the X11 platform).
212
213 All platforms are expected to provide a unique system ID for each device.
214*/
215qint64 QInputDevice::systemId() const
216{
217 Q_D(const QInputDevice);
218 return d->systemId;
219}
220
221/*!
222 Returns the seat with which the device is associated, if known; otherwise empty.
223
224 Devices that are intended to be used together by one user may be configured
225 to have the same seat name. That is only possible on Wayland and X11
226 platforms so far.
227*/
228QString QInputDevice::seatName() const
229{
230 Q_D(const QInputDevice);
231 return d->seatName;
232}
233
234using InputDevicesList = QList<const QInputDevice *>;
235Q_GLOBAL_STATIC(InputDevicesList, deviceList)
236Q_CONSTINIT static QBasicMutex devicesMutex;
237
238/*!
239 Returns a list of all registered input devices (keyboards and pointing devices).
240
241 \note The list of devices is not always complete on all platforms. So far,
242 the most-complete information is available on the \l {Qt for Linux/X11}{X11}
243 platform, at startup and in response to hot-plugging. Most other platforms
244 are only able to provide generic devices of various types, only after receiving
245 events from them; and most platforms do not tell Qt when a device is plugged in,
246 or when it is unplugged at runtime.
247
248 \note The returned list cannot be used to add new devices. To add a simulated
249 touch screen for an autotest, QTest::createTouchDevice() can be used.
250 Platform plugins should call QWindowSystemInterface::registerInputDevice()
251 to add devices as they are discovered.
252*/
253QList<const QInputDevice *> QInputDevice::devices()
254{
255 QMutexLocker lock(&devicesMutex);
256 return *deviceList();
257}
258
259/*!
260 \since 6.3
261
262 Returns a list of seat names for all registered input devices (keyboards and pointing devices).
263*/
264QStringList QInputDevice::seatNames()
265{
266 QMutexLocker locker(&devicesMutex);
267 const InputDevicesList devices = *deviceList();
268 locker.unlock();
269 QStringList result;
270 for (const QInputDevice *d : devices) {
271 if (!result.contains(str: d->seatName()))
272 result.append(t: d->seatName());
273 }
274
275 return result;
276}
277
278/*!
279 Returns the core or master keyboard on the given seat \a seatName.
280*/
281const QInputDevice *QInputDevice::primaryKeyboard(const QString& seatName)
282{
283 QMutexLocker locker(&devicesMutex);
284 const InputDevicesList devices = *deviceList();
285 locker.unlock();
286 const QInputDevice *ret = nullptr;
287 for (const QInputDevice *d : devices) {
288 if (d->type() != DeviceType::Keyboard)
289 continue;
290 if (seatName.isNull() || d->seatName() == seatName) {
291 // the master keyboard's parent is not another input device
292 if (!d->parent() || !qobject_cast<const QInputDevice *>(object: d->parent()))
293 return d;
294 if (!ret)
295 ret = d;
296 }
297 }
298 if (!ret) {
299 qCDebug(lcQpaInputDevices) << "no keyboards registered for seat" << seatName
300 << "The platform plugin should have provided one via "
301 "QWindowSystemInterface::registerInputDevice(). Creating a default one for now.";
302 ret = new QInputDevice("core keyboard"_L1, 0, DeviceType::Keyboard, seatName, QCoreApplication::instance());
303 QInputDevicePrivate::registerDevice(dev: ret);
304 return ret;
305 }
306 qWarning() << "core keyboard ambiguous for seat" << seatName;
307 return ret;
308}
309
310QInputDevicePrivate::~QInputDevicePrivate()
311 = default;
312
313/*!
314 \internal
315 Checks whether a matching device is already registered
316 (via operator==, not pointer equality).
317*/
318bool QInputDevicePrivate::isRegistered(const QInputDevice *dev)
319{
320 if (!dev)
321 return false;
322 QMutexLocker locker(&devicesMutex);
323 InputDevicesList v = *deviceList();
324 for (const QInputDevice *d : v)
325 if (d && *d == *dev)
326 return true;
327 return false;
328}
329
330/*!
331 \internal
332 Find the device with the given \a systemId (for example the xinput
333 device ID on X11), which is expected to be unique if nonzero.
334
335 If the \a systemId is not unique, this function returns the first one found.
336
337 \note Use QInputDevicePrivate::queryTabletDevice() if the device is a
338 tablet or a tablet stylus; in that case, \a id is not unique.
339*/
340const QInputDevice *QInputDevicePrivate::fromId(qint64 systemId)
341{
342 QMutexLocker locker(&devicesMutex);
343 for (const QInputDevice *dev : *deviceList()) {
344 if (dev->systemId() == systemId)
345 return dev;
346 }
347 return nullptr;
348}
349
350void QInputDevicePrivate::registerDevice(const QInputDevice *dev)
351{
352 QMutexLocker lock(&devicesMutex);
353 deviceList()->append(t: dev);
354 qCInfo(lcQpaInputDevices) << "Registered" << dev;
355}
356
357/*!
358 \internal
359*/
360void QInputDevicePrivate::unregisterDevice(const QInputDevice *dev)
361{
362 if (deviceList.isDestroyed())
363 return; // nothing to remove!
364
365 QMutexLocker lock(&devicesMutex);
366 deviceList()->removeOne(t: dev);
367 qCInfo(lcQpaInputDevices) << "Unregistered" << dev;
368}
369
370bool QInputDevice::operator==(const QInputDevice &other) const
371{
372 return systemId() == other.systemId();
373}
374
375#ifndef QT_NO_DEBUG_STREAM
376QDebug operator<<(QDebug debug, const QInputDevice *device)
377{
378 QDebugStateSaver saver(debug);
379 debug.nospace();
380 debug.noquote();
381
382 debug << "QInputDevice(";
383 if (!device)
384 return debug << "0x0)";
385
386 const QInputDevicePrivate *d = QInputDevicePrivate::get(q: device);
387
388 if (d->pointingDeviceType)
389 return operator<<(debug, static_cast<const QPointingDevice *>(device));
390
391 debug << "QInputDevice(";
392 debug << '"' << device->name() << "\", type=" << device->type()
393 << ", ID=" << device->systemId() << ", seat='" << device->seatName() << "'";
394 debug << ')';
395 return debug;
396}
397#endif // !QT_NO_DEBUG_STREAM
398
399QT_END_NAMESPACE
400
401#include "moc_qinputdevice.cpp"
402

source code of qtbase/src/gui/kernel/qinputdevice.cpp