Differential D3617 Diff 9389 kcms/touchpad/src/backends/kwin_wayland/kwinwaylandtouchpad.h

Changeset View

Standalone View

View Options

kcms/touchpad/src/backends/kwin_wayland/kwinwaylandtouchpad.h

  • This file was added.
1​/*
2​ * Copyright (C) 2016 Roman Gilg <subdiff@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​#ifndef KWINWAYLANDTOUCHPAD_H
20​#define KWINWAYLANDTOUCHPAD_H
21​
22​#include <libinput.h>
23​
graesslinUnsubmitted
Done

why an include of libinput.h? If you use that you also have to find libinput in CMake. Otherwise it won't compile on all systems.

graesslin: why an include of libinput.h? If you use that you also have to find libinput in CMake.
24​#include <QObject>
25​#include <QString>
26​
27​class QDBusInterface;
28​
29​class KWinWaylandTouchpad : public QObject
30​{
31​ Q_OBJECT
32​
33​ //
34​ // general
35​ Q_PROPERTY(QString name READ name CONSTANT)
36​ Q_PROPERTY(bool supportsDisableEvents READ supportsDisableEvents CONSTANT)
sebasUnsubmitted
Not Done

I wonder if it wouldn't be neater if the features would be an enum, and you'd have methods to check for supported and enabled features. Have you thought of this?

sebas: I wonder if it wouldn't be neater if the features would be an enum, and you'd have methods to…
romanggAuthorUnsubmitted
Not Done

Haven't thought about it. The structure here is analogous to the structure in KWin's libinput counter part.

romangg: Haven't thought about it. The structure here is analogous to the structure in KWin's libinput…
37​ Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
38​
39​ //
40​ // advanced
41​ Q_PROPERTY(Qt::MouseButtons supportedButtons READ supportedButtons CONSTANT)
42​
43​ Q_PROPERTY(bool supportsLeftHanded READ supportsLeftHanded CONSTANT)
44​ Q_PROPERTY(bool leftHandedEnabledByDefault READ leftHandedEnabledByDefault CONSTANT)
45​ Q_PROPERTY(bool leftHanded READ isLeftHanded WRITE setLeftHanded NOTIFY leftHandedChanged)
46​
47​ Q_PROPERTY(bool supportsDisableEventsOnExternalMouse READ supportsDisableEventsOnExternalMouse CONSTANT)
48​
49​ Q_PROPERTY(bool supportsDisableWhileTyping READ supportsDisableWhileTyping CONSTANT)
50​ Q_PROPERTY(bool disableWhileTypingEnabledByDefault READ disableWhileTypingEnabledByDefault CONSTANT)
51​ Q_PROPERTY(bool disableWhileTyping READ isDisableWhileTyping WRITE setDisableWhileTyping NOTIFY disableWhileTypingChanged)
52​
53​ Q_PROPERTY(bool supportsMiddleEmulation READ supportsMiddleEmulation CONSTANT)
54​ Q_PROPERTY(bool middleEmulationEnabledByDefault READ middleEmulationEnabledByDefault CONSTANT)
55​ Q_PROPERTY(bool middleEmulation READ isMiddleEmulation WRITE setMiddleEmulation NOTIFY middleEmulationChanged)
56​
57​ //
58​ // acceleration speed and profile
59​ Q_PROPERTY(bool supportsPointerAcceleration READ supportsPointerAcceleration CONSTANT)
60​ Q_PROPERTY(qreal pointerAcceleration READ pointerAcceleration WRITE setPointerAcceleration NOTIFY pointerAccelerationChanged)
61​
62​ Q_PROPERTY(bool supportsPointerAccelerationProfileFlat READ supportsPointerAccelerationProfileFlat CONSTANT)
63​ Q_PROPERTY(bool defaultPointerAccelerationProfileFlat READ defaultPointerAccelerationProfileFlat CONSTANT)
64​ Q_PROPERTY(bool pointerAccelerationProfileFlat READ pointerAccelerationProfileFlat WRITE setPointerAccelerationProfileFlat NOTIFY pointerAccelerationProfileChanged)
65​
66​ Q_PROPERTY(bool supportsPointerAccelerationProfileAdaptive READ supportsPointerAccelerationProfileAdaptive CONSTANT)
67​ Q_PROPERTY(bool defaultPointerAccelerationProfileAdaptive READ defaultPointerAccelerationProfileAdaptive CONSTANT)
68​ Q_PROPERTY(bool pointerAccelerationProfileAdaptive READ pointerAccelerationProfileAdaptive WRITE setPointerAccelerationProfileAdaptive NOTIFY pointerAccelerationProfileChanged)
69​
70​ //
71​ // tapping
72​ Q_PROPERTY(int tapFingerCount READ tapFingerCount CONSTANT)
73​ Q_PROPERTY(bool tapToClickEnabledByDefault READ tapToClickEnabledByDefault CONSTANT)
74​ Q_PROPERTY(bool tapToClick READ isTapToClick WRITE setTapToClick NOTIFY tapToClickChanged)
75​
76​ Q_PROPERTY(bool supportsLmrTapButtonMap READ supportsLmrTapButtonMap CONSTANT)
77​ Q_PROPERTY(bool lmrTapButtonMapEnabledByDefault READ lmrTapButtonMapEnabledByDefault CONSTANT)
78​ Q_PROPERTY(bool lmrTapButtonMap READ lmrTapButtonMap WRITE setLmrTapButtonMap NOTIFY lmrTapButtonMapChanged)
79​
80​ Q_PROPERTY(bool tapAndDragEnabledByDefault READ tapAndDragEnabledByDefault CONSTANT)
81​ Q_PROPERTY(bool tapAndDrag READ isTapAndDrag WRITE setTapAndDrag NOTIFY tapAndDragChanged)
82​
83​ Q_PROPERTY(bool tapDragLockEnabledByDefault READ tapDragLockEnabledByDefault CONSTANT)
84​ Q_PROPERTY(bool tapDragLock READ isTapDragLock WRITE setTapDragLock NOTIFY tapDragLockChanged)
85​
86​ //
87​ // scrolling
88​ Q_PROPERTY(bool supportsNaturalScroll READ supportsNaturalScroll CONSTANT)
89​ Q_PROPERTY(bool naturalScrollEnabledByDefault READ naturalScrollEnabledByDefault CONSTANT)
90​ Q_PROPERTY(bool naturalScroll READ isNaturalScroll WRITE setNaturalScroll NOTIFY naturalScrollChanged)
91​
92​ Q_PROPERTY(bool supportsScrollTwoFinger READ supportsScrollTwoFinger CONSTANT)
93​ Q_PROPERTY(bool scrollTwoFingerEnabledByDefault READ scrollTwoFingerEnabledByDefault CONSTANT)
94​ Q_PROPERTY(bool scrollTwoFinger READ isScrollTwoFinger WRITE setScrollTwoFinger NOTIFY scrollMethodChanged)
95​
96​ Q_PROPERTY(bool supportsScrollEdge READ supportsScrollEdge CONSTANT)
97​ Q_PROPERTY(bool scrollEdgeEnabledByDefault READ scrollEdgeEnabledByDefault CONSTANT)
98​ Q_PROPERTY(bool scrollEdge READ isScrollEdge WRITE setScrollEdge NOTIFY scrollMethodChanged)
99​
100​ Q_PROPERTY(bool supportsScrollOnButtonDown READ supportsScrollOnButtonDown CONSTANT)
101​ Q_PROPERTY(bool scrollOnButtonDownEnabledByDefault READ scrollOnButtonDownEnabledByDefault CONSTANT)
102​ Q_PROPERTY(bool scrollOnButtonDown READ isScrollOnButtonDown WRITE setScrollOnButtonDown NOTIFY scrollMethodChanged)
103​
104​ Q_PROPERTY(quint32 defaultScrollButton READ defaultScrollButton CONSTANT)
105​ Q_PROPERTY(quint32 scrollButton READ scrollButton WRITE setScrollButton NOTIFY scrollButtonChanged)
106​
107​public:
108​ KWinWaylandTouchpad(QString dbusName);
109​ virtual ~KWinWaylandTouchpad();
110​
111​ bool init();
112​
113​ bool getConfig();
114​ bool getDefaultConfig();
115​ bool applyConfig();
116​ bool isChangedConfig() const;
117​
118​ //
119​ // general
120​ QString name() const {
121​ return m_name.val;
122​ }
123​ QString sysName() const {
124​ return m_sysName.val;
125​ }
126​ bool supportsDisableEvents() const {
127​ return m_supportsDisableEvents.val;
128​ }
129​ void setEnabled(bool enabled) {
130​ m_enabled.set(enabled);
131​ }
132​ bool isEnabled() const {
133​ return m_enabled.val;
134​ }
135​ Qt::MouseButtons supportedButtons() const {
136​ return m_supportedButtons.val;
137​ }
138​
139​ //
140​ // advanced
141​ bool supportsLeftHanded() const {
142​ return m_supportsLeftHanded.val;
143​ }
144​ bool leftHandedEnabledByDefault() const {
145​ return m_leftHandedEnabledByDefault.val;
146​ }
147​ bool isLeftHanded() const {
148​ return m_leftHanded.val;
149​ }
150​ void setLeftHanded(bool set) {
151​ m_leftHanded.set(set);
152​ }
153​
154​ bool supportsDisableEventsOnExternalMouse() const {
155​ return m_supportsDisableEventsOnExternalMouse.val;
156​ }
157​
158​ bool supportsDisableWhileTyping() const {
159​ return m_supportsDisableWhileTyping.val;
160​ }
161​ bool disableWhileTypingEnabledByDefault() const {
162​ return m_disableWhileTypingEnabledByDefault.val;
163​ }
164​ bool isDisableWhileTyping() const {
165​ return m_disableWhileTyping.val;
166​ }
167​ void setDisableWhileTyping(bool set) {
168​ m_disableWhileTyping.set(set);
169​ }
170​
171​ bool supportsMiddleEmulation() const {
172​ return m_supportsMiddleEmulation.val;
173​ }
174​ bool middleEmulationEnabledByDefault() const {
175​ return m_middleEmulationEnabledByDefault.val;
176​ }
177​ bool isMiddleEmulation() const {
178​ return m_middleEmulation.val;
179​ }
180​ void setMiddleEmulation(bool set) {
181​ m_middleEmulation.set(set);
182​ }
183​
184​ //
185​ // acceleration speed and profile
186​ bool supportsPointerAcceleration() const {
187​ return m_supportsPointerAcceleration.val;
188​ }
189​ qreal pointerAcceleration() const {
190​ return m_pointerAcceleration.val;
191​ }
192​ void setPointerAcceleration(qreal acceleration) {
193​ m_pointerAcceleration.set(acceleration);
194​ }
195​
196​ bool supportsPointerAccelerationProfileFlat() const {
197​ return m_supportsPointerAccelerationProfileFlat.val;
198​ }
199​ bool defaultPointerAccelerationProfileFlat() const {
200​ return m_defaultPointerAccelerationProfileFlat.val;
201​ }
202​ bool pointerAccelerationProfileFlat() const {
203​ return m_pointerAccelerationProfileFlat.val;
204​ }
205​ void setPointerAccelerationProfileFlat(bool set) {
206​ m_pointerAccelerationProfileFlat.set(set);
207​ }
208​
209​ bool supportsPointerAccelerationProfileAdaptive() const {
210​ return m_supportsPointerAccelerationProfileAdaptive.val;
211​ }
212​ bool defaultPointerAccelerationProfileAdaptive() const {
213​ return m_defaultPointerAccelerationProfileAdaptive.val;
214​ }
215​ bool pointerAccelerationProfileAdaptive() const {
216​ return m_pointerAccelerationProfileAdaptive.val;
217​ }
218​ void setPointerAccelerationProfileAdaptive(bool set) {
219​ m_pointerAccelerationProfileAdaptive.set(set);
220​ }
221​
222​ //
223​ // tapping
224​ int tapFingerCount() const {
225​ return m_tapFingerCount.val;
226​ }
227​ bool tapToClickEnabledByDefault() const {
228​ return m_tapToClickEnabledByDefault.val;
229​ }
230​ bool isTapToClick() const {
231​ return m_tapToClick.val;
232​ }
233​ void setTapToClick(bool set) {
234​ m_tapToClick.set(set);
235​ }
236​
237​ bool supportsLmrTapButtonMap() const {
238​ return m_tapFingerCount.val > 1;
239​ }
240​ bool lmrTapButtonMapEnabledByDefault() const {
241​ return m_lmrTapButtonMapEnabledByDefault.val;
242​ }
243​ bool lmrTapButtonMap() const {
244​ return m_lmrTapButtonMap.val;
245​ }
246​ void setLmrTapButtonMap(bool set) {
247​ m_lmrTapButtonMap.set(set);
248​ }
249​
250​ bool tapAndDragEnabledByDefault() const {
251​ return m_tapAndDragEnabledByDefault.val;
252​ }
253​ bool isTapAndDrag() const {
254​ return m_tapAndDrag.val;
255​ }
256​ void setTapAndDrag(bool set) {
257​ m_tapAndDrag.set(set);
258​ }
259​
260​ bool tapDragLockEnabledByDefault() const {
261​ return m_tapDragLockEnabledByDefault.val;
262​ }
263​ bool isTapDragLock() const {
264​ return m_tapDragLock.val;
265​ }
266​ void setTapDragLock(bool set) {
267​ m_tapDragLock.set(set);
268​ }
269​
270​ //
271​ // scrolling
272​ bool supportsNaturalScroll() const {
273​ return m_supportsNaturalScroll.val;
274​ }
275​ bool naturalScrollEnabledByDefault() const {
276​ return m_naturalScrollEnabledByDefault.val;
277​ }
278​ bool isNaturalScroll() const {
279​ return m_naturalScroll.val;
280​ }
281​ void setNaturalScroll(bool set) {
282​ m_naturalScroll.set(set);
283​ }
284​
285​ bool supportsScrollTwoFinger() const {
286​ return m_supportsScrollTwoFinger.val;
287​ }
288​ bool scrollTwoFingerEnabledByDefault() const {
289​ return m_scrollTwoFingerEnabledByDefault.val;
290​ }
291​ bool isScrollTwoFinger() const {
292​ return m_isScrollTwoFinger.val;
293​ }
294​ void setScrollTwoFinger(bool set) {
295​ m_isScrollTwoFinger.set(set);
296​ }
297​
298​ bool supportsScrollEdge() const {
299​ return m_supportsScrollEdge.val;
300​ }
301​ bool scrollEdgeEnabledByDefault() const {
302​ return m_scrollEdgeEnabledByDefault.val;
303​ }
304​ bool isScrollEdge() const {
305​ return m_isScrollEdge.val;
306​ }
307​ void setScrollEdge(bool set) {
308​ m_isScrollEdge.set(set);
309​ }
310​
311​ bool supportsScrollOnButtonDown() const {
312​ return m_supportsScrollOnButtonDown.val;
313​ }
314​ bool scrollOnButtonDownEnabledByDefault() const {
315​ return m_scrollOnButtonDownEnabledByDefault.val;
316​ }
317​ bool isScrollOnButtonDown() const {
318​ return m_isScrollOnButtonDown.val;
319​ }
320​ void setScrollOnButtonDown(bool set) {
321​ m_isScrollOnButtonDown.set(set);
322​ }
323​
324​ quint32 defaultScrollButton() const {
325​ return m_defaultScrollButton.val;
326​ }
327​ quint32 scrollButton() const {
328​ return m_scrollButton.val;
329​ }
330​ void setScrollButton(quint32 button) {
331​ m_scrollButton.set(button);
332​ }
333​
334​Q_SIGNALS:
335​ void leftHandedChanged();
336​ void pointerAccelerationChanged();
337​ void pointerAccelerationProfileChanged();
338​ void enabledChanged();
339​ void tapToClickChanged();
340​ void tapAndDragChanged();
341​ void tapDragLockChanged();
342​ void lmrTapButtonMapChanged();
343​ void disableWhileTypingChanged();
344​ void middleEmulationChanged();
345​ void naturalScrollChanged();
346​ void scrollMethodChanged();
347​ void scrollButtonChanged();
348​
349​private:
350​ template <typename T>
351​ struct Prop {
352​ explicit Prop(QByteArray dbusName)
sebasUnsubmitted
Done

const & for the argument?

sebas: const & for the argument?
353​ : dbus(dbusName)
354​ {}
355​
356​ void set(T newVal) {
357​ if (avail && val != newVal) {
358​ val = newVal;
359​ }
360​ }
361​ void set(const Prop<T> &p) {
362​ if (avail && val != p.val) {
363​ val = p.val;
364​ }
365​ }
366​ bool changed() const {
367​ return avail && (old != val);
368​ }
369​
370​ QByteArray dbus;
371​ bool avail;
372​ T old;
373​ T val;
374​ };
375​
376​ template<typename T>
377​ bool valueLoader(Prop<T> &prop);
378​
379​ template<typename T>
380​ QString valueWriter(const Prop<T> &prop);
381​
382​ //
383​ // general
384​ Prop<QString> m_name = Prop<QString>("name");
385​ Prop<QString> m_sysName = Prop<QString>("sysName");
386​ Prop<bool> m_supportsDisableEvents = Prop<bool>("supportsDisableEvents");
387​ Prop<bool> m_enabled = Prop<bool>("enabled");
388​
389​ //
390​ // advanced
391​ Prop<Qt::MouseButtons> m_supportedButtons = Prop<Qt::MouseButtons>("supportedButtons");
392​
393​ Prop<bool> m_supportsLeftHanded = Prop<bool>("supportsLeftHanded");
394​ Prop<bool> m_leftHandedEnabledByDefault = Prop<bool>("leftHandedEnabledByDefault");
395​ Prop<bool> m_leftHanded = Prop<bool>("leftHanded");
396​
397​ Prop<bool> m_supportsDisableEventsOnExternalMouse = Prop<bool>("supportsDisableEventsOnExternalMouse");
398​
399​ Prop<bool> m_supportsDisableWhileTyping = Prop<bool>("supportsDisableWhileTyping");
400​ Prop<bool> m_disableWhileTypingEnabledByDefault = Prop<bool>("disableWhileTypingEnabledByDefault");
401​ Prop<bool> m_disableWhileTyping = Prop<bool>("disableWhileTyping");
402​
403​ Prop<bool> m_supportsMiddleEmulation = Prop<bool>("supportsMiddleEmulation");
404​ Prop<bool> m_middleEmulationEnabledByDefault = Prop<bool>("middleEmulationEnabledByDefault");
405​ Prop<bool> m_middleEmulation = Prop<bool>("middleEmulation");
406​
407​ //
408​ // acceleration speed and profile
409​ Prop<bool> m_supportsPointerAcceleration = Prop<bool>("supportsPointerAcceleration");
410​ Prop<qreal> m_defaultPointerAcceleration = Prop<qreal>("defaultPointerAcceleration");
411​ Prop<qreal> m_pointerAcceleration = Prop<qreal>("pointerAcceleration");
412​
413​ Prop<bool> m_supportsPointerAccelerationProfileFlat = Prop<bool>("supportsPointerAccelerationProfileFlat");
414​ Prop<bool> m_defaultPointerAccelerationProfileFlat = Prop<bool>("defaultPointerAccelerationProfileFlat");
415​ Prop<bool> m_pointerAccelerationProfileFlat = Prop<bool>("pointerAccelerationProfileFlat");
416​
417​ Prop<bool> m_supportsPointerAccelerationProfileAdaptive = Prop<bool>("supportsPointerAccelerationProfileAdaptive");
418​ Prop<bool> m_defaultPointerAccelerationProfileAdaptive = Prop<bool>("defaultPointerAccelerationProfileAdaptive");
419​ Prop<bool> m_pointerAccelerationProfileAdaptive = Prop<bool>("pointerAccelerationProfileAdaptive");
420​
421​ //
422​ // tapping
423​ Prop<int> m_tapFingerCount = Prop<int>("tapFingerCount");
424​ Prop<bool> m_tapToClickEnabledByDefault = Prop<bool>("tapToClickEnabledByDefault");
425​ Prop<bool> m_tapToClick = Prop<bool>("tapToClick");
426​
427​ Prop<bool> m_lmrTapButtonMapEnabledByDefault = Prop<bool>("lmrTapButtonMapEnabledByDefault");
428​ Prop<bool> m_lmrTapButtonMap = Prop<bool>("lmrTapButtonMap");
429​
430​ Prop<bool> m_tapAndDragEnabledByDefault = Prop<bool>("tapAndDragEnabledByDefault");
431​ Prop<bool> m_tapAndDrag = Prop<bool>("tapAndDrag");
432​ Prop<bool> m_tapDragLockEnabledByDefault = Prop<bool>("tapDragLockEnabledByDefault");
433​ Prop<bool> m_tapDragLock = Prop<bool>("tapDragLock");
434​
435​ //
436​ // scrolling
437​ Prop<bool> m_supportsNaturalScroll = Prop<bool>("supportsNaturalScroll");
438​ Prop<bool> m_naturalScrollEnabledByDefault = Prop<bool>("naturalScrollEnabledByDefault");
439​ Prop<bool> m_naturalScroll = Prop<bool>("naturalScroll");
440​
441​ Prop<bool> m_supportsScrollTwoFinger = Prop<bool>("supportsScrollTwoFinger");
442​ Prop<bool> m_scrollTwoFingerEnabledByDefault = Prop<bool>("scrollTwoFingerEnabledByDefault");
443​ Prop<bool> m_isScrollTwoFinger = Prop<bool>("scrollTwoFinger");
444​
445​ Prop<bool> m_supportsScrollEdge = Prop<bool>("supportsScrollEdge");
446​ Prop<bool> m_scrollEdgeEnabledByDefault = Prop<bool>("scrollEdgeEnabledByDefault");
447​ Prop<bool> m_isScrollEdge = Prop<bool>("scrollEdge");
448​
449​ Prop<bool> m_supportsScrollOnButtonDown = Prop<bool>("supportsScrollOnButtonDown");
450​ Prop<bool> m_scrollOnButtonDownEnabledByDefault = Prop<bool>("scrollOnButtonDownEnabledByDefault");
451​ Prop<bool> m_isScrollOnButtonDown = Prop<bool>("scrollOnButtonDown");
452​
453​ Prop<quint32> m_defaultScrollButton = Prop<quint32>("defaultScrollButton");
454​ Prop<quint32> m_scrollButton = Prop<quint32>("scrollButton");
455​
456​
457​ QDBusInterface *m_iface;
458​};
459​
460​#endif