Differential D8460 Diff 21274 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 <libinput-properties.h>
27​#include <KLocalizedString>
romanggUnsubmitted
Done

This include is not needed.

romangg: This include is not needed.
28​
29​#include <X11/X.h>
30​#include <X11/Xlib.h>
31​#include <X11/Xatom.h>
32​#include <X11/extensions/XInput2.h>
33​#include <X11/extensions/XI.h>
34​#include <X11/Xutil.h>
35​#ifdef HAVE_XCURSOR
36​# include <X11/Xcursor/Xcursor.h>
37​#include <X11/extensions/XInput.h>
38​#endif
39​
40​static const char PROFILE_NONE[] = I18N_NOOP("None");
41​static const char PROFILE_ADAPTIVE[] = I18N_NOOP("Adaptive");
42​static const char PROFILE_FLAT[] = I18N_NOOP("Flat");
43​
romanggUnsubmitted
Done

These 3 are never used.

romangg: These 3 are never used.
44​struct ScopedXDeleter
45​{
46​ static inline void cleanup(void *pointer) { if (pointer) XFree(pointer); }
47​};
48​
49​template<typename Callback>
50​static void XI2ForallPointerDevices(Display *dpy, const Callback &callback) {
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​ int ndevices_return;
67​ XDeviceInfo *info = XListInputDevices(dpy, &ndevices_return);
68​ if (!info) {
69​ return;
70​ }
71​ for (int i = 0; i < ndevices_return; ++i) {
72​ if( info[i].use == IsXPointer || info[i].use == IsXExtensionPointer ) {
73​ callback(info + i);
74​ }
75​ }
76​ XFreeDeviceList(info);
77​}
78​
79​X11MouseBackend::X11MouseBackend(QObject* parent) : MouseBackend(parent), m_dpy(nullptr)
80​{
81​ m_platformX11 = QX11Info::isPlatformX11();
82​ if (m_platformX11) {
83​ m_dpy = QX11Info::display();
84​ } else {
85​ // let's hope we have a compatibility system like Xwayland ready
86​ m_dpy = XOpenDisplay(nullptr);
87​ }
88​ initAtom();
89​}
90​
91​void X11MouseBackend::initAtom()
92​{
93​ if (!m_dpy) {
94​ return;
95​ }
96​
97​ m_evdevScrollDistanceAtom = XInternAtom(m_dpy, EVDEV_PROP_SCROLL_DISTANCE, True);
98​ m_evdevWheelEmulationAtom = XInternAtom(m_dpy, EVDEV_PROP_WHEEL, True);
99​ m_evdevWheelEmulationAxesAtom = XInternAtom(m_dpy, EVDEV_PROP_WHEEL_AXES, True);
100​}
101​
102​
103​X11MouseBackend::~X11MouseBackend()
104​{
105​ if (!m_platformX11 && m_dpy) {
106​ XCloseDisplay(m_dpy);
107​ }
108​}
109​
110​bool X11MouseBackend::supportScrollPolarity()
111​{
112​ return m_numButtons >= 5;
113​}
114​
115​double X11MouseBackend::accelRate() {
116​ return m_accelRate;
117​}
118​
119​MouseHanded X11MouseBackend::handed()
120​{
121​ return m_handed;
122​}
123​
124​int X11MouseBackend::threshold() {
125​ return m_threshold;
126​}
127​
128​void X11MouseBackend::load() {
129​ if (!m_dpy) {
130​ return;
131​ }
132​
133​ m_accelRate = 1.0;
134​ int accel_num, accel_den;
135​ XGetPointerControl(m_dpy, &accel_num, &accel_den, &m_threshold);
136​ m_accelRate = double(accel_num) / double(accel_den);
137​
138​ // get settings from X server
139​ unsigned char map[20];
140​ m_numButtons = XGetPointerMapping(m_dpy, map, 20);
romanggUnsubmitted
Done

Below you do it with 256 for reasons explained there.

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

nitpick: Spaces

romangg: nitpick: Spaces
172​ if (m_numButtons == 1)
173​ {
174​ map[0] = (unsigned char) 1;
175​ }
176​ else if (m_numButtons == 2)
177​ {
178​ if (settings.handed == MouseHanded::Right)
179​ {
180​ map[0] = (unsigned char) 1;
181​ map[1] = (unsigned char) 3;
182​ }
183​ else
184​ {
185​ map[0] = (unsigned char) 3;
186​ map[1] = (unsigned char) 1;
187​ }
188​ }
189​ else // 3 buttons and more
190​ {
191​ if (settings.handed == MouseHanded::Right)
192​ {
193​ map[0] = (unsigned char) 1;
194​ map[1] = (unsigned char) m_middleButton;
195​ map[2] = (unsigned char) 3;
196​ }
197​ else
198​ {
199​ map[0] = (unsigned char) 3;
200​ map[1] = (unsigned char) m_middleButton;
201​ map[2] = (unsigned char) 1;
202​ }
203​ }
204​
205​ int retval;
206​ if (remap) {
207​ while ((retval=XSetPointerMapping(m_dpy, map,
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​ m_numButtons)) == MappingBusy)
romanggUnsubmitted
Done

Spaces

romangg: Spaces
209​ /* keep trying until the pointer is free */
210​ { };
211​ }
212​
213​ // apply reverseScrollPolarity for all non-touchpad pointer, touchpad
214​ // are belong to kcm touchpad.
215​ XIForallPointerDevices(m_dpy, [&] (XDeviceInfo *info) {
216​ int deviceid = info->id;
romanggUnsubmitted
Done

Capture "this" pointer and settings reference directly.

romangg: Capture "this" pointer and settings reference directly.
217​ evdevApplyReverseScroll(deviceid, settings.reverseScrollPolarity);
218​ });
219​
220​ }
221​
222​ XChangePointerControl(m_dpy,
223​ true, true, int(qRound(settings.accelRate*10)), 10, settings.thresholdMove);
224​
225​ XFlush(m_dpy);
226​}
227​
228​QString X11MouseBackend::currentCursorTheme() {
229​ if (!m_dpy) {
230​ return QString();
231​ }
232​
233​ QByteArray name = XGetDefault( m_dpy, "Xcursor", "theme" );
234​#ifdef HAVE_XCURSOR
235​ if (name.isEmpty()) {
236​ name = QByteArray( XcursorGetTheme( m_dpy));
237​ }
238​#endif
239​ return QFile::decodeName(name);
240​}
241​
242​void X11MouseBackend::applyCursorTheme(const QString &theme, int size) {
243​#ifdef HAVE_XCURSOR
244​
245​ // Apply the KDE cursor theme to ourselves
246​ if (m_dpy) {
247​ return;
248​ }
249​ if( !theme.isEmpty())
250​ XcursorSetTheme(m_dpy, QFile::encodeName(theme));
251​
252​ if (size >= 0)
253​ XcursorSetDefaultSize(m_dpy, size);
254​
255​ // Load the default cursor from the theme and apply it to the root window.
256​ Cursor handle = XcursorLibraryLoadCursor(m_dpy, "left_ptr");
257​ XDefineCursor(m_dpy, DefaultRootWindow(m_dpy), handle);
258​ XFreeCursor(m_dpy, handle); // Don't leak the cursor
259​ XFlush(m_dpy);
260​#endif
261​}
262​
263​bool X11MouseBackend::evdevApplyReverseScroll(int deviceid, bool reverse)
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​}