From 82750a240db9225e865a98e8a387dc95db94915e Mon Sep 17 00:00:00 2001 From: JengHyun Kang Date: Thu, 7 Jan 2016 17:23:24 +0900 Subject: [PATCH] Add a patch for support extra touch events. - libinput commit name: add orientation and size of touch point and pressure to the API Change-Id: Icfd09c132b51bf15837f11bdd662181e666960b5 --- packaging/libinput.spec | 1 + src/evdev-fallback.c | 47 ++++++++- src/evdev-fallback.h | 2 + src/evdev.c | 43 ++++++++ src/evdev.h | 15 +++ src/libinput-private.h | 13 ++- src/libinput.c | 162 ++++++++++++++++++++++++++++- src/libinput.h | 222 ++++++++++++++++++++++++++++++++++++++++ src/libinput.sym | 10 ++ 9 files changed, 505 insertions(+), 10 deletions(-) mode change 100755 => 100644 packaging/libinput.spec diff --git a/packaging/libinput.spec b/packaging/libinput.spec old mode 100755 new mode 100644 index b1922005..af0deada --- a/packaging/libinput.spec +++ b/packaging/libinput.spec @@ -16,6 +16,7 @@ BuildRequires: pkgconfig(libevdev) BuildRequires: pkgconfig(libevent) BuildRequires: pkgconfig(libudev) BuildRequires: pkgconfig(mtdev) +BuildRequires: pkgconfig(wacom) %description diff --git a/src/evdev-fallback.c b/src/evdev-fallback.c index 0b756610..87fd26f6 100644 --- a/src/evdev-fallback.c +++ b/src/evdev-fallback.c @@ -254,7 +254,7 @@ fallback_flush_mt_down(struct fallback_dispatch *dispatch, evdev_transform_absolute(device, &point); touch_notify_touch_down(base, time, slot_idx, seat_slot, - &point); + &point, &slot->area, slot->pressure); return true; } @@ -285,7 +285,7 @@ fallback_flush_mt_motion(struct fallback_dispatch *dispatch, evdev_transform_absolute(device, &point); touch_notify_touch_motion(base, time, slot_idx, seat_slot, - &point); + &point, &slot->area, slot->pressure); return true; } @@ -355,6 +355,11 @@ fallback_flush_st_down(struct fallback_dispatch *dispatch, struct libinput_seat *seat = base->seat; struct device_coords point; int seat_slot; + struct ellipse default_touch = { + .major = DEFAULT_TOUCH_MAJOR, + .minor = DEFAULT_TOUCH_MINOR, + .orientation = DEFAULT_TOUCH_ORIENTATION + }; if (!(device->seat_caps & EVDEV_DEVICE_TOUCH)) return false; @@ -376,7 +381,7 @@ fallback_flush_st_down(struct fallback_dispatch *dispatch, point = dispatch->abs.point; evdev_transform_absolute(device, &point); - touch_notify_touch_down(base, time, -1, seat_slot, &point); + touch_notify_touch_down(base, time, -1, seat_slot, &point, &default_touch, DEFAULT_TOUCH_PRESSURE); return true; } @@ -389,6 +394,11 @@ fallback_flush_st_motion(struct fallback_dispatch *dispatch, struct libinput_device *base = &device->base; struct device_coords point; int seat_slot; + struct ellipse default_touch = { + .major = DEFAULT_TOUCH_MAJOR, + .minor = DEFAULT_TOUCH_MINOR, + .orientation = DEFAULT_TOUCH_ORIENTATION + }; point = dispatch->abs.point; evdev_transform_absolute(device, &point); @@ -398,7 +408,7 @@ fallback_flush_st_motion(struct fallback_dispatch *dispatch, if (seat_slot == -1) return false; - touch_notify_touch_motion(base, time, -1, seat_slot, &point); + touch_notify_touch_motion(base, time, -1, seat_slot, &point, &default_touch, DEFAULT_TOUCH_PRESSURE); return true; } @@ -600,6 +610,23 @@ fallback_process_touch(struct fallback_dispatch *dispatch, dispatch->pending_event |= EVDEV_ABSOLUTE_MT; slot->dirty = true; break; + case ABS_MT_TOUCH_MAJOR: + dispatch->mt.slots[dispatch->mt.slot].area.major = e->value; + if (dispatch->pending_event == EVDEV_NONE) + dispatch->pending_event = EVDEV_ABSOLUTE_MT; + break; + case ABS_MT_TOUCH_MINOR: + dispatch->mt.slots[dispatch->mt.slot].area.minor = e->value; + if (dispatch->pending_event == EVDEV_NONE) + dispatch->pending_event = EVDEV_ABSOLUTE_MT; + break; + case ABS_MT_ORIENTATION: + dispatch->mt.slots[dispatch->mt.slot].area.orientation = e->value; + if (dispatch->pending_event == EVDEV_NONE) + dispatch->pending_event = EVDEV_ABSOLUTE_MT; + break; + default: + break; } } @@ -1566,6 +1593,18 @@ fallback_dispatch_init_slots(struct fallback_dispatch *dispatch, slots[slot].point.y = libevdev_get_slot_value(evdev, slot, ABS_MT_POSITION_Y); + slots[slot].area.major = libevdev_get_slot_value(evdev, + slot, + ABS_MT_TOUCH_MAJOR); + slots[slot].area.minor = libevdev_get_slot_value(evdev, + slot, + ABS_MT_TOUCH_MINOR); + slots[slot].area.orientation = libevdev_get_slot_value(evdev, + slot, + ABS_MT_ORIENTATION); + slots[slot].pressure = libevdev_get_slot_value(evdev, + slot, + ABS_MT_PRESSURE); } dispatch->mt.slots = slots; dispatch->mt.slots_len = num_slots; diff --git a/src/evdev-fallback.h b/src/evdev-fallback.h index 519ae0a9..fd01c752 100644 --- a/src/evdev-fallback.h +++ b/src/evdev-fallback.h @@ -80,6 +80,8 @@ struct mt_slot { struct device_coords point; struct device_coords hysteresis_center; enum palm_state palm_state; + struct ellipse area; + int32_t pressure; }; struct fallback_dispatch { diff --git a/src/evdev.c b/src/evdev.c index 4b37064f..cc02e7bb 100644 --- a/src/evdev.c +++ b/src/evdev.c @@ -44,6 +44,7 @@ #include "libinput-private.h" #include "quirks.h" #include "util-input-event.h" +#include "stdio.h" #if HAVE_LIBWACOM #include @@ -399,6 +400,42 @@ evdev_device_transform_y(struct evdev_device *device, return absinfo_scale_axis(device->abs.absinfo_y, y, height); } +double +evdev_device_transform_orientation(struct evdev_device *device, + int32_t orientation) +{ + const struct input_absinfo *orientation_info = + device->abs.absinfo_orientation; + + double angle = DEFAULT_TOUCH_ORIENTATION; + + /* ABS_MT_ORIENTATION is defined as a clockwise rotation - zero + * (instead of minimum) is mapped to the y-axis, and maximum is + * mapped to the x-axis. So minimum is likely to be negative but + * plays no role in scaling the value to degrees.*/ + if (orientation_info) + angle = (90.0 * orientation) / orientation_info->maximum; + + return fmod(360.0 + angle, 360.0); +} + +double +evdev_device_transform_pressure(struct evdev_device *device, + int32_t pressure) +{ + const struct input_absinfo *pressure_info = + device->abs.absinfo_pressure; + + if (pressure_info) { + double max_pressure = pressure_info->maximum; + double min_pressure = pressure_info->minimum; + return (pressure - min_pressure) / + (max_pressure - min_pressure); + } else { + return DEFAULT_TOUCH_PRESSURE; + } +} + void evdev_notify_axis_legacy_wheel(struct evdev_device *device, uint64_t time, @@ -1864,8 +1901,14 @@ evdev_extract_abs_axes(struct evdev_device *device, device->abs.absinfo_x = libevdev_get_abs_info(evdev, ABS_MT_POSITION_X); device->abs.absinfo_y = libevdev_get_abs_info(evdev, ABS_MT_POSITION_Y); + device->abs.absinfo_orientation = libevdev_get_abs_info(evdev, ABS_MT_ORIENTATION); + device->abs.absinfo_pressure = libevdev_get_abs_info(evdev, ABS_MT_PRESSURE); + device->abs.absinfo_major = libevdev_get_abs_info(evdev, ABS_MT_TOUCH_MAJOR); + device->abs.absinfo_minor = libevdev_get_abs_info(evdev, ABS_MT_TOUCH_MINOR); + device->abs.dimensions.x = abs((int)absinfo_range(device->abs.absinfo_x)); device->abs.dimensions.y = abs((int)absinfo_range(device->abs.absinfo_y)); + device->is_mt = 1; } diff --git a/src/evdev.h b/src/evdev.h index 9f34253c..ee1d1cc5 100644 --- a/src/evdev.h +++ b/src/evdev.h @@ -42,6 +42,11 @@ /* The fake resolution value for abs devices without resolution */ #define EVDEV_FAKE_RESOLUTION 1 +#define DEFAULT_TOUCH_PRESSURE 1.0 +#define DEFAULT_TOUCH_ORIENTATION 0.0 +#define DEFAULT_TOUCH_MAJOR 0.0 +#define DEFAULT_TOUCH_MINOR 0.0 + enum evdev_event_type { EVDEV_NONE, EVDEV_ABSOLUTE_TOUCH_DOWN = bit(0), @@ -189,6 +194,7 @@ struct evdev_device { struct { const struct input_absinfo *absinfo_x, *absinfo_y; + const struct input_absinfo *absinfo_major, *absinfo_minor, *absinfo_pressure, *absinfo_orientation; bool is_fake_resolution; int apply_calibration; @@ -551,6 +557,15 @@ double evdev_device_transform_y(struct evdev_device *device, double y, uint32_t height); + +double +evdev_device_transform_orientation(struct evdev_device *device, + int32_t orientation); + +double +evdev_device_transform_pressure(struct evdev_device *device, + int32_t pressure); + void evdev_device_suspend(struct evdev_device *device); diff --git a/src/libinput-private.h b/src/libinput-private.h index baca85aa..c282e350 100644 --- a/src/libinput-private.h +++ b/src/libinput-private.h @@ -122,6 +122,11 @@ struct phys_ellipsis { double minor; }; +/* Ellipse parameters in device coordinates */ +struct ellipse { + int major, minor, orientation; +}; + struct libinput_interface_backend { int (*resume)(struct libinput *libinput); void (*suspend)(struct libinput *libinput); @@ -704,14 +709,18 @@ touch_notify_touch_down(struct libinput_device *device, uint64_t time, int32_t slot, int32_t seat_slot, - const struct device_coords *point); + const struct device_coords *point, + const struct ellipse *area, + int32_t pressure); void touch_notify_touch_motion(struct libinput_device *device, uint64_t time, int32_t slot, int32_t seat_slot, - const struct device_coords *point); + const struct device_coords *point, + const struct ellipse *area, + int32_t pressure); void touch_notify_touch_up(struct libinput_device *device, diff --git a/src/libinput.c b/src/libinput.c index 783926d0..94bdff9c 100644 --- a/src/libinput.c +++ b/src/libinput.c @@ -195,8 +195,10 @@ struct libinput_event_touch { uint64_t time; int32_t slot; int32_t seat_slot; - struct device_coords point; -}; + struct device_coords point; + struct ellipse area; + int32_t pressure; + }; struct libinput_event_gesture { struct libinput_event base; @@ -970,6 +972,150 @@ libinput_event_touch_get_y(struct libinput_event_touch *event) return absinfo_convert_to_mm(device->abs.absinfo_y, event->point.y); } + LIBINPUT_EXPORT double + libinput_event_touch_get_major(struct libinput_event_touch *event) + { + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TOUCH_DOWN, + LIBINPUT_EVENT_TOUCH_MOTION); + + return event->area.major; + } + + LIBINPUT_EXPORT double + libinput_event_touch_get_major_transformed(struct libinput_event_touch *event, + uint32_t width, + uint32_t height) + { + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TOUCH_DOWN, + LIBINPUT_EVENT_TOUCH_MOTION); + + return event->area.major; + } + + LIBINPUT_EXPORT int + libinput_event_touch_has_major(struct libinput_event_touch *event) + { + struct evdev_device *device = + (struct evdev_device *) event->base.device; + + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TOUCH_DOWN, + LIBINPUT_EVENT_TOUCH_MOTION); + + return device->abs.absinfo_major != 0; + } + + LIBINPUT_EXPORT double + libinput_event_touch_get_minor(struct libinput_event_touch *event) + { + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TOUCH_DOWN, + LIBINPUT_EVENT_TOUCH_MOTION); + + return event->area.minor; + } + + LIBINPUT_EXPORT double + libinput_event_touch_get_minor_transformed(struct libinput_event_touch *event, + uint32_t width, + uint32_t height) + { + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TOUCH_DOWN, + LIBINPUT_EVENT_TOUCH_MOTION); + + return event->area.minor; + } + + LIBINPUT_EXPORT int + libinput_event_touch_has_minor(struct libinput_event_touch *event) + { + struct evdev_device *device = + (struct evdev_device *) event->base.device; + + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TOUCH_DOWN, + LIBINPUT_EVENT_TOUCH_MOTION); + + return device->abs.absinfo_minor != 0; + } + + LIBINPUT_EXPORT double + libinput_event_touch_get_orientation(struct libinput_event_touch *event) + { + struct evdev_device *device = + (struct evdev_device *) event->base.device; + + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TOUCH_DOWN, + LIBINPUT_EVENT_TOUCH_MOTION); + + return evdev_device_transform_orientation(device, + event->area.orientation); + } + + LIBINPUT_EXPORT int + libinput_event_touch_has_orientation(struct libinput_event_touch *event) + { + struct evdev_device *device = + (struct evdev_device *) event->base.device; + + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TOUCH_DOWN, + LIBINPUT_EVENT_TOUCH_MOTION); + + return device->abs.absinfo_orientation != 0; + } + + LIBINPUT_EXPORT double + libinput_event_touch_get_pressure(struct libinput_event_touch *event) + { + struct evdev_device *device = + (struct evdev_device *) event->base.device; + + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TOUCH_DOWN, + LIBINPUT_EVENT_TOUCH_MOTION); + + return evdev_device_transform_pressure(device, + event->pressure); + } + + LIBINPUT_EXPORT int + libinput_event_touch_has_pressure(struct libinput_event_touch *event) + { + struct evdev_device *device = + (struct evdev_device *) event->base.device; + + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TOUCH_DOWN, + LIBINPUT_EVENT_TOUCH_MOTION); + + return device->abs.absinfo_pressure != 0; + } + LIBINPUT_EXPORT uint32_t libinput_event_gesture_get_time(struct libinput_event_gesture *event) { @@ -2644,7 +2790,9 @@ touch_notify_touch_down(struct libinput_device *device, uint64_t time, int32_t slot, int32_t seat_slot, - const struct device_coords *point) + const struct device_coords *point, + const struct ellipse *area, + int32_t pressure) { struct libinput_event_touch *touch_event; @@ -2658,6 +2806,8 @@ touch_notify_touch_down(struct libinput_device *device, .slot = slot, .seat_slot = seat_slot, .point = *point, + .area = *area, + .pressure = pressure, }; post_device_event(device, time, @@ -2670,7 +2820,9 @@ touch_notify_touch_motion(struct libinput_device *device, uint64_t time, int32_t slot, int32_t seat_slot, - const struct device_coords *point) + const struct device_coords *point, + const struct ellipse *area, + int32_t pressure) { struct libinput_event_touch *touch_event; @@ -2684,6 +2836,8 @@ touch_notify_touch_motion(struct libinput_device *device, .slot = slot, .seat_slot = seat_slot, .point = *point, + .area = *area, + .pressure = pressure, }; post_device_event(device, time, diff --git a/src/libinput.h b/src/libinput.h index 2e4cfb85..50423151 100644 --- a/src/libinput.h +++ b/src/libinput.h @@ -1897,6 +1897,228 @@ double libinput_event_touch_get_y_transformed(struct libinput_event_touch *event, uint32_t height); +/** + * @ingroup event_touch + * + * Return the diameter of the major axis of the touch ellipse in mm. + * This value might not be provided by the device, in that case the value + * 0.0 is returned. + * + * A more detailed explanation can be found in @ref touch_event_properties. + * + * For events not of type @ref LIBINPUT_EVENT_TOUCH_DOWN, @ref + * LIBINPUT_EVENT_TOUCH_MOTION, this function returns 0. + * + * @note It is an application bug to call this function for events of type + * other than @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION. + * + * @param event The libinput touch event + * @return The current major axis diameter + */ +double +libinput_event_touch_get_major(struct libinput_event_touch *event); + +/** + * @ingroup event_touch + * + * Return the diameter of the major axis of the touch ellipse in screen + * space. This value might not be provided by the device, in that case the + * value 0.0 is returned. + * + * A more detailed explanation can be found in @ref touch_event_properties. + * + * For events not of type @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION this function returns 0. + * + * @note It is an application bug to call this function for events of type + * other than @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION. + * + * @param event The libinput touch event + * @param width The current output screen width + * @param height The current output screen height + * @return The current major axis diameter + */ +double +libinput_event_touch_get_major_transformed(struct libinput_event_touch *event, + uint32_t width, + uint32_t height); + +/** + * @ingroup event_touch + * + * Return whether the event contains a major axis value of the touch ellipse. + * + * A more detailed explanation can be found in @ref touch_event_properties. + * + * For events not of type @ref LIBINPUT_EVENT_TOUCH_DOWN, @ref + * LIBINPUT_EVENT_TOUCH_MOTION, this function returns 0. + * + * @note It is an application bug to call this function for events of type + * other than @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION. + * + * @param event The libinput touch event + * @return Non-zero when a major diameter is available + */ +int +libinput_event_touch_has_major(struct libinput_event_touch *event); + +/** + * @ingroup event_touch + * + * Return the diameter of the minor axis of the touch ellipse in mm. + * This value might not be provided by the device, in this case the value + * 0.0 is returned. + * + * A more detailed explanation can be found in @ref touch_event_properties. + * + * For events not of type @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION this function returns 0. + * + * @note It is an application bug to call this function for events of type + * other than @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION. + * + * @param event The libinput touch event + * @return The current minor diameter + */ +double +libinput_event_touch_get_minor(struct libinput_event_touch *event); + +/** + * @ingroup event_touch + * + * Return the diameter of the minor axis of the touch ellipse in screen + * space. This value might not be provided by the device, in this case + * the value 0.0 is returned. + * + * A more detailed explanation can be found in @ref touch_event_properties. + * + * For events not of type @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION this function returns 0. + * + * @note It is an application bug to call this function for events of type + * other than @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION. + * + * @param event The libinput touch event + * @param width The current output screen width + * @param height The current output screen height + * @return The current minor diameter + */ +double +libinput_event_touch_get_minor_transformed(struct libinput_event_touch *event, + uint32_t width, + uint32_t height); +/** + * @ingroup event_touch + * + * Return whether the event contains a minor axis value of the touch ellipse. + * + * A more detailed explanation can be found in @ref touch_event_properties. + * + * For events not of type @ref LIBINPUT_EVENT_TOUCH_DOWN, @ref + * LIBINPUT_EVENT_TOUCH_MOTION, this function returns 0. + * + * @note It is an application bug to call this function for events of type + * other than @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION. + * + * @param event The libinput touch event + * @return Non-zero when a minor diameter is available + */ +int +libinput_event_touch_has_minor(struct libinput_event_touch *event); + +/** + * @ingroup event_touch + * + * Return the pressure value applied to the touch contact normalized to the + * range [0, 1]. If this value is not available the function returns the maximum + * value 1.0. + * + * A more detailed explanation can be found in @ref touch_event_properties. + * + * For events not of type @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION this function returns 0. + * + * @note It is an application bug to call this function for events of type + * other than @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION. + * + * @param event The libinput touch event + * @return The current pressure value + */ +double +libinput_event_touch_get_pressure(struct libinput_event_touch *event); + +/** + * @ingroup event_touch + * + * Return whether the event contains a pressure value for the touch contact. + * + * A more detailed explanation can be found in @ref touch_event_properties. + * + * For events not of type @ref LIBINPUT_EVENT_TOUCH_DOWN, @ref + * LIBINPUT_EVENT_TOUCH_MOTION, this function returns 0. + * + * @note It is an application bug to call this function for events of type + * other than @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION. + * + * @param event The libinput touch event + * @return Non-zero when a pressure value is available + */ +int +libinput_event_touch_has_pressure(struct libinput_event_touch *event); + +/** + * @ingroup event_touch + * + * Return the major axis rotation in degrees, clockwise from the logical north + * of the touch screen. + * + * @note Even when the orientation is measured by the device, it might be only + * available in coarse steps (e.g only indicating alignment with either of the + * axes). + * + * A more detailed explanation can be found in @ref touch_event_properties. + * + * For events not of type @ref LIBINPUT_EVENT_TOUCH_DOWN, @ref + * LIBINPUT_EVENT_TOUCH_MOTION, this function returns 0. + * + * @note It is an application bug to call this function for events of type + * other than @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION. + * + * @param event The libinput touch event + * @return The current orientation value + */ +double +libinput_event_touch_get_orientation(struct libinput_event_touch *event); + +/** + * @ingroup event_touch + * + * Return whether the event contains a orientation value for the touch contact. + * + * A more detailed explanation can be found in @ref touch_event_properties. + * + * For events not of type @ref LIBINPUT_EVENT_TOUCH_DOWN, @ref + * LIBINPUT_EVENT_TOUCH_MOTION, this function returns 0. + * + * @note It is an application bug to call this function for events of type + * other than @ref LIBINPUT_EVENT_TOUCH_DOWN or @ref + * LIBINPUT_EVENT_TOUCH_MOTION. + * + * @param event The libinput touch event + * @return Non-zero when an orientation value is available + */ +int +libinput_event_touch_has_orientation(struct libinput_event_touch *event); + /** * @ingroup event_touch * diff --git a/src/libinput.sym b/src/libinput.sym index 2f3a7eee..fe5a9a3c 100644 --- a/src/libinput.sym +++ b/src/libinput.sym @@ -179,6 +179,16 @@ LIBINPUT_1.1 { libinput_device_config_accel_get_profiles; libinput_device_config_accel_get_default_profile; libinput_device_config_accel_set_profile; + libinput_event_touch_get_major; + libinput_event_touch_get_major_transformed; + libinput_event_touch_get_minor; + libinput_event_touch_get_minor_transformed; + libinput_event_touch_get_orientation; + libinput_event_touch_get_pressure; + libinput_event_touch_has_major; + libinput_event_touch_has_minor; + libinput_event_touch_has_orientation; + libinput_event_touch_has_pressure; } LIBINPUT_0.21.0; LIBINPUT_1.2 { -- 2.34.1