fdo-mirrors/libevdev
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libevdev/libevdev.git synced 2025-12-20 12:40:07 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rename a few getters for consistency

Browse source 
Deprecated:
* libevdev_get_abs_min, libevdev_get_abs_max
* libevdev_get_input_prop_name

Will be removed in one or two versions.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
Reviewed-by: Benjamin Tissoires <benjamin.tissoires@gmail.com>
This commit is contained in:
Peter Hutterer 2013-07-30 11:25:00 +10:00
parent 2ff65baf59
commit 00528f27d5
5 changed files with 55 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
libevdev/libevdev.c
View file

@ -813,13 +813,14 @@ int libevdev_get_abs_##name(const struct libevdev *dev, unsigned int code) \
return absinfo ? absinfo->field : 0; \
}
ABS_GETTER(max, maximum);
ABS_GETTER(min, minimum);
ABS_GETTER(max, maximum); /* DEPRECATED */
ABS_GETTER(min, minimum); /* DEPRECATED */
ABS_GETTER(maximum, maximum);
ABS_GETTER(minimum, minimum);
ABS_GETTER(fuzz, fuzz)
ABS_GETTER(flat, flat)
ABS_GETTER(resolution, resolution)
int
libevdev_enable_event_type(struct libevdev *dev, unsigned int type)
{
@ -986,8 +987,15 @@ libevdev_get_event_code_name(unsigned int type, unsigned int code)
return event_type_map[type][code];
}
/* DEPRECATED */
const char*
libevdev_get_input_prop_name(unsigned int prop)
{
return libevdev_get_property_name(prop);
}
const char*
libevdev_get_property_name(unsigned int prop)
{
if (prop > INPUT_PROP_MAX)
return NULL;

23
libevdev/libevdev.h
View file

@ -657,7 +657,7 @@ int libevdev_has_event_code(const struct libevdev *dev, unsigned int type, unsig
*
* @return axis minimum for the given axis or 0 if the axis is invalid
*/
int libevdev_get_abs_min(const struct libevdev *dev, unsigned int code);
int libevdev_get_abs_minimum(const struct libevdev *dev, unsigned int code);
/**
* @ingroup bits
*
@ -668,7 +668,7 @@ int libevdev_get_abs_min(const struct libevdev *dev, unsigned int code);
*
* @return axis maximum for the given axis or 0 if the axis is invalid
*/
int libevdev_get_abs_max(const struct libevdev *dev, unsigned int code);
int libevdev_get_abs_maximum(const struct libevdev *dev, unsigned int code);
/**
* @ingroup bits
*
@ -1043,7 +1043,7 @@ const char * libevdev_get_event_code_name(unsigned int type, unsigned int code);
* @note On older kernels input properties may not be defined and
* libevdev_get_input_prop_name() will always return NULL
*/
const char * libevdev_get_input_prop_name(unsigned int prop);
const char* libevdev_get_property_name(unsigned int prop);
/**
* @ingroup misc
@ -1074,4 +1074,21 @@ int libevdev_get_event_type_max(unsigned int type);
*/
int libevdev_get_repeat(struct libevdev *dev, int *delay, int *period);
/********* DEPRECATED SECTION *********/
#if defined(__GNUC__) && __GNUC__ >= 4
#define LIBEVDEV_DEPRECATED __attribute__ ((deprecated))
#else
#define LIBEVDEV_DEPRECATED
#endif
/* replacement: libevdev_get_abs_minimum */
int libevdev_get_abs_min(const struct libevdev *dev, unsigned int code) LIBEVDEV_DEPRECATED;
/* replacement: libevdev_get_abs_maximum */
int libevdev_get_abs_max(const struct libevdev *dev, unsigned int code) LIBEVDEV_DEPRECATED;
/* replacement: libevdev_get_property_name */
const char* libevdev_get_input_prop_name(unsigned int prop) LIBEVDEV_DEPRECATED;
/**************************************/
#endif /* libevdev_H */

14
test/test-event-names.c
View file

@ -204,14 +204,14 @@ END_TEST
START_TEST(test_prop_name)
{
ck_assert_str_eq(libevdev_get_input_prop_name(INPUT_PROP_POINTER), "INPUT_PROP_POINTER");
ck_assert_str_eq(libevdev_get_input_prop_name(INPUT_PROP_DIRECT), "INPUT_PROP_DIRECT");
ck_assert_str_eq(libevdev_get_input_prop_name(INPUT_PROP_BUTTONPAD), "INPUT_PROP_BUTTONPAD");
ck_assert_str_eq(libevdev_get_input_prop_name(INPUT_PROP_SEMI_MT), "INPUT_PROP_SEMI_MT");
ck_assert_str_eq(libevdev_get_input_prop_name(INPUT_PROP_MAX), "INPUT_PROP_MAX");
ck_assert_str_eq(libevdev_get_property_name(INPUT_PROP_POINTER), "INPUT_PROP_POINTER");
ck_assert_str_eq(libevdev_get_property_name(INPUT_PROP_DIRECT), "INPUT_PROP_DIRECT");
ck_assert_str_eq(libevdev_get_property_name(INPUT_PROP_BUTTONPAD), "INPUT_PROP_BUTTONPAD");
ck_assert_str_eq(libevdev_get_property_name(INPUT_PROP_SEMI_MT), "INPUT_PROP_SEMI_MT");
ck_assert_str_eq(libevdev_get_property_name(INPUT_PROP_MAX), "INPUT_PROP_MAX");
ck_assert(libevdev_get_input_prop_name(INPUT_PROP_MAX - 1) == NULL);
ck_assert(libevdev_get_input_prop_name(INPUT_PROP_MAX + 1) == NULL);
ck_assert(libevdev_get_property_name(INPUT_PROP_MAX - 1) == NULL);
ck_assert(libevdev_get_property_name(INPUT_PROP_MAX + 1) == NULL);
}
END_TEST

32
test/test-libevdev-has-event.c
View file

@ -479,15 +479,15 @@ START_TEST(test_device_get_abs_info)
rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
ck_assert_int_eq(libevdev_get_abs_min(dev, ABS_MAX + 1), 0);
ck_assert_int_eq(libevdev_get_abs_max(dev, ABS_MAX + 1), 0);
ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_MAX + 1), 0);
ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_MAX + 1), 0);
ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_MAX + 1), 0);
ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_MAX + 1), 0);
ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_MAX + 1), 0);
ck_assert(!libevdev_get_abs_info(dev, ABS_MAX + 1));
ck_assert_int_eq(libevdev_get_abs_min(dev, ABS_X), 0);
ck_assert_int_eq(libevdev_get_abs_max(dev, ABS_X), 1000);
ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X), 0);
ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X), 1000);
ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X), 1);
ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X), 2);
ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X), 3);
@ -499,8 +499,8 @@ START_TEST(test_device_get_abs_info)
ck_assert_int_eq(a->flat, 2);
ck_assert_int_eq(a->resolution, 3);
ck_assert_int_eq(libevdev_get_abs_min(dev, ABS_MT_POSITION_X), 0);
ck_assert_int_eq(libevdev_get_abs_max(dev, ABS_MT_POSITION_X), 1000);
ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_MT_POSITION_X), 0);
ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_MT_POSITION_X), 1000);
ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_MT_POSITION_X), 1);
ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_MT_POSITION_X), 2);
ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_MT_POSITION_X), 3);
@ -512,8 +512,8 @@ START_TEST(test_device_get_abs_info)
ck_assert_int_eq(a->flat, 2);
ck_assert_int_eq(a->resolution, 3);
ck_assert_int_eq(libevdev_get_abs_min(dev, ABS_Y), -500);
ck_assert_int_eq(libevdev_get_abs_max(dev, ABS_Y), 500);
ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_Y), -500);
ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_Y), 500);
ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_Y), 10);
ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_Y), 20);
ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_Y), 30);
@ -525,8 +525,8 @@ START_TEST(test_device_get_abs_info)
ck_assert_int_eq(a->flat, 20);
ck_assert_int_eq(a->resolution, 30);
ck_assert_int_eq(libevdev_get_abs_min(dev, ABS_MT_POSITION_Y), -500);
ck_assert_int_eq(libevdev_get_abs_max(dev, ABS_MT_POSITION_Y), 500);
ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_MT_POSITION_Y), -500);
ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_MT_POSITION_Y), 500);
ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_MT_POSITION_Y), 10);
ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_MT_POSITION_Y), 20);
ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_MT_POSITION_Y), 30);
@ -711,8 +711,8 @@ START_TEST(test_device_kernel_change_axis)
rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev);
ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));;
ck_assert_int_eq(libevdev_get_abs_min(dev, ABS_X), 0);
ck_assert_int_eq(libevdev_get_abs_max(dev, ABS_X), 1000);
ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X), 0);
ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X), 1000);
ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X), 1);
ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X), 2);
ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X), 3);
@ -725,8 +725,8 @@ START_TEST(test_device_kernel_change_axis)
rc = libevdev_kernel_set_abs_value(dev, ABS_X, &abs);
ck_assert_int_eq(rc, 0);
ck_assert_int_eq(libevdev_get_abs_min(dev, ABS_X), 500);
ck_assert_int_eq(libevdev_get_abs_max(dev, ABS_X), 5000);
ck_assert_int_eq(libevdev_get_abs_minimum(dev, ABS_X), 500);
ck_assert_int_eq(libevdev_get_abs_maximum(dev, ABS_X), 5000);
ck_assert_int_eq(libevdev_get_abs_fuzz(dev, ABS_X), 10);
ck_assert_int_eq(libevdev_get_abs_flat(dev, ABS_X), 20);
ck_assert_int_eq(libevdev_get_abs_resolution(dev, ABS_X), 30);
@ -734,8 +734,8 @@ START_TEST(test_device_kernel_change_axis)
/* make sure kernel device is changed */
rc = libevdev_new_from_fd(uinput_device_get_fd(uidev), &dev2);
ck_assert_msg(rc == 0, "Failed to init device: %s", strerror(-rc));
ck_assert_int_eq(libevdev_get_abs_min(dev2, ABS_X), 500);
ck_assert_int_eq(libevdev_get_abs_max(dev2, ABS_X), 5000);
ck_assert_int_eq(libevdev_get_abs_minimum(dev2, ABS_X), 500);
ck_assert_int_eq(libevdev_get_abs_maximum(dev2, ABS_X), 5000);
ck_assert_int_eq(libevdev_get_abs_fuzz(dev2, ABS_X), 10);
ck_assert_int_eq(libevdev_get_abs_flat(dev2, ABS_X), 20);
ck_assert_int_eq(libevdev_get_abs_resolution(dev2, ABS_X), 30);

2
tools/libevdev-events.c
View file

@ -103,7 +103,7 @@ print_props(struct libevdev *dev)
for (i = 0; i <= INPUT_PROP_MAX; i++) {
if (libevdev_has_property(dev, i))
printf(" Property type %d (%s)\n", i,
libevdev_get_input_prop_name(i));
libevdev_get_property_name(i));
}
}