diff --git a/autotests/integration/scripting/scripts/screenedgetouch.qmlc b/autotests/integration/scripting/scripts/screenedgetouch.qmlc
new file mode 100644
index 0000000000000000000000000000000000000000..dbc80ea83a5644ec68276ee2bc6184caf787db4b
GIT binary patch
literal 1500
zc$|$>O=}ZT6upyVGBIguAQh@~kxda?WX70iBE>ISQ0O9B7cSf+nGZugo0+sCUAS_k
z{sIvfE{hh?y;~s*e?UQ83NHKsfqLGZm&r7ym^Ylfx%ZxX&wckzc6JMOv+7mP6Oocq
z>D${I&m4v5NF};jvht<8UA%0VMZ0KOg|cDWX3Z!XhFvx+qkJV_E7dKV<ht~;^=YuL
zJaAu+3co&l%sh9$95~nRyehsJt|c=+)--U^z$ii##r{?14X5_+q5T-^EOr5;(F%Uh
z9^H*hI3+mVDZc#(SOipAqY~N`xr>?!<{Z*#D;9bewYu@1wj5nerPQPv*3stBiO;DM
zpXe-%b)LwxCuZnGr*t&RD)Z=Q(oV=ToDsTeFTT8((k?D(Oi<)G#FC?ion~KT${&G$
zOWvu!j(JV@d)gii*@xU)I+#Z~Q2BGy_f>*<#!kdnZi!zN@$tPTx#xJm@XuZe=Clss
z4d5}b54-^mfFs~HunK{7zyn?a?}5+25E#Y6HHq$%2Mnk|b!tlgf|x7y$)Oy4CRx1i
zfz#pm60i+^9}x?_O>i8%-9s&l+I&7s`ozkx{gir~;o@naeuuJTvrhH|+n-Mx5p(YR
zFq<gF{ded#di22Er7Cx3%J_x<)|;IzzPIX(n&Nxh!n+O6X6Pj1kMIz+2FMZr2a&(W
z3QcJCxRzj^16*n$;xXUB(?Vn$SzTmoaF<O)yT~HM2wDy1Tqm6$!ED3Uxvv3YH86B}
ze>(E}P@CBQ_Mr!NENTo`&0}Q`&^aP(2YFSVL6^BMe+doL@tEVlmz(mtf$e`W<NNl4
N>Evh!{kM2-e*vGc#Wer`

literal 0
Hc$@<O00001

diff --git a/autotests/libinput/device_test.cpp b/autotests/libinput/device_test.cpp
--- a/autotests/libinput/device_test.cpp
+++ b/autotests/libinput/device_test.cpp
@@ -23,6 +23,8 @@
 
 #include <KSharedConfig>
 
+#include <QDBusInterface>
+#include <QDBusConnection>
 #include <QtTest>
 
 #include <linux/input.h>
@@ -33,6 +35,7 @@
 {
     Q_OBJECT
 private Q_SLOTS:
+    void initTestCase();
     void testStaticGetter();
     void testDeviceType_data();
     void testDeviceType();
@@ -51,6 +54,10 @@
     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();
@@ -135,6 +142,8 @@
     void testLoadPointerAcceleration();
     void testLoadPointerAccelerationProfile_data();
     void testLoadPointerAccelerationProfile();
+    void testLoadClickMethod_data();
+    void testLoadClickMethod();
     void testLoadTapToClick_data();
     void testLoadTapToClick();
     void testLoadTapAndDrag_data();
@@ -163,6 +172,22 @@
     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
@@ -243,16 +268,22 @@
     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);
 }
@@ -275,6 +306,7 @@
     Device d(&device);
     QCOMPARE(d.supportsGesture(), supported);
     QCOMPARE(d.property("gestureSupport").toBool(), supported);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "gestureSupport"), supported);
 }
 
 void TestLibinputDevice::testNames_data()
@@ -301,10 +333,13 @@
     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()
@@ -315,6 +350,7 @@
     Device d(&device);
     QCOMPARE(d.product(), 100u);
     QCOMPARE(d.property("product").toUInt(), 100u);
