diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..df663b0 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/libinput-1.16.3.tar.xz diff --git a/0001-Revert-tools-switch-measure-touchpad-tap-to-python-l.patch b/0001-Revert-tools-switch-measure-touchpad-tap-to-python-l.patch new file mode 100644 index 0000000..14cf796 --- /dev/null +++ b/0001-Revert-tools-switch-measure-touchpad-tap-to-python-l.patch @@ -0,0 +1,100 @@ +From 207c40c49d81edee5dae15fa519704ffad6fbb40 Mon Sep 17 00:00:00 2001 +From: Peter Hutterer +Date: Tue, 3 Nov 2020 15:14:29 +1000 +Subject: [PATCH libinput 1/4] Revert "tools: switch measure-touchpad-tap to + python-libevdev" + +This reverts commit 274b80d06cd0fb51911fae9252c7a800c5f6af94. +--- + tools/libinput-measure-touchpad-tap.py | 39 ++++++++++++++++---------- + 1 file changed, 24 insertions(+), 15 deletions(-) + +diff --git a/tools/libinput-measure-touchpad-tap.py b/tools/libinput-measure-touchpad-tap.py +index b42b78e3..e1b82d9d 100755 +--- a/tools/libinput-measure-touchpad-tap.py ++++ b/tools/libinput-measure-touchpad-tap.py +@@ -27,7 +27,8 @@ + import sys + import argparse + try: +- import libevdev ++ import evdev ++ import evdev.ecodes + import textwrap + import pyudev + except ModuleNotFoundError as e: +@@ -82,18 +83,27 @@ class InvalidDeviceError(Exception): + pass + + +-class Device(libevdev.Device): ++class Device(object): + def __init__(self, path): + if path is None: + self.path = self._find_touch_device() + else: + self.path = path +- fd = open(self.path, 'rb') +- super().__init__(fd) + +- print("Using {}: {}\n".format(self.name, self.path)) ++ self.device = evdev.InputDevice(self.path) + +- if not self.has(libevdev.EV_KEY.BTN_TOUCH): ++ print("Using {}: {}\n".format(self.device.name, self.path)) ++ ++ # capabilities returns a dict with the EV_* codes as key, ++ # each of which is a list of tuples of (code, AbsInfo) ++ # ++ # Get the abs list first (or empty list if missing), ++ # then extract the pressure absinfo from that ++ codes = self.device.capabilities(absinfo=True).get( ++ evdev.ecodes.EV_KEY, [] ++ ) ++ ++ if evdev.ecodes.BTN_TOUCH not in codes: + raise InvalidDeviceError("device does not have BTN_TOUCH") + + self.touches = [] +@@ -131,16 +141,16 @@ class Device(libevdev.Device): + end='') + + def handle_key(self, event): +- tapcodes = [libevdev.EV_KEY.BTN_TOOL_DOUBLETAP, +- libevdev.EV_KEY.BTN_TOOL_TRIPLETAP, +- libevdev.EV_KEY.BTN_TOOL_QUADTAP, +- libevdev.EV_KEY.BTN_TOOL_QUINTTAP] ++ tapcodes = [evdev.ecodes.BTN_TOOL_DOUBLETAP, ++ evdev.ecodes.BTN_TOOL_TRIPLETAP, ++ evdev.ecodes.BTN_TOOL_QUADTAP, ++ evdev.ecodes.BTN_TOOL_QUINTTAP] + if event.code in tapcodes and event.value > 0: + error("\rThis tool cannot handle multiple fingers, " + "output will be invalid") + return + +- if event.matches(libevdev.EV_KEY.BTN_TOUCH): ++ if event.code == evdev.ecodes.BTN_TOUCH: + self.handle_btn_touch(event) + + def handle_syn(self, event): +@@ -151,13 +161,12 @@ class Device(libevdev.Device): + orientation=self.touch.orientation) + + def handle_event(self, event): +- if event.matches(libevdev.EV_KEY): ++ if event.type == evdev.ecodes.EV_KEY: + self.handle_key(event) + + def read_events(self): +- while True: +- for event in self.events(): +- self.handle_event(event) ++ for event in self.device.read_loop(): ++ self.handle_event(event) + + def print_summary(self): + deltas = sorted(t.tdelta for t in self.touches) +-- +2.28.0 + diff --git a/0001-evdev-quirks_get_tuples-can-deal-with-a-NULL-quirks.patch b/0001-evdev-quirks_get_tuples-can-deal-with-a-NULL-quirks.patch new file mode 100644 index 0000000..c89d114 --- /dev/null +++ b/0001-evdev-quirks_get_tuples-can-deal-with-a-NULL-quirks.patch @@ -0,0 +1,36 @@ +From f8a01c184ab00b048fd5413214a3d8620fe0b060 Mon Sep 17 00:00:00 2001 +From: Peter Hutterer +Date: Fri, 23 Oct 2020 12:53:35 +1000 +Subject: [PATCH libinput 1/5] evdev: quirks_get_tuples can deal with a NULL + quirks + +Signed-off-by: Peter Hutterer +(cherry picked from commit fa0c3ee38838be11a9e50cc51e4a5d42cc394b44) +--- + src/evdev.c | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +diff --git a/src/evdev.c b/src/evdev.c +index 40f0726b..e6a00199 100644 +--- a/src/evdev.c ++++ b/src/evdev.c +@@ -2083,7 +2083,7 @@ evdev_pre_configure_model_quirks(struct evdev_device *device) + libevdev_disable_event_code(device->evdev, EV_MSC, MSC_TIMESTAMP); + } + +- if (q && quirks_get_tuples(q, QUIRK_ATTR_EVENT_CODE_DISABLE, &t)) { ++ if (quirks_get_tuples(q, QUIRK_ATTR_EVENT_CODE_DISABLE, &t)) { + int type, code; + + for (size_t i = 0; i < t->ntuples; i++) { +@@ -2107,7 +2107,6 @@ evdev_pre_configure_model_quirks(struct evdev_device *device) + } + + quirks_unref(q); +- + } + + static void +-- +2.31.1 + diff --git a/0002-Revert-tools-switch-measure-touchpad-pressure-to-pyt.patch b/0002-Revert-tools-switch-measure-touchpad-pressure-to-pyt.patch new file mode 100644 index 0000000..68fdcb6 --- /dev/null +++ b/0002-Revert-tools-switch-measure-touchpad-pressure-to-pyt.patch @@ -0,0 +1,145 @@ +From 0e35c5baa7d0d0c15661a9f870ad5e58f06341b7 Mon Sep 17 00:00:00 2001 +From: Peter Hutterer +Date: Tue, 3 Nov 2020 15:22:53 +1000 +Subject: [PATCH libinput 2/4] Revert "tools: switch measure-touchpad-pressure + to python-libevdev" + +This reverts commit 33afe9f8756196e5a4df5fff33cb1344d5b6bc53. + +Signed-off-by: Peter Hutterer +--- + tools/libinput-measure-touchpad-pressure.py | 62 ++++++++++++--------- + 1 file changed, 35 insertions(+), 27 deletions(-) + +diff --git a/tools/libinput-measure-touchpad-pressure.py b/tools/libinput-measure-touchpad-pressure.py +index a55bad0c..df958e4d 100755 +--- a/tools/libinput-measure-touchpad-pressure.py ++++ b/tools/libinput-measure-touchpad-pressure.py +@@ -28,7 +28,8 @@ import sys + import subprocess + import argparse + try: +- import libevdev ++ import evdev ++ import evdev.ecodes + import pyudev + except ModuleNotFoundError as e: + print('Error: {}'.format(str(e)), file=sys.stderr) +@@ -177,33 +178,41 @@ class InvalidDeviceError(Exception): + pass + + +-class Device(libevdev.Device): ++class Device(object): + def __init__(self, path): + if path is None: + self.path = self.find_touchpad_device() + else: + self.path = path + +- fd = open(self.path, 'rb') +- super().__init__(fd) ++ self.device = evdev.InputDevice(self.path) + +- print("Using {}: {}\n".format(self.name, self.path)) ++ print("Using {}: {}\n".format(self.device.name, self.path)) + +- self.has_mt_pressure = True +- absinfo = self.absinfo[libevdev.EV_ABS.ABS_MT_PRESSURE] +- if absinfo is None: +- absinfo = self.absinfo[libevdev.EV_ABS.ABS_PRESSURE] +- self.has_mt_pressure = False +- if absinfo is None: ++ # capabilities rturns a dict with the EV_* codes as key, ++ # each of which is a list of tuples of (code, AbsInfo) ++ # ++ # Get the abs list first (or empty list if missing), ++ # then extract the pressure absinfo from that ++ all_caps = self.device.capabilities(absinfo=True) ++ caps = all_caps.get(evdev.ecodes.EV_ABS, []) ++ p = [cap[1] for cap in caps if cap[0] == evdev.ecodes.ABS_MT_PRESSURE] ++ if not p: ++ p = [cap[1] for cap in caps if cap[0] == evdev.ecodes.ABS_PRESSURE] ++ if not p: + raise InvalidDeviceError("Device does not have ABS_PRESSURE or ABS_MT_PRESSURE") ++ self.has_mt_pressure = False ++ else: ++ self.has_mt_pressure = True + +- prange = absinfo.maximum - absinfo.minimum ++ p = p[0] ++ prange = p.max - p.min + + # libinput defaults +- self.down = int(absinfo.minimum + 0.12 * prange) +- self.up = int(absinfo.minimum + 0.10 * prange) ++ self.down = int(p.min + 0.12 * prange) ++ self.up = int(p.min + 0.10 * prange) + self.palm = 130 # the libinput default +- self.thumb = absinfo.maximum ++ self.thumb = p.max + + self._init_thresholds_from_quirks() + self.sequences = [] +@@ -249,10 +258,10 @@ class Device(libevdev.Device): + + def handle_key(device, event): + tapcodes = [ +- libevdev.EV_KEY.BTN_TOOL_DOUBLETAP, +- libevdev.EV_KEY.BTN_TOOL_TRIPLETAP, +- libevdev.EV_KEY.BTN_TOOL_QUADTAP, +- libevdev.EV_KEY.BTN_TOOL_QUINTTAP ++ evdev.ecodes.BTN_TOOL_DOUBLETAP, ++ evdev.ecodes.BTN_TOOL_TRIPLETAP, ++ evdev.ecodes.BTN_TOOL_QUADTAP, ++ evdev.ecodes.BTN_TOOL_QUINTTAP + ] + if event.code in tapcodes and event.value > 0: + print('\r\033[2KThis tool cannot handle multiple fingers, ' +@@ -260,7 +269,7 @@ def handle_key(device, event): + + + def handle_abs(device, event): +- if event.matches(libevdev.EV_ABS.ABS_MT_TRACKING_ID): ++ if event.code == evdev.ecodes.ABS_MT_TRACKING_ID: + if event.value > -1: + device.start_new_sequence(event.value) + else: +@@ -271,8 +280,8 @@ def handle_abs(device, event): + except IndexError: + # If the finger was down at startup + pass +- elif (event.matches(libevdev.EV_ABS.ABS_MT_PRESSURE) or +- (event.matches(libevdev.EV_ABS.ABS_PRESSURE) and not device.has_mt_pressure)): ++ elif ((event.code == evdev.ecodes.ABS_MT_PRESSURE) or ++ (event.code == evdev.ecodes.ABS_PRESSURE and not device.has_mt_pressure)): + try: + s = device.current_sequence() + s.append(Touch(pressure=event.value)) +@@ -283,9 +292,9 @@ def handle_abs(device, event): + + + def handle_event(device, event): +- if event.matches(libevdev.EV_ABS): ++ if event.type == evdev.ecodes.EV_ABS: + handle_abs(device, event) +- elif event.matches(libevdev.EV_KEY): ++ elif event.type == evdev.ecodes.EV_KEY: + handle_key(device, event) + + +@@ -312,9 +321,8 @@ def loop(device): + print(headers) + print(fmt.separator()) + +- while True: +- for event in device.events(): +- handle_event(device, event) ++ for event in device.device.read_loop(): ++ handle_event(device, event) + + + def colon_tuple(string): +-- +2.28.0 + diff --git a/0002-evdev-localize-two-variables-during-quirks-handling.patch b/0002-evdev-localize-two-variables-during-quirks-handling.patch new file mode 100644 index 0000000..8498e2f --- /dev/null +++ b/0002-evdev-localize-two-variables-during-quirks-handling.patch @@ -0,0 +1,33 @@ +From 7a69cf4c04c86d1699d82486ca84d1892ad65e07 Mon Sep 17 00:00:00 2001 +From: Peter Hutterer +Date: Fri, 23 Oct 2020 12:54:54 +1000 +Subject: [PATCH libinput 2/5] evdev: localize two variables during quirks + handling + +Signed-off-by: Peter Hutterer +(cherry picked from commit 30502dee1e925c270429669c4acd293645c3cba3) +--- + src/evdev.c | 6 ++---- + 1 file changed, 2 insertions(+), 4 deletions(-) + +diff --git a/src/evdev.c b/src/evdev.c +index e6a00199..2f6c7447 100644 +--- a/src/evdev.c ++++ b/src/evdev.c +@@ -2084,11 +2084,9 @@ evdev_pre_configure_model_quirks(struct evdev_device *device) + } + + if (quirks_get_tuples(q, QUIRK_ATTR_EVENT_CODE_DISABLE, &t)) { +- int type, code; +- + for (size_t i = 0; i < t->ntuples; i++) { +- type = t->tuples[i].first; +- code = t->tuples[i].second; ++ int type = t->tuples[i].first; ++ int code = t->tuples[i].second; + + if (code == EVENT_CODE_UNDEFINED) + libevdev_disable_event_type(device->evdev, +-- +2.31.1 + diff --git a/0003-Revert-tools-switch-measure-touch-size-to-python-lib.patch b/0003-Revert-tools-switch-measure-touch-size-to-python-lib.patch new file mode 100644 index 0000000..705f159 --- /dev/null +++ b/0003-Revert-tools-switch-measure-touch-size-to-python-lib.patch @@ -0,0 +1,149 @@ +From bf1dea1a8e516dd0372c2e7e3c818a05f3777a89 Mon Sep 17 00:00:00 2001 +From: Peter Hutterer +Date: Tue, 3 Nov 2020 15:24:23 +1000 +Subject: [PATCH libinput 3/4] Revert "tools: switch measure-touch-size to + python-libevdev" + +This reverts commit deb759a0699a0ad18a9fa3dda8f1b397e34ae537. +--- + tools/libinput-measure-touch-size.py | 79 ++++++++++++++++------------ + 1 file changed, 44 insertions(+), 35 deletions(-) + +diff --git a/tools/libinput-measure-touch-size.py b/tools/libinput-measure-touch-size.py +index 5d98bc28..f974df43 100755 +--- a/tools/libinput-measure-touch-size.py ++++ b/tools/libinput-measure-touch-size.py +@@ -28,7 +28,8 @@ import sys + import subprocess + import argparse + try: +- import libevdev ++ import evdev ++ import evdev.ecodes + import pyudev + except ModuleNotFoundError as e: + print('Error: {}'.format(str(e)), file=sys.stderr) +@@ -171,23 +172,32 @@ class InvalidDeviceError(Exception): + pass + + +-class Device(libevdev.Device): ++class Device(object): + def __init__(self, path): + if path is None: + self.path = self.find_touch_device() + else: + self.path = path + +- fd = open(self.path, 'rb') +- super().__init__(fd) ++ self.device = evdev.InputDevice(self.path) + +- print("Using {}: {}\n".format(self.name, self.path)) ++ print("Using {}: {}\n".format(self.device.name, self.path)) + +- if not self.has(libevdev.EV_ABS.ABS_MT_TOUCH_MAJOR): ++ # capabilities returns a dict with the EV_* codes as key, ++ # each of which is a list of tuples of (code, AbsInfo) ++ # ++ # Get the abs list first (or empty list if missing), ++ # then extract the touch major absinfo from that ++ caps = self.device.capabilities(absinfo=True).get( ++ evdev.ecodes.EV_ABS, [] ++ ) ++ codes = [cap[0] for cap in caps] ++ ++ if evdev.ecodes.ABS_MT_TOUCH_MAJOR not in codes: + raise InvalidDeviceError("Device does not have ABS_MT_TOUCH_MAJOR") + +- self.has_minor = self.has(libevdev.EV_ABS.ABS_MT_TOUCH_MINOR) +- self.has_orientation = self.has(libevdev.EV_ABS.ABS_MT_ORIENTATION) ++ self.has_minor = evdev.ecodes.ABS_MT_TOUCH_MINOR in codes ++ self.has_orientation = evdev.ecodes.ABS_MT_ORIENTATION in codes + + self.up = 0 + self.down = 0 +@@ -239,32 +249,32 @@ class Device(libevdev.Device): + return self.sequences[-1] + + def handle_key(self, event): +- tapcodes = [libevdev.EV_KEY.BTN_TOOL_DOUBLETAP, +- libevdev.EV_KEY.BTN_TOOL_TRIPLETAP, +- libevdev.EV_KEY.BTN_TOOL_QUADTAP, +- libevdev.EV_KEY.BTN_TOOL_QUINTTAP] ++ tapcodes = [evdev.ecodes.BTN_TOOL_DOUBLETAP, ++ evdev.ecodes.BTN_TOOL_TRIPLETAP, ++ evdev.ecodes.BTN_TOOL_QUADTAP, ++ evdev.ecodes.BTN_TOOL_QUINTTAP] + if event.code in tapcodes and event.value > 0: + print("\rThis tool cannot handle multiple fingers, " + "output will be invalid", file=sys.stderr) + + def handle_abs(self, event): +- if event.matches(libevdev.EV_ABS.ABS_MT_TRACKING_ID): +- if event.value > -1: +- self.start_new_sequence(event.value) +- else: +- try: +- s = self.current_sequence() +- s.finalize() +- print("\r{}".format(s)) +- except IndexError: +- # If the finger was down during start +- pass +- elif event.matches(libevdev.EV_ABS.ABS_MT_TOUCH_MAJOR): +- self.touch.major = event.value +- elif event.matches(libevdev.EV_ABS.ABS_MT_TOUCH_MINOR): +- self.touch.minor = event.value +- elif event.matches(libevdev.EV_ABS.ABS_MT_ORIENTATION): +- self.touch.orientation = event.value ++ if event.code == evdev.ecodes.ABS_MT_TRACKING_ID: ++ if event.value > -1: ++ self.start_new_sequence(event.value) ++ else: ++ try: ++ s = self.current_sequence() ++ s.finalize() ++ print("\r{}".format(s)) ++ except IndexError: ++ # If the finger was down during start ++ pass ++ elif event.code == evdev.ecodes.ABS_MT_TOUCH_MAJOR: ++ self.touch.major = event.value ++ elif event.code == evdev.ecodes.ABS_MT_TOUCH_MINOR: ++ self.touch.minor = event.value ++ elif event.code == evdev.ecodes.ABS_MT_ORIENTATION: ++ self.touch.orientation = event.value + + def handle_syn(self, event): + if self.touch.dirty: +@@ -278,11 +288,11 @@ class Device(libevdev.Device): + pass + + def handle_event(self, event): +- if event.matches(libevdev.EV_ABS): ++ if event.type == evdev.ecodes.EV_ABS: + self.handle_abs(event) +- elif event.matches(libevdev.EV_KEY): ++ elif event.type == evdev.ecodes.EV_KEY: + self.handle_key(event) +- elif event.matches(libevdev.EV_SYN): ++ elif event.type == evdev.ecodes.EV_SYN: + self.handle_syn(event) + + def read_events(self): +@@ -293,9 +303,8 @@ class Device(libevdev.Device): + print("Place a single finger on the device to measure touch size.\n" + "Ctrl+C to exit\n") + +- while True: +- for event in self.events(): +- self.handle_event(event) ++ for event in self.device.read_loop(): ++ self.handle_event(event) + + + def colon_tuple(string): +-- +2.28.0 + diff --git a/0003-quirks-add-AttrEventCodeEnable-as-counterpoint-to-th.patch b/0003-quirks-add-AttrEventCodeEnable-as-counterpoint-to-th.patch new file mode 100644 index 0000000..8add7ea --- /dev/null +++ b/0003-quirks-add-AttrEventCodeEnable-as-counterpoint-to-th.patch @@ -0,0 +1,488 @@ +From ec0c4a65e00302c193a36c56a7f2f021c43bf183 Mon Sep 17 00:00:00 2001 +From: Peter Hutterer +Date: Fri, 23 Oct 2020 09:14:33 +1000 +Subject: [PATCH libinput 3/5] quirks: add AttrEventCodeEnable as counterpoint + to the disable one + +Currently unused, but let's get this in because we may need this very soon for +broken tablets. + +Enabling EV_ABS axes requires an absinfo struct - we default to a simple 0-1 +axis range for those as the most generic option. Anything more custom will +need more custom treatment when we need it. + +Signed-off-by: Peter Hutterer +(cherry picked from commit e3c4ff38984dfb4b51c245032c4aff5169d15257) +--- + doc/user/device-quirks.rst | 4 + + meson.build | 1 + + src/evdev.c | 26 ++++ + src/quirks.c | 10 +- + src/quirks.h | 1 + + src/util-strings.h | 12 ++ + test/litest-device-keyboard-quirked.c | 216 ++++++++++++++++++++++++++ + test/litest.h | 1 + + test/test-device.c | 76 +++++++++ + 9 files changed, 345 insertions(+), 2 deletions(-) + create mode 100644 test/litest-device-keyboard-quirked.c + +diff --git a/doc/user/device-quirks.rst b/doc/user/device-quirks.rst +index 0a055a35..21c43e1c 100644 +--- a/doc/user/device-quirks.rst ++++ b/doc/user/device-quirks.rst +@@ -177,6 +177,10 @@ AttrEventCodeDisable=EV_ABS;BTN_STYLUS;EV_KEY:0x123; + Disables the evdev event type/code tuples on the device. Entries may be + a named event type, or a named event code, or a named event type with a + hexadecimal event code, separated by a single colon. ++AttrEventCodeEnable=EV_ABS;BTN_STYLUS;EV_KEY:0x123; ++ Enables the evdev event type/code tuples on the device. Entries may be ++ a named event type, or a named event code, or a named event type with a ++ hexadecimal event code, separated by a single colon. + AttrPointingStickIntegration=internal|external + Indicates the integration of the pointing stick. This is a string enum. + Only needed for external pointing sticks. These are rare. +diff --git a/meson.build b/meson.build +index c9b53a3b..0481fa10 100644 +--- a/meson.build ++++ b/meson.build +@@ -780,6 +780,7 @@ if get_option('tests') + 'test/litest-device-ignored-mouse.c', + 'test/litest-device-keyboard.c', + 'test/litest-device-keyboard-all-codes.c', ++ 'test/litest-device-keyboard-quirked.c', + 'test/litest-device-keyboard-razer-blackwidow.c', + 'test/litest-device-keyboard-razer-blade-stealth.c', + 'test/litest-device-keyboard-razer-blade-stealth-videoswitch.c', +diff --git a/src/evdev.c b/src/evdev.c +index 2f6c7447..4bcd3066 100644 +--- a/src/evdev.c ++++ b/src/evdev.c +@@ -2083,6 +2083,32 @@ evdev_pre_configure_model_quirks(struct evdev_device *device) + libevdev_disable_event_code(device->evdev, EV_MSC, MSC_TIMESTAMP); + } + ++ if (quirks_get_tuples(q, QUIRK_ATTR_EVENT_CODE_ENABLE, &t)) { ++ for (size_t i = 0; i < t->ntuples; i++) { ++ const struct input_absinfo absinfo = { ++ .minimum = 0, ++ .maximum = 1, ++ }; ++ ++ int type = t->tuples[i].first; ++ int code = t->tuples[i].second; ++ ++ if (code == EVENT_CODE_UNDEFINED) ++ libevdev_enable_event_type(device->evdev, type); ++ else ++ libevdev_enable_event_code(device->evdev, ++ type, ++ code, ++ type == EV_ABS ? &absinfo : NULL); ++ evdev_log_debug(device, ++ "quirks: enabling %s %s (%#x %#x)\n", ++ libevdev_event_type_get_name(type), ++ libevdev_event_code_get_name(type, code), ++ type, ++ code); ++ } ++ } ++ + if (quirks_get_tuples(q, QUIRK_ATTR_EVENT_CODE_DISABLE, &t)) { + for (size_t i = 0; i < t->ntuples; i++) { + int type = t->tuples[i].first; +diff --git a/src/quirks.c b/src/quirks.c +index 45d1f554..69f41fde 100644 +--- a/src/quirks.c ++++ b/src/quirks.c +@@ -273,6 +273,7 @@ quirk_get_name(enum quirk q) + case QUIRK_ATTR_THUMB_SIZE_THRESHOLD: return "AttrThumbSizeThreshold"; + case QUIRK_ATTR_MSC_TIMESTAMP: return "AttrMscTimestamp"; + case QUIRK_ATTR_EVENT_CODE_DISABLE: return "AttrEventCodeDisable"; ++ case QUIRK_ATTR_EVENT_CODE_ENABLE: return "AttrEventCodeEnable"; + default: + abort(); + } +@@ -737,10 +738,15 @@ parse_attr(struct quirks_context *ctx, + p->type = PT_STRING; + p->value.s = safe_strdup(value); + rc = true; +- } else if (streq(key, quirk_get_name(QUIRK_ATTR_EVENT_CODE_DISABLE))) { ++ } else if (streq(key, quirk_get_name(QUIRK_ATTR_EVENT_CODE_DISABLE)) || ++ streq(key, quirk_get_name(QUIRK_ATTR_EVENT_CODE_ENABLE))) { + struct input_event events[32]; + size_t nevents = ARRAY_LENGTH(events); +- p->id = QUIRK_ATTR_EVENT_CODE_DISABLE; ++ if (streq(key, quirk_get_name(QUIRK_ATTR_EVENT_CODE_DISABLE))) ++ p->id = QUIRK_ATTR_EVENT_CODE_DISABLE; ++ else ++ p->id = QUIRK_ATTR_EVENT_CODE_ENABLE; ++ + if (!parse_evcode_property(value, events, &nevents) || + nevents == 0) + goto out; +diff --git a/src/quirks.h b/src/quirks.h +index ee85fe3b..0b2fe9f3 100644 +--- a/src/quirks.h ++++ b/src/quirks.h +@@ -109,6 +109,7 @@ enum quirk { + QUIRK_ATTR_THUMB_SIZE_THRESHOLD, + QUIRK_ATTR_MSC_TIMESTAMP, + QUIRK_ATTR_EVENT_CODE_DISABLE, ++ QUIRK_ATTR_EVENT_CODE_ENABLE, + + _QUIRK_LAST_ATTR_QUIRK_, /* Guard: do not modify */ + }; +diff --git a/src/util-strings.h b/src/util-strings.h +index 2c31ff80..80e88aeb 100644 +--- a/src/util-strings.h ++++ b/src/util-strings.h +@@ -111,6 +111,18 @@ xasprintf(char **strp, const char *fmt, ...) + return rc; + } + ++__attribute__ ((format (printf, 2, 0))) ++static inline int ++xvasprintf(char **strp, const char *fmt, va_list args) ++{ ++ int rc = 0; ++ rc = vasprintf(strp, fmt, args); ++ if ((rc == -1) && strp) ++ *strp = NULL; ++ ++ return rc; ++} ++ + static inline bool + safe_atoi_base(const char *str, int *val, int base) + { +diff --git a/test/litest-device-keyboard-quirked.c b/test/litest-device-keyboard-quirked.c +new file mode 100644 +index 00000000..748794b2 +--- /dev/null ++++ b/test/litest-device-keyboard-quirked.c +@@ -0,0 +1,216 @@ ++/* ++ * Copyright © 2013 Red Hat, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the next ++ * paragraph) shall be included in all copies or substantial portions of the ++ * Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING ++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ++ * DEALINGS IN THE SOFTWARE. ++ */ ++ ++#include "config.h" ++ ++#include "litest.h" ++#include "litest-int.h" ++ ++static struct input_id input_id = { ++ .bustype = 0x11, ++ .vendor = 0x1, ++ .product = 0x1, ++}; ++ ++static int events[] = { ++ EV_REL, REL_X, ++ EV_REL, REL_Y, ++ ++ EV_KEY, KEY_ESC, ++ EV_KEY, KEY_1, ++ EV_KEY, KEY_2, ++ EV_KEY, KEY_3, ++ EV_KEY, KEY_4, ++ EV_KEY, KEY_5, ++ EV_KEY, KEY_6, ++ EV_KEY, KEY_7, ++ EV_KEY, KEY_8, ++ EV_KEY, KEY_9, ++ EV_KEY, KEY_0, ++ EV_KEY, KEY_MINUS, ++ EV_KEY, KEY_EQUAL, ++ EV_KEY, KEY_BACKSPACE, ++ EV_KEY, KEY_TAB, ++ EV_KEY, KEY_Q, ++ EV_KEY, KEY_W, ++ EV_KEY, KEY_E, ++ EV_KEY, KEY_R, ++ EV_KEY, KEY_T, ++ EV_KEY, KEY_Y, ++ EV_KEY, KEY_U, ++ EV_KEY, KEY_I, ++ EV_KEY, KEY_O, ++ EV_KEY, KEY_P, ++ EV_KEY, KEY_LEFTBRACE, ++ EV_KEY, KEY_RIGHTBRACE, ++ EV_KEY, KEY_ENTER, ++ EV_KEY, KEY_LEFTCTRL, ++ EV_KEY, KEY_A, ++ EV_KEY, KEY_S, ++ EV_KEY, KEY_D, ++ EV_KEY, KEY_F, ++ EV_KEY, KEY_G, ++ EV_KEY, KEY_H, ++ EV_KEY, KEY_J, ++ EV_KEY, KEY_K, ++ EV_KEY, KEY_L, ++ EV_KEY, KEY_SEMICOLON, ++ EV_KEY, KEY_APOSTROPHE, ++ EV_KEY, KEY_GRAVE, ++ EV_KEY, KEY_LEFTSHIFT, ++ EV_KEY, KEY_BACKSLASH, ++ EV_KEY, KEY_Z, ++ EV_KEY, KEY_X, ++ EV_KEY, KEY_C, ++ EV_KEY, KEY_V, ++ EV_KEY, KEY_B, ++ EV_KEY, KEY_N, ++ EV_KEY, KEY_M, ++ EV_KEY, KEY_COMMA, ++ EV_KEY, KEY_DOT, ++ EV_KEY, KEY_SLASH, ++ EV_KEY, KEY_RIGHTSHIFT, ++ EV_KEY, KEY_KPASTERISK, ++ EV_KEY, KEY_LEFTALT, ++ EV_KEY, KEY_SPACE, ++ EV_KEY, KEY_CAPSLOCK, ++ EV_KEY, KEY_F1, ++ EV_KEY, KEY_F2, ++ EV_KEY, KEY_F3, ++ EV_KEY, KEY_F4, ++ EV_KEY, KEY_F5, ++ EV_KEY, KEY_F6, ++ EV_KEY, KEY_F7, ++ EV_KEY, KEY_F8, ++ EV_KEY, KEY_F9, ++ EV_KEY, KEY_F10, ++ EV_KEY, KEY_NUMLOCK, ++ EV_KEY, KEY_SCROLLLOCK, ++ EV_KEY, KEY_KP7, ++ EV_KEY, KEY_KP8, ++ EV_KEY, KEY_KP9, ++ EV_KEY, KEY_KPMINUS, ++ EV_KEY, KEY_KP4, ++ EV_KEY, KEY_KP5, ++ EV_KEY, KEY_KP6, ++ EV_KEY, KEY_KPPLUS, ++ EV_KEY, KEY_KP1, ++ EV_KEY, KEY_KP2, ++ EV_KEY, KEY_KP3, ++ EV_KEY, KEY_KP0, ++ EV_KEY, KEY_KPDOT, ++ EV_KEY, KEY_ZENKAKUHANKAKU, ++ EV_KEY, KEY_102ND, ++ EV_KEY, KEY_F11, ++ EV_KEY, KEY_F12, ++ EV_KEY, KEY_RO, ++ EV_KEY, KEY_KATAKANA, ++ EV_KEY, KEY_HIRAGANA, ++ EV_KEY, KEY_HENKAN, ++ EV_KEY, KEY_KATAKANAHIRAGANA, ++ EV_KEY, KEY_MUHENKAN, ++ EV_KEY, KEY_KPJPCOMMA, ++ EV_KEY, KEY_KPENTER, ++ EV_KEY, KEY_RIGHTCTRL, ++ EV_KEY, KEY_KPSLASH, ++ EV_KEY, KEY_SYSRQ, ++ EV_KEY, KEY_RIGHTALT, ++ EV_KEY, KEY_LINEFEED, ++ EV_KEY, KEY_HOME, ++ EV_KEY, KEY_UP, ++ EV_KEY, KEY_PAGEUP, ++ EV_KEY, KEY_LEFT, ++ EV_KEY, KEY_RIGHT, ++ EV_KEY, KEY_END, ++ EV_KEY, KEY_DOWN, ++ EV_KEY, KEY_PAGEDOWN, ++ EV_KEY, KEY_INSERT, ++ EV_KEY, KEY_DELETE, ++ EV_KEY, KEY_MACRO, ++ EV_KEY, KEY_MUTE, ++ EV_KEY, KEY_VOLUMEDOWN, ++ EV_KEY, KEY_VOLUMEUP, ++ EV_KEY, KEY_POWER, ++ EV_KEY, KEY_KPEQUAL, ++ EV_KEY, KEY_KPPLUSMINUS, ++ EV_KEY, KEY_PAUSE, ++ /* EV_KEY, KEY_SCALE, */ ++ EV_KEY, KEY_KPCOMMA, ++ EV_KEY, KEY_HANGEUL, ++ EV_KEY, KEY_HANJA, ++ EV_KEY, KEY_YEN, ++ EV_KEY, KEY_LEFTMETA, ++ EV_KEY, KEY_RIGHTMETA, ++ EV_KEY, KEY_COMPOSE, ++ EV_KEY, KEY_STOP, ++ ++ EV_KEY, KEY_MENU, ++ EV_KEY, KEY_CALC, ++ EV_KEY, KEY_SETUP, ++ EV_KEY, KEY_SLEEP, ++ EV_KEY, KEY_WAKEUP, ++ EV_KEY, KEY_SCREENLOCK, ++ EV_KEY, KEY_DIRECTION, ++ EV_KEY, KEY_CYCLEWINDOWS, ++ EV_KEY, KEY_MAIL, ++ EV_KEY, KEY_BOOKMARKS, ++ EV_KEY, KEY_COMPUTER, ++ EV_KEY, KEY_BACK, ++ EV_KEY, KEY_FORWARD, ++ EV_KEY, KEY_NEXTSONG, ++ EV_KEY, KEY_PLAYPAUSE, ++ EV_KEY, KEY_PREVIOUSSONG, ++ EV_KEY, KEY_STOPCD, ++ EV_KEY, KEY_HOMEPAGE, ++ EV_KEY, KEY_REFRESH, ++ EV_KEY, KEY_F14, ++ EV_KEY, KEY_F15, ++ EV_KEY, KEY_SEARCH, ++ EV_KEY, KEY_MEDIA, ++ EV_KEY, KEY_FN, ++ EV_LED, LED_NUML, ++ EV_LED, LED_CAPSL, ++ EV_LED, LED_SCROLLL, ++ -1, -1, ++}; ++ ++static const char quirk_file[] = ++"[litest Quirked Keyboard enable rel]\n" ++"MatchName=litest Quirked Keyboard\n" ++"AttrEventCodeEnable=BTN_RIGHT;EV_KEY:0x110\n" /* BTN_LEFT */ ++"\n" ++"[litest Quirked keyboard disable F1-F3]\n" ++"MatchName=litest Quirked Keyboard\n" ++"AttrEventCodeDisable=KEY_F1;EV_KEY:0x3c;KEY_F3\n"; ++ ++TEST_DEVICE("keyboard-quirked", ++ .type = LITEST_KEYBOARD_QUIRKED, ++ .features = LITEST_KEYS | LITEST_IGNORED, /* Only use this keyboard in specific tests */ ++ .interface = NULL, ++ ++ .name = "Quirked Keyboard", ++ .id = &input_id, ++ .events = events, ++ .absinfo = NULL, ++ .quirk_file = quirk_file, ++) +diff --git a/test/litest.h b/test/litest.h +index 1f4e609d..25dc9eed 100644 +--- a/test/litest.h ++++ b/test/litest.h +@@ -306,6 +306,7 @@ enum litest_device_type { + LITEST_TABLET_MODE_UNRELIABLE, + LITEST_KEYBOARD_LOGITECH_MEDIA_KEYBOARD_ELITE, + LITEST_SONY_VAIO_KEYS, ++ LITEST_KEYBOARD_QUIRKED, + }; + + #define LITEST_DEVICELESS -2 +diff --git a/test/test-device.c b/test/test-device.c +index 3a4a6b57..a50372d4 100644 +--- a/test/test-device.c ++++ b/test/test-device.c +@@ -1419,6 +1419,81 @@ START_TEST(device_quirks_logitech_marble_mouse) + } + END_TEST + ++char *debug_messages[64] = { NULL }; ++ ++static void ++debug_log_handler(struct libinput *libinput, ++ enum libinput_log_priority priority, ++ const char *format, ++ va_list args) ++{ ++ char *message; ++ int n; ++ ++ if (priority != LIBINPUT_LOG_PRIORITY_DEBUG) ++ return; ++ ++ n = xvasprintf(&message, format, args); ++ litest_assert_int_gt(n, 0); ++ ++ for (size_t idx = 0; idx < ARRAY_LENGTH(debug_messages); idx++) { ++ if (debug_messages[idx] == NULL) { ++ debug_messages[idx] = message; ++ return; ++ } ++ } ++ ++ litest_abort_msg("Out of space for debug messages"); ++} ++ ++START_TEST(device_quirks) ++{ ++ struct libinput *li; ++ struct litest_device *dev; ++ struct libinput_device *device; ++ char **message; ++ bool disable_key_f1 = false, ++ enable_btn_left = false; ++ ++ li = litest_create_context(); ++ libinput_log_set_priority(li, LIBINPUT_LOG_PRIORITY_DEBUG); ++ libinput_log_set_handler(li, debug_log_handler); ++ dev = litest_add_device(li, LITEST_KEYBOARD_QUIRKED); ++ device = dev->libinput_device; ++ ++ ck_assert(libinput_device_pointer_has_button(device, ++ BTN_LEFT)); ++ ck_assert(libinput_device_pointer_has_button(dev->libinput_device, ++ BTN_RIGHT)); ++ ck_assert(!libinput_device_keyboard_has_key(dev->libinput_device, ++ KEY_F1)); ++ ck_assert(!libinput_device_keyboard_has_key(dev->libinput_device, ++ KEY_F2)); ++ ck_assert(!libinput_device_keyboard_has_key(dev->libinput_device, ++ KEY_F3)); ++ ++ /* Scrape the debug messages for confirmation that our quirks are ++ * triggered, the above checks cannot work non-key codes */ ++ message = debug_messages; ++ while (*message) { ++ if (strstr(*message, "disabling EV_KEY KEY_F1")) ++ disable_key_f1 = true; ++ if (strstr(*message, "enabling EV_KEY BTN_LEFT")) ++ enable_btn_left = true; ++ ++ message++; ++ } ++ ++ ck_assert(disable_key_f1); ++ ck_assert(enable_btn_left); ++ ++ litest_disable_log_handler(li); ++ ++ litest_delete_device(dev); ++ litest_destroy_context(li); ++} ++END_TEST ++ + START_TEST(device_capability_at_least_one) + { + struct litest_device *dev = litest_current_device(); +@@ -1670,6 +1745,7 @@ TEST_COLLECTION(device) + litest_add_for_device("device:quirks", device_quirks_cyborg_rat_mode_button, LITEST_CYBORG_RAT); + litest_add_for_device("device:quirks", device_quirks_apple_magicmouse, LITEST_MAGICMOUSE); + litest_add_for_device("device:quirks", device_quirks_logitech_marble_mouse, LITEST_LOGITECH_TRACKBALL); ++ litest_add_no_device("device:quirks", device_quirks); + + litest_add("device:capability", device_capability_at_least_one, LITEST_ANY, LITEST_ANY); + litest_add("device:capability", device_capability_check_invalid, LITEST_ANY, LITEST_ANY); +-- +2.31.1 + diff --git a/0004-Revert-tools-switch-measure-fuzz-to-use-python-libev.patch b/0004-Revert-tools-switch-measure-fuzz-to-use-python-libev.patch new file mode 100644 index 0000000..2678286 --- /dev/null +++ b/0004-Revert-tools-switch-measure-fuzz-to-use-python-libev.patch @@ -0,0 +1,90 @@ +From 2f294e771a5e9cdeedff4627905634b9daac9bec Mon Sep 17 00:00:00 2001 +From: Peter Hutterer +Date: Tue, 3 Nov 2020 15:30:18 +1000 +Subject: [PATCH libinput 4/4] Revert "tools: switch measure-fuzz to use + python-libevdev" + +This reverts commit 795c08eb44fca078fa9935fdc5b8482bb7b43413. +--- + tools/libinput-measure-fuzz.py | 40 ++++++++++++++++++++++++---------- + 1 file changed, 29 insertions(+), 11 deletions(-) + +diff --git a/tools/libinput-measure-fuzz.py b/tools/libinput-measure-fuzz.py +index c392d74a..f539fe23 100755 +--- a/tools/libinput-measure-fuzz.py ++++ b/tools/libinput-measure-fuzz.py +@@ -29,7 +29,8 @@ import sys + import argparse + import subprocess + try: +- import libevdev ++ import evdev ++ import evdev.ecodes + import pyudev + except ModuleNotFoundError as e: + print('Error: {}'.format(str(e)), file=sys.stderr) +@@ -74,15 +75,15 @@ class InvalidDeviceError(Exception): + pass + + +-class Device(libevdev.Device): ++class Device(object): + def __init__(self, path): + if path is None: + self.path = self.find_touch_device() + else: + self.path = path + +- fd = open(self.path, 'rb') +- super().__init__(fd) ++ self.device = evdev.InputDevice(self.path) ++ self.name = self.device.name + context = pyudev.Context() + self.udev_device = pyudev.Devices.from_device_file(context, self.path) + +@@ -137,18 +138,35 @@ class Device(libevdev.Device): + Returns a tuple of (xfuzz, yfuzz) with the fuzz as set on the device + axis. Returns None if no fuzz is set. + ''' +- if not self.has(libevdev.EV_ABS.ABS_X) or not self.has(libevdev.EV_ABS.ABS_Y): ++ # capabilities returns a dict with the EV_* codes as key, ++ # each of which is a list of tuples of (code, AbsInfo) ++ # ++ # Get the abs list first (or empty list if missing), ++ # then extract the touch major absinfo from that ++ caps = self.device.capabilities(absinfo=True).get(evdev.ecodes.EV_ABS, []) ++ codes = [cap[0] for cap in caps] ++ ++ if evdev.ecodes.ABS_X not in codes or evdev.ecodes.ABS_Y not in codes: + raise InvalidDeviceError('device does not have x/y axes') + +- if self.has(libevdev.EV_ABS.ABS_MT_POSITION_X) != self.has(libevdev.EV_ABS.ABS_MT_POSITION_Y): ++ if (evdev.ecodes.ABS_MT_POSITION_X in codes) != (evdev.ecodes.ABS_MT_POSITION_Y in codes): + raise InvalidDeviceError('device does not have both multitouch axes') + +- xfuzz = (self.absinfo[libevdev.EV_ABS.ABS_X].fuzz or +- self.absinfo[libevdev.EV_ABS.ABS_MT_POSITION_X].fuzz) +- yfuzz = (self.absinfo[libevdev.EV_ABS.ABS_Y].fuzz or +- self.absinfo[libevdev.EV_ABS.ABS_MT_POSITION_Y].fuzz) ++ axes = { ++ 0x00: None, ++ 0x01: None, ++ 0x35: None, ++ 0x36: None, ++ } + +- if xfuzz == 0 and yfuzz == 0: ++ for c in caps: ++ if c[0] in axes.keys(): ++ axes[c[0]] = c[1].fuzz ++ ++ xfuzz = axes[0x35] or axes[0x00] ++ yfuzz = axes[0x36] or axes[0x01] ++ ++ if xfuzz is None and yfuzz is None: + return None + + return (xfuzz, yfuzz) +-- +2.28.0 + diff --git a/0004-quirks-add-AttrInputPropEnable-and-Disable.patch b/0004-quirks-add-AttrInputPropEnable-and-Disable.patch new file mode 100644 index 0000000..8286f5c --- /dev/null +++ b/0004-quirks-add-AttrInputPropEnable-and-Disable.patch @@ -0,0 +1,447 @@ +From ea835c0f9a3cf8b599ea63f1057ee8cdb997db95 Mon Sep 17 00:00:00 2001 +From: Peter Hutterer +Date: Fri, 23 Oct 2020 10:38:14 +1000 +Subject: [PATCH libinput 4/5] quirks: add AttrInputPropEnable and Disable + +The latter requires libevdev 1.10 but since that'll take a while to filter +into our various CI systems, let's make it conditional. + +Signed-off-by: Peter Hutterer +(cherry picked from commit e882bd02167a9e2ca1c26c104026a8b29bf23ffa) +--- + doc/user/device-quirks.rst | 6 +++ + meson.build | 3 ++ + src/evdev.c | 35 ++++++++++++++++ + src/quirks.c | 51 ++++++++++++++++++++++++ + src/quirks.h | 16 ++++++++ + src/util-prop-parsers.c | 57 +++++++++++++++++++++++++++ + src/util-prop-parsers.h | 1 + + test/litest-device-keyboard-quirked.c | 17 +++++++- + test/test-device.c | 16 +++++++- + test/test-utils.c | 47 ++++++++++++++++++++++ + 10 files changed, 247 insertions(+), 2 deletions(-) + +diff --git a/doc/user/device-quirks.rst b/doc/user/device-quirks.rst +index 21c43e1c..faaea47f 100644 +--- a/doc/user/device-quirks.rst ++++ b/doc/user/device-quirks.rst +@@ -181,6 +181,12 @@ AttrEventCodeEnable=EV_ABS;BTN_STYLUS;EV_KEY:0x123; + Enables the evdev event type/code tuples on the device. Entries may be + a named event type, or a named event code, or a named event type with a + hexadecimal event code, separated by a single colon. ++AttrInputPropDisable=INPUT_PROP_BUTTONPAD;INPUT_PROP_POINTER; ++ Disables the evdev input property on the device. Entries may be ++ a named input property or the hexadecimal value of that property. ++AttrInputPropEnable=INPUT_PROP_BUTTONPAD;INPUT_PROP_POINTER; ++ Enables the evdev input property on the device. Entries may be ++ a named input property or the hexadecimal value of that property. + AttrPointingStickIntegration=internal|external + Indicates the integration of the pointing stick. This is a string enum. + Only needed for external pointing sticks. These are rare. +diff --git a/meson.build b/meson.build +index 0481fa10..040e3f1f 100644 +--- a/meson.build ++++ b/meson.build +@@ -125,6 +125,9 @@ pkgconfig = import('pkgconfig') + dep_udev = dependency('libudev') + dep_mtdev = dependency('mtdev', version : '>= 1.1.0') + dep_libevdev = dependency('libevdev') ++config_h.set10('HAVE_LIBEVDEV_DISABLE_PROPERTY', ++ dep_libevdev.version().version_compare('>= 1.9.902')) ++ + dep_lm = cc.find_library('m', required : false) + dep_rt = cc.find_library('rt', required : false) + +diff --git a/src/evdev.c b/src/evdev.c +index 4bcd3066..44d01711 100644 +--- a/src/evdev.c ++++ b/src/evdev.c +@@ -2050,6 +2050,8 @@ evdev_pre_configure_model_quirks(struct evdev_device *device) + struct quirks_context *quirks; + struct quirks *q; + const struct quirk_tuples *t; ++ const uint32_t *props = NULL; ++ size_t nprops = 0; + char *prop; + + /* Touchpad is a clickpad but INPUT_PROP_BUTTONPAD is not set, see +@@ -2130,6 +2132,39 @@ evdev_pre_configure_model_quirks(struct evdev_device *device) + } + } + ++ if (quirks_get_uint32_array(q, ++ QUIRK_ATTR_INPUT_PROP_ENABLE, ++ &props, ++ &nprops)) { ++ for (size_t idx = 0; idx < nprops; idx++) { ++ unsigned int p = props[idx]; ++ libevdev_enable_property(device->evdev, p); ++ evdev_log_debug(device, ++ "quirks: enabling %s (%#x)\n", ++ libevdev_property_get_name(p), ++ p); ++ } ++ } ++ ++ if (quirks_get_uint32_array(q, ++ QUIRK_ATTR_INPUT_PROP_DISABLE, ++ &props, ++ &nprops)) { ++#if HAVE_LIBEVDEV_DISABLE_PROPERTY ++ for (size_t idx = 0; idx < nprops; idx++) { ++ unsigned int p = props[idx]; ++ libevdev_disable_property(device->evdev, p); ++ evdev_log_debug(device, ++ "quirks: disabling %s (%#x)\n", ++ libevdev_property_get_name(p), ++ p); ++ } ++#else ++ evdev_log_error(device, ++ "quirks: a quirk for this device requires newer libevdev than installed\n"); ++#endif ++ } ++ + quirks_unref(q); + } + +diff --git a/src/quirks.c b/src/quirks.c +index 69f41fde..4a49154f 100644 +--- a/src/quirks.c ++++ b/src/quirks.c +@@ -57,6 +57,14 @@ enum property_type { + PT_RANGE, + PT_DOUBLE, + PT_TUPLES, ++ PT_UINT_ARRAY, ++}; ++ ++struct quirk_array { ++ union { ++ uint32_t u[32]; ++ } data; ++ size_t nelements; + }; + + /** +@@ -79,6 +87,7 @@ struct property { + struct quirk_dimensions dim; + struct quirk_range range; + struct quirk_tuples tuples; ++ struct quirk_array array; + } value; + }; + +@@ -274,6 +283,8 @@ quirk_get_name(enum quirk q) + case QUIRK_ATTR_MSC_TIMESTAMP: return "AttrMscTimestamp"; + case QUIRK_ATTR_EVENT_CODE_DISABLE: return "AttrEventCodeDisable"; + case QUIRK_ATTR_EVENT_CODE_ENABLE: return "AttrEventCodeEnable"; ++ case QUIRK_ATTR_INPUT_PROP_DISABLE: return "AttrInputPropDisable"; ++ case QUIRK_ATTR_INPUT_PROP_ENABLE: return "AttrInputPropEnable"; + default: + abort(); + } +@@ -758,6 +769,24 @@ parse_attr(struct quirks_context *ctx, + p->value.tuples.ntuples = nevents; + p->type = PT_TUPLES; + ++ rc = true; ++ } else if (streq(key, quirk_get_name(QUIRK_ATTR_INPUT_PROP_DISABLE)) || ++ streq(key, quirk_get_name(QUIRK_ATTR_INPUT_PROP_ENABLE))) { ++ unsigned int props[INPUT_PROP_CNT]; ++ size_t nprops = ARRAY_LENGTH(props); ++ if (streq(key, quirk_get_name(QUIRK_ATTR_INPUT_PROP_DISABLE))) ++ p->id = QUIRK_ATTR_INPUT_PROP_DISABLE; ++ else ++ p->id = QUIRK_ATTR_INPUT_PROP_ENABLE; ++ ++ if (!parse_input_prop_property(value, props, &nprops) || ++ nprops == 0) ++ goto out; ++ ++ memcpy(p->value.array.data.u, props, nprops * sizeof(unsigned int)); ++ p->value.array.nelements = nprops; ++ p->type = PT_UINT_ARRAY; ++ + rc = true; + } else { + qlog_error(ctx, "Unknown key %s in %s\n", key, s->name); +@@ -1589,3 +1618,25 @@ quirks_get_tuples(struct quirks *q, + + return true; + } ++ ++bool ++quirks_get_uint32_array(struct quirks *q, ++ enum quirk which, ++ const uint32_t **array, ++ size_t *nelements) ++{ ++ struct property *p; ++ ++ if (!q) ++ return false; ++ ++ p = quirk_find_prop(q, which); ++ if (!p) ++ return false; ++ ++ assert(p->type == PT_UINT_ARRAY); ++ *array = p->value.array.data.u; ++ *nelements = p->value.array.nelements; ++ ++ return true; ++} +diff --git a/src/quirks.h b/src/quirks.h +index 0b2fe9f3..4f2c6a8c 100644 +--- a/src/quirks.h ++++ b/src/quirks.h +@@ -110,6 +110,8 @@ enum quirk { + QUIRK_ATTR_MSC_TIMESTAMP, + QUIRK_ATTR_EVENT_CODE_DISABLE, + QUIRK_ATTR_EVENT_CODE_ENABLE, ++ QUIRK_ATTR_INPUT_PROP_DISABLE, ++ QUIRK_ATTR_INPUT_PROP_ENABLE, + + _QUIRK_LAST_ATTR_QUIRK_, /* Guard: do not modify */ + }; +@@ -313,3 +315,17 @@ bool + quirks_get_tuples(struct quirks *q, + enum quirk which, + const struct quirk_tuples **tuples); ++ ++/** ++ * Get the uint32 array of the given quirk. ++ * This function will assert if the quirk type does not match the ++ * requested type. If the quirk is not set for this device, tuples is ++ * unchanged. ++ * ++ * @return true if the quirk value is valid, false otherwise. ++ */ ++bool ++quirks_get_uint32_array(struct quirks *q, ++ enum quirk which, ++ const uint32_t **array, ++ size_t *nelements); +diff --git a/src/util-prop-parsers.c b/src/util-prop-parsers.c +index 9e076328..5a5cf8e0 100644 +--- a/src/util-prop-parsers.c ++++ b/src/util-prop-parsers.c +@@ -402,6 +402,63 @@ out: + return rc; + } + ++/** ++ * Parses a string of the format "INPUT_PROP_BUTTONPAD;INPUT_PROP_POINTER;0x123;" ++ * where each element must be a named input prop OR a hexcode in the form ++ * 0x1234 ++ * ++ * props must point to an existing array of size nprops. ++ * nprops specifies the size of the array in props and returns the number ++ * of elements, elements exceeding nprops are simply ignored, just make sure ++ * props is large enough for your use-case. ++ * ++ * On success, props contains nprops elements. ++ */ ++bool ++parse_input_prop_property(const char *prop, unsigned int *props_out, size_t *nprops) ++{ ++ char **strv = NULL; ++ bool rc = false; ++ size_t count = 0; ++ size_t idx; ++ unsigned int props[INPUT_PROP_CNT]; /* doubling up on quirks is a bug */ ++ ++ strv = strv_from_string(prop, ";"); ++ if (!strv) ++ goto out; ++ ++ for (idx = 0; strv[idx]; idx++) ++ count++; ++ ++ if (count == 0 || count > ARRAY_LENGTH(props)) ++ goto out; ++ ++ count = min(*nprops, count); ++ for (idx = 0; strv[idx]; idx++) { ++ char *s = strv[idx]; ++ unsigned int prop; ++ ++ if (safe_atou_base(s, &prop, 16)) { ++ if (prop > INPUT_PROP_MAX) ++ goto out; ++ } else { ++ int val = libevdev_property_from_name(s); ++ if (val == -1) ++ goto out; ++ prop = (unsigned int)val; ++ } ++ props[idx] = prop; ++ } ++ ++ memcpy(props_out, props, count * sizeof *props); ++ *nprops = count; ++ rc = true; ++ ++out: ++ strv_free(strv); ++ return rc; ++} ++ + /** + * Parse the property value for the EVDEV_ABS_00 properties. Spec is + * EVDEV_ABS_00=min:max:res:fuzz:flat +diff --git a/src/util-prop-parsers.h b/src/util-prop-parsers.h +index 7ed136a9..5f0d8673 100644 +--- a/src/util-prop-parsers.h ++++ b/src/util-prop-parsers.h +@@ -38,6 +38,7 @@ bool parse_calibration_property(const char *prop, float calibration[6]); + bool parse_range_property(const char *prop, int *hi, int *lo); + #define EVENT_CODE_UNDEFINED 0xffff + bool parse_evcode_property(const char *prop, struct input_event *events, size_t *nevents); ++bool parse_input_prop_property(const char *prop, unsigned int *props_out, size_t *nprops); + + enum tpkbcombo_layout { + TPKBCOMBO_LAYOUT_UNKNOWN, +diff --git a/test/litest-device-keyboard-quirked.c b/test/litest-device-keyboard-quirked.c +index 748794b2..53161fa4 100644 +--- a/test/litest-device-keyboard-quirked.c ++++ b/test/litest-device-keyboard-quirked.c +@@ -191,6 +191,10 @@ static int events[] = { + EV_LED, LED_NUML, + EV_LED, LED_CAPSL, + EV_LED, LED_SCROLLL, ++ ++ /* gets disabled */ ++ INPUT_PROP_MAX, INPUT_PROP_POINTING_STICK, ++ + -1, -1, + }; + +@@ -201,7 +205,18 @@ static const char quirk_file[] = + "\n" + "[litest Quirked keyboard disable F1-F3]\n" + "MatchName=litest Quirked Keyboard\n" +-"AttrEventCodeDisable=KEY_F1;EV_KEY:0x3c;KEY_F3\n"; ++"AttrEventCodeDisable=KEY_F1;EV_KEY:0x3c;KEY_F3\n" ++#if HAVE_LIBEVDEV_DISABLE_PROPERTY ++"\n" ++"[litest Quirked keyboard enable buttonpad]\n" ++"MatchName=litest Quirked Keyboard\n" ++"AttrInputPropEnable=INPUT_PROP_BUTTONPAD\n" ++"\n" ++"[litest Quirked keyboard disable pointingstick]\n" ++"MatchName=litest Quirked Keyboard\n" ++"AttrInputPropDisable=INPUT_PROP_POINTING_STICK\n" ++#endif ++; + + TEST_DEVICE("keyboard-quirked", + .type = LITEST_KEYBOARD_QUIRKED, +diff --git a/test/test-device.c b/test/test-device.c +index a50372d4..6c38ed44 100644 +--- a/test/test-device.c ++++ b/test/test-device.c +@@ -1454,6 +1454,10 @@ START_TEST(device_quirks) + char **message; + bool disable_key_f1 = false, + enable_btn_left = false; ++#if HAVE_LIBEVDEV_DISABLE_PROPERTY ++ bool disable_pointingstick = false, ++ enable_buttonpad = false; ++#endif + + li = litest_create_context(); + libinput_log_set_priority(li, LIBINPUT_LOG_PRIORITY_DEBUG); +@@ -1480,12 +1484,22 @@ START_TEST(device_quirks) + disable_key_f1 = true; + if (strstr(*message, "enabling EV_KEY BTN_LEFT")) + enable_btn_left = true; +- ++#if HAVE_LIBEVDEV_DISABLE_PROPERTY ++ if (strstr(*message, "enabling INPUT_PROP_BUTTONPAD")) ++ enable_buttonpad = true; ++ if (strstr(*message, "disabling INPUT_PROP_POINTING_STICK")) ++ disable_pointingstick = true; ++#endif ++ free(*message); + message++; + } + + ck_assert(disable_key_f1); + ck_assert(enable_btn_left); ++#if HAVE_LIBEVDEV_DISABLE_PROPERTY ++ ck_assert(enable_buttonpad); ++ ck_assert(disable_pointingstick); ++#endif + + litest_disable_log_handler(li); + +diff --git a/test/test-utils.c b/test/test-utils.c +index 5faec0e4..5955f56e 100644 +--- a/test/test-utils.c ++++ b/test/test-utils.c +@@ -546,6 +546,52 @@ START_TEST(evcode_prop_parser) + } + END_TEST + ++START_TEST(input_prop_parser) ++{ ++ struct parser_test_val { ++ const char *prop; ++ bool success; ++ size_t nvals; ++ uint32_t values[20]; ++ } tests[] = { ++ { "INPUT_PROP_BUTTONPAD", true, 1, {INPUT_PROP_BUTTONPAD}}, ++ { "INPUT_PROP_BUTTONPAD;INPUT_PROP_POINTER", true, 2, ++ { INPUT_PROP_BUTTONPAD, ++ INPUT_PROP_POINTER }}, ++ { "INPUT_PROP_BUTTONPAD;0x00;0x03", true, 3, ++ { INPUT_PROP_BUTTONPAD, ++ INPUT_PROP_POINTER, ++ INPUT_PROP_SEMI_MT }}, ++ { .prop = "", .success = false }, ++ { .prop = "0xff", .success = false }, ++ { .prop = "INPUT_PROP", .success = false }, ++ { .prop = "INPUT_PROP_FOO", .success = false }, ++ { .prop = "INPUT_PROP_FOO;INPUT_PROP_FOO", .success = false }, ++ { .prop = "INPUT_PROP_POINTER;INPUT_PROP_FOO", .success = false }, ++ { .prop = "none", .success = false }, ++ { .prop = NULL }, ++ }; ++ struct parser_test_val *t; ++ ++ for (int i = 0; tests[i].prop; i++) { ++ bool success; ++ uint32_t props[32]; ++ size_t nprops = ARRAY_LENGTH(props); ++ ++ t = &tests[i]; ++ success = parse_input_prop_property(t->prop, props, &nprops); ++ ck_assert(success == t->success); ++ if (!success) ++ continue; ++ ++ ck_assert_int_eq(nprops, t->nvals); ++ for (size_t j = 0; j < t->nvals; j++) { ++ ck_assert_int_eq(t->values[j], props[j]); ++ } ++ } ++} ++END_TEST ++ + START_TEST(evdev_abs_parser) + { + struct test { +@@ -1244,6 +1290,7 @@ litest_utils_suite(void) + tcase_add_test(tc, calibration_prop_parser); + tcase_add_test(tc, range_prop_parser); + tcase_add_test(tc, evcode_prop_parser); ++ tcase_add_test(tc, input_prop_parser); + tcase_add_test(tc, evdev_abs_parser); + tcase_add_test(tc, safe_atoi_test); + tcase_add_test(tc, safe_atoi_base_16_test); +-- +2.31.1 + diff --git a/0005-tools-print-the-AttrEventCodeEnable-and-AttrInputPro.patch b/0005-tools-print-the-AttrEventCodeEnable-and-AttrInputPro.patch new file mode 100644 index 0000000..2441935 --- /dev/null +++ b/0005-tools-print-the-AttrEventCodeEnable-and-AttrInputPro.patch @@ -0,0 +1,85 @@ +From ab7b8fb32294d0923af4132e85c00d7b6c51e1d3 Mon Sep 17 00:00:00 2001 +From: Peter Hutterer +Date: Tue, 10 Nov 2020 13:32:26 +1000 +Subject: [PATCH libinput 5/5] tools: print the AttrEventCodeEnable and + AttrInputPropEnable/Disable quirks + +Introduced in e3c4ff3 and e882bd02 + +Signed-off-by: Peter Hutterer +(cherry picked from commit 2c50ffab249f21f6dece2fdd0f45a6f2427f44bb) +--- + tools/shared.c | 37 +++++++++++++++++++++++++++++++++---- + 1 file changed, 33 insertions(+), 4 deletions(-) + +diff --git a/tools/shared.c b/tools/shared.c +index af791274..55c48ea1 100644 +--- a/tools/shared.c ++++ b/tools/shared.c +@@ -576,15 +576,15 @@ tools_exec_command(const char *prefix, int real_argc, char **real_argv) + } + + static void +-sprintf_event_codes(char *buf, size_t sz, struct quirks *quirks) ++sprintf_event_codes(char *buf, size_t sz, struct quirks *quirks, enum quirk q) + { + const struct quirk_tuples *t; + size_t off = 0; + int printed; + const char *name; + +- quirks_get_tuples(quirks, QUIRK_ATTR_EVENT_CODE_DISABLE, &t); +- name = quirk_get_name(QUIRK_ATTR_EVENT_CODE_DISABLE); ++ quirks_get_tuples(quirks, q, &t); ++ name = quirk_get_name(q); + printed = snprintf(buf, sz, "%s=", name); + assert(printed != -1); + off += printed; +@@ -600,6 +600,29 @@ sprintf_event_codes(char *buf, size_t sz, struct quirks *quirks) + } + } + ++static void ++sprintf_input_props(char *buf, size_t sz, struct quirks *quirks, enum quirk q) ++{ ++ const uint32_t *properties; ++ size_t nprops = 0; ++ size_t off = 0; ++ int printed; ++ const char *name; ++ ++ quirks_get_uint32_array(quirks, q, &properties, &nprops); ++ name = quirk_get_name(q); ++ printed = snprintf(buf, sz, "%s=", name); ++ assert(printed != -1); ++ off += printed; ++ ++ for (size_t i = 0; off < sz && i < nprops; i++) { ++ const char *name = libevdev_property_get_name(properties[i]); ++ printed = snprintf(buf + off, sz - off, "%s;", name); ++ assert(printed != -1); ++ off += printed; ++ } ++} ++ + void + tools_list_device_quirks(struct quirks_context *ctx, + struct udev_device *device, +@@ -680,7 +703,13 @@ tools_list_device_quirks(struct quirks_context *ctx, + callback(userdata, buf); + break; + case QUIRK_ATTR_EVENT_CODE_DISABLE: +- sprintf_event_codes(buf, sizeof(buf), quirks); ++ case QUIRK_ATTR_EVENT_CODE_ENABLE: ++ sprintf_event_codes(buf, sizeof(buf), quirks, q); ++ callback(userdata, buf); ++ break; ++ case QUIRK_ATTR_INPUT_PROP_DISABLE: ++ case QUIRK_ATTR_INPUT_PROP_ENABLE: ++ sprintf_input_props(buf, sizeof(buf), quirks, q); + callback(userdata, buf); + break; + default: +-- +2.31.1 + diff --git a/0006-quirks-add-quirk-for-Dell-Precision-7550-7750-touchp.patch b/0006-quirks-add-quirk-for-Dell-Precision-7550-7750-touchp.patch new file mode 100644 index 0000000..6d55257 --- /dev/null +++ b/0006-quirks-add-quirk-for-Dell-Precision-7550-7750-touchp.patch @@ -0,0 +1,32 @@ +From 89e2e00b307d7aea63b43ff83cbf520aee27fad5 Mon Sep 17 00:00:00 2001 +From: Scott Jann +Date: Mon, 3 Aug 2020 00:03:59 -0500 +Subject: [PATCH libinput] quirks: add quirk for Dell Precision 7550/7750 + touchpad + +Signed-off-by: Scott Jann +(cherry picked from commit 69959c8a3b0612fb2bea015713f630a896188529) +--- + quirks/50-system-dell.quirks | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/quirks/50-system-dell.quirks b/quirks/50-system-dell.quirks +index 232c309a..aaddbffe 100644 +--- a/quirks/50-system-dell.quirks ++++ b/quirks/50-system-dell.quirks +@@ -65,6 +65,12 @@ MatchName=*DualPoint Stick + MatchDMIModalias=dmi:*svnDellInc.:pnLatitudeE7470* + AttrTrackpointMultiplier=0.125 + ++[Precision 7x50 Touchpad] ++MatchBus=i2c ++MatchUdevType=touchpad ++MatchDMIModalias=dmi:*svnDellInc.:pnPrecision7?50* ++AttrInputPropDisable=INPUT_PROP_BUTTONPAD ++ + # The touch device has the same vid/pid as the totem, the MatchName + # directive is required here + [Canvas Totem] +-- +2.31.1 + diff --git a/EMPTY b/EMPTY deleted file mode 100644 index 0519ecb..0000000 --- a/EMPTY +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file diff --git a/libinput.spec b/libinput.spec new file mode 100644 index 0000000..a99df04 --- /dev/null +++ b/libinput.spec @@ -0,0 +1,781 @@ +%global udevdir %(pkg-config --variable=udevdir udev) + +#global gitdate 20141211 +%global gitversion 58abea394 + +Name: libinput +Version: 1.16.3 +Release: 2%{?gitdate:.%{gitdate}git%{gitversion}}%{?dist} +Summary: Input device library + +License: MIT +URL: http://www.freedesktop.org/wiki/Software/libinput/ +%if 0%{?gitdate} +Source0: %{name}-%{gitdate}.tar.xz +Source1: make-git-snapshot.sh +Source2: commitid +%else +Source0: http://www.freedesktop.org/software/libinput/libinput-%{version}.tar.xz +%endif + +# Backout the python-evdev -> python-libevdev conversion +Patch001: 0001-Revert-tools-switch-measure-touchpad-tap-to-python-l.patch +Patch002: 0002-Revert-tools-switch-measure-touchpad-pressure-to-pyt.patch +Patch003: 0003-Revert-tools-switch-measure-touch-size-to-python-lib.patch +Patch004: 0004-Revert-tools-switch-measure-fuzz-to-use-python-libev.patch + +# AttrInputPropDisable support (#1951885) +Patch005: 0001-evdev-quirks_get_tuples-can-deal-with-a-NULL-quirks.patch +Patch006: 0002-evdev-localize-two-variables-during-quirks-handling.patch +Patch007: 0003-quirks-add-AttrEventCodeEnable-as-counterpoint-to-th.patch +Patch008: 0004-quirks-add-AttrInputPropEnable-and-Disable.patch +Patch009: 0005-tools-print-the-AttrEventCodeEnable-and-AttrInputPro.patch +Patch010: 0006-quirks-add-quirk-for-Dell-Precision-7550-7750-touchp.patch + +BuildRequires: git-core +BuildRequires: gcc gcc-c++ +BuildRequires: meson +BuildRequires: pkgconfig(libudev) +BuildRequires: pkgconfig(mtdev) >= 1.1.0 +BuildRequires: pkgconfig(libevdev) >= 1.10 +BuildRequires: pkgconfig(libwacom) >= 0.20 +BuildRequires: python3-devel +BuildRequires: check-devel + +%description +libinput is a library that handles input devices for display servers and other +applications that need to directly deal with input devices. + +It provides device detection, device handling, input device event processing +and abstraction so minimize the amount of custom input code the user of +libinput need to provide the common set of functionality that users expect. + + +%package devel +Summary: Development files for %{name} +Requires: %{name}%{?_isa} = %{version}-%{release} + +%description devel +The %{name}-devel package contains libraries and header files for +developing applications that use %{name}. + +%package utils +Summary: Utilities and tools for debugging %{name} +Requires: %{name}%{?_isa} = %{version}-%{release} +Requires: python3-evdev python3-pyudev + +%description utils +The %{name}-utils package contains tools to debug hardware and analyze +%{name}. + +%package test +Summary: libinput integration test suite +Requires: %{name}%{?_isa} = %{version}-%{release} + +%description test +The %{name}-test package contains the libinput test suite. It is not +intended to be run by users. + +%prep +%autosetup -S git +# Replace whatever the source uses with the approved call +pathfix.py -i %{__python3} -p -n $(git grep -l '#!/usr/bin/.*python3') + +%build +%meson -Ddebug-gui=false \ + -Ddocumentation=false \ + -Dtests=true \ + -Dinstall-tests=true \ + -Dudev-dir=%{udevdir} +%meson_build + +%install +%meson_install + +# Remove tools requiring python-libevdev +rm $RPM_BUILD_ROOT/%{_libexecdir}/libinput/libinput-replay +rm $RPM_BUILD_ROOT/%{_mandir}/man1/libinput-record.1* +rm $RPM_BUILD_ROOT/%{_libexecdir}/libinput/libinput-analyze +rm $RPM_BUILD_ROOT/%{_mandir}/man1/libinput-analyze.1* +rm $RPM_BUILD_ROOT/%{_libexecdir}/libinput/libinput-analyze-per-slot-delta +rm $RPM_BUILD_ROOT/%{_mandir}/man1/libinput-analyze-per-slot-delta.1* +rm $RPM_BUILD_ROOT/%{_libexecdir}/libinput/libinput-measure-touchpad-size +rm $RPM_BUILD_ROOT/%{_mandir}/man1/libinput-measure-touchpad-size.1* + +%post +/sbin/ldconfig +/usr/bin/udevadm hwdb --update >/dev/null 2>&1 || : + +%postun -p /sbin/ldconfig + + +%files +%doc COPYING +%{_libdir}/libinput.so.* +%{udevdir}/libinput-device-group +%{udevdir}/libinput-fuzz-to-zero +%{udevdir}/libinput-fuzz-extract +%{udevdir}/rules.d/80-libinput-device-groups.rules +%{udevdir}/rules.d/90-libinput-fuzz-override.rules +%{_bindir}/libinput +%dir %{_libexecdir}/libinput/ +%{_libexecdir}/libinput/libinput-debug-events +%{_libexecdir}/libinput/libinput-list-devices +%{_mandir}/man1/libinput.1* +%{_datadir}/libinput/*.quirks +%dir %{_datadir}/zsh +%dir %{_datadir}/zsh/site-functions +%{_datadir}/zsh/site-functions/* +%{_mandir}/man1/libinput-list-devices.1* +%{_mandir}/man1/libinput-debug-events.1* + +%files devel +%{_includedir}/libinput.h +%{_libdir}/libinput.so +%{_libdir}/pkgconfig/libinput.pc + +%files utils +%{_libexecdir}/libinput/libinput-debug-tablet +%{_libexecdir}/libinput/libinput-measure +%{_libexecdir}/libinput/libinput-measure-fuzz +%{_libexecdir}/libinput/libinput-measure-touchpad-tap +%{_libexecdir}/libinput/libinput-measure-touchpad-pressure +%{_libexecdir}/libinput/libinput-measure-touch-size +%{_libexecdir}/libinput/libinput-quirks +%{_libexecdir}/libinput/libinput-record +%{_mandir}/man1/libinput-debug-tablet.1* +%{_mandir}/man1/libinput-measure.1* +%{_mandir}/man1/libinput-measure-fuzz.1* +%{_mandir}/man1/libinput-measure-touchpad-tap.1* +%{_mandir}/man1/libinput-measure-touch-size.1* +%{_mandir}/man1/libinput-measure-touchpad-pressure.1* +%{_mandir}/man1/libinput-quirks.1* +%{_mandir}/man1/libinput-quirks-list.1* +%{_mandir}/man1/libinput-quirks-validate.1* +%{_mandir}/man1/libinput-replay.1* + +%files test +%{_libexecdir}/libinput/libinput-test-suite +%{_mandir}/man1/libinput-test-suite.1* + +%changelog +* Tue May 25 2021 Peter Hutterer 1.16.3-2 +- Add support for AddrInputPropDisable (#1951885) + +* Tue Nov 03 2020 Peter Hutterer 1.16.3-1 +- libinput 1.16.3 (#1886648) + +* Mon Oct 28 2019 Peter Hutterer 1.14.3-1 +- libinput 1.14.3 (#1728821) + +* Thu May 09 2019 Peter Hutterer 1.13.2-1 +- libinput 1.13.3 (#1690212) + +* Fri Jan 11 2019 Peter Hutterer 1.12.3-3 +- Allow for the tablet mode quirk to apply to touchpads (#1664225) +- Add a quirk for the Asus VivoBook Flip to keep the + keyboard and touchpad working in tablet mode + +* Fri Dec 14 2018 Peter Hutterer 1.12.3-2 +- Add a quirk for the Lenovo T480s (#1658604) +- Add a quirk for the HP Spectre x360 + +* Tue Nov 13 2018 Peter Hutterer 1.12.3-1 +- libinput 1.12.3 (#1647294) + +* Fri Nov 02 2018 Peter Hutterer 1.12.0-6 +- Backport event code disabling quirks (#1643815) + +* Mon Oct 15 2018 Peter Hutterer 1.12.0-5 +- Handle a touch restarting in the same frame (#1639091) + +* Wed Oct 10 2018 Peter Hutterer 1.12.0-4 +- Fix Wacom PTH660 palm threshold (#1637788) + +* Mon Oct 08 2018 Peter Hutterer 1.12.0-3 +- Fix sporadic crash on two-finger scrolling (#1636282) +- Fix one more device quirk + +* Wed Sep 19 2018 Peter Hutterer 1.12.0-2 +- Fix some buggy device quirks (related #1614636) + +* Tue Sep 11 2018 Peter Hutterer 1.12.0-1 +- libinput 1.12.0 (#1614636) + +* Mon Sep 10 2018 Peter Hutterer 1.11.903-2 +- drop libinput replay, this tool requires libevdev-python which we don't + have in RHEL and it's a debugging-tool only. + +* Wed Sep 05 2018 Peter Hutterer 1.11.903-1 +- libinput 1.12rc3 (#1614636) + +* Tue Aug 14 2018 Peter Hutterer 1.11.902-1 +- libinput 1.12rc2 (#1614636) + +* Tue Jul 31 2018 Peter Hutterer 1.11.901-1 +- libinput 1.12rc1 + +* Wed Jul 25 2018 Peter Hutterer 1.11.3-1 +- libinput 1.11.3 + +* Fri Jul 13 2018 Fedora Release Engineering - 1.11.2-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Fri Jul 06 2018 Peter Hutterer 1.11.2-2 +- Replace all python3 calls with the rpm macro + +* Tue Jul 03 2018 Peter Hutterer 1.11.2-1 +- libinput 1.11.2 + +* Wed Jun 20 2018 Peter Hutterer 1.11.1-2 +- Fix segfault in libinput list-devices + +* Tue Jun 19 2018 Peter Hutterer 1.11.1-1 +- libinput 1.11.1 + +* Tue Jun 05 2018 Peter Hutterer 1.11.0-1 +- libinput 1.11.0 + +* Fri Jun 01 2018 Peter Hutterer 1.10.902-2 +- Revert direct sensitivity attribute reading (#1583324) + +* Wed May 30 2018 Peter Hutterer 1.10.902-1 +- libinput 1.11 rc2 + +* Tue May 22 2018 Peter Hutterer 1.10.901-1 +- libinput 1.11 rc1 + +* Thu May 17 2018 Peter Hutterer 1.10.7-2 +- libinput 1.10.7 + +* Mon May 14 2018 Peter Hutterer 1.10.6-2 +- Fix palm threshold on MacBookPro5,5 (#1575260) + +* Tue May 01 2018 Peter Hutterer 1.10.6-1 +- libinput 1.10.6 + +* Fri Apr 27 2018 Peter Hutterer 1.10.5-3 +- Fix the T460s halting cursor problem harder (#1572394) + +* Fri Apr 27 2018 Peter Hutterer 1.10.5-2 +- Fix the T460s halting cursor problem (#1572394) + +* Thu Apr 19 2018 Peter Hutterer 1.10.5-1 +- libinput 1.10.5 + +* Thu Apr 19 2018 Peter Hutterer 1.10.4-2 +- Disable ABS_MT_TOOL_PALM on the Lenovo Carbon X1 6th (#1565692) + +* Mon Apr 09 2018 Peter Hutterer 1.10.4-1 +- libinput 1.10.4 + +* Wed Mar 14 2018 Peter Hutterer 1.10.3-1 +- libinput 1.10.3 + +* Mon Mar 12 2018 Peter Hutterer 1.10.2-4 +- Fix occasional crashes on gestures when libinput loses track of hovering + fake fingers + +* Thu Mar 08 2018 Peter Hutterer 1.10.2-3 +- Add BuildRequires gcc-c++, needed for a test build + +* Wed Mar 07 2018 Peter Hutterer 1.10.2-2 +- libinput 1.10.2 + +* Fri Mar 02 2018 Peter Hutterer 1.10.1-2 +- Fix touchpad jitter by changing from "disable if no jitter" to "enable if + jitter" (#1548550) + +* Wed Feb 28 2018 Peter Hutterer 1.10.1-1 +- libinput 1.10.1 + +* Tue Feb 13 2018 Peter Hutterer 1.10.0-2 +- Fix crasher due to missing devnode after resume (#1536633) + +* Tue Feb 13 2018 Peter Hutterer 1.10.0-1 +- libinput 1.10 + +* Tue Feb 06 2018 Peter Hutterer 1.9.902-1 +- libinput 1.10rc2 + +* Mon Feb 05 2018 Peter Hutterer 1.9.901-3 +- Fix crasher on first event from tablets not supported by libwacom + (#1535755) + +* Fri Feb 02 2018 Peter Hutterer 1.9.901-2 +- Use autosetup instead of the manual git magic + +* Mon Jan 22 2018 Peter Hutterer 1.9.901-1 +- libinput 1.10rc1 + +* Thu Dec 14 2017 Peter Hutterer 1.9.4-1 +- libinput 1.9.4 + +* Fri Dec 08 2017 Peter Hutterer 1.9.3-2 +- Immediately post key events, don't wait for EV_SYN + +* Tue Nov 28 2017 Peter Hutterer 1.9.3-1 +- libinput 1.9.3 + +* Wed Nov 15 2017 Peter Hutterer 1.9.2-1 +- libinput 1.9.2 + +* Wed Nov 15 2017 Peter Hutterer 1.9.1-4 +- Mark the Lenovo Compact Keyboard as external (#1510814) + +* Tue Nov 14 2017 Peter Hutterer 1.9.1-3 +- Handle printing of tablet mode switches (#1510814) + +* Thu Nov 09 2017 Peter Hutterer 1.9.1-2 +- Split some of the tools into a libinput-utils package so we can require + the various bits easier (#1509298) + +* Mon Oct 30 2017 Peter Hutterer 1.9.1-1 +- libinput 1.9.1 + +* Thu Oct 26 2017 Peter Hutterer 1.9.0-2 +- Drop explicit .gz from the man pages + +* Thu Oct 19 2017 Peter Hutterer 1.9.0-1 +- libinput 1.9.0 + +* Tue Oct 10 2017 Peter Hutterer 1.8.902-1 +- libinput 1.9rc2 + +* Thu Sep 28 2017 Peter Hutterer 1.8.901-1 +- libinput 1.9rc1 + +* Thu Sep 07 2017 Peter Hutterer 1.8.2-1 +- libinput 1.8.2 + +* Tue Sep 05 2017 Peter Hutterer 1.8.1-4 +- Don't try pinching when the finger number exceeds available slots +- Don't resume a disabled touchpad after a lid switch open (#1448962) + +* Thu Aug 03 2017 Fedora Release Engineering - 1.8.1-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild + +* Wed Jul 26 2017 Fedora Release Engineering - 1.8.1-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Wed Jul 19 2017 Peter Hutterer 1.8.1-1 +- libinput 1.8.1 + +* Thu Jul 13 2017 Igor Gnatenko - 1.8.0-2 +- Add missing BuildRequires: gcc +- Fixup other BuildRequires +- Rebuild for pkg-config fix from meson + +* Mon Jul 03 2017 Peter Hutterer 1.8.0-1 +- libinput 1.8 + +* Tue Jun 27 2017 Peter Hutterer 1.7.902-2 +- Switch to meson as build system + +* Mon Jun 26 2017 Peter Hutterer 1.7.902-1 +- libinput 1.8rc2 + +* Mon Jun 19 2017 Peter Hutterer 1.7.901-2 +- libinput 1.8rc1 with source files this time + +* Mon Jun 19 2017 Peter Hutterer 1.7.901-1 +- libinput 1.8rc1 + +* Mon Jun 12 2017 Peter Hutterer 1.7.3-1 +- libinput 1.7.3 + +* Tue May 09 2017 Peter Hutterer 1.7.2-2 +- Ignore taps in the palm detection area even in software buttons (#1415796) + +* Tue May 09 2017 Peter Hutterer 1.7.2-1 +- libinput 1.7.2 + +* Thu May 04 2017 Peter Hutterer 1.7.1-4 +- Fix a crash when shutting down a touchpad lid listener (#1440927) + +* Thu May 04 2017 Peter Hutterer 1.7.1-3 +- Fix crash when we have multiple keyboard event listeners for the lid + switch (#1440927) + +* Tue May 02 2017 Peter Hutterer 1.7.1-2 +- Add patches to fix elantech pressure detection + +* Tue Apr 25 2017 Peter Hutterer 1.7.1-1 +- libinput 1.7.1 + +* Thu Mar 23 2017 Peter Hutterer 1.7.0-1 +- libinput 1.7 + +* Fri Mar 10 2017 Peter Hutterer 1.6.902-1 +- libinput 1.7rc2 + +* Thu Feb 23 2017 Peter Hutterer 1.6.901-1 +- libinput 1.7rc1 + +* Wed Feb 22 2017 Peter Hutterer 1.6.2-2 +- Fix middle button emulation for Logitech Marble Mouse (#1421439) + +* Tue Feb 21 2017 Peter Hutterer 1.6.2-1 +- libinput 1.6.2 + +* Fri Feb 10 2017 Fedora Release Engineering - 1.6.1-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Thu Feb 02 2017 Peter Hutterer 1.6.1-1 +- libinput 1.6.1 + +* Wed Feb 01 2017 Peter Hutterer 1.6.0-2 +- revert the tap timeout reduction (#1414935) + +* Fri Jan 20 2017 Peter Hutterer 1.6.0-1 +- libinput 1.6 + +* Mon Jan 16 2017 Peter Hutterer 1.5.902-1 +- libinput 1.6rc2 + +* Tue Jan 10 2017 Peter Hutterer 1.5.901-1 +- libinput 1.6rc1 + +* Wed Dec 07 2016 Peter Hutterer 1.5.3-1 +- libinput 1.5.3 + +* Fri Nov 25 2016 Peter Hutterer 1.5.2-2 +- Swap to the correct tarball so we match the checksums from upstream (had a + local mixup of tarballs) + +* Fri Nov 25 2016 Peter Hutterer 1.5.2-1 +- libinput 1.5.2 + +* Tue Nov 22 2016 Peter Hutterer 1.5.1-2 +- Improve responsiveness of touchpads by reducing the motion history. + +* Fri Nov 11 2016 Peter Hutterer 1.5.1-1 +- libinput 1.5.1 + +* Wed Sep 14 2016 Peter Hutterer 1.5.0-2 +- Drop the synaptics 3-slot workaround + +* Wed Sep 14 2016 Peter Hutterer 1.5.0-1 +- libinput 1.5.0 + +* Thu Sep 08 2016 Peter Hutterer 1.4.901-2 +- Avoid spurious trackpoint events halting the touchpad (related #1364850) + +* Wed Sep 07 2016 Peter Hutterer 1.4.901-1 +- libinput 1.5rc1 + +* Wed Aug 31 2016 Peter Hutterer 1.4.2-2 +- Add quirk for the HP 8510w touchpad (#1351285) + +* Tue Aug 30 2016 Peter Hutterer 1.4.2-1 +- libinput 1.4.2 + +* Fri Aug 05 2016 Peter Hutterer 1.4.1-1 +- libinput 1.4.1 + +* Mon Jul 18 2016 Peter Hutterer 1.4.0-1 +- libinput 1.4 + +* Tue Jul 12 2016 Peter Hutterer 1.3.901-1 +- libinput 1.4rc1 + +* Fri Jun 24 2016 Peter Hutterer 1.3.3-2 +- Drop the now unnecessary patch + +* Fri Jun 24 2016 Peter Hutterer 1.3.3-1 +- libinput 1.3.3 + +* Thu Jun 16 2016 Peter Hutterer 1.3.2-1 +- libinput 1.3.2 + +* Mon May 30 2016 Peter Hutterer 1.3.1-1 +- libinput 1.3.1 + +* Fri May 20 2016 Peter Hutterer 1.3.0-3 +- Stop pointer jitter on the Dell E5420, E530 and Lenovo Yoga 2 + +* Thu May 19 2016 Peter Hutterer 1.3.0-2 +- Disable negative pressure transition on non-synaptics pads to avoid + jerky movement (#1335249) + +* Tue May 10 2016 Peter Hutterer 1.3.0-1 +- libinput 1.3.0 + +* Wed May 04 2016 Peter Hutterer 1.2.903-1 +- libinput 1.3rc3 + +* Thu Apr 21 2016 Peter Hutterer 1.2.902-1 +- libinput 1.3rc2 + +* Tue Apr 19 2016 Peter Hutterer 1.2.4-1 +- libinput 1.2.4 + +* Tue Apr 12 2016 Peter Hutterer 1.2.3-1 +- libinput 1.2.3 + +* Tue Mar 15 2016 Peter Hutterer 1.2.2-1 +- libinput 1.2.2 + +* Fri Mar 11 2016 Peter Hutterer 1.2.1-4 +- Fix jerky pointer motion on the Lenovo T450/T460/X1 3rd hardware + +* Mon Mar 07 2016 Peter Hutterer 1.2.1-3 +- Fix segfault on mislabeled tablets (#1314955) + +* Wed Mar 02 2016 Peter Hutterer 1.2.1-2 +- Bump to maintain upgrade path with F23 + +* Mon Feb 29 2016 Peter Hutterer 1.2.1-1 +- libinput 1.2.1 + +* Tue Feb 23 2016 Peter Hutterer 1.2.0-1 +- libinput 1.2.0 + +* Mon Feb 15 2016 Peter Hutterer 1.1.902-2 +- Add libwacom-devel to BuildRequires + +* Mon Feb 15 2016 Peter Hutterer 1.1.902-1 +- libinput 1.2rc2 + +* Wed Feb 10 2016 Peter Hutterer 1.1.7-1 +- libinput 1.1.7 + +* Fri Feb 05 2016 Peter Hutterer 1.1.6-1 +- libinput 1.1.6 + +* Thu Feb 04 2016 Peter Hutterer 1.1.5-4 +- Fix patches from -3, they got corrupted somehow + +* Thu Feb 04 2016 Peter Hutterer 1.1.5-3 +- Disable the mode button on the Cyborg RAT 5 +- Drop touchpad motion hysteresis by default + +* Thu Feb 04 2016 Fedora Release Engineering - 1.1.5-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Mon Jan 25 2016 Peter Hutterer 1.1.5-1 +- libinput 1.1.5 + +* Tue Jan 19 2016 Peter Hutterer 1.1.4-3 +- disable MT for semi-mt devices to solve the various two- and three-finger + issues (at the cost of pinch gestures) (#1295073) + +* Mon Jan 11 2016 Peter Hutterer 1.1.4-2 +- fix disable-while-typing on macbooks + +* Tue Dec 22 2015 Peter Hutterer 1.1.4-1 +- libinput 1.1.4 + +* Wed Dec 16 2015 Peter Hutterer 1.1.3-1 +- libinput 1.1.3 + +* Wed Dec 09 2015 Peter Hutterer 1.1.2-1 +- libinput 1.1.2 + +* Mon Dec 07 2015 Peter Hutterer 1.1.1-2 +- Reduce 2fg scroll threshold to 1mm (#1247958) + +* Mon Nov 16 2015 Peter Hutterer 1.1.1-1 +- libinput 1.1.1 + +* Mon Nov 02 2015 Peter Hutterer 1.1.0-3 +- Fix invalid device group pointer, causing invalid memory access + +* Wed Oct 28 2015 Peter Hutterer 1.1.0-2 +- Fix crash triggered by Asus RoG Gladius mouse (#1275407) + +* Mon Oct 26 2015 Peter Hutterer 1.1.0-1 +- libinput 1.1.0 + +* Wed Oct 21 2015 Peter Hutterer 1.0.2-1 +- libinput 1.0.2 + +* Sat Sep 19 2015 Peter Hutterer 1.0.1-3 +- Fix the number of clicks sent in multitap (fdo #92016) + +* Mon Sep 07 2015 Peter Hutterer 1.0.1-2 +- Don't interpret short scrolls as right click (#1256045) + +* Thu Sep 03 2015 Peter Hutterer 1.0.1-1 +- libinput 1.0.1 + +* Wed Aug 26 2015 Peter Hutterer 1.0.0-1 +- libinput 1.0 + +* Fri Aug 21 2015 Peter Hutterer 0.99.1-1 +- libinput 1.0RC1 + +* Wed Aug 05 2015 Peter Hutterer 0.21.0-3 +- Fix 2fg scroll threshold handling (#1249365) + +* Tue Aug 04 2015 Peter Hutterer 0.21.0-2 +- Fix pointer speed configuration, broke with 0.21.0 + +* Tue Aug 04 2015 Peter Hutterer 0.21.0-1 +- libinput 0.21.0 +- fix 3fg touch detection on Synaptics semi-mt touchpads + +* Thu Jul 30 2015 Peter Hutterer 0.20.0-6 +- Fix broken 2fg scrolling on single-touch touchpads (#1246651) +- Drop distance threshold for 2fg gesture detection (#1246868) + +* Wed Jul 29 2015 Peter Hutterer 0.20.0-5 +- Add a size hint for Apple one-button touchpads (#1246651) + +* Wed Jul 29 2015 Peter Hutterer 0.20.0-4 +- Disable 2fg scrolling on Synaptics semi-mt (#1235175) + +* Fri Jul 24 2015 Peter Hutterer 0.20.0-3 +- Disable thumb detection, too many false positives (#1246093) + +* Tue Jul 21 2015 Peter Hutterer 0.20.0-2 +- Restore parsing for trackpoing const accel + +* Thu Jul 16 2015 Peter Hutterer 0.20.0-1 +- libinput 0.20 + +* Tue Jul 14 2015 Peter Hutterer 0.19.0-3 +- Only edge scroll when the finger is on the actual edge + +* Thu Jul 09 2015 Peter Hutterer 0.19.0-2 +- enable edge scrolling on clickpads (#1225579) + +* Mon Jul 06 2015 Peter Hutterer 0.19.0-1 +- libinput 0.19.0 + +* Wed Jul 01 2015 Peter Hutterer 0.18.0-5 +- Improve trackpoint->touchpad transition responsiveness (#1233844) + +* Mon Jun 29 2015 Peter Hutterer 0.18.0-4 +- Steepen deceleration curve to get better 1:1 movement on slow speeds + (#1231304) +- Provide custom accel method for <1000dpi mice (#1227039) + +* Thu Jun 25 2015 Peter Hutterer 0.18.0-3 +- Fix stuck finger after a clickpad click on resolutionless touchpads + +* Wed Jun 24 2015 Peter Hutterer 0.18.0-2 +- Fix initial jump during edge scrolling + +* Mon Jun 22 2015 Peter Hutterer 0.18.0-1 +- libinput 0.18.0 + +* Tue Jun 16 2015 Peter Hutterer 0.17.0-5 +- Use physical values for the hystersis where possible (#1230462) +- Disable right-edge palm detection when edge scrolling is active + (fdo#90980) + +* Tue Jun 16 2015 Peter Hutterer 0.17.0-4 +- Avoid erroneous finger movement after a physical click (#1230441) + +* Fri Jun 12 2015 Peter Hutterer 0.17.0-3 +- Require udev.pc for the build + +* Tue Jun 09 2015 Peter Hutterer 0.17.0-2 +- Cap the minimum acceleration slowdown at 0.3 (#1227796) + +* Thu Jun 04 2015 Peter Hutterer 0.17.0-1 +- libinput 0.17 + +* Tue Jun 02 2015 Peter Hutterer 0.16.0-4 +- Always set the middle button as default button for button-scrolling + (#1227182) + +* Tue Jun 02 2015 Peter Hutterer 0.16.0-3 +- Reduce tap-n-drag timeout (#1225998) + +* Tue Jun 02 2015 Peter Hutterer 0.16.0-2 +- Handle slow motions better (#1227039) + +* Tue Jun 02 2015 Peter Hutterer 0.16.0-1 +- libinput 0.16.0 + +* Fri May 29 2015 Peter Hutterer 0.15.0-4 +- Add tap-to-end-drag patch (#1225998) + +* Wed May 27 2015 Peter Hutterer 0.15.0-3 +- Refine disable-while-typing (#1209753) + +* Mon May 18 2015 Peter Hutterer 0.15.0-2 +- Add disable-while-typing feature (#1209753) + +* Tue May 05 2015 Peter Hutterer 0.15.0-1 +- libinput 0.15.0 + +* Fri Apr 24 2015 Peter Hutterer 0.14.1-2 +- Fix crash with the MS Surface Type Cover (#1206869) + +* Wed Apr 22 2015 Peter Hutterer 0.14.1-1 +- libinput 0.14.1 + +* Thu Apr 16 2015 Peter Hutterer 0.13.0-6 +- git add the patch... + +* Thu Apr 16 2015 Peter Hutterer 0.13.0-5 +- Reduce palm detection threshold to 70mm (#1209753) +- Don't allow taps in the top part of the palm zone (#1209753) + +* Thu Apr 09 2015 Peter Hutterer 0.13.0-4 +- Fix finger miscounts on single-touch touchpads (#1209151) + +* Wed Apr 08 2015 Peter Hutterer 0.13.0-3 +- Fix mouse slowdown (#1208992) + +* Wed Apr 08 2015 Peter Hutterer 0.13.0-2 +- Fix crasher triggered by fake MT devices without ABS_X/Y (#1207574) + +* Tue Mar 24 2015 Peter Hutterer 0.13.0-1 +- libinput 0.13.0 + +* Fri Mar 20 2015 Peter Hutterer 0.12.0-2 +- Install the udev rules in the udevdir, not libdir (#1203645) + +* Tue Mar 10 2015 Peter Hutterer 0.12.0-1 +- libinput 0.12.0 + +* Mon Feb 23 2015 Peter Hutterer 0.11.0-1 +- libinput 0.11.0 + +* Fri Feb 06 2015 Peter Hutterer 0.10.0-1 +- libinput 0.10.0 + +* Fri Jan 30 2015 Peter Hutterer 0.9.0-1 +- libinput 0.9.0 + +* Mon Jan 19 2015 Peter Hutterer 0.8.0-1 +- libinput 0.8.0 + +* Thu Dec 11 2014 Peter Hutterer 0.7.0-2.20141211git58abea394 +- git snapshot, fixes a crasher and fd confusion after suspending a device + +* Fri Dec 05 2014 Peter Hutterer 0.7.0-1 +- libinput 0.7.0 + +* Mon Nov 24 2014 Peter Hutterer 0.6.0-3.20141124git92d178f16 +- Add the hooks to build from a git snapshot +- Disable silent rules +- Update to today's git master + +* Fri Sep 12 2014 Peter Hutterer 0.6.0-2 +- libinput 0.6.0 + +* Sun Aug 17 2014 Fedora Release Engineering - 0.5.0-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild + +* Wed Jul 23 2014 Peter Hutterer 0.5.0-1 +- libinput 0.5.0 + +* Wed Jul 02 2014 Peter Hutterer 0.4.0-2 +- Add the new touchpad pointer acceleration code + +* Wed Jun 25 2014 Kalev Lember - 0.4.0-1 +- Update to 0.4.0 + +* Sat Jun 07 2014 Fedora Release Engineering - 0.2.0-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Fri May 23 2014 Peter Hutterer 0.2.0-1 +- libinput 0.2.0 + +* Fri Feb 28 2014 Kalev Lember - 0.1.0-1 +- Initial Fedora packaging diff --git a/sources b/sources new file mode 100644 index 0000000..bf9fdd4 --- /dev/null +++ b/sources @@ -0,0 +1 @@ +SHA512 (libinput-1.16.3.tar.xz) = cdf87988b24dc0a44b7b6ed3e15e70c7702bf65f1cfe257924967677c7a1f1485011a9e30254ba8962c83885de78f824e7955cedb07322676332d42532ec4a39