First part of the big revamp to get rid of libinput_tablet_tool_axis and replace it with a set of axis-specific APIs.
Signed-off-by: Peter Hutterer <[email protected]> --- src/libinput.c | 128 +++++++++++++++++++++++++++++++++++++++++++-- src/libinput.h | 146 +++++++++++++++++++++++++++++++++++++++++++++++++--- src/libinput.sym | 10 +++- test/tablet.c | 112 ++++++++++++++++------------------------ tools/event-debug.c | 43 +++++----------- 5 files changed, 328 insertions(+), 111 deletions(-) diff --git a/src/libinput.c b/src/libinput.c index df44e7e..f37d174 100644 --- a/src/libinput.c +++ b/src/libinput.c @@ -913,8 +913,8 @@ libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event) } LIBINPUT_EXPORT int -libinput_event_tablet_tool_axis_has_changed(struct libinput_event_tablet_tool *event, - enum libinput_tablet_tool_axis axis) +libinput_event_tablet_tool_x_has_changed( + struct libinput_event_tablet_tool *event) { require_event_type(libinput_event_get_context(&event->base), event->base.type, @@ -923,8 +923,128 @@ libinput_event_tablet_tool_axis_has_changed(struct libinput_event_tablet_tool *e LIBINPUT_EVENT_TABLET_TOOL_TIP, LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY); - return (NCHARS(axis) <= sizeof(event->changed_axes)) ? - bit_is_set(event->changed_axes, axis) : 0; + return bit_is_set(event->changed_axes, + LIBINPUT_TABLET_TOOL_AXIS_X); +} + +LIBINPUT_EXPORT int +libinput_event_tablet_tool_y_has_changed( + struct libinput_event_tablet_tool *event) +{ + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TABLET_TOOL_AXIS, + LIBINPUT_EVENT_TABLET_TOOL_TIP, + LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY); + + return bit_is_set(event->changed_axes, + LIBINPUT_TABLET_TOOL_AXIS_Y); +} + +LIBINPUT_EXPORT int +libinput_event_tablet_tool_pressure_has_changed( + struct libinput_event_tablet_tool *event) +{ + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TABLET_TOOL_AXIS, + LIBINPUT_EVENT_TABLET_TOOL_TIP, + LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY); + + return bit_is_set(event->changed_axes, + LIBINPUT_TABLET_TOOL_AXIS_PRESSURE); +} + +LIBINPUT_EXPORT int +libinput_event_tablet_tool_distance_has_changed( + struct libinput_event_tablet_tool *event) +{ + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TABLET_TOOL_AXIS, + LIBINPUT_EVENT_TABLET_TOOL_TIP, + LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY); + + return bit_is_set(event->changed_axes, + LIBINPUT_TABLET_TOOL_AXIS_DISTANCE); +} + +LIBINPUT_EXPORT int +libinput_event_tablet_tool_tilt_x_has_changed( + struct libinput_event_tablet_tool *event) +{ + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TABLET_TOOL_AXIS, + LIBINPUT_EVENT_TABLET_TOOL_TIP, + LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY); + + return bit_is_set(event->changed_axes, + LIBINPUT_TABLET_TOOL_AXIS_TILT_X); +} + +LIBINPUT_EXPORT int +libinput_event_tablet_tool_tilt_y_has_changed( + struct libinput_event_tablet_tool *event) +{ + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TABLET_TOOL_AXIS, + LIBINPUT_EVENT_TABLET_TOOL_TIP, + LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY); + + return bit_is_set(event->changed_axes, + LIBINPUT_TABLET_TOOL_AXIS_TILT_Y); +} + +LIBINPUT_EXPORT int +libinput_event_tablet_tool_rotation_has_changed( + struct libinput_event_tablet_tool *event) +{ + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TABLET_TOOL_AXIS, + LIBINPUT_EVENT_TABLET_TOOL_TIP, + LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY); + + return bit_is_set(event->changed_axes, + LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z); +} + +LIBINPUT_EXPORT int +libinput_event_tablet_tool_slider_has_changed( + struct libinput_event_tablet_tool *event) +{ + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TABLET_TOOL_AXIS, + LIBINPUT_EVENT_TABLET_TOOL_TIP, + LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY); + + return bit_is_set(event->changed_axes, + LIBINPUT_TABLET_TOOL_AXIS_SLIDER); +} + +LIBINPUT_EXPORT int +libinput_event_tablet_tool_wheel_has_changed( + struct libinput_event_tablet_tool *event) +{ + require_event_type(libinput_event_get_context(&event->base), + event->base.type, + 0, + LIBINPUT_EVENT_TABLET_TOOL_AXIS, + LIBINPUT_EVENT_TABLET_TOOL_TIP, + LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY); + + return bit_is_set(event->changed_axes, + LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL); } LIBINPUT_EXPORT double diff --git a/src/libinput.h b/src/libinput.h index 48f72a1..8bd1480 100644 --- a/src/libinput.h +++ b/src/libinput.h @@ -1360,7 +1360,7 @@ libinput_event_tablet_tool_get_base_event(struct libinput_event_tablet_tool *eve /** * @ingroup event_tablet * - * Checks if an axis was updated in this event or return 0 otherwise. + * Check if the x axis was updated in this event. * For tablet events that are not of type @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS or * type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, this function returns 0. * @@ -1368,12 +1368,144 @@ libinput_event_tablet_tool_get_base_event(struct libinput_event_tablet_tool *eve * @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS and @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY. * * @param event The libinput tablet event - * @param axis The axis to check for updates * @return 1 if the axis was updated or 0 otherwise */ int -libinput_event_tablet_tool_axis_has_changed(struct libinput_event_tablet_tool *event, - enum libinput_tablet_tool_axis axis); +libinput_event_tablet_tool_x_has_changed( + struct libinput_event_tablet_tool *event); + +/** + * @ingroup event_tablet + * + * Check if the y axis was updated in this event. + * For tablet events that are not of type @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS or + * type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, this function returns 0. + * + * @note It is an application bug to call this function for events other than + * @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS and @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY. + * + * @param event The libinput tablet event + * @return 1 if the axis was updated or 0 otherwise + */ +int +libinput_event_tablet_tool_y_has_changed( + struct libinput_event_tablet_tool *event); + +/** + * @ingroup event_tablet + * + * Check if the pressure axis was updated in this event. + * For tablet events that are not of type @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS or + * type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, this function returns 0. + * + * @note It is an application bug to call this function for events other than + * @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS and @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY. + * + * @param event The libinput tablet event + * @return 1 if the axis was updated or 0 otherwise + */ +int +libinput_event_tablet_tool_pressure_has_changed( + struct libinput_event_tablet_tool *event); + +/** + * @ingroup event_tablet + * + * Check if the distance axis was updated in this event. + * For tablet events that are not of type @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS or + * type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, this function returns 0. + * + * @note It is an application bug to call this function for events other than + * @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS and @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY. + * + * @param event The libinput tablet event + * @return 1 if the axis was updated or 0 otherwise + */ +int +libinput_event_tablet_tool_distance_has_changed( + struct libinput_event_tablet_tool *event); + +/** + * @ingroup event_tablet + * + * Check if the tilt x axis was updated in this event. + * For tablet events that are not of type @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS or + * type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, this function returns 0. + * + * @note It is an application bug to call this function for events other than + * @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS and @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY. + * + * @param event The libinput tablet event + * @return 1 if the axis was updated or 0 otherwise + */ +int +libinput_event_tablet_tool_tilt_x_has_changed( + struct libinput_event_tablet_tool *event); + +/** + * @ingroup event_tablet + * + * Check if the tilt y axis was updated in this event. + * For tablet events that are not of type @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS or + * type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, this function returns 0. + * + * @note It is an application bug to call this function for events other than + * @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS and @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY. + * + * @param event The libinput tablet event + * @return 1 if the axis was updated or 0 otherwise + */ +int +libinput_event_tablet_tool_tilt_y_has_changed( + struct libinput_event_tablet_tool *event); +/** + * @ingroup event_tablet + * + * Check if the z-rotation axis was updated in this event. + * For tablet events that are not of type @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS or + * type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, this function returns 0. + * + * @note It is an application bug to call this function for events other than + * @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS and @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY. + * + * @param event The libinput tablet event + * @return 1 if the axis was updated or 0 otherwise + */ +int +libinput_event_tablet_tool_rotation_has_changed( + struct libinput_event_tablet_tool *event); +/** + * @ingroup event_tablet + * + * Check if the slider axis was updated in this event. + * For tablet events that are not of type @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS or + * type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, this function returns 0. + * + * @note It is an application bug to call this function for events other than + * @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS and @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY. + * + * @param event The libinput tablet event + * @return 1 if the axis was updated or 0 otherwise + */ +int +libinput_event_tablet_tool_slider_has_changed( + struct libinput_event_tablet_tool *event); +/** + * @ingroup event_tablet + * + * Check if the wheel axis was updated in this event. + * For tablet events that are not of type @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS or + * type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY, this function returns 0. + * + * @note It is an application bug to call this function for events other than + * @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS and @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY. + * + * @param event The libinput tablet event + * @return 1 if the axis was updated or 0 otherwise + */ +int +libinput_event_tablet_tool_wheel_has_changed( + struct libinput_event_tablet_tool *event); /** * @ingroup event_tablet @@ -1405,7 +1537,7 @@ libinput_event_tablet_tool_axis_has_changed(struct libinput_event_tablet_tool *e * libinput_event_tablet_tool_get_axis_delta() instead. * * @note This function may be called for a specific axis even if - * libinput_event_tablet_tool_axis_has_changed() returns 0 for that axis. + * libinput_event_tablet_tool_*_has_changed() returns 0 for that axis. * libinput always includes all device axes in the event. * * If the event is of type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY and the @@ -1464,7 +1596,7 @@ libinput_event_tablet_tool_get_axis_delta_discrete( * screen coordinates. * * @note This function may be called for a specific axis even if - * libinput_event_tablet_tool_axis_has_changed() returns 0 for that axis. + * libinput_event_tablet_tool_*_has_changed() returns 0 for that axis. * libinput always includes all device axes in the event. * * @param event The libinput tablet event @@ -1482,7 +1614,7 @@ libinput_event_tablet_tool_get_x_transformed(struct libinput_event_tablet_tool * * screen coordinates. * * @note This function may be called for a specific axis even if - * libinput_event_tablet_tool_axis_has_changed() returns 0 for that axis. + * libinput_event_tablet_tool_*_has_changed() returns 0 for that axis. * libinput always includes all device axes in the event. * * @param event The libinput tablet event diff --git a/src/libinput.sym b/src/libinput.sym index 1704903..bee03b9 100644 --- a/src/libinput.sym +++ b/src/libinput.sym @@ -185,7 +185,15 @@ LIBINPUT_1.1 { * keep them separate */ LIBINPUT_TABLET_SUPPORT { libinput_event_get_tablet_tool_event; - libinput_event_tablet_tool_axis_has_changed; + libinput_event_tablet_tool_x_has_changed; + libinput_event_tablet_tool_y_has_changed; + libinput_event_tablet_tool_pressure_has_changed; + libinput_event_tablet_tool_distance_has_changed; + libinput_event_tablet_tool_rotation_has_changed; + libinput_event_tablet_tool_tilt_x_has_changed; + libinput_event_tablet_tool_tilt_y_has_changed; + libinput_event_tablet_tool_wheel_has_changed; + libinput_event_tablet_tool_slider_has_changed; libinput_event_tablet_tool_get_axis_delta; libinput_event_tablet_tool_get_axis_delta_discrete; libinput_event_tablet_tool_get_axis_value; diff --git a/test/tablet.c b/test/tablet.c index 4cd5cef..724feb3 100644 --- a/test/tablet.c +++ b/test/tablet.c @@ -721,10 +721,8 @@ START_TEST(proximity_has_axes) tablet_event = libinput_event_get_tablet_tool_event(event); tool = libinput_event_tablet_tool_get_tool(tablet_event); - ck_assert(libinput_event_tablet_tool_axis_has_changed( - tablet_event, LIBINPUT_TABLET_TOOL_AXIS_X)); - ck_assert(libinput_event_tablet_tool_axis_has_changed( - tablet_event, LIBINPUT_TABLET_TOOL_AXIS_Y)); + ck_assert(libinput_event_tablet_tool_x_has_changed(tablet_event)); + ck_assert(libinput_event_tablet_tool_y_has_changed(tablet_event)); x = libinput_event_tablet_tool_get_axis_value(tablet_event, LIBINPUT_TABLET_TOOL_AXIS_X); @@ -735,9 +733,8 @@ START_TEST(proximity_has_axes) litest_assert_double_ne(y, 0); if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)) { - ck_assert(libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)); + ck_assert(libinput_event_tablet_tool_distance_has_changed( + tablet_event)); distance = libinput_event_tablet_tool_get_axis_value( tablet_event, @@ -747,12 +744,10 @@ START_TEST(proximity_has_axes) if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) && libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) { - ck_assert(libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_TILT_X)); - ck_assert(libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)); + ck_assert(libinput_event_tablet_tool_tilt_x_has_changed( + tablet_event)); + ck_assert(libinput_event_tablet_tool_tilt_y_has_changed( + tablet_event)); x = libinput_event_tablet_tool_get_axis_value( tablet_event, @@ -806,10 +801,8 @@ START_TEST(proximity_has_axes) tablet_event = libinput_event_get_tablet_tool_event(event); tool = libinput_event_tablet_tool_get_tool(tablet_event); - ck_assert(!libinput_event_tablet_tool_axis_has_changed( - tablet_event, LIBINPUT_TABLET_TOOL_AXIS_X)); - ck_assert(!libinput_event_tablet_tool_axis_has_changed( - tablet_event, LIBINPUT_TABLET_TOOL_AXIS_Y)); + ck_assert(!libinput_event_tablet_tool_x_has_changed(tablet_event)); + ck_assert(!libinput_event_tablet_tool_y_has_changed(tablet_event)); x = libinput_event_tablet_tool_get_axis_value(tablet_event, LIBINPUT_TABLET_TOOL_AXIS_X); @@ -819,9 +812,8 @@ START_TEST(proximity_has_axes) litest_assert_double_eq(y, last_y); if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)) { - ck_assert(!libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)); + ck_assert(!libinput_event_tablet_tool_distance_has_changed( + tablet_event)); distance = libinput_event_tablet_tool_get_axis_value( tablet_event, @@ -831,12 +823,10 @@ START_TEST(proximity_has_axes) if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) && libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) { - ck_assert(!libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_TILT_X)); - ck_assert(!libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)); + ck_assert(!libinput_event_tablet_tool_tilt_x_has_changed( + tablet_event)); + ck_assert(!libinput_event_tablet_tool_tilt_y_has_changed( + tablet_event)); x = libinput_event_tablet_tool_get_axis_value( tablet_event, @@ -885,10 +875,10 @@ START_TEST(motion) ck_assert_int_eq(libinput_event_get_type(event), LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY); - x_changed = libinput_event_tablet_tool_axis_has_changed( - tablet_event, LIBINPUT_TABLET_TOOL_AXIS_X); - y_changed = libinput_event_tablet_tool_axis_has_changed( - tablet_event, LIBINPUT_TABLET_TOOL_AXIS_Y); + x_changed = libinput_event_tablet_tool_x_has_changed( + tablet_event); + y_changed = libinput_event_tablet_tool_y_has_changed( + tablet_event); ck_assert(x_changed); ck_assert(y_changed); @@ -920,10 +910,10 @@ START_TEST(motion) type = libinput_event_get_type(event); if (type == LIBINPUT_EVENT_TABLET_TOOL_AXIS) { - x_changed = libinput_event_tablet_tool_axis_has_changed( - tablet_event, LIBINPUT_TABLET_TOOL_AXIS_X); - y_changed = libinput_event_tablet_tool_axis_has_changed( - tablet_event, LIBINPUT_TABLET_TOOL_AXIS_Y); + x_changed = libinput_event_tablet_tool_x_has_changed( + tablet_event); + y_changed = libinput_event_tablet_tool_y_has_changed( + tablet_event); ck_assert(x_changed); ck_assert(y_changed); @@ -1036,20 +1026,17 @@ START_TEST(motion_delta_partial) event = libinput_get_event(li); tablet_event = libinput_event_get_tablet_tool_event(event); - ck_assert(!libinput_event_tablet_tool_axis_has_changed(tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_X)); + ck_assert(!libinput_event_tablet_tool_x_has_changed(tablet_event)); dx = libinput_event_tablet_tool_get_axis_delta(tablet_event, LIBINPUT_TABLET_TOOL_AXIS_X); litest_assert_double_eq(dx, 0.0); - ck_assert(!libinput_event_tablet_tool_axis_has_changed(tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_Y)); + ck_assert(!libinput_event_tablet_tool_y_has_changed(tablet_event)); dy = libinput_event_tablet_tool_get_axis_delta(tablet_event, LIBINPUT_TABLET_TOOL_AXIS_Y); litest_assert_double_eq(dy, 0.0); - ck_assert(libinput_event_tablet_tool_axis_has_changed(tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)); + ck_assert(libinput_event_tablet_tool_distance_has_changed(tablet_event)); ddist = libinput_event_tablet_tool_get_axis_delta(tablet_event, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE); ck_assert_double_gt(ddist, 0); @@ -1334,18 +1321,16 @@ START_TEST(normalization) if (libinput_event_get_type(event) == LIBINPUT_EVENT_TABLET_TOOL_AXIS) { tablet_event = libinput_event_get_tablet_tool_event(event); - if (libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_PRESSURE)) { + if (libinput_event_tablet_tool_pressure_has_changed( + tablet_event)) { pressure = libinput_event_tablet_tool_get_axis_value( tablet_event, LIBINPUT_TABLET_TOOL_AXIS_PRESSURE); litest_assert_double_eq(pressure, 0); } - if (libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_TILT_X)) { + if (libinput_event_tablet_tool_tilt_x_has_changed( + tablet_event)) { tilt_vertical = libinput_event_tablet_tool_get_axis_value( tablet_event, @@ -1354,9 +1339,8 @@ START_TEST(normalization) litest_assert_double_eq(tilt_vertical, -1); } - if (libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) { + if (libinput_event_tablet_tool_tilt_y_has_changed( + tablet_event)) { tilt_horizontal = libinput_event_tablet_tool_get_axis_value( tablet_event, @@ -1396,18 +1380,16 @@ START_TEST(normalization) if (libinput_event_get_type(event) == LIBINPUT_EVENT_TABLET_TOOL_AXIS) { tablet_event = libinput_event_get_tablet_tool_event(event); - if (libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_PRESSURE)) { + if (libinput_event_tablet_tool_pressure_has_changed( + tablet_event)) { pressure = libinput_event_tablet_tool_get_axis_value( tablet_event, LIBINPUT_TABLET_TOOL_AXIS_PRESSURE); litest_assert_double_eq(pressure, 1); } - if (libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_TILT_X)) { + if (libinput_event_tablet_tool_tilt_x_has_changed( + tablet_event)) { tilt_vertical = libinput_event_tablet_tool_get_axis_value( tablet_event, @@ -1416,9 +1398,8 @@ START_TEST(normalization) litest_assert_double_eq(tilt_vertical, 1); } - if (libinput_event_tablet_tool_axis_has_changed( - tablet_event, - LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) { + if (libinput_event_tablet_tool_tilt_y_has_changed( + tablet_event)) { tilt_horizontal = libinput_event_tablet_tool_get_axis_value( tablet_event, @@ -1977,8 +1958,7 @@ START_TEST(mouse_rotation) -1); event = libinput_get_event(li); tev = libinput_event_get_tablet_tool_event(event); - ck_assert(libinput_event_tablet_tool_axis_has_changed(tev, - LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z)); + ck_assert(libinput_event_tablet_tool_rotation_has_changed(tev)); val = libinput_event_tablet_tool_get_axis_value(tev, LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z); @@ -2040,8 +2020,7 @@ START_TEST(mouse_wheel) event = libinput_get_event(li); tev = libinput_event_get_tablet_tool_event(event); - ck_assert(libinput_event_tablet_tool_axis_has_changed(tev, - LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL)); + ck_assert(libinput_event_tablet_tool_wheel_has_changed(tev)); val = libinput_event_tablet_tool_get_axis_value(tev, LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL); ck_assert_int_eq(val, 0); @@ -2071,8 +2050,7 @@ START_TEST(mouse_wheel) event = libinput_get_event(li); tev = libinput_event_get_tablet_tool_event(event); - ck_assert(!libinput_event_tablet_tool_axis_has_changed(tev, - LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL)); + ck_assert(!libinput_event_tablet_tool_wheel_has_changed(tev)); val = libinput_event_tablet_tool_get_axis_value(tev, LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL); ck_assert_int_eq(val, 0); @@ -2168,8 +2146,7 @@ START_TEST(airbrush_wheel) -1); event = libinput_get_event(li); tev = libinput_event_get_tablet_tool_event(event); - ck_assert(libinput_event_tablet_tool_axis_has_changed(tev, - LIBINPUT_TABLET_TOOL_AXIS_SLIDER)); + ck_assert(libinput_event_tablet_tool_slider_has_changed(tev)); val = libinput_event_tablet_tool_get_axis_value(tev, LIBINPUT_TABLET_TOOL_AXIS_SLIDER); @@ -2259,8 +2236,7 @@ START_TEST(artpen_rotation) -1); event = libinput_get_event(li); tev = libinput_event_get_tablet_tool_event(event); - ck_assert(libinput_event_tablet_tool_axis_has_changed(tev, - LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z)); + ck_assert(libinput_event_tablet_tool_rotation_has_changed(tev)); val = libinput_event_tablet_tool_get_axis_value(tev, LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z); diff --git a/tools/event-debug.c b/tools/event-debug.c index aaa31b2..54ad1f2 100644 --- a/tools/event-debug.c +++ b/tools/event-debug.c @@ -332,16 +332,6 @@ print_pointer_axis_event(struct libinput_event *ev) printf("vert %.2f%s horiz %.2f%s\n", v, have_vert, h, have_horiz); } -static const char* -tablet_axis_changed_sym(struct libinput_event_tablet_tool *t, - enum libinput_tablet_tool_axis axis) -{ - if (libinput_event_tablet_tool_axis_has_changed(t, axis)) - return "*"; - else - return ""; -} - static void print_tablet_axes(struct libinput_event_tablet_tool *t) { @@ -351,13 +341,16 @@ print_tablet_axes(struct libinput_event_tablet_tool *t) double rotation, slider, wheel; double delta; +#define changed_sym(ev, ax) \ + (libinput_event_tablet_tool_##ax##_has_changed(ev) ? "*" : "") + x = libinput_event_tablet_tool_get_axis_value(t, LIBINPUT_TABLET_TOOL_AXIS_X); y = libinput_event_tablet_tool_get_axis_value(t, LIBINPUT_TABLET_TOOL_AXIS_Y); dx = libinput_event_tablet_tool_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_X); dy = libinput_event_tablet_tool_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_Y); printf("\t%.2f%s/%.2f%s (%.2f/%.2f)", - x, tablet_axis_changed_sym(t, LIBINPUT_TABLET_TOOL_AXIS_X), - y, tablet_axis_changed_sym(t, LIBINPUT_TABLET_TOOL_AXIS_Y), + x, changed_sym(t, x), + y, changed_sym(t, y), dx, dy); if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) || @@ -371,10 +364,8 @@ print_tablet_axes(struct libinput_event_tablet_tool *t) dy = libinput_event_tablet_tool_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y); printf("\ttilt: %.2f%s/%.2f%s (%.2f/%.2f)", - x, tablet_axis_changed_sym(t, - LIBINPUT_TABLET_TOOL_AXIS_TILT_X), - y, tablet_axis_changed_sym(t, - LIBINPUT_TABLET_TOOL_AXIS_TILT_Y), + x, changed_sym(t, tilt_x), + y, changed_sym(t, tilt_y), dx, dy); } @@ -388,17 +379,13 @@ print_tablet_axes(struct libinput_event_tablet_tool *t) delta = libinput_event_tablet_tool_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE); printf("\tdistance: %.2f%s (%.2f)", - dist, - tablet_axis_changed_sym(t, - LIBINPUT_TABLET_TOOL_AXIS_DISTANCE), + dist, changed_sym(t, distance), delta); } else { delta = libinput_event_tablet_tool_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_PRESSURE); printf("\tpressure: %.2f%s (%.2f)", - pressure, - tablet_axis_changed_sym(t, - LIBINPUT_TABLET_TOOL_AXIS_PRESSURE), + pressure, changed_sym(t, pressure), delta); } } @@ -409,9 +396,7 @@ print_tablet_axes(struct libinput_event_tablet_tool *t) delta = libinput_event_tablet_tool_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z); printf("\trotation: %.2f%s (%.2f)", - rotation, - tablet_axis_changed_sym(t, - LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z), + rotation, changed_sym(t, rotation), delta); } @@ -421,9 +406,7 @@ print_tablet_axes(struct libinput_event_tablet_tool *t) delta = libinput_event_tablet_tool_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_SLIDER); printf("\tslider: %.2f%s (%.2f)", - slider, - tablet_axis_changed_sym(t, - LIBINPUT_TABLET_TOOL_AXIS_SLIDER), + slider, changed_sym(t, slider), delta); } @@ -433,9 +416,7 @@ print_tablet_axes(struct libinput_event_tablet_tool *t) delta = libinput_event_tablet_tool_get_axis_delta_discrete(t, LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL); printf("\twheel: %.2f%s (%d)", - wheel, - tablet_axis_changed_sym(t, - LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL), + wheel, changed_sym(t, wheel), (int)delta); } } -- 2.5.0 _______________________________________________ wayland-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/wayland-devel