+    QCOMPARE(dbusProperty<quint32>(d.sysName(), "product"), 100u);
 }
 
 void TestLibinputDevice::testVendor()
@@ -325,6 +361,7 @@
     Device d(&device);
     QCOMPARE(d.vendor(), 200u);
     QCOMPARE(d.property("vendor").toUInt(), 200u);
+    QCOMPARE(dbusProperty<quint32>(d.sysName(), "vendor"), 200u);
 }
 
 void TestLibinputDevice::testTapFingerCount()
@@ -335,6 +372,7 @@
     Device d(&device);
     QCOMPARE(d.tapFingerCount(), 3);
     QCOMPARE(d.property("tapFingerCount").toInt(), 3);
+    QCOMPARE(dbusProperty<int>(d.sysName(), "tapFingerCount"), 3);
 }
 
 void TestLibinputDevice::testSize_data()
@@ -359,6 +397,7 @@
     Device d(&device);
     QTEST(d.size(), "expectedSize");
     QTEST(d.property("size").toSizeF(), "expectedSize");
+    QTEST(dbusProperty<QSizeF>(d.sysName(), "size"), "expectedSize");
 }
 
 void TestLibinputDevice::testLeftHandedEnabledByDefault_data()
@@ -378,6 +417,7 @@
     Device d(&device);
     QCOMPARE(d.leftHandedEnabledByDefault(), enabled);
     QCOMPARE(d.property("leftHandedEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "leftHandedEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testTapEnabledByDefault_data()
@@ -397,6 +437,7 @@
     Device d(&device);
     QCOMPARE(d.tapToClickEnabledByDefault(), enabled);
     QCOMPARE(d.property("tapToClickEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "tapToClickEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testMiddleEmulationEnabledByDefault_data()
@@ -416,6 +457,7 @@
     Device d(&device);
     QCOMPARE(d.middleEmulationEnabledByDefault(), enabled);
     QCOMPARE(d.property("middleEmulationEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "middleEmulationEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testNaturalScrollEnabledByDefault_data()
@@ -435,6 +477,7 @@
     Device d(&device);
     QCOMPARE(d.naturalScrollEnabledByDefault(), enabled);
     QCOMPARE(d.property("naturalScrollEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "naturalScrollEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testScrollTwoFingerEnabledByDefault_data()
@@ -454,6 +497,7 @@
     Device d(&device);
     QCOMPARE(d.scrollTwoFingerEnabledByDefault(), enabled);
     QCOMPARE(d.property("scrollTwoFingerEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollTwoFingerEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testScrollEdgeEnabledByDefault_data()
@@ -473,6 +517,7 @@
     Device d(&device);
     QCOMPARE(d.scrollEdgeEnabledByDefault(), enabled);
     QCOMPARE(d.property("scrollEdgeEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollEdgeEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testDefaultPointerAccelerationProfileFlat_data()
@@ -492,6 +537,7 @@
     Device d(&device);
     QCOMPARE(d.defaultPointerAccelerationProfileFlat(), enabled);
     QCOMPARE(d.property("defaultPointerAccelerationProfileFlat").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "defaultPointerAccelerationProfileFlat"), enabled);
 }
 
 void TestLibinputDevice::testDefaultPointerAccelerationProfileAdaptive_data()
@@ -511,6 +557,47 @@
     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()
@@ -530,6 +617,7 @@
     Device d(&device);
     QCOMPARE(d.scrollOnButtonDownEnabledByDefault(), enabled);
     QCOMPARE(d.property("scrollOnButtonDownEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "scrollOnButtonDownEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testDefaultScrollButton_data()
@@ -556,6 +644,7 @@
     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()
@@ -575,6 +664,7 @@
     Device d(&device);
     QCOMPARE(d.supportsDisableWhileTyping(), enabled);
     QCOMPARE(d.property("supportsDisableWhileTyping").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsDisableWhileTyping"), enabled);
 }
 
 void TestLibinputDevice::testSupportsPointerAcceleration_data()
@@ -594,6 +684,7 @@
     Device d(&device);
     QCOMPARE(d.supportsPointerAcceleration(), enabled);
     QCOMPARE(d.property("supportsPointerAcceleration").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsPointerAcceleration"), enabled);
 }
 
 void TestLibinputDevice::testSupportsLeftHanded_data()
@@ -613,6 +704,7 @@
     Device d(&device);
     QCOMPARE(d.supportsLeftHanded(), enabled);
     QCOMPARE(d.property("supportsLeftHanded").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsLeftHanded"), enabled);
 }
 
 void TestLibinputDevice::testSupportsCalibrationMatrix_data()
@@ -632,6 +724,7 @@
     Device d(&device);
     QCOMPARE(d.supportsCalibrationMatrix(), enabled);
     QCOMPARE(d.property("supportsCalibrationMatrix").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsCalibrationMatrix"), enabled);
 }
 
 void TestLibinputDevice::testSupportsDisableEvents_data()
@@ -651,6 +744,7 @@
     Device d(&device);
     QCOMPARE(d.supportsDisableEvents(), enabled);
     QCOMPARE(d.property("supportsDisableEvents").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsDisableEvents"), enabled);
 }
 
 void TestLibinputDevice::testSupportsDisableEventsOnExternalMouse_data()
@@ -670,6 +764,7 @@
     Device d(&device);
     QCOMPARE(d.supportsDisableEventsOnExternalMouse(), enabled);
     QCOMPARE(d.property("supportsDisableEventsOnExternalMouse").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsDisableEventsOnExternalMouse"), enabled);
 }
 
 void TestLibinputDevice::testSupportsMiddleEmulation_data()
@@ -689,6 +784,7 @@
     Device d(&device);
     QCOMPARE(d.supportsMiddleEmulation(), enabled);
     QCOMPARE(d.property("supportsMiddleEmulation").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsMiddleEmulation"), enabled);
 }
 
 void TestLibinputDevice::testSupportsNaturalScroll_data()
@@ -708,6 +804,7 @@
     Device d(&device);
     QCOMPARE(d.supportsNaturalScroll(), enabled);
     QCOMPARE(d.property("supportsNaturalScroll").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsNaturalScroll"), enabled);
 }
 
 void TestLibinputDevice::testSupportsScrollTwoFinger_data()
@@ -727,6 +824,7 @@
     Device d(&device);
     QCOMPARE(d.supportsScrollTwoFinger(), enabled);
     QCOMPARE(d.property("supportsScrollTwoFinger").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsScrollTwoFinger"), enabled);
 }
 
 void TestLibinputDevice::testSupportsScrollEdge_data()
@@ -746,6 +844,7 @@
     Device d(&device);
     QCOMPARE(d.supportsScrollEdge(), enabled);
     QCOMPARE(d.property("supportsScrollEdge").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsScrollEdge"), enabled);
 }
 
 void TestLibinputDevice::testSupportsScrollOnButtonDown_data()
@@ -765,6 +864,7 @@
     Device d(&device);
     QCOMPARE(d.supportsScrollOnButtonDown(), enabled);
     QCOMPARE(d.property("supportsScrollOnButtonDown").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "supportsScrollOnButtonDown"), enabled);
 }
 
 void TestLibinputDevice::testDefaultPointerAcceleration_data()
@@ -787,6 +887,7 @@
     Device d(&device);
     QCOMPARE(d.defaultPointerAcceleration(), accel);
     QCOMPARE(d.property("defaultPointerAcceleration").toReal(), accel);
+    QCOMPARE(dbusProperty<qreal>(d.sysName(), "defaultPointerAcceleration"), accel);
 }
 
 void TestLibinputDevice::testPointerAcceleration_data()
@@ -818,13 +919,15 @@
     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()
@@ -857,14 +960,16 @@
     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()
@@ -907,6 +1012,7 @@
     Device d(&device);
     QCOMPARE(d.isPointer(), isPointer);
     QTEST(d.supportedButtons(), "expectedButtons");
+    QTEST(Qt::MouseButtons(dbusProperty<int>(d.sysName(), "supportedButtons")), "expectedButtons");
 }
 
 void TestLibinputDevice::testAlphaNumericKeyboard_data()
@@ -959,6 +1065,7 @@
     Device d(&device);
     QCOMPARE(d.isKeyboard(), true);
     QTEST(d.isAlphaNumericKeyboard(), "isAlpha");
+    QTEST(dbusProperty<bool>(d.sysName(), "alphaNumericKeyboard"), "isAlpha");
 }
 
 
@@ -992,13 +1099,16 @@
     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()
@@ -1031,14 +1141,16 @@
     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()
@@ -1058,6 +1170,7 @@
     Device d(&device);
     QCOMPARE(d.tapAndDragEnabledByDefault(), enabled);
     QCOMPARE(d.property("tapAndDragEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "tapAndDragEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testTapAndDrag_data()
@@ -1085,14 +1198,16 @@
     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()
@@ -1112,6 +1227,7 @@
     Device d(&device);
     QCOMPARE(d.tapDragLockEnabledByDefault(), enabled);
     QCOMPARE(d.property("tapDragLockEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "tapDragLockEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testTapDragLock_data()
@@ -1139,14 +1255,16 @@
     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()
@@ -1179,6 +1297,7 @@
     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());
@@ -1188,6 +1307,7 @@
     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()
@@ -1220,6 +1340,7 @@
     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());
@@ -1229,6 +1350,7 @@
     QCOMPARE(d.isNaturalScroll(), expectedValue);
     QCOMPARE(d.property("naturalScroll").toBool(), expectedValue);
     QCOMPARE(naturalScrollChangedSpy.isEmpty(), initValue == expectedValue);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "naturalScroll"), expectedValue);
 }
 
 void TestLibinputDevice::testScrollTwoFinger_data()
@@ -1265,6 +1387,8 @@
     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());
@@ -1274,6 +1398,7 @@
     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()
@@ -1310,6 +1435,8 @@
     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());
@@ -1319,6 +1446,7 @@
     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()
@@ -1355,6 +1483,8 @@
     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());
@@ -1364,6 +1494,7 @@
     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()
@@ -1393,6 +1524,7 @@
     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());
@@ -1402,6 +1534,7 @@
     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()
@@ -1421,6 +1554,7 @@
     Device d(&device);
     QCOMPARE(d.disableWhileTypingEnabledByDefault(), enabled);
     QCOMPARE(d.property("disableWhileTypingEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "disableWhileTypingEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testLmrTapButtonMapEnabledByDefault_data()
@@ -1440,6 +1574,7 @@
     Device d(&device);
     QCOMPARE(d.lmrTapButtonMapEnabledByDefault(), enabled);
     QCOMPARE(d.property("lmrTapButtonMapEnabledByDefault").toBool(), enabled);
+    QCOMPARE(dbusProperty<bool>(d.sysName(), "lmrTapButtonMapEnabledByDefault"), enabled);
 }
 
 void TestLibinputDevice::testLmrTapButtonMap_data()
@@ -1522,6 +1657,7 @@
     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());
@@ -1531,6 +1667,7 @@
     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()
@@ -1669,14 +1806,79 @@
     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")
+            << (quint32) LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS << "clickMethodAreas"
+            << (quint32) LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER << "clickMethodClickfinger";
+    QTest::newRow("clickMethodClickfinger -> clickMethodAreas")
+            << (quint32) LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER << "clickMethodClickfinger"
+            << (quint32) LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS << "clickMethodAreas";
+    QTest::newRow("clickMethodAreas -> clickMethodAreas")
+            << (quint32) LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS << "clickMethodAreas"
+            << (quint32) LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS << "clickMethodAreas";
+    QTest::newRow("clickMethodClickfinger -> clickMethodClickfinger")
+            << (quint32) LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER << "clickMethodClickfinger"
+            << (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");
@@ -2094,11 +2296,13 @@
     // 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) {
@@ -2190,8 +2394,10 @@
     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)
diff --git a/autotests/libinput/mock_libinput.h b/autotests/libinput/mock_libinput.h
--- a/autotests/libinput/mock_libinput.h
+++ b/autotests/libinput/mock_libinput.h
@@ -101,6 +101,10 @@
 
     bool lidSwitch = false;
     bool tabletModeSwitch = false;
+    quint32 supportedClickMethods = 0;
+    enum libinput_config_click_method defaultClickMethod = LIBINPUT_CONFIG_CLICK_METHOD_NONE;
+    enum libinput_config_click_method clickMethod = LIBINPUT_CONFIG_CLICK_METHOD_NONE;
+    bool setClickMethodReturnValue = 0;
 };
 
 struct libinput_event {
diff --git a/autotests/libinput/mock_libinput.cpp b/autotests/libinput/mock_libinput.cpp
--- a/autotests/libinput/mock_libinput.cpp
+++ b/autotests/libinput/mock_libinput.cpp
@@ -276,6 +276,33 @@
     return device->pointerAccelerationProfile;
 }
 
+uint32_t libinput_device_config_click_get_methods(struct libinput_device *device)
+{
+    return device->supportedClickMethods;
+}
+
+enum libinput_config_click_method libinput_device_config_click_get_default_method(struct libinput_device *device)
+{
+    return device->defaultClickMethod;
+}
+
+enum libinput_config_click_method libinput_device_config_click_get_method(struct libinput_device *device)
+{
+    return device->clickMethod;
+}
+
+enum libinput_config_status libinput_device_config_click_set_method(struct libinput_device *device, enum libinput_config_click_method method)
+{
+    if (device->setClickMethodReturnValue == 0) {
+        if (!(device->supportedClickMethods & method) && method!= LIBINPUT_CONFIG_CLICK_METHOD_NONE) {
+            return LIBINPUT_CONFIG_STATUS_INVALID;
+        }
+        device->clickMethod = method;
+        return LIBINPUT_CONFIG_STATUS_SUCCESS;
+    }
+    return LIBINPUT_CONFIG_STATUS_INVALID;
+}
+
 uint32_t libinput_device_config_send_events_get_mode(struct libinput_device *device)
 {
     if (device->enabled) {
diff --git a/libinput/device.h b/libinput/device.h
--- a/libinput/device.h
+++ b/libinput/device.h
@@ -61,7 +61,7 @@
     Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
     //
     // advanced
-    Q_PROPERTY(Qt::MouseButtons supportedButtons READ supportedButtons CONSTANT)
+    Q_PROPERTY(int supportedButtons READ supportedButtons CONSTANT)
     Q_PROPERTY(bool supportsCalibrationMatrix READ supportsCalibrationMatrix CONSTANT)
 
     Q_PROPERTY(bool supportsLeftHanded READ supportsLeftHanded CONSTANT)
@@ -129,6 +129,14 @@
     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);
@@ -381,6 +389,38 @@
     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;
     }
@@ -456,6 +496,7 @@
     void naturalScrollChanged();
     void scrollMethodChanged();
     void scrollButtonChanged();
+    void clickMethodChanged();
 
 private:
     template <typename T>
@@ -518,6 +559,9 @@
     enum libinput_config_accel_profile m_defaultPointerAccelerationProfile;
     enum libinput_config_accel_profile m_pointerAccelerationProfile;
     bool m_enabled;
+    quint32 m_supportedClickMethods;
+    enum libinput_config_click_method m_defaultClickMethod;
+    enum libinput_config_click_method m_clickMethod;
 
     KConfigGroup m_config;
     bool m_loading = false;
diff --git a/libinput/device.cpp b/libinput/device.cpp
--- a/libinput/device.cpp
+++ b/libinput/device.cpp
@@ -83,7 +83,8 @@
     MiddleButtonEmulation,
     NaturalScroll,
     ScrollMethod,
-    ScrollButton
+    ScrollButton,
+    ClickMethod
 };
 
 struct ConfigData {
@@ -129,7 +130,8 @@
     {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::ScrollButton, ConfigData(QByteArrayLiteral("ScrollButton"), &Device::setScrollButton, &Device::defaultScrollButton)},
+    {ConfigKey::ClickMethod, ConfigData(QByteArrayLiteral("ClickMethod"), &Device::setClickMethodFromInt, &Device::defaultClickMethodToInt)}
 };
 
 namespace {
@@ -209,6 +211,9 @@
     , 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))
 {
     libinput_device_ref(m_device);
 
@@ -356,6 +361,27 @@
     }
 }
 
+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)) {