Rename a few getters for consistency

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>

diff --git a/libevdev/libevdev.c b/libevdev/libevdev.c
index 386d06288cb2d22d0a14c6e8d16124007da2b926..cdf338b06cc9f1c70fcdd703f494722efacc92f5 100644 (file)
--- a/libevdev/libevdev.c
+++ b/libevdev/libevdev.c
@@ -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;

diff --git a/libevdev/libevdev.h b/libevdev/libevdev.h
index 208a1a24e9ec4da4b75a30a506d4a15733af633e..c8159ca17def60231d2a8e8c975364618b5ccab9 100644 (file)
--- a/libevdev/libevdev.h
+++ b/libevdev/libevdev.h
@@ -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 */

diff --git a/test/test-event-names.c b/test/test-event-names.c
index 2701de5fe981dbaacd587500de83bf661687b5e4..74d033548345ae3cec1c161ac17193833a7d002b 100644 (file)
--- a/test/test-event-names.c
+++ b/test/test-event-names.c
@@ -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(libevdev_get_input_prop_name(INPUT_PROP_MAX - 1) == NULL);
-       ck_assert(libevdev_get_input_prop_name(INPUT_PROP_MAX + 1) == NULL);
+       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_property_name(INPUT_PROP_MAX - 1) == NULL);
+       ck_assert(libevdev_get_property_name(INPUT_PROP_MAX + 1) == NULL);
 }
 END_TEST
 

diff --git a/test/test-libevdev-has-event.c b/test/test-libevdev-has-event.c
index f6db68eb8da832b76997e2400786e5d49ef205df..1d2266cf084065c3894b6c6beedd98d33630cff2 100644 (file)
--- a/test/test-libevdev-has-event.c
+++ b/test/test-libevdev-has-event.c
@@ -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);

diff --git a/tools/libevdev-events.c b/tools/libevdev-events.c
index ee64cea061c972cbdd012bae23f61aa0ee94485d..9b2e1a763c0767c2813f89b8675ae0e8ad4515b7 100644 (file)
--- a/tools/libevdev-events.c
+++ b/tools/libevdev-events.c
@@ -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));
        }
 }