fdo-mirrors/libinput
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libinput/libinput.git synced 2026-05-08 11:19:14 +02: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; double angle;
}; };
struct libinput_event_tablet { struct libinput_event_tablet_tool {
struct libinput_event base; struct libinput_event base;
uint32_t button; uint32_t button;
enum libinput_button_state state; enum libinput_button_state state;
@ -306,8 +306,8 @@ libinput_event_get_gesture_event(struct libinput_event *event)
return (struct libinput_event_gesture *) event; return (struct libinput_event_gesture *) event;
} }
LIBINPUT_EXPORT struct libinput_event_tablet * LIBINPUT_EXPORT struct libinput_event_tablet_tool *
libinput_event_get_tablet_event(struct libinput_event *event) libinput_event_get_tablet_tool_event(struct libinput_event *event)
{ {
require_event_type(libinput_event_get_context(event), require_event_type(libinput_event_get_context(event),
event->type, event->type,
@ -317,7 +317,7 @@ libinput_event_get_tablet_event(struct libinput_event *event)
LIBINPUT_EVENT_TABLET_TOOL_TIP, LIBINPUT_EVENT_TABLET_TOOL_TIP,
LIBINPUT_EVENT_TABLET_TOOL_BUTTON); 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 * 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_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) enum libinput_tablet_tool_axis axis)
{ {
require_event_type(libinput_event_get_context(&event->base), 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_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) enum libinput_tablet_tool_axis axis)
{ {
struct evdev_device *device = struct evdev_device *device =
@ -962,7 +962,7 @@ libinput_event_tablet_get_axis_value(struct libinput_event_tablet *event,
} }
LIBINPUT_EXPORT double 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) enum libinput_tablet_tool_axis axis)
{ {
struct evdev_device *device = struct evdev_device *device =
@ -996,8 +996,8 @@ libinput_event_tablet_get_axis_delta(struct libinput_event_tablet *event,
} }
LIBINPUT_EXPORT double LIBINPUT_EXPORT double
libinput_event_tablet_get_axis_delta_discrete( libinput_event_tablet_tool_get_axis_delta_discrete(
struct libinput_event_tablet *event, struct libinput_event_tablet_tool *event,
enum libinput_tablet_tool_axis axis) enum libinput_tablet_tool_axis axis)
{ {
require_event_type(libinput_event_get_context(&event->base), require_event_type(libinput_event_get_context(&event->base),
@ -1024,7 +1024,7 @@ libinput_event_tablet_get_axis_delta_discrete(
} }
LIBINPUT_EXPORT double 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) uint32_t width)
{ {
struct evdev_device *device = struct evdev_device *device =
@ -1043,7 +1043,7 @@ libinput_event_tablet_get_x_transformed(struct libinput_event_tablet *event,
} }
LIBINPUT_EXPORT double 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) uint32_t height)
{ {
struct evdev_device *device = 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_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), require_event_type(libinput_event_get_context(&event->base),
event->base.type, 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_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), require_event_type(libinput_event_get_context(&event->base),
event->base.type, 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_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), require_event_type(libinput_event_get_context(&event->base),
event->base.type, event->base.type,
@ -1104,7 +1104,7 @@ libinput_event_tablet_get_tip_state(struct libinput_event_tablet *event)
} }
LIBINPUT_EXPORT uint32_t 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), require_event_type(libinput_event_get_context(&event->base),
event->base.type, event->base.type,
@ -1118,7 +1118,7 @@ libinput_event_tablet_get_time(struct libinput_event_tablet *event)
} }
LIBINPUT_EXPORT uint64_t 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), require_event_type(libinput_event_get_context(&event->base),
event->base.type, event->base.type,
@ -1132,7 +1132,7 @@ libinput_event_tablet_get_time_usec(struct libinput_event_tablet *event)
} }
LIBINPUT_EXPORT uint32_t 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), require_event_type(libinput_event_get_context(&event->base),
event->base.type, event->base.type,
@ -1143,7 +1143,7 @@ libinput_event_tablet_get_button(struct libinput_event_tablet *event)
} }
LIBINPUT_EXPORT enum libinput_button_state 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), require_event_type(libinput_event_get_context(&event->base),
event->base.type, event->base.type,
@ -1154,7 +1154,7 @@ libinput_event_tablet_get_button_state(struct libinput_event_tablet *event)
} }
LIBINPUT_EXPORT uint32_t 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), require_event_type(libinput_event_get_context(&event->base),
event->base.type, event->base.type,
@ -1979,13 +1979,13 @@ tablet_notify_axis(struct libinput_device *device,
double *deltas, double *deltas,
double *deltas_discrete) double *deltas_discrete)
{ {
struct libinput_event_tablet *axis_event; struct libinput_event_tablet_tool *axis_event;
axis_event = zalloc(sizeof *axis_event); axis_event = zalloc(sizeof *axis_event);
if (!axis_event) if (!axis_event)
return; return;
*axis_event = (struct libinput_event_tablet) { *axis_event = (struct libinput_event_tablet_tool) {
.time = time, .time = time,
.tool = tool, .tool = tool,
.proximity_state = LIBINPUT_TABLET_TOOL_PROXIMITY_IN, .proximity_state = LIBINPUT_TABLET_TOOL_PROXIMITY_IN,
@ -2015,13 +2015,13 @@ tablet_notify_proximity(struct libinput_device *device,
unsigned char *changed_axes, unsigned char *changed_axes,
double *axes) double *axes)
{ {
struct libinput_event_tablet *proximity_event; struct libinput_event_tablet_tool *proximity_event;
proximity_event = zalloc(sizeof *proximity_event); proximity_event = zalloc(sizeof *proximity_event);
if (!proximity_event) if (!proximity_event)
return; return;
*proximity_event = (struct libinput_event_tablet) { *proximity_event = (struct libinput_event_tablet_tool) {
.time = time, .time = time,
.tool = tool, .tool = tool,
.proximity_state = proximity_state, .proximity_state = proximity_state,
@ -2048,13 +2048,13 @@ tablet_notify_tip(struct libinput_device *device,
enum libinput_tablet_tool_tip_state tip_state, enum libinput_tablet_tool_tip_state tip_state,
double *axes) double *axes)
{ {
struct libinput_event_tablet *tip_event; struct libinput_event_tablet_tool *tip_event;
tip_event = zalloc(sizeof *tip_event); tip_event = zalloc(sizeof *tip_event);
if (!tip_event) if (!tip_event)
return; return;
*tip_event = (struct libinput_event_tablet) { *tip_event = (struct libinput_event_tablet_tool) {
.time = time, .time = time,
.tool = tool, .tool = tool,
.tip_state = tip_state, .tip_state = tip_state,
@ -2079,7 +2079,7 @@ tablet_notify_button(struct libinput_device *device,
int32_t button, int32_t button,
enum libinput_button_state state) enum libinput_button_state state)
{ {
struct libinput_event_tablet *button_event; struct libinput_event_tablet_tool *button_event;
int32_t seat_button_count; int32_t seat_button_count;
button_event = zalloc(sizeof *button_event); button_event = zalloc(sizeof *button_event);
@ -2090,7 +2090,7 @@ tablet_notify_button(struct libinput_device *device,
button, button,
state); state);
*button_event = (struct libinput_event_tablet) { *button_event = (struct libinput_event_tablet_tool) {
.time = time, .time = time,
.tool = tool, .tool = tool,
.button = button, .button = button,
@ -2463,7 +2463,7 @@ libinput_event_gesture_get_base_event(struct libinput_event_gesture *event)
} }
LIBINPUT_EXPORT struct libinput_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), require_event_type(libinput_event_get_context(&event->base),
event->base.type, event->base.type,

66
src/libinput.h
View file

@ -426,13 +426,13 @@ struct libinput_event_touch;
/** /**
* @ingroup event_tablet * @ingroup event_tablet
* @struct libinput_event_tablet * @struct libinput_event_tablet_tool
* *
* Tablet event representing an axis update, button press, or tool update. Valid * 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 * 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. * 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 * @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 * Return the tablet event that is this input event. If the event type does not
* match the tablet event types, this function returns NULL. * 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 * @return A tablet event, or NULL for other events
*/ */
struct libinput_event_tablet * struct libinput_event_tablet_tool *
libinput_event_get_tablet_event(struct libinput_event *event); libinput_event_get_tablet_tool_event(struct libinput_event *event);
/** /**
* @ingroup 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 * @return The generic libinput_event of this event
*/ */
struct libinput_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 * @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 * @return 1 if the axis was updated or 0 otherwise
*/ */
int 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); enum libinput_tablet_tool_axis axis);
/** /**
* @ingroup event_tablet * @ingroup event_tablet
@ -1380,8 +1380,8 @@ libinput_event_tablet_axis_has_changed(struct libinput_event_tablet *event,
* value is dependent on the axis: * value is dependent on the axis:
* - @ref LIBINPUT_TABLET_TOOL_AXIS_X and @ref LIBINPUT_TABLET_TOOL_AXIS_Y - the X and * - @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 * Y coordinates of the tablet tool, in mm from the top left corner of the
* tablet. Use libinput_event_tablet_get_x_transformed() and * tablet. Use libinput_event_tablet_tool_get_x_transformed() and
* libinput_event_tablet_get_y_transformed() for transforming each * libinput_event_tablet_tool_get_y_transformed() for transforming each
* respective axis value into a different coordinate space. * respective axis value into a different coordinate space.
* - @ref LIBINPUT_TABLET_TOOL_AXIS_DISTANCE - The distance from the tablet's * - @ref LIBINPUT_TABLET_TOOL_AXIS_DISTANCE - The distance from the tablet's
* sensor, normalized from 0 to 1 * 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. * 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, * - @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 * 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 * @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. * libinput always includes all device axes in the event.
* *
* If the event is of type @ref LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY and the * 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 * @return The current value of the the axis
*/ */
double 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); enum libinput_tablet_tool_axis axis);
/** /**
* @ingroup event_tablet * @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, * - @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 * similar or equivalent to a mouse wheel. The value is a delta from the
* device's previous position, in degrees. * 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. * details.
* *
* @param event The libinput tablet event * @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 * @return The delta to the previous axis value
*/ */
double 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); enum libinput_tablet_tool_axis axis);
/** /**
* @ingroup event_tablet * @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 * @return The delta to the previous axis value in discrete steps
*/ */
double double
libinput_event_tablet_get_axis_delta_discrete( libinput_event_tablet_tool_get_axis_delta_discrete(
struct libinput_event_tablet *event, struct libinput_event_tablet_tool *event,
enum libinput_tablet_tool_axis axis); enum libinput_tablet_tool_axis axis);
/** /**
@ -1462,7 +1462,7 @@ libinput_event_tablet_get_axis_delta_discrete(
* screen coordinates. * screen coordinates.
* *
* @note This function may be called for a specific axis even if * @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. * libinput always includes all device axes in the event.
* *
* @param event The libinput tablet 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 * @return the current absolute x coordinate transformed to a screen coordinate
*/ */
double 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); uint32_t width);
/** /**
* @ingroup event_tablet * @ingroup event_tablet
@ -1480,7 +1480,7 @@ libinput_event_tablet_get_x_transformed(struct libinput_event_tablet *event,
* screen coordinates. * screen coordinates.
* *
* @note This function may be called for a specific axis even if * @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. * libinput always includes all device axes in the event.
* *
* @param event The libinput tablet 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 * @return the current absolute y coordinate transformed to a screen coordinate
*/ */
double 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); uint32_t height);
/** /**
* @ingroup event_tablet * @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 * @return The new tool triggering this event
*/ */
struct libinput_tablet_tool * 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 * @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. * @return The new proximity state of the tool from the event.
*/ */
enum libinput_tablet_tool_proximity_state 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 * @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. * @return The new tip state of the tool from the event.
*/ */
enum libinput_tablet_tool_tip_state 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 * @ingroup event_tablet
@ -1554,7 +1554,7 @@ libinput_event_tablet_get_tip_state(struct libinput_event_tablet *event);
* @return the button triggering this event * @return the button triggering this event
*/ */
uint32_t 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 * @ingroup event_tablet
@ -1568,7 +1568,7 @@ libinput_event_tablet_get_button(struct libinput_event_tablet *event);
* @return the button state triggering this event * @return the button state triggering this event
*/ */
enum libinput_button_state 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 * @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 * @return the seat wide pressed button count for the key of this event
*/ */
uint32_t 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 * @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 * @return The event time for this event
*/ */
uint32_t 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 * @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 * @return The event time for this event in microseconds
*/ */
uint64_t 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 * @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. /* tablet APIs, they are not part of any stable API promise yet.
* keep them separate */ * keep them separate */
LIBINPUT_TABLET_SUPPORT { LIBINPUT_TABLET_SUPPORT {
libinput_event_get_tablet_event; libinput_event_get_tablet_tool_event;
libinput_event_tablet_axis_has_changed; libinput_event_tablet_tool_axis_has_changed;
libinput_event_tablet_get_axis_delta; libinput_event_tablet_tool_get_axis_delta;
libinput_event_tablet_get_axis_delta_discrete; libinput_event_tablet_tool_get_axis_delta_discrete;
libinput_event_tablet_get_axis_value; libinput_event_tablet_tool_get_axis_value;
libinput_event_tablet_get_base_event; libinput_event_tablet_tool_get_base_event;
libinput_event_tablet_get_button; libinput_event_tablet_tool_get_button;
libinput_event_tablet_get_button_state; libinput_event_tablet_tool_get_button_state;
libinput_event_tablet_get_proximity_state; libinput_event_tablet_tool_get_proximity_state;
libinput_event_tablet_get_seat_button_count; libinput_event_tablet_tool_get_seat_button_count;
libinput_event_tablet_get_time; libinput_event_tablet_tool_get_time;
libinput_event_tablet_get_tip_state; libinput_event_tablet_tool_get_tip_state;
libinput_event_tablet_get_tool; libinput_event_tablet_tool_get_tool;
libinput_event_tablet_get_x_transformed; libinput_event_tablet_tool_get_x_transformed;
libinput_event_tablet_get_y_transformed; libinput_event_tablet_tool_get_y_transformed;
libinput_event_tablet_get_time_usec; libinput_event_tablet_tool_get_time_usec;
libinput_tool_get_serial; libinput_tool_get_serial;
libinput_tool_get_tool_id; libinput_tool_get_tool_id;
libinput_tool_get_type; libinput_tool_get_type;

30
test/litest.c
View file

@ -1901,7 +1901,7 @@ static void
litest_print_event(struct libinput_event *event) litest_print_event(struct libinput_event *event)
{ {
struct libinput_event_pointer *p; struct libinput_event_pointer *p;
struct libinput_event_tablet *t; struct libinput_event_tablet_tool *t;
struct libinput_device *dev; struct libinput_device *dev;
enum libinput_event_type type; enum libinput_event_type type;
double x, y; double x, y;
@ -1948,20 +1948,20 @@ litest_print_event(struct libinput_event *event)
fprintf(stderr, "vert %.f horiz %.2f", y, x); fprintf(stderr, "vert %.f horiz %.2f", y, x);
break; break;
case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY: 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", fprintf(stderr, "proximity %d\n",
libinput_event_tablet_get_proximity_state(t)); libinput_event_tablet_tool_get_proximity_state(t));
break; break;
case LIBINPUT_EVENT_TABLET_TOOL_TIP: 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", fprintf(stderr, "tip %d\n",
libinput_event_tablet_get_tip_state(t)); libinput_event_tablet_tool_get_tip_state(t));
break; break;
case LIBINPUT_EVENT_TABLET_TOOL_BUTTON: 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", fprintf(stderr, "button %d state %d\n",
libinput_event_tablet_get_button(t), libinput_event_tablet_tool_get_button(t),
libinput_event_tablet_get_button_state(t)); libinput_event_tablet_tool_get_button_state(t));
break; break;
default: default:
break; break;
@ -2330,16 +2330,16 @@ litest_is_gesture_event(struct libinput_event *event,
return gevent; return gevent;
} }
struct libinput_event_tablet * litest_is_tablet_event( struct libinput_event_tablet_tool * litest_is_tablet_event(
struct libinput_event *event, struct libinput_event *event,
enum libinput_event_type type) enum libinput_event_type type)
{ {
struct libinput_event_tablet *tevent; struct libinput_event_tablet_tool *tevent;
litest_assert(event != NULL); litest_assert(event != NULL);
litest_assert_int_eq(libinput_event_get_type(event), type); 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); litest_assert(tevent != NULL);
return tevent; return tevent;
@ -2350,7 +2350,7 @@ litest_assert_tablet_button_event(struct libinput *li, unsigned int button,
enum libinput_button_state state) enum libinput_button_state state)
{ {
struct libinput_event *event; 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; enum libinput_event_type type = LIBINPUT_EVENT_TABLET_TOOL_BUTTON;
litest_wait_for_event(li); 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_notnull(event);
litest_assert_int_eq(libinput_event_get_type(event), type); litest_assert_int_eq(libinput_event_get_type(event), type);
tev = libinput_event_get_tablet_event(event); tev = libinput_event_get_tablet_tool_event(event);
litest_assert_int_eq(libinput_event_tablet_get_button(tev), litest_assert_int_eq(libinput_event_tablet_tool_get_button(tev),
button); 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); state);
libinput_event_destroy(event); 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, struct libinput_event *event,
enum libinput_event_type type, enum libinput_event_type type,
int nfingers); int nfingers);
struct libinput_event_tablet * litest_is_tablet_event( struct libinput_event_tablet_tool * litest_is_tablet_event(
struct libinput_event *event, struct libinput_event *event,
enum libinput_event_type type); 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_keyboard_event(event) == NULL);
ck_assert(libinput_event_get_touch_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_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); 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_keyboard_event(event) == NULL);
ck_assert(libinput_event_get_touch_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_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); litest_restore_log_handler(li);
} }
libinput_event_destroy(event); 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_keyboard_event(event) == NULL);
ck_assert(libinput_event_get_touch_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_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); litest_restore_log_handler(li);
} }
libinput_event_destroy(event); 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_pointer_event(event) == NULL);
ck_assert(libinput_event_get_touch_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_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); litest_restore_log_handler(li);
} }
libinput_event_destroy(event); 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_pointer_event(event) == NULL);
ck_assert(libinput_event_get_keyboard_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_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); litest_restore_log_handler(li);
} }
libinput_event_destroy(event); libinput_event_destroy(event);
@ -414,10 +414,10 @@ START_TEST(event_conversion_tablet)
if (type >= LIBINPUT_EVENT_TABLET_TOOL_AXIS && if (type >= LIBINPUT_EVENT_TABLET_TOOL_AXIS &&
type <= LIBINPUT_EVENT_TABLET_TOOL_BUTTON) { type <= LIBINPUT_EVENT_TABLET_TOOL_BUTTON) {
struct libinput_event_tablet *t; struct libinput_event_tablet_tool *t;
struct libinput_event *base; struct libinput_event *base;
t = libinput_event_get_tablet_event(event); t = libinput_event_get_tablet_tool_event(event);
base = libinput_event_tablet_get_base_event(t); base = libinput_event_tablet_tool_get_base_event(t);
ck_assert(event == base); ck_assert(event == base);
events++; 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 static void
print_tablet_tip_event(struct libinput_event *ev) 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; 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"); printf("%s\n", state == LIBINPUT_TABLET_TOOL_TIP_DOWN ? "down" : "up");
} }
static void static void
print_tablet_button_event(struct libinput_event *ev) 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; 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", 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", 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 static void
@ -327,28 +327,28 @@ print_pointer_axis_event(struct libinput_event *ev)
} }
static const char* 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) 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 "*"; return "*";
else else
return ""; return "";
} }
static void 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 x, y, dx, dy;
double dist, pressure; double dist, pressure;
double rotation, slider, wheel; double rotation, slider, wheel;
double delta; double delta;
x = libinput_event_tablet_get_axis_value(t, LIBINPUT_TABLET_TOOL_AXIS_X); x = libinput_event_tablet_tool_get_axis_value(t, LIBINPUT_TABLET_TOOL_AXIS_X);
y = libinput_event_tablet_get_axis_value(t, LIBINPUT_TABLET_TOOL_AXIS_Y); y = libinput_event_tablet_tool_get_axis_value(t, LIBINPUT_TABLET_TOOL_AXIS_Y);
dx = libinput_event_tablet_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_X); dx = libinput_event_tablet_tool_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_X);
dy = libinput_event_tablet_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_Y); dy = libinput_event_tablet_tool_get_axis_delta(t, LIBINPUT_TABLET_TOOL_AXIS_Y);
printf("\t%.2f%s/%.2f%s (%.2f/%.2f)", printf("\t%.2f%s/%.2f%s (%.2f/%.2f)",
x, tablet_axis_changed_sym(t, LIBINPUT_TABLET_TOOL_AXIS_X), x, tablet_axis_changed_sym(t, LIBINPUT_TABLET_TOOL_AXIS_X),
y, tablet_axis_changed_sym(t, LIBINPUT_TABLET_TOOL_AXIS_Y), 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) || if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) ||
libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) { 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); 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); 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); 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); LIBINPUT_TABLET_TOOL_AXIS_TILT_Y);
printf("\ttilt: %.2f%s/%.2f%s (%.2f/%.2f)", printf("\ttilt: %.2f%s/%.2f%s (%.2f/%.2f)",
x, tablet_axis_changed_sym(t, 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) || if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE) ||
libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_PRESSURE)) { 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); 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); LIBINPUT_TABLET_TOOL_AXIS_PRESSURE);
if (dist) { if (dist) {
delta = libinput_event_tablet_get_axis_delta(t, delta = libinput_event_tablet_tool_get_axis_delta(t,
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE); LIBINPUT_TABLET_TOOL_AXIS_DISTANCE);
printf("\tdistance: %.2f%s (%.2f)", printf("\tdistance: %.2f%s (%.2f)",
dist, dist,
@ -387,7 +387,7 @@ print_tablet_axes(struct libinput_event_tablet *t)
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE), LIBINPUT_TABLET_TOOL_AXIS_DISTANCE),
delta); delta);
} else { } else {
delta = libinput_event_tablet_get_axis_delta(t, delta = libinput_event_tablet_tool_get_axis_delta(t,
LIBINPUT_TABLET_TOOL_AXIS_PRESSURE); LIBINPUT_TABLET_TOOL_AXIS_PRESSURE);
printf("\tpressure: %.2f%s (%.2f)", printf("\tpressure: %.2f%s (%.2f)",
pressure, 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)) { 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); 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); LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z);
printf("\trotation: %.2f%s (%.2f)", printf("\trotation: %.2f%s (%.2f)",
rotation, rotation,
@ -410,9 +410,9 @@ print_tablet_axes(struct libinput_event_tablet *t)
} }
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_SLIDER)) { 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); 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); LIBINPUT_TABLET_TOOL_AXIS_SLIDER);
printf("\tslider: %.2f%s (%.2f)", printf("\tslider: %.2f%s (%.2f)",
slider, 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)) { 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); 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); LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL);
printf("\twheel: %.2f%s (%d)", printf("\twheel: %.2f%s (%d)",
wheel, wheel,
@ -437,9 +437,9 @@ print_tablet_axes(struct libinput_event_tablet *t)
static void static void
print_tablet_axis_event(struct libinput_event *ev) 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); print_tablet_axes(t);
printf("\n"); printf("\n");
} }
@ -456,8 +456,8 @@ print_touch_event_without_coords(struct libinput_event *ev)
static void static void
print_proximity_event(struct libinput_event *ev) print_proximity_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);
struct libinput_tablet_tool *tool = libinput_event_tablet_get_tool(t); struct libinput_tablet_tool *tool = libinput_event_tablet_tool_get_tool(t);
enum libinput_tablet_tool_proximity_state state; enum libinput_tablet_tool_proximity_state state;
const char *tool_str, const char *tool_str,
*state_str; *state_str;
@ -491,9 +491,9 @@ print_proximity_event(struct libinput_event *ev)
abort(); 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) { if (state == LIBINPUT_TABLET_TOOL_PROXIMITY_IN) {
print_tablet_axes(t); 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 static void
handle_event_tablet(struct libinput_event *ev, struct window *w) 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; double x, y;
switch (libinput_event_get_type(ev)) { switch (libinput_event_get_type(ev)) {
case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY: 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) { LIBINPUT_TABLET_TOOL_PROXIMITY_OUT) {
w->tool.x_in = 0; w->tool.x_in = 0;
w->tool.y_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.x_up = 0;
w->tool.y_up = 0; w->tool.y_up = 0;
} else { } 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->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); w->height);
} }
break; break;
case LIBINPUT_EVENT_TABLET_TOOL_AXIS: 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->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->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); 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); 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); 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); LIBINPUT_TABLET_TOOL_AXIS_TILT_Y);
break; break;
case LIBINPUT_EVENT_TABLET_TOOL_TIP: case LIBINPUT_EVENT_TABLET_TOOL_TIP:
x = libinput_event_tablet_get_x_transformed(t, w->width); x = libinput_event_tablet_tool_get_x_transformed(t, w->width);
y = libinput_event_tablet_get_y_transformed(t, w->height); y = libinput_event_tablet_tool_get_y_transformed(t, w->height);
if (libinput_event_tablet_get_tip_state(t) == if (libinput_event_tablet_tool_get_tip_state(t) ==
LIBINPUT_TABLET_TOOL_TIP_DOWN) { LIBINPUT_TABLET_TOOL_TIP_DOWN) {
w->tool.x_down = x; w->tool.x_down = x;
w->tool.y_down = y; w->tool.y_down = y;