diff --git a/autotests/libinput/device_test.cpp b/autotests/libinput/device_test.cpp
index 0dfae64ec..cebc895d6 100644
--- a/autotests/libinput/device_test.cpp
+++ b/autotests/libinput/device_test.cpp
@@ -1,2404 +1,2428 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 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 2 of the License, or
 (at your option) 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 "mock_libinput.h"
 #include "../../libinput/device.h"
 #include <config-kwin.h>
 
 #include <KSharedConfig>
 
 #include <QDBusInterface>
 #include <QDBusConnection>
 #include <QtTest>
 
 #include <linux/input.h>
 
 using namespace KWin::LibInput;
 
 class TestLibinputDevice : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void testStaticGetter();
     void testDeviceType_data();
     void testDeviceType();
     void testGestureSupport_data();
     void testGestureSupport();
     void testNames_data();
     void testNames();
     void testProduct();
     void testVendor();
     void testTapFingerCount();
     void testSize_data();
     void testSize();
     void testDefaultPointerAcceleration_data();
     void testDefaultPointerAcceleration();
     void testDefaultPointerAccelerationProfileFlat_data();
     void testDefaultPointerAccelerationProfileFlat();
     void testDefaultPointerAccelerationProfileAdaptive_data();
     void testDefaultPointerAccelerationProfileAdaptive();
     void testDefaultClickMethodAreas_data();
     void testDefaultClickMethodAreas();
     void testDefaultClickMethodClickfinger_data();
     void testDefaultClickMethodClickfinger();
     void testLeftHandedEnabledByDefault_data();
     void testLeftHandedEnabledByDefault();
     void testTapEnabledByDefault_data();
     void testTapEnabledByDefault();
     void testMiddleEmulationEnabledByDefault_data();
     void testMiddleEmulationEnabledByDefault();
     void testNaturalScrollEnabledByDefault_data();
     void testNaturalScrollEnabledByDefault();
     void testScrollTwoFingerEnabledByDefault_data();
     void testScrollTwoFingerEnabledByDefault();
     void testScrollEdgeEnabledByDefault_data();
     void testScrollEdgeEnabledByDefault();
     void testScrollOnButtonDownEnabledByDefault_data();
     void testScrollOnButtonDownEnabledByDefault();
     void testDisableWhileTypingEnabledByDefault_data();
     void testDisableWhileTypingEnabledByDefault();
     void testLmrTapButtonMapEnabledByDefault_data();
     void testLmrTapButtonMapEnabledByDefault();
     void testSupportsDisableWhileTyping_data();
     void testSupportsDisableWhileTyping();
     void testSupportsPointerAcceleration_data();
     void testSupportsPointerAcceleration();
     void testSupportsLeftHanded_data();
     void testSupportsLeftHanded();
     void testSupportsCalibrationMatrix_data();
     void testSupportsCalibrationMatrix();
     void testSupportsDisableEvents_data();
     void testSupportsDisableEvents();
     void testSupportsDisableEventsOnExternalMouse_data();
     void testSupportsDisableEventsOnExternalMouse();
     void testSupportsMiddleEmulation_data();
     void testSupportsMiddleEmulation();
     void testSupportsNaturalScroll_data();
     void testSupportsNaturalScroll();
     void testSupportsScrollTwoFinger_data();
     void testSupportsScrollTwoFinger();
     void testSupportsScrollEdge_data();
     void testSupportsScrollEdge();
     void testSupportsScrollOnButtonDown_data();
     void testSupportsScrollOnButtonDown();
     void testDefaultScrollButton_data();
     void testDefaultScrollButton();
     void testPointerAcceleration_data();
     void testPointerAcceleration();
     void testLeftHanded_data();
     void testLeftHanded();
     void testSupportedButtons_data();
     void testSupportedButtons();
     void testAlphaNumericKeyboard_data();
     void testAlphaNumericKeyboard();
     void testEnabled_data();
     void testEnabled();
     void testTapToClick_data();
     void testTapToClick();
     void testTapAndDragEnabledByDefault_data();
     void testTapAndDragEnabledByDefault();
     void testTapAndDrag_data();
     void testTapAndDrag();
     void testTapDragLockEnabledByDefault_data();
     void testTapDragLockEnabledByDefault();
     void testTapDragLock_data();
     void testTapDragLock();
     void testMiddleEmulation_data();
     void testMiddleEmulation();
     void testNaturalScroll_data();
     void testNaturalScroll();
