[PATCH v2 libinput] Change axis events to carry all directions
Hans de Goede
hdegoede at redhat.com
Fri Jan 9 04:05:53 PST 2015
Hi,
On 07-01-15 02:33, Peter Hutterer wrote:
> Sending separate axis events instead of one unified events is limiting,
> especially when simultaneously scrolling in both directions and the caller
> tries to implement kinetic scrolling.
>
> Take a page from the tablet-support branch and instead implement the axis
> event as a generic event that can contain multiple axes simultaneously.
>
> Right now we only have two (scroll) axes and we could easily just check both
> for non-zero values. If we want to allow further axes in the future, we need
> a check whether an axis is set in an event, that's what
> libinput_event_pointer_has_axis to scroll events() is for.
>
> We also need the mask to notify of a scroll stop event, which could otherwise
> be confused as a vertical-only or horizontal-only event.
>
> This is an API and ABI break.
>
> Signed-off-by: Peter Hutterer <peter.hutterer at who-t.net>
> ---
> I think I addressed the comments but I'm not 100% sure. Squashed both patches
> now together to make it easier this time.
>
> Changes to v1:
> - use AS_MASK in edge scrolling
> - libinput_event_pointer_get_axis_value() checks for the bit being set and
> logs a client bug
> - added early bail out if edge scrolling deltas for the direction we want are 0
> - use !!(axes & mask) as return value for libinput_event_pointer_has_axis()
> to avoid leaking mask values
See (minor) comments inline.
>
> src/evdev-mt-touchpad-edge-scroll.c | 27 ++++++++++------
> src/evdev.c | 62 ++++++++++++++++++-------------------
> src/libinput-private.h | 4 +--
> src/libinput-util.h | 1 +
> src/libinput.c | 47 +++++++++++++++++++++-------
> src/libinput.h | 22 +++++++------
> test/litest.c | 19 ++++++------
> test/pointer.c | 11 ++++---
> test/touchpad.c | 16 +++++-----
> tools/event-debug.c | 22 ++++---------
> tools/event-gui.c | 18 +++++------
> 11 files changed, 141 insertions(+), 108 deletions(-)
>
> diff --git a/src/evdev-mt-touchpad-edge-scroll.c b/src/evdev-mt-touchpad-edge-scroll.c
> index a4dc093..093cd5d 100644
> --- a/src/evdev-mt-touchpad-edge-scroll.c
> +++ b/src/evdev-mt-touchpad-edge-scroll.c
> @@ -314,7 +314,7 @@ tp_edge_scroll_post_events(struct tp_dispatch *tp, uint64_t time)
> struct libinput_device *device = &tp->device->base;
> struct tp_touch *t;
> enum libinput_pointer_axis axis;
> - double dx, dy, *delta;
> + double dx, dy;
>
> tp_for_each_touch(tp, t) {
> if (!t->dirty)
> @@ -325,19 +325,17 @@ tp_edge_scroll_post_events(struct tp_dispatch *tp, uint64_t time)
> if (t->scroll.direction != -1) {
> /* Send stop scroll event */
> pointer_notify_axis(device, time,
> - t->scroll.direction,
> + AS_MASK(t->scroll.direction),
> LIBINPUT_POINTER_AXIS_SOURCE_FINGER,
> - 0.0);
> + 0.0, 0.0);
> t->scroll.direction = -1;
> }
> continue;
> case EDGE_RIGHT:
> axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
> - delta = &dy;
> break;
> case EDGE_BOTTOM:
> axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
> - delta = &dx;
> break;
> default: /* EDGE_RIGHT | EDGE_BOTTOM */
> continue; /* Don't know direction yet, skip */
> @@ -346,12 +344,21 @@ tp_edge_scroll_post_events(struct tp_dispatch *tp, uint64_t time)
> tp_get_delta(t, &dx, &dy);
> tp_filter_motion(tp, &dx, &dy, NULL, NULL, time);
>
> - if (fabs(*delta) < t->scroll.threshold)
> + if (fabs(dx) < t->scroll.threshold)
> + dx = 0.0;
> + if (fabs(dy) < t->scroll.threshold)
> + dy = 0.0;
> +
> + if ((dx == 0.0 &&
> + axis == LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL) ||
> + (dy == 0.0 &&
> + axis == LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))
> continue;
>
Why not simply keep the delta pointer and the:
if (fabs(*delta) < t->scroll.threshold)
continue;
? That has the same result, the value of the other axis is
irrelevant since we only pass in the axes mask for the one axis.
> - pointer_notify_axis(device, time, axis,
> + pointer_notify_axis(device, time,
> + AS_MASK(axis),
> LIBINPUT_POINTER_AXIS_SOURCE_FINGER,
> - *delta);
> + dx, dy);
> t->scroll.direction = axis;
>
> tp_edge_scroll_handle_event(tp, t, SCROLL_EVENT_POSTED);
> @@ -369,9 +376,9 @@ tp_edge_scroll_stop_events(struct tp_dispatch *tp, uint64_t time)
> tp_for_each_touch(tp, t) {
> if (t->scroll.direction != -1) {
> pointer_notify_axis(device, time,
> - t->scroll.direction,
> + AS_MASK(t->scroll.direction),
> LIBINPUT_POINTER_AXIS_SOURCE_FINGER,
> - 0.0);
> + 0.0, 0.0);
> t->scroll.direction = -1;
> }
> }
> diff --git a/src/evdev.c b/src/evdev.c
> index 1718491..7597afc 100644
> --- a/src/evdev.c
> +++ b/src/evdev.c
> @@ -539,18 +539,20 @@ evdev_process_absolute_motion(struct evdev_device *device,
> static void
> evdev_notify_axis(struct evdev_device *device,
> uint64_t time,
> - enum libinput_pointer_axis axis,
> + uint32_t axes,
> enum libinput_pointer_axis_source source,
> - double value)
> + double x, double y)
> {
> - if (device->scroll.natural_scrolling_enabled)
> - value *= -1;
> + if (device->scroll.natural_scrolling_enabled) {
> + x *= -1;
> + y *= -1;
> + }
>
> pointer_notify_axis(&device->base,
> time,
> - axis,
> + axes,
> source,
> - value);
> + x, y);
> }
>
> static inline void
> @@ -575,8 +577,9 @@ evdev_process_relative(struct evdev_device *device,
> evdev_notify_axis(
> device,
> time,
> - LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
> + AS_MASK(LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL),
> LIBINPUT_POINTER_AXIS_SOURCE_WHEEL,
> + 0,
> -1 * e->value * DEFAULT_AXIS_STEP_DISTANCE);
> break;
> case REL_HWHEEL:
> @@ -584,9 +587,10 @@ evdev_process_relative(struct evdev_device *device,
> evdev_notify_axis(
> device,
> time,
> - LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
> + AS_MASK(LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL),
> LIBINPUT_POINTER_AXIS_SOURCE_WHEEL,
> - e->value * DEFAULT_AXIS_STEP_DISTANCE);
> + e->value * DEFAULT_AXIS_STEP_DISTANCE,
> + 0);
> break;
> }
> }
> @@ -1792,6 +1796,7 @@ evdev_post_scroll(struct evdev_device *device,
> double dy)
> {
> double trigger_horiz, trigger_vert;
> + uint32_t axes;
>
> if (!evdev_is_scrolling(device,
> LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))
> @@ -1829,28 +1834,29 @@ evdev_post_scroll(struct evdev_device *device,
> LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
> }
>
> + axes = device->scroll.direction;
> +
> /* We use the trigger to enable, but the delta from this event for
> * the actual scroll movement. Otherwise we get a jump once
> * scrolling engages */
> - if (dy != 0.0 &&
> - evdev_is_scrolling(device,
> + if (!evdev_is_scrolling(device,
> LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL)) {
> - evdev_notify_axis(device,
> - time,
> - LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
> - source,
> - dy);
> + dy = 0.0;
> + axes &= ~AS_MASK(LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
There is no need to clear axes here since axes == scroll.direction and
!evdev_is_scrolling(...) checks that the flag is not set in scroll.direction,
so you're clearing a flag which you've just checked is 0.
> }
> -
> - if (dx != 0.0 &&
> - evdev_is_scrolling(device,
> + if (!evdev_is_scrolling(device,
> LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)) {
> + dx = 0.0;
> + axes &= ~AS_MASK(LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
Idem.
> + }
> +
> + if (dx != 0.0 || dy != 0.0)
> evdev_notify_axis(device,
> time,
> - LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
> + axes,
And following the above logic you can just drop axes and use
device->scroll.direction directly, as you are doing below in the
evdev_stop_scroll case.
Cleanup: You may want to convert the code mangling / testing
device->scroll.direction to use AS_MASK.
> source,
> - dx);
> - }
> + dx,
> + dy);
> }
>
> void
> @@ -1859,18 +1865,12 @@ evdev_stop_scroll(struct evdev_device *device,
> enum libinput_pointer_axis_source source)
> {
> /* terminate scrolling with a zero scroll event */
> - if (device->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))
> + if (device->scroll.direction != 0)
> pointer_notify_axis(&device->base,
> time,
> - LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
> + device->scroll.direction,
> source,
> - 0);
> - if (device->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL))
> - pointer_notify_axis(&device->base,
> - time,
> - LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
> - source,
> - 0);
> + 0.0, 0.0);
>
> device->scroll.buildup_horizontal = 0;
> device->scroll.buildup_vertical = 0;
> diff --git a/src/libinput-private.h b/src/libinput-private.h
> index 84a0d44..0cb9b25 100644
> --- a/src/libinput-private.h
> +++ b/src/libinput-private.h
> @@ -278,9 +278,9 @@ pointer_notify_button(struct libinput_device *device,
> void
> pointer_notify_axis(struct libinput_device *device,
> uint64_t time,
> - enum libinput_pointer_axis axis,
> + uint32_t axes,
> enum libinput_pointer_axis_source source,
> - double value);
> + double x, double y);
>
> void
> touch_notify_touch_down(struct libinput_device *device,
> diff --git a/src/libinput-util.h b/src/libinput-util.h
> index 6825841..0abf6c2 100644
> --- a/src/libinput-util.h
> +++ b/src/libinput-util.h
> @@ -79,6 +79,7 @@ int list_empty(const struct list *list);
> #define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0])
> #define ARRAY_FOR_EACH(_arr, _elem) \
> for (size_t _i = 0; _i < ARRAY_LENGTH(_arr) && (_elem = &_arr[_i]); _i++)
> +#define AS_MASK(v) (1 << (v))
>
> #define min(a, b) (((a) < (b)) ? (a) : (b))
> #define max(a, b) (((a) > (b)) ? (a) : (b))
> diff --git a/src/libinput.c b/src/libinput.c
> index 426c306..d71ca67 100644
> --- a/src/libinput.c
> +++ b/src/libinput.c
> @@ -64,9 +64,8 @@ struct libinput_event_pointer {
> uint32_t button;
> uint32_t seat_button_count;
> enum libinput_button_state state;
> - enum libinput_pointer_axis axis;
> enum libinput_pointer_axis_source source;
> - double value;
> + uint32_t axes;
> };
>
> struct libinput_event_touch {
> @@ -379,16 +378,41 @@ libinput_event_pointer_get_seat_button_count(
> return event->seat_button_count;
> }
>
> -LIBINPUT_EXPORT enum libinput_pointer_axis
> -libinput_event_pointer_get_axis(struct libinput_event_pointer *event)
> +LIBINPUT_EXPORT int
> +libinput_event_pointer_has_axis(struct libinput_event_pointer *event,
> + enum libinput_pointer_axis axis)
> {
> - return event->axis;
> + if (event->base.type == LIBINPUT_EVENT_POINTER_AXIS) {
> + switch (axis) {
> + case LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL:
> + case LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL:
> + return !!(event->axes & (1 << axis));
Use AS_MASK ?
> + }
> + }
> + return 0;
> }
>
> LIBINPUT_EXPORT double
> -libinput_event_pointer_get_axis_value(struct libinput_event_pointer *event)
> +libinput_event_pointer_get_axis_value(struct libinput_event_pointer *event,
> + enum libinput_pointer_axis axis)
> {
> - return event->value;
> + struct libinput *libinput = event->base.device->seat->libinput;
> + double value = 0;
> +
> + if (!libinput_event_pointer_has_axis(event, axis)) {
> + log_bug_client(libinput, "value requested for unset axis\n");
> + } else {
> + switch (axis) {
> + case LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL:
> + value = event->x;
> + break;
> + case LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL:
> + value = event->y;
> + break;
> + }
> + }
> +
> + return value;
> }
>
> LIBINPUT_EXPORT enum libinput_pointer_axis_source
> @@ -992,9 +1016,9 @@ pointer_notify_button(struct libinput_device *device,
> void
> pointer_notify_axis(struct libinput_device *device,
> uint64_t time,
> - enum libinput_pointer_axis axis,
> + uint32_t axes,
> enum libinput_pointer_axis_source source,
> - double value)
> + double x, double y)
> {
> struct libinput_event_pointer *axis_event;
>
> @@ -1004,9 +1028,10 @@ pointer_notify_axis(struct libinput_device *device,
>
> *axis_event = (struct libinput_event_pointer) {
> .time = time,
> - .axis = axis,
> - .value = value,
> + .x = x,
> + .y = y,
> .source = source,
> + .axes = axes,
> };
>
> post_device_event(device, time,
> diff --git a/src/libinput.h b/src/libinput.h
> index 56b77c2..f9f538b 100644
> --- a/src/libinput.h
> +++ b/src/libinput.h
> @@ -653,17 +653,17 @@ libinput_event_pointer_get_seat_button_count(
> /**
> * @ingroup event_pointer
> *
> - * Return the axis that triggered this event.
> - * For pointer events that are not of type @ref LIBINPUT_EVENT_POINTER_AXIS,
> - * this function returns 0.
> + * Check if the event has a valid value for the given axis.
> *
> - * @note It is an application bug to call this function for events other than
> - * @ref LIBINPUT_EVENT_POINTER_AXIS.
> + * If this function returns non-zero for an axis and
> + * libinput_event_pointer_get_axis_value() returns a value of 0, the event
> + * is a scroll stop event.
> *
> - * @return the axis triggering this event
> + * @return non-zero if this event contains a value for this axis
> */
> -enum libinput_pointer_axis
> -libinput_event_pointer_get_axis(struct libinput_event_pointer *event);
> +int
> +libinput_event_pointer_has_axis(struct libinput_event_pointer *event,
> + enum libinput_pointer_axis axis);
>
> /**
> * @ingroup event_pointer
> @@ -676,6 +676,9 @@ libinput_event_pointer_get_axis(struct libinput_event_pointer *event);
> * respectively. For the interpretation of the value, see
> * libinput_event_pointer_get_axis_source().
> *
> + * If libinput_event_pointer_has_axis() returns 0 for an axis, this function
> + * returns 0 for that axis.
> + *
> * For pointer events that are not of type @ref LIBINPUT_EVENT_POINTER_AXIS,
> * this function returns 0.
> *
> @@ -685,7 +688,8 @@ libinput_event_pointer_get_axis(struct libinput_event_pointer *event);
> * @return the axis value of this event
> */
> double
> -libinput_event_pointer_get_axis_value(struct libinput_event_pointer *event);
> +libinput_event_pointer_get_axis_value(struct libinput_event_pointer *event,
> + enum libinput_pointer_axis axis);
>
> /**
> * @ingroup event_pointer
> diff --git a/test/litest.c b/test/litest.c
> index 392ffe2..757f445 100644
> --- a/test/litest.c
> +++ b/test/litest.c
> @@ -983,11 +983,11 @@ litest_print_event(struct libinput_event *event)
> case LIBINPUT_EVENT_POINTER_AXIS:
> p = libinput_event_get_pointer_event(event);
> fprintf(stderr,
> - "axis %s value %.2f",
> - libinput_event_pointer_get_axis(p) ==
> - LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL ?
> - "vert" : "horiz",
> - libinput_event_pointer_get_axis_value(p));
> + "vert %.f horiz %.2f",
> + libinput_event_pointer_get_axis_value(p,
> + LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL),
> + libinput_event_pointer_get_axis_value(p,
> + LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL));
> break;
> default:
> break;
> @@ -1198,23 +1198,24 @@ litest_assert_scroll(struct libinput *li,
> LIBINPUT_EVENT_POINTER_AXIS);
> ptrev = libinput_event_get_pointer_event(event);
> ck_assert(ptrev != NULL);
> - ck_assert_int_eq(libinput_event_pointer_get_axis(ptrev), axis);
>
> if (next_event) {
> /* Normal scroll event, check dir */
> if (minimum_movement > 0) {
> ck_assert_int_ge(
> - libinput_event_pointer_get_axis_value(ptrev),
> + libinput_event_pointer_get_axis_value(ptrev,
> + axis),
> minimum_movement);
> } else {
> ck_assert_int_le(
> - libinput_event_pointer_get_axis_value(ptrev),
> + libinput_event_pointer_get_axis_value(ptrev,
> + axis),
> minimum_movement);
> }
> } else {
> /* Last scroll event, must be 0 */
> ck_assert_int_eq(
> - libinput_event_pointer_get_axis_value(ptrev),
> + libinput_event_pointer_get_axis_value(ptrev, axis),
> 0);
> }
> libinput_event_destroy(event);
> diff --git a/test/pointer.c b/test/pointer.c
> index b9bd3cc..120e165 100644
> --- a/test/pointer.c
> +++ b/test/pointer.c
> @@ -348,6 +348,7 @@ test_wheel_event(struct litest_device *dev, int which, int amount)
> struct libinput *li = dev->libinput;
> struct libinput_event *event;
> struct libinput_event_pointer *ptrev;
> + enum libinput_pointer_axis axis;
>
> /* the current evdev implementation scales the scroll wheel events
> up by a factor 10 */
> @@ -372,11 +373,13 @@ test_wheel_event(struct litest_device *dev, int which, int amount)
>
> ptrev = libinput_event_get_pointer_event(event);
> ck_assert(ptrev != NULL);
> - ck_assert_int_eq(libinput_event_pointer_get_axis(ptrev),
> - which == REL_WHEEL ?
> +
> + axis = (which == REL_WHEEL) ?
> LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL :
> - LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
> - ck_assert_int_eq(libinput_event_pointer_get_axis_value(ptrev), expected);
> + LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
> +
> + ck_assert_int_eq(libinput_event_pointer_get_axis_value(ptrev, axis),
> + expected);
> ck_assert_int_eq(libinput_event_pointer_get_axis_source(ptrev),
> LIBINPUT_POINTER_AXIS_SOURCE_WHEEL);
> libinput_event_destroy(event);
> diff --git a/test/touchpad.c b/test/touchpad.c
> index 422e8fe..dbe16a3 100644
> --- a/test/touchpad.c
> +++ b/test/touchpad.c
> @@ -1439,18 +1439,19 @@ START_TEST(touchpad_2fg_scroll_slow_distance)
>
> /* last event is value 0, tested elsewhere */
> while (libinput_next_event_type(li) != LIBINPUT_EVENT_NONE) {
> + double axisval;
> ck_assert_int_eq(libinput_event_get_type(event),
> LIBINPUT_EVENT_POINTER_AXIS);
> ptrev = libinput_event_get_pointer_event(event);
>
> - ck_assert_int_eq(libinput_event_pointer_get_axis(ptrev),
> - LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
> - ck_assert(libinput_event_pointer_get_axis_value(ptrev) > 0.0);
> + axisval = libinput_event_pointer_get_axis_value(ptrev,
> + LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
> + ck_assert(axisval > 0.0);
>
> /* this is to verify we test the right thing, if the value
> is greater than scroll.threshold we triggered the wrong
> condition */
> - ck_assert(libinput_event_pointer_get_axis_value(ptrev) < 5.0);
> + ck_assert(axisval < 5.0);
>
> libinput_event_destroy(event);
> event = libinput_get_event(li);
> @@ -1627,18 +1628,19 @@ START_TEST(touchpad_edge_scroll_slow_distance)
> ck_assert_notnull(event);
>
> while (libinput_next_event_type(li) != LIBINPUT_EVENT_NONE) {
> + double axisval;
> ck_assert_int_eq(libinput_event_get_type(event),
> LIBINPUT_EVENT_POINTER_AXIS);
> ptrev = libinput_event_get_pointer_event(event);
>
> - ck_assert_int_eq(libinput_event_pointer_get_axis(ptrev),
> + axisval = libinput_event_pointer_get_axis_value(ptrev,
> LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
> - ck_assert(libinput_event_pointer_get_axis_value(ptrev) > 0.0);
> + ck_assert(axisval > 0.0);
>
> /* this is to verify we test the right thing, if the value
> is greater than scroll.threshold we triggered the wrong
> condition */
> - ck_assert(libinput_event_pointer_get_axis_value(ptrev) < 5.0);
> + ck_assert(axisval < 5.0);
>
> libinput_event_destroy(event);
> event = libinput_get_event(li);
> diff --git a/tools/event-debug.c b/tools/event-debug.c
> index 8fbea24..4a84d67 100644
> --- a/tools/event-debug.c
> +++ b/tools/event-debug.c
> @@ -225,24 +225,14 @@ static void
> print_axis_event(struct libinput_event *ev)
> {
> struct libinput_event_pointer *p = libinput_event_get_pointer_event(ev);
> - enum libinput_pointer_axis axis = libinput_event_pointer_get_axis(p);
> - const char *ax;
> - double val;
> -
> - switch (axis) {
> - case LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL:
> - ax = "vscroll";
> - break;
> - case LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL:
> - ax = "hscroll";
> - break;
> - default:
> - abort();
> - }
> + double v, h;
>
> + v = libinput_event_pointer_get_axis_value(p,
> + LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
> + h = libinput_event_pointer_get_axis_value(p,
> + LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
> print_event_time(libinput_event_pointer_get_time(p));
> - val = libinput_event_pointer_get_axis_value(p);
> - printf("%s %.2f\n", ax, val);
> + printf("vert %.2f horiz %.2f\n", v, h);
> }
>
> static void
> diff --git a/tools/event-gui.c b/tools/event-gui.c
> index 9a08d8e..4f9d7e6 100644
> --- a/tools/event-gui.c
> +++ b/tools/event-gui.c
> @@ -358,20 +358,20 @@ static void
> handle_event_axis(struct libinput_event *ev, struct window *w)
> {
> struct libinput_event_pointer *p = libinput_event_get_pointer_event(ev);
> - enum libinput_pointer_axis axis = libinput_event_pointer_get_axis(p);
> - double v = libinput_event_pointer_get_axis_value(p);
> + double v, h;
>
> - switch (axis) {
> - case LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL:
> + v = libinput_event_pointer_get_axis_value(p,
> + LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
> + h = libinput_event_pointer_get_axis_value(p,
> + LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
> +
> + if (v != 0.0) {
> w->vy += (int)v;
> w->vy = clip(w->vy, 0, w->height);
> - break;
> - case LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL:
> + }
> + if (h != 0.0) {
> w->hx += (int)v;
> w->hx = clip(w->hx, 0, w->width);
> - break;
> - default:
> - abort();
> }
> }
Otherwise this looks good, so with the above minor items fixed this
patch is:
Reviewed-by: Hans de Goede <hdegoede at redhat.com>
Regards,
Hans
More information about the wayland-devel
mailing list