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

tablet: rename the libinput_tool calls to libinput_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:35:03 +10:00
parent a10e92849c
commit abb98d5738
6 changed files with 99 additions and 99 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/evdev-tablet.c
View file

@ -1008,7 +1008,7 @@ tablet_destroy(struct evdev_dispatch *dispatch)
struct libinput_tablet_tool *tool, *tmp; struct libinput_tablet_tool *tool, *tmp;
list_for_each_safe(tool, tmp, &tablet->tool_list, link) { list_for_each_safe(tool, tmp, &tablet->tool_list, link) {
libinput_tool_unref(tool); libinput_tablet_tool_unref(tool);
} }
free(tablet); free(tablet);

26
src/libinput.c
View file

@ -1165,33 +1165,33 @@ libinput_event_tablet_tool_get_seat_button_count(struct libinput_event_tablet_to
} }
LIBINPUT_EXPORT enum libinput_tablet_tool_type LIBINPUT_EXPORT enum libinput_tablet_tool_type
libinput_tool_get_type(struct libinput_tablet_tool *tool) libinput_tablet_tool_get_type(struct libinput_tablet_tool *tool)
{ {
return tool->type; return tool->type;
} }
LIBINPUT_EXPORT uint64_t LIBINPUT_EXPORT uint64_t
libinput_tool_get_tool_id(struct libinput_tablet_tool *tool) libinput_tablet_tool_get_tool_id(struct libinput_tablet_tool *tool)
{ {
return tool->tool_id; return tool->tool_id;
} }
LIBINPUT_EXPORT uint64_t LIBINPUT_EXPORT uint64_t
libinput_tool_get_serial(struct libinput_tablet_tool *tool) libinput_tablet_tool_get_serial(struct libinput_tablet_tool *tool)
{ {
return tool->serial; return tool->serial;
} }
LIBINPUT_EXPORT int LIBINPUT_EXPORT int
libinput_tool_has_axis(struct libinput_tablet_tool *tool, libinput_tablet_tool_has_axis(struct libinput_tablet_tool *tool,
enum libinput_tablet_tool_axis axis) enum libinput_tablet_tool_axis axis)
{ {
return bit_is_set(tool->axis_caps, axis); return bit_is_set(tool->axis_caps, axis);
} }
LIBINPUT_EXPORT int LIBINPUT_EXPORT int
libinput_tool_has_button(struct libinput_tablet_tool *tool, libinput_tablet_tool_has_button(struct libinput_tablet_tool *tool,
uint32_t code) uint32_t code)
{ {
if (NCHARS(code) > sizeof(tool->buttons)) if (NCHARS(code) > sizeof(tool->buttons))
return 0; return 0;
@ -1200,27 +1200,27 @@ libinput_tool_has_button(struct libinput_tablet_tool *tool,
} }
LIBINPUT_EXPORT void LIBINPUT_EXPORT void
libinput_tool_set_user_data(struct libinput_tablet_tool *tool, libinput_tablet_tool_set_user_data(struct libinput_tablet_tool *tool,
void *user_data) void *user_data)
{ {
tool->user_data = user_data; tool->user_data = user_data;
} }
LIBINPUT_EXPORT void * LIBINPUT_EXPORT void *
libinput_tool_get_user_data(struct libinput_tablet_tool *tool) libinput_tablet_tool_get_user_data(struct libinput_tablet_tool *tool)
{ {
return tool->user_data; return tool->user_data;
} }
LIBINPUT_EXPORT struct libinput_tablet_tool * LIBINPUT_EXPORT struct libinput_tablet_tool *
libinput_tool_ref(struct libinput_tablet_tool *tool) libinput_tablet_tool_ref(struct libinput_tablet_tool *tool)
{ {
tool->refcount++; tool->refcount++;
return tool; return tool;
} }
LIBINPUT_EXPORT struct libinput_tablet_tool * LIBINPUT_EXPORT struct libinput_tablet_tool *
libinput_tool_unref(struct libinput_tablet_tool *tool) libinput_tablet_tool_unref(struct libinput_tablet_tool *tool)
{ {
assert(tool->refcount > 0); assert(tool->refcount > 0);
@ -1374,7 +1374,7 @@ libinput_unref(struct libinput *libinput)
} }
list_for_each_safe(tool, next_tool, &libinput->tool_list, link) { list_for_each_safe(tool, next_tool, &libinput->tool_list, link) {
libinput_tool_unref(tool); libinput_tablet_tool_unref(tool);
} }
libinput_timer_subsys_destroy(libinput); libinput_timer_subsys_destroy(libinput);

34
src/libinput.h
View file

@ -174,7 +174,7 @@ struct libinput_tablet_tool;
* physical tools may share the same tool type, e.g. a Wacom Classic Pen, * physical tools may share the same tool type, e.g. a Wacom Classic Pen,
* Wacom Pro Pen and a Wacom Grip Pen are all of type @ref * Wacom Pro Pen and a Wacom Grip Pen are all of type @ref
* LIBINPUT_TABLET_TOOL_TYPE_PEN. * LIBINPUT_TABLET_TOOL_TYPE_PEN.
* Use libinput_tool_get_tool_id() to get a specific model where applicable. * Use libinput_tablet_tool_get_tool_id() to get a specific model where applicable.
* *
* Note that on some device, the eraser tool is on the tail end of a pen * Note that on some device, the eraser tool is on the tail end of a pen
* device. On other devices, e.g. MS Surface 3, the eraser is the pen tip * device. On other devices, e.g. MS Surface 3, the eraser is the pen tip
@ -1497,7 +1497,7 @@ libinput_event_tablet_tool_get_y_transformed(struct libinput_event_tablet_tool *
* Returns the tool that was in use during this event. * Returns the tool that was in use during this event.
* By default, each tool will stay valid for as long as it is being used, and is * By default, each tool will stay valid for as long as it is being used, and is
* destroyed when another tool comes into proximity. However, the lifetime of * destroyed when another tool comes into proximity. However, the lifetime of
* the tool may be extended by using libinput_tool_ref() to increment the * the tool may be extended by using libinput_tablet_tool_ref() to increment the
* reference count of the tool. This guarantees that whenever the tool comes * reference count of the tool. This guarantees that whenever the tool comes
* back into proximity of the tablet, that the same structure will be used to * back into proximity of the tablet, that the same structure will be used to
* represent the tool. * represent the tool.
@ -1611,17 +1611,17 @@ libinput_event_tablet_tool_get_time_usec(struct libinput_event_tablet_tool *even
* @param tool The libinput tool * @param tool The libinput tool
* @return The tool type for this tool object * @return The tool type for this tool object
* *
* @see libinput_tool_get_tool_id * @see libinput_tablet_tool_get_tool_id
*/ */
enum libinput_tablet_tool_type enum libinput_tablet_tool_type
libinput_tool_get_type(struct libinput_tablet_tool *tool); libinput_tablet_tool_get_type(struct libinput_tablet_tool *tool);
/** /**
* @ingroup event_tablet * @ingroup event_tablet
* *
* Return the tool ID for a tool object. If nonzero, this number identifies * Return the tool ID for a tool object. If nonzero, this number identifies
* the specific type of the tool with more precision than the type returned in * the specific type of the tool with more precision than the type returned in
* libinput_tool_get_type(). Not all tablets support a tool ID. * libinput_tablet_tool_get_type(). Not all tablets support a tool ID.
* *
* Tablets known to support tool IDs include the Wacom Intuos 3, 4, 5, Wacom * Tablets known to support tool IDs include the Wacom Intuos 3, 4, 5, Wacom
* Cintiq and Wacom Intuos Pro series. * Cintiq and Wacom Intuos Pro series.
@ -1629,10 +1629,10 @@ libinput_tool_get_type(struct libinput_tablet_tool *tool);
* @param tool The libinput tool * @param tool The libinput tool
* @return The tool ID for this tool object or 0 if none is provided * @return The tool ID for this tool object or 0 if none is provided
* *
* @see libinput_tool_get_type * @see libinput_tablet_tool_get_type
*/ */
uint64_t uint64_t
libinput_tool_get_tool_id(struct libinput_tablet_tool *tool); libinput_tablet_tool_get_tool_id(struct libinput_tablet_tool *tool);
/** /**
* @ingroup event_tablet * @ingroup event_tablet
@ -1643,7 +1643,7 @@ libinput_tool_get_tool_id(struct libinput_tablet_tool *tool);
* @return The passed tool * @return The passed tool
*/ */
struct libinput_tablet_tool * struct libinput_tablet_tool *
libinput_tool_ref(struct libinput_tablet_tool *tool); libinput_tablet_tool_ref(struct libinput_tablet_tool *tool);
/** /**
* @ingroup event_tablet * @ingroup event_tablet
@ -1655,8 +1655,8 @@ libinput_tool_ref(struct libinput_tablet_tool *tool);
* @return Whether or not the axis is supported * @return Whether or not the axis is supported
*/ */
int int
libinput_tool_has_axis(struct libinput_tablet_tool *tool, libinput_tablet_tool_has_axis(struct libinput_tablet_tool *tool,
enum libinput_tablet_tool_axis axis); enum libinput_tablet_tool_axis axis);
/** /**
* @ingroup event_tablet * @ingroup event_tablet
@ -1670,8 +1670,8 @@ libinput_tool_has_axis(struct libinput_tablet_tool *tool,
* @return 1 if the tool supports this button code, 0 if it does not * @return 1 if the tool supports this button code, 0 if it does not
*/ */
int int
libinput_tool_has_button(struct libinput_tablet_tool *tool, libinput_tablet_tool_has_button(struct libinput_tablet_tool *tool,
uint32_t code); uint32_t code);
/** /**
* @ingroup event_tablet * @ingroup event_tablet
@ -1683,7 +1683,7 @@ libinput_tool_has_button(struct libinput_tablet_tool *tool,
* @return NULL if the tool was destroyed otherwise the passed tool * @return NULL if the tool was destroyed otherwise the passed tool
*/ */
struct libinput_tablet_tool * struct libinput_tablet_tool *
libinput_tool_unref(struct libinput_tablet_tool *tool); libinput_tablet_tool_unref(struct libinput_tablet_tool *tool);
/** /**
* @ingroup event_tablet * @ingroup event_tablet
@ -1698,7 +1698,7 @@ libinput_tool_unref(struct libinput_tablet_tool *tool);
* @return The new tool serial triggering this event * @return The new tool serial triggering this event
*/ */
uint64_t uint64_t
libinput_tool_get_serial(struct libinput_tablet_tool *tool); libinput_tablet_tool_get_serial(struct libinput_tablet_tool *tool);
/** /**
* @ingroup event_tablet * @ingroup event_tablet
@ -1709,7 +1709,7 @@ libinput_tool_get_serial(struct libinput_tablet_tool *tool);
* @return The user data associated with the tool object * @return The user data associated with the tool object
*/ */
void * void *
libinput_tool_get_user_data(struct libinput_tablet_tool *tool); libinput_tablet_tool_get_user_data(struct libinput_tablet_tool *tool);
/** /**
* @ingroup event_tablet * @ingroup event_tablet
@ -1720,8 +1720,8 @@ libinput_tool_get_user_data(struct libinput_tablet_tool *tool);
* @param user_data The user data to associate with the tool object * @param user_data The user data to associate with the tool object
*/ */
void void
libinput_tool_set_user_data(struct libinput_tablet_tool *tool, libinput_tablet_tool_set_user_data(struct libinput_tablet_tool *tool,
void *user_data); void *user_data);
/** /**
* @defgroup base Initialization and manipulation of libinput contexts * @defgroup base Initialization and manipulation of libinput contexts

18
src/libinput.sym
View file

@ -200,13 +200,13 @@ LIBINPUT_TABLET_SUPPORT {
libinput_event_tablet_tool_get_x_transformed; libinput_event_tablet_tool_get_x_transformed;
libinput_event_tablet_tool_get_y_transformed; libinput_event_tablet_tool_get_y_transformed;
libinput_event_tablet_tool_get_time_usec; libinput_event_tablet_tool_get_time_usec;
libinput_tool_get_serial; libinput_tablet_tool_get_serial;
libinput_tool_get_tool_id; libinput_tablet_tool_get_tool_id;
libinput_tool_get_type; libinput_tablet_tool_get_type;
libinput_tool_get_user_data; libinput_tablet_tool_get_user_data;
libinput_tool_has_button; libinput_tablet_tool_has_button;
libinput_tool_has_axis; libinput_tablet_tool_has_axis;
libinput_tool_ref; libinput_tablet_tool_ref;
libinput_tool_set_user_data; libinput_tablet_tool_set_user_data;
libinput_tool_unref; libinput_tablet_tool_unref;
} LIBINPUT_1.1; } LIBINPUT_1.1;

68
test/tablet.c
View file

@ -592,7 +592,7 @@ START_TEST(proximity_in_out)
have_tool_update++; have_tool_update++;
tablet_event = libinput_event_get_tablet_tool_event(event); tablet_event = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tablet_event); tool = libinput_event_tablet_tool_get_tool(tablet_event);
ck_assert_int_eq(libinput_tool_get_type(tool), ck_assert_int_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_PEN); LIBINPUT_TABLET_TOOL_TYPE_PEN);
} }
libinput_event_destroy(event); libinput_event_destroy(event);
@ -734,7 +734,7 @@ START_TEST(proximity_has_axes)
litest_assert_double_ne(x, 0); litest_assert_double_ne(x, 0);
litest_assert_double_ne(y, 0); litest_assert_double_ne(y, 0);
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)) { if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)) {
ck_assert(libinput_event_tablet_tool_axis_has_changed( ck_assert(libinput_event_tablet_tool_axis_has_changed(
tablet_event, tablet_event,
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)); LIBINPUT_TABLET_TOOL_AXIS_DISTANCE));
@ -745,8 +745,8 @@ START_TEST(proximity_has_axes)
litest_assert_double_ne(distance, 0); litest_assert_double_ne(distance, 0);
} }
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) && if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) &&
libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) { libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) {
ck_assert(libinput_event_tablet_tool_axis_has_changed( ck_assert(libinput_event_tablet_tool_axis_has_changed(
tablet_event, tablet_event,
LIBINPUT_TABLET_TOOL_AXIS_TILT_X)); LIBINPUT_TABLET_TOOL_AXIS_TILT_X));
@ -781,12 +781,12 @@ START_TEST(proximity_has_axes)
LIBINPUT_TABLET_TOOL_AXIS_X); LIBINPUT_TABLET_TOOL_AXIS_X);
last_y = libinput_event_tablet_tool_get_axis_value(tablet_event, last_y = libinput_event_tablet_tool_get_axis_value(tablet_event,
LIBINPUT_TABLET_TOOL_AXIS_Y); LIBINPUT_TABLET_TOOL_AXIS_Y);
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)) if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE))
last_distance = libinput_event_tablet_tool_get_axis_value( last_distance = libinput_event_tablet_tool_get_axis_value(
tablet_event, tablet_event,
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE); LIBINPUT_TABLET_TOOL_AXIS_DISTANCE);
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) && if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) &&
libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) { libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) {
last_tx = libinput_event_tablet_tool_get_axis_value( last_tx = libinput_event_tablet_tool_get_axis_value(
tablet_event, tablet_event,
LIBINPUT_TABLET_TOOL_AXIS_TILT_X); LIBINPUT_TABLET_TOOL_AXIS_TILT_X);
@ -818,7 +818,7 @@ START_TEST(proximity_has_axes)
litest_assert_double_eq(x, last_x); litest_assert_double_eq(x, last_x);
litest_assert_double_eq(y, last_y); litest_assert_double_eq(y, last_y);
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)) { if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)) {
ck_assert(!libinput_event_tablet_tool_axis_has_changed( ck_assert(!libinput_event_tablet_tool_axis_has_changed(
tablet_event, tablet_event,
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)); LIBINPUT_TABLET_TOOL_AXIS_DISTANCE));
@ -829,8 +829,8 @@ START_TEST(proximity_has_axes)
litest_assert_double_eq(distance, last_distance); litest_assert_double_eq(distance, last_distance);
} }
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) && if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) &&
libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) { libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) {
ck_assert(!libinput_event_tablet_tool_axis_has_changed( ck_assert(!libinput_event_tablet_tool_axis_has_changed(
tablet_event, tablet_event,
LIBINPUT_TABLET_TOOL_AXIS_TILT_X)); LIBINPUT_TABLET_TOOL_AXIS_TILT_X));
@ -1454,7 +1454,7 @@ START_TEST(tool_serial)
event = libinput_get_event(li); event = libinput_get_event(li);
tablet_event = libinput_event_get_tablet_tool_event(event); tablet_event = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tablet_event); tool = libinput_event_tablet_tool_get_tool(tablet_event);
ck_assert_uint_eq(libinput_tool_get_serial(tool), 1000); ck_assert_uint_eq(libinput_tablet_tool_get_serial(tool), 1000);
libinput_event_destroy(event); libinput_event_destroy(event);
} }
END_TEST END_TEST
@ -1487,7 +1487,7 @@ START_TEST(serial_changes_tool)
tablet_event = libinput_event_get_tablet_tool_event(event); tablet_event = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tablet_event); tool = libinput_event_tablet_tool_get_tool(tablet_event);
ck_assert_uint_eq(libinput_tool_get_serial(tool), 2000); ck_assert_uint_eq(libinput_tablet_tool_get_serial(tool), 2000);
libinput_event_destroy(event); libinput_event_destroy(event);
} }
END_TEST END_TEST
@ -1520,7 +1520,7 @@ START_TEST(invalid_serials)
tablet_event = libinput_event_get_tablet_tool_event(event); tablet_event = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tablet_event); tool = libinput_event_tablet_tool_get_tool(tablet_event);
ck_assert_uint_eq(libinput_tool_get_serial(tool), 1000); ck_assert_uint_eq(libinput_tablet_tool_get_serial(tool), 1000);
} }
libinput_event_destroy(event); libinput_event_destroy(event);
@ -1550,9 +1550,9 @@ START_TEST(tool_ref)
tool = libinput_event_tablet_tool_get_tool(tablet_event); tool = libinput_event_tablet_tool_get_tool(tablet_event);
ck_assert_notnull(tool); ck_assert_notnull(tool);
ck_assert(tool == libinput_tool_ref(tool)); ck_assert(tool == libinput_tablet_tool_ref(tool));
ck_assert(tool == libinput_tool_unref(tool)); ck_assert(tool == libinput_tablet_tool_unref(tool));
ck_assert(libinput_tool_unref(tool) == NULL); ck_assert(libinput_tablet_tool_unref(tool) == NULL);
libinput_event_destroy(event); libinput_event_destroy(event);
} }
@ -1732,13 +1732,13 @@ START_TEST(tool_capabilities)
t = libinput_event_get_tablet_tool_event(event); t = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(t); tool = libinput_event_tablet_tool_get_tool(t);
ck_assert(libinput_tool_has_axis(tool, ck_assert(libinput_tablet_tool_has_axis(tool,
LIBINPUT_TABLET_TOOL_AXIS_PRESSURE)); LIBINPUT_TABLET_TOOL_AXIS_PRESSURE));
ck_assert(libinput_tool_has_axis(tool, ck_assert(libinput_tablet_tool_has_axis(tool,
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)); LIBINPUT_TABLET_TOOL_AXIS_DISTANCE));
ck_assert(!libinput_tool_has_axis(tool, ck_assert(!libinput_tablet_tool_has_axis(tool,
LIBINPUT_TABLET_TOOL_AXIS_TILT_X)); LIBINPUT_TABLET_TOOL_AXIS_TILT_X));
ck_assert(!libinput_tool_has_axis(tool, ck_assert(!libinput_tablet_tool_has_axis(tool,
LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)); LIBINPUT_TABLET_TOOL_AXIS_TILT_Y));
libinput_event_destroy(event); libinput_event_destroy(event);
@ -1755,13 +1755,13 @@ START_TEST(tool_capabilities)
t = libinput_event_get_tablet_tool_event(event); t = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(t); tool = libinput_event_tablet_tool_get_tool(t);
ck_assert(libinput_tool_has_axis(tool, ck_assert(libinput_tablet_tool_has_axis(tool,
LIBINPUT_TABLET_TOOL_AXIS_PRESSURE)); LIBINPUT_TABLET_TOOL_AXIS_PRESSURE));
ck_assert(libinput_tool_has_axis(tool, ck_assert(libinput_tablet_tool_has_axis(tool,
LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)); LIBINPUT_TABLET_TOOL_AXIS_DISTANCE));
ck_assert(libinput_tool_has_axis(tool, ck_assert(libinput_tablet_tool_has_axis(tool,
LIBINPUT_TABLET_TOOL_AXIS_TILT_X)); LIBINPUT_TABLET_TOOL_AXIS_TILT_X));
ck_assert(libinput_tool_has_axis(tool, ck_assert(libinput_tablet_tool_has_axis(tool,
LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)); LIBINPUT_TABLET_TOOL_AXIS_TILT_Y));
libinput_event_destroy(event); libinput_event_destroy(event);
@ -1851,7 +1851,7 @@ START_TEST(mouse_tool)
tev = libinput_event_get_tablet_tool_event(event); tev = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tev); tool = libinput_event_tablet_tool_get_tool(tev);
ck_assert_notnull(tool); ck_assert_notnull(tool);
ck_assert_int_eq(libinput_tool_get_type(tool), ck_assert_int_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_MOUSE); LIBINPUT_TABLET_TOOL_TYPE_MOUSE);
libinput_event_destroy(event); libinput_event_destroy(event);
@ -1886,7 +1886,7 @@ START_TEST(mouse_buttons)
tev = libinput_event_get_tablet_tool_event(event); tev = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tev); tool = libinput_event_tablet_tool_get_tool(tev);
ck_assert_notnull(tool); ck_assert_notnull(tool);
libinput_tool_ref(tool); libinput_tablet_tool_ref(tool);
libinput_event_destroy(event); libinput_event_destroy(event);
@ -1895,7 +1895,7 @@ START_TEST(mouse_buttons)
EV_KEY, EV_KEY,
code); code);
ck_assert_int_eq(!!has_button, ck_assert_int_eq(!!has_button,
!!libinput_tool_has_button(tool, code)); !!libinput_tablet_tool_has_button(tool, code));
if (!has_button) if (!has_button)
continue; continue;
@ -1915,7 +1915,7 @@ START_TEST(mouse_buttons)
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
} }
libinput_tool_unref(tool); libinput_tablet_tool_unref(tool);
} }
END_TEST END_TEST
@ -2025,11 +2025,11 @@ START_TEST(mouse_wheel)
tev = libinput_event_get_tablet_tool_event(event); tev = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tev); tool = libinput_event_tablet_tool_get_tool(tev);
ck_assert_notnull(tool); ck_assert_notnull(tool);
libinput_tool_ref(tool); libinput_tablet_tool_ref(tool);
libinput_event_destroy(event); libinput_event_destroy(event);
ck_assert(libinput_tool_has_axis(tool, ck_assert(libinput_tablet_tool_has_axis(tool,
LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL)); LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL));
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
@ -2090,7 +2090,7 @@ START_TEST(mouse_wheel)
litest_assert_empty_queue(li); litest_assert_empty_queue(li);
} }
libinput_tool_unref(tool); libinput_tablet_tool_unref(tool);
} }
END_TEST END_TEST
@ -2120,7 +2120,7 @@ START_TEST(airbrush_tool)
tev = libinput_event_get_tablet_tool_event(event); tev = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tev); tool = libinput_event_tablet_tool_get_tool(tev);
ck_assert_notnull(tool); ck_assert_notnull(tool);
ck_assert_int_eq(libinput_tool_get_type(tool), ck_assert_int_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH); LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH);
libinput_event_destroy(event); libinput_event_destroy(event);
@ -2207,9 +2207,9 @@ START_TEST(artpen_tool)
tev = libinput_event_get_tablet_tool_event(event); tev = libinput_event_get_tablet_tool_event(event);
tool = libinput_event_tablet_tool_get_tool(tev); tool = libinput_event_tablet_tool_get_tool(tev);
ck_assert_notnull(tool); ck_assert_notnull(tool);
ck_assert_int_eq(libinput_tool_get_type(tool), ck_assert_int_eq(libinput_tablet_tool_get_type(tool),
LIBINPUT_TABLET_TOOL_TYPE_PEN); LIBINPUT_TABLET_TOOL_TYPE_PEN);
ck_assert(libinput_tool_has_axis(tool, ck_assert(libinput_tablet_tool_has_axis(tool,
LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z)); LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z));
libinput_event_destroy(event); libinput_event_destroy(event);

50
tools/event-debug.c
View file

@ -354,8 +354,8 @@ print_tablet_axes(struct libinput_event_tablet_tool *t)
y, tablet_axis_changed_sym(t, LIBINPUT_TABLET_TOOL_AXIS_Y), y, tablet_axis_changed_sym(t, LIBINPUT_TABLET_TOOL_AXIS_Y),
dx, dy); dx, dy);
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) || if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) ||
libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) { libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) {
x = libinput_event_tablet_tool_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_tool_get_axis_value(t, y = libinput_event_tablet_tool_get_axis_value(t,
@ -372,8 +372,8 @@ print_tablet_axes(struct libinput_event_tablet_tool *t)
dx, dy); dx, dy);
} }
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE) || if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE) ||
libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_PRESSURE)) { libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_PRESSURE)) {
dist = libinput_event_tablet_tool_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_tool_get_axis_value(t, pressure = libinput_event_tablet_tool_get_axis_value(t,
@ -397,7 +397,7 @@ print_tablet_axes(struct libinput_event_tablet_tool *t)
} }
} }
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z)) { if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z)) {
rotation = libinput_event_tablet_tool_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_tool_get_axis_delta(t, delta = libinput_event_tablet_tool_get_axis_delta(t,
@ -409,7 +409,7 @@ print_tablet_axes(struct libinput_event_tablet_tool *t)
delta); delta);
} }
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_SLIDER)) { if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_SLIDER)) {
slider = libinput_event_tablet_tool_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_tool_get_axis_delta(t, delta = libinput_event_tablet_tool_get_axis_delta(t,
@ -421,7 +421,7 @@ print_tablet_axes(struct libinput_event_tablet_tool *t)
delta); delta);
} }
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL)) { if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL)) {
wheel = libinput_event_tablet_tool_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_tool_get_axis_delta_discrete(t, delta = libinput_event_tablet_tool_get_axis_delta_discrete(t,
@ -462,7 +462,7 @@ print_proximity_event(struct libinput_event *ev)
const char *tool_str, const char *tool_str,
*state_str; *state_str;
switch (libinput_tool_get_type(tool)) { switch (libinput_tablet_tool_get_type(tool)) {
case LIBINPUT_TABLET_TOOL_TYPE_PEN: case LIBINPUT_TABLET_TOOL_TYPE_PEN:
tool_str = "pen"; tool_str = "pen";
break; break;
@ -507,41 +507,41 @@ print_proximity_event(struct libinput_event *ev)
printf("\t%s (%#" PRIx64 ", id %#" PRIx64 ") %s", printf("\t%s (%#" PRIx64 ", id %#" PRIx64 ") %s",
tool_str, tool_str,
libinput_tool_get_serial(tool), libinput_tablet_tool_get_serial(tool),
libinput_tool_get_tool_id(tool), libinput_tablet_tool_get_tool_id(tool),
state_str); state_str);
printf("\taxes:"); printf("\taxes:");
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE)) if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_DISTANCE))
printf("d"); printf("d");
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_PRESSURE)) if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_PRESSURE))
printf("p"); printf("p");
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) || if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_X) ||
libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y)) libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_TILT_Y))
printf("t"); printf("t");
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z)) if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_ROTATION_Z))
printf("r"); printf("r");
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_SLIDER)) if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_SLIDER))
printf("s"); printf("s");
if (libinput_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL)) if (libinput_tablet_tool_has_axis(tool, LIBINPUT_TABLET_TOOL_AXIS_REL_WHEEL))
printf("w"); printf("w");
printf("\tbtn:"); printf("\tbtn:");
if (libinput_tool_has_button(tool, BTN_TOUCH)) if (libinput_tablet_tool_has_button(tool, BTN_TOUCH))
printf("T"); printf("T");
if (libinput_tool_has_button(tool, BTN_STYLUS)) if (libinput_tablet_tool_has_button(tool, BTN_STYLUS))
printf("S"); printf("S");
if (libinput_tool_has_button(tool, BTN_STYLUS2)) if (libinput_tablet_tool_has_button(tool, BTN_STYLUS2))
printf("S2"); printf("S2");
if (libinput_tool_has_button(tool, BTN_LEFT)) if (libinput_tablet_tool_has_button(tool, BTN_LEFT))
printf("L"); printf("L");
if (libinput_tool_has_button(tool, BTN_MIDDLE)) if (libinput_tablet_tool_has_button(tool, BTN_MIDDLE))
printf("M"); printf("M");
if (libinput_tool_has_button(tool, BTN_RIGHT)) if (libinput_tablet_tool_has_button(tool, BTN_RIGHT))
printf("R"); printf("R");
if (libinput_tool_has_button(tool, BTN_SIDE)) if (libinput_tablet_tool_has_button(tool, BTN_SIDE))
printf("Sd"); printf("Sd");
if (libinput_tool_has_button(tool, BTN_EXTRA)) if (libinput_tablet_tool_has_button(tool, BTN_EXTRA))
printf("Ex"); printf("Ex");
printf("\n"); printf("\n");