X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Flibinput.c;h=5780a92d7aca126cf3df182c11550a6a21b09e01;hb=HEAD;hp=f384f4396b9bd98933b7948f0fa945e6118299d5;hpb=21cf84a5801dc63932857574b81e5e79db10aed1;p=platform%2Fupstream%2Flibinput.git diff --git a/src/libinput.c b/src/libinput.c index f384f43..5780a92 100644 --- a/src/libinput.c +++ b/src/libinput.c @@ -56,7 +56,7 @@ struct libinput_event_keyboard { uint32_t time; uint32_t key; uint32_t seat_key_count; - enum libinput_keyboard_key_state state; + enum libinput_key_state state; }; struct libinput_event_pointer { @@ -81,8 +81,8 @@ struct libinput_event_touch { }; static void -libinput_default_log_func(enum libinput_log_priority priority, - void *data, +libinput_default_log_func(struct libinput *libinput, + enum libinput_log_priority priority, const char *format, va_list args) { const char *prefix; @@ -98,55 +98,47 @@ libinput_default_log_func(enum libinput_log_priority priority, vfprintf(stderr, format, args); } -struct log_data { - enum libinput_log_priority priority; - libinput_log_handler handler; - void *user_data; -}; - -static struct log_data log_data = { - .priority = LIBINPUT_LOG_PRIORITY_ERROR, - .handler = libinput_default_log_func, - .user_data = NULL, -}; - void -log_msg_va(enum libinput_log_priority priority, +log_msg_va(struct libinput *libinput, + enum libinput_log_priority priority, const char *format, va_list args) { - if (log_data.handler && log_data.priority <= priority) - log_data.handler(priority, log_data.user_data, format, args); + if (libinput->log_handler && + libinput->log_priority <= priority) + libinput->log_handler(libinput, priority, format, args); } void -log_msg(enum libinput_log_priority priority, const char *format, ...) +log_msg(struct libinput *libinput, + enum libinput_log_priority priority, + const char *format, ...) { va_list args; va_start(args, format); - log_msg_va(priority, format, args); + log_msg_va(libinput, priority, format, args); va_end(args); } LIBINPUT_EXPORT void -libinput_log_set_priority(enum libinput_log_priority priority) +libinput_log_set_priority(struct libinput *libinput, + enum libinput_log_priority priority) { - log_data.priority = priority; + libinput->log_priority = priority; } LIBINPUT_EXPORT enum libinput_log_priority -libinput_log_get_priority(void) +libinput_log_get_priority(const struct libinput *libinput) { - return log_data.priority; + return libinput->log_priority; } LIBINPUT_EXPORT void -libinput_log_set_handler(libinput_log_handler log_handler, - void *user_data) +libinput_log_set_handler(struct libinput *libinput, + libinput_log_handler log_handler) { - log_data.handler = log_handler; - log_data.user_data = user_data; + libinput->log_handler = log_handler; } static void @@ -285,7 +277,7 @@ libinput_event_keyboard_get_key(struct libinput_event_keyboard *event) return event->key; } -LIBINPUT_EXPORT enum libinput_keyboard_key_state +LIBINPUT_EXPORT enum libinput_key_state libinput_event_keyboard_get_key_state(struct libinput_event_keyboard *event) { return event->state; @@ -465,7 +457,6 @@ libinput_add_fd(struct libinput *libinput, ep.data.ptr = source; if (epoll_ctl(libinput->epoll_fd, EPOLL_CTL_ADD, fd, &ep) < 0) { - close(source->fd); free(source); return NULL; } @@ -499,9 +490,12 @@ libinput_init(struct libinput *libinput, return -1; } + libinput->log_handler = libinput_default_log_func; + libinput->log_priority = LIBINPUT_LOG_PRIORITY_ERROR; libinput->interface = interface; libinput->interface_backend = interface_backend; libinput->user_data = user_data; + libinput->refcount = 1; list_init(&libinput->source_destroy_list); list_init(&libinput->seat_list); @@ -530,15 +524,27 @@ libinput_drop_destroyed_sources(struct libinput *libinput) list_init(&libinput->source_destroy_list); } -LIBINPUT_EXPORT void -libinput_destroy(struct libinput *libinput) +LIBINPUT_EXPORT struct libinput * +libinput_ref(struct libinput *libinput) +{ + libinput->refcount++; + return libinput; +} + +LIBINPUT_EXPORT struct libinput * +libinput_unref(struct libinput *libinput) { struct libinput_event *event; struct libinput_device *device, *next_device; struct libinput_seat *seat, *next_seat; if (libinput == NULL) - return; + return NULL; + + assert(libinput->refcount > 0); + libinput->refcount--; + if (libinput->refcount > 0) + return libinput; libinput_suspend(libinput); @@ -562,6 +568,8 @@ libinput_destroy(struct libinput *libinput) libinput_drop_destroyed_sources(libinput); close(libinput->epoll_fd); free(libinput); + + return NULL; } LIBINPUT_EXPORT void @@ -607,10 +615,11 @@ libinput_seat_init(struct libinput_seat *seat, list_insert(&libinput->seat_list, &seat->link); } -LIBINPUT_EXPORT void +LIBINPUT_EXPORT struct libinput_seat * libinput_seat_ref(struct libinput_seat *seat) { seat->refcount++; + return seat; } static void @@ -622,13 +631,17 @@ libinput_seat_destroy(struct libinput_seat *seat) seat->destroy(seat); } -LIBINPUT_EXPORT void +LIBINPUT_EXPORT struct libinput_seat * libinput_seat_unref(struct libinput_seat *seat) { assert(seat->refcount > 0); seat->refcount--; - if (seat->refcount == 0) + if (seat->refcount == 0) { libinput_seat_destroy(seat); + return NULL; + } else { + return seat; + } } LIBINPUT_EXPORT void @@ -663,10 +676,11 @@ libinput_device_init(struct libinput_device *device, device->refcount = 1; } -LIBINPUT_EXPORT void +LIBINPUT_EXPORT struct libinput_device * libinput_device_ref(struct libinput_device *device) { device->refcount++; + return device; } static void @@ -675,13 +689,17 @@ libinput_device_destroy(struct libinput_device *device) evdev_device_destroy((struct evdev_device *) device); } -LIBINPUT_EXPORT void +LIBINPUT_EXPORT struct libinput_device * libinput_device_unref(struct libinput_device *device) { assert(device->refcount > 0); device->refcount--; - if (device->refcount == 0) + if (device->refcount == 0) { libinput_device_destroy(device); + return NULL; + } else { + return device; + } } LIBINPUT_EXPORT int @@ -717,14 +735,14 @@ libinput_dispatch(struct libinput *libinput) static uint32_t update_seat_key_count(struct libinput_seat *seat, int32_t key, - enum libinput_keyboard_key_state state) + enum libinput_key_state state) { assert(key >= 0 && key <= KEY_MAX); switch (state) { - case LIBINPUT_KEYBOARD_KEY_STATE_PRESSED: + case LIBINPUT_KEY_STATE_PRESSED: return ++seat->button_count[key]; - case LIBINPUT_KEYBOARD_KEY_STATE_RELEASED: + case LIBINPUT_KEY_STATE_RELEASED: /* We might not have received the first PRESSED event. */ if (seat->button_count[key] == 0) return 0; @@ -816,7 +834,7 @@ void keyboard_notify_key(struct libinput_device *device, uint32_t time, uint32_t key, - enum libinput_keyboard_key_state state) + enum libinput_key_state state) { struct libinput_event_keyboard *key_event; uint32_t seat_key_count; @@ -1033,7 +1051,6 @@ touch_notify_frame(struct libinput_device *device, &touch_event->base); } - static void libinput_post_event(struct libinput *libinput, struct libinput_event *event) @@ -1143,6 +1160,24 @@ libinput_device_get_sysname(struct libinput_device *device) } LIBINPUT_EXPORT const char * +libinput_device_get_name(struct libinput_device *device) +{ + return evdev_device_get_name((struct evdev_device *) device); +} + +LIBINPUT_EXPORT unsigned int +libinput_device_get_id_product(struct libinput_device *device) +{ + return evdev_device_get_id_product((struct evdev_device *) device); +} + +LIBINPUT_EXPORT unsigned int +libinput_device_get_id_vendor(struct libinput_device *device) +{ + return evdev_device_get_id_vendor((struct evdev_device *) device); +} + +LIBINPUT_EXPORT const char * libinput_device_get_output_name(struct libinput_device *device) { return evdev_device_get_output((struct evdev_device *) device); @@ -1185,6 +1220,16 @@ libinput_device_has_capability(struct libinput_device *device, capability); } +LIBINPUT_EXPORT int +libinput_device_get_size(struct libinput_device *device, + double *width, + double *height) +{ + return evdev_device_get_size((struct evdev_device *)device, + width, + height); +} + LIBINPUT_EXPORT struct libinput_event * libinput_event_device_notify_get_base_event(struct libinput_event_device_notify *event) { @@ -1208,3 +1253,251 @@ libinput_event_touch_get_base_event(struct libinput_event_touch *event) { return &event->base; } + +LIBINPUT_EXPORT const char * +libinput_config_status_to_str(enum libinput_config_status status) +{ + const char *str = NULL; + + switch(status) { + case LIBINPUT_CONFIG_STATUS_SUCCESS: + str = "Success"; + break; + case LIBINPUT_CONFIG_STATUS_UNSUPPORTED: + str = "Unsupported configuration option"; + break; + case LIBINPUT_CONFIG_STATUS_INVALID: + str = "Invalid argument range"; + break; + } + + return str; +} + +LIBINPUT_EXPORT int +libinput_device_config_tap_get_finger_count(struct libinput_device *device) +{ + return device->config.tap ? device->config.tap->count(device) : 0; +} + +LIBINPUT_EXPORT enum libinput_config_status +libinput_device_config_tap_set_enabled(struct libinput_device *device, + enum libinput_config_tap_state enable) +{ + if (enable != LIBINPUT_CONFIG_TAP_ENABLED && + enable != LIBINPUT_CONFIG_TAP_DISABLED) + return LIBINPUT_CONFIG_STATUS_INVALID; + + if (enable && + libinput_device_config_tap_get_finger_count(device) == 0) + return LIBINPUT_CONFIG_STATUS_UNSUPPORTED; + + return device->config.tap->set_enabled(device, enable); +} + +LIBINPUT_EXPORT enum libinput_config_tap_state +libinput_device_config_tap_get_enabled(struct libinput_device *device) +{ + if (libinput_device_config_tap_get_finger_count(device) == 0) + return LIBINPUT_CONFIG_TAP_DISABLED; + + return device->config.tap->get_enabled(device); +} + +LIBINPUT_EXPORT enum libinput_config_tap_state +libinput_device_config_tap_get_default_enabled(struct libinput_device *device) +{ + if (libinput_device_config_tap_get_finger_count(device) == 0) + return LIBINPUT_CONFIG_TAP_DISABLED; + + return device->config.tap->get_default(device); +} + +LIBINPUT_EXPORT int +libinput_device_config_calibration_has_matrix(struct libinput_device *device) +{ + return device->config.calibration ? + device->config.calibration->has_matrix(device) : 0; +} + +LIBINPUT_EXPORT enum libinput_config_status +libinput_device_config_calibration_set_matrix(struct libinput_device *device, + const float matrix[6]) +{ + if (!libinput_device_config_calibration_has_matrix(device)) + return LIBINPUT_CONFIG_STATUS_UNSUPPORTED; + + return device->config.calibration->set_matrix(device, matrix); +} + +LIBINPUT_EXPORT int +libinput_device_config_calibration_get_matrix(struct libinput_device *device, + float matrix[6]) +{ + if (!libinput_device_config_calibration_has_matrix(device)) + return 0; + + return device->config.calibration->get_matrix(device, matrix); +} + +LIBINPUT_EXPORT int +libinput_device_config_calibration_get_default_matrix(struct libinput_device *device, + float matrix[6]) +{ + if (!libinput_device_config_calibration_has_matrix(device)) + return 0; + + return device->config.calibration->get_default_matrix(device, matrix); +} + +LIBINPUT_EXPORT uint32_t +libinput_device_config_send_events_get_modes(struct libinput_device *device) +{ + uint32_t modes = LIBINPUT_CONFIG_SEND_EVENTS_ENABLED; + + if (device->config.sendevents) + modes |= device->config.sendevents->get_modes(device); + + return modes; +} + +LIBINPUT_EXPORT enum libinput_config_status +libinput_device_config_send_events_set_mode(struct libinput_device *device, + enum libinput_config_send_events_mode mode) +{ + if ((libinput_device_config_send_events_get_modes(device) & mode) == 0) + return LIBINPUT_CONFIG_STATUS_UNSUPPORTED; + + if (device->config.sendevents) + return device->config.sendevents->set_mode(device, mode); + else /* mode must be _ENABLED to get here */ + return LIBINPUT_CONFIG_STATUS_SUCCESS; +} + +LIBINPUT_EXPORT enum libinput_config_send_events_mode +libinput_device_config_send_events_get_mode(struct libinput_device *device) +{ + if (device->config.sendevents) + return device->config.sendevents->get_mode(device); + else + return LIBINPUT_CONFIG_SEND_EVENTS_ENABLED; +} + +LIBINPUT_EXPORT enum libinput_config_send_events_mode +libinput_device_config_send_events_get_default_mode(struct libinput_device *device) +{ + return LIBINPUT_CONFIG_SEND_EVENTS_ENABLED; +} + + +LIBINPUT_EXPORT int +libinput_device_config_accel_is_available(struct libinput_device *device) +{ + return device->config.accel ? + device->config.accel->available(device) : 0; +} + +LIBINPUT_EXPORT enum libinput_config_status +libinput_device_config_accel_set_speed(struct libinput_device *device, + double speed) +{ + if (!libinput_device_config_accel_is_available(device)) + return LIBINPUT_CONFIG_STATUS_UNSUPPORTED; + + if (speed < -1.0 || speed > 1.0) + return LIBINPUT_CONFIG_STATUS_INVALID; + + return device->config.accel->set_speed(device, speed); +} + +LIBINPUT_EXPORT double +libinput_device_config_accel_get_speed(struct libinput_device *device) +{ + if (!libinput_device_config_accel_is_available(device)) + return 0; + + return device->config.accel->get_speed(device); +} + +LIBINPUT_EXPORT double +libinput_device_config_accel_get_default_speed(struct libinput_device *device) +{ + if (!libinput_device_config_accel_is_available(device)) + return 0; + + return device->config.accel->get_default_speed(device); +} + +LIBINPUT_EXPORT int +libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device) +{ + if (!device->config.natural_scroll) + return 0; + + return device->config.natural_scroll->has(device); +} + +LIBINPUT_EXPORT enum libinput_config_status +libinput_device_config_scroll_set_natural_scroll_enabled(struct libinput_device *device, + int enabled) +{ + if (!libinput_device_config_scroll_has_natural_scroll(device)) + return LIBINPUT_CONFIG_STATUS_UNSUPPORTED; + + return device->config.natural_scroll->set_enabled(device, enabled); +} + +LIBINPUT_EXPORT int +libinput_device_config_scroll_get_natural_scroll_enabled(struct libinput_device *device) +{ + if (!device->config.natural_scroll) + return 0; + + return device->config.natural_scroll->get_enabled(device); +} + +LIBINPUT_EXPORT int +libinput_device_config_scroll_get_default_natural_scroll_enabled(struct libinput_device *device) +{ + if (!device->config.natural_scroll) + return 0; + + return device->config.natural_scroll->get_default_enabled(device); +} + +LIBINPUT_EXPORT int +libinput_device_config_buttons_has_left_handed(struct libinput_device *device) +{ + if (!device->config.left_handed) + return 0; + + return device->config.left_handed->has(device); +} + +LIBINPUT_EXPORT enum libinput_config_status +libinput_device_config_buttons_set_left_handed(struct libinput_device *device, + int left_handed) +{ + if (!libinput_device_config_buttons_has_left_handed(device)) + return LIBINPUT_CONFIG_STATUS_UNSUPPORTED; + + return device->config.left_handed->set(device, left_handed); +} + +LIBINPUT_EXPORT int +libinput_device_config_buttons_get_left_handed(struct libinput_device *device) +{ + if (!libinput_device_config_buttons_has_left_handed(device)) + return 0; + + return device->config.left_handed->get(device); +} + +LIBINPUT_EXPORT int +libinput_device_config_buttons_get_default_left_handed(struct libinput_device *device) +{ + if (!libinput_device_config_buttons_has_left_handed(device)) + return 0; + + return device->config.left_handed->get_default(device); +}