+    void testScrollFactor();
     void testScrollTwoFinger_data();
     void testScrollTwoFinger();
     void testScrollEdge_data();
     void testScrollEdge();
     void testScrollButtonDown_data();
     void testScrollButtonDown();
     void testScrollButton_data();
     void testScrollButton();
     void testDisableWhileTyping_data();
     void testDisableWhileTyping();
     void testLmrTapButtonMap_data();
     void testLmrTapButtonMap();
     void testLoadEnabled_data();
     void testLoadEnabled();
     void testLoadPointerAcceleration_data();
     void testLoadPointerAcceleration();
     void testLoadPointerAccelerationProfile_data();
     void testLoadPointerAccelerationProfile();
     void testLoadClickMethod_data();
     void testLoadClickMethod();
     void testLoadTapToClick_data();
     void testLoadTapToClick();
     void testLoadTapAndDrag_data();
     void testLoadTapAndDrag();
     void testLoadTapDragLock_data();
     void testLoadTapDragLock();
     void testLoadMiddleButtonEmulation_data();
     void testLoadMiddleButtonEmulation();
     void testLoadNaturalScroll_data();
     void testLoadNaturalScroll();
     void testLoadScrollMethod_data();
     void testLoadScrollMethod();
     void testLoadScrollButton_data();
     void testLoadScrollButton();
     void testLoadDisableWhileTyping_data();
     void testLoadDisableWhileTyping();
     void testLoadLmrTapButtonMap_data();
     void testLoadLmrTapButtonMap();
     void testLoadLeftHanded_data();
     void testLoadLeftHanded();
     void testScreenId();
     void testOrientation_data();
     void testOrientation();
     void testCalibrationWithDefault();
     void testSwitch_data();
     void testSwitch();
 };
 
 namespace {
 template <typename T>
 T dbusProperty(const QString &name, const char *property)
 {
     QDBusInterface interface{QStringLiteral("org.kde.kwin.tests.libinputdevice"),
                              QStringLiteral("/org/kde/KWin/InputDevice/") + name,
                              QStringLiteral("org.kde.KWin.InputDevice")};
     return interface.property(property).value<T>();
 }
 }
 
 void TestLibinputDevice::initTestCase()
 {
     QDBusConnection::sessionBus().registerService(QStringLiteral("org.kde.kwin.tests.libinputdevice"));
 }
 
 void TestLibinputDevice::testStaticGetter()
 {
     // this test verifies that the static getter for Device works as expected
     QVERIFY(Device::devices().isEmpty());
 
     // create some device
     libinput_device device1;
     libinput_device device2;
     // at the moment not yet known to Device
     QVERIFY(!Device::getDevice(&device1));
     QVERIFY(!Device::getDevice(&device2));
     QVERIFY(Device::devices().isEmpty());
 
     // now create a Device for one
     Device *d1 = new Device(&device1);
     QCOMPARE(Device::devices().count(), 1);
     QCOMPARE(Device::devices().first(), d1);
     QCOMPARE(Device::getDevice(&device1), d1);
     QVERIFY(!Device::getDevice(&device2));
 
     // and a second Device
     Device *d2 = new Device(&device2);
     QCOMPARE(Device::devices().count(), 2);
     QCOMPARE(Device::devices().first(), d1);
     QCOMPARE(Device::devices().last(), d2);
     QCOMPARE(Device::getDevice(&device1), d1);
     QCOMPARE(Device::getDevice(&device2), d2);
 
     // now delete d1
     delete d1;
     QCOMPARE(Device::devices().count(), 1);
     QCOMPARE(Device::devices().first(), d2);
     QCOMPARE(Device::getDevice(&device2), d2);
     QVERIFY(!Device::getDevice(&device1));
 
     // and delete d2
     delete d2;
     QVERIFY(!Device::getDevice(&device1));
     QVERIFY(!Device::getDevice(&device2));
     QVERIFY(Device::devices().isEmpty());
 }
 
 void TestLibinputDevice::testDeviceType_data()
 {
     QTest::addColumn<bool>("keyboard");
     QTest::addColumn<bool>("pointer");
     QTest::addColumn<bool>("touch");
     QTest::addColumn<bool>("tabletTool");
     QTest::addColumn<bool>("switchDevice");
 
     QTest::newRow("keyboard") << true << false << false << false << false;
     QTest::newRow("pointer") << false << true << false << false << false;
     QTest::newRow("touch") << false << false << true << false << false;
     QTest::newRow("keyboard/pointer") << true << true << false << false << false;
     QTest::newRow("keyboard/touch") << true << false << true << false << false;
     QTest::newRow("pointer/touch") << false << true << true << false << false;
     QTest::newRow("keyboard/pointer/touch") << true << true << true << false << false;
     QTest::newRow("tabletTool") << false << false << false << true << false;
     QTest::newRow("switch") << false << false << false << false << true;
 }
 
 void TestLibinputDevice::testDeviceType()
 {
     // this test verifies that the device type is recognized correctly
     QFETCH(bool, keyboard);
     QFETCH(bool, pointer);
     QFETCH(bool, touch);
     QFETCH(bool, tabletTool);
     QFETCH(bool, switchDevice);
 
     libinput_device device;
     device.keyboard = keyboard;
     device.pointer = pointer;
     device.touch = touch;
     device.tabletTool = tabletTool;
     device.switchDevice = switchDevice;
 
     Device d(&device);
     QCOMPARE(d.isKeyboard(), keyboard);
     QCOMPARE(d.property("keyboard").toBool(), keyboard);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "keyboard"), keyboard);
     QCOMPARE(d.isPointer(), pointer);
     QCOMPARE(d.property("pointer").toBool(), pointer);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "pointer"), pointer);
     QCOMPARE(d.isTouch(), touch);
     QCOMPARE(d.property("touch").toBool(), touch);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "touch"), touch);
     QCOMPARE(d.isTabletPad(), false);
     QCOMPARE(d.property("tabletPad").toBool(), false);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tabletPad"), false);
     QCOMPARE(d.isTabletTool(), tabletTool);
     QCOMPARE(d.property("tabletTool").toBool(), tabletTool);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tabletTool"), tabletTool);
     QCOMPARE(d.isSwitch(), switchDevice);
     QCOMPARE(d.property("switchDevice").toBool(), switchDevice);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "switchDevice"), switchDevice);
 
     QCOMPARE(d.device(), &device);
 }
 
 void TestLibinputDevice::testGestureSupport_data()
 {
     QTest::addColumn<bool>("supported");
 
     QTest::newRow("supported") << true;
     QTest::newRow("not supported") << false;
 }
 
 void TestLibinputDevice::testGestureSupport()
 {
     // this test verifies whether the Device supports gestures
     QFETCH(bool, supported);
     libinput_device device;
     device.gestureSupported = supported;
 
     Device d(&device);
     QCOMPARE(d.supportsGesture(), supported);
     QCOMPARE(d.property("gestureSupport").toBool(), supported);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "gestureSupport"), supported);
 }
 
 void TestLibinputDevice::testNames_data()
 {
     QTest::addColumn<QByteArray>("name");
     QTest::addColumn<QByteArray>("sysName");
     QTest::addColumn<QByteArray>("outputName");
 
     QTest::newRow("empty") << QByteArray() << QByteArrayLiteral("event1") << QByteArray();
     QTest::newRow("set") << QByteArrayLiteral("awesome test device") << QByteArrayLiteral("event0") << QByteArrayLiteral("hdmi0");
 }
 
 void TestLibinputDevice::testNames()
 {
     // this test verifies the various name properties of the Device
     QFETCH(QByteArray, name);
     QFETCH(QByteArray, sysName);
     QFETCH(QByteArray, outputName);
     libinput_device device;
     device.name = name;
     device.sysName = sysName;
     device.outputName = outputName;
 
     Device d(&device);
     QCOMPARE(d.name().toUtf8(), name);
     QCOMPARE(d.property("name").toString().toUtf8(), name);
     QCOMPARE(dbusProperty<QString>(d.sysName(), "name"), name);
     QCOMPARE(d.sysName().toUtf8(), sysName);
     QCOMPARE(d.property("sysName").toString().toUtf8(), sysName);
     QCOMPARE(dbusProperty<QString>(d.sysName(), "sysName"), sysName);
     QCOMPARE(d.outputName().toUtf8(), outputName);
     QCOMPARE(d.property("outputName").toString().toUtf8(), outputName);
     QCOMPARE(dbusProperty<QString>(d.sysName(), "outputName"), outputName);
 }
 
 void TestLibinputDevice::testProduct()
 {
     // this test verifies the product property
     libinput_device device;
     device.product = 100u;
     Device d(&device);
     QCOMPARE(d.product(), 100u);
     QCOMPARE(d.property("product").toUInt(), 100u);
     QCOMPARE(dbusProperty<quint32>(d.sysName(), "product"), 100u);
 }
 
 void TestLibinputDevice::testVendor()
 {
     // this test verifies the vendor property
     libinput_device device;
     device.vendor = 200u;
     Device d(&device);
     QCOMPARE(d.vendor(), 200u);
     QCOMPARE(d.property("vendor").toUInt(), 200u);
     QCOMPARE(dbusProperty<quint32>(d.sysName(), "vendor"), 200u);
 }
 
 void TestLibinputDevice::testTapFingerCount()
 {
     // this test verifies the tap finger count property
     libinput_device device;
     device.tapFingerCount = 3;
     Device d(&device);
     QCOMPARE(d.tapFingerCount(), 3);
     QCOMPARE(d.property("tapFingerCount").toInt(), 3);
     QCOMPARE(dbusProperty<int>(d.sysName(), "tapFingerCount"), 3);
 }
 
 void TestLibinputDevice::testSize_data()
 {
     QTest::addColumn<QSizeF>("setSize");
     QTest::addColumn<int>("returnValue");
     QTest::addColumn<QSizeF>("expectedSize");
 
     QTest::newRow("10/20") << QSizeF(10.5, 20.2) << 0 << QSizeF(10.5, 20.2);
     QTest::newRow("failure") << QSizeF(10, 20) << 1 << QSizeF();
 }
 
 void TestLibinputDevice::testSize()
 {
     // this test verifies that getting the size works correctly including failures
     QFETCH(QSizeF, setSize);
     QFETCH(int, returnValue);
     libinput_device device;
     device.deviceSize = setSize;
     device.deviceSizeReturnValue = returnValue;
 
     Device d(&device);
     QTEST(d.size(), "expectedSize");
     QTEST(d.property("size").toSizeF(), "expectedSize");
     QTEST(dbusProperty<QSizeF>(d.sysName(), "size"), "expectedSize");
 }
 
 void TestLibinputDevice::testLeftHandedEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testLeftHandedEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.leftHandedEnabledByDefault = enabled;
 
     Device d(&device);
     QCOMPARE(d.leftHandedEnabledByDefault(), enabled);
     QCOMPARE(d.property("leftHandedEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "leftHandedEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testTapEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testTapEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.tapEnabledByDefault = enabled;
 
     Device d(&device);
     QCOMPARE(d.tapToClickEnabledByDefault(), enabled);
     QCOMPARE(d.property("tapToClickEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tapToClickEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testMiddleEmulationEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testMiddleEmulationEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.middleEmulationEnabledByDefault = enabled;
 
     Device d(&device);
     QCOMPARE(d.middleEmulationEnabledByDefault(), enabled);
     QCOMPARE(d.property("middleEmulationEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "middleEmulationEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testNaturalScrollEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testNaturalScrollEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.naturalScrollEnabledByDefault = enabled;
 
     Device d(&device);
     QCOMPARE(d.naturalScrollEnabledByDefault(), enabled);
     QCOMPARE(d.property("naturalScrollEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "naturalScrollEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testScrollTwoFingerEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testScrollTwoFingerEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.defaultScrollMethod = enabled ? LIBINPUT_CONFIG_SCROLL_2FG : LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
 
     Device d(&device);
     QCOMPARE(d.scrollTwoFingerEnabledByDefault(), enabled);
     QCOMPARE(d.property("scrollTwoFingerEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollTwoFingerEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testScrollEdgeEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testScrollEdgeEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.defaultScrollMethod = enabled ? LIBINPUT_CONFIG_SCROLL_EDGE : LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
 
     Device d(&device);
     QCOMPARE(d.scrollEdgeEnabledByDefault(), enabled);
     QCOMPARE(d.property("scrollEdgeEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollEdgeEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testDefaultPointerAccelerationProfileFlat_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testDefaultPointerAccelerationProfileFlat()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.defaultPointerAccelerationProfile = enabled ? LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT : LIBINPUT_CONFIG_ACCEL_PROFILE_NONE;
 
     Device d(&device);
     QCOMPARE(d.defaultPointerAccelerationProfileFlat(), enabled);
     QCOMPARE(d.property("defaultPointerAccelerationProfileFlat").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "defaultPointerAccelerationProfileFlat"), enabled);
 }
 
 void TestLibinputDevice::testDefaultPointerAccelerationProfileAdaptive_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testDefaultPointerAccelerationProfileAdaptive()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.defaultPointerAccelerationProfile = enabled ? LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE : LIBINPUT_CONFIG_ACCEL_PROFILE_NONE;
 
     Device d(&device);
     QCOMPARE(d.defaultPointerAccelerationProfileAdaptive(), enabled);
     QCOMPARE(d.property("defaultPointerAccelerationProfileAdaptive").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "defaultPointerAccelerationProfileAdaptive"), enabled);
 }
 
 void TestLibinputDevice::testDefaultClickMethodAreas_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::addRow("enabled") << true;
     QTest::addRow("disabled") << false;
 }
 
 void TestLibinputDevice::testDefaultClickMethodAreas()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.defaultClickMethod = enabled ? LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS : LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER;
 
     Device d(&device);
     QCOMPARE(d.defaultClickMethodAreas(), enabled);
     QCOMPARE(d.property("defaultClickMethodAreas").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "defaultClickMethodAreas"), enabled);
 }
 
 void TestLibinputDevice::testDefaultClickMethodClickfinger_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::addRow("enabled") << true;
     QTest::addRow("disabled") << false;
 }
 
 void TestLibinputDevice::testDefaultClickMethodClickfinger()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.defaultClickMethod = enabled ? LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER : LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS;
 
     Device d(&device);
     QCOMPARE(d.defaultClickMethodClickfinger(), enabled);
     QCOMPARE(d.property("defaultClickMethodClickfinger").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "defaultClickMethodClickfinger"), enabled);
 }
 
 void TestLibinputDevice::testScrollOnButtonDownEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testScrollOnButtonDownEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.defaultScrollMethod = enabled ? LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN : LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
 
     Device d(&device);
     QCOMPARE(d.scrollOnButtonDownEnabledByDefault(), enabled);
     QCOMPARE(d.property("scrollOnButtonDownEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollOnButtonDownEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testDefaultScrollButton_data()
 {
     QTest::addColumn<quint32>("button");
 
     QTest::newRow("0") << 0u;
     QTest::newRow("BTN_LEFT") << quint32(BTN_LEFT);
     QTest::newRow("BTN_RIGHT") << quint32(BTN_RIGHT);
     QTest::newRow("BTN_MIDDLE") << quint32(BTN_MIDDLE);
     QTest::newRow("BTN_SIDE") << quint32(BTN_SIDE);
     QTest::newRow("BTN_EXTRA") << quint32(BTN_EXTRA);
     QTest::newRow("BTN_FORWARD") << quint32(BTN_FORWARD);
     QTest::newRow("BTN_BACK") << quint32(BTN_BACK);
     QTest::newRow("BTN_TASK") << quint32(BTN_TASK);
 }
 
 void TestLibinputDevice::testDefaultScrollButton()
 {
     libinput_device device;
     QFETCH(quint32, button);
     device.defaultScrollButton = button;
 
     Device d(&device);
     QCOMPARE(d.defaultScrollButton(), button);
     QCOMPARE(d.property("defaultScrollButton").value<quint32>(), button);
     QCOMPARE(dbusProperty<quint32>(d.sysName(), "defaultScrollButton"), button);
 }
 
 void TestLibinputDevice::testSupportsDisableWhileTyping_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsDisableWhileTyping()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportsDisableWhileTyping = enabled;
 
     Device d(&device);
     QCOMPARE(d.supportsDisableWhileTyping(), enabled);
     QCOMPARE(d.property("supportsDisableWhileTyping").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsDisableWhileTyping"), enabled);
 }
 
 void TestLibinputDevice::testSupportsPointerAcceleration_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsPointerAcceleration()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportsPointerAcceleration = enabled;
 
     Device d(&device);
     QCOMPARE(d.supportsPointerAcceleration(), enabled);
     QCOMPARE(d.property("supportsPointerAcceleration").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsPointerAcceleration"), enabled);
 }
 
 void TestLibinputDevice::testSupportsLeftHanded_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsLeftHanded()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportsLeftHanded = enabled;
 
     Device d(&device);
     QCOMPARE(d.supportsLeftHanded(), enabled);
     QCOMPARE(d.property("supportsLeftHanded").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsLeftHanded"), enabled);
 }
 
 void TestLibinputDevice::testSupportsCalibrationMatrix_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsCalibrationMatrix()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportsCalibrationMatrix = enabled;
 
     Device d(&device);
     QCOMPARE(d.supportsCalibrationMatrix(), enabled);
     QCOMPARE(d.property("supportsCalibrationMatrix").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsCalibrationMatrix"), enabled);
 }
 
 void TestLibinputDevice::testSupportsDisableEvents_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsDisableEvents()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportsDisableEvents = enabled;
 
     Device d(&device);
     QCOMPARE(d.supportsDisableEvents(), enabled);
     QCOMPARE(d.property("supportsDisableEvents").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsDisableEvents"), enabled);
 }
 
 void TestLibinputDevice::testSupportsDisableEventsOnExternalMouse_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsDisableEventsOnExternalMouse()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportsDisableEventsOnExternalMouse = enabled;
 
     Device d(&device);
     QCOMPARE(d.supportsDisableEventsOnExternalMouse(), enabled);
     QCOMPARE(d.property("supportsDisableEventsOnExternalMouse").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsDisableEventsOnExternalMouse"), enabled);
 }
 
 void TestLibinputDevice::testSupportsMiddleEmulation_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsMiddleEmulation()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportsMiddleEmulation = enabled;
 
     Device d(&device);
     QCOMPARE(d.supportsMiddleEmulation(), enabled);
     QCOMPARE(d.property("supportsMiddleEmulation").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsMiddleEmulation"), enabled);
 }
 
 void TestLibinputDevice::testSupportsNaturalScroll_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsNaturalScroll()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportsNaturalScroll = enabled;
 
     Device d(&device);
     QCOMPARE(d.supportsNaturalScroll(), enabled);
     QCOMPARE(d.property("supportsNaturalScroll").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsNaturalScroll"), enabled);
 }
 
 void TestLibinputDevice::testSupportsScrollTwoFinger_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsScrollTwoFinger()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportedScrollMethods = enabled ? LIBINPUT_CONFIG_SCROLL_2FG : LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
 
     Device d(&device);
     QCOMPARE(d.supportsScrollTwoFinger(), enabled);
     QCOMPARE(d.property("supportsScrollTwoFinger").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsScrollTwoFinger"), enabled);
 }
 
 void TestLibinputDevice::testSupportsScrollEdge_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsScrollEdge()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportedScrollMethods = enabled ? LIBINPUT_CONFIG_SCROLL_EDGE : LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
 
     Device d(&device);
     QCOMPARE(d.supportsScrollEdge(), enabled);
     QCOMPARE(d.property("supportsScrollEdge").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsScrollEdge"), enabled);
 }
 
 void TestLibinputDevice::testSupportsScrollOnButtonDown_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testSupportsScrollOnButtonDown()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.supportedScrollMethods = enabled ? LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN : LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
 
     Device d(&device);
     QCOMPARE(d.supportsScrollOnButtonDown(), enabled);
     QCOMPARE(d.property("supportsScrollOnButtonDown").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsScrollOnButtonDown"), enabled);
 }
 
 void TestLibinputDevice::testDefaultPointerAcceleration_data()
 {
     QTest::addColumn<qreal>("accel");
 
     QTest::newRow("-1.0") << -1.0;
     QTest::newRow("-0.5") << -0.5;
     QTest::newRow("0.0") << 0.0;
     QTest::newRow("0.3") << 0.3;
     QTest::newRow("1.0") << 1.0;
 }
 
 void TestLibinputDevice::testDefaultPointerAcceleration()
 {
     QFETCH(qreal, accel);
     libinput_device device;
     device.defaultPointerAcceleration = accel;
 
     Device d(&device);
     QCOMPARE(d.defaultPointerAcceleration(), accel);
     QCOMPARE(d.property("defaultPointerAcceleration").toReal(), accel);
     QCOMPARE(dbusProperty<qreal>(d.sysName(), "defaultPointerAcceleration"), accel);
 }
 
 void TestLibinputDevice::testPointerAcceleration_data()
 {
     QTest::addColumn<bool>("supported");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<qreal>("accel");
     QTest::addColumn<qreal>("setAccel");
     QTest::addColumn<qreal>("expectedAccel");
     QTest::addColumn<bool>("expectedChanged");
 
     QTest::newRow("-1 -> 2.0") << true << false << -1.0 << 2.0 << 1.0 << true;
     QTest::newRow("0 -> -1.0") << true << false << 0.0 << -1.0 << -1.0 << true;
     QTest::newRow("1 -> 1") << true << false << 1.0 << 1.0 << 1.0 << false;
     QTest::newRow("unsupported") << false << false << 0.0 << 1.0 << 0.0 << false;
     QTest::newRow("set fails") << true << true << -1.0 << 1.0 << -1.0 << false;
 }
 
 void TestLibinputDevice::testPointerAcceleration()
 {
     QFETCH(bool, supported);
     QFETCH(bool, setShouldFail);
     QFETCH(qreal, accel);
     libinput_device device;
     device.supportsPointerAcceleration = supported;
     device.pointerAcceleration = accel;
     device.setPointerAccelerationReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.pointerAcceleration(), accel);
     QCOMPARE(d.property("pointerAcceleration").toReal(), accel);
     QCOMPARE(dbusProperty<qreal>(d.sysName(), "pointerAcceleration"), accel);
 
     QSignalSpy pointerAccelChangedSpy(&d, &Device::pointerAccelerationChanged);
     QVERIFY(pointerAccelChangedSpy.isValid());
     QFETCH(qreal, setAccel);
     d.setPointerAcceleration(setAccel);
     QTEST(d.pointerAcceleration(), "expectedAccel");
     QTEST(!pointerAccelChangedSpy.isEmpty(), "expectedChanged");
     QTEST(dbusProperty<qreal>(d.sysName(), "pointerAcceleration"), "expectedAccel");
 }
 
 void TestLibinputDevice::testLeftHanded_data()
 {
     QTest::addColumn<bool>("supported");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("expectedValue");
 
     QTest::newRow("unsupported/true") << false << false << true << false << false;
     QTest::newRow("unsupported/false") << false << false << false << true << false;
     QTest::newRow("true -> false") << true << false << true << false << false;
     QTest::newRow("false -> true") << true << false << false << true  << true;
     QTest::newRow("set fails") << true << true << true << false << true;
     QTest::newRow("true -> true") << true << false << true << true << true;
     QTest::newRow("false -> false") << true << false << false << false << false;
 }
 
 void TestLibinputDevice::testLeftHanded()
 {
     QFETCH(bool, supported);
     QFETCH(bool, setShouldFail);
     QFETCH(bool, initValue);
     libinput_device device;
     device.supportsLeftHanded = supported;
     device.leftHanded = initValue;
     device.setLeftHandedReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.isLeftHanded(), supported && initValue);
     QCOMPARE(d.property("leftHanded").toBool(), supported && initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "leftHanded"), supported && initValue);
 
     QSignalSpy leftHandedChangedSpy(&d, &Device::leftHandedChanged);
     QVERIFY(leftHandedChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setLeftHanded(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isLeftHanded(), expectedValue);
     QCOMPARE(leftHandedChangedSpy.isEmpty(), (supported && initValue) == expectedValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "leftHanded"), expectedValue);
 }
 
 void TestLibinputDevice::testSupportedButtons_data()
 {
     QTest::addColumn<bool>("isPointer");
     QTest::addColumn<Qt::MouseButtons>("setButtons");
     QTest::addColumn<Qt::MouseButtons>("expectedButtons");
 
     QTest::newRow("left")    << true << Qt::MouseButtons(Qt::LeftButton)    << Qt::MouseButtons(Qt::LeftButton);
     QTest::newRow("right")   << true << Qt::MouseButtons(Qt::RightButton)   << Qt::MouseButtons(Qt::RightButton);
     QTest::newRow("middle")  << true << Qt::MouseButtons(Qt::MiddleButton)  << Qt::MouseButtons(Qt::MiddleButton);
     QTest::newRow("extra1")  << true << Qt::MouseButtons(Qt::ExtraButton1)  << Qt::MouseButtons(Qt::ExtraButton1);
     QTest::newRow("extra2")  << true << Qt::MouseButtons(Qt::ExtraButton2)  << Qt::MouseButtons(Qt::ExtraButton2);
     QTest::newRow("back")    << true << Qt::MouseButtons(Qt::BackButton)    << Qt::MouseButtons(Qt::BackButton);
     QTest::newRow("forward") << true << Qt::MouseButtons(Qt::ForwardButton) << Qt::MouseButtons(Qt::ForwardButton);
     QTest::newRow("task")    << true << Qt::MouseButtons(Qt::TaskButton)    << Qt::MouseButtons(Qt::TaskButton);
 
     QTest::newRow("no pointer/left")    << false << Qt::MouseButtons(Qt::LeftButton)    << Qt::MouseButtons();
     QTest::newRow("no pointer/right")   << false << Qt::MouseButtons(Qt::RightButton)   << Qt::MouseButtons();
     QTest::newRow("no pointer/middle")  << false << Qt::MouseButtons(Qt::MiddleButton)  << Qt::MouseButtons();
     QTest::newRow("no pointer/extra1")  << false << Qt::MouseButtons(Qt::ExtraButton1)  << Qt::MouseButtons();
     QTest::newRow("no pointer/extra2")  << false << Qt::MouseButtons(Qt::ExtraButton2)  << Qt::MouseButtons();
     QTest::newRow("no pointer/back")    << false << Qt::MouseButtons(Qt::BackButton)    << Qt::MouseButtons();
     QTest::newRow("no pointer/forward") << false << Qt::MouseButtons(Qt::ForwardButton) << Qt::MouseButtons();
     QTest::newRow("no pointer/task")    << false << Qt::MouseButtons(Qt::TaskButton)    << Qt::MouseButtons();
 
     QTest::newRow("all") << true
                          << Qt::MouseButtons(Qt::LeftButton | Qt::RightButton | Qt::MiddleButton | Qt::ExtraButton1 | Qt::ExtraButton2 | Qt::BackButton | Qt::ForwardButton | Qt::TaskButton)
                          << Qt::MouseButtons(Qt::LeftButton | Qt::RightButton | Qt::MiddleButton | Qt::ExtraButton1 | Qt::ExtraButton2 | Qt::BackButton | Qt::ForwardButton | Qt::TaskButton);
 }
 
 void TestLibinputDevice::testSupportedButtons()
 {
     libinput_device device;
     QFETCH(bool, isPointer);
     device.pointer = isPointer;
     QFETCH(Qt::MouseButtons, setButtons);
     device.supportedButtons = setButtons;
 
     Device d(&device);
     QCOMPARE(d.isPointer(), isPointer);
     QTEST(d.supportedButtons(), "expectedButtons");
     QTEST(Qt::MouseButtons(dbusProperty<int>(d.sysName(), "supportedButtons")), "expectedButtons");
 }
 
 void TestLibinputDevice::testAlphaNumericKeyboard_data()
 {
     QTest::addColumn<QVector<quint32>>("supportedKeys");
     QTest::addColumn<bool>("isAlpha");
 
     QVector<quint32> keys;
 
     for (int i = KEY_1; i <= KEY_0; i++) {
         keys << i;
         QByteArray row = QByteArrayLiteral("number");
         row.append(QByteArray::number(i));
         QTest::newRow(row.constData()) << keys << false;
     }
     for (int i = KEY_Q; i <= KEY_P; i++) {
         keys << i;
         QByteArray row = QByteArrayLiteral("alpha");
         row.append(QByteArray::number(i));
         QTest::newRow(row.constData()) << keys << false;
     }
     for (int i = KEY_A; i <= KEY_L; i++) {
         keys << i;
         QByteArray row = QByteArrayLiteral("alpha");
         row.append(QByteArray::number(i));
         QTest::newRow(row.constData()) << keys << false;
     }
     for (int i = KEY_Z; i < KEY_M; i++) {
         keys << i;
         QByteArray row = QByteArrayLiteral("alpha");
         row.append(QByteArray::number(i));
         QTest::newRow(row.constData()) << keys << false;
     }
     // adding a different key should not result in it becoming alphanumeric keyboard
     keys << KEY_SEMICOLON;
     QTest::newRow("semicolon") << keys << false;
 
     // last but not least the M which should turn everything on
     keys << KEY_M;
     QTest::newRow("alphanumeric") << keys << true;
 }
 
 void TestLibinputDevice::testAlphaNumericKeyboard()
 {
     QFETCH(QVector<quint32>, supportedKeys);
     libinput_device device;
     device.keyboard = true;
     device.keys = supportedKeys;
 
     Device d(&device);
     QCOMPARE(d.isKeyboard(), true);
     QTEST(d.isAlphaNumericKeyboard(), "isAlpha");
     QTEST(dbusProperty<bool>(d.sysName(), "alphaNumericKeyboard"), "isAlpha");
 }
 
 
 void TestLibinputDevice::testEnabled_data()
 {
     QTest::addColumn<bool>("supported");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("expectedValue");
 
     QTest::newRow("unsupported/true") << false << false << true << false << true;
     QTest::newRow("unsupported/false") << false << false << false << true << true;
     QTest::newRow("true -> false") << true << false << true << false << false;
     QTest::newRow("false -> true") << true << false << false << true  << true;
     QTest::newRow("set fails") << true << true << true << false << true;
     QTest::newRow("true -> true") << true << false << true << true << true;
     QTest::newRow("false -> false") << true << false << false << false << false;
 }
 
 void TestLibinputDevice::testEnabled()
 {
     libinput_device device;
     QFETCH(bool, supported);
     QFETCH(bool, setShouldFail);
     QFETCH(bool, initValue);
     device.supportsDisableEvents = supported;
     device.enabled = initValue;
     device.setEnableModeReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.isEnabled(), !supported || initValue);
     QCOMPARE(d.property("enabled").toBool(), !supported || initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "enabled"), !supported || initValue);
 
     QSignalSpy enabledChangedSpy(&d, &Device::enabledChanged);
     QVERIFY(enabledChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setEnabled(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isEnabled(), expectedValue);
 
     QCOMPARE(dbusProperty<bool>(d.sysName(), "enabled"), expectedValue);
 }
 
 void TestLibinputDevice::testTapToClick_data()
 {
     QTest::addColumn<int>("fingerCount");
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("expectedValue");
 
     QTest::newRow("unsupported") << 0 << false << true << true << false;
     QTest::newRow("true -> false") << 1 << true << false << false << false;
     QTest::newRow("false -> true") << 2 << false << true << false << true;
     QTest::newRow("set fails") << 3 << true << false << true << true;
     QTest::newRow("true -> true") << 2 << true << true << false << true;
     QTest::newRow("false -> false") << 1 << false << false << false << false;
 }
 
 void TestLibinputDevice::testTapToClick()
 {
     libinput_device device;
     QFETCH(int, fingerCount);
     QFETCH(bool, initValue);
     QFETCH(bool, setShouldFail);
     device.tapFingerCount = fingerCount;
     device.tapToClick = initValue;
     device.setTapToClickReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.tapFingerCount(), fingerCount);
     QCOMPARE(d.isTapToClick(), initValue);
     QCOMPARE(d.property("tapToClick").toBool(), initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tapToClick"), initValue);
 
     QSignalSpy tapToClickChangedSpy(&d, &Device::tapToClickChanged);
     QVERIFY(tapToClickChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setTapToClick(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isTapToClick(), expectedValue);
     QCOMPARE(tapToClickChangedSpy.isEmpty(), initValue == expectedValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tapToClick"), expectedValue);
 }
 
 void TestLibinputDevice::testTapAndDragEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testTapAndDragEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.tapAndDragEnabledByDefault = enabled;
 
     Device d(&device);
     QCOMPARE(d.tapAndDragEnabledByDefault(), enabled);
     QCOMPARE(d.property("tapAndDragEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tapAndDragEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testTapAndDrag_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("expectedValue");
 
     QTest::newRow("true -> false") << true << false << false << false;
     QTest::newRow("false -> true") << false << true << false << true;
     QTest::newRow("set fails") << true << false << true << true;
     QTest::newRow("true -> true") << true << true << false << true;
     QTest::newRow("false -> false") << false << false << false << false;
 }
 
 void TestLibinputDevice::testTapAndDrag()
 {
     libinput_device device;
     QFETCH(bool, initValue);
     QFETCH(bool, setShouldFail);
     device.tapAndDrag = initValue;
     device.setTapAndDragReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.isTapAndDrag(), initValue);
     QCOMPARE(d.property("tapAndDrag").toBool(), initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tapAndDrag"), initValue);
 
     QSignalSpy tapAndDragChangedSpy(&d, &Device::tapAndDragChanged);
     QVERIFY(tapAndDragChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setTapAndDrag(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isTapAndDrag(), expectedValue);
     QCOMPARE(tapAndDragChangedSpy.isEmpty(), initValue == expectedValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tapAndDrag"), expectedValue);
 }
 
 void TestLibinputDevice::testTapDragLockEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testTapDragLockEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.tapDragLockEnabledByDefault = enabled;
 
     Device d(&device);
     QCOMPARE(d.tapDragLockEnabledByDefault(), enabled);
     QCOMPARE(d.property("tapDragLockEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tapDragLockEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testTapDragLock_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("expectedValue");
 
     QTest::newRow("true -> false") << true << false << false << false;
     QTest::newRow("false -> true") << false << true << false << true;
     QTest::newRow("set fails") << true << false << true << true;
     QTest::newRow("true -> true") << true << true << false << true;
     QTest::newRow("false -> false") << false << false << false << false;
 }
 
 void TestLibinputDevice::testTapDragLock()
 {
     libinput_device device;
     QFETCH(bool, initValue);
     QFETCH(bool, setShouldFail);
     device.tapDragLock = initValue;
     device.setTapDragLockReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.isTapDragLock(), initValue);
     QCOMPARE(d.property("tapDragLock").toBool(), initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tapDragLock"), initValue);
 
     QSignalSpy tapDragLockChangedSpy(&d, &Device::tapDragLockChanged);
     QVERIFY(tapDragLockChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setTapDragLock(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isTapDragLock(), expectedValue);
     QCOMPARE(tapDragLockChangedSpy.isEmpty(), initValue == expectedValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tapDragLock"), expectedValue);
 }
 
 void TestLibinputDevice::testMiddleEmulation_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("expectedValue");
     QTest::addColumn<bool>("supportsMiddleButton");
 
     QTest::newRow("true -> false") << true << false << false << false << true;
     QTest::newRow("false -> true") << false << true << false << true << true;
     QTest::newRow("set fails") << true << false << true << true << true;
     QTest::newRow("true -> true") << true << true << false << true << true;
     QTest::newRow("false -> false") << false << false << false << false << true;
 
     QTest::newRow("false -> true, unsupported") << false << true << true << false << false;
 }
 
 void TestLibinputDevice::testMiddleEmulation()
 {
     libinput_device device;
     QFETCH(bool, initValue);
     QFETCH(bool, setShouldFail);
     QFETCH(bool, supportsMiddleButton);
     device.supportsMiddleEmulation = supportsMiddleButton;
     device.middleEmulation = initValue;
     device.setMiddleEmulationReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.isMiddleEmulation(), initValue);
     QCOMPARE(d.property("middleEmulation").toBool(), initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "middleEmulation"), initValue);
 
     QSignalSpy middleEmulationChangedSpy(&d, &Device::middleEmulationChanged);
     QVERIFY(middleEmulationChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setMiddleEmulation(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isMiddleEmulation(), expectedValue);
     QCOMPARE(d.property("middleEmulation").toBool(), expectedValue);
     QCOMPARE(middleEmulationChangedSpy.isEmpty(), initValue == expectedValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "middleEmulation"), expectedValue);
 }
 
 void TestLibinputDevice::testNaturalScroll_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("expectedValue");
     QTest::addColumn<bool>("supportsNaturalScroll");
 
     QTest::newRow("true -> false") << true << false << false << false << true;
     QTest::newRow("false -> true") << false << true << false << true << true;
     QTest::newRow("set fails") << true << false << true << true << true;
     QTest::newRow("true -> true") << true << true << false << true << true;
     QTest::newRow("false -> false") << false << false << false << false << true;
 
     QTest::newRow("false -> true, unsupported") << false << true << true << false << false;
 }
 
 void TestLibinputDevice::testNaturalScroll()
 {
     libinput_device device;
     QFETCH(bool, initValue);
     QFETCH(bool, setShouldFail);
     QFETCH(bool, supportsNaturalScroll);
     device.supportsNaturalScroll = supportsNaturalScroll;
     device.naturalScroll = initValue;
     device.setNaturalScrollReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.isNaturalScroll(), initValue);
     QCOMPARE(d.property("naturalScroll").toBool(), initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "naturalScroll"), initValue);
 
     QSignalSpy naturalScrollChangedSpy(&d, &Device::naturalScrollChanged);
     QVERIFY(naturalScrollChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setNaturalScroll(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isNaturalScroll(), expectedValue);
     QCOMPARE(d.property("naturalScroll").toBool(), expectedValue);
     QCOMPARE(naturalScrollChangedSpy.isEmpty(), initValue == expectedValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "naturalScroll"), expectedValue);
 }
 
+void TestLibinputDevice::testScrollFactor()
+{
+    libinput_device device;
+
+    qreal initValue = 1.0;
+
+    Device d(&device);
+    QCOMPARE(d.scrollFactor(), initValue);
+    QCOMPARE(d.property("scrollFactor").toReal(), initValue);
+    QCOMPARE(dbusProperty<qreal>(d.sysName(), "scrollFactor"), initValue);
+
+    QSignalSpy scrollFactorChangedSpy(&d, &Device::scrollFactorChanged);
+    QVERIFY(scrollFactorChangedSpy.isValid());
+
+    qreal expectedValue = 2.0;
+
+    d.setScrollFactor(expectedValue);
+    QCOMPARE(d.scrollFactor(), expectedValue);
+    QCOMPARE(d.property("scrollFactor").toReal(), expectedValue);
+    QCOMPARE(scrollFactorChangedSpy.isEmpty(), false);
+    QCOMPARE(dbusProperty<qreal>(d.sysName(), "scrollFactor"), expectedValue);
+}
+
 void TestLibinputDevice::testScrollTwoFinger_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("otherValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("expectedValue");
     QTest::addColumn<bool>("supportsScrollTwoFinger");
 
     QTest::newRow("true -> false") << true << false << false << false << false << true;
     QTest::newRow("other -> false") << false << true << false << false << false << true;
     QTest::newRow("false -> true") << false << false << true << false << true << true;
     QTest::newRow("set fails") << true << false << false << true << true << true;
     QTest::newRow("true -> true") << true << false << true << false << true << true;
     QTest::newRow("false -> false") << false << false << false << false << false << true;
 
     QTest::newRow("false -> true, unsupported") << false << false << true << true << false << false;
 }
 
 void TestLibinputDevice::testScrollTwoFinger()
 {
     libinput_device device;
     QFETCH(bool, initValue);
     QFETCH(bool, otherValue);
     QFETCH(bool, setShouldFail);
     QFETCH(bool, supportsScrollTwoFinger);
     device.supportedScrollMethods = (supportsScrollTwoFinger ? LIBINPUT_CONFIG_SCROLL_2FG : LIBINPUT_CONFIG_SCROLL_NO_SCROLL) | LIBINPUT_CONFIG_SCROLL_EDGE;
     device.scrollMethod = initValue ? LIBINPUT_CONFIG_SCROLL_2FG : otherValue ? LIBINPUT_CONFIG_SCROLL_EDGE : LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
     device.setScrollMethodReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.isScrollTwoFinger(), initValue);
     QCOMPARE(d.property("scrollTwoFinger").toBool(), initValue);
     QCOMPARE(d.property("scrollEdge").toBool(), otherValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollTwoFinger"), initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollEdge"), otherValue);
 
     QSignalSpy scrollMethodChangedSpy(&d, &Device::scrollMethodChanged);
     QVERIFY(scrollMethodChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setScrollTwoFinger(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isScrollTwoFinger(), expectedValue);
     QCOMPARE(d.property("scrollTwoFinger").toBool(), expectedValue);
     QCOMPARE(scrollMethodChangedSpy.isEmpty(), initValue == expectedValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollTwoFinger"), expectedValue);
 }
 
 void TestLibinputDevice::testScrollEdge_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("otherValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("expectedValue");
     QTest::addColumn<bool>("supportsScrollEdge");
 
     QTest::newRow("true -> false") << true << false << false << false << false << true;
     QTest::newRow("other -> false") << false << true << false << false << false << true;
     QTest::newRow("false -> true") << false << false << true << false << true << true;
     QTest::newRow("set fails") << true << false << false << true << true << true;
     QTest::newRow("true -> true") << true << false << true << false << true << true;
     QTest::newRow("false -> false") << false << false << false << false << false << true;
 
     QTest::newRow("false -> true, unsupported") << false << false << true << true << false << false;
 }
 
 void TestLibinputDevice::testScrollEdge()
 {
     libinput_device device;
     QFETCH(bool, initValue);
     QFETCH(bool, otherValue);
     QFETCH(bool, setShouldFail);
     QFETCH(bool, supportsScrollEdge);
     device.supportedScrollMethods = (supportsScrollEdge ? LIBINPUT_CONFIG_SCROLL_EDGE : LIBINPUT_CONFIG_SCROLL_NO_SCROLL) | LIBINPUT_CONFIG_SCROLL_2FG;
     device.scrollMethod = initValue ? LIBINPUT_CONFIG_SCROLL_EDGE : otherValue ? LIBINPUT_CONFIG_SCROLL_2FG : LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
     device.setScrollMethodReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.isScrollEdge(), initValue);
     QCOMPARE(d.property("scrollEdge").toBool(), initValue);
     QCOMPARE(d.property("scrollTwoFinger").toBool(), otherValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollEdge"), initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollTwoFinger"), otherValue);
 
     QSignalSpy scrollMethodChangedSpy(&d, &Device::scrollMethodChanged);
     QVERIFY(scrollMethodChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setScrollEdge(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isScrollEdge(), expectedValue);
     QCOMPARE(d.property("scrollEdge").toBool(), expectedValue);
     QCOMPARE(scrollMethodChangedSpy.isEmpty(), initValue == expectedValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollEdge"), expectedValue);
 }
 
 void TestLibinputDevice::testScrollButtonDown_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("otherValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("expectedValue");
     QTest::addColumn<bool>("supportsScrollButtonDown");
 
     QTest::newRow("true -> false") << true << false << false << false << false << true;
     QTest::newRow("other -> false") << false << true << false << false << false << true;
     QTest::newRow("false -> true") << false << false << true << false << true << true;
     QTest::newRow("set fails") << true << false << false << true << true << true;
     QTest::newRow("true -> true") << true << false << true << false << true << true;
     QTest::newRow("false -> false") << false << false << false << false << false << true;
 
     QTest::newRow("false -> true, unsupported") << false << false << true << true << false << false;
 }
 
 void TestLibinputDevice::testScrollButtonDown()
 {
     libinput_device device;
     QFETCH(bool, initValue);
     QFETCH(bool, otherValue);
     QFETCH(bool, setShouldFail);
     QFETCH(bool, supportsScrollButtonDown);
     device.supportedScrollMethods = (supportsScrollButtonDown ? LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN : LIBINPUT_CONFIG_SCROLL_NO_SCROLL) | LIBINPUT_CONFIG_SCROLL_2FG;
     device.scrollMethod = initValue ? LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN : otherValue ? LIBINPUT_CONFIG_SCROLL_2FG : LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
     device.setScrollMethodReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.isScrollOnButtonDown(), initValue);
     QCOMPARE(d.property("scrollOnButtonDown").toBool(), initValue);
     QCOMPARE(d.property("scrollTwoFinger").toBool(), otherValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollOnButtonDown"), initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollTwoFinger"), otherValue);
 
     QSignalSpy scrollMethodChangedSpy(&d, &Device::scrollMethodChanged);
     QVERIFY(scrollMethodChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setScrollOnButtonDown(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isScrollOnButtonDown(), expectedValue);
     QCOMPARE(d.property("scrollOnButtonDown").toBool(), expectedValue);
     QCOMPARE(scrollMethodChangedSpy.isEmpty(), initValue == expectedValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollOnButtonDown"), expectedValue);
 }
 
 void TestLibinputDevice::testScrollButton_data()
 {
     QTest::addColumn<quint32>("initValue");
     QTest::addColumn<quint32>("setValue");
     QTest::addColumn<quint32>("expectedValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("scrollOnButton");
 
     QTest::newRow("BTN_LEFT -> BTN_RIGHT") << quint32(BTN_LEFT) << quint32(BTN_RIGHT) << quint32(BTN_RIGHT) << false << true;
     QTest::newRow("BTN_LEFT -> BTN_LEFT") << quint32(BTN_LEFT) << quint32(BTN_LEFT) << quint32(BTN_LEFT) << false << true;
     QTest::newRow("set should fail") << quint32(BTN_LEFT) << quint32(BTN_RIGHT) << quint32(BTN_LEFT) << true << true;
     QTest::newRow("not scroll on button") << quint32(BTN_LEFT) << quint32(BTN_RIGHT) << quint32(BTN_LEFT) << false << false;
 }
 
 void TestLibinputDevice::testScrollButton()
 {
     libinput_device device;
     QFETCH(quint32, initValue);
     QFETCH(bool, setShouldFail);
     QFETCH(bool, scrollOnButton);
     device.scrollButton = initValue;
     device.supportedScrollMethods = scrollOnButton ? LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN : LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
     device.setScrollButtonReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.scrollButton(), initValue);
     QCOMPARE(d.property("scrollButton").value<quint32>(), initValue);
     QCOMPARE(dbusProperty<quint32>(d.sysName(), "scrollButton"), initValue);
 
     QSignalSpy scrollButtonChangedSpy(&d, &Device::scrollButtonChanged);
     QVERIFY(scrollButtonChangedSpy.isValid());
     QFETCH(quint32, setValue);
     d.setScrollButton(setValue);
     QFETCH(quint32, expectedValue);
     QCOMPARE(d.scrollButton(), expectedValue);
     QCOMPARE(d.property("scrollButton").value<quint32>(), expectedValue);
     QCOMPARE(scrollButtonChangedSpy.isEmpty(), initValue == expectedValue);
     QCOMPARE(dbusProperty<quint32>(d.sysName(), "scrollButton"), expectedValue);
 }
 
 void TestLibinputDevice::testDisableWhileTypingEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testDisableWhileTypingEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.disableWhileTypingEnabledByDefault = enabled ? LIBINPUT_CONFIG_DWT_ENABLED : LIBINPUT_CONFIG_DWT_DISABLED;
 
     Device d(&device);
     QCOMPARE(d.disableWhileTypingEnabledByDefault(), enabled);
     QCOMPARE(d.property("disableWhileTypingEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "disableWhileTypingEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testLmrTapButtonMapEnabledByDefault_data()
 {
     QTest::addColumn<bool>("enabled");
 
     QTest::newRow("enabled") << true;
     QTest::newRow("disabled") << false;
 }
 
 void TestLibinputDevice::testLmrTapButtonMapEnabledByDefault()
 {
     QFETCH(bool, enabled);
     libinput_device device;
     device.defaultTapButtonMap = enabled ? LIBINPUT_CONFIG_TAP_MAP_LMR : LIBINPUT_CONFIG_TAP_MAP_LRM;
 
     Device d(&device);
     QCOMPARE(d.lmrTapButtonMapEnabledByDefault(), enabled);
     QCOMPARE(d.property("lmrTapButtonMapEnabledByDefault").toBool(), enabled);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "lmrTapButtonMapEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testLmrTapButtonMap_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("expectedValue");
     QTest::addColumn<int>("fingerCount");
 
     QTest::newRow("true -> false") << true << false << false << false << 3;
     QTest::newRow("false -> true") << false << true << false << true << 3;
     QTest::newRow("true -> false") << true << false << false << false << 2;
     QTest::newRow("false -> true") << false << true << false << true << 2;
 
     QTest::newRow("set fails") << true << false << true << true << 3;
 
     QTest::newRow("true -> true") << true << true << false << true << 3;
     QTest::newRow("false -> false") << false << false << false << false << 3;
     QTest::newRow("true -> true") << true << true << false << true << 2;
     QTest::newRow("false -> false") << false << false << false << false << 2;
 
     QTest::newRow("false -> true, fingerCount 0") << false << true << true << false << 0;
 
     // TODO: is this a fail in libinput?
     //QTest::newRow("false -> true, fingerCount 1") << false << true << true << false << 1;
 }
 
 void TestLibinputDevice::testLmrTapButtonMap()
 {
     libinput_device device;
     QFETCH(bool, initValue);
     QFETCH(bool, setShouldFail);
     QFETCH(int, fingerCount);
     device.tapFingerCount = fingerCount;
     device.tapButtonMap = initValue ? LIBINPUT_CONFIG_TAP_MAP_LMR : LIBINPUT_CONFIG_TAP_MAP_LRM;
     device.setTapButtonMapReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.lmrTapButtonMap(), initValue);
     QCOMPARE(d.property("lmrTapButtonMap").toBool(), initValue);
 
     QSignalSpy tapButtonMapChangedSpy(&d, &Device::tapButtonMapChanged);
     QVERIFY(tapButtonMapChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setLmrTapButtonMap(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.lmrTapButtonMap(), expectedValue);
     QCOMPARE(d.property("lmrTapButtonMap").toBool(), expectedValue);
     QCOMPARE(tapButtonMapChangedSpy.isEmpty(), initValue == expectedValue);
 }
 
 void TestLibinputDevice::testDisableWhileTyping_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("setValue");
     QTest::addColumn<bool>("setShouldFail");
     QTest::addColumn<bool>("expectedValue");
     QTest::addColumn<bool>("supportsDisableWhileTyping");
 
     QTest::newRow("true -> false") << true << false << false << false << true;
     QTest::newRow("false -> true") << false << true << false << true << true;
     QTest::newRow("set fails") << true << false << true << true << true;
     QTest::newRow("true -> true") << true << true << false << true << true;
     QTest::newRow("false -> false") << false << false << false << false << true;
 
     QTest::newRow("false -> true, unsupported") << false << true << true << false << false;
 }
 
 void TestLibinputDevice::testDisableWhileTyping()
 {
     libinput_device device;
     QFETCH(bool, initValue);
     QFETCH(bool, setShouldFail);
     QFETCH(bool, supportsDisableWhileTyping);
     device.supportsDisableWhileTyping = supportsDisableWhileTyping;
     device.disableWhileTyping = initValue ? LIBINPUT_CONFIG_DWT_ENABLED : LIBINPUT_CONFIG_DWT_DISABLED;
     device.setDisableWhileTypingReturnValue = setShouldFail;
 
     Device d(&device);
     QCOMPARE(d.isDisableWhileTyping(), initValue);
     QCOMPARE(d.property("disableWhileTyping").toBool(), initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "disableWhileTyping"), initValue);
 
     QSignalSpy disableWhileTypingChangedSpy(&d, &Device::disableWhileTypingChanged);
     QVERIFY(disableWhileTypingChangedSpy.isValid());
     QFETCH(bool, setValue);
     d.setDisableWhileTyping(setValue);
     QFETCH(bool, expectedValue);
     QCOMPARE(d.isDisableWhileTyping(), expectedValue);
     QCOMPARE(d.property("disableWhileTyping").toBool(), expectedValue);
     QCOMPARE(disableWhileTypingChangedSpy.isEmpty(), initValue == expectedValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "disableWhileTyping"), expectedValue);
 }
 
 void TestLibinputDevice::testLoadEnabled_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("configValue");
 
     QTest::newRow("false -> true") << false << true;
     QTest::newRow("true -> false") << true << false;
     QTest::newRow("true -> true") << true << true;
     QTest::newRow("false -> false") << false << false;
 }
 
 void TestLibinputDevice::testLoadEnabled()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(bool, configValue);
     QFETCH(bool, initValue);
     inputConfig.writeEntry("Enabled", configValue);
 
     libinput_device device;
     device.supportsDisableEvents = true;
     device.enabled = initValue;
     device.setEnableModeReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.isEnabled(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.isEnabled(), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.isEnabled(), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setEnabled(initValue);
         QCOMPARE(inputConfig.readEntry("Enabled", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadPointerAcceleration_data()
 {
     QTest::addColumn<qreal>("initValue");
     QTest::addColumn<qreal>("configValue");
 
     QTest::newRow("-0.2 -> 0.9") << -0.2 << 0.9;
     QTest::newRow("0.0 -> -1.0") << 0.0 << -1.0;
     QTest::newRow("0.123 -> -0.456") << 0.123 << -0.456;
     QTest::newRow("0.7 -> 0.7") << 0.7 << 0.7;
 }
 
 void TestLibinputDevice::testLoadPointerAcceleration()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(qreal, configValue);
     QFETCH(qreal, initValue);
     inputConfig.writeEntry("PointerAcceleration", configValue);
 
     libinput_device device;
     device.supportsPointerAcceleration = true;
     device.pointerAcceleration = initValue;
     device.setPointerAccelerationReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.pointerAcceleration(), initValue);
     QCOMPARE(d.property("pointerAcceleration").toReal(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.pointerAcceleration(), initValue);
     QCOMPARE(d.property("pointerAcceleration").toReal(), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.pointerAcceleration(), configValue);
     QCOMPARE(d.property("pointerAcceleration").toReal(), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setPointerAcceleration(initValue);
         QCOMPARE(inputConfig.readEntry("PointerAcceleration", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadPointerAccelerationProfile_data()
 {
     QTest::addColumn<quint32>("initValue");
     QTest::addColumn<QString>("initValuePropNameString");
     QTest::addColumn<quint32>("configValue");
     QTest::addColumn<QString>("configValuePropNameString");
 
     QTest::newRow("pointerAccelerationProfileFlat -> pointerAccelerationProfileAdaptive")
             << (quint32) LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT << "pointerAccelerationProfileFlat"
             << (quint32) LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE << "pointerAccelerationProfileAdaptive";
     QTest::newRow("pointerAccelerationProfileAdaptive -> pointerAccelerationProfileFlat")
             << (quint32) LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE << "pointerAccelerationProfileAdaptive"
             << (quint32) LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT << "pointerAccelerationProfileFlat";
     QTest::newRow("pointerAccelerationProfileAdaptive -> pointerAccelerationProfileAdaptive")
             << (quint32) LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE << "pointerAccelerationProfileAdaptive" << (quint32) LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE << "pointerAccelerationProfileAdaptive";
 }
 
 void TestLibinputDevice::testLoadPointerAccelerationProfile()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(quint32, initValue);
     QFETCH(quint32, configValue);
     QFETCH(QString, initValuePropNameString);
     QFETCH(QString, configValuePropNameString);
 
     QByteArray initValuePropName = initValuePropNameString.toLatin1();
     QByteArray configValuePropName = configValuePropNameString.toLatin1();
 
     inputConfig.writeEntry("PointerAccelerationProfile", configValue);
 
     libinput_device device;
     device.supportedPointerAccelerationProfiles = LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT | LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE;
     device.pointerAccelerationProfile = (libinput_config_accel_profile) initValue;
     device.setPointerAccelerationProfileReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.property(initValuePropName).toBool(), true);
     QCOMPARE(d.property(configValuePropName).toBool(), initValue == configValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.property(initValuePropName).toBool(), true);
     QCOMPARE(d.property(configValuePropName).toBool(), initValue == configValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.property(initValuePropName).toBool(), initValue == configValue);
     QCOMPARE(d.property(configValuePropName).toBool(), true);
     QCOMPARE(dbusProperty<bool>(d.sysName(), initValuePropName), initValue == configValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), configValuePropName), true);
 
     // and try to store
     if (configValue != initValue) {
         d.setProperty(initValuePropName, true);
         QCOMPARE(inputConfig.readEntry("PointerAccelerationProfile", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadClickMethod_data()
 {
     QTest::addColumn<quint32>("initValue");
     QTest::addColumn<QString>("initValuePropNameString");
     QTest::addColumn<quint32>("configValue");
     QTest::addColumn<QString>("configValuePropNameString");
 
     QTest::newRow("clickMethodAreas -> clickMethodClickfinger")
             << static_cast<quint32>(LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS) << "clickMethodAreas"
             << static_cast<quint32>(LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER) << "clickMethodClickfinger";
     QTest::newRow("clickMethodClickfinger -> clickMethodAreas")
             << static_cast<quint32>(LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER) << "clickMethodClickfinger"
             << static_cast<quint32>(LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS) << "clickMethodAreas";
     QTest::newRow("clickMethodAreas -> clickMethodAreas")
             << static_cast<quint32>(LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS) << "clickMethodAreas"
             << static_cast<quint32>(LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS) << "clickMethodAreas";
     QTest::newRow("clickMethodClickfinger -> clickMethodClickfinger")
             << static_cast<quint32>(LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER) << "clickMethodClickfinger"
             << static_cast<quint32>(LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER) << "clickMethodClickfinger";
 }
 
 void TestLibinputDevice::testLoadClickMethod()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(quint32, initValue);
     QFETCH(quint32, configValue);
     QFETCH(QString, initValuePropNameString);
     QFETCH(QString, configValuePropNameString);
 
     QByteArray initValuePropName = initValuePropNameString.toLatin1();
     QByteArray configValuePropName = configValuePropNameString.toLatin1();
 
     inputConfig.writeEntry("ClickMethod", configValue);
 
     libinput_device device;
     device.supportedClickMethods = LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS | LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER;
     device.clickMethod = (libinput_config_click_method) initValue;
     device.setClickMethodReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.property(initValuePropName).toBool(), true);
     QCOMPARE(d.property(configValuePropName).toBool(), initValue == configValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.property(initValuePropName).toBool(), true);
     QCOMPARE(d.property(configValuePropName).toBool(), initValue == configValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.property(initValuePropName).toBool(), initValue == configValue);
     QCOMPARE(d.property(configValuePropName).toBool(), true);
     QCOMPARE(dbusProperty<bool>(d.sysName(), initValuePropName), initValue == configValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), configValuePropName), true);
 
     // and try to store
     if (configValue != initValue) {
         d.setProperty(initValuePropName, true);
         QCOMPARE(inputConfig.readEntry("ClickMethod", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadTapToClick_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("configValue");
 
     QTest::newRow("false -> true") << false << true;
     QTest::newRow("true -> false") << true << false;
     QTest::newRow("true -> true") << true << true;
     QTest::newRow("false -> false") << false << false;
 }
 
 void TestLibinputDevice::testLoadTapToClick()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(bool, configValue);
     QFETCH(bool, initValue);
     inputConfig.writeEntry("TapToClick", configValue);
 
     libinput_device device;
     device.tapFingerCount = 2;
     device.tapToClick = initValue;
     device.setTapToClickReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.isTapToClick(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.isTapToClick(), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.isTapToClick(), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setTapToClick(initValue);
         QCOMPARE(inputConfig.readEntry("TapToClick", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadTapAndDrag_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("configValue");
 
     QTest::newRow("false -> true") << false << true;
     QTest::newRow("true -> false") << true << false;
     QTest::newRow("true -> true") << true << true;
     QTest::newRow("false -> false") << false << false;
 }
 
 void TestLibinputDevice::testLoadTapAndDrag()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(bool, configValue);
     QFETCH(bool, initValue);
     inputConfig.writeEntry("TapAndDrag", configValue);
 
     libinput_device device;
     device.tapAndDrag = initValue;
     device.setTapAndDragReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.isTapAndDrag(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.isTapAndDrag(), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.isTapAndDrag(), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setTapAndDrag(initValue);
         QCOMPARE(inputConfig.readEntry("TapAndDrag", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadTapDragLock_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("configValue");
 
     QTest::newRow("false -> true") << false << true;
     QTest::newRow("true -> false") << true << false;
     QTest::newRow("true -> true") << true << true;
     QTest::newRow("false -> false") << false << false;
 }
 
 void TestLibinputDevice::testLoadTapDragLock()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(bool, configValue);
     QFETCH(bool, initValue);
     inputConfig.writeEntry("TapDragLock", configValue);
 
     libinput_device device;
     device.tapDragLock = initValue;
     device.setTapDragLockReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.isTapDragLock(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.isTapDragLock(), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.isTapDragLock(), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setTapDragLock(initValue);
         QCOMPARE(inputConfig.readEntry("TapDragLock", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadMiddleButtonEmulation_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("configValue");
 
     QTest::newRow("false -> true") << false << true;
     QTest::newRow("true -> false") << true << false;
     QTest::newRow("true -> true") << true << true;
     QTest::newRow("false -> false") << false << false;
 }
 
 void TestLibinputDevice::testLoadMiddleButtonEmulation()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(bool, configValue);
     QFETCH(bool, initValue);
     inputConfig.writeEntry("MiddleButtonEmulation", configValue);
 
     libinput_device device;
     device.supportsMiddleEmulation = true;
     device.middleEmulation = initValue;
     device.setMiddleEmulationReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.isMiddleEmulation(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.isMiddleEmulation(), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.isMiddleEmulation(), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setMiddleEmulation(initValue);
         QCOMPARE(inputConfig.readEntry("MiddleButtonEmulation", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadNaturalScroll_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("configValue");
 
     QTest::newRow("false -> true") << false << true;
     QTest::newRow("true -> false") << true << false;
     QTest::newRow("true -> true") << true << true;
     QTest::newRow("false -> false") << false << false;
 }
 
 void TestLibinputDevice::testLoadNaturalScroll()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(bool, configValue);
     QFETCH(bool, initValue);
     inputConfig.writeEntry("NaturalScroll", configValue);
 
     libinput_device device;
     device.supportsNaturalScroll = true;
     device.naturalScroll = initValue;
     device.setNaturalScrollReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.isNaturalScroll(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.isNaturalScroll(), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.isNaturalScroll(), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setNaturalScroll(initValue);
         QCOMPARE(inputConfig.readEntry("NaturalScroll", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadScrollMethod_data()
 {
     QTest::addColumn<quint32>("initValue");
     QTest::addColumn<QString>("initValuePropNameString");
     QTest::addColumn<quint32>("configValue");
     QTest::addColumn<QString>("configValuePropNameString");
 
     QTest::newRow("scrollTwoFinger -> scrollEdge") << (quint32) LIBINPUT_CONFIG_SCROLL_2FG << "scrollTwoFinger" << (quint32) LIBINPUT_CONFIG_SCROLL_EDGE << "scrollEdge";
     QTest::newRow("scrollOnButtonDown -> scrollTwoFinger") << (quint32) LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN << "scrollOnButtonDown" << (quint32) LIBINPUT_CONFIG_SCROLL_2FG << "scrollTwoFinger";
     QTest::newRow("scrollEdge -> scrollEdge") << (quint32) LIBINPUT_CONFIG_SCROLL_EDGE << "scrollEdge" << (quint32) LIBINPUT_CONFIG_SCROLL_EDGE << "scrollEdge";
 }
 
 void TestLibinputDevice::testLoadScrollMethod()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(quint32, initValue);
     QFETCH(quint32, configValue);
     QFETCH(QString, initValuePropNameString);
     QFETCH(QString, configValuePropNameString);
 
     QByteArray initValuePropName = initValuePropNameString.toLatin1();
     QByteArray configValuePropName = configValuePropNameString.toLatin1();
 
     inputConfig.writeEntry("ScrollMethod", configValue);
 
     libinput_device device;
     device.supportedScrollMethods = LIBINPUT_CONFIG_SCROLL_2FG | LIBINPUT_CONFIG_SCROLL_EDGE | LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
     device.scrollMethod = (libinput_config_scroll_method) initValue;
     device.setScrollMethodReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.property(initValuePropName).toBool(), true);
     QCOMPARE(d.property(configValuePropName).toBool(), initValue == configValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.property(initValuePropName).toBool(), true);
     QCOMPARE(d.property(configValuePropName).toBool(), initValue == configValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.property(initValuePropName).toBool(), initValue == configValue);
     QCOMPARE(d.property(configValuePropName).toBool(), true);
 
     // and try to store
     if (configValue != initValue) {
         d.setProperty(initValuePropName, true);
         QCOMPARE(inputConfig.readEntry("ScrollMethod", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadScrollButton_data()
 {
     QTest::addColumn<quint32>("initValue");
     QTest::addColumn<quint32>("configValue");
 
     QTest::newRow("BTN_LEFT -> BTN_RIGHT") << quint32(BTN_LEFT) << quint32(BTN_RIGHT);
     QTest::newRow("BTN_LEFT -> BTN_LEFT") << quint32(BTN_LEFT) << quint32(BTN_LEFT);
 }
 
 void TestLibinputDevice::testLoadScrollButton()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(quint32, configValue);
     QFETCH(quint32, initValue);
     inputConfig.writeEntry("ScrollButton", configValue);
 
     libinput_device device;
     device.supportedScrollMethods = LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
     device.scrollMethod = LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
     device.scrollButton = initValue;
     device.setScrollButtonReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.isScrollOnButtonDown(), true);
     QCOMPARE(d.scrollButton(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.isScrollOnButtonDown(), true);
     QCOMPARE(d.scrollButton(), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.isScrollOnButtonDown(), true);
     QCOMPARE(d.scrollButton(), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setScrollButton(initValue);
         QCOMPARE(inputConfig.readEntry("ScrollButton", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadLeftHanded_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("configValue");
 
     QTest::newRow("false -> true") << false << true;
     QTest::newRow("true -> false") << true << false;
     QTest::newRow("true -> true") << true << true;
     QTest::newRow("false -> false") << false << false;
 }
 
 void TestLibinputDevice::testLoadLeftHanded()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(bool, configValue);
     QFETCH(bool, initValue);
     inputConfig.writeEntry("LeftHanded", configValue);
 
     libinput_device device;
     device.supportsLeftHanded = true;
     device.leftHanded = initValue;
     device.setLeftHandedReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.isLeftHanded(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.isLeftHanded(), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.isLeftHanded(), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setLeftHanded(initValue);
         QCOMPARE(inputConfig.readEntry("LeftHanded", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadDisableWhileTyping_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("configValue");
 
     QTest::newRow("false -> true") << false << true;
     QTest::newRow("true -> false") << true << false;
     QTest::newRow("true -> true") << true << true;
     QTest::newRow("false -> false") << false << false;
 }
 
 void TestLibinputDevice::testLoadDisableWhileTyping()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(bool, configValue);
     QFETCH(bool, initValue);
     inputConfig.writeEntry("DisableWhileTyping", configValue);
 
     libinput_device device;
     device.supportsDisableWhileTyping = true;
     device.disableWhileTyping = initValue ? LIBINPUT_CONFIG_DWT_ENABLED : LIBINPUT_CONFIG_DWT_DISABLED;
     device.setDisableWhileTypingReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.isDisableWhileTyping(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.isDisableWhileTyping(), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.isDisableWhileTyping(), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setDisableWhileTyping(initValue);
         QCOMPARE(inputConfig.readEntry("DisableWhileTyping", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testLoadLmrTapButtonMap_data()
 {
     QTest::addColumn<bool>("initValue");
     QTest::addColumn<bool>("configValue");
 
     QTest::newRow("false -> true") << false << true;
     QTest::newRow("true -> false") << true << false;
     QTest::newRow("true -> true") << true << true;
     QTest::newRow("false -> false") << false << false;
 }
 
 void TestLibinputDevice::testLoadLmrTapButtonMap()
 {
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup inputConfig(config, QStringLiteral("Test"));
     QFETCH(bool, configValue);
     QFETCH(bool, initValue);
     inputConfig.writeEntry("LmrTapButtonMap", configValue);
 
     libinput_device device;
     device.tapFingerCount = 3;
     device.tapButtonMap = initValue ? LIBINPUT_CONFIG_TAP_MAP_LMR : LIBINPUT_CONFIG_TAP_MAP_LRM;
     device.setTapButtonMapReturnValue = false;
 
     Device d(&device);
     QCOMPARE(d.lmrTapButtonMap(), initValue);
     // no config group set, should not change
     d.loadConfiguration();
     QCOMPARE(d.lmrTapButtonMap(), initValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "lmrTapButtonMap"), initValue);
 
     // set the group
     d.setConfig(inputConfig);
     d.loadConfiguration();
     QCOMPARE(d.lmrTapButtonMap(), configValue);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "lmrTapButtonMap"), configValue);
 
     // and try to store
     if (configValue != initValue) {
         d.setLmrTapButtonMap(initValue);
         QCOMPARE(inputConfig.readEntry("LmrTapButtonMap", configValue), initValue);
     }
 }
 
 void TestLibinputDevice::testScreenId()
 {
     libinput_device device;
     Device d(&device);
     QCOMPARE(d.screenId(), 0);
     d.setScreenId(1);
     QCOMPARE(d.screenId(), 1);
 }
 
 void TestLibinputDevice::testOrientation_data()
 {
     QTest::addColumn<Qt::ScreenOrientation>("orientation");
     QTest::addColumn<float>("m11");
     QTest::addColumn<float>("m12");
     QTest::addColumn<float>("m13");
     QTest::addColumn<float>("m21");
     QTest::addColumn<float>("m22");
     QTest::addColumn<float>("m23");
     QTest::addColumn<bool>("defaultIsIdentity");
 
     QTest::newRow("Primary") << Qt::PrimaryOrientation << 1.0f << 2.0f << 3.0f << 4.0f << 5.0f << 6.0f << false;
     QTest::newRow("Landscape") << Qt::LandscapeOrientation << 1.0f << 2.0f << 3.0f << 4.0f << 5.0f << 6.0f << false;
     QTest::newRow("Portrait") << Qt::PortraitOrientation << 0.0f << -1.0f << 1.0f << 1.0f << 0.0f << 0.0f << true;
     QTest::newRow("InvertedLandscape") << Qt::InvertedLandscapeOrientation << -1.0f << 0.0f << 1.0f << 0.0f << -1.0f << 1.0f << true;
     QTest::newRow("InvertedPortrait") << Qt::InvertedPortraitOrientation << 0.0f << 1.0f << 0.0f << -1.0f << 0.0f << 1.0f << true;
 }
 
 void TestLibinputDevice::testOrientation()
 {
     libinput_device device;
     device.supportsCalibrationMatrix = true;
     device.defaultCalibrationMatrix = std::array<float, 6>{{1.0, 2.0, 3.0, 4.0, 5.0, 6.0}};
     QFETCH(bool, defaultIsIdentity);
     device.defaultCalibrationMatrixIsIdentity = defaultIsIdentity;
     Device d(&device);
     QFETCH(Qt::ScreenOrientation, orientation);
     d.setOrientation(orientation);
     QTEST(device.calibrationMatrix[0], "m11");
     QTEST(device.calibrationMatrix[1], "m12");
     QTEST(device.calibrationMatrix[2], "m13");
     QTEST(device.calibrationMatrix[3], "m21");
     QTEST(device.calibrationMatrix[4], "m22");
     QTEST(device.calibrationMatrix[5], "m23");
 }
 
 void TestLibinputDevice::testCalibrationWithDefault()
 {
     libinput_device device;
     device.supportsCalibrationMatrix = true;
     device.defaultCalibrationMatrix = std::array<float, 6>{{2.0, 3.0, 0.0, 4.0, 5.0, 0.0}};
     device.defaultCalibrationMatrixIsIdentity = false;
     Device d(&device);
     d.setOrientation(Qt::PortraitOrientation);
     QCOMPARE(device.calibrationMatrix[0], 3.0f);
     QCOMPARE(device.calibrationMatrix[1], -2.0f);
     QCOMPARE(device.calibrationMatrix[2], 2.0f);
     QCOMPARE(device.calibrationMatrix[3], 5.0f);
     QCOMPARE(device.calibrationMatrix[4], -4.0f);
     QCOMPARE(device.calibrationMatrix[5], 4.0f);
 }
 
 void TestLibinputDevice::testSwitch_data()
 {
     QTest::addColumn<bool>("lid");
     QTest::addColumn<bool>("tablet");
 
     QTest::newRow("lid") << true << false;
     QTest::newRow("tablet") << false << true;
 }
 
 void TestLibinputDevice::testSwitch()
 {
     libinput_device device;
     device.switchDevice = true;
     QFETCH(bool, lid);
     QFETCH(bool, tablet);
     device.lidSwitch = lid;
     device.tabletModeSwitch = tablet;
 
     Device d(&device);
     QCOMPARE(d.isSwitch(), true);
     QCOMPARE(d.isLidSwitch(), lid);
     QCOMPARE(d.property("lidSwitch").toBool(), lid);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "lidSwitch"), lid);
     QCOMPARE(d.isTabletModeSwitch(), tablet);
     QCOMPARE(d.property("tabletModeSwitch").toBool(), tablet);
     QCOMPARE(dbusProperty<bool>(d.sysName(), "tabletModeSwitch"), tablet);
 }
 
 QTEST_GUILESS_MAIN(TestLibinputDevice)
 #include "device_test.moc"
diff --git a/libinput/device.cpp b/libinput/device.cpp
index a5f970ace..1e1dfd22e 100644
--- a/libinput/device.cpp
+++ b/libinput/device.cpp
@@ -1,531 +1,552 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 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 2 of the License, or
 (at your option) 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 "device.h"
 
 #include <QDBusConnection>
 
 #include <linux/input.h>
 
 #include <config-kwin.h>
 
 namespace KWin
 {
 namespace LibInput
 {
 
 static bool checkAlphaNumericKeyboard(libinput_device *device)
 {
     for (uint i = KEY_1; i <= KEY_0; i++) {
         if (libinput_device_keyboard_has_key(device, i) == 0) {
             return false;
         }
     }
     for (uint i = KEY_Q; i <= KEY_P; i++) {
         if (libinput_device_keyboard_has_key(device, i) == 0) {
             return false;
         }
     }
     for (uint i = KEY_A; i <= KEY_L; i++) {
         if (libinput_device_keyboard_has_key(device, i) == 0) {
             return false;
         }
     }
     for (uint i = KEY_Z; i <= KEY_M; i++) {
         if (libinput_device_keyboard_has_key(device, i) == 0) {
             return false;
         }
     }
     return true;
 }
 
 QVector<Device*> Device::s_devices;
 
 Device *Device::getDevice(libinput_device *native)
 {
     auto it = std::find_if(s_devices.constBegin(), s_devices.constEnd(),
         [native] (const Device *d) {
             return d->device() == native;
         }
     );
     if (it != s_devices.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 enum class ConfigKey {
     Enabled,
     LeftHanded,
     DisableWhileTyping,
     PointerAcceleration,
     PointerAccelerationProfile,
     TapToClick,
     LmrTapButtonMap,
     TapAndDrag,
     TapDragLock,
     MiddleButtonEmulation,
     NaturalScroll,
     ScrollMethod,
     ScrollButton,
-    ClickMethod
+    ClickMethod,
+    ScrollFactor
 };
 
 struct ConfigData {
     explicit ConfigData(QByteArray _key, void (Device::*_setter)(bool), bool (Device::*_defaultValue)() const = nullptr)
         : key(_key)
     { booleanSetter.setter = _setter; booleanSetter.defaultValue = _defaultValue; }
 
     explicit ConfigData(QByteArray _key, void (Device::*_setter)(quint32), quint32 (Device::*_defaultValue)() const = nullptr)
         : key(_key)
     { quint32Setter.setter = _setter; quint32Setter.defaultValue = _defaultValue; }
 
     explicit ConfigData(QByteArray _key, void (Device::*_setter)(QString), QString (Device::*_defaultValue)() const = nullptr)
         : key(_key)
     { stringSetter.setter = _setter; stringSetter.defaultValue = _defaultValue; }
 
+    explicit ConfigData(QByteArray _key, void (Device::*_setter)(qreal), qreal (Device::*_defaultValue)() const = nullptr)
+        : key(_key)
+    { qrealSetter.setter = _setter; qrealSetter.defaultValue = _defaultValue; }
+
     QByteArray key;
 
     struct {
         void (Device::*setter)(bool) = nullptr;
         bool (Device::*defaultValue)() const;
     } booleanSetter;
 
     struct {
         void (Device::*setter)(quint32) = nullptr;
         quint32 (Device::*defaultValue)() const;
     } quint32Setter;
     struct {
         void (Device::*setter)(QString) = nullptr;
         QString (Device::*defaultValue)() const;
     } stringSetter;
+    struct {
+        void (Device::*setter)(qreal) = nullptr;
+        qreal (Device::*defaultValue)() const;
+    } qrealSetter;
 };
 
 static const QMap<ConfigKey, ConfigData> s_configData {
     {ConfigKey::Enabled, ConfigData(QByteArrayLiteral("Enabled"), &Device::setEnabled)},
     {ConfigKey::LeftHanded, ConfigData(QByteArrayLiteral("LeftHanded"), &Device::setLeftHanded, &Device::leftHandedEnabledByDefault)},
     {ConfigKey::DisableWhileTyping, ConfigData(QByteArrayLiteral("DisableWhileTyping"), &Device::setDisableWhileTyping, &Device::disableWhileTypingEnabledByDefault)},
     {ConfigKey::PointerAcceleration, ConfigData(QByteArrayLiteral("PointerAcceleration"), &Device::setPointerAccelerationFromString, &Device::defaultPointerAccelerationToString)},
     {ConfigKey::PointerAccelerationProfile, ConfigData(QByteArrayLiteral("PointerAccelerationProfile"), &Device::setPointerAccelerationProfileFromInt, &Device::defaultPointerAccelerationProfileToInt)},
     {ConfigKey::TapToClick, ConfigData(QByteArrayLiteral("TapToClick"), &Device::setTapToClick, &Device::tapToClickEnabledByDefault)},
     {ConfigKey::TapAndDrag, ConfigData(QByteArrayLiteral("TapAndDrag"), &Device::setTapAndDrag, &Device::tapAndDragEnabledByDefault)},
     {ConfigKey::TapDragLock, ConfigData(QByteArrayLiteral("TapDragLock"), &Device::setTapDragLock, &Device::tapDragLockEnabledByDefault)},
     {ConfigKey::MiddleButtonEmulation, ConfigData(QByteArrayLiteral("MiddleButtonEmulation"), &Device::setMiddleEmulation, &Device::middleEmulationEnabledByDefault)},
     {ConfigKey::LmrTapButtonMap, ConfigData(QByteArrayLiteral("LmrTapButtonMap"), &Device::setLmrTapButtonMap, &Device::lmrTapButtonMapEnabledByDefault)},
     {ConfigKey::NaturalScroll, ConfigData(QByteArrayLiteral("NaturalScroll"), &Device::setNaturalScroll, &Device::naturalScrollEnabledByDefault)},
     {ConfigKey::ScrollMethod, ConfigData(QByteArrayLiteral("ScrollMethod"), &Device::activateScrollMethodFromInt, &Device::defaultScrollMethodToInt)},
     {ConfigKey::ScrollButton, ConfigData(QByteArrayLiteral("ScrollButton"), &Device::setScrollButton, &Device::defaultScrollButton)},
-    {ConfigKey::ClickMethod, ConfigData(QByteArrayLiteral("ClickMethod"), &Device::setClickMethodFromInt, &Device::defaultClickMethodToInt)}
+    {ConfigKey::ClickMethod, ConfigData(QByteArrayLiteral("ClickMethod"), &Device::setClickMethodFromInt, &Device::defaultClickMethodToInt)},
+    {ConfigKey::ScrollFactor, ConfigData(QByteArrayLiteral("ScrollFactor"), &Device::setScrollFactor, &Device::scrollFactorDefault)}
 };
 
 namespace {
 QMatrix4x4 defaultCalibrationMatrix(libinput_device *device)
 {
     float matrix[6];
     const int ret = libinput_device_config_calibration_get_default_matrix(device, matrix);
     if (ret == 0) {
         return QMatrix4x4();
     }
     return QMatrix4x4{
         matrix[0], matrix[1], matrix[2], 0.0f,
         matrix[3], matrix[4], matrix[5], 0.0f,
         0.0f,  0.0f, 1.0f, 0.0f,
         0.0f,  0.0f, 0.0f, 1.0f
     };
 }
 }
 
 Device::Device(libinput_device *device, QObject *parent)
     : QObject(parent)
     , m_device(device)
     , m_keyboard(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_KEYBOARD))
     , m_pointer(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_POINTER))
     , m_touch(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_TOUCH))
     , m_tabletTool(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_TABLET_TOOL))
     , m_tabletPad(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_TABLET_PAD))
     , m_supportsGesture(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_GESTURE))
     , m_switch(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_SWITCH))
     , m_lidSwitch(m_switch ? libinput_device_switch_has_switch(m_device, LIBINPUT_SWITCH_LID) : false)
     , m_tabletSwitch(m_switch ? libinput_device_switch_has_switch(m_device, LIBINPUT_SWITCH_TABLET_MODE) : false)
     , m_name(QString::fromLocal8Bit(libinput_device_get_name(m_device)))
     , m_sysName(QString::fromLocal8Bit(libinput_device_get_sysname(m_device)))
     , m_outputName(QString::fromLocal8Bit(libinput_device_get_output_name(m_device)))
     , m_product(libinput_device_get_id_product(m_device))
     , m_vendor(libinput_device_get_id_vendor(m_device))
     , m_tapFingerCount(libinput_device_config_tap_get_finger_count(m_device))
     , m_defaultTapButtonMap(libinput_device_config_tap_get_default_button_map(m_device))
     , m_tapButtonMap(libinput_device_config_tap_get_button_map(m_device))
     , m_tapToClickEnabledByDefault(libinput_device_config_tap_get_default_enabled(m_device) == LIBINPUT_CONFIG_TAP_ENABLED)
     , m_tapToClick(libinput_device_config_tap_get_enabled(m_device))
     , m_tapAndDragEnabledByDefault(libinput_device_config_tap_get_default_drag_enabled(m_device))
     , m_tapAndDrag(libinput_device_config_tap_get_drag_enabled(m_device))
     , m_tapDragLockEnabledByDefault(libinput_device_config_tap_get_default_drag_lock_enabled(m_device))
     , m_tapDragLock(libinput_device_config_tap_get_drag_lock_enabled(m_device))
     , m_supportsDisableWhileTyping(libinput_device_config_dwt_is_available(m_device))
     , m_supportsPointerAcceleration(libinput_device_config_accel_is_available(m_device))
     , m_supportsLeftHanded(libinput_device_config_left_handed_is_available(m_device))
     , m_supportsCalibrationMatrix(libinput_device_config_calibration_has_matrix(m_device))
     , m_supportsDisableEvents(libinput_device_config_send_events_get_modes(m_device) & LIBINPUT_CONFIG_SEND_EVENTS_DISABLED)
     , m_supportsDisableEventsOnExternalMouse(libinput_device_config_send_events_get_modes(m_device) & LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE)
     , m_supportsMiddleEmulation(libinput_device_config_middle_emulation_is_available(m_device))
     , m_supportsNaturalScroll(libinput_device_config_scroll_has_natural_scroll(m_device))
     , m_supportedScrollMethods(libinput_device_config_scroll_get_methods(m_device))
     , m_leftHandedEnabledByDefault(libinput_device_config_left_handed_get_default(m_device))
     , m_middleEmulationEnabledByDefault(libinput_device_config_middle_emulation_get_default_enabled(m_device) == LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED)
     , m_naturalScrollEnabledByDefault(libinput_device_config_scroll_get_default_natural_scroll_enabled(m_device))
     , m_defaultScrollMethod(libinput_device_config_scroll_get_default_method(m_device))
     , m_defaultScrollButton(libinput_device_config_scroll_get_default_button(m_device))
     , m_disableWhileTypingEnabledByDefault(libinput_device_config_dwt_get_default_enabled(m_device))
     , m_disableWhileTyping(m_supportsDisableWhileTyping ? libinput_device_config_dwt_get_enabled(m_device) == LIBINPUT_CONFIG_DWT_ENABLED : false)
     , m_middleEmulation(libinput_device_config_middle_emulation_get_enabled(m_device) == LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED)
     , m_leftHanded(m_supportsLeftHanded ? libinput_device_config_left_handed_get(m_device) : false)
     , m_naturalScroll(m_supportsNaturalScroll ? libinput_device_config_scroll_get_natural_scroll_enabled(m_device) : false)
     , m_scrollMethod(libinput_device_config_scroll_get_method(m_device))
     , m_scrollButton(libinput_device_config_scroll_get_button(m_device))
     , m_defaultPointerAcceleration(libinput_device_config_accel_get_default_speed(m_device))
     , m_pointerAcceleration(libinput_device_config_accel_get_speed(m_device))
     , m_supportedPointerAccelerationProfiles(libinput_device_config_accel_get_profiles(m_device))
     , m_defaultPointerAccelerationProfile(libinput_device_config_accel_get_default_profile(m_device))
     , m_pointerAccelerationProfile(libinput_device_config_accel_get_profile(m_device))
     , m_enabled(m_supportsDisableEvents ? libinput_device_config_send_events_get_mode(m_device) == LIBINPUT_CONFIG_SEND_EVENTS_ENABLED : true)
     , m_config()
     , m_defaultCalibrationMatrix(m_supportsCalibrationMatrix ? defaultCalibrationMatrix(m_device) : QMatrix4x4{})
     , m_supportedClickMethods(libinput_device_config_click_get_methods(m_device))
     , m_defaultClickMethod(libinput_device_config_click_get_default_method(m_device))
     , m_clickMethod(libinput_device_config_click_get_method(m_device))
+    , m_scrollFactor(scrollFactorDefault())
 {
     libinput_device_ref(m_device);
 
     qreal width = 0;
     qreal height = 0;
     if (libinput_device_get_size(m_device, &width, &height) == 0) {
         m_size = QSizeF(width, height);
     }
     if (m_pointer) {
         if (libinput_device_pointer_has_button(m_device, BTN_LEFT) == 1) {
             m_supportedButtons |= Qt::LeftButton;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_MIDDLE) == 1) {
             m_supportedButtons |= Qt::MiddleButton;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_RIGHT) == 1) {
             m_supportedButtons |= Qt::RightButton;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_SIDE) == 1) {
             m_supportedButtons |= Qt::ExtraButton1;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_EXTRA) == 1) {
             m_supportedButtons |= Qt::ExtraButton2;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_BACK) == 1) {
             m_supportedButtons |= Qt::BackButton;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_FORWARD) == 1) {
             m_supportedButtons |= Qt::ForwardButton;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_TASK) == 1) {
             m_supportedButtons |= Qt::TaskButton;
         }
     }
     if (m_keyboard) {
         m_alphaNumericKeyboard = checkAlphaNumericKeyboard(m_device);
     }
 
     s_devices << this;
     QDBusConnection::sessionBus().registerObject(QStringLiteral("/org/kde/KWin/InputDevice/") + m_sysName,
                                                  QStringLiteral("org.kde.KWin.InputDevice"),
                                                  this,
                                                  QDBusConnection::ExportAllProperties
     );
 }
 
 Device::~Device()
 {
     s_devices.removeOne(this);
     QDBusConnection::sessionBus().unregisterObject(QStringLiteral("/org/kde/KWin/InputDevice/") + m_sysName);
     libinput_device_unref(m_device);
 }
 
 template <typename T>
 void Device::writeEntry(const ConfigKey &key, const T &value)
 {
     if (!m_config.isValid()) {
         return;
     }
     if (m_loading) {
         return;
     }
     auto it = s_configData.find(key);
     Q_ASSERT(it != s_configData.end());
     m_config.writeEntry(it.value().key.constData(), value);
     m_config.sync();
 }
 
 template <typename T, typename Setter>
 void Device::readEntry(const QByteArray &key, const Setter &s, const T &defaultValue)
 {
     if (!s.setter) {
         return;
     }
 
     (this->*(s.setter))(m_config.readEntry(key.constData(), s.defaultValue ? (this->*(s.defaultValue))() : defaultValue));
 }
 
 void Device::loadConfiguration()
 {
     if (!m_config.isValid()) {
         return;
     }
     m_loading = true;
     for (auto it = s_configData.begin(), end = s_configData.end(); it != end; ++it) {
         const auto key = it.value().key;
         if (!m_config.hasKey(key.constData())) {
             continue;
         }
         readEntry(key, it.value().booleanSetter, true);
         readEntry(key, it.value().quint32Setter, 0);
         readEntry(key, it.value().stringSetter, "");
+        readEntry(key, it.value().qrealSetter, 1.0);
     };
 
     m_loading = false;
 }
 
 void Device::setPointerAcceleration(qreal acceleration)
 {
     if (!m_supportsPointerAcceleration) {
         return;
     }
     acceleration = qBound(-1.0, acceleration, 1.0);
     if (libinput_device_config_accel_set_speed(m_device, acceleration) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (m_pointerAcceleration != acceleration) {
             m_pointerAcceleration = acceleration;
             emit pointerAccelerationChanged();
             writeEntry(ConfigKey::PointerAcceleration, QString::number(acceleration, 'f', 3));
         }
     }
 }
 
 void Device::setScrollButton(quint32 button)
 {
     if (!(m_supportedScrollMethods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN)) {
         return;
     }
     if (libinput_device_config_scroll_set_button(m_device, button) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (m_scrollButton != button) {
             m_scrollButton = button;
             writeEntry(ConfigKey::ScrollButton, m_scrollButton);
             emit scrollButtonChanged();
         }
     }
 }
 
 void Device::setPointerAccelerationProfile(bool set, enum  libinput_config_accel_profile profile)
 {
     if (!(m_supportedPointerAccelerationProfiles & profile)) {
         return;
     }
     if (!set) {
         profile = (profile == LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT) ? LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE : LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT;
         if (!(m_supportedPointerAccelerationProfiles & profile)) {
             return;
         }
     }
 
     if (libinput_device_config_accel_set_profile(m_device, profile) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (m_pointerAccelerationProfile != profile) {
             m_pointerAccelerationProfile = profile;
             emit pointerAccelerationProfileChanged();
             writeEntry(ConfigKey::PointerAccelerationProfile, (quint32) profile);
         }
     }
 }
 
 void Device::setClickMethod(bool set, enum libinput_config_click_method method)
 {
     if (!(m_supportedClickMethods & method)) {
         return;
     }
     if (!set) {
         method = (method == LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS) ? LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER : LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS;
         if (!(m_supportedClickMethods & method)) {
             return;
         }
     }
 
     if (libinput_device_config_click_set_method(m_device, method) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (m_clickMethod != method) {
             m_clickMethod = method;
             emit clickMethodChanged();
             writeEntry(ConfigKey::ClickMethod, (quint32) method);
         }
     }
 }
 
 void Device::setScrollMethod(bool set, enum libinput_config_scroll_method method)
 {
     if (!(m_supportedScrollMethods & method)) {
         return;
     }
 
     bool isCurrent = m_scrollMethod == method;
     if (!set) {
         if (isCurrent) {
             method = LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
             isCurrent = false;
         } else {
             return;
         }
     }
 
     if (libinput_device_config_scroll_set_method(m_device, method) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (!isCurrent) {
             m_scrollMethod = method;
             emit scrollMethodChanged();
             writeEntry(ConfigKey::ScrollMethod, (quint32) method);
         }
     }
 }
 
 void Device::setLmrTapButtonMap(bool set)
 {
     enum libinput_config_tap_button_map map = set ? LIBINPUT_CONFIG_TAP_MAP_LMR : LIBINPUT_CONFIG_TAP_MAP_LRM;
 
     if (m_tapFingerCount < 2) {
         return;
     }
     if (!set) {
         map = LIBINPUT_CONFIG_TAP_MAP_LRM;
     }
 
     if (libinput_device_config_tap_set_button_map(m_device, map) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (m_tapButtonMap != map) {
             m_tapButtonMap = map;
             writeEntry(ConfigKey::LmrTapButtonMap, set);
             emit tapButtonMapChanged();
         }
     }
 }
 
 int Device::stripsCount() const
 {
     return libinput_device_tablet_pad_get_num_strips(m_device);
 }
 
 int Device::ringsCount() const
 {
     return libinput_device_tablet_pad_get_num_rings(m_device);
 }
 
 #define CONFIG(method, condition, function, variable, key) \
 void Device::method(bool set) \
 { \
     if (condition) { \
         return; \
     } \
     if (libinput_device_config_##function(m_device, set) == LIBINPUT_CONFIG_STATUS_SUCCESS) { \
         if (m_##variable != set) { \
             m_##variable = set; \
             writeEntry(ConfigKey::key, m_##variable); \
             emit variable##Changed(); \
         }\
     } \
 }
 
 CONFIG(setLeftHanded, !m_supportsLeftHanded, left_handed_set, leftHanded, LeftHanded)
 CONFIG(setNaturalScroll, !m_supportsNaturalScroll, scroll_set_natural_scroll_enabled, naturalScroll, NaturalScroll)
 
 #undef CONFIG
 
 #define CONFIG(method, condition, function, enum, variable, key) \
 void Device::method(bool set) \
 { \
     if (condition) { \
         return; \
     } \
     if (libinput_device_config_##function(m_device, set ? LIBINPUT_CONFIG_##enum##_ENABLED : LIBINPUT_CONFIG_##enum##_DISABLED) == LIBINPUT_CONFIG_STATUS_SUCCESS) { \
         if (m_##variable != set) { \
             m_##variable = set; \
             writeEntry(ConfigKey::key, m_##variable); \
             emit variable##Changed(); \
         }\
     } \
 }
 
 CONFIG(setEnabled, !m_supportsDisableEvents, send_events_set_mode, SEND_EVENTS, enabled, Enabled)
 CONFIG(setDisableWhileTyping, !m_supportsDisableWhileTyping, dwt_set_enabled, DWT, disableWhileTyping, DisableWhileTyping)
 CONFIG(setTapToClick, m_tapFingerCount == 0, tap_set_enabled, TAP, tapToClick, TapToClick)
 CONFIG(setTapAndDrag, false, tap_set_drag_enabled, DRAG, tapAndDrag, TapAndDrag)
 CONFIG(setTapDragLock, false, tap_set_drag_lock_enabled, DRAG_LOCK, tapDragLock, TapDragLock)
 CONFIG(setMiddleEmulation, m_supportsMiddleEmulation == false, middle_emulation_set_enabled, MIDDLE_EMULATION, middleEmulation, MiddleButtonEmulation)
 
 #undef CONFIG
 
+void Device::setScrollFactor(qreal factor)
+{
+    if (m_scrollFactor != factor) {
+        m_scrollFactor = factor;
+        writeEntry(ConfigKey::ScrollFactor, m_scrollFactor);
+        emit scrollFactorChanged();
+    }
+}
+
 void Device::setOrientation(Qt::ScreenOrientation orientation)
 {
     if (!m_supportsCalibrationMatrix) {
         return;
     }
     // 90 deg cw:
     static const QMatrix4x4 portraitMatrix{
         0.0f, -1.0f, 1.0f, 0.0f,
         1.0f,  0.0f, 0.0f, 0.0f,
         0.0f,  0.0f, 1.0f, 0.0f,
         0.0f,  0.0f, 0.0f, 1.0f
     };
     // 180 deg cw:
     static const QMatrix4x4 invertedLandscapeMatrix{
         -1.0f,  0.0f, 1.0f, 0.0f,
          0.0f, -1.0f, 1.0f, 0.0f,
          0.0f,  0.0f, 1.0f, 0.0f,
          0.0f,  0.0f, 0.0f, 1.0f
     };
     // 270 deg cw
     static const QMatrix4x4 invertedPortraitMatrix{
          0.0f, 1.0f, 0.0f, 0.0f,
         -1.0f, 0.0f, 1.0f, 0.0f,
          0.0f,  0.0f, 1.0f, 0.0f,
          0.0f,  0.0f, 0.0f, 1.0f
     };
     QMatrix4x4 matrix;
     switch (orientation) {
     case Qt::PortraitOrientation:
         matrix = portraitMatrix;
         break;
     case Qt::InvertedLandscapeOrientation:
         matrix = invertedLandscapeMatrix;
         break;
     case Qt::InvertedPortraitOrientation:
         matrix = invertedPortraitMatrix;
         break;
     case Qt::PrimaryOrientation:
     case Qt::LandscapeOrientation:
     default:
         break;
     }
     const auto combined = m_defaultCalibrationMatrix * matrix;
     const auto columnOrder = combined.constData();
     float m[6] = {
         columnOrder[0], columnOrder[4], columnOrder[8],
         columnOrder[1], columnOrder[5], columnOrder[9]
     };
     libinput_device_config_calibration_set_matrix(m_device, m);
 }
 
 }
 }
diff --git a/libinput/device.h b/libinput/device.h
index c72f8c121..e34c5d4b5 100644
--- a/libinput/device.h
+++ b/libinput/device.h
@@ -1,585 +1,597 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 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 2 of the License, or
 (at your option) 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 KWIN_LIBINPUT_DEVICE_H
 #define KWIN_LIBINPUT_DEVICE_H
 
 #include <libinput.h>
 
 #include <KConfigGroup>
 
 #include <QObject>
 #include <QMatrix4x4>
 #include <QSizeF>
 #include <QVector>
 #include "kwin_export.h"
 
 struct libinput_device;
 
 namespace KWin
 {
 namespace LibInput
 {
 enum class ConfigKey;
 
 class KWIN_EXPORT Device : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.KWin.InputDevice")
     //
     // general
     Q_PROPERTY(bool keyboard READ isKeyboard CONSTANT)
     Q_PROPERTY(bool alphaNumericKeyboard READ isAlphaNumericKeyboard CONSTANT)
     Q_PROPERTY(bool pointer READ isPointer CONSTANT)
     Q_PROPERTY(bool touchpad READ isTouchpad CONSTANT)
     Q_PROPERTY(bool touch READ isTouch CONSTANT)
     Q_PROPERTY(bool tabletTool READ isTabletTool CONSTANT)
     Q_PROPERTY(bool tabletPad READ isTabletPad CONSTANT)
     Q_PROPERTY(bool gestureSupport READ supportsGesture CONSTANT)
     Q_PROPERTY(QString name READ name CONSTANT)
     Q_PROPERTY(QString sysName READ sysName CONSTANT)
     Q_PROPERTY(QString outputName READ outputName CONSTANT)
     Q_PROPERTY(QSizeF size READ size CONSTANT)
     Q_PROPERTY(quint32 product READ product CONSTANT)
     Q_PROPERTY(quint32 vendor READ vendor CONSTANT)
     Q_PROPERTY(bool supportsDisableEvents READ supportsDisableEvents CONSTANT)
     Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
     //
     // advanced
     Q_PROPERTY(int supportedButtons READ supportedButtons CONSTANT)
     Q_PROPERTY(bool supportsCalibrationMatrix READ supportsCalibrationMatrix 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 supportsDisableEventsOnExternalMouse READ supportsDisableEventsOnExternalMouse CONSTANT)
 
     Q_PROPERTY(bool supportsDisableWhileTyping READ supportsDisableWhileTyping CONSTANT)
     Q_PROPERTY(bool disableWhileTypingEnabledByDefault READ disableWhileTypingEnabledByDefault CONSTANT)
     Q_PROPERTY(bool disableWhileTyping READ isDisableWhileTyping WRITE setDisableWhileTyping NOTIFY disableWhileTypingChanged)
     //
     // acceleration speed and profile
     Q_PROPERTY(bool supportsPointerAcceleration READ supportsPointerAcceleration CONSTANT)
     Q_PROPERTY(qreal defaultPointerAcceleration READ defaultPointerAcceleration 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)
     //
     // tapping
     Q_PROPERTY(int tapFingerCount READ tapFingerCount CONSTANT)
     Q_PROPERTY(bool tapToClickEnabledByDefault READ tapToClickEnabledByDefault CONSTANT)
     Q_PROPERTY(bool tapToClick READ isTapToClick WRITE setTapToClick NOTIFY tapToClickChanged)
 
     Q_PROPERTY(bool supportsLmrTapButtonMap READ supportsLmrTapButtonMap CONSTANT)
     Q_PROPERTY(bool lmrTapButtonMapEnabledByDefault READ lmrTapButtonMapEnabledByDefault CONSTANT)
     Q_PROPERTY(bool lmrTapButtonMap READ lmrTapButtonMap WRITE setLmrTapButtonMap NOTIFY tapButtonMapChanged)
 
     Q_PROPERTY(bool tapAndDragEnabledByDefault READ tapAndDragEnabledByDefault CONSTANT)
     Q_PROPERTY(bool tapAndDrag READ isTapAndDrag WRITE setTapAndDrag NOTIFY tapAndDragChanged)
     Q_PROPERTY(bool tapDragLockEnabledByDefault READ tapDragLockEnabledByDefault CONSTANT)
     Q_PROPERTY(bool tapDragLock READ isTapDragLock WRITE setTapDragLock NOTIFY tapDragLockChanged)
 
     Q_PROPERTY(bool supportsMiddleEmulation READ supportsMiddleEmulation CONSTANT)
     Q_PROPERTY(bool middleEmulationEnabledByDefault READ middleEmulationEnabledByDefault CONSTANT)
     Q_PROPERTY(bool middleEmulation READ isMiddleEmulation WRITE setMiddleEmulation NOTIFY middleEmulationChanged)
     //
     // 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)
 
     Q_PROPERTY(bool supportsScrollTwoFinger READ supportsScrollTwoFinger CONSTANT)
     Q_PROPERTY(bool scrollTwoFingerEnabledByDefault READ scrollTwoFingerEnabledByDefault CONSTANT)
     Q_PROPERTY(bool scrollTwoFinger READ isScrollTwoFinger WRITE setScrollTwoFinger NOTIFY scrollMethodChanged)
 
     Q_PROPERTY(bool supportsScrollEdge READ supportsScrollEdge CONSTANT)
     Q_PROPERTY(bool scrollEdgeEnabledByDefault READ scrollEdgeEnabledByDefault CONSTANT)
     Q_PROPERTY(bool scrollEdge READ isScrollEdge WRITE setScrollEdge NOTIFY scrollMethodChanged)
 
     Q_PROPERTY(bool supportsScrollOnButtonDown READ supportsScrollOnButtonDown CONSTANT)
     Q_PROPERTY(bool scrollOnButtonDownEnabledByDefault READ scrollOnButtonDownEnabledByDefault CONSTANT)
     Q_PROPERTY(quint32 defaultScrollButton READ defaultScrollButton CONSTANT)
     Q_PROPERTY(bool scrollOnButtonDown READ isScrollOnButtonDown WRITE setScrollOnButtonDown NOTIFY scrollMethodChanged)
     Q_PROPERTY(quint32 scrollButton READ scrollButton WRITE setScrollButton NOTIFY scrollButtonChanged)
 
+    Q_PROPERTY(qreal scrollFactor READ scrollFactor WRITE setScrollFactor NOTIFY scrollFactorChanged)
+
     // switches
     Q_PROPERTY(bool switchDevice READ isSwitch CONSTANT)
     Q_PROPERTY(bool lidSwitch READ isLidSwitch CONSTANT)
     Q_PROPERTY(bool tabletModeSwitch READ isTabletModeSwitch CONSTANT)
 
     // Click Methods 
     Q_PROPERTY(bool supportsClickMethodAreas READ supportsClickMethodAreas CONSTANT)
     Q_PROPERTY(bool defaultClickMethodAreas READ defaultClickMethodAreas CONSTANT)
     Q_PROPERTY(bool clickMethodAreas READ isClickMethodAreas WRITE setClickMethodAreas NOTIFY clickMethodChanged)
 
     Q_PROPERTY(bool supportsClickMethodClickfinger READ supportsClickMethodClickfinger CONSTANT)
     Q_PROPERTY(bool defaultClickMethodClickfinger READ defaultClickMethodClickfinger CONSTANT)
     Q_PROPERTY(bool clickMethodClickfinger READ isClickMethodClickfinger WRITE setClickMethodClickfinger NOTIFY clickMethodChanged)
 
 public:
     explicit Device(libinput_device *device, QObject *parent = nullptr);
     ~Device() override;
 
     bool isKeyboard() const {
         return m_keyboard;
     }
     bool isAlphaNumericKeyboard() const {
         return m_alphaNumericKeyboard;
     }
     bool isPointer() const {
         return m_pointer;
     }
     bool isTouchpad() const{
         return m_pointer &&
                 // ignore all combined devices. E.g. a touchpad on a keyboard we don't want to toggle
                 // as that would result in the keyboard going off as well
                 !(m_keyboard || m_touch || m_tabletPad || m_tabletTool) &&
                 // is this a touch pad? We don't really know, let's do some assumptions
                 (m_tapFingerCount > 0  || m_supportsDisableWhileTyping || m_supportsDisableEventsOnExternalMouse);
     }
     bool isTouch() const {
         return m_touch;
     }
     bool isTabletTool() const {
         return m_tabletTool;
     }
     bool isTabletPad() const {
         return m_tabletPad;
     }
     bool supportsGesture() const {
         return m_supportsGesture;
     }
     QString name() const {
         return m_name;
     }
     QString sysName() const {
         return m_sysName;
     }
     QString outputName() const {
         return m_outputName;
     }
     QSizeF size() const {
         return m_size;
     }
     quint32 product() const {
         return m_product;
     }
     quint32 vendor() const {
         return m_vendor;
     }
     Qt::MouseButtons supportedButtons() const {
         return m_supportedButtons;
     }
     int tapFingerCount() const {
         return m_tapFingerCount;
     }
     bool tapToClickEnabledByDefault() const {
         return m_tapToClickEnabledByDefault;
     }
     bool isTapToClick() const {
         return m_tapToClick;
     }
     /**
      * Set the Device to tap to click if @p set is @c true.
      */
     void setTapToClick(bool set);
     bool tapAndDragEnabledByDefault() const {
         return m_tapAndDragEnabledByDefault;
     }
     bool isTapAndDrag() const {
         return m_tapAndDrag;
     }
     void setTapAndDrag(bool set);
     bool tapDragLockEnabledByDefault() const {
         return m_tapDragLockEnabledByDefault;
     }
     bool isTapDragLock() const {
         return m_tapDragLock;
     }
     void setTapDragLock(bool set);
     bool supportsDisableWhileTyping() const {
         return m_supportsDisableWhileTyping;
     }
     bool disableWhileTypingEnabledByDefault() const {
         return m_disableWhileTypingEnabledByDefault;
     }
     bool supportsPointerAcceleration() const {
         return m_supportsPointerAcceleration;
     }
     bool supportsLeftHanded() const {
         return m_supportsLeftHanded;
     }
     bool supportsCalibrationMatrix() const {
         return m_supportsCalibrationMatrix;
     }
     bool supportsDisableEvents() const {
         return m_supportsDisableEvents;
     }
     bool supportsDisableEventsOnExternalMouse() const {
         return m_supportsDisableEventsOnExternalMouse;
     }
     bool supportsMiddleEmulation() const {
         return m_supportsMiddleEmulation;
     }
     bool supportsNaturalScroll() const {
         return m_supportsNaturalScroll;
     }
     bool supportsScrollTwoFinger() const {
         return (m_supportedScrollMethods & LIBINPUT_CONFIG_SCROLL_2FG);
     }
     bool supportsScrollEdge() const {
         return (m_supportedScrollMethods & LIBINPUT_CONFIG_SCROLL_EDGE);
     }
     bool supportsScrollOnButtonDown() const {
         return (m_supportedScrollMethods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
     }
     bool leftHandedEnabledByDefault() const {
         return m_leftHandedEnabledByDefault;
     }
     bool middleEmulationEnabledByDefault() const {
         return m_middleEmulationEnabledByDefault;
     }
     bool naturalScrollEnabledByDefault() const {
         return m_naturalScrollEnabledByDefault;
     }
     enum libinput_config_scroll_method defaultScrollMethod() const {
         return m_defaultScrollMethod;
     }
     quint32 defaultScrollMethodToInt() const {
         return (quint32) m_defaultScrollMethod;
     }
     bool scrollTwoFingerEnabledByDefault() const {
         return m_defaultScrollMethod == LIBINPUT_CONFIG_SCROLL_2FG;
     }
     bool scrollEdgeEnabledByDefault() const {
         return m_defaultScrollMethod == LIBINPUT_CONFIG_SCROLL_EDGE;
     }
     bool scrollOnButtonDownEnabledByDefault() const {
         return m_defaultScrollMethod == LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
     }
     bool supportsLmrTapButtonMap() const {
         return m_tapFingerCount > 1;
     }
     bool lmrTapButtonMapEnabledByDefault() const {
         return m_defaultTapButtonMap == LIBINPUT_CONFIG_TAP_MAP_LMR;
     }
 
     void setLmrTapButtonMap(bool set);
     bool lmrTapButtonMap() const {
         return m_tapButtonMap & LIBINPUT_CONFIG_TAP_MAP_LMR;
     }
 
     quint32 defaultScrollButton() const {
         return m_defaultScrollButton;
     }
     bool isMiddleEmulation() const {
         return m_middleEmulation;
     }
     void setMiddleEmulation(bool set);
     bool isNaturalScroll() const {
         return m_naturalScroll;
     }
     void setNaturalScroll(bool set);
     void setScrollMethod(bool set, enum libinput_config_scroll_method method);
     bool isScrollTwoFinger() const {
         return m_scrollMethod & LIBINPUT_CONFIG_SCROLL_2FG;
     }
     void setScrollTwoFinger(bool set) {
         setScrollMethod(set, LIBINPUT_CONFIG_SCROLL_2FG);
     }
     bool isScrollEdge() const {
         return m_scrollMethod & LIBINPUT_CONFIG_SCROLL_EDGE;
     }
     void setScrollEdge(bool set) {
         setScrollMethod(set, LIBINPUT_CONFIG_SCROLL_EDGE);
     }
     bool isScrollOnButtonDown() const {
         return m_scrollMethod & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
     }
     void setScrollOnButtonDown(bool set) {
         setScrollMethod(set, LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
     }
     void activateScrollMethodFromInt(quint32 method) {
         setScrollMethod(true, (libinput_config_scroll_method) method);
     }
     quint32 scrollButton() const {
         return m_scrollButton;
     }
     void setScrollButton(quint32 button);
 
+    qreal scrollFactorDefault() const {
+        return 1.0;
+    }
+    qreal scrollFactor() const {
+        return m_scrollFactor;
+    }
+    void setScrollFactor(qreal factor);
+
     void setDisableWhileTyping(bool set);
     bool isDisableWhileTyping() const {
         return m_disableWhileTyping;
     }
     bool isLeftHanded() const {
         return m_leftHanded;
     }
     /**
      * Sets the Device to left handed mode if @p set is @c true.
      * If @p set is @c false the device is set to right handed mode
      */
     void setLeftHanded(bool set);
 
     qreal defaultPointerAcceleration() const {
         return m_defaultPointerAcceleration;
     }
     qreal pointerAcceleration() const {
         return m_pointerAcceleration;
     }
     /**
      * @param acceleration mapped to range [-1,1] with -1 being the slowest, 1 being the fastest supported acceleration.
      */
     void setPointerAcceleration(qreal acceleration);
     void setPointerAccelerationFromString(QString acceleration) {
         setPointerAcceleration(acceleration.toDouble());
     }
     QString defaultPointerAccelerationToString() const {
         return QString::number(m_pointerAcceleration, 'f', 3);
     }
     bool supportsPointerAccelerationProfileFlat() const {
         return (m_supportedPointerAccelerationProfiles & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
     }
     bool supportsPointerAccelerationProfileAdaptive() const {
         return (m_supportedPointerAccelerationProfiles & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
     }
     bool defaultPointerAccelerationProfileFlat() const {
         return (m_defaultPointerAccelerationProfile & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
     }
     bool defaultPointerAccelerationProfileAdaptive() const {
         return (m_defaultPointerAccelerationProfile & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
     }
     bool pointerAccelerationProfileFlat() const {
         return (m_pointerAccelerationProfile & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
     }
     bool pointerAccelerationProfileAdaptive() const {
         return (m_pointerAccelerationProfile & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
     }
     void setPointerAccelerationProfile(bool set, enum  libinput_config_accel_profile profile);
     void setPointerAccelerationProfileFlat(bool set) {
         setPointerAccelerationProfile(set, LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
     }
     void setPointerAccelerationProfileAdaptive(bool set) {
         setPointerAccelerationProfile(set, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
     }
     void setPointerAccelerationProfileFromInt(quint32 profile) {
         setPointerAccelerationProfile(true, (libinput_config_accel_profile) profile);
     }
     quint32 defaultPointerAccelerationProfileToInt() const {
         return (quint32) m_defaultPointerAccelerationProfile;
     }
     bool supportsClickMethodAreas() const {
         return (m_supportedClickMethods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
     }
     bool defaultClickMethodAreas() const {
         return (m_defaultClickMethod == LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
     }
     bool isClickMethodAreas() const {
         return (m_clickMethod == LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
     }
     bool supportsClickMethodClickfinger() const {
         return (m_supportedClickMethods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
     }
     bool defaultClickMethodClickfinger() const {
         return (m_defaultClickMethod == LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
     }
     bool isClickMethodClickfinger() const {
         return (m_clickMethod == LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
     }
     void setClickMethod(bool set, enum libinput_config_click_method method);
     void setClickMethodAreas(bool set) {
         setClickMethod(set, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
     }
     void setClickMethodClickfinger(bool set) {
         setClickMethod(set, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
     }
     void setClickMethodFromInt(quint32 method) {
         setClickMethod(true, (libinput_config_click_method) method);
     }
     quint32 defaultClickMethodToInt() const {
         return (quint32) m_defaultClickMethod;
     }
 
     bool isEnabled() const {
         return m_enabled;
     }
     void setEnabled(bool enabled);
 
     libinput_device *device() const {
         return m_device;
     }
 
     /**
      * Sets the @p config to load the Device configuration from and to store each
      * successful Device configuration.
      */
     void setConfig(const KConfigGroup &config) {
         m_config = config;
     }
 
     /**
      * The id of the screen in KWin identifiers. Set from KWin through setScreenId.
      */
     int screenId() const {
         return m_screenId;
     }
 
     /**
      * Sets the KWin screen id for the device
      */
     void setScreenId(int screenId) {
         m_screenId = screenId;
     }
 
     void setOrientation(Qt::ScreenOrientation orientation);
 
     /**
      * Loads the configuration and applies it to the Device
      */
     void loadConfiguration();
 
     bool isSwitch() const {
         return m_switch;
     }
 
     bool isLidSwitch() const {
         return m_lidSwitch;
     }
 
     bool isTabletModeSwitch() const {
         return m_tabletSwitch;
     }
 
     int stripsCount() const;
     int ringsCount() const;
 
     /**
      * All created Devices
      */
     static QVector<Device*> devices() {
         return s_devices;
     }
     /**
      * Gets the Device for @p native. @c null if there is no Device for @p native.
      */
     static Device *getDevice(libinput_device *native);
 
 Q_SIGNALS:
     void tapButtonMapChanged();
     void leftHandedChanged();
     void disableWhileTypingChanged();
     void pointerAccelerationChanged();
     void pointerAccelerationProfileChanged();
     void enabledChanged();
     void tapToClickChanged();
     void tapAndDragChanged();
     void tapDragLockChanged();
     void middleEmulationChanged();
     void naturalScrollChanged();
     void scrollMethodChanged();
     void scrollButtonChanged();
+    void scrollFactorChanged();
     void clickMethodChanged();
 
 private:
     template <typename T>
     void writeEntry(const ConfigKey &key, const T &value);
     template <typename T, typename Setter>
     void readEntry(const QByteArray &key, const Setter &s, const T &defaultValue = T());
     libinput_device *m_device;
     bool m_keyboard;
     bool m_alphaNumericKeyboard = false;
     bool m_pointer;
     bool m_touch;
     bool m_tabletTool;
     bool m_tabletPad;
     bool m_supportsGesture;
     bool m_switch = false;
     bool m_lidSwitch = false;
     bool m_tabletSwitch = false;
     QString m_name;
     QString m_sysName;
     QString m_outputName;
     QSizeF m_size;
     quint32 m_product;
     quint32 m_vendor;
     Qt::MouseButtons m_supportedButtons = Qt::NoButton;
     int m_tapFingerCount;
     enum libinput_config_tap_button_map m_defaultTapButtonMap;
     enum libinput_config_tap_button_map m_tapButtonMap;
     bool m_tapToClickEnabledByDefault;
     bool m_tapToClick;
     bool m_tapAndDragEnabledByDefault;
     bool m_tapAndDrag;
     bool m_tapDragLockEnabledByDefault;
     bool m_tapDragLock;
     bool m_supportsDisableWhileTyping;
     bool m_supportsPointerAcceleration;
     bool m_supportsLeftHanded;
     bool m_supportsCalibrationMatrix;
     bool m_supportsDisableEvents;
     bool m_supportsDisableEventsOnExternalMouse;
     bool m_supportsMiddleEmulation;
     bool m_supportsNaturalScroll;
     quint32 m_supportedScrollMethods;
     bool m_supportsScrollEdge;
     bool m_supportsScrollOnButtonDown;
     bool m_leftHandedEnabledByDefault;
     bool m_middleEmulationEnabledByDefault;
     bool m_naturalScrollEnabledByDefault;
     enum libinput_config_scroll_method m_defaultScrollMethod;
     quint32 m_defaultScrollButton;
     bool m_disableWhileTypingEnabledByDefault;
     bool m_disableWhileTyping;
     bool m_middleEmulation;
     bool m_leftHanded;
     bool m_naturalScroll;
     enum libinput_config_scroll_method m_scrollMethod;
     quint32 m_scrollButton;
     qreal m_defaultPointerAcceleration;
     qreal m_pointerAcceleration;
+    qreal m_scrollFactor;
     quint32 m_supportedPointerAccelerationProfiles;
     enum libinput_config_accel_profile m_defaultPointerAccelerationProfile;
     enum libinput_config_accel_profile m_pointerAccelerationProfile;
     bool m_enabled;
 
     KConfigGroup m_config;
     bool m_loading = false;
 
     int m_screenId = 0;
     Qt::ScreenOrientation m_orientation = Qt::PrimaryOrientation;
     QMatrix4x4 m_defaultCalibrationMatrix;
     quint32 m_supportedClickMethods;
     enum libinput_config_click_method m_defaultClickMethod;
     enum libinput_config_click_method m_clickMethod;
 
     static QVector<Device*> s_devices;
 };
 
 }
 }
 
 Q_DECLARE_METATYPE(KWin::LibInput::Device*)
 
 #endif
diff --git a/libinput/events.cpp b/libinput/events.cpp
index 56969ad8b..add7bf661 100644
--- a/libinput/events.cpp
+++ b/libinput/events.cpp
@@ -1,397 +1,397 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2014 Martin Gräßlin <mgraesslin@kde.org>
 
 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 2 of the License, or
 (at your option) 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 "events.h"
 #include "device.h"
 
 #include <QSize>
 
 namespace KWin
 {
 namespace LibInput
 {
 
 Event *Event::create(libinput_event *event)
 {
     if (!event) {
         return nullptr;
     }
     const auto t = libinput_event_get_type(event);
     // TODO: add touch events
     // TODO: add device notify events
     switch (t) {
     case LIBINPUT_EVENT_KEYBOARD_KEY:
         return new KeyEvent(event);
     case LIBINPUT_EVENT_POINTER_AXIS:
     case LIBINPUT_EVENT_POINTER_BUTTON:
     case LIBINPUT_EVENT_POINTER_MOTION:
     case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
         return new PointerEvent(event, t);
     case LIBINPUT_EVENT_TOUCH_DOWN:
     case LIBINPUT_EVENT_TOUCH_UP:
     case LIBINPUT_EVENT_TOUCH_MOTION:
     case LIBINPUT_EVENT_TOUCH_CANCEL:
     case LIBINPUT_EVENT_TOUCH_FRAME:
         return new TouchEvent(event, t);
     case LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN:
     case LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE:
     case LIBINPUT_EVENT_GESTURE_SWIPE_END:
         return new SwipeGestureEvent(event, t);
     case LIBINPUT_EVENT_GESTURE_PINCH_BEGIN:
     case LIBINPUT_EVENT_GESTURE_PINCH_UPDATE:
     case LIBINPUT_EVENT_GESTURE_PINCH_END:
         return new PinchGestureEvent(event, t);
     case LIBINPUT_EVENT_TABLET_TOOL_AXIS:
     case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY:
     case LIBINPUT_EVENT_TABLET_TOOL_TIP:
         return new TabletToolEvent(event, t);
     case LIBINPUT_EVENT_TABLET_TOOL_BUTTON:
         return new TabletToolButtonEvent(event, t);
     case LIBINPUT_EVENT_TABLET_PAD_RING:
         return new TabletPadRingEvent(event, t);
     case LIBINPUT_EVENT_TABLET_PAD_STRIP:
         return new TabletPadStripEvent(event, t);
     case LIBINPUT_EVENT_TABLET_PAD_BUTTON:
         return new TabletPadButtonEvent(event, t);
     case LIBINPUT_EVENT_SWITCH_TOGGLE:
         return new SwitchEvent(event, t);
     default:
         return new Event(event, t);
     }
 }
 
 Event::Event(libinput_event *event, libinput_event_type type)
     : m_event(event)
     , m_type(type)
     , m_device(nullptr)
 {
 }
 
 Event::~Event()
 {
     libinput_event_destroy(m_event);
 }
 
 Device *Event::device() const
 {
     if (!m_device) {
         m_device = Device::getDevice(libinput_event_get_device(m_event));
     }
     return m_device;
 }
 
 libinput_device *Event::nativeDevice() const
 {
     if (m_device) {
         return m_device->device();
     }
     return libinput_event_get_device(m_event);
 }
 
 KeyEvent::KeyEvent(libinput_event *event)
     : Event(event, LIBINPUT_EVENT_KEYBOARD_KEY)
     , m_keyboardEvent(libinput_event_get_keyboard_event(event))
 {
 }
 
 KeyEvent::~KeyEvent() = default;
 
 uint32_t KeyEvent::key() const
 {
     return libinput_event_keyboard_get_key(m_keyboardEvent);
 }
 
 InputRedirection::KeyboardKeyState KeyEvent::state() const
 {
     switch (libinput_event_keyboard_get_key_state(m_keyboardEvent)) {
     case LIBINPUT_KEY_STATE_PRESSED:
         return InputRedirection::KeyboardKeyPressed;
     case LIBINPUT_KEY_STATE_RELEASED:
         return InputRedirection::KeyboardKeyReleased;
     }
     abort();
 }
 
 uint32_t KeyEvent::time() const
 {
     return libinput_event_keyboard_get_time(m_keyboardEvent);
 }
 
 PointerEvent::PointerEvent(libinput_event *event, libinput_event_type type)
     : Event(event, type)
     , m_pointerEvent(libinput_event_get_pointer_event(event))
 {
 }
 
 PointerEvent::~PointerEvent() = default;
 
 QPointF PointerEvent::absolutePos() const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE);
     return QPointF(libinput_event_pointer_get_absolute_x(m_pointerEvent),
                    libinput_event_pointer_get_absolute_y(m_pointerEvent));
 }
 
 QPointF PointerEvent::absolutePos(const QSize &size) const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE);
     return QPointF(libinput_event_pointer_get_absolute_x_transformed(m_pointerEvent, size.width()),
                    libinput_event_pointer_get_absolute_y_transformed(m_pointerEvent, size.height()));
 }
 
 QSizeF PointerEvent::delta() const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_POINTER_MOTION);
     return QSizeF(libinput_event_pointer_get_dx(m_pointerEvent), libinput_event_pointer_get_dy(m_pointerEvent));
 }
 
 QSizeF PointerEvent::deltaUnaccelerated() const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_POINTER_MOTION);
     return QSizeF(libinput_event_pointer_get_dx_unaccelerated(m_pointerEvent), libinput_event_pointer_get_dy_unaccelerated(m_pointerEvent));
 }
 
 uint32_t PointerEvent::time() const
 {
     return libinput_event_pointer_get_time(m_pointerEvent);
 }
 
 quint64 PointerEvent::timeMicroseconds() const
 {
     return libinput_event_pointer_get_time_usec(m_pointerEvent);
 }
 
 uint32_t PointerEvent::button() const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_POINTER_BUTTON);
     return libinput_event_pointer_get_button(m_pointerEvent);
 }
 
 InputRedirection::PointerButtonState PointerEvent::buttonState() const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_POINTER_BUTTON);
     switch (libinput_event_pointer_get_button_state(m_pointerEvent)) {
     case LIBINPUT_BUTTON_STATE_PRESSED:
         return InputRedirection::PointerButtonPressed;
     case LIBINPUT_BUTTON_STATE_RELEASED:
         return InputRedirection::PointerButtonReleased;
     }
     abort();
 }
 
 QVector<InputRedirection::PointerAxis> PointerEvent::axis() const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_POINTER_AXIS);
     QVector<InputRedirection::PointerAxis> a;
     if (libinput_event_pointer_has_axis(m_pointerEvent, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)) {
         a << InputRedirection::PointerAxisHorizontal;
     }
     if (libinput_event_pointer_has_axis(m_pointerEvent, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL)) {
         a << InputRedirection::PointerAxisVertical;
     }
     return a;
 }
 
 qreal PointerEvent::axisValue(InputRedirection::PointerAxis axis) const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_POINTER_AXIS);
     const libinput_pointer_axis a = axis == InputRedirection::PointerAxisHorizontal
                                           ? LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL
                                           : LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
-    return libinput_event_pointer_get_axis_value(m_pointerEvent, a);
+    return libinput_event_pointer_get_axis_value(m_pointerEvent, a) * device()->scrollFactor();
 }
 
 qint32 PointerEvent::discreteAxisValue(InputRedirection::PointerAxis axis) const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_POINTER_AXIS);
     const libinput_pointer_axis a = (axis == InputRedirection::PointerAxisHorizontal)
         ? LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL
         : LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
-    return libinput_event_pointer_get_axis_value_discrete(m_pointerEvent, a);
+    return libinput_event_pointer_get_axis_value_discrete(m_pointerEvent, a) * device()->scrollFactor();
 }
 
 InputRedirection::PointerAxisSource PointerEvent::axisSource() const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_POINTER_AXIS);
     switch (libinput_event_pointer_get_axis_source(m_pointerEvent)) {
     case LIBINPUT_POINTER_AXIS_SOURCE_WHEEL:
         return InputRedirection::PointerAxisSourceWheel;
     case LIBINPUT_POINTER_AXIS_SOURCE_FINGER:
         return InputRedirection::PointerAxisSourceFinger;
     case LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS:
         return InputRedirection::PointerAxisSourceContinuous;
     case LIBINPUT_POINTER_AXIS_SOURCE_WHEEL_TILT:
         return InputRedirection::PointerAxisSourceWheelTilt;
     default:
         return InputRedirection::PointerAxisSourceUnknown;
     }
 }
 
 TouchEvent::TouchEvent(libinput_event *event, libinput_event_type type)
     : Event(event, type)
     , m_touchEvent(libinput_event_get_touch_event(event))
 {
 }
 
 TouchEvent::~TouchEvent() = default;
 
 quint32 TouchEvent::time() const
 {
     return libinput_event_touch_get_time(m_touchEvent);
 }
 
 QPointF TouchEvent::absolutePos() const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_TOUCH_DOWN || type() == LIBINPUT_EVENT_TOUCH_MOTION);
     return QPointF(libinput_event_touch_get_x(m_touchEvent),
                    libinput_event_touch_get_y(m_touchEvent));
 }
 
 QPointF TouchEvent::absolutePos(const QSize &size) const
 {
     Q_ASSERT(type() == LIBINPUT_EVENT_TOUCH_DOWN || type() == LIBINPUT_EVENT_TOUCH_MOTION);
     return QPointF(libinput_event_touch_get_x_transformed(m_touchEvent, size.width()),
                    libinput_event_touch_get_y_transformed(m_touchEvent, size.height()));
 }
 
 qint32 TouchEvent::id() const
 {
     Q_ASSERT(type() != LIBINPUT_EVENT_TOUCH_CANCEL && type() != LIBINPUT_EVENT_TOUCH_FRAME);
 
     const qint32 slot = libinput_event_touch_get_slot(m_touchEvent);
 
     return slot == -1 ? 0 : slot;
 }
 
 GestureEvent::GestureEvent(libinput_event *event, libinput_event_type type)
     : Event(event, type)
     , m_gestureEvent(libinput_event_get_gesture_event(event))
 {
 }
 
 GestureEvent::~GestureEvent() = default;
 
 quint32 GestureEvent::time() const
 {
     return libinput_event_gesture_get_time(m_gestureEvent);
 }
 
 int GestureEvent::fingerCount() const
 {
     return libinput_event_gesture_get_finger_count(m_gestureEvent);
 }
 
 QSizeF GestureEvent::delta() const
 {
     return QSizeF(libinput_event_gesture_get_dx(m_gestureEvent),
                   libinput_event_gesture_get_dy(m_gestureEvent));
 }
 
 bool GestureEvent::isCancelled() const
 {
     return libinput_event_gesture_get_cancelled(m_gestureEvent) != 0;
 }
 
 PinchGestureEvent::PinchGestureEvent(libinput_event *event, libinput_event_type type)
     : GestureEvent(event, type)
 {
 }
 
 PinchGestureEvent::~PinchGestureEvent() = default;
 
 qreal PinchGestureEvent::scale() const
 {
     return libinput_event_gesture_get_scale(m_gestureEvent);
 }
 
 qreal PinchGestureEvent::angleDelta() const
 {
     return libinput_event_gesture_get_angle_delta(m_gestureEvent);
 }
 
 SwipeGestureEvent::SwipeGestureEvent(libinput_event *event, libinput_event_type type)
     : GestureEvent(event, type)
 {
 }
 
 SwipeGestureEvent::~SwipeGestureEvent() = default;
 
 SwitchEvent::SwitchEvent(libinput_event *event, libinput_event_type type)
     : Event(event, type)
     , m_switchEvent(libinput_event_get_switch_event(event))
 {
 }
 
 SwitchEvent::~SwitchEvent() = default;
 
 SwitchEvent::State SwitchEvent::state() const
 {
     switch (libinput_event_switch_get_switch_state(m_switchEvent))
     {
     case LIBINPUT_SWITCH_STATE_OFF:
         return State::Off;
     case LIBINPUT_SWITCH_STATE_ON:
         return State::On;
     default:
         Q_UNREACHABLE();
     }
     return State::Off;
 }
 
 quint32 SwitchEvent::time() const
 {
     return libinput_event_switch_get_time(m_switchEvent);
 }
 
 quint64 SwitchEvent::timeMicroseconds() const
 {
     return libinput_event_switch_get_time_usec(m_switchEvent);
 }
 
 TabletToolEvent::TabletToolEvent(libinput_event *event, libinput_event_type type)
     : Event(event, type)
     , m_tabletToolEvent(libinput_event_get_tablet_tool_event(event))
 {
 }
 
 TabletToolButtonEvent::TabletToolButtonEvent(libinput_event *event, libinput_event_type type)
     : Event(event, type)
     , m_tabletToolEvent(libinput_event_get_tablet_tool_event(event))
 {
 }
 
 TabletPadButtonEvent::TabletPadButtonEvent(libinput_event *event, libinput_event_type type)
     : Event(event, type)
     , m_tabletPadEvent(libinput_event_get_tablet_pad_event(event))
 {
 }
 
 TabletPadStripEvent::TabletPadStripEvent(libinput_event *event, libinput_event_type type)
     : Event(event, type)
     , m_tabletPadEvent(libinput_event_get_tablet_pad_event(event))
 {
 }
 
 TabletPadRingEvent::TabletPadRingEvent(libinput_event *event, libinput_event_type type)
     : Event(event, type)
     , m_tabletPadEvent(libinput_event_get_tablet_pad_event(event))
 {
 }
 }
 }