diff --git a/kcms/touchpad/src/backends/kwin_wayland/kwinwaylandbackend.cpp b/kcms/touchpad/src/backends/kwin_wayland/kwinwaylandbackend.cpp --- a/kcms/touchpad/src/backends/kwin_wayland/kwinwaylandbackend.cpp +++ b/kcms/touchpad/src/backends/kwin_wayland/kwinwaylandbackend.cpp @@ -40,6 +40,8 @@ QDBusConnection::sessionBus(), this); + m_mode = TouchpadInputBackendMode::WaylandLibinput; + findTouchpads(); m_deviceManager->connection().connect(QStringLiteral("org.kde.KWin"), diff --git a/kcms/touchpad/src/backends/x11/libinputtouchpad.h b/kcms/touchpad/src/backends/x11/libinputtouchpad.h --- a/kcms/touchpad/src/backends/x11/libinputtouchpad.h +++ b/kcms/touchpad/src/backends/x11/libinputtouchpad.h @@ -23,8 +23,474 @@ class LibinputTouchpad : public XlibTouchpad { + Q_OBJECT + // + // general + Q_PROPERTY(QString name READ name CONSTANT) + Q_PROPERTY(bool supportsDisableEvents READ supportsDisableEvents CONSTANT) + Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged) + // + // advanced + Q_PROPERTY(Qt::MouseButtons supportedButtons READ supportedButtons CONSTANT) + + Q_PROPERTY(bool supportsLeftHanded READ supportsLeftHanded CONSTANT) + Q_PROPERTY(bool leftHandedEnabledByDefault READ leftHandedEnabledByDefault CONSTANT) + Q_PROPERTY(bool leftHanded READ isLeftHanded WRITE setLeftHanded NOTIFY leftHandedChanged) + + Q_PROPERTY(bool 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) + + Q_PROPERTY(bool supportsMiddleEmulation READ supportsMiddleEmulation CONSTANT) + Q_PROPERTY(bool middleEmulationEnabledByDefault READ middleEmulationEnabledByDefault CONSTANT) + Q_PROPERTY(bool middleEmulation READ isMiddleEmulation WRITE setMiddleEmulation NOTIFY middleEmulationChanged) + + // + // acceleration speed and profile + Q_PROPERTY(bool supportsPointerAcceleration READ supportsPointerAcceleration CONSTANT) + Q_PROPERTY(qreal pointerAcceleration READ pointerAcceleration WRITE setPointerAcceleration NOTIFY pointerAccelerationChanged) + + Q_PROPERTY(bool supportsPointerAccelerationProfileFlat READ supportsPointerAccelerationProfileFlat CONSTANT) + Q_PROPERTY(bool defaultPointerAccelerationProfileFlat READ defaultPointerAccelerationProfileFlat CONSTANT) + Q_PROPERTY(bool pointerAccelerationProfileFlat READ pointerAccelerationProfileFlat WRITE setPointerAccelerationProfileFlat NOTIFY pointerAccelerationProfileChanged) + + Q_PROPERTY(bool supportsPointerAccelerationProfileAdaptive READ supportsPointerAccelerationProfileAdaptive CONSTANT) + Q_PROPERTY(bool defaultPointerAccelerationProfileAdaptive READ defaultPointerAccelerationProfileAdaptive CONSTANT) + Q_PROPERTY(bool pointerAccelerationProfileAdaptive READ pointerAccelerationProfileAdaptive WRITE setPointerAccelerationProfileAdaptive NOTIFY pointerAccelerationProfileChanged) + + // + // scrolling + Q_PROPERTY(bool supportsNaturalScroll READ supportsNaturalScroll CONSTANT) + Q_PROPERTY(bool naturalScrollEnabledByDefault READ naturalScrollEnabledByDefault CONSTANT) + Q_PROPERTY(bool naturalScroll READ isNaturalScroll WRITE setNaturalScroll NOTIFY naturalScrollChanged) + + 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(bool scrollOnButtonDown READ isScrollOnButtonDown WRITE setScrollOnButtonDown NOTIFY scrollMethodChanged) + + Q_PROPERTY(quint32 defaultScrollButton READ defaultScrollButton CONSTANT) + Q_PROPERTY(quint32 scrollButton READ scrollButton WRITE setScrollButton NOTIFY scrollButtonChanged) + + // + // 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 lmrTapButtonMapChanged) + + 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) + + // 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: LibinputTouchpad(Display *display, int deviceId); + bool getConfig() override; + bool applyConfig() override; + bool getDefaultConfig() override; + bool isChangedConfig() override; + + // + // general + QString name() { + return m_name; + } + bool supportsDisableEvents() { + return m_supportsDisableEvents.avail ? m_supportsDisableEvents.val : false; + } + bool enabled() { + return !m_enabled.val; + } + void setEnabled(bool set) { + m_enabled.set(!set); + } + // + // advanced + Qt::MouseButtons supportedButtons() const { + return m_supportedButtons.val; + } + bool supportsLeftHanded() const { + return m_supportsLeftHanded.val; + } + bool leftHandedEnabledByDefault() const { + return m_leftHandedEnabledByDefault.val; + } + bool isLeftHanded() const { + return m_leftHanded.val; + } + void setLeftHanded(bool set) { + m_leftHanded.set(set); + } + + bool supportsDisableEventsOnExternalMouse() const { + return m_supportsDisableEventsOnExternalMouse.avail ? m_supportsDisableEventsOnExternalMouse.val : false; + } + + bool supportsDisableWhileTyping() const { + return m_supportsDisableWhileTyping.val; + } + bool disableWhileTypingEnabledByDefault() const { + return m_disableWhileTypingEnabledByDefault.val; + } + bool isDisableWhileTyping() const { + return m_disableWhileTyping.val; + } + void setDisableWhileTyping(bool set) { + m_disableWhileTyping.set(set); + } + + bool supportsMiddleEmulation() const { + return m_supportsMiddleEmulation.val; + } + bool middleEmulationEnabledByDefault() const { + return m_middleEmulationEnabledByDefault.val; + } + bool isMiddleEmulation() const { + return m_middleEmulation.val; + } + void setMiddleEmulation(bool set) { + m_middleEmulation.set(set); + } + + // + // acceleration speed and profile + bool supportsPointerAcceleration() const { + return m_supportsPointerAcceleration.val; + } + qreal pointerAcceleration() const { + return m_pointerAcceleration.val; + } + void setPointerAcceleration(qreal acceleration) { + m_pointerAcceleration.set(acceleration); + } + + bool supportsPointerAccelerationProfileFlat() const { + return m_supportsPointerAccelerationProfileFlat.avail ? m_supportsPointerAccelerationProfileFlat.val : false; + } + bool defaultPointerAccelerationProfileFlat() const { + return m_defaultPointerAccelerationProfileFlat.val; + } + bool pointerAccelerationProfileFlat() const { + return m_pointerAccelerationProfileFlat.val; + } + void setPointerAccelerationProfileFlat(bool set) { + m_pointerAccelerationProfileFlat.set(set); + } + + bool supportsPointerAccelerationProfileAdaptive() const { + return m_supportsPointerAccelerationProfileAdaptive.avail ? m_supportsPointerAccelerationProfileAdaptive.val : false; + } + bool defaultPointerAccelerationProfileAdaptive() const { + return m_defaultPointerAccelerationProfileAdaptive.val; + } + bool pointerAccelerationProfileAdaptive() const { + return m_pointerAccelerationProfileAdaptive.val; + } + void setPointerAccelerationProfileAdaptive(bool set) { + m_pointerAccelerationProfileAdaptive.set(set); + } + + // + // scrolling + bool supportsNaturalScroll() const { + return m_supportsNaturalScroll.val; + } + bool naturalScrollEnabledByDefault() const { + return m_naturalScrollEnabledByDefault.val; + } + bool isNaturalScroll() const { + return m_naturalScroll.val; + } + void setNaturalScroll(bool set) { + m_naturalScroll.set(set); + } + + bool supportsScrollTwoFinger() const { + return m_supportsScrollTwoFinger.avail ? m_supportsScrollTwoFinger.val : false; + } + bool scrollTwoFingerEnabledByDefault() const { + return m_scrollTwoFingerEnabledByDefault.val; + } + bool isScrollTwoFinger() const { + return m_isScrollTwoFinger.val; + } + void setScrollTwoFinger(bool set) { + m_isScrollTwoFinger.set(set); + } + + bool supportsScrollEdge() const { + return m_supportsScrollEdge.avail ? m_supportsScrollEdge.val : false; + } + bool scrollEdgeEnabledByDefault() const { + return m_scrollEdgeEnabledByDefault.val; + } + bool isScrollEdge() const { + return m_isScrollEdge.val; + } + void setScrollEdge(bool set) { + m_isScrollEdge.set(set); + } + + bool supportsScrollOnButtonDown() const { + return m_supportsScrollOnButtonDown.avail ? m_supportsScrollOnButtonDown.val : false; + } + bool scrollOnButtonDownEnabledByDefault() const { + return m_scrollOnButtonDownEnabledByDefault.val; + } + bool isScrollOnButtonDown() const { + return m_isScrollOnButtonDown.val; + } + void setScrollOnButtonDown(bool set) { + m_isScrollOnButtonDown.set(set); + } + + quint32 defaultScrollButton() const { + return m_defaultScrollButton.val; + } + quint32 scrollButton() const { + return m_scrollButton.val; + } + void setScrollButton(quint32 button) { + m_scrollButton.set(button); + } + + // + // tapping + int tapFingerCount() const { + return m_tapFingerCount.val; + } + bool tapToClickEnabledByDefault() const { + return m_tapToClickEnabledByDefault.val; + } + bool isTapToClick() const { + return m_tapToClick.val; + } + void setTapToClick(bool set) { + m_tapToClick.set(set); + } + + bool supportsLmrTapButtonMap() const { + return m_tapFingerCount.val > 1; + } + bool lmrTapButtonMapEnabledByDefault() const { + return m_lmrTapButtonMapEnabledByDefault.val; + } + bool lmrTapButtonMap() const { + return m_lmrTapButtonMap.val; + } + void setLmrTapButtonMap(bool set) { + m_lmrTapButtonMap.set(set); + } + + bool tapAndDragEnabledByDefault() const { + return m_tapAndDragEnabledByDefault.val; + } + bool isTapAndDrag() const { + return m_tapAndDrag.val; + } + void setTapAndDrag(bool set) { + m_tapAndDrag.set(set); + } + + bool tapDragLockEnabledByDefault() const { + return m_tapDragLockEnabledByDefault.val; + } + bool isTapDragLock() const { + return m_tapDragLock.val; + } + void setTapDragLock(bool set) { + m_tapDragLock.set(set); + } + + bool supportsClickMethodAreas() const { + return m_supportsClickMethodAreas.avail ? m_supportsClickMethodAreas.val : false; + } + bool defaultClickMethodAreas() const { + return m_defaultClickMethodAreas.val; + } + bool isClickMethodAreas() const { + return m_clickMethodAreas.val; + } + void setClickMethodAreas(bool set) { + m_clickMethodAreas.set(set); + } + + bool supportsClickMethodClickfinger() const { + return m_supportsClickMethodClickfinger.avail ? m_supportsClickMethodClickfinger.val : false; + } + bool defaultClickMethodClickfinger() const { + return m_defaultClickMethodClickfinger.val; + } + bool isClickMethodClickfinger() const { + return m_clickMethodClickfinger.val; + } + void setClickMethodClickfinger(bool set) { + m_clickMethodClickfinger.set(set); + } + +Q_SIGNALS: + void enabledChanged(); + // Tapping + void tapToClickChanged(); + void lmrTapButtonMapChanged(); + void tapAndDragChanged(); + void tapDragLockChanged(); + // Advanced + void leftHandedChanged(); + void disableWhileTypingChanged(); + void middleEmulationChanged(); + // acceleration speed and profile + void pointerAccelerationChanged(); + void pointerAccelerationProfileChanged(); + // scrolling + void naturalScrollChanged(); + void scrollMethodChanged(); + void scrollButtonChanged(); + // click methods + void clickMethodChanged(); + +private: + template + struct Prop { + explicit Prop(const QByteArray &_name) + : name(_name) + {} + + void set(T newVal) { + if (avail && val != newVal) { + val = newVal; + } + } + void set(const Prop &p) { + if (avail && val != p.val) { + val = p.val; + } + } + bool changed() const { + return avail && (old != val); + } + + QByteArray name; + bool avail; + T old; + T val; + }; + + template + bool valueLoader(Prop &prop); + + template + QString valueWriter(const Prop &prop); + + // + // general + Prop m_supportsDisableEvents = Prop("SupportsDisableEvents"); + Prop m_enabled = Prop("Enabled"); + Prop m_enabledDefault = Prop("EnabledDefault"); + + // + // advanced + Prop m_supportedButtons = Prop("SupportedButtons"); + + Prop m_supportsLeftHanded = Prop("SupportsLeftHanded"); + Prop m_leftHandedEnabledByDefault = Prop("LeftHandedEnabledByDefault"); + Prop m_leftHanded = Prop("LeftHanded"); + + Prop m_supportsDisableEventsOnExternalMouse = Prop("SupportsDisableEventsOnExternalMouse"); + Prop m_disableEventsOnExternalMouse = Prop("DisableEventsOnExternalMouse"); + Prop m_disableEventsOnExternalMouseDefault = Prop("DisableEventsOnExternalMouseDefault"); + + Prop m_supportsDisableWhileTyping = Prop("SupportsDisableWhileTyping"); + Prop m_disableWhileTypingEnabledByDefault = Prop("DisableWhileTypingEnabledByDefault"); + Prop m_disableWhileTyping = Prop("DisableWhileTyping"); + + Prop m_supportsMiddleEmulation = Prop("SupportsMiddleEmulation"); + Prop m_middleEmulationEnabledByDefault = Prop("MiddleEmulationEnabledByDefault"); + Prop m_middleEmulation = Prop("MiddleEmulation"); + + // + // acceleration speed and profile + Prop m_supportsPointerAcceleration = Prop("SupportsPointerAcceleration"); + Prop m_defaultPointerAcceleration = Prop("DefaultPointerAcceleration"); + Prop m_pointerAcceleration = Prop("PointerAcceleration"); + + Prop m_supportsPointerAccelerationProfileFlat = Prop("SupportsPointerAccelerationProfileFlat"); + Prop m_defaultPointerAccelerationProfileFlat = Prop("DefaultPointerAccelerationProfileFlat"); + Prop m_pointerAccelerationProfileFlat = Prop("PointerAccelerationProfileFlat"); + + Prop m_supportsPointerAccelerationProfileAdaptive = Prop("SupportsPointerAccelerationProfileAdaptive"); + Prop m_defaultPointerAccelerationProfileAdaptive = Prop("DefaultPointerAccelerationProfileAdaptive"); + Prop m_pointerAccelerationProfileAdaptive = Prop("PointerAccelerationProfileAdaptive"); + + // + // scrolling + Prop m_supportsNaturalScroll = Prop("SupportsNaturalScroll"); + Prop m_naturalScrollEnabledByDefault = Prop("NaturalScrollEnabledByDefault"); + Prop m_naturalScroll = Prop("NaturalScroll"); + + Prop m_supportsScrollTwoFinger = Prop("SupportsScrollTwoFinger"); + Prop m_scrollTwoFingerEnabledByDefault = Prop("ScrollTwoFingerEnabledByDefault"); + Prop m_isScrollTwoFinger = Prop("ScrollTwoFinger"); + + Prop m_supportsScrollEdge = Prop("SupportsScrollEdge"); + Prop m_scrollEdgeEnabledByDefault = Prop("ScrollEdgeEnabledByDefault"); + Prop m_isScrollEdge = Prop("ScrollEdge"); + + Prop m_supportsScrollOnButtonDown = Prop("SupportsScrollOnButtonDown"); + Prop m_scrollOnButtonDownEnabledByDefault = Prop("ScrollOnButtonDownEnabledByDefault"); + Prop m_isScrollOnButtonDown = Prop("ScrollOnButtonDown"); + + Prop m_defaultScrollButton = Prop("DefaultScrollButton"); + Prop m_scrollButton = Prop("ScrollButton"); + + // + // tapping + Prop m_tapFingerCount = Prop("TapFingerCount"); + Prop m_tapToClickEnabledByDefault = Prop("TapToClickEnabledByDefault"); + Prop m_tapToClick = Prop("Tapping"); + + Prop m_lmrTapButtonMapEnabledByDefault = Prop("LmrTapButtonMapEnabledByDefault"); + Prop m_lmrTapButtonMap = Prop("LmrTapButtonMap"); + + Prop m_tapAndDragEnabledByDefault = Prop("TapAndDragEnabledByDefault"); + Prop m_tapAndDrag = Prop("TapAndDrag"); + Prop m_tapDragLockEnabledByDefault = Prop("TapDragLockEnabledByDefault"); + Prop m_tapDragLock = Prop("TapDragLock"); + + // Click Method + Prop m_supportsClickMethodAreas = Prop("SupportsClickMethodAreas"); + Prop m_defaultClickMethodAreas = Prop("DefaultClickMethodAreas"); + Prop m_clickMethodAreas = Prop("ClickMethodAreas"); + + Prop m_supportsClickMethodClickfinger = Prop("SupportsClickMethodClickfinger"); + Prop m_defaultClickMethodClickfinger = Prop("DefaultClickMethodClickfinger"); + Prop m_clickMethodClickfinger = Prop("ClickMethodClickfinger"); + + + QString m_name; }; #endif // LIBINPUTTOUCHPAD_H diff --git a/kcms/touchpad/src/backends/x11/libinputtouchpad.cpp b/kcms/touchpad/src/backends/x11/libinputtouchpad.cpp --- a/kcms/touchpad/src/backends/x11/libinputtouchpad.cpp +++ b/kcms/touchpad/src/backends/x11/libinputtouchpad.cpp @@ -16,46 +16,396 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ +#include +#include + #include "libinputtouchpad.h" #include #include +#include +#include +#include "logging.h" + +namespace { +template +T valueLoaderPart(QVariant const &reply) { Q_UNUSED(reply); return T(); } + +template<> +bool valueLoaderPart(QVariant const &reply) { return reply.toBool(); } + +template<> +int valueLoaderPart(QVariant const &reply) { return reply.toInt(); } + +template<> +quint32 valueLoaderPart(QVariant const &reply) { return reply.toInt(); } + +template<> +qreal valueLoaderPart(QVariant const &reply) { return reply.toReal(); } + +template<> +QString valueLoaderPart(QVariant const &reply) { return reply.toString(); } + +template<> +Qt::MouseButtons valueLoaderPart(QVariant const &reply) { return static_cast(reply.toInt()); } +} + const struct Parameter libinputProperties[] = { + + /* libinput disable supports property */ + {"SupportsDisableEvents", PT_INT, 0, 1, LIBINPUT_PROP_SENDEVENTS_AVAILABLE, 8, 0}, + {"Enabled", PT_INT, 0, 1, LIBINPUT_PROP_SENDEVENTS_ENABLED, 8, 0}, + {"EnabledDefault", PT_INT, 0, 1, LIBINPUT_PROP_SENDEVENTS_ENABLED_DEFAULT, 8, 0}, + + /* LeftHandSupport */ + {"LeftHandedEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_LEFT_HANDED_DEFAULT, 8, 0}, + {"LeftHanded", PT_INT, 0, 1, LIBINPUT_PROP_LEFT_HANDED, 8, 0}, + + /* Disable on external mouse */ + {"SupportsDisableEventsOnExternalMouse",PT_INT, 0, 1, LIBINPUT_PROP_SENDEVENTS_AVAILABLE, 8, 1}, + {"DisableEventsOnExternalMouse", PT_INT, 0, 1, LIBINPUT_PROP_SENDEVENTS_ENABLED, 8, 1}, + {"DisableEventsOnExternalMouseDefault", PT_INT, 0, 1, LIBINPUT_PROP_SENDEVENTS_ENABLED_DEFAULT, 8, 1}, + + /* Disable while typing */ + {"DisableWhileTypingEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_DISABLE_WHILE_TYPING_DEFAULT, 8, 0}, + {"DisableWhileTyping", PT_INT, 0, 1, LIBINPUT_PROP_DISABLE_WHILE_TYPING, 8, 0}, + + /* Middle Emulation */ + {"MiddleEmulationEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_MIDDLE_EMULATION_ENABLED_DEFAULT, 8, 0}, + {"MiddleEmulation", PT_INT, 0, 1, LIBINPUT_PROP_MIDDLE_EMULATION_ENABLED, 8, 0}, + /* This is a boolean for all three fingers, no per-finger config */ - {"Tapping", PT_INT, 0, 1, "libinput Tapping Enabled", 8, 0}, + {"Tapping", PT_INT, 0, 1, LIBINPUT_PROP_TAP, 8, 0}, + {"TapToClickEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_TAP_DEFAULT, 8, 0}, + + /* LMR */ + {"LmrTapButtonMapEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_TAP_BUTTONMAP_DEFAULT, 8, 1}, + {"LmrTapButtonMap", PT_INT, 0, 1, LIBINPUT_PROP_TAP_BUTTONMAP, 8, 1}, + + /* Tap and Drag Enabled */ + {"TapAndDragEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_TAP_DRAG_DEFAULT, 8, 0}, + {"TapAndDrag", PT_INT, 0, 1, LIBINPUT_PROP_TAP_DRAG, 8, 0}, + + /* Tap and Drag Lock Enabled */ + {"TapDragLockEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_TAP_DRAG_LOCK_DEFAULT, 8, 0}, + {"TapDragLock", PT_INT, 0, 1, LIBINPUT_PROP_TAP_DRAG_LOCK, 8, 0}, + /* libinput normalizes the accel to -1/1 */ - {"AccelFactor", PT_DOUBLE, -1.0, 1.0, "libinput Accel Speed", 0 /*float */, 0}, - /* Only one of these may be set at one time */ - {"VertEdgeScroll", PT_INT, 0, 1, "libinput Scroll Method Enabled", 8, 1}, - {"VertTwoFingerScroll", PT_INT, 0, 1, "libinput Scroll Method Enabled", 8, 0}, - {"InvertVertScroll", PT_INT, 0, 1, "libinput Natural Scrolling Enabled", 8, 0}, + {"DefaultPointerAcceleration", PT_DOUBLE, -1.0, 1.0, LIBINPUT_PROP_ACCEL_DEFAULT, 0 /*float */, 0}, + {"PointerAcceleration", PT_DOUBLE, -1.0, 1.0, LIBINPUT_PROP_ACCEL, 0 /*float */, 0}, + + /* Libinput Accel Profile */ + {"SupportsPointerAccelerationProfileAdaptive", PT_BOOL, 0, 1, LIBINPUT_PROP_ACCEL_PROFILES_AVAILABLE, 8, 0}, + {"DefaultPointerAccelerationProfileAdaptive", PT_BOOL, 0, 1, LIBINPUT_PROP_ACCEL_PROFILE_ENABLED_DEFAULT, 8, 0}, + {"PointerAccelerationProfileAdaptive", PT_BOOL, 0, 1, LIBINPUT_PROP_ACCEL_PROFILE_ENABLED, 8, 0}, + {"SupportsPointerAccelerationProfileFlat", PT_BOOL, 0, 1, LIBINPUT_PROP_ACCEL_PROFILES_AVAILABLE, 8, 1}, + {"DefaultPointerAccelerationProfileFlat", PT_BOOL, 0, 1, LIBINPUT_PROP_ACCEL_PROFILE_ENABLED_DEFAULT, 8, 1}, + {"PointerAccelerationProfileFlat", PT_BOOL, 0, 1, LIBINPUT_PROP_ACCEL_PROFILE_ENABLED, 8, 1}, + + /* Natural Scrolling */ + {"NaturalScrollEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_NATURAL_SCROLL_DEFAULT, 8, 0}, + {"NaturalScroll", PT_INT, 0, 1, LIBINPUT_PROP_NATURAL_SCROLL, 8, 0}, + + /* Two-Finger Scrolling */ + {"SupportsScrollTwoFinger", PT_INT, 0, 1, LIBINPUT_PROP_SCROLL_METHODS_AVAILABLE, 8, 0}, + {"ScrollTwoFingerEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_SCROLL_METHOD_ENABLED_DEFAULT, 8, 0}, + {"ScrollTwoFinger", PT_INT, 0, 1, LIBINPUT_PROP_SCROLL_METHOD_ENABLED, 8, 0}, + + /* Edge Scrolling */ + {"SupportsScrollEdge", PT_INT, 0, 1, LIBINPUT_PROP_SCROLL_METHODS_AVAILABLE, 8, 1}, + {"ScrollEdgeEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_SCROLL_METHOD_ENABLED_DEFAULT, 8, 1}, + {"ScrollEdge", PT_INT, 0, 1, LIBINPUT_PROP_SCROLL_METHOD_ENABLED, 8, 1}, + + /* scroll on button */ + {"SupportsScrollOnButtonDown", PT_INT, 0, 1, LIBINPUT_PROP_SCROLL_METHODS_AVAILABLE, 8, 2}, + {"ScrollOnButtonDownEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_SCROLL_METHOD_ENABLED_DEFAULT, 8, 2}, + {"ScrollOnButtonDown", PT_INT, 0, 1, LIBINPUT_PROP_SCROLL_METHOD_ENABLED, 8, 2}, + + /* Scroll Button for scroll on button Down */ + {"DefaultScrollButton", PT_INT, 0, INT_MAX, LIBINPUT_PROP_SCROLL_BUTTON_DEFAULT, 32, 0}, + {"ScrollButton", PT_INT, 0, INT_MAX, LIBINPUT_PROP_SCROLL_BUTTON, 32, 0}, + + /* Click Methods */ + {"SupportsClickMethodAreas", PT_INT, 0, 1, LIBINPUT_PROP_CLICK_METHODS_AVAILABLE, 8, 0}, + {"DefaultClickMethodAreas", PT_INT, 0, 1, LIBINPUT_PROP_CLICK_METHOD_ENABLED_DEFAULT, 8, 0}, + {"ClickMethodAreas", PT_INT, 0, 1, LIBINPUT_PROP_CLICK_METHOD_ENABLED, 8, 0}, + + {"SupportsClickMethodClickfinger", PT_INT, 0, 1, LIBINPUT_PROP_CLICK_METHODS_AVAILABLE, 8, 1}, + {"DefaultClickMethodClickfinger", PT_INT, 0, 1, LIBINPUT_PROP_CLICK_METHOD_ENABLED_DEFAULT, 8, 1}, + {"ClickMethodClickfinger", PT_INT, 0, 1, LIBINPUT_PROP_CLICK_METHOD_ENABLED, 8, 1}, + /* libinput doesn't have a separate toggle for horiz scrolling */ { NULL, PT_INT, 0, 0, 0, 0, 0 } }; -LibinputTouchpad::LibinputTouchpad(Display *display, int deviceId): XlibTouchpad(display, deviceId) +Qt::MouseButtons maskBtns(Display *display, XIButtonClassInfo *buttonInfo) +{ + Qt::MouseButtons buttons = Qt::NoButton; + for (int i = 0; i < buttonInfo->num_buttons; ++i) { + QByteArray reply = XGetAtomName(display, buttonInfo->labels[i]); + + if (reply == BTN_LABEL_PROP_BTN_LEFT) { + buttons |= Qt::LeftButton; + } + if (reply == BTN_LABEL_PROP_BTN_RIGHT) { + buttons |= Qt::RightButton; + } + if (reply == BTN_LABEL_PROP_BTN_MIDDLE) { + buttons |= Qt::MiddleButton; + } + if (reply == BTN_LABEL_PROP_BTN_SIDE) { + buttons |= Qt::ExtraButton1; + } + if (reply == BTN_LABEL_PROP_BTN_EXTRA) { + buttons |= Qt::ExtraButton2; + } + if (reply == BTN_LABEL_PROP_BTN_FORWARD) { + buttons |= Qt::ForwardButton; + } + if (reply == BTN_LABEL_PROP_BTN_BACK) { + buttons |= Qt::BackButton; + } + if (reply == BTN_LABEL_PROP_BTN_TASK) { + buttons |= Qt::TaskButton; + } + } + return buttons; +} + +LibinputTouchpad::LibinputTouchpad(Display *display, int deviceId): + XlibTouchpad(nullptr, display, deviceId) { loadSupportedProperties(libinputProperties); - /* FIXME: has a different format than Synaptics Off but we don't expose - the toggle so this is just to stop it from crashing when we check - m_touchpadOffAtom */ - m_touchpadOffAtom.intern(m_connection, - "libinput Send Events Mode enabled"); - - - XcbAtom scroll_methods(m_connection, - "libinput Scroll Methods Available", - true); - if (scroll_methods.atom() != 0) { - PropertyInfo methods(m_display, - m_deviceId, - scroll_methods.atom(), - 0); - if (!methods.value(0).toInt()) - m_supported.removeAll("VertTwoFingerScroll"); - else if (!methods.value(1).toInt()) - m_supported.removeAll("VertEdgeScroll"); + int nDevices = 0; + XIDeviceInfo *deviceInfo = XIQueryDevice(m_display, m_deviceId, &nDevices); + m_name = deviceInfo->name; + + for (int i = 0; i < deviceInfo->num_classes; ++i) { + XIAnyClassInfo *classInfo = deviceInfo->classes[i]; + + if (classInfo->type == XIButtonClass) { + XIButtonClassInfo *btnInfo = (XIButtonClassInfo*) classInfo; + m_supportedButtons.set(maskBtns(m_display, btnInfo)); + } + + if (classInfo->type == XITouchClass) { + XITouchClassInfo *touchInfo = (XITouchClassInfo*) classInfo; + m_tapFingerCount.set(touchInfo->num_touches); + } + } + XIFreeDeviceInfo(deviceInfo); + + m_supportsLeftHanded.set(m_leftHanded.avail); + m_supportsDisableWhileTyping.set(m_disableWhileTyping.avail); + m_supportsMiddleEmulation.set(m_middleEmulation.avail); + m_supportsPointerAcceleration.set(m_pointerAcceleration.avail); + m_supportsNaturalScroll.set(m_naturalScroll.avail); +} + +bool LibinputTouchpad::getConfig() +{ + bool success = true; + + success &= valueLoader(m_supportsDisableEvents); + success &= valueLoader(m_enabled); + success &= valueLoader(m_enabledDefault); + + success &= valueLoader(m_tapToClickEnabledByDefault); + success &= valueLoader(m_tapToClick); + success &= valueLoader(m_lmrTapButtonMapEnabledByDefault); + success &= valueLoader(m_lmrTapButtonMap); + success &= valueLoader(m_tapAndDragEnabledByDefault); + success &= valueLoader(m_tapAndDrag); + success &= valueLoader(m_tapDragLockEnabledByDefault); + success &= valueLoader(m_tapDragLock); + + success &= valueLoader(m_leftHandedEnabledByDefault); + success &= valueLoader(m_leftHanded); + + success &= valueLoader(m_supportsDisableEventsOnExternalMouse); + success &= valueLoader(m_disableEventsOnExternalMouse); + success &= valueLoader(m_disableEventsOnExternalMouseDefault); + + success &= valueLoader(m_disableWhileTypingEnabledByDefault); + success &= valueLoader(m_disableWhileTyping); + + success &= valueLoader(m_middleEmulationEnabledByDefault); + success &= valueLoader(m_middleEmulation); + + success &= valueLoader(m_defaultPointerAcceleration); + success &= valueLoader(m_pointerAcceleration); + + success &= valueLoader(m_supportsPointerAccelerationProfileFlat); + success &= valueLoader(m_defaultPointerAccelerationProfileFlat); + success &= valueLoader(m_pointerAccelerationProfileFlat); + success &= valueLoader(m_supportsPointerAccelerationProfileAdaptive); + success &= valueLoader(m_defaultPointerAccelerationProfileAdaptive); + success &= valueLoader(m_pointerAccelerationProfileAdaptive); + + success &= valueLoader(m_naturalScrollEnabledByDefault); + success &= valueLoader(m_naturalScroll); + + success &= valueLoader(m_supportsScrollTwoFinger); + success &= valueLoader(m_scrollTwoFingerEnabledByDefault); + success &= valueLoader(m_isScrollTwoFinger); + + success &= valueLoader(m_supportsScrollEdge); + success &= valueLoader(m_scrollEdgeEnabledByDefault); + success &= valueLoader(m_isScrollEdge); + + success &= valueLoader(m_supportsScrollOnButtonDown); + success &= valueLoader(m_scrollOnButtonDownEnabledByDefault); + success &= valueLoader(m_isScrollOnButtonDown); + + success &= valueLoader(m_defaultScrollButton); + success &= valueLoader(m_scrollButton); + + // click methods + success &= valueLoader(m_supportsClickMethodAreas); + success &= valueLoader(m_supportsClickMethodClickfinger); + success &= valueLoader(m_defaultClickMethodAreas); + success &= valueLoader(m_defaultClickMethodClickfinger); + success &= valueLoader(m_clickMethodAreas); + success &= valueLoader(m_clickMethodClickfinger); + + return success; +} + +bool LibinputTouchpad::applyConfig() +{ + QVector msgs; + + msgs << valueWriter(m_enabled) + << valueWriter(m_tapToClick) + << valueWriter(m_lmrTapButtonMap) + << valueWriter(m_tapAndDrag) + << valueWriter(m_tapDragLock) + << valueWriter(m_leftHanded) + << valueWriter(m_disableWhileTyping) + << valueWriter(m_middleEmulation) + << valueWriter(m_pointerAcceleration) + << valueWriter(m_pointerAccelerationProfileFlat) + << valueWriter(m_pointerAccelerationProfileAdaptive) + << valueWriter(m_naturalScroll) + << valueWriter(m_isScrollTwoFinger) + << valueWriter(m_isScrollEdge) + << valueWriter(m_isScrollOnButtonDown) + << valueWriter(m_scrollButton) + << valueWriter(m_clickMethodAreas) + << valueWriter(m_clickMethodClickfinger); + + bool success = true; + QString error_msg; + + for (QString m : msgs) { + if (!m.isNull()) { + qCCritical(KCM_TOUCHPAD) << "in error:" << m; + if (!success) { + error_msg.append("\n"); + } + error_msg.append(m); + success = false; + } + } + + if (!success) { + qCCritical(KCM_TOUCHPAD) << error_msg; + } + + flush(); + return success; +} + +bool LibinputTouchpad::getDefaultConfig() +{ + m_enabled.set(m_enabledDefault); + m_tapToClick.set(m_tapToClickEnabledByDefault); + m_lmrTapButtonMap.set(m_lmrTapButtonMapEnabledByDefault); + m_tapAndDrag.set(m_tapAndDragEnabledByDefault); + m_tapDragLock.set(m_tapDragLockEnabledByDefault); + m_leftHanded.set(m_leftHandedEnabledByDefault); + m_disableEventsOnExternalMouse.set(m_disableEventsOnExternalMouseDefault); + m_disableWhileTyping.set(m_disableWhileTypingEnabledByDefault); + m_middleEmulation.set(m_middleEmulationEnabledByDefault); + m_pointerAcceleration.set(m_defaultPointerAcceleration); + m_pointerAccelerationProfileFlat.set(m_defaultPointerAccelerationProfileFlat); + m_pointerAccelerationProfileAdaptive.set(m_defaultPointerAccelerationProfileAdaptive); + m_naturalScroll.set(m_naturalScrollEnabledByDefault); + m_isScrollTwoFinger.set(m_scrollTwoFingerEnabledByDefault); + m_isScrollEdge.set(m_scrollEdgeEnabledByDefault); + m_isScrollOnButtonDown.set(m_scrollOnButtonDownEnabledByDefault); + m_scrollButton.set(m_defaultScrollButton); + m_clickMethodAreas.set(m_defaultClickMethodAreas); + m_clickMethodClickfinger.set(m_defaultClickMethodClickfinger); + + return true; +} + +bool LibinputTouchpad::isChangedConfig() +{ + + bool changed = m_enabled.changed() || + m_tapToClick.changed() || + m_lmrTapButtonMap.changed() || + m_tapAndDrag.changed() || + m_tapDragLock.changed() || + m_leftHanded.changed() || + m_disableEventsOnExternalMouse.changed() || + m_disableWhileTyping.changed() || + m_middleEmulation.changed() || + m_pointerAcceleration.changed() || + m_pointerAccelerationProfileFlat.changed() || + m_pointerAccelerationProfileAdaptive.changed() || + m_naturalScroll.changed() || + m_isScrollTwoFinger.changed() || + m_isScrollEdge.changed() || + m_isScrollOnButtonDown.changed() || + m_scrollButton.changed() || + m_clickMethodAreas.changed() || + m_clickMethodClickfinger.changed(); + + return changed; +} + +template +bool LibinputTouchpad::valueLoader(Prop &prop) +{ + const Parameter *p = findParameter(QString::fromAscii(prop.name)); + + if (!p) { + qCCritical(KCM_TOUCHPAD) << "Error on read of " << QString::fromAscii(prop.name); + } + + QVariant reply = getParameter(p); + if (!reply.isValid()) { + qCDebug(KCM_TOUCHPAD) << "Property not available : " << QString::fromAscii(prop.name); + prop.avail = false; + return true; + } + prop.avail = true; + + T replyValue = valueLoaderPart(reply); + + prop.old = replyValue; + prop.val = replyValue; + return true; +} + +template +QString LibinputTouchpad::valueWriter(const Prop &prop) +{ + const Parameter *p = findParameter(QString::fromAscii(prop.name)); + + if (!p || !prop.changed()) { + return QString(); + } + + bool error = !setParameter( p, prop.val); + if (error) { + qCCritical(KCM_TOUCHPAD) << "Cannot set property " + QString::fromAscii(prop.name); + return QStringLiteral("Cannot set property ") + QString::fromAscii(prop.name); } + return QString(); } diff --git a/kcms/touchpad/src/backends/x11/synapticstouchpad.h b/kcms/touchpad/src/backends/x11/synapticstouchpad.h --- a/kcms/touchpad/src/backends/x11/synapticstouchpad.h +++ b/kcms/touchpad/src/backends/x11/synapticstouchpad.h @@ -24,6 +24,8 @@ class SynapticsTouchpad : public XlibTouchpad { + Q_OBJECT + public: SynapticsTouchpad(Display *display, int deviceId); diff --git a/kcms/touchpad/src/backends/x11/synapticstouchpad.cpp b/kcms/touchpad/src/backends/x11/synapticstouchpad.cpp --- a/kcms/touchpad/src/backends/x11/synapticstouchpad.cpp +++ b/kcms/touchpad/src/backends/x11/synapticstouchpad.cpp @@ -128,7 +128,7 @@ { NULL, PT_INT, 0, 0, 0, 0, 0 } }; -SynapticsTouchpad::SynapticsTouchpad(Display *display, int deviceId): XlibTouchpad(display, deviceId), +SynapticsTouchpad::SynapticsTouchpad(Display *display, int deviceId): XlibTouchpad(nullptr,display, deviceId), m_resX(1), m_resY(1) { m_capsAtom.intern(m_connection, SYNAPTICS_PROP_CAPABILITIES); diff --git a/kcms/touchpad/src/backends/x11/xlibbackend.h b/kcms/touchpad/src/backends/x11/xlibbackend.h --- a/kcms/touchpad/src/backends/x11/xlibbackend.h +++ b/kcms/touchpad/src/backends/x11/xlibbackend.h @@ -43,12 +43,18 @@ { Q_OBJECT + Q_PROPERTY(int touchpadCount READ touchpadCount CONSTANT) + public: static XlibBackend* initialize(QObject *parent = nullptr); ~XlibBackend(); bool applyConfig(const QVariantHash &) override; + bool applyConfig() override; bool getConfig(QVariantHash &) override; + bool getConfig() override; + bool getDefaultConfig() override; + bool isChangedConfig() const override; QStringList supportedParameters() const override { return m_device ? m_device->supportedParameters() : QStringList(); } @@ -65,6 +71,7 @@ void watchForEvents(bool keyboard) override; QStringList listMouses(const QStringList &blacklist) override; + QVector getDevices() const override { return m_device ? QVector { m_device.data()} : QVector(); } private slots: void propertyChanged(xcb_atom_t); diff --git a/kcms/touchpad/src/backends/x11/xlibbackend.cpp b/kcms/touchpad/src/backends/x11/xlibbackend.cpp --- a/kcms/touchpad/src/backends/x11/xlibbackend.cpp +++ b/kcms/touchpad/src/backends/x11/xlibbackend.cpp @@ -109,6 +109,7 @@ info < deviceInfo.data() + nDevices; info++) { // Make sure device is touchpad + if (info->type != m_touchpadAtom.atom()) { continue; } @@ -120,8 +121,10 @@ Atom *atom = properties.data(), *atomEnd = properties.data() + nProperties; for (; atom != atomEnd; atom++) { if (*atom == m_libinputIdentifierAtom.atom()) { + m_mode = TouchpadInputBackendMode::XLibinput; return new LibinputTouchpad(m_display.data(), info->id); } else if (*atom == m_synapticsIdentifierAtom.atom()) { + m_mode = TouchpadInputBackendMode::XSynaptics; return new SynapticsTouchpad(m_display.data(), info->id); } } @@ -144,6 +147,20 @@ return success; } +bool XlibBackend::applyConfig() +{ + if (!m_device) { + return false; + } + + bool success = m_device->applyConfig(); + if (!success) { + m_errorString = i18n("Cannot apply touchpad configuration"); + } + + return success; +} + bool XlibBackend::getConfig(QVariantHash &p) { if (!m_device) { @@ -157,6 +174,41 @@ return success; } +bool XlibBackend::getConfig() +{ + if(!m_device) { + return false; + } + + bool success = m_device->getConfig(); + if (!success) { + m_errorString = i18n("Cannot read touchpad configuration"); + } + return success; +} + +bool XlibBackend::getDefaultConfig() +{ + if (!m_device) { + return false; + } + + bool success = m_device->getDefaultConfig(); + if (!success) { + m_errorString = i18n("Cannot read default touchpad configuration"); + } + return success; +} + +bool XlibBackend::isChangedConfig() const +{ + if (!m_device) { + return false; + } + + return m_device->isChangedConfig(); +} + void XlibBackend::setTouchpadEnabled(bool enable) { if (!m_device) { diff --git a/kcms/touchpad/src/backends/x11/xlibtouchpad.h b/kcms/touchpad/src/backends/x11/xlibtouchpad.h --- a/kcms/touchpad/src/backends/x11/xlibtouchpad.h +++ b/kcms/touchpad/src/backends/x11/xlibtouchpad.h @@ -19,6 +19,7 @@ #ifndef XLIBTOUCHPAD_H #define XLIBTOUCHPAD_H +#include #include #include @@ -42,16 +43,22 @@ unsigned prop_offset; /* Offset inside property */ }; -class XlibTouchpad +class XlibTouchpad : public QObject { + Q_OBJECT + public: - XlibTouchpad(Display *display, int deviceId); + XlibTouchpad(QObject *parent, Display *display, int deviceId); virtual ~XlibTouchpad() {}; int deviceId() { return m_deviceId; } const QStringList &supportedParameters() const { return m_supported; } bool applyConfig(const QVariantHash &p); bool getConfig(QVariantHash &p); + virtual bool getConfig() { return false; } + virtual bool applyConfig() { return false; } + virtual bool getDefaultConfig() { return false; } + virtual bool isChangedConfig() { return false; } void setEnabled(bool enable); bool enabled(); void setTouchpadOff(int touchpadOff); diff --git a/kcms/touchpad/src/backends/x11/xlibtouchpad.cpp b/kcms/touchpad/src/backends/x11/xlibtouchpad.cpp --- a/kcms/touchpad/src/backends/x11/xlibtouchpad.cpp +++ b/kcms/touchpad/src/backends/x11/xlibtouchpad.cpp @@ -16,7 +16,8 @@ return value; } -XlibTouchpad::XlibTouchpad(Display *display, int deviceId) : +XlibTouchpad::XlibTouchpad(QObject *parent, Display *display, int deviceId) : + QObject(parent), m_display(display), m_connection(XGetXCBConnection(display)), m_deviceId(deviceId) @@ -189,7 +190,6 @@ if (!prop) { return 0; } - PropertyInfo p(m_display, m_deviceId, prop, m_floatType.atom()); if (!p.b && !p.f && !p.i) { return 0; diff --git a/kcms/touchpad/src/kcm/libinput/touchpadconfiglibinput.h b/kcms/touchpad/src/kcm/libinput/touchpadconfiglibinput.h --- a/kcms/touchpad/src/kcm/libinput/touchpadconfiglibinput.h +++ b/kcms/touchpad/src/kcm/libinput/touchpadconfiglibinput.h @@ -32,6 +32,7 @@ public: explicit TouchpadConfigLibinput(TouchpadConfigContainer *parent, + TouchpadBackend* backend, const QVariantList &args = QVariantList()); virtual ~TouchpadConfigLibinput() {} diff --git a/kcms/touchpad/src/kcm/libinput/touchpadconfiglibinput.cpp b/kcms/touchpad/src/kcm/libinput/touchpadconfiglibinput.cpp --- a/kcms/touchpad/src/kcm/libinput/touchpadconfiglibinput.cpp +++ b/kcms/touchpad/src/kcm/libinput/touchpadconfiglibinput.cpp @@ -35,7 +35,7 @@ #include "version.h" -TouchpadConfigLibinput::TouchpadConfigLibinput(TouchpadConfigContainer *parent, const QVariantList &args) +TouchpadConfigLibinput::TouchpadConfigLibinput(TouchpadConfigContainer *parent, TouchpadBackend* backend, const QVariantList &args) : TouchpadConfigPlugin(parent) { KAboutData* data = new KAboutData(QStringLiteral("kcm_touchpad"), @@ -52,7 +52,7 @@ m_parent->setAboutData(data); - m_backend = TouchpadBackend::implementation(); + m_backend = backend; m_initError = !m_backend->errorString().isNull(); m_view = new QQuickWidget(this); diff --git a/kcms/touchpad/src/kcm/touchpadconfigcontainer.cpp b/kcms/touchpad/src/kcm/touchpadconfigcontainer.cpp --- a/kcms/touchpad/src/kcm/touchpadconfigcontainer.cpp +++ b/kcms/touchpad/src/kcm/touchpadconfigcontainer.cpp @@ -20,6 +20,7 @@ #include "touchpadconfigplugin.h" #include "kcm/libinput/touchpadconfiglibinput.h" #include "kcm/xlib/touchpadconfigxlib.h" +#include "touchpadbackend.h" #include @@ -36,10 +37,16 @@ TouchpadConfigContainer::TouchpadConfigContainer(QWidget *parent, const QVariantList &args) : KCModule(parent, args) { + TouchpadBackend *backend = TouchpadBackend::implementation(); if (KWindowSystem::isPlatformX11()) { - m_plugin = new TouchpadConfigXlib(this); + if (backend->m_mode == TouchpadInputBackendMode::XLibinput){ + m_plugin = new TouchpadConfigLibinput(this, backend); + } + else if (backend->m_mode == TouchpadInputBackendMode::XSynaptics) + m_plugin = new TouchpadConfigXlib(this, backend); + } else if (KWindowSystem::isPlatformWayland()) { - m_plugin = new TouchpadConfigLibinput(this); + m_plugin = new TouchpadConfigLibinput(this, backend); } } diff --git a/kcms/touchpad/src/kcm/xlib/touchpadconfigxlib.h b/kcms/touchpad/src/kcm/xlib/touchpadconfigxlib.h --- a/kcms/touchpad/src/kcm/xlib/touchpadconfigxlib.h +++ b/kcms/touchpad/src/kcm/xlib/touchpadconfigxlib.h @@ -52,6 +52,7 @@ public: explicit TouchpadConfigXlib(TouchpadConfigContainer *parent, + TouchpadBackend* backend, const QVariantList &args = QVariantList()); ~TouchpadConfigXlib() override; diff --git a/kcms/touchpad/src/kcm/xlib/touchpadconfigxlib.cpp b/kcms/touchpad/src/kcm/xlib/touchpadconfigxlib.cpp --- a/kcms/touchpad/src/kcm/xlib/touchpadconfigxlib.cpp +++ b/kcms/touchpad/src/kcm/xlib/touchpadconfigxlib.cpp @@ -98,7 +98,7 @@ return widget; } -TouchpadConfigXlib::TouchpadConfigXlib(TouchpadConfigContainer *parent, const QVariantList &args) +TouchpadConfigXlib::TouchpadConfigXlib(TouchpadConfigContainer *parent, TouchpadBackend* backend, const QVariantList &args) : TouchpadConfigPlugin(parent), m_configOutOfSync(false) { @@ -174,7 +174,7 @@ new SliderPair(m_pointerMotion.kcfg_PressureMotionMinZ, m_pointerMotion.kcfg_PressureMotionMaxZ, this); - m_backend = TouchpadBackend::implementation(); + m_backend = backend; KConfigDialogManager::changedMap()->insert("CustomSlider", SIGNAL(valueChanged(double))); diff --git a/kcms/touchpad/src/touchpadbackend.h b/kcms/touchpad/src/touchpadbackend.h --- a/kcms/touchpad/src/touchpadbackend.h +++ b/kcms/touchpad/src/touchpadbackend.h @@ -24,6 +24,12 @@ #include #include +enum class TouchpadInputBackendMode { + WaylandLibinput = 0, + XLibinput = 1, + XSynaptics = 2 +}; + class Q_DECL_EXPORT TouchpadBackend : public QObject { Q_OBJECT @@ -34,13 +40,15 @@ public: static TouchpadBackend *implementation(); + TouchpadInputBackendMode m_mode; + virtual bool applyConfig(const QVariantHash &) {return false;} virtual bool getConfig(QVariantHash &) {return false;} - virtual bool applyConfig() {return false;} - virtual bool getConfig() {return false;} - virtual bool getDefaultConfig() {return false;} - virtual bool isChangedConfig() const {return false;} + virtual bool applyConfig() { return false; } + virtual bool getConfig() { return false; } + virtual bool getDefaultConfig() { return false; } + virtual bool isChangedConfig() const { return false; } virtual QStringList supportedParameters() const {return QStringList();} virtual QString errorString() const {return QString();}