aiden
/
core
mirror of https://github.com/cutefishos/core
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

SettingsDaemon: Add mouse module

Browse Source
pull/9/head
reionwong 4 years ago
parent 95b2d360ef
commit 01e3881188
11 changed files with 774 additions and 1 deletions
Show Stats Download Patch File Download Diff File

1
debian/control vendored
Unescape Escape View File

@ -6,6 +6,7 @@ Build-Depends: cmake,
debhelper (>= 9),
extra-cmake-modules,
pkg-config,
xserver-xorg-input-libinput-dev,
libxcb1-dev,
libxcb-randr0-dev,
libsm-dev,

11
settings-daemon/CMakeLists.txt
Unescape Escape View File

@ -2,6 +2,8 @@ project(cutefish-settings-daemon)
set(TARGET cutefish-settings-daemon)
find_package(PulseAudio)
find_package(X11 REQUIRED)
pkg_check_modules(XORGLIBINPUT xorg-libinput IMPORTED_TARGET)
file (GLOB_RECURSE SRCS
"*.cpp"
@ -19,6 +21,8 @@ file (GLOB_RECURSE SRCS
"language/*.h"
"dock/*.cpp"
"dock/*.h"
"mouse/*.h"
"mouse/*.cpp"
)
set(SOURCES ${SRCS})
@ -44,6 +48,9 @@ qt5_add_dbus_adaptor(DBUS_SOURCES
qt5_add_dbus_adaptor(DBUS_SOURCES
dock/org.cutefish.Dock.xml
dock/dock.h Dock)
qt5_add_dbus_adaptor(DBUS_SOURCES
mouse/org.cutefish.Mouse.xml
mouse/mousemanager.h Mouse)
set_source_files_properties(${DBUS_SOURCES} PROPERTIES SKIP_AUTOGEN ON)
add_executable(${TARGET} ${SOURCES} ${DBUS_SOURCES} ${HEADERS} ${FORMS} ${RESOURCES})
@ -54,6 +61,10 @@ target_link_libraries(${TARGET}
Qt5::DBus
Qt5::X11Extras
${PULSEAUDIO_LIBRARY}
${X11_LIBRARIES}
X11::X11
X11::Xi
PkgConfig::XORGLIBINPUT
)
file(GLOB TS_FILES translations/*.ts)

1
settings-daemon/application.cpp
Unescape Escape View File

@ -36,6 +36,7 @@ Application::Application(int &argc, char **argv)
, m_brightnessManager(new BrightnessManager(this))
, m_upowerManager(new UPowerManager(this))
, m_language(new Language(this))
, m_mouse(new Mouse)
{
new DBusAdaptor(this);
// connect to D-Bus and register as an object:

2
settings-daemon/application.h
Unescape Escape View File

@ -26,6 +26,7 @@
#include "brightness/brightnessmanager.h"
#include "battery/upowermanager.h"
#include "language/language.h"
#include "mouse/mousemanager.h"
class Application : public QApplication
{
@ -44,6 +45,7 @@ private:
BrightnessManager *m_brightnessManager;
UPowerManager *m_upowerManager;
Language *m_language;
Mouse *m_mouse;
};
#endif // APPLICATION_H

39
settings-daemon/mouse/libinputsettings.cpp
Unescape Escape View File

@ -0,0 +1,39 @@
/*
SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "libinputsettings.h"
#include <QDebug>
#include <QSettings>
template<>
bool LibinputSettings::load(QString key, bool defVal)
{
QSettings settings("cutefishos", "mouse");
return settings.value(key, defVal).toBool();
}
template<>
qreal LibinputSettings::load(QString key, qreal defVal)
{
QSettings settings("cutefishos", "mouse");
return settings.value(key, defVal).toReal();
}
template<>
void LibinputSettings::save(QString key, bool val)
{
QSettings settings("cutefishos", "mouse");
settings.setValue(key, val);
settings.sync();
}
template<>
void LibinputSettings::save(QString key, qreal val)
{
QSettings settings("cutefishos", "mouse");
settings.setValue(key, val);
settings.sync();
}

20
settings-daemon/mouse/libinputsettings.h
Unescape Escape View File

@ -0,0 +1,20 @@
/*
SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#ifndef LIBINPUTSETTINGS_H
#define LIBINPUTSETTINGS_H
#include <QString>
struct LibinputSettings {
template<class T>
T load(QString key, T defVal);
template<class T>
void save(QString key, T val);
};
#endif // LIBINPUTSETTINGS_H

84
settings-daemon/mouse/mousemanager.cpp
Unescape Escape View File

@ -0,0 +1,84 @@
/*
* Copyright (C) 2021 CutefishOS Team.
*
* Author: Reion Wong <reionwong@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "mousemanager.h"
#include "mouseadaptor.h"
Mouse::Mouse(QObject *parent)
: QObject(parent)
, m_inputDummydevice(new X11LibinputDummyDevice(this, QX11Info::display()))
{
// init dbus
new MouseAdaptor(this);
QDBusConnection::sessionBus().registerObject(QStringLiteral("/Mouse"), this);
connect(m_inputDummydevice, &X11LibinputDummyDevice::leftHandedChanged, this, &Mouse::leftHandedChanged);
connect(m_inputDummydevice, &X11LibinputDummyDevice::pointerAccelerationProfileChanged, this, &Mouse::accelerationChanged);
connect(m_inputDummydevice, &X11LibinputDummyDevice::naturalScrollChanged, this, &Mouse::naturalScrollChanged);
connect(m_inputDummydevice, &X11LibinputDummyDevice::pointerAccelerationChanged, this, &Mouse::pointerAccelerationChanged);
}
Mouse::~Mouse()
{
delete m_inputDummydevice;
}
bool Mouse::leftHanded() const
{
return m_inputDummydevice->isLeftHanded();
}
void Mouse::setLeftHanded(bool enabled)
{
m_inputDummydevice->setLeftHanded(enabled);
m_inputDummydevice->applyConfig();
}
bool Mouse::acceleration() const
{
return m_inputDummydevice->pointerAccelerationProfileFlat();
}
void Mouse::setAcceleration(bool enabled)
{
m_inputDummydevice->setPointerAccelerationProfileFlat(enabled);
m_inputDummydevice->applyConfig();
}
bool Mouse::naturalScroll() const
{
return m_inputDummydevice->isNaturalScroll();
}
void Mouse::setNaturalScroll(bool enabled)
{
m_inputDummydevice->setNaturalScroll(enabled);
m_inputDummydevice->applyConfig();
}
qreal Mouse::pointerAcceleration() const
{
return m_inputDummydevice->pointerAcceleration();
}
void Mouse::setPointerAcceleration(qreal value)
{
m_inputDummydevice->setPointerAcceleration(value);
m_inputDummydevice->applyConfig();
}

60
settings-daemon/mouse/mousemanager.h
Unescape Escape View File

@ -0,0 +1,60 @@
/*
* Copyright (C) 2021 CutefishOS Team.
*
* Author: Reion Wong <reionwong@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef MOUSE_H
#define MOUSE_H
#include <QObject>
#include "x11libinputdummydevice.h"
class Mouse : public QObject
{
Q_OBJECT
Q_PROPERTY(bool leftHanded READ leftHanded WRITE setLeftHanded NOTIFY leftHandedChanged)
Q_PROPERTY(bool acceleration READ acceleration WRITE setAcceleration NOTIFY accelerationChanged)
Q_PROPERTY(bool naturalScroll READ naturalScroll WRITE setNaturalScroll NOTIFY naturalScrollChanged)
Q_PROPERTY(qreal pointerAcceleration READ pointerAcceleration WRITE setPointerAcceleration NOTIFY pointerAccelerationChanged)
public:
explicit Mouse(QObject *parent = nullptr);
~Mouse();
bool leftHanded() const;
void setLeftHanded(bool enabled);
bool acceleration() const;
void setAcceleration(bool enabled);
bool naturalScroll() const;
void setNaturalScroll(bool enabled);
qreal pointerAcceleration() const;
void setPointerAcceleration(qreal value);
signals:
void leftHandedChanged();
void accelerationChanged();
void naturalScrollChanged();
void pointerAccelerationChanged();
private:
X11LibinputDummyDevice *m_inputDummydevice;
};
#endif // MOUSE_H

16
settings-daemon/mouse/org.cutefish.Mouse.xml
Unescape Escape View File

@ -0,0 +1,16 @@
<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node>
<interface name="org.cutefish.Mouse">
<method name="setLeftHanded"><arg name="value" type="b" direction="in"/></method>
<property name="leftHanded" type="b" access="read"/>
<signal name="leftHandedChanged"></signal>
<method name="setPointerAcceleration"><arg name="value" type="d" direction="in"/></method>
<property name="pointerAcceleration" type="d" access="read"/>
<signal name="pointerAccelerationChanged"></signal>
<method name="setNaturalScroll"><arg name="value" type="b" direction="in"/></method>
<property name="naturalScroll" type="b" access="read"/>
<signal name="naturalScrollChanged"></signal>
</interface>
</node>

242
settings-daemon/mouse/x11libinputdummydevice.cpp
Unescape Escape View File

@ -0,0 +1,242 @@
/*
SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "x11libinputdummydevice.h"
#include "libinputsettings.h"
#include <QDebug>
#include <libinput-properties.h>
#include <X11/Xatom.h>
#include <X11/extensions/XInput.h>
#include <X11/extensions/XInput2.h>
static Atom s_touchpadAtom;
template<typename Callback>
static void XIForallPointerDevices(Display *dpy, const Callback &callback)
{
int ndevices_return;
XDeviceInfo *info = XListInputDevices(dpy, &ndevices_return);
if (!info) {
return;
}
for (int i = 0; i < ndevices_return; ++i) {
XDeviceInfo *dev = info + i;
if ((dev->use == IsXPointer || dev->use == IsXExtensionPointer) && dev->type != s_touchpadAtom) {
callback(dev);
}
}
XFreeDeviceList(info);
}
struct ScopedXDeleter {
static inline void cleanup(void *pointer)
{
if (pointer) {
XFree(pointer);
}
}
};
namespace
{
template<typename T>
void valueWriterPart(T val, Atom valAtom, Display *dpy)
{
Q_UNUSED(val);
Q_UNUSED(valAtom);
Q_UNUSED(dpy);
}
template<>
void valueWriterPart<bool>(bool val, Atom valAtom, Display *dpy)
{
XIForallPointerDevices(dpy, [&](XDeviceInfo *info) {
int deviceid = info->id;
Status status;
Atom type_return;
int format_return;
unsigned long num_items_return;
unsigned long bytes_after_return;
unsigned char *_data = nullptr;
// data returned is an 1 byte boolean
status = XIGetProperty(dpy, deviceid, valAtom, 0, 1, False, XA_INTEGER, &type_return, &format_return, &num_items_return, &bytes_after_return, &_data);
if (status != Success) {
return;
}
QScopedArrayPointer<unsigned char, ScopedXDeleter> data(_data);
_data = nullptr;
if (type_return != XA_INTEGER || !data || format_return != 8) {
return;
}
unsigned char sendVal[2] = {0};
if (num_items_return == 1) {
sendVal[0] = val;
} else {
// Special case for acceleration profile.
const Atom accel = XInternAtom(dpy, LIBINPUT_PROP_ACCEL_PROFILE_ENABLED, True);
if (num_items_return != 2 || valAtom != accel) {
return;
}
sendVal[val] = 1;
}
XIChangeProperty(dpy, deviceid, valAtom, XA_INTEGER, 8, XIPropModeReplace, sendVal, num_items_return);
});
}
template<>
void valueWriterPart<qreal>(qreal val, Atom valAtom, Display *dpy)
{
XIForallPointerDevices(dpy, [&](XDeviceInfo *info) {
int deviceid = info->id;
Status status;
Atom float_type = XInternAtom(dpy, "FLOAT", False);
Atom type_return;
int format_return;
unsigned long num_items_return;
unsigned long bytes_after_return;
unsigned char *_data = nullptr;
// data returned is an 1 byte boolean
status = XIGetProperty(dpy, deviceid, valAtom, 0, 1, False, float_type, &type_return, &format_return, &num_items_return, &bytes_after_return, &_data);
if (status != Success) {
return;
}
QScopedArrayPointer<unsigned char, ScopedXDeleter> data(_data);
_data = nullptr;
if (type_return != float_type || !data || format_return != 32 || num_items_return != 1) {
return;
}
unsigned char buffer[4096];
float *sendPtr = (float *)buffer;
*sendPtr = val;
XIChangeProperty(dpy, deviceid, valAtom, float_type, format_return, XIPropModeReplace, buffer, 1);
});
}
}
X11LibinputDummyDevice::X11LibinputDummyDevice(QObject *parent, Display *dpy)
: QObject(parent)
, m_settings(new LibinputSettings())
, m_dpy(dpy)
{
m_leftHanded.atom = XInternAtom(dpy, LIBINPUT_PROP_LEFT_HANDED, True);
m_middleEmulation.atom = XInternAtom(dpy, LIBINPUT_PROP_MIDDLE_EMULATION_ENABLED, True);
m_naturalScroll.atom = XInternAtom(dpy, LIBINPUT_PROP_NATURAL_SCROLL, True);
m_pointerAcceleration.atom = XInternAtom(dpy, LIBINPUT_PROP_ACCEL, True);
m_pointerAccelerationProfileFlat.atom = XInternAtom(dpy, LIBINPUT_PROP_ACCEL_PROFILE_ENABLED, True);
m_supportsDisableEvents.val = false;
m_enabled.val = true;
m_supportedButtons.val = Qt::LeftButton | Qt::MiddleButton | Qt::RightButton;
m_supportsLeftHanded.val = true;
m_supportsMiddleEmulation.val = true;
m_middleEmulationEnabledByDefault.val = false;
m_supportsPointerAcceleration.val = true;
m_defaultPointerAcceleration.val = 0;
m_supportsPointerAccelerationProfileAdaptive.val = true;
m_supportsPointerAccelerationProfileFlat.val = true;
m_defaultPointerAccelerationProfileAdaptive.val = true;
m_defaultPointerAccelerationProfileFlat.val = false;
m_supportsNaturalScroll.val = true;
m_naturalScrollEnabledByDefault.val = false;
s_touchpadAtom = XInternAtom(m_dpy, XI_TOUCHPAD, True);
// Init
getConfig();
applyConfig();
}
X11LibinputDummyDevice::~X11LibinputDummyDevice()
{
delete m_settings;
}
bool X11LibinputDummyDevice::getConfig()
{
auto reset = [this](Prop<bool> &prop, bool defVal) {
prop.reset(m_settings->load(prop.cfgName, defVal));
};
reset(m_leftHanded, false);
reset(m_middleEmulation, false);
reset(m_naturalScroll, false);
reset(m_pointerAccelerationProfileFlat, false);
m_pointerAccelerationProfileAdaptive.reset(!m_settings->load(m_pointerAccelerationProfileFlat.cfgName, false));
m_pointerAcceleration.reset(m_settings->load(m_pointerAcceleration.cfgName, 0.));
emit leftHandedChanged();
emit naturalScrollChanged();
emit pointerAccelerationProfileChanged();
emit pointerAccelerationChanged();
return true;
}
bool X11LibinputDummyDevice::getDefaultConfig()
{
m_leftHanded.set(false);
m_pointerAcceleration.set(m_defaultPointerAcceleration);
m_pointerAccelerationProfileFlat.set(m_defaultPointerAccelerationProfileFlat);
m_pointerAccelerationProfileAdaptive.set(m_defaultPointerAccelerationProfileAdaptive);
m_middleEmulation.set(m_middleEmulationEnabledByDefault);
m_naturalScroll.set(m_naturalScrollEnabledByDefault);
return true;
}
bool X11LibinputDummyDevice::applyConfig()
{
valueWriter(m_leftHanded);
valueWriter(m_middleEmulation);
valueWriter(m_naturalScroll);
valueWriter(m_pointerAcceleration);
valueWriter(m_pointerAccelerationProfileFlat);
return true;
}
template<typename T>
bool X11LibinputDummyDevice::valueWriter(Prop<T> &prop)
{
// Check atom availability first.
if (prop.atom == None) {
return false;
}
if (prop.val != prop.old) {
m_settings->save(prop.cfgName, prop.val);
}
valueWriterPart(prop.val, prop.atom, m_dpy);
prop.old = prop.val;
return true;
}
bool X11LibinputDummyDevice::isChangedConfig() const
{
return m_leftHanded.changed() || m_pointerAcceleration.changed() || m_pointerAccelerationProfileFlat.changed()
|| m_pointerAccelerationProfileAdaptive.changed() || m_middleEmulation.changed() || m_naturalScroll.changed();
}

297
settings-daemon/mouse/x11libinputdummydevice.h
Unescape Escape View File

@ -0,0 +1,297 @@
/*
SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#ifndef X11LIBINPUTDUMMYDEVICE_H
#define X11LIBINPUTDUMMYDEVICE_H
#include <QObject>
#include <QString>
#include <QX11Info>
#include <X11/Xdefs.h>
struct LibinputSettings;
class X11LibinputDummyDevice : public QObject
{
Q_OBJECT
//
// general
Q_PROPERTY(QString name READ name CONSTANT)
Q_PROPERTY(bool supportsDisableEvents READ supportsDisableEvents CONSTANT)
Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
//
// advanced
Q_PROPERTY(Qt::MouseButtons supportedButtons READ supportedButtons CONSTANT)
Q_PROPERTY(bool supportsLeftHanded READ supportsLeftHanded CONSTANT)
Q_PROPERTY(bool leftHandedEnabledByDefault READ leftHandedEnabledByDefault CONSTANT)
Q_PROPERTY(bool leftHanded READ isLeftHanded WRITE setLeftHanded NOTIFY leftHandedChanged)
Q_PROPERTY(bool supportsMiddleEmulation READ supportsMiddleEmulation CONSTANT)
Q_PROPERTY(bool middleEmulationEnabledByDefault READ middleEmulationEnabledByDefault CONSTANT)
Q_PROPERTY(bool middleEmulation READ isMiddleEmulation WRITE setMiddleEmulation NOTIFY middleEmulationChanged)
//
// acceleration speed and profile
Q_PROPERTY(bool supportsPointerAcceleration READ supportsPointerAcceleration CONSTANT)
Q_PROPERTY(qreal pointerAcceleration READ pointerAcceleration WRITE setPointerAcceleration NOTIFY pointerAccelerationChanged)
Q_PROPERTY(bool supportsPointerAccelerationProfileFlat READ supportsPointerAccelerationProfileFlat CONSTANT)
Q_PROPERTY(bool defaultPointerAccelerationProfileFlat READ defaultPointerAccelerationProfileFlat CONSTANT)
Q_PROPERTY(bool pointerAccelerationProfileFlat READ pointerAccelerationProfileFlat WRITE setPointerAccelerationProfileFlat NOTIFY
pointerAccelerationProfileChanged)
Q_PROPERTY(bool supportsPointerAccelerationProfileAdaptive READ supportsPointerAccelerationProfileAdaptive CONSTANT)
Q_PROPERTY(bool defaultPointerAccelerationProfileAdaptive READ defaultPointerAccelerationProfileAdaptive CONSTANT)
Q_PROPERTY(bool pointerAccelerationProfileAdaptive READ pointerAccelerationProfileAdaptive WRITE setPointerAccelerationProfileAdaptive NOTIFY
pointerAccelerationProfileChanged)
//
// scrolling
Q_PROPERTY(bool supportsNaturalScroll READ supportsNaturalScroll CONSTANT)
Q_PROPERTY(bool naturalScrollEnabledByDefault READ naturalScrollEnabledByDefault CONSTANT)
Q_PROPERTY(bool naturalScroll READ isNaturalScroll WRITE setNaturalScroll NOTIFY naturalScrollChanged)
public:
X11LibinputDummyDevice(QObject *parent, Display *dpy);
~X11LibinputDummyDevice() override;
bool getConfig();
bool getDefaultConfig();
bool applyConfig();
bool isChangedConfig() const;
//
// general
QString name() const
{
return m_name.val;
}
QString sysName() const
{
return m_sysName.val;
}
bool supportsDisableEvents() const
{
return m_supportsDisableEvents.val;
}
void setEnabled(bool enabled)
{
m_enabled.set(enabled);
}
bool isEnabled() const
{
return m_enabled.val;
}
Qt::MouseButtons supportedButtons() const
{
return m_supportedButtons.val;
}
//
// advanced
bool supportsLeftHanded() const
{
return m_supportsLeftHanded.val;
}
bool leftHandedEnabledByDefault() const
{
return m_leftHandedEnabledByDefault.val;
}
bool isLeftHanded() const
{
return m_leftHanded.val;
}
void setLeftHanded(bool set)
{
m_leftHanded.set(set);
}
bool supportsMiddleEmulation() const
{
return m_supportsMiddleEmulation.val;
}
bool middleEmulationEnabledByDefault() const
{
return m_middleEmulationEnabledByDefault.val;
}
bool isMiddleEmulation() const
{
return m_middleEmulation.val;
}
void setMiddleEmulation(bool set)
{
m_middleEmulation.set(set);
}
//
// acceleration speed and profile
bool supportsPointerAcceleration() const
{
return m_supportsPointerAcceleration.val;
}
qreal pointerAcceleration() const
{
return m_pointerAcceleration.val;
}
void setPointerAcceleration(qreal acceleration)
{
m_pointerAcceleration.set(acceleration);
}
bool supportsPointerAccelerationProfileFlat() const
{
return m_supportsPointerAccelerationProfileFlat.val;
}
bool defaultPointerAccelerationProfileFlat() const
{
return m_defaultPointerAccelerationProfileFlat.val;
}
bool pointerAccelerationProfileFlat() const
{
return m_pointerAccelerationProfileFlat.val;
}
void setPointerAccelerationProfileFlat(bool set)
{
m_pointerAccelerationProfileFlat.set(set);
}
bool supportsPointerAccelerationProfileAdaptive() const
{
return m_supportsPointerAccelerationProfileAdaptive.val;
}
bool defaultPointerAccelerationProfileAdaptive() const
{
return m_defaultPointerAccelerationProfileAdaptive.val;
}
bool pointerAccelerationProfileAdaptive() const
{
return m_pointerAccelerationProfileAdaptive.val;
}
void setPointerAccelerationProfileAdaptive(bool set)
{
m_pointerAccelerationProfileAdaptive.set(set);
}
//
// scrolling
bool supportsNaturalScroll() const
{
return m_supportsNaturalScroll.val;
}
bool naturalScrollEnabledByDefault() const
{
return m_naturalScrollEnabledByDefault.val;
}
bool isNaturalScroll() const
{
return m_naturalScroll.val;
}
void setNaturalScroll(bool set)
{
m_naturalScroll.set(set);
}
Q_SIGNALS:
void leftHandedChanged();
void pointerAccelerationChanged();
void pointerAccelerationProfileChanged();
void enabledChanged();
void middleEmulationChanged();
void naturalScrollChanged();
private:
template<typename T>
struct Prop {
explicit Prop(const QString &_name, const QString &_cfgName = "")
: name(_name)
, cfgName(_cfgName)
{
}
void set(T newVal)
{
if (avail && val != newVal) {
val = newVal;
}
}
void set(const Prop<T> &p)
{
if (avail && val != p.val) {
val = p.val;
}
}
bool changed() const
{
return avail && (old != val);
}
void reset(T newVal)
{
val = newVal;
old = newVal;
}
QString name;
QString cfgName;
bool avail = true;
T old;
T val;
Atom atom;
};
template<typename T>
bool valueWriter(Prop<T> &prop);
//
// general
Prop<QString> m_name = Prop<QString>("name");
Prop<QString> m_sysName = Prop<QString>("sysName");
Prop<bool> m_supportsDisableEvents = Prop<bool>("supportsDisableEvents");
Prop<bool> m_enabled = Prop<bool>("enabled");
//
// advanced
Prop<Qt::MouseButtons> m_supportedButtons = Prop<Qt::MouseButtons>("supportedButtons");
Prop<bool> m_supportsLeftHanded = Prop<bool>("supportsLeftHanded");
Prop<bool> m_leftHandedEnabledByDefault = Prop<bool>("leftHandedEnabledByDefault");
Prop<bool> m_leftHanded = Prop<bool>("leftHanded", "XLbInptLeftHanded");
Prop<bool> m_supportsMiddleEmulation = Prop<bool>("supportsMiddleEmulation");
Prop<bool> m_middleEmulationEnabledByDefault = Prop<bool>("middleEmulationEnabledByDefault");
Prop<bool> m_middleEmulation = Prop<bool>("middleEmulation", "XLbInptMiddleEmulation");
//
// acceleration speed and profile
Prop<bool> m_supportsPointerAcceleration = Prop<bool>("supportsPointerAcceleration");
Prop<qreal> m_defaultPointerAcceleration = Prop<qreal>("defaultPointerAcceleration");
Prop<qreal> m_pointerAcceleration = Prop<qreal>("pointerAcceleration", "XLbInptPointerAcceleration");
Prop<bool> m_supportsPointerAccelerationProfileFlat = Prop<bool>("supportsPointerAccelerationProfileFlat");
Prop<bool> m_defaultPointerAccelerationProfileFlat = Prop<bool>("defaultPointerAccelerationProfileFlat");
Prop<bool> m_pointerAccelerationProfileFlat = Prop<bool>("pointerAccelerationProfileFlat", "XLbInptAccelProfileFlat");
Prop<bool> m_supportsPointerAccelerationProfileAdaptive = Prop<bool>("supportsPointerAccelerationProfileAdaptive");
Prop<bool> m_defaultPointerAccelerationProfileAdaptive = Prop<bool>("defaultPointerAccelerationProfileAdaptive");
Prop<bool> m_pointerAccelerationProfileAdaptive = Prop<bool>("pointerAccelerationProfileAdaptive");
//
// scrolling
Prop<bool> m_supportsNaturalScroll = Prop<bool>("supportsNaturalScroll");
Prop<bool> m_naturalScrollEnabledByDefault = Prop<bool>("naturalScrollEnabledByDefault");
Prop<bool> m_naturalScroll = Prop<bool>("naturalScroll", "XLbInptNaturalScroll");
LibinputSettings *m_settings;
Display *m_dpy = nullptr;
};
#endif // X11LIBINPUTDUMMYDEVICE_H
Write Preview
Loading…
Cancel
Save