fdo-mirrors/libinput
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libinput/libinput.git synced 2025-12-27 09:10:06 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

tablet: rename libinput_event_tablet to libinput_event_tablet_tool

Browse source 
Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
Reviewed-by: Hans de Goede <hdegoede@redhat.com>
This commit is contained in:
Peter Hutterer 2015-11-16 16:28:55 +10:00
parent 2cfd52244a
commit a10e92849c
9 changed files with 369 additions and 369 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
src/libinput.c
View file

@ -125,7 +125,7 @@ struct libinput_event_gesture {
double angle;
};
struct libinput_event_tablet {
struct libinput_event_tablet_tool {
struct libinput_event base;
uint32_t button;
enum libinput_button_state state;
@ -306,8 +306,8 @@ libinput_event_get_gesture_event(struct libinput_event *event)
return (struct libinput_event_gesture *) event;
}
LIBINPUT_EXPORT struct libinput_event_tablet *
libinput_event_get_tablet_event(struct libinput_event *event)
LIBINPUT_EXPORT struct libinput_event_tablet_tool *
libinput_event_get_tablet_tool_event(struct libinput_event *event)
{
require_event_type(libinput_event_get_context(event),
event->type,
@ -317,7 +317,7 @@ libinput_event_get_tablet_event(struct libinput_event *event)
LIBINPUT_EVENT_TABLET_TOOL_TIP,
LIBINPUT_EVENT_TABLET_TOOL_BUTTON);
return (struct libinput_event_tablet *) event;
return (struct libinput_event_tablet_tool *) event;
}
LIBINPUT_EXPORT struct libinput_event_device_notify *
@ -913,7 +913,7 @@ libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event)
}
LIBINPUT_EXPORT int
libinput_event_tablet_axis_has_changed(struct libinput_event_tablet *event,
libinput_event_tablet_tool_axis_has_changed(struct libinput_event_tablet_tool *event,
enum libinput_tablet_tool_axis axis)
{
require_event_type(libinput_event_get_context(&event->base),
@ -928,7 +928,7 @@ libinput_event_tablet_axis_has_changed(struct libinput_event_tablet *event,
}
LIBINPUT_EXPORT double
libinput_event_tablet_get_axis_value(struct libinput_event_tablet *event,
libinput_event_tablet_tool_get_axis_value(struct libinput_event_tablet_tool *event,
enum libinput_tablet_tool_axis axis)
{
struct evdev_device *device =
@ -962,7 +962,7 @@ libinput_event_tablet_get_axis_value(struct libinput_event_tablet *event,
}
LIBINPUT_EXPORT double
libinput_event_tablet_get_axis_delta(struct libinput_event_tablet *event,
libinput_event_tablet_tool_get_axis_delta(struct libinput_event_tablet_tool *event,
enum libinput_tablet_tool_axis axis)
{
struct evdev_device *device =
@ -996,8 +996,8 @@ libinput_event_tablet_get_axis_delta(struct libinput_event_tablet *event,
}
LIBINPUT_EXPORT double
libinput_event_tablet_get_axis_delta_discrete(
struct libinput_event_tablet *event,
libinput_event_tablet_tool_get_axis_delta_discrete(
struct libinput_event_tablet_tool *event,
enum libinput_tablet_tool_axis axis)
{
require_event_type(libinput_event_get_context(&event->base),
@ -1024,7 +1024,7 @@ libinput_event_tablet_get_axis_delta_discrete(
}
LIBINPUT_EXPORT double
libinput_event_tablet_get_x_transformed(struct libinput_event_tablet *event,
libinput_event_tablet_tool_get_x_transformed(struct libinput_event_tablet_tool *event,
uint32_t width)
{
struct evdev_device *device =
@ -1043,7 +1043,7 @@ libinput_event_tablet_get_x_transformed(struct libinput_event_tablet *event,
}
LIBINPUT_EXPORT double
libinput_event_tablet_get_y_transformed(struct libinput_event_tablet *event,
libinput_event_tablet_tool_get_y_transformed(struct libinput_event_tablet_tool *event,
uint32_t height)
{
struct evdev_device *device =
@ -1062,7 +1062,7 @@ libinput_event_tablet_get_y_transformed(struct libinput_event_tablet *event,
}
LIBINPUT_EXPORT struct libinput_tablet_tool *
libinput_event_tablet_get_tool(struct libinput_event_tablet *event)
libinput_event_tablet_tool_get_tool(struct libinput_event_tablet_tool *event)
{
require_event_type(libinput_event_get_context(&event->base),
event->base.type,
@ -1076,7 +1076,7 @@ libinput_event_tablet_get_tool(struct libinput_event_tablet *event)
}
LIBINPUT_EXPORT enum libinput_tablet_tool_proximity_state
libinput_event_tablet_get_proximity_state(struct libinput_event_tablet *event)
libinput_event_tablet_tool_get_proximity_state(struct libinput_event_tablet_tool *event)
{
require_event_type(libinput_event_get_context(&event->base),
event->base.type,
@ -1090,7 +1090,7 @@ libinput_event_tablet_get_proximity_state(struct libinput_event_tablet *event)
}
LIBINPUT_EXPORT enum libinput_tablet_tool_tip_state
libinput_event_tablet_get_tip_state(struct libinput_event_tablet *event)
libinput_event_tablet_tool_get_tip_state(struct libinput_event_tablet_tool *event)
{
require_event_type(libinput_event_get_context(&event->base),
event->base.type,
@ -1104,7 +1104,7 @@ libinput_event_tablet_get_tip_state(struct libinput_event_tablet *event)
}
LIBINPUT_EXPORT uint32_t
libinput_event_tablet_get_time(struct libinput_event_tablet *event)
libinput_event_tablet_tool_get_time(struct libinput_event_tablet_tool *event)
{
require_event_type(libinput_event_get_context(&event->base),
event->base.type,
@ -1118,7 +1118,7 @@ libinput_event_tablet_get_time(struct libinput_event_tablet *event)
}
LIBINPUT_EXPORT uint64_t
libinput_event_tablet_get_time_usec(struct libinput_event_tablet *event)
libinput_event_tablet_tool_get_time_usec(struct libinput_event_tablet_tool *event)
{
require_event_type(libinput_event_get_context(&event->base),
event->base.type,
@ -1132,7 +1132,7 @@ libinput_event_tablet_get_time_usec(struct libinput_event_tablet *event)
}
LIBINPUT_EXPORT uint32_t
libinput_event_tablet_get_button(struct libinput_event_tablet *event)
libinput_event_tablet_tool_get_button(struct libinput_event_tablet_tool *event)
{
require_event_type(libinput_event_get_context(&event->base),
event->base.type,
@ -1143,7 +1143,7 @@ libinput_event_tablet_get_button(struct libinput_event_tablet *event)
}
LIBINPUT_EXPORT enum libinput_button_state
libinput_event_tablet_get_button_state(struct libinput_event_tablet *event)
libinput_event_tablet_tool_get_button_state(struct libinput_event_tablet_tool *event)
{
require_event_type(libinput_event_get_context(&event->base),
event->base.type,
@ -1154,7 +1154,7 @@ libinput_event_tablet_get_button_state(struct libinput_event_tablet *event)
}
LIBINPUT_EXPORT uint32_t
libinput_event_tablet_get_seat_button_count(struct libinput_event_tablet *event)
libinput_event_tablet_tool_get_seat_button_count(struct libinput_event_tablet_tool *event)
{
require_event_type(libinput_event_get_context(&event->base),
event->base.type,
@ -1979,13 +1979,13 @@ tablet_notify_axis(struct libinput_device *device,
double *deltas,
double *deltas_discrete)
{
struct libinput_event_tablet *axis_event;
struct libinput_event_tablet_tool *axis_event;
axis_event = zalloc(sizeof *axis_event);
if (!axis_event)
return;
*axis_event = (struct libinput_event_tablet) {
*axis_event = (struct libinput_event_tablet_tool) {
.time = time,
.tool = tool,
.proximity_state = LIBINPUT_TABLET_TOOL_PROXIMITY_IN,
@ -2015,13 +2015,13 @@ tablet_notify_proximity(struct libinput_device *device,
unsigned char *changed_axes,
double *axes)
{
struct libinput_event_tablet *proximity_event;
struct libinput_event_tablet_tool *proximity_event;
proximity_event = zalloc(sizeof *proximity_event);
if (!proximity_event)
return;
*proximity_event = (struct libinput_event_tablet) {
*proximity_event = (struct libinput_event_tablet_tool) {
.time = time,
.tool = tool,
.proximity_state = proximity_state,
@ -2048,13 +2048,13 @@ tablet_notify_tip(struct libinput_device *device,
enum libinput_tablet_tool_tip_state tip_state,
double *axes)
{
struct libinput_event_tablet *tip_event;
struct libinput_event_tablet_tool *tip_event;
tip_event = zalloc(sizeof *tip_event);
if (!tip_event)
return;
*tip_event = (struct libinput_event_tablet) {
*tip_event = (struct libinput_event_tablet_tool) {
.time = time,
.tool = tool,
.tip_state = tip_state,
@ -2079,7 +2079,7 @@ tablet_notify_button(struct libinput_device *device,
int32_t button,
enum libinput_button_state state)
{
struct libinput_event_tablet *button_event;
struct libinput_event_tablet_tool *button_event;
int32_t seat_button_count;
button_event = zalloc(sizeof *button_event);
@ -2090,7 +2090,7 @@ tablet_notify_button(struct libinput_device *device,
button,
state);
*button_event = (struct libinput_event_tablet) {
*button_event = (struct libinput_event_tablet_tool) {
.time = time,
.tool = tool,
.button = button,
@ -2463,7 +2463,7 @@ libinput_event_gesture_get_base_event(struct libinput_event_gesture *event)
}
LIBINPUT_EXPORT struct libinput_event *
libinput_event_tablet_get_base_event(struct libinput_event_tablet *event)
libinput_event_tablet_tool_get_base_event(struct libinput_event_tablet_tool *event)
{
require_event_type(libinput_event_get_context(&event->base),
event->base.type,

66
src/libinput.h
View file

@ -426,13 +426,13 @@ struct libinput_event_touch;
/**
* @ingroup event_tablet
* @struct libinput_event_tablet
* @struct libinput_event_tablet_tool
*
* Tablet event representing an axis update, button press, or tool update. Valid
* event types for this event are @ref LIBINPUT_EVENT_TABLET_TOOL_AXIS, @ref
* LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY and @ref LIBINPUT_EVENT_TABLET_TOOL_BUTTON.
*/
struct libinput_event_tablet;
struct libinput_event_tablet_tool;
/**
* @defgroup event Accessing and destruction of events
@ -546,12 +546,12 @@ libinput_event_get_gesture_event(struct libinput_event *event);
* Return the tablet event that is this input event. If the event type does not
* match the tablet event types, this function returns NULL.
*
* The inverse of this function is libinput_event_tablet_get_base_event().
* The inverse of this function is libinput_event_tablet_tool_get_base_event().
*
* @return A tablet event, or NULL for other events
*/
struct libinput_event_tablet *
libinput_event_get_tablet_event(struct libinput_event *event);
struct libinput_event_tablet_tool *
libinput_event_get_tablet_tool_event(struct libinput_event *event);
/**
* @ingroup event
@ -1353,7 +1353,7 @@ libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event);
* @return The generic libinput_event of this event
*/
struct libinput_event *
libinput_event_tablet_get_base_event(struct libinput_event_tablet *event);
libinput_event_tablet_tool_get_base_event(struct libinput_event_tablet_tool *event);
/**
* @ingroup event_tablet
@ -1370,8 +1370,8 @@ libinput_event_tablet_get_base_event(struct libinput_event_tablet *event);
* @return 1 if the axis was updated or 0 otherwise
*/
int
libinput_event_tablet_axis_has_changed(struct libinput_event_tablet *event,
enum libinput_tablet_tool_axis axis);
libinput_event_tablet_tool_axis_has_changed(struct libinput_event_tablet_tool *event,
enum libinput_tablet_tool_axis axis);
/**
* @ingroup event_tablet
@ -1380,8 +1380,8 @@ libinput_event_tablet_axis_has_changed(struct libinput_event_tablet *event,
* value is dependent on the axis:
* - @ref LIBINPUT_TABLET_TOOL_AXIS_X and @ref LIBINPUT_TABLET_TOOL_AXIS_Y - the X and
* Y coordinates of the tablet tool, in mm from the top left corner of the
* tablet. Use libinput_event_tablet_get_x_transformed() and
* libinput_event_tablet_get_y_transformed() for transforming each
* tablet. Use libinput_event_tablet_tool_get_x_transformed() and
* libinput_event_tablet_tool_get_y_transformed() for transforming each
* respective axis value into a different coordinate space.
* - @ref LIBINPUT_TABLET_TOOL_AXIS_DISTANCE - The distance from the tablet's
* sensor, normalized from 0 to 1
@ -1400,10 +1400,10 @@ libinput_event_tablet_axis_has_changed(struct libinput_event_tablet *event,
* from 0 to 1. e.g. the wheel-like tool on the Wacom Airbrush.
* - @ref LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL - A relative wheel on the tool,
* similar or equivalent to a mouse wheel. The value is always 0, use
* libinput_event_tablet_get_axis_delta() instead.
* libinput_event_tablet_tool_get_axis_delta() instead.
*
* @note This function may be called for a specific axis even if
* libinput_event_tablet_axis_has_changed() returns 0 for that axis.
* libinput_event_tablet_tool_axis_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
@ -1415,8 +1415,8 @@ libinput_event_tablet_axis_has_changed(struct libinput_event_tablet *event,
* @return The current value of the the axis
*/
double
libinput_event_tablet_get_axis_value(struct libinput_event_tablet *event,
enum libinput_tablet_tool_axis axis);
libinput_event_tablet_tool_get_axis_value(struct libinput_event_tablet_tool *event,
enum libinput_tablet_tool_axis axis);
/**
* @ingroup event_tablet
@ -1426,7 +1426,7 @@ libinput_event_tablet_get_axis_value(struct libinput_event_tablet *event,
* - @ref LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL - A relative wheel on the tool,
* similar or equivalent to a mouse wheel. The value is a delta from the
* device's previous position, in degrees.
* For all other axes, see libinput_event_tablet_get_axis_value() for
* For all other axes, see libinput_event_tablet_tool_get_axis_value() for
* details.
*
* @param event The libinput tablet event
@ -1434,8 +1434,8 @@ libinput_event_tablet_get_axis_value(struct libinput_event_tablet *event,
* @return The delta to the previous axis value
*/
double
libinput_event_tablet_get_axis_delta(struct libinput_event_tablet *event,
enum libinput_tablet_tool_axis axis);
libinput_event_tablet_tool_get_axis_delta(struct libinput_event_tablet_tool *event,
enum libinput_tablet_tool_axis axis);
/**
* @ingroup event_tablet
@ -1451,8 +1451,8 @@ libinput_event_tablet_get_axis_delta(struct libinput_event_tablet *event,
* @return The delta to the previous axis value in discrete steps
*/
double
libinput_event_tablet_get_axis_delta_discrete(
struct libinput_event_tablet *event,
libinput_event_tablet_tool_get_axis_delta_discrete(
struct libinput_event_tablet_tool *event,
enum libinput_tablet_tool_axis axis);
/**
@ -1462,7 +1462,7 @@ libinput_event_tablet_get_axis_delta_discrete(
* screen coordinates.
*
* @note This function may be called for a specific axis even if
* libinput_event_tablet_axis_has_changed() returns 0 for that axis.
* libinput_event_tablet_tool_axis_has_changed() returns 0 for that axis.
* libinput always includes all device axes in the event.
*
* @param event The libinput tablet event
@ -1470,8 +1470,8 @@ libinput_event_tablet_get_axis_delta_discrete(
* @return the current absolute x coordinate transformed to a screen coordinate
*/
double
libinput_event_tablet_get_x_transformed(struct libinput_event_tablet *event,
uint32_t width);
libinput_event_tablet_tool_get_x_transformed(struct libinput_event_tablet_tool *event,
uint32_t width);
/**
* @ingroup event_tablet
@ -1480,7 +1480,7 @@ libinput_event_tablet_get_x_transformed(struct libinput_event_tablet *event,
* screen coordinates.
*
* @note This function may be called for a specific axis even if
* libinput_event_tablet_axis_has_changed() returns 0 for that axis.
* libinput_event_tablet_tool_axis_has_changed() returns 0 for that axis.
* libinput always includes all device axes in the event.
*
* @param event The libinput tablet event
@ -1488,8 +1488,8 @@ libinput_event_tablet_get_x_transformed(struct libinput_event_tablet *event,
* @return the current absolute y coordinate transformed to a screen coordinate
*/
double
libinput_event_tablet_get_y_transformed(struct libinput_event_tablet *event,
uint32_t height);
libinput_event_tablet_tool_get_y_transformed(struct libinput_event_tablet_tool *event,
uint32_t height);
/**
* @ingroup event_tablet
@ -1509,7 +1509,7 @@ libinput_event_tablet_get_y_transformed(struct libinput_event_tablet *event,
* @return The new tool triggering this event
*/
struct libinput_tablet_tool *
libinput_event_tablet_get_tool(struct libinput_event_tablet *event);
libinput_event_tablet_tool_get_tool(struct libinput_event_tablet_tool *event);
/**
* @ingroup event_tablet
@ -1524,7 +1524,7 @@ libinput_event_tablet_get_tool(struct libinput_event_tablet *event);
* @return The new proximity state of the tool from the event.
*/
enum libinput_tablet_tool_proximity_state
libinput_event_tablet_get_proximity_state(struct libinput_event_tablet *event);
libinput_event_tablet_tool_get_proximity_state(struct libinput_event_tablet_tool *event);
/**
* @ingroup event_tablet
@ -1538,7 +1538,7 @@ libinput_event_tablet_get_proximity_state(struct libinput_event_tablet *event);
* @return The new tip state of the tool from the event.
*/
enum libinput_tablet_tool_tip_state
libinput_event_tablet_get_tip_state(struct libinput_event_tablet *event);
libinput_event_tablet_tool_get_tip_state(struct libinput_event_tablet_tool *event);
/**
* @ingroup event_tablet
@ -1554,7 +1554,7 @@ libinput_event_tablet_get_tip_state(struct libinput_event_tablet *event);
* @return the button triggering this event
*/
uint32_t
libinput_event_tablet_get_button(struct libinput_event_tablet *event);
libinput_event_tablet_tool_get_button(struct libinput_event_tablet_tool *event);
/**
* @ingroup event_tablet
@ -1568,7 +1568,7 @@ libinput_event_tablet_get_button(struct libinput_event_tablet *event);
* @return the button state triggering this event
*/
enum libinput_button_state
libinput_event_tablet_get_button_state(struct libinput_event_tablet *event);
libinput_event_tablet_tool_get_button_state(struct libinput_event_tablet_tool *event);
/**
* @ingroup event_tablet
@ -1583,7 +1583,7 @@ libinput_event_tablet_get_button_state(struct libinput_event_tablet *event);
* @return the seat wide pressed button count for the key of this event
*/
uint32_t
libinput_event_tablet_get_seat_button_count(struct libinput_event_tablet *event);
libinput_event_tablet_tool_get_seat_button_count(struct libinput_event_tablet_tool *event);
/**
* @ingroup event_tablet
@ -1592,7 +1592,7 @@ libinput_event_tablet_get_seat_button_count(struct libinput_event_tablet *event)
* @return The event time for this event
*/
uint32_t
libinput_event_tablet_get_time(struct libinput_event_tablet *event);
libinput_event_tablet_tool_get_time(struct libinput_event_tablet_tool *event);
/**
* @ingroup event_tablet
@ -1601,7 +1601,7 @@ libinput_event_tablet_get_time(struct libinput_event_tablet *event);
* @return The event time for this event in microseconds
*/
uint64_t
libinput_event_tablet_get_time_usec(struct libinput_event_tablet *event);
libinput_event_tablet_tool_get_time_usec(struct libinput_event_tablet_tool *event);
/**
* @ingroup event_tablet

32
src/libinput.sym
View file

@ -184,22 +184,22 @@ LIBINPUT_1.1 {
/* tablet APIs, they are not part of any stable API promise yet.
* keep them separate */
LIBINPUT_TABLET_SUPPORT {
libinput_event_get_tablet_event;
libinput_event_tablet_axis_has_changed;
libinput_event_tablet_get_axis_delta;
libinput_event_tablet_get_axis_delta_discrete;
libinput_event_tablet_get_axis_value;
libinput_event_tablet_get_base_event;
libinput_event_tablet_get_button;
libinput_event_tablet_get_button_state;
libinput_event_tablet_get_proximity_state;
libinput_event_tablet_get_seat_button_count;
libinput_event_tablet_get_time;
libinput_event_tablet_get_tip_state;
libinput_event_tablet_get_tool;
libinput_event_tablet_get_x_transformed;
libinput_event_tablet_get_y_transformed;
libinput_event_tablet_get_time_usec;
libinput_event_get_tablet_tool_event;
libinput_event_tablet_tool_axis_has_changed;
libinput_event_tablet_tool_get_axis_delta;
libinput_event_tablet_tool_get_axis_delta_discrete;
libinput_event_tablet_tool_get_axis_value;
libinput_event_tablet_tool_get_base_event;
libinput_event_tablet_tool_get_button;
libinput_event_tablet_tool_get_button_state;
libinput_event_tablet_tool_get_proximity_state;
libinput_event_tablet_tool_get_seat_button_count;
libinput_event_tablet_tool_get_time;
libinput_event_tablet_tool_get_tip_state;
libinput_event_tablet_tool_get_tool;
libinput_event_tablet_tool_get_x_transformed;
libinput_event_tablet_tool_get_y_transformed;
libinput_event_tablet_tool_get_time_usec;
libinput_tool_get_serial;
libinput_tool_get_tool_id;
libinput_tool_get_type;

30
test/litest.c
View file

@ -1901,7 +1901,7 @@ static void
litest_print_event(struct libinput_event *event)
{
struct libinput_event_pointer *p;
struct libinput_event_tablet *t;
struct libinput_event_tablet_tool *t;
struct libinput_device *dev;
enum libinput_event_type type;
double x, y;
@ -1948,20 +1948,20 @@ litest_print_event(struct libinput_event *event)
fprintf(stderr, "vert %.f horiz %.2f", y, x);
break;
case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY:
t = libinput_event_get_tablet_event(event);
t = libinput_event_get_tablet_tool_event(event);
fprintf(stderr, "proximity %d\n",
libinput_event_tablet_get_proximity_state(t));
libinput_event_tablet_tool_get_proximity_state(t));
break;
case LIBINPUT_EVENT_TABLET_TOOL_TIP:
t = libinput_event_get_tablet_event(event);
t = libinput_event_get_tablet_tool_event(event);
fprintf(stderr, "tip %d\n",
libinput_event_tablet_get_tip_state(t));
libinput_event_tablet_tool_get_tip_state(t));
break;
case LIBINPUT_EVENT_TABLET_TOOL_BUTTON:
t = libinput_event_get_tablet_event(event);
t = libinput_event_get_tablet_tool_event(event);
fprintf(stderr, "button %d state %d\n",
libinput_event_tablet_get_button(t),
libinput_event_tablet_get_button_state(t));
libinput_event_tablet_tool_get_button(t),
libinput_event_tablet_tool_get_button_state(t));
break;
default:
break;
@ -2330,16 +2330,16 @@ litest_is_gesture_event(struct libinput_event *event,
return gevent;
}
struct libinput_event_tablet * litest_is_tablet_event(
struct libinput_event_tablet_tool * litest_is_tablet_event(
struct libinput_event *event,
enum libinput_event_type type)
{
struct libinput_event_tablet *tevent;
struct libinput_event_tablet_tool *tevent;
litest_assert(event != NULL);
litest_assert_int_eq(libinput_event_get_type(event), type);
tevent = libinput_event_get_tablet_event(event);
tevent = libinput_event_get_tablet_tool_event(event);
litest_assert(tevent != NULL);
return tevent;
@ -2350,7 +2350,7 @@ litest_assert_tablet_button_event(struct libinput *li, unsigned int button,
enum libinput_button_state state)
{
struct libinput_event *event;
struct libinput_event_tablet *tev;
struct libinput_event_tablet_tool *tev;
enum libinput_event_type type = LIBINPUT_EVENT_TABLET_TOOL_BUTTON;
litest_wait_for_event(li);
@ -2358,10 +2358,10 @@ litest_assert_tablet_button_event(struct libinput *li, unsigned int button,
litest_assert_notnull(event);
litest_assert_int_eq(libinput_event_get_type(event), type);
tev = libinput_event_get_tablet_event(event);
litest_assert_int_eq(libinput_event_tablet_get_button(tev),
tev = libinput_event_get_tablet_tool_event(event);
litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev),
button);
litest_assert_int_eq(libinput_event_tablet_get_button_state(tev),
litest_assert_int_eq(libinput_event_tablet_tool_get_button_state(tev),
state);
libinput_event_destroy(event);
}

2
test/litest.h
View file

@ -402,7 +402,7 @@ struct libinput_event_gesture * litest_is_gesture_event(
struct libinput_event *event,
enum libinput_event_type type,
int nfingers);
struct libinput_event_tablet * litest_is_tablet_event(
struct libinput_event_tablet_tool * litest_is_tablet_event(
struct libinput_event *event,
enum libinput_event_type type);

16
test/misc.c
View file

@ -133,7 +133,7 @@ START_TEST(event_conversion_device_notify)
ck_assert(libinput_event_get_keyboard_event(event) == NULL);
ck_assert(libinput_event_get_touch_event(event) == NULL);
ck_assert(libinput_event_get_gesture_event(event) == NULL);
ck_assert(libinput_event_get_tablet_event(event) == NULL);
ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
litest_restore_log_handler(li);
}
@ -189,7 +189,7 @@ START_TEST(event_conversion_pointer)
ck_assert(libinput_event_get_keyboard_event(event) == NULL);
ck_assert(libinput_event_get_touch_event(event) == NULL);
ck_assert(libinput_event_get_gesture_event(event) == NULL);
ck_assert(libinput_event_get_tablet_event(event) == NULL);
ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
@ -239,7 +239,7 @@ START_TEST(event_conversion_pointer_abs)
ck_assert(libinput_event_get_keyboard_event(event) == NULL);
ck_assert(libinput_event_get_touch_event(event) == NULL);
ck_assert(libinput_event_get_gesture_event(event) == NULL);
ck_assert(libinput_event_get_tablet_event(event) == NULL);
ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
@ -282,7 +282,7 @@ START_TEST(event_conversion_key)
ck_assert(libinput_event_get_pointer_event(event) == NULL);
ck_assert(libinput_event_get_touch_event(event) == NULL);
ck_assert(libinput_event_get_gesture_event(event) == NULL);
ck_assert(libinput_event_get_tablet_event(event) == NULL);
ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
@ -332,7 +332,7 @@ START_TEST(event_conversion_touch)
ck_assert(libinput_event_get_pointer_event(event) == NULL);
ck_assert(libinput_event_get_keyboard_event(event) == NULL);
ck_assert(libinput_event_get_gesture_event(event) == NULL);
ck_assert(libinput_event_get_tablet_event(event) == NULL);
ck_assert(libinput_event_get_tablet_tool_event(event) == NULL);
litest_restore_log_handler(li);
}
libinput_event_destroy(event);
@ -414,10 +414,10 @@ START_TEST(event_conversion_tablet)
if (type >= LIBINPUT_EVENT_TABLET_TOOL_AXIS &&
type <= LIBINPUT_EVENT_TABLET_TOOL_BUTTON) {
struct libinput_event_tablet *t;
struct libinput_event_tablet_tool *t;
struct libinput_event *base;
t = libinput_event_get_tablet_event(event);
base = libinput_event_tablet_get_base_event(t);
t = libinput_event_get_tablet_tool_event(event);
base = libinput_event_tablet_tool_get_base_event(t);
ck_assert(event == base);
events++;

438
test/tablet.c
View file

File diff suppressed because it is too large Load diff

72
tools/event-debug.c
View file

@ -284,28 +284,28 @@ print_pointer_button_event(struct libinput_event *ev)
static void
print_tablet_tip_event(struct libinput_event *ev)
{
struct libinput_event_tablet *p = libinput_event_get_tablet_event(ev);
struct libinput_event_tablet_tool *p = libinput_event_get_tablet_tool_event(ev);
enum libinput_tablet_tool_tip_state state;
print_event_time(libinput_event_tablet_get_time(p));
print_event_time(libinput_event_tablet_tool_get_time(p));
state = libinput_event_tablet_get_tip_state(p);
state = libinput_event_tablet_tool_get_tip_state(p);
printf("%s\n", state == LIBINPUT_TABLET_TOOL_TIP_DOWN ? "down" : "up");
}
static void
print_tablet_button_event(struct libinput_event *ev)
{
struct libinput_event_tablet *p = libinput_event_get_tablet_event(ev);
struct libinput_event_tablet_tool *p = libinput_event_get_tablet_tool_event(ev);
enum libinput_button_state state;
print_event_time(libinput_event_tablet_get_time(p));
print_event_time(libinput_event_tablet_tool_get_time(p));
state = libinput_event_tablet_get_button_state(p);
state = libinput_event_tablet_tool_get_button_state(p);
printf("%3d %s, seat count: %u\n",
libinput_event_tablet_get_button(p),
libinput_event_tablet_tool_get_button(p),
state == LIBINPUT_BUTTON_STATE_PRESSED ? "pressed" : "released",
libinput_event_tablet_get_seat_button_count(p));
libinput_event_tablet_tool_get_seat_button_count(p));
}
static void
@ -327,28 +327,28 @@ print_pointer_axis_event(struct libinput_event *ev)
}
static const char*
tablet_axis_changed_sym(struct libinput_event_tablet *t,
tablet_axis_changed_sym(struct libinput_event_tablet_tool *t,
enum libinput_tablet_tool_axis axis)
{
if (libinput_event_tablet_axis_has_changed(t, axis))
if (libinput_event_tablet_tool_axis_has_changed(t, axis))
return "*";
else
return "";
}
static void
print_tablet_axes(struct libinput_event_tablet *t)
print_tablet_axes(struct libinput_event_tablet_tool *t)
{
struct libinput_tablet_tool *tool = libinput_event_tablet_get_tool(t);
struct libinput_tablet_tool *tool = libinput_event_tablet_tool_get_tool(t);
double x, y, dx, dy;
double dist, pressure;
double rotation, slider, wheel;
double delta;
x = libinput_event_tablet_get_axis_value(t, LIBINPUT_TABLET_TOOL_AXIS_X);
y = libinput_event_tablet_get_axis_value(t, LIBINPUT_TABLET_TOOL_AXIS_Y);
dx = libinput_event_tablet_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_X);
dy = libinput_event_tablet_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_Y);
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),
@ -356,13 +356,13 @@ print_tablet_axes(struct libinput_event_tablet *t)
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) ||
libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) {
x = libinput_event_tablet_get_axis_value(t,
x = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_TILT_X);
y = libinput_event_tablet_get_axis_value(t,
y = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_TILT_Y);
dx = libinput_event_tablet_get_axis_delta(t,
dx = libinput_event_tablet_tool_get_axis_delta(t,
LIBINPUT_TABLET_TOOL_AXIS_TILT_X);
dy = libinput_event_tablet_get_axis_delta(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,
@ -374,12 +374,12 @@ print_tablet_axes(struct libinput_event_tablet *t)
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE) ||
libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_PRESSURE)) {
dist = libinput_event_tablet_get_axis_value(t,
dist = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE);
pressure = libinput_event_tablet_get_axis_value(t,
pressure = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_PRESSURE);
if (dist) {
delta = libinput_event_tablet_get_axis_delta(t,
delta = libinput_event_tablet_tool_get_axis_delta(t,
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE);
printf("\tdistance: %.2f%s (%.2f)",
dist,
@ -387,7 +387,7 @@ print_tablet_axes(struct libinput_event_tablet *t)
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE),
delta);
} else {
delta = libinput_event_tablet_get_axis_delta(t,
delta = libinput_event_tablet_tool_get_axis_delta(t,
LIBINPUT_TABLET_TOOL_AXIS_PRESSURE);
printf("\tpressure: %.2f%s (%.2f)",
pressure,
@ -398,9 +398,9 @@ print_tablet_axes(struct libinput_event_tablet *t)
}
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z)) {
rotation = libinput_event_tablet_get_axis_value(t,
rotation = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z);
delta = libinput_event_tablet_get_axis_delta(t,
delta = libinput_event_tablet_tool_get_axis_delta(t,
LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z);
printf("\trotation: %.2f%s (%.2f)",
rotation,
@ -410,9 +410,9 @@ print_tablet_axes(struct libinput_event_tablet *t)
}
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_SLIDER)) {
slider = libinput_event_tablet_get_axis_value(t,
slider = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_SLIDER);
delta = libinput_event_tablet_get_axis_delta(t,
delta = libinput_event_tablet_tool_get_axis_delta(t,
LIBINPUT_TABLET_TOOL_AXIS_SLIDER);
printf("\tslider: %.2f%s (%.2f)",
slider,
@ -422,9 +422,9 @@ print_tablet_axes(struct libinput_event_tablet *t)
}
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL)) {
wheel = libinput_event_tablet_get_axis_value(t,
wheel = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL);
delta = libinput_event_tablet_get_axis_delta_discrete(t,
delta = libinput_event_tablet_tool_get_axis_delta_discrete(t,
LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL);
printf("\twheel: %.2f%s (%d)",
wheel,
@ -437,9 +437,9 @@ print_tablet_axes(struct libinput_event_tablet *t)
static void
print_tablet_axis_event(struct libinput_event *ev)
{
struct libinput_event_tablet *t = libinput_event_get_tablet_event(ev);
struct libinput_event_tablet_tool *t = libinput_event_get_tablet_tool_event(ev);
print_event_time(libinput_event_tablet_get_time(t));
print_event_time(libinput_event_tablet_tool_get_time(t));
print_tablet_axes(t);
printf("\n");
}
@ -456,8 +456,8 @@ print_touch_event_without_coords(struct libinput_event *ev)
static void
print_proximity_event(struct libinput_event *ev)
{
struct libinput_event_tablet *t = libinput_event_get_tablet_event(ev);
struct libinput_tablet_tool *tool = libinput_event_tablet_get_tool(t);
struct libinput_event_tablet_tool *t = libinput_event_get_tablet_tool_event(ev);
struct libinput_tablet_tool *tool = libinput_event_tablet_tool_get_tool(t);
enum libinput_tablet_tool_proximity_state state;
const char *tool_str,
*state_str;
@ -491,9 +491,9 @@ print_proximity_event(struct libinput_event *ev)
abort();
}
state = libinput_event_tablet_get_proximity_state(t);
state = libinput_event_tablet_tool_get_proximity_state(t);
print_event_time(libinput_event_tablet_get_time(t));
print_event_time(libinput_event_tablet_tool_get_time(t));
if (state == LIBINPUT_TABLET_TOOL_PROXIMITY_IN) {
print_tablet_axes(t);

26
tools/event-gui.c
View file

@ -599,12 +599,12 @@ handle_event_pinch(struct libinput_event *ev, struct window *w)
static void
handle_event_tablet(struct libinput_event *ev, struct window *w)
{
struct libinput_event_tablet *t = libinput_event_get_tablet_event(ev);
struct libinput_event_tablet_tool *t = libinput_event_get_tablet_tool_event(ev);
double x, y;
switch (libinput_event_get_type(ev)) {
case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY:
if (libinput_event_tablet_get_proximity_state(t) ==
if (libinput_event_tablet_tool_get_proximity_state(t) ==
LIBINPUT_TABLET_TOOL_PROXIMITY_OUT) {
w->tool.x_in = 0;
w->tool.y_in = 0;
@ -613,30 +613,30 @@ handle_event_tablet(struct libinput_event *ev, struct window *w)
w->tool.x_up = 0;
w->tool.y_up = 0;
} else {
w->tool.x_in = libinput_event_tablet_get_x_transformed(t,
w->tool.x_in = libinput_event_tablet_tool_get_x_transformed(t,
w->width);
w->tool.y_in = libinput_event_tablet_get_y_transformed(t,
w->tool.y_in = libinput_event_tablet_tool_get_y_transformed(t,
w->height);
}
break;
case LIBINPUT_EVENT_TABLET_TOOL_AXIS:
w->tool.x = libinput_event_tablet_get_x_transformed(t,
w->tool.x = libinput_event_tablet_tool_get_x_transformed(t,
w->width);
w->tool.y = libinput_event_tablet_get_y_transformed(t,
w->tool.y = libinput_event_tablet_tool_get_y_transformed(t,
w->height);
w->tool.pressure = libinput_event_tablet_get_axis_value(t,
w->tool.pressure = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_PRESSURE);
w->tool.distance = libinput_event_tablet_get_axis_value(t,
w->tool.distance = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE);
w->tool.tilt_x = libinput_event_tablet_get_axis_value(t,
w->tool.tilt_x = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_TILT_X);
w->tool.tilt_y = libinput_event_tablet_get_axis_value(t,
w->tool.tilt_y = libinput_event_tablet_tool_get_axis_value(t,
LIBINPUT_TABLET_TOOL_AXIS_TILT_Y);
break;
case LIBINPUT_EVENT_TABLET_TOOL_TIP:
x = libinput_event_tablet_get_x_transformed(t, w->width);
y = libinput_event_tablet_get_y_transformed(t, w->height);
if (libinput_event_tablet_get_tip_state(t) ==
x = libinput_event_tablet_tool_get_x_transformed(t, w->width);
y = libinput_event_tablet_tool_get_y_transformed(t, w->height);
if (libinput_event_tablet_tool_get_tip_state(t) ==
LIBINPUT_TABLET_TOOL_TIP_DOWN) {
w->tool.x_down = x;
w->tool.y_down = y;