diff --git a/kcms/touchpad/src/backends/x11/libinputtouchpad.cpp b/kcms/touchpad/src/backends/x11/libinputtouchpad.cpp index c86026c4f..bf97b31bc 100644 --- a/kcms/touchpad/src/backends/x11/libinputtouchpad.cpp +++ b/kcms/touchpad/src/backends/x11/libinputtouchpad.cpp @@ -1,403 +1,436 @@ /* * Copyright (C) 2019 Atul Bisht * * 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "libinputtouchpad.h" #include "logging.h" +#include + #include #include #include #include #include +static const QSet configProps = { + QStringLiteral("enabled"), + QStringLiteral("disableWhileTyping"), + QStringLiteral("disableEventsOnExternalMouse"), + QStringLiteral("leftHanded"), + QStringLiteral("middleEmulation"), + QStringLiteral("pointerAcceleration"), + QStringLiteral("pointerAccelerationProfileFlat"), + QStringLiteral("pointerAccelerationProfileAdaptive"), + QStringLiteral("tapToClick"), + QStringLiteral("tapAndDrag"), + QStringLiteral("tapDragLock"), + QStringLiteral("lrmTapButtonMap"), + QStringLiteral("lmrTapButtonMap"), + QStringLiteral("scrollTwoFinger"), + QStringLiteral("scrollOnButtonDown"), + QStringLiteral("scrollButton"), + QStringLiteral("scrollEdge"), + QStringLiteral("naturalScroll"), + QStringLiteral("horizontalScrolling"), + QStringLiteral("clickMethodAreas"), + QStringLiteral("clickMethodClickfinger") +}; + const 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 */ {"tapToClick", PT_INT, 0, 1, LIBINPUT_PROP_TAP, 8, 0}, {"tapToClickEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_TAP_DEFAULT, 8, 0}, /* LMR */ {"lrmTapButtonMapEnabledByDefault", PT_INT, 0, 1, LIBINPUT_PROP_TAP_BUTTONMAP_DEFAULT, 8, 0}, {"lrmTapButtonMap", PT_INT, 0, 1, LIBINPUT_PROP_TAP_BUTTONMAP, 8, 0}, {"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 */ {"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}, /* Horizontal scrolling */ {"horizontalScrolling", PT_INT, 0, 1, LIBINPUT_PROP_HORIZ_SCROLL_ENABLED, 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 */ { nullptr, PT_INT, 0, 0, nullptr, 0, 0 } }; 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): LibinputCommon(), XlibTouchpad(display, deviceId) { loadSupportedProperties(libinputProperties); 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.avail = true; m_supportedButtons.set(maskBtns(m_display, btnInfo)); } if (classInfo->type == XITouchClass) { XITouchClassInfo *touchInfo = (XITouchClassInfo*) classInfo; m_tapFingerCount.avail = true; m_tapFingerCount.set(touchInfo->num_touches); } } XIFreeDeviceInfo(deviceInfo); /* FingerCount cannot be zero */ if (!m_tapFingerCount.val) { m_tapFingerCount.avail = true; m_tapFingerCount.set(1); } + m_config = KSharedConfig::openConfig(QStringLiteral("touchpadxlibinputrc")); } 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_lrmTapButtonMapEnabledByDefault); success &= valueLoader(m_lrmTapButtonMap); 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_horizontalScrolling); 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_lrmTapButtonMap) << 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_horizontalScrolling) << 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_lrmTapButtonMap.set(m_lrmTapButtonMap); 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_horizontalScrolling.set(true); 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_lrmTapButtonMap.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_horizontalScrolling.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()) { prop.avail = false; return true; } prop.avail = true; - T replyValue = valueLoaderPart(reply); + auto touchpadConfig = m_config->group(m_name); + const T replyValue = valueLoaderPart(reply); + const T loadedValue = touchpadConfig.readEntry(QString(prop.name), replyValue); prop.old = replyValue; - prop.val = replyValue; + prop.val = loadedValue; + 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); } + auto touchpadConfig = m_config->group(m_name); + touchpadConfig.writeEntry(QString(prop.name), prop.val); + touchpadConfig.config()->sync(); return QString(); } diff --git a/kcms/touchpad/src/backends/x11/libinputtouchpad.h b/kcms/touchpad/src/backends/x11/libinputtouchpad.h index eab026025..3668bee4c 100644 --- a/kcms/touchpad/src/backends/x11/libinputtouchpad.h +++ b/kcms/touchpad/src/backends/x11/libinputtouchpad.h @@ -1,130 +1,133 @@ /* * Copyright (C) 2019 Atul Bisht * * 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef LIBINPUTTOUCHPAD_H #define LIBINPUTTOUCHPAD_H -#include - #include "xlibtouchpad.h" #include "backends/libinputcommon.h" +#include +#include + class LibinputTouchpad : public LibinputCommon, public XlibTouchpad { Q_OBJECT public: LibinputTouchpad(Display *display, int deviceId); ~LibinputTouchpad() override {} bool getConfig() override; bool applyConfig() override; bool getDefaultConfig() override; bool isChangedConfig() override; private: template bool valueLoader(Prop &prop); template QString valueWriter(const Prop &prop); + KSharedConfigPtr m_config; + // // general QString name() const override { return m_name; } bool supportsDisableEvents() const override { return m_supportsDisableEvents.avail && m_supportsDisableEvents.val; } bool isEnabled() const override { return !m_enabled.val; } void setEnabled(bool set) override { m_enabled.set(!set); } // // Tapping void setLmrTapButtonMap(bool set) override { m_lrmTapButtonMap.set(!set); m_lmrTapButtonMap.set(set); } // // advanced bool supportsLeftHanded() const override { return m_leftHanded.avail; } bool supportsDisableEventsOnExternalMouse() const override { return m_supportsDisableEventsOnExternalMouse.avail && m_supportsDisableEventsOnExternalMouse.val; } bool supportsDisableWhileTyping() const override { return m_disableWhileTyping.avail; } bool supportsMiddleEmulation() const override { return m_middleEmulation.avail; } // // acceleration speed and profile bool supportsPointerAcceleration() const override { return m_pointerAcceleration.avail; } bool supportsPointerAccelerationProfileFlat() const override { return m_supportsPointerAccelerationProfileFlat.avail && m_supportsPointerAccelerationProfileFlat.val; } bool supportsPointerAccelerationProfileAdaptive() const override { return m_supportsPointerAccelerationProfileAdaptive.avail && m_supportsPointerAccelerationProfileAdaptive.val; } // // scrolling bool supportsNaturalScroll() const override { return m_naturalScroll.avail; } bool supportsHorizontalScrolling() const override { return true; } bool supportsScrollTwoFinger() const override { return m_supportsScrollTwoFinger.avail && m_supportsScrollTwoFinger.val; } bool supportsScrollEdge() const override { return m_supportsScrollEdge.avail && m_supportsScrollEdge.val; } bool supportsScrollOnButtonDown() const override { return m_supportsScrollOnButtonDown.avail && m_supportsScrollOnButtonDown.val; } // // click method bool supportsClickMethodAreas() const override { return m_supportsClickMethodAreas.avail && m_supportsClickMethodAreas.val; } bool supportsClickMethodClickfinger() const override { return m_supportsClickMethodClickfinger.avail && m_supportsClickMethodClickfinger.val; } // Tapping Prop m_lrmTapButtonMapEnabledByDefault = Prop("lrmTapButtonMapEnabledByDefault"); Prop m_lrmTapButtonMap = Prop("lrmTapButtonMap"); // // advanced Prop m_disableEventsOnExternalMouse = Prop("disableEventsOnExternalMouse"); Prop m_disableEventsOnExternalMouseDefault = Prop("disableEventsOnExternalMouseDefault"); QString m_name; }; #endif // LIBINPUTTOUCHPAD_H diff --git a/kcms/touchpad/src/kcm/touchpadconfigcontainer.cpp b/kcms/touchpad/src/kcm/touchpadconfigcontainer.cpp index 85fd4d6c5..879ef003e 100644 --- a/kcms/touchpad/src/kcm/touchpadconfigcontainer.cpp +++ b/kcms/touchpad/src/kcm/touchpadconfigcontainer.cpp @@ -1,86 +1,97 @@ /* * Copyright 2017 Roman Gilg * * 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "touchpadconfigcontainer.h" #include "touchpadconfigplugin.h" #include "kcm/libinput/touchpadconfiglibinput.h" #include "kcm/xlib/touchpadconfigxlib.h" #include "touchpadbackend.h" #include extern "C" { Q_DECL_EXPORT void kcminit_touchpad() { if (KWindowSystem::isPlatformX11()) { - TouchpadConfigXlib::kcmInit(); + TouchpadConfigContainer::kcmInit(); } } } TouchpadConfigContainer::TouchpadConfigContainer(QWidget *parent, const QVariantList &args) : KCModule(parent, args) { TouchpadBackend *backend = TouchpadBackend::implementation(); if (KWindowSystem::isPlatformX11()) { if (backend->getMode() == TouchpadInputBackendMode::XLibinput) { m_plugin = new TouchpadConfigLibinput(this, backend); } else if (backend->getMode() == TouchpadInputBackendMode::XSynaptics) { m_plugin = new TouchpadConfigXlib(this, backend); } } else if (KWindowSystem::isPlatformWayland()) { m_plugin = new TouchpadConfigLibinput(this, backend); } } +void TouchpadConfigContainer::kcmInit() +{ + TouchpadBackend *backend = TouchpadBackend::implementation(); + if (backend->getMode() == TouchpadInputBackendMode::XLibinput) { + backend->getConfig(); + backend->applyConfig(); + } else if (backend->getMode() == TouchpadInputBackendMode::XSynaptics) { + TouchpadConfigXlib::kcmInit(); + } +} + QSize TouchpadConfigContainer::minimumSizeHint() const { return m_plugin->minimumSizeHint(); } QSize TouchpadConfigContainer::sizeHint() const { return m_plugin->sizeHint(); } void TouchpadConfigContainer::resizeEvent(QResizeEvent *event) { Q_EMIT changed(false); m_plugin->resize(this->size()); } void TouchpadConfigContainer::load() { m_plugin->load(); } void TouchpadConfigContainer::save() { m_plugin->save(); } void TouchpadConfigContainer::defaults() { m_plugin->defaults(); } void TouchpadConfigContainer::hideEvent(QHideEvent *e) { m_plugin->hideEvent(e); KCModule::hideEvent(e); } diff --git a/kcms/touchpad/src/kcm/touchpadconfigcontainer.h b/kcms/touchpad/src/kcm/touchpadconfigcontainer.h index f3307f619..adfe30094 100644 --- a/kcms/touchpad/src/kcm/touchpadconfigcontainer.h +++ b/kcms/touchpad/src/kcm/touchpadconfigcontainer.h @@ -1,58 +1,60 @@ /* * Copyright 2017 Roman Gilg * * 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef TOUCHPADCONFIGCONTAINER_H #define TOUCHPADCONFIGCONTAINER_H #include class TouchpadConfigPlugin; class TouchpadConfigLibinput; class TouchpadConfigXlib; class TouchpadConfigContainer : public KCModule { Q_OBJECT friend TouchpadConfigXlib; friend TouchpadConfigLibinput; public: explicit TouchpadConfigContainer(QWidget *parent, const QVariantList &args = QVariantList()); + static void kcmInit(); + QSize minimumSizeHint() const override; QSize sizeHint() const override; void resizeEvent(QResizeEvent *event) override; void load() override; void save() override; void defaults() override; void kcmLoad() {KCModule::load();} void kcmSave() {KCModule::save();} void kcmDefaults() {KCModule::defaults();} protected: void hideEvent(QHideEvent *) override; private: TouchpadConfigPlugin* m_plugin = nullptr; }; #endif // TOUCHPADCONFIGCONTAINER_H