SettingsDaemon: Add mouse module

4 years ago · 01e3881188
parent 95b2d360ef
commit 01e3881188
11 changed files with 774 additions and 1 deletions
--- a/debian/control
+++ b/debian/control
@ -6,6 +6,7 @@ Build-Depends: cmake,
               debhelper (>= 9),
               extra-cmake-modules,
               pkg-config,
+               xserver-xorg-input-libinput-dev,
               libxcb1-dev,
               libxcb-randr0-dev,
               libsm-dev,
--- a/settings-daemon/CMakeLists.txt
+++ b/settings-daemon/CMakeLists.txt
@ -2,6 +2,8 @@ project(cutefish-settings-daemon)
 set(TARGET cutefish-settings-daemon)

 find_package(PulseAudio)
+find_package(X11 REQUIRED)
+pkg_check_modules(XORGLIBINPUT xorg-libinput IMPORTED_TARGET)

 file (GLOB_RECURSE SRCS
  "*.cpp"
@ -19,6 +21,8 @@ file (GLOB_RECURSE SRCS
  "language/*.h"
  "dock/*.cpp"
  "dock/*.h"
+  "mouse/*.h"
+  "mouse/*.cpp"
 )

 set(SOURCES ${SRCS})
@ -44,6 +48,9 @@ qt5_add_dbus_adaptor(DBUS_SOURCES
 qt5_add_dbus_adaptor(DBUS_SOURCES
                     dock/org.cutefish.Dock.xml
                     dock/dock.h Dock)
+qt5_add_dbus_adaptor(DBUS_SOURCES
+                     mouse/org.cutefish.Mouse.xml
+                     mouse/mousemanager.h Mouse)
 set_source_files_properties(${DBUS_SOURCES} PROPERTIES SKIP_AUTOGEN ON)

 add_executable(${TARGET} ${SOURCES} ${DBUS_SOURCES} ${HEADERS} ${FORMS} ${RESOURCES})
@ -54,6 +61,10 @@ target_link_libraries(${TARGET}
        Qt5::DBus
        Qt5::X11Extras
        ${PULSEAUDIO_LIBRARY}
+        ${X11_LIBRARIES}
+        X11::X11
+        X11::Xi
+        PkgConfig::XORGLIBINPUT
 )

 file(GLOB TS_FILES translations/*.ts)
@ -62,4 +73,4 @@ add_custom_target(translations DEPENDS ${QM_FILES} SOURCES ${TS_FILES})
 add_dependencies(${TARGET} translations)

 install(TARGETS ${TARGET} DESTINATION /usr/bin)
-install(FILES ${QM_FILES} DESTINATION /usr/share/${TARGET}/translations)
+install(FILES ${QM_FILES} DESTINATION /usr/share/${TARGET}/translations)
--- a/settings-daemon/application.cpp
+++ b/settings-daemon/application.cpp
@ -36,6 +36,7 @@ Application::Application(int &argc, char **argv)
    , m_brightnessManager(new BrightnessManager(this))
    , m_upowerManager(new UPowerManager(this))
    , m_language(new Language(this))
+    , m_mouse(new Mouse)
 {
    new DBusAdaptor(this);
    // connect to D-Bus and register as an object:
--- a/settings-daemon/application.h
+++ b/settings-daemon/application.h
@ -26,6 +26,7 @@
 #include "brightness/brightnessmanager.h"
 #include "battery/upowermanager.h"
 #include "language/language.h"
+#include "mouse/mousemanager.h"

 class Application : public QApplication
 {
@ -44,6 +45,7 @@ private:
    BrightnessManager *m_brightnessManager;
    UPowerManager *m_upowerManager;
    Language *m_language;
+    Mouse *m_mouse;
 };

 #endif // APPLICATION_H
--- a/settings-daemon/mouse/libinputsettings.cpp
+++ b/settings-daemon/mouse/libinputsettings.cpp
@ -0,0 +1,39 @@
+/*
+    SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+#include "libinputsettings.h"
+
+#include <QDebug>
+#include <QSettings>
+
+template<>
+bool LibinputSettings::load(QString key, bool defVal)
+{
+    QSettings settings("cutefishos", "mouse");
+    return settings.value(key, defVal).toBool();
+}
+
+template<>
+qreal LibinputSettings::load(QString key, qreal defVal)
+{
+    QSettings settings("cutefishos", "mouse");
+    return settings.value(key, defVal).toReal();
+}
+
+template<>
+void LibinputSettings::save(QString key, bool val)
+{
+    QSettings settings("cutefishos", "mouse");
+    settings.setValue(key, val);
+    settings.sync();
+}
+
+template<>
+void LibinputSettings::save(QString key, qreal val)
+{
+    QSettings settings("cutefishos", "mouse");
+    settings.setValue(key, val);
+    settings.sync();
+}
--- a/settings-daemon/mouse/libinputsettings.h
+++ b/settings-daemon/mouse/libinputsettings.h
@ -0,0 +1,20 @@
+/*
+    SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#ifndef LIBINPUTSETTINGS_H
+#define LIBINPUTSETTINGS_H
+
+#include <QString>
+
+struct LibinputSettings {
+    template<class T>
+    T load(QString key, T defVal);
+
+    template<class T>
+    void save(QString key, T val);
+};
+
+#endif // LIBINPUTSETTINGS_H
--- a/settings-daemon/mouse/mousemanager.cpp
+++ b/settings-daemon/mouse/mousemanager.cpp
@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2021 CutefishOS Team.
+ *
+ * Author:     Reion Wong <reionwong@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "mousemanager.h"
+#include "mouseadaptor.h"
+
+Mouse::Mouse(QObject *parent)
+    : QObject(parent)
+    , m_inputDummydevice(new X11LibinputDummyDevice(this, QX11Info::display()))
+{
+    // init dbus
+    new MouseAdaptor(this);
+    QDBusConnection::sessionBus().registerObject(QStringLiteral("/Mouse"), this);
+
+    connect(m_inputDummydevice, &X11LibinputDummyDevice::leftHandedChanged, this, &Mouse::leftHandedChanged);
+    connect(m_inputDummydevice, &X11LibinputDummyDevice::pointerAccelerationProfileChanged, this, &Mouse::accelerationChanged);
+    connect(m_inputDummydevice, &X11LibinputDummyDevice::naturalScrollChanged, this, &Mouse::naturalScrollChanged);
+    connect(m_inputDummydevice, &X11LibinputDummyDevice::pointerAccelerationChanged, this, &Mouse::pointerAccelerationChanged);
+}
+
+Mouse::~Mouse()
+{
+    delete m_inputDummydevice;
+}
+
+bool Mouse::leftHanded() const
+{
+    return m_inputDummydevice->isLeftHanded();
+}
+
+void Mouse::setLeftHanded(bool enabled)
+{
+    m_inputDummydevice->setLeftHanded(enabled);
+    m_inputDummydevice->applyConfig();
+}
+
+bool Mouse::acceleration() const
+{
+    return m_inputDummydevice->pointerAccelerationProfileFlat();
+}
+
+void Mouse::setAcceleration(bool enabled)
+{
+    m_inputDummydevice->setPointerAccelerationProfileFlat(enabled);
+    m_inputDummydevice->applyConfig();
+}
+
+bool Mouse::naturalScroll() const
+{
+    return m_inputDummydevice->isNaturalScroll();
+}
+
+void Mouse::setNaturalScroll(bool enabled)
+{
+    m_inputDummydevice->setNaturalScroll(enabled);
+    m_inputDummydevice->applyConfig();
+}
+
+qreal Mouse::pointerAcceleration() const
+{
+    return m_inputDummydevice->pointerAcceleration();
+}
+
+void Mouse::setPointerAcceleration(qreal value)
+{
+    m_inputDummydevice->setPointerAcceleration(value);
+    m_inputDummydevice->applyConfig();
+}
--- a/settings-daemon/mouse/mousemanager.h
+++ b/settings-daemon/mouse/mousemanager.h
@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2021 CutefishOS Team.
+ *
+ * Author:     Reion Wong <reionwong@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MOUSE_H
+#define MOUSE_H
+
+#include <QObject>
+#include "x11libinputdummydevice.h"
+
+class Mouse : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool leftHanded READ leftHanded WRITE setLeftHanded NOTIFY leftHandedChanged)
+    Q_PROPERTY(bool acceleration READ acceleration WRITE setAcceleration NOTIFY accelerationChanged)
+    Q_PROPERTY(bool naturalScroll READ naturalScroll WRITE setNaturalScroll NOTIFY naturalScrollChanged)
+    Q_PROPERTY(qreal pointerAcceleration READ pointerAcceleration WRITE setPointerAcceleration NOTIFY pointerAccelerationChanged)
+
+public:
+    explicit Mouse(QObject *parent = nullptr);
+    ~Mouse();
+
+    bool leftHanded() const;
+    void setLeftHanded(bool enabled);
+
+    bool acceleration() const;
+    void setAcceleration(bool enabled);
+
+    bool naturalScroll() const;
+    void setNaturalScroll(bool enabled);
+
+    qreal pointerAcceleration() const;
+    void setPointerAcceleration(qreal value);
+
+signals:
+    void leftHandedChanged();
+    void accelerationChanged();
+    void naturalScrollChanged();
+    void pointerAccelerationChanged();
+
+private:
+    X11LibinputDummyDevice *m_inputDummydevice;
+};
+
+#endif // MOUSE_H
--- a/settings-daemon/mouse/org.cutefish.Mouse.xml
+++ b/settings-daemon/mouse/org.cutefish.Mouse.xml
@ -0,0 +1,16 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+  <interface name="org.cutefish.Mouse">
+    <method name="setLeftHanded"><arg name="value" type="b" direction="in"/></method>
+    <property name="leftHanded" type="b" access="read"/>
+    <signal name="leftHandedChanged"></signal>
+
+    <method name="setPointerAcceleration"><arg name="value" type="d" direction="in"/></method>
+    <property name="pointerAcceleration" type="d" access="read"/>
+    <signal name="pointerAccelerationChanged"></signal>
+
+    <method name="setNaturalScroll"><arg name="value" type="b" direction="in"/></method>
+    <property name="naturalScroll" type="b" access="read"/>
+    <signal name="naturalScrollChanged"></signal>
+  </interface>
+</node>
--- a/settings-daemon/mouse/x11libinputdummydevice.cpp
+++ b/settings-daemon/mouse/x11libinputdummydevice.cpp
@ -0,0 +1,242 @@
+/*
+    SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+#include "x11libinputdummydevice.h"
+#include "libinputsettings.h"
+#include <QDebug>
+#include <libinput-properties.h>
+
+#include <X11/Xatom.h>
+#include <X11/extensions/XInput.h>
+#include <X11/extensions/XInput2.h>
+
+static Atom s_touchpadAtom;
+
+template<typename Callback>
+static void XIForallPointerDevices(Display *dpy, const Callback &callback)
+{
+    int ndevices_return;
+    XDeviceInfo *info = XListInputDevices(dpy, &ndevices_return);
+    if (!info) {
+        return;
+    }
+    for (int i = 0; i < ndevices_return; ++i) {
+        XDeviceInfo *dev = info + i;
+        if ((dev->use == IsXPointer || dev->use == IsXExtensionPointer) && dev->type != s_touchpadAtom) {
+            callback(dev);
+        }
+    }
+    XFreeDeviceList(info);
+}
+
+struct ScopedXDeleter {
+    static inline void cleanup(void *pointer)
+    {
+        if (pointer) {
+            XFree(pointer);
+        }
+    }
+};
+
+namespace
+{
+template<typename T>
+void valueWriterPart(T val, Atom valAtom, Display *dpy)
+{
+    Q_UNUSED(val);
+    Q_UNUSED(valAtom);
+    Q_UNUSED(dpy);
+}
+
+template<>
+void valueWriterPart<bool>(bool val, Atom valAtom, Display *dpy)
+{
+    XIForallPointerDevices(dpy, [&](XDeviceInfo *info) {
+        int deviceid = info->id;
+        Status status;
+        Atom type_return;
+        int format_return;
+        unsigned long num_items_return;
+        unsigned long bytes_after_return;
+
+        unsigned char *_data = nullptr;
+        // data returned is an 1 byte boolean
+        status = XIGetProperty(dpy, deviceid, valAtom, 0, 1, False, XA_INTEGER, &type_return, &format_return, &num_items_return, &bytes_after_return, &_data);
+        if (status != Success) {
+            return;
+        }
+
+        QScopedArrayPointer<unsigned char, ScopedXDeleter> data(_data);
+        _data = nullptr;
+
+        if (type_return != XA_INTEGER || !data || format_return != 8) {
+            return;
+        }
+
+        unsigned char sendVal[2] = {0};
+        if (num_items_return == 1) {
+            sendVal[0] = val;
+        } else {
+            // Special case for acceleration profile.
+            const Atom accel = XInternAtom(dpy, LIBINPUT_PROP_ACCEL_PROFILE_ENABLED, True);
+            if (num_items_return != 2 || valAtom != accel) {
+                return;
+            }
+            sendVal[val] = 1;
+        }
+
+        XIChangeProperty(dpy, deviceid, valAtom, XA_INTEGER, 8, XIPropModeReplace, sendVal, num_items_return);
+    });
+}
+
+template<>
+void valueWriterPart<qreal>(qreal val, Atom valAtom, Display *dpy)
+{
+    XIForallPointerDevices(dpy, [&](XDeviceInfo *info) {
+        int deviceid = info->id;
+        Status status;
+        Atom float_type = XInternAtom(dpy, "FLOAT", False);
+        Atom type_return;
+        int format_return;
+        unsigned long num_items_return;
+        unsigned long bytes_after_return;
+
+        unsigned char *_data = nullptr;
+        // data returned is an 1 byte boolean
+        status = XIGetProperty(dpy, deviceid, valAtom, 0, 1, False, float_type, &type_return, &format_return, &num_items_return, &bytes_after_return, &_data);
+        if (status != Success) {
+            return;
+        }
+
+        QScopedArrayPointer<unsigned char, ScopedXDeleter> data(_data);
+        _data = nullptr;
+
+        if (type_return != float_type || !data || format_return != 32 || num_items_return != 1) {
+            return;
+        }
+
+        unsigned char buffer[4096];
+        float *sendPtr = (float *)buffer;
+        *sendPtr = val;
+
+        XIChangeProperty(dpy, deviceid, valAtom, float_type, format_return, XIPropModeReplace, buffer, 1);
+    });
+}
+}
+
+X11LibinputDummyDevice::X11LibinputDummyDevice(QObject *parent, Display *dpy)
+    : QObject(parent)
+    , m_settings(new LibinputSettings())
+    , m_dpy(dpy)
+{
+    m_leftHanded.atom = XInternAtom(dpy, LIBINPUT_PROP_LEFT_HANDED, True);
+    m_middleEmulation.atom = XInternAtom(dpy, LIBINPUT_PROP_MIDDLE_EMULATION_ENABLED, True);
+    m_naturalScroll.atom = XInternAtom(dpy, LIBINPUT_PROP_NATURAL_SCROLL, True);
+    m_pointerAcceleration.atom = XInternAtom(dpy, LIBINPUT_PROP_ACCEL, True);
+    m_pointerAccelerationProfileFlat.atom = XInternAtom(dpy, LIBINPUT_PROP_ACCEL_PROFILE_ENABLED, True);
+
+    m_supportsDisableEvents.val = false;
+    m_enabled.val = true;
+    m_supportedButtons.val = Qt::LeftButton | Qt::MiddleButton | Qt::RightButton;
+    m_supportsLeftHanded.val = true;
+    m_supportsMiddleEmulation.val = true;
+    m_middleEmulationEnabledByDefault.val = false;
+
+    m_supportsPointerAcceleration.val = true;
+    m_defaultPointerAcceleration.val = 0;
+
+    m_supportsPointerAccelerationProfileAdaptive.val = true;
+    m_supportsPointerAccelerationProfileFlat.val = true;
+
+    m_defaultPointerAccelerationProfileAdaptive.val = true;
+    m_defaultPointerAccelerationProfileFlat.val = false;
+
+    m_supportsNaturalScroll.val = true;
+    m_naturalScrollEnabledByDefault.val = false;
+
+    s_touchpadAtom = XInternAtom(m_dpy, XI_TOUCHPAD, True);
+
+    // Init
+    getConfig();
+    applyConfig();
+}
+
+X11LibinputDummyDevice::~X11LibinputDummyDevice()
+{
+    delete m_settings;
+}
+
+bool X11LibinputDummyDevice::getConfig()
+{
+    auto reset = [this](Prop<bool> &prop, bool defVal) {
+        prop.reset(m_settings->load(prop.cfgName, defVal));
+    };
+
+    reset(m_leftHanded, false);
+
+    reset(m_middleEmulation, false);
+    reset(m_naturalScroll, false);
+    reset(m_pointerAccelerationProfileFlat, false);
+
+    m_pointerAccelerationProfileAdaptive.reset(!m_settings->load(m_pointerAccelerationProfileFlat.cfgName, false));
+    m_pointerAcceleration.reset(m_settings->load(m_pointerAcceleration.cfgName, 0.));
+
+    emit leftHandedChanged();
+    emit naturalScrollChanged();
+    emit pointerAccelerationProfileChanged();
+    emit pointerAccelerationChanged();
+
+    return true;
+}
+
+bool X11LibinputDummyDevice::getDefaultConfig()
+{
+    m_leftHanded.set(false);
+
+    m_pointerAcceleration.set(m_defaultPointerAcceleration);
+    m_pointerAccelerationProfileFlat.set(m_defaultPointerAccelerationProfileFlat);
+    m_pointerAccelerationProfileAdaptive.set(m_defaultPointerAccelerationProfileAdaptive);
+
+    m_middleEmulation.set(m_middleEmulationEnabledByDefault);
+    m_naturalScroll.set(m_naturalScrollEnabledByDefault);
+
+    return true;
+}
+
+bool X11LibinputDummyDevice::applyConfig()
+{
+    valueWriter(m_leftHanded);
+    valueWriter(m_middleEmulation);
+    valueWriter(m_naturalScroll);
+    valueWriter(m_pointerAcceleration);
+    valueWriter(m_pointerAccelerationProfileFlat);
+
+    return true;
+}
+
+template<typename T>
+bool X11LibinputDummyDevice::valueWriter(Prop<T> &prop)
+{
+    // Check atom availability first.
+    if (prop.atom == None) {
+        return false;
+    }
+
+    if (prop.val != prop.old) {
+        m_settings->save(prop.cfgName, prop.val);
+    }
+
+    valueWriterPart(prop.val, prop.atom, m_dpy);
+
+    prop.old = prop.val;
+
+    return true;
+}
+
+bool X11LibinputDummyDevice::isChangedConfig() const
+{
+    return m_leftHanded.changed() || m_pointerAcceleration.changed() || m_pointerAccelerationProfileFlat.changed()
+        || m_pointerAccelerationProfileAdaptive.changed() || m_middleEmulation.changed() || m_naturalScroll.changed();
+}
--- a/settings-daemon/mouse/x11libinputdummydevice.h
+++ b/settings-daemon/mouse/x11libinputdummydevice.h
@ -0,0 +1,297 @@
+/*
+    SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#ifndef X11LIBINPUTDUMMYDEVICE_H
+#define X11LIBINPUTDUMMYDEVICE_H
+
+#include <QObject>
+#include <QString>
+#include <QX11Info>
+
+#include <X11/Xdefs.h>
+
+struct LibinputSettings;
+
+class X11LibinputDummyDevice : public QObject
+{
+    Q_OBJECT
+
+    //
+    // general
+    Q_PROPERTY(QString name READ name CONSTANT)
+    Q_PROPERTY(bool supportsDisableEvents READ supportsDisableEvents CONSTANT)
+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
+
+    //
+    // advanced
+    Q_PROPERTY(Qt::MouseButtons supportedButtons READ supportedButtons CONSTANT)
+
+    Q_PROPERTY(bool supportsLeftHanded READ supportsLeftHanded CONSTANT)
+    Q_PROPERTY(bool leftHandedEnabledByDefault READ leftHandedEnabledByDefault CONSTANT)
+    Q_PROPERTY(bool leftHanded READ isLeftHanded WRITE setLeftHanded NOTIFY leftHandedChanged)
+
+    Q_PROPERTY(bool supportsMiddleEmulation READ supportsMiddleEmulation CONSTANT)
+    Q_PROPERTY(bool middleEmulationEnabledByDefault READ middleEmulationEnabledByDefault CONSTANT)
+    Q_PROPERTY(bool middleEmulation READ isMiddleEmulation WRITE setMiddleEmulation NOTIFY middleEmulationChanged)
+
+    //
+    // acceleration speed and profile
+    Q_PROPERTY(bool supportsPointerAcceleration READ supportsPointerAcceleration CONSTANT)
+    Q_PROPERTY(qreal pointerAcceleration READ pointerAcceleration WRITE setPointerAcceleration NOTIFY pointerAccelerationChanged)
+
+    Q_PROPERTY(bool supportsPointerAccelerationProfileFlat READ supportsPointerAccelerationProfileFlat CONSTANT)
+    Q_PROPERTY(bool defaultPointerAccelerationProfileFlat READ defaultPointerAccelerationProfileFlat CONSTANT)
+    Q_PROPERTY(bool pointerAccelerationProfileFlat READ pointerAccelerationProfileFlat WRITE setPointerAccelerationProfileFlat NOTIFY
+                   pointerAccelerationProfileChanged)
+
+    Q_PROPERTY(bool supportsPointerAccelerationProfileAdaptive READ supportsPointerAccelerationProfileAdaptive CONSTANT)
+    Q_PROPERTY(bool defaultPointerAccelerationProfileAdaptive READ defaultPointerAccelerationProfileAdaptive CONSTANT)
+    Q_PROPERTY(bool pointerAccelerationProfileAdaptive READ pointerAccelerationProfileAdaptive WRITE setPointerAccelerationProfileAdaptive NOTIFY
+                   pointerAccelerationProfileChanged)
+
+    //
+    // scrolling
+    Q_PROPERTY(bool supportsNaturalScroll READ supportsNaturalScroll CONSTANT)
+    Q_PROPERTY(bool naturalScrollEnabledByDefault READ naturalScrollEnabledByDefault CONSTANT)
+    Q_PROPERTY(bool naturalScroll READ isNaturalScroll WRITE setNaturalScroll NOTIFY naturalScrollChanged)
+
+public:
+    X11LibinputDummyDevice(QObject *parent, Display *dpy);
+    ~X11LibinputDummyDevice() override;
+
+    bool getConfig();
+    bool getDefaultConfig();
+    bool applyConfig();
+    bool isChangedConfig() const;
+
+    //
+    // general
+    QString name() const
+    {
+        return m_name.val;
+    }
+    QString sysName() const
+    {
+        return m_sysName.val;
+    }
+    bool supportsDisableEvents() const
+    {
+        return m_supportsDisableEvents.val;
+    }
+    void setEnabled(bool enabled)
+    {
+        m_enabled.set(enabled);
+    }
+    bool isEnabled() const
+    {
+        return m_enabled.val;
+    }
+    Qt::MouseButtons supportedButtons() const
+    {
+        return m_supportedButtons.val;
+    }
+
+    //
+    // advanced
+    bool supportsLeftHanded() const
+    {
+        return m_supportsLeftHanded.val;
+    }
+    bool leftHandedEnabledByDefault() const
+    {
+        return m_leftHandedEnabledByDefault.val;
+    }
+    bool isLeftHanded() const
+    {
+        return m_leftHanded.val;
+    }
+    void setLeftHanded(bool set)
+    {
+        m_leftHanded.set(set);
+    }
+
+    bool supportsMiddleEmulation() const
+    {
+        return m_supportsMiddleEmulation.val;
+    }
+    bool middleEmulationEnabledByDefault() const
+    {
+        return m_middleEmulationEnabledByDefault.val;
+    }
+    bool isMiddleEmulation() const
+    {
+        return m_middleEmulation.val;
+    }
+    void setMiddleEmulation(bool set)
+    {
+        m_middleEmulation.set(set);
+    }
+
+    //
+    // acceleration speed and profile
+    bool supportsPointerAcceleration() const
+    {
+        return m_supportsPointerAcceleration.val;
+    }
+    qreal pointerAcceleration() const
+    {
+        return m_pointerAcceleration.val;
+    }
+    void setPointerAcceleration(qreal acceleration)
+    {
+        m_pointerAcceleration.set(acceleration);
+    }
+
+    bool supportsPointerAccelerationProfileFlat() const
+    {
+        return m_supportsPointerAccelerationProfileFlat.val;
+    }
+    bool defaultPointerAccelerationProfileFlat() const
+    {
+        return m_defaultPointerAccelerationProfileFlat.val;
+    }
+    bool pointerAccelerationProfileFlat() const
+    {
+        return m_pointerAccelerationProfileFlat.val;
+    }
+    void setPointerAccelerationProfileFlat(bool set)
+    {
+        m_pointerAccelerationProfileFlat.set(set);
+    }
+
+    bool supportsPointerAccelerationProfileAdaptive() const
+    {
+        return m_supportsPointerAccelerationProfileAdaptive.val;
+    }
+    bool defaultPointerAccelerationProfileAdaptive() const
+    {
+        return m_defaultPointerAccelerationProfileAdaptive.val;
+    }
+    bool pointerAccelerationProfileAdaptive() const
+    {
+        return m_pointerAccelerationProfileAdaptive.val;
+    }
+    void setPointerAccelerationProfileAdaptive(bool set)
+    {
+        m_pointerAccelerationProfileAdaptive.set(set);
+    }
+
+    //
+    // scrolling
+    bool supportsNaturalScroll() const
+    {
+        return m_supportsNaturalScroll.val;
+    }
+    bool naturalScrollEnabledByDefault() const
+    {
+        return m_naturalScrollEnabledByDefault.val;
+    }
+    bool isNaturalScroll() const
+    {
+        return m_naturalScroll.val;
+    }
+    void setNaturalScroll(bool set)
+    {
+        m_naturalScroll.set(set);
+    }
+
+Q_SIGNALS:
+    void leftHandedChanged();
+    void pointerAccelerationChanged();
+    void pointerAccelerationProfileChanged();
+    void enabledChanged();
+    void middleEmulationChanged();
+    void naturalScrollChanged();
+
+private:
+    template<typename T>
+    struct Prop {
+        explicit Prop(const QString &_name, const QString &_cfgName = "")
+            : name(_name)
+            , cfgName(_cfgName)
+        {
+        }
+
+        void set(T newVal)
+        {
+            if (avail && val != newVal) {
+                val = newVal;
+            }
+        }
+        void set(const Prop<T> &p)
+        {
+            if (avail && val != p.val) {
+                val = p.val;
+            }
+        }
+        bool changed() const
+        {
+            return avail && (old != val);
+        }
+
+        void reset(T newVal)
+        {
+            val = newVal;
+            old = newVal;
+        }
+
+        QString name;
+        QString cfgName;
+
+        bool avail = true;
+        T old;
+        T val;
+
+        Atom atom;
+    };
+
+    template<typename T>
+    bool valueWriter(Prop<T> &prop);
+
+    //
+    // general
+    Prop<QString> m_name = Prop<QString>("name");
+    Prop<QString> m_sysName = Prop<QString>("sysName");
+    Prop<bool> m_supportsDisableEvents = Prop<bool>("supportsDisableEvents");
+    Prop<bool> m_enabled = Prop<bool>("enabled");
+
+    //
+    // advanced
+    Prop<Qt::MouseButtons> m_supportedButtons = Prop<Qt::MouseButtons>("supportedButtons");
+
+    Prop<bool> m_supportsLeftHanded = Prop<bool>("supportsLeftHanded");
+    Prop<bool> m_leftHandedEnabledByDefault = Prop<bool>("leftHandedEnabledByDefault");
+    Prop<bool> m_leftHanded = Prop<bool>("leftHanded", "XLbInptLeftHanded");
+
+    Prop<bool> m_supportsMiddleEmulation = Prop<bool>("supportsMiddleEmulation");
+    Prop<bool> m_middleEmulationEnabledByDefault = Prop<bool>("middleEmulationEnabledByDefault");
+    Prop<bool> m_middleEmulation = Prop<bool>("middleEmulation", "XLbInptMiddleEmulation");
+
+    //
+    // acceleration speed and profile
+    Prop<bool> m_supportsPointerAcceleration = Prop<bool>("supportsPointerAcceleration");
+    Prop<qreal> m_defaultPointerAcceleration = Prop<qreal>("defaultPointerAcceleration");
+    Prop<qreal> m_pointerAcceleration = Prop<qreal>("pointerAcceleration", "XLbInptPointerAcceleration");
+
+    Prop<bool> m_supportsPointerAccelerationProfileFlat = Prop<bool>("supportsPointerAccelerationProfileFlat");
+    Prop<bool> m_defaultPointerAccelerationProfileFlat = Prop<bool>("defaultPointerAccelerationProfileFlat");
+    Prop<bool> m_pointerAccelerationProfileFlat = Prop<bool>("pointerAccelerationProfileFlat", "XLbInptAccelProfileFlat");
+
+    Prop<bool> m_supportsPointerAccelerationProfileAdaptive = Prop<bool>("supportsPointerAccelerationProfileAdaptive");
+    Prop<bool> m_defaultPointerAccelerationProfileAdaptive = Prop<bool>("defaultPointerAccelerationProfileAdaptive");
+    Prop<bool> m_pointerAccelerationProfileAdaptive = Prop<bool>("pointerAccelerationProfileAdaptive");
+
+    //
+    // scrolling
+    Prop<bool> m_supportsNaturalScroll = Prop<bool>("supportsNaturalScroll");
+    Prop<bool> m_naturalScrollEnabledByDefault = Prop<bool>("naturalScrollEnabledByDefault");
+    Prop<bool> m_naturalScroll = Prop<bool>("naturalScroll", "XLbInptNaturalScroll");
+
+    LibinputSettings *m_settings;
+    Display *m_dpy = nullptr;
+};
+
+#endif // X11LIBINPUTDUMMYDEVICE_H