fdo-mirrors/libinput
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libinput/libinput.git synced 2026-05-04 08:57:59 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

tablet: rename axis_has_changed into an axis-specific API set

Browse source 
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 <peter.hutterer@who-t.net>
Acked-by: Hans de Goede <hdegoede@redhat.com>
Reviewed-by: Lyude <cpaul@redhat.com>
This commit is contained in:
Peter Hutterer 2015-12-14 09:05:37 +10:00
parent 67b92adee7
commit 5c9c481047
5 changed files with 339 additions and 113 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

128
src/libinput.c
View file

@ -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

159
src/libinput.h
View file

@ -1361,20 +1361,161 @@ 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.
* 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.
* Check if the x axis was updated in this event.
* For tablet events that are not of type @ref
* LIBINPUT_EVENT_TABLET_TOOL_AXIS, @ref LIBINPUT_EVENT_TABLET_TOOL_TIP, or
* @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
* @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, @ref LIBINPUT_EVENT_TABLET_TOOL_TIP, or
* @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, @ref LIBINPUT_EVENT_TABLET_TOOL_TIP, or
* @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, @ref LIBINPUT_EVENT_TABLET_TOOL_TIP, or
* @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, @ref LIBINPUT_EVENT_TABLET_TOOL_TIP, or
* @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, @ref LIBINPUT_EVENT_TABLET_TOOL_TIP, or
* @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, @ref LIBINPUT_EVENT_TABLET_TOOL_TIP, or
* @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, @ref LIBINPUT_EVENT_TABLET_TOOL_TIP, or
* @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, @ref LIBINPUT_EVENT_TABLET_TOOL_TIP, or
* @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
@ -1406,7 +1547,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
@ -1465,7 +1606,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
@ -1483,7 +1624,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

10
src/libinput.sym
View file

@ -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;

112
test/tablet.c
View file

@ -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,
@ -1969,8 +1950,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);
@ -2032,8 +2012,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);
@ -2063,8 +2042,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);
@ -2160,8 +2138,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);
@ -2251,8 +2228,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);

43
tools/event-debug.c
View file

@ -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);
}
}