Differential D8460 Diff 21675 kcms/input/backends/x11/x11mousebackend.cpp

Changeset View

Standalone View

View Options

kcms/input/backends/x11/x11mousebackend.cpp

  • This file was added.
1​/*
2​ * Copyright 2017 Xuetian Weng <wengxt@gmail.com>
3​ *
4​ * This program is free software; you can redistribute it and/or modify
5​ * it under the terms of the GNU General Public License as published by
6​ * the Free Software Foundation; either version 2 of the License, or
7​ * (at your option) any later version.
8​ *
9​ * This program is distributed in the hope that it will be useful,
10​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
11​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12​ * GNU General Public License for more details.
13​ *
14​ * You should have received a copy of the GNU General Public License
15​ * along with this program; if not, write to the Free Software
16​ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17​ */
18​
19​#include "x11mousebackend.h"
20​#include "mousesettings.h"
21​#include <config-X11.h>
22​
23​#include <QFile>
24​#include <QX11Info>
25​#include <evdev-properties.h>
26​#include <KLocalizedString>
27​
romanggUnsubmitted
Done

This include is not needed.

romangg: This include is not needed.
28​#include <X11/X.h>
29​#include <X11/Xlib.h>
30​#include <X11/Xatom.h>
31​#include <X11/extensions/XInput2.h>
32​#include <X11/extensions/XI.h>
33​#include <X11/Xutil.h>
34​#ifdef HAVE_XCURSOR
35​# include <X11/Xcursor/Xcursor.h>
36​#include <X11/extensions/XInput.h>
37​#endif
38​
39​struct ScopedXDeleter {
40​ static inline void cleanup(void* pointer)
41​ {
42​ if (pointer) {
43​ XFree(pointer);
romanggUnsubmitted
Done

These 3 are never used.

romangg: These 3 are never used.
44​ }
45​ }
46​};
47​
48​template<typename Callback>
49​static void XI2ForallPointerDevices(Display* dpy, const Callback& callback)
50​{
51​ int ndevices_return;
romanggUnsubmitted
Done

Never used.

romangg: Never used.
52​ XIDeviceInfo* info = XIQueryDevice(dpy, XIAllDevices, &ndevices_return);
53​ if (!info) {
54​ return;
55​ }
56​ for (int i = 0; i < ndevices_return; ++i) {
57​ if ((info + i)->use == XISlavePointer) {
58​ callback(info + i);
59​ }
60​ }
61​ XIFreeDeviceInfo(info);
62​}
63​
64​template<typename Callback>
65​static void XIForallPointerDevices(Display* dpy, const Callback& callback)
66​{
67​ int ndevices_return;
68​ XDeviceInfo* info = XListInputDevices(dpy, &ndevices_return);
69​ if (!info) {
70​ return;
71​ }
72​ for (int i = 0; i < ndevices_return; ++i) {
73​ if (info[i].use == IsXPointer || info[i].use == IsXExtensionPointer) {
74​ callback(info + i);
75​ }
76​ }
77​ XFreeDeviceList(info);
78​}
79​
80​X11MouseBackend::X11MouseBackend(QObject* parent) : MouseBackend(parent), m_dpy(nullptr)
81​{
82​ m_platformX11 = QX11Info::isPlatformX11();
83​ if (m_platformX11) {
84​ m_dpy = QX11Info::display();
85​ } else {
86​ // let's hope we have a compatibility system like Xwayland ready
87​ m_dpy = XOpenDisplay(nullptr);
88​ }
89​ initAtom();
90​}
91​
92​void X11MouseBackend::initAtom()
93​{
94​ if (!m_dpy) {
95​ return;
96​ }
97​
98​ m_evdevScrollDistanceAtom = XInternAtom(m_dpy, EVDEV_PROP_SCROLL_DISTANCE, True);
99​ m_evdevWheelEmulationAtom = XInternAtom(m_dpy, EVDEV_PROP_WHEEL, True);
100​ m_evdevWheelEmulationAxesAtom = XInternAtom(m_dpy, EVDEV_PROP_WHEEL_AXES, True);
101​}
102​
103​
104​X11MouseBackend::~X11MouseBackend()
105​{
106​ if (!m_platformX11 && m_dpy) {
107​ XCloseDisplay(m_dpy);
108​ }
109​}
110​
111​bool X11MouseBackend::supportScrollPolarity()
112​{
113​ return m_numButtons >= 5;
114​}
115​
116​double X11MouseBackend::accelRate()
117​{
118​ return m_accelRate;
119​}
120​
121​MouseHanded X11MouseBackend::handed()
122​{
123​ return m_handed;
124​}
125​
126​int X11MouseBackend::threshold()
127​{
128​ return m_threshold;
129​}
130​
131​void X11MouseBackend::load()
132​{
133​ if (!m_dpy) {
134​ return;
135​ }
136​
137​ m_accelRate = 1.0;
138​ int accel_num, accel_den;
139​ XGetPointerControl(m_dpy, &accel_num, &accel_den, &m_threshold);
140​ m_accelRate = double(accel_num) / double(accel_den);
romanggUnsubmitted
Done

Below you do it with 256 for reasons explained there.

romangg: Below you do it with 256 for reasons explained there.
141​
142​ // get settings from X server
143​ unsigned char map[256];
144​ m_numButtons = XGetPointerMapping(m_dpy, map, 256);
145​ m_middleButton = -1;
146​
147​ m_handed = MouseHanded::NotSupported;
148​ // ## keep this in sync with KGlobalSettings::mouseSettings
149​ if (m_numButtons == 2) {
150​ if (map[0] == 1 && map[1] == 2) {
151​ m_handed = MouseHanded::Right;
152​ } else if (map[0] == 2 && map[1] == 1) {
153​ m_handed = MouseHanded::Left;
154​ }
155​ } else if (m_numButtons >= 3) {
156​ m_middleButton = map[1];
157​ if (map[0] == 1 && map[2] == 3) {
158​ m_handed = MouseHanded::Right;
159​ } else if (map[0] == 3 && map[2] == 1) {
160​ m_handed = MouseHanded::Left;
161​ }
162​ }
163​}
164​
165​void X11MouseBackend::apply(const MouseSettings& settings, bool force)
166​{
167​ // 256 might seems extreme, but X has already been known to return 32,
168​ // and we don't want to truncate things. Xlib limits the table to 256 bytes,
169​ // so it's a good upper bound..
romanggUnsubmitted
Done

You set m_numButtons here and in load. This creates some ambiguity. Shouldn't be it enough to set it in the load() function?

romangg: You set m_numButtons here and in load. This creates some ambiguity. Shouldn't be it enough to…
170​ unsigned char map[256];
171​ XGetPointerMapping(m_dpy, map, 256);
romanggUnsubmitted
Done

nitpick: Spaces

romangg: nitpick: Spaces
172​
173​ if (settings.handedEnabled && (settings.handedNeedsApply || force)) {
174​ if (m_numButtons == 1) {
175​ map[0] = (unsigned char) 1;
176​ } else if (m_numButtons == 2) {
177​ if (settings.handed == MouseHanded::Right) {
178​ map[0] = (unsigned char) 1;
179​ map[1] = (unsigned char) 3;
180​ } else {
181​ map[0] = (unsigned char) 3;
182​ map[1] = (unsigned char) 1;
183​ }
184​ } else { // 3 buttons and more
185​ if (settings.handed == MouseHanded::Right) {
186​ map[0] = (unsigned char) 1;
187​ map[1] = (unsigned char) m_middleButton;
188​ map[2] = (unsigned char) 3;
189​ } else {
190​ map[0] = (unsigned char) 3;
191​ map[1] = (unsigned char) m_middleButton;
192​ map[2] = (unsigned char) 1;
193​ }
194​ }
195​
196​ int retval;
197​ if (m_numButtons >= 1) {
198​ while ((retval = XSetPointerMapping(m_dpy, map,
199​ m_numButtons)) == MappingBusy)
200​ /* keep trying until the pointer is free */
201​ { };
202​ }
203​
204​ // apply reverseScrollPolarity for all non-touchpad pointer, touchpad
205​ // are belong to kcm touchpad.
206​ XIForallPointerDevices(m_dpy, [this, &settings](XDeviceInfo * info) {
207​ int deviceid = info->id;
romanggUnsubmitted
Done

remap only used here -> Don't use local variable. Just check the condition here.

romangg: remap only used here -> Don't use local variable. Just check the condition here.
208​ evdevApplyReverseScroll(deviceid, settings.reverseScrollPolarity);
romanggUnsubmitted
Done

Spaces

romangg: Spaces
209​ });
210​
211​ }
212​
213​ XChangePointerControl(m_dpy,
214​ true, true, int(qRound(settings.accelRate * 10)), 10, settings.thresholdMove);
215​
216​ XFlush(m_dpy);
romanggUnsubmitted
Done

Capture "this" pointer and settings reference directly.

romangg: Capture "this" pointer and settings reference directly.
217​}
218​
219​QString X11MouseBackend::currentCursorTheme()
220​{
221​ if (!m_dpy) {
222​ return QString();
223​ }
224​
225​ QByteArray name = XGetDefault(m_dpy, "Xcursor", "theme");
226​#ifdef HAVE_XCURSOR
227​ if (name.isEmpty()) {
228​ name = QByteArray(XcursorGetTheme(m_dpy));
229​ }
230​#endif
231​ return QFile::decodeName(name);
232​}
233​
234​void X11MouseBackend::applyCursorTheme(const QString& theme, int size)
235​{
236​#ifdef HAVE_XCURSOR
237​
238​ // Apply the KDE cursor theme to ourselves
239​ if (m_dpy) {
240​ return;
241​ }
242​ if (!theme.isEmpty()) {
243​ XcursorSetTheme(m_dpy, QFile::encodeName(theme));
244​ }
245​
246​ if (size >= 0) {
247​ XcursorSetDefaultSize(m_dpy, size);
248​ }
249​
250​ // Load the default cursor from the theme and apply it to the root window.
251​ Cursor handle = XcursorLibraryLoadCursor(m_dpy, "left_ptr");
252​ XDefineCursor(m_dpy, DefaultRootWindow(m_dpy), handle);
253​ XFreeCursor(m_dpy, handle); // Don't leak the cursor
254​ XFlush(m_dpy);
255​#endif
256​}
257​
258​bool X11MouseBackend::evdevApplyReverseScroll(int deviceid, bool reverse)
259​{
260​ // Check atom availability first.
261​ if (m_evdevWheelEmulationAtom == None || m_evdevScrollDistanceAtom == None ||
262​ m_evdevWheelEmulationAxesAtom == None) {
263​ return false;
264​ }
265​ Status status;
266​ Atom type_return;
267​ int format_return;
268​ unsigned long num_items_return;
269​ unsigned long bytes_after_return;
270​
271​ unsigned char* _data = nullptr;
272​ //data returned is an 1 byte boolean
273​ status = XIGetProperty(m_dpy, deviceid, m_evdevWheelEmulationAtom, 0, 1,
274​ False, XA_INTEGER, &type_return, &format_return,
275​ &num_items_return, &bytes_after_return, &_data);
276​ QScopedArrayPointer<unsigned char, ScopedXDeleter> data(_data);
277​ _data = nullptr;
278​ if (status != Success) {
279​ return false;
280​ }
281​
282​ // pointer device without wheel emulation
283​ if (type_return != XA_INTEGER || data == NULL || *data == False) {
284​ status = XIGetProperty(m_dpy, deviceid, m_evdevScrollDistanceAtom, 0, 3,
285​ False, XA_INTEGER, &type_return, &format_return,
286​ &num_items_return, &bytes_after_return, &_data);
287​ data.reset(_data);
288​ _data = nullptr;
289​ // negate scroll distance
290​ if (status == Success && type_return == XA_INTEGER &&
291​ format_return == 32 && num_items_return == 3) {
292​ int32_t* vals = (int32_t*)data.data();
293​ for (unsigned long i = 0; i < num_items_return; ++i) {
294​ int32_t val = *(vals + i);
295​ *(vals + i) = (int32_t)(reverse ? -abs(val) : abs(val));
296​ }
297​ XIChangeProperty(m_dpy, deviceid, m_evdevScrollDistanceAtom, XA_INTEGER,
298​ 32, XIPropModeReplace, data.data(), 3);
299​ }
300​ } else { // wheel emulation used, reverse wheel axes
301​ status = XIGetProperty(m_dpy, deviceid, m_evdevWheelEmulationAxesAtom, 0, 4,
302​ False, XA_INTEGER, &type_return, &format_return,
303​ &num_items_return, &bytes_after_return, &_data);
304​ data.reset(_data);
305​ _data = nullptr;
306​ if (status == Success && type_return == XA_INTEGER &&
307​ format_return == 8 && num_items_return == 4) {
308​ // when scroll direction is not reversed,
309​ // up button id should be smaller than down button id,
310​ // up/left are odd elements, down/right are even elements
311​ for (int i = 0; i < 2; ++i) {
312​ unsigned char odd = data[i * 2];
313​ unsigned char even = data[i * 2 + 1];
314​ unsigned char max_elem = std::max(odd, even);
315​ unsigned char min_elem = std::min(odd, even);
316​ data[i * 2] = reverse ? max_elem : min_elem;
317​ data[i * 2 + 1] = reverse ? min_elem : max_elem;
318​ }
319​ XIChangeProperty(m_dpy, deviceid, m_evdevWheelEmulationAxesAtom, XA_INTEGER,
320​ 8, XIPropModeReplace, data.data(), 4);
321​ }
322​ }
323​
324​ return true;
325​}
326​
327​