From: Junghoon Date: Mon, 27 Jul 2015 07:44:01 +0000 (+0900) Subject: pepper: libinput: wayland: x11: input refactoring X-Git-Tag: accepted/tizen/mobile/20151221.050925~34^2~258 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c8c7558f3bea9660ff8723cebaafabd4a03f5090;p=platform%2Fcore%2Fuifw%2Fpepper.git pepper: libinput: wayland: x11: input refactoring - remove input backend interface - add input device managing code Change-Id: I4df5d300439a4fff108198e6208c193253a36521 --- diff --git a/src/lib/libinput/libinput-internal.h b/src/lib/libinput/libinput-internal.h index e8e6779..240f064 100644 --- a/src/lib/libinput/libinput-internal.h +++ b/src/lib/libinput/libinput-internal.h @@ -7,7 +7,8 @@ /* TODO: Error logging. */ #define PEPPER_ERROR(...) -typedef struct li_seat li_seat_t; +typedef struct li_device li_device_t; +typedef struct li_device_property li_device_property_t; struct pepper_libinput { @@ -17,26 +18,27 @@ struct pepper_libinput struct wl_event_source *libinput_event_source; int libinput_fd; - struct wl_list seat_list; + struct wl_list device_list; }; -struct li_seat +struct li_device { - pepper_seat_t *base; pepper_libinput_t *input; + pepper_pointer_device_t *pointer; + pepper_keyboard_device_t *keyboard; + pepper_touch_device_t *touch; - uint32_t id; uint32_t caps; - char *name; - int pointer_x_last; - int pointer_y_last; - int touch_x_last; /* FIXME */ - int touch_y_last; /* FIXME */ + struct wl_list property_list; + struct wl_list link; +}; +struct li_device_property /* FIXME */ +{ + char *key; + char *data; struct wl_list link; - struct wl_signal capabilities_signal; - struct wl_signal name_signal; }; #endif /* LIBINPUT_INTERNAL_H */ diff --git a/src/lib/libinput/libinput.c b/src/lib/libinput/libinput.c index d550814..0e8c3a5 100644 --- a/src/lib/libinput/libinput.c +++ b/src/lib/libinput/libinput.c @@ -8,89 +8,6 @@ #include "libinput-internal.h" -static void -li_seat_destroy(void *data) -{ - li_seat_t *seat = (li_seat_t *)data; - - wl_list_remove(&seat->link); - - if (seat->name) - free(seat->name); - - free(seat); -} - -static void -li_seat_add_capabilities_listener(void *data, struct wl_listener *listener) -{ - li_seat_t *seat = (li_seat_t *)data; - wl_signal_add(&seat->capabilities_signal, listener); -} - -static void -li_seat_add_name_listener(void *data, struct wl_listener *listener) -{ - li_seat_t *seat = (li_seat_t *)data; - wl_signal_add(&seat->name_signal, listener); -} - -static uint32_t -li_seat_get_capabilities(void *data) -{ - li_seat_t *seat = (li_seat_t *)data; - return seat->caps; -} - -static const char * -li_seat_get_name(void *data) -{ - li_seat_t *seat = (li_seat_t *)data; - return seat->name; -} - -static const pepper_seat_backend_t li_seat_backend = -{ - li_seat_destroy, - li_seat_add_capabilities_listener, - li_seat_add_name_listener, - li_seat_get_capabilities, - li_seat_get_name, -}; - -static li_seat_t * -li_seat_create(pepper_libinput_t *input) -{ - li_seat_t *seat; - - seat = (li_seat_t *)calloc(1, sizeof(li_seat_t)); - if (!seat) - { - PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__); - return NULL; - } - - wl_signal_init(&seat->capabilities_signal); - wl_signal_init(&seat->name_signal); - - seat->input = input; - seat->base = pepper_compositor_add_seat(input->compositor, - &li_seat_backend, seat); - if (!seat->base) - { - PEPPER_ERROR("Failed to create pepper_seat in %s\n", __FUNCTION__); - goto error; - } - - return seat; - -error: - if (seat) - free(seat); - - return NULL; -} - static int libinput_open_restricted(const char *path, int flags, void *user_data) { @@ -144,281 +61,250 @@ get_capabilities(struct libinput_device *device) } static void +libinput_device_get_properties(struct libinput_device *libinput_device, + struct wl_list *property_list) +{ + /* get properties */ + struct udev_device *udev_device = libinput_device_get_udev_device(libinput_device); + struct udev_list_entry *e; + + e = udev_device_get_properties_list_entry(udev_device); + while (e) + { + li_device_property_t *property; + const char *name = udev_list_entry_get_name(e); + const char *value = udev_list_entry_get_value(e); + + property = (li_device_property_t *)calloc(1, sizeof(li_device_property_t)); + if (!property) + continue; + + property->key = strdup(name); + property->data = strdup(value); + + wl_list_insert(property_list, &property->link); + + e = udev_list_entry_get_next(e); + } +} + +static void device_added(pepper_libinput_t *input, struct libinput_device *libinput_device) { - struct libinput_seat *libinput_seat; - const char *seat_name; - li_seat_t *tmp, *seat = NULL; - uint32_t caps; + struct wl_list property_list; + uint32_t caps; + li_device_t *device; - libinput_seat = libinput_device_get_seat(libinput_device); - seat_name = libinput_seat_get_logical_name(libinput_seat); + caps = get_capabilities(libinput_device); + device = (li_device_t *)calloc(1, sizeof(li_device_t)); + if (!device) + { + PEPPER_ERROR("Failed to allocate memory\n"); + /* TODO: error handling */ + return; + } + + device->input = input; + device->caps = caps; - wl_list_for_each(tmp, &input->seat_list, link) + + if (caps & WL_SEAT_CAPABILITY_POINTER) { - if (strcmp(tmp->name, seat_name) == 0) + pepper_pointer_device_t *pointer_device; + + pointer_device = pepper_pointer_device_create(input->compositor); + if (!pointer_device) { - seat = tmp; - break; + PEPPER_ERROR("Failed to create pepper pointer device\n"); + /* TODO: error handling */ + return; } + device->pointer = pointer_device; } - - if (!seat) + else if (caps & WL_SEAT_CAPABILITY_KEYBOARD) { - seat = li_seat_create(input); - if (!seat) + pepper_keyboard_device_t *keyboard_device; + + keyboard_device = pepper_keyboard_device_create(input->compositor); + if (!keyboard_device) { - PEPPER_ERROR("Failed to create libinput_seat in %s\n", __FUNCTION__); + PEPPER_ERROR("Failed to create pepper keyboard device\n"); + /* TODO: error handling */ return; } + device->keyboard = keyboard_device; + } + else if (caps & WL_SEAT_CAPABILITY_TOUCH) + { + pepper_touch_device_t *touch_device; - wl_list_insert(&input->seat_list, &seat->link); + touch_device = pepper_touch_device_create(input->compositor); + if (!touch_device) + { + PEPPER_ERROR("Failed to create pepper touch device\n"); + /* TODO: error handling */ + return; + } + device->touch = touch_device; } - libinput_device_set_user_data(libinput_device, seat); + wl_list_init(&property_list); /* FIXME */ + libinput_device_get_properties(libinput_device, &property_list); /* FIXME */ + wl_list_init(&device->property_list); /* FIXME */ + wl_list_insert_list(&device->property_list, &property_list); /* FIXME */ - /* TODO - * check tab count - * check calibration - */ + wl_list_insert(&input->device_list, &device->link); + libinput_device_set_user_data(libinput_device, device); +} - caps = get_capabilities(libinput_device); - if (seat->caps != caps) - { - seat->caps |= caps; - wl_signal_emit(&seat->capabilities_signal, seat); - } +static void +clear_property_list(struct wl_list *list) +{ + li_device_property_t *property, *tmp; + + if (wl_list_empty(list)) + return; - if (!seat->name) + wl_list_for_each_safe(property, tmp, list, link) { - seat->name = strdup(seat_name); - wl_signal_emit(&seat->name_signal, seat); + wl_list_remove(&property->link); + + if (property->key) + free(property->key); + if (property->data) + free(property->data); + + free(property); } } static void -device_removed(pepper_libinput_t *input, struct libinput_device *libinput_device) +li_device_destroy(li_device_t *device) { - li_seat_t *seat; - uint32_t caps; + wl_list_remove(&device->link); + clear_property_list(&device->property_list); - seat = (li_seat_t *)libinput_device_get_user_data(libinput_device); - caps = get_capabilities(libinput_device); + if (device->pointer) + pepper_pointer_device_destroy(device->pointer); - if (seat->caps != caps) - { - seat->caps = caps; - wl_signal_emit(&seat->capabilities_signal, seat); - } + if (device->keyboard) + pepper_keyboard_device_destroy(device->keyboard); + + if (device->touch) + pepper_touch_device_destroy(device->touch); + + free(device); +} + +static void +device_removed(pepper_libinput_t *input, struct libinput_device *libinput_device) +{ + li_device_t *device; + device = (li_device_t *)libinput_device_get_user_data(libinput_device); + li_device_destroy(device); } static void pointer_motion(struct libinput_device *libinput_device, struct libinput_event_pointer *pointer_event) { - li_seat_t *seat; - pepper_input_event_t event; - - seat = (li_seat_t *)libinput_device_get_user_data(libinput_device); - - event.type = PEPPER_INPUT_EVENT_POINTER_MOTION; - event.time = libinput_event_pointer_get_time(pointer_event); - event.serial = 0; - event.index = 0; - event.state = 0; - event.value = 0; - event.x = seat->pointer_x_last = wl_fixed_from_double( - libinput_event_pointer_get_dx(pointer_event)); - event.y = seat->pointer_y_last = wl_fixed_from_double( - libinput_event_pointer_get_dy(pointer_event)); - - pepper_seat_handle_event(seat->base, &event); + li_device_t *device; + wl_fixed_t dx, dy; + + device = (li_device_t *)libinput_device_get_user_data(libinput_device); + + dx = wl_fixed_from_double(libinput_event_pointer_get_dx(pointer_event)); + dy = wl_fixed_from_double(libinput_event_pointer_get_dy(pointer_event)); + + /* TODO */ } static void pointer_motion_absolute(struct libinput_device *libinput_device, struct libinput_event_pointer *pointer_event) { - li_seat_t *seat; - pepper_input_event_t event; - - seat = (li_seat_t *)libinput_device_get_user_data(libinput_device); - + li_device_t *device; + device = (li_device_t *)libinput_device_get_user_data(libinput_device); /* TODO */ - - pepper_seat_handle_event(seat->base, &event); } static void pointer_button(struct libinput_device *libinput_device, struct libinput_event_pointer *pointer_event) { - li_seat_t *seat; - pepper_input_event_t event; - - seat = (li_seat_t *)libinput_device_get_user_data(libinput_device); - - event.type = PEPPER_INPUT_EVENT_POINTER_BUTTON; - event.time = libinput_event_pointer_get_time(pointer_event); - event.serial = 0; - event.index = libinput_event_pointer_get_button(pointer_event); - event.state = libinput_event_pointer_get_button_state(pointer_event); - event.value = 0; - event.x = seat->pointer_x_last; - event.y = seat->pointer_y_last; - - pepper_seat_handle_event(seat->base, &event); + li_device_t *device; + device = (li_device_t *)libinput_device_get_user_data(libinput_device); + /* TODO */ } static void pointer_axis(struct libinput_device *libinput_device, struct libinput_event_pointer *pointer_event) { - li_seat_t *seat; - pepper_input_event_t event; - - seat = (li_seat_t *)libinput_device_get_user_data(libinput_device); - - event.type = PEPPER_INPUT_EVENT_POINTER_AXIS; - event.time = libinput_event_pointer_get_time(pointer_event); - event.serial = 0; + int axis = -1; + wl_fixed_t value; + li_device_t *device; + device = (li_device_t *)libinput_device_get_user_data(libinput_device); if (libinput_event_pointer_has_axis(pointer_event, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL) != 0) - { - event.index = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL; - } + axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL; /* FIXME */ else if (libinput_event_pointer_has_axis(pointer_event, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL) != 0) - { - event.index = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL; - } + axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL; /* FIXME */ - event.state = 0; - event.value = wl_fixed_from_double(libinput_event_pointer_get_axis_value(pointer_event, - event.index)); - event.x = seat->pointer_x_last; - event.y = seat->pointer_y_last; + if (axis < 0) + return; - /* TODO: check axis_source */ + value = wl_fixed_from_double(libinput_event_pointer_get_axis_value(pointer_event, axis)); - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static void keyboard_key(struct libinput_device *libinput_device, struct libinput_event_keyboard *keyboard_event) { - li_seat_t *seat; - pepper_input_event_t event; + li_device_t *device; + device = (li_device_t *)libinput_device_get_user_data(libinput_device); - seat = (li_seat_t *)libinput_device_get_user_data(libinput_device); - - event.type = PEPPER_INPUT_EVENT_KEYBOARD_KEY; - event.time = libinput_event_keyboard_get_time(keyboard_event); - event.serial = 0; - event.index = libinput_event_keyboard_get_key(keyboard_event); - event.state = libinput_event_keyboard_get_key_state(keyboard_event); - event.value = 0; - event.x = 0; - event.y = 0; - - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static void touch_down(struct libinput_device *libinput_device, struct libinput_event_touch *touch_event) { - li_seat_t *seat; - pepper_input_event_t event; - uint32_t width, height; - - seat = (li_seat_t *)libinput_device_get_user_data(libinput_device); - - event.type = PEPPER_INPUT_EVENT_TOUCH_DOWN; - event.time = libinput_event_touch_get_time(touch_event); - event.serial = 0; - event.index = libinput_event_touch_get_seat_slot(touch_event); /* XXX */ - event.value = 0; - event.state = 0; - - width = 1280; /* FIXME: get width from output */ - event.x = wl_fixed_from_double( - libinput_event_touch_get_x_transformed(touch_event, width)); - seat->touch_x_last = event.x; - - height = 720; /* FIXME: get height from output */ - event.y = wl_fixed_from_double( - libinput_event_touch_get_y_transformed(touch_event, height)); - seat->touch_y_last = event.y; - - pepper_seat_handle_event(seat->base, &event); + li_device_t *device; + device = (li_device_t *)libinput_device_get_user_data(libinput_device); + /* TODO */ } static void touch_up(struct libinput_device *libinput_device, struct libinput_event_touch *touch_event) { - li_seat_t *seat; - pepper_input_event_t event; - - seat = (li_seat_t *)libinput_device_get_user_data(libinput_device); - - event.type = PEPPER_INPUT_EVENT_TOUCH_UP; - event.time = libinput_event_touch_get_time(touch_event); - event.serial = 0; - event.index = libinput_event_touch_get_seat_slot(touch_event); /* XXX */ - event.value = 0; - event.state = 0; - event.x = seat->touch_x_last; - event.y = seat->touch_y_last; - - pepper_seat_handle_event(seat->base, &event); + li_device_t *device; + device = (li_device_t *)libinput_device_get_user_data(libinput_device); + /* TODO */ } static void touch_motion(struct libinput_device *libinput_device, struct libinput_event_touch *touch_event) { - li_seat_t *seat; - pepper_input_event_t event; - uint32_t width, height; - - seat = (li_seat_t *)libinput_device_get_user_data(libinput_device); - - - event.type = PEPPER_INPUT_EVENT_TOUCH_MOTION; - event.time = libinput_event_touch_get_time(touch_event); - event.serial = 0; - event.index = libinput_event_touch_get_seat_slot(touch_event); /* XXX */ - event.value = 0; - event.state = 0; - - width = 1280; /* FIXME: get width from output */ - event.x = wl_fixed_from_double( - libinput_event_touch_get_x_transformed(touch_event, width)); - seat->touch_x_last = event.x; - - height = 720; /* FIXME: get height from output */ - event.y = wl_fixed_from_double( - libinput_event_touch_get_y_transformed(touch_event, height)); - seat->touch_y_last = event.y; - - pepper_seat_handle_event(seat->base, &event); + li_device_t *device; + device = (li_device_t *)libinput_device_get_user_data(libinput_device); + /* TODO */ } static void touch_frame(struct libinput_device *libinput_device, struct libinput_event_touch *touch_event) { - li_seat_t *seat; - pepper_input_event_t event; - - seat = (li_seat_t *)libinput_device_get_user_data(libinput_device); - - event.type = PEPPER_INPUT_EVENT_TOUCH_FRAME; - pepper_seat_handle_event(seat->base, &event); + li_device_t *device; + device = (li_device_t *)libinput_device_get_user_data(libinput_device); + /* TODO */ } static void @@ -513,8 +399,7 @@ pepper_libinput_create(pepper_compositor_t *compositor, struct udev *udev) input->compositor = compositor; input->udev = udev; - - wl_list_init(&input->seat_list); + wl_list_init(&input->device_list); input->libinput = libinput_udev_create_context(&libinput_interface, input, input->udev); if (!input->libinput) @@ -557,10 +442,10 @@ error: PEPPER_API void pepper_libinput_destroy(pepper_libinput_t *input) { - li_seat_t *seat, *tmp; + li_device_t *device, *tmp; - wl_list_for_each_safe(seat, tmp, &input->seat_list, link) - li_seat_destroy(seat); + wl_list_for_each_safe(device, tmp, &input->device_list, link) + li_device_destroy(device); if (input->libinput) libinput_unref(input->libinput); diff --git a/src/lib/pepper/input.c b/src/lib/pepper/input.c index 6daec92..5374930 100644 --- a/src/lib/pepper/input.c +++ b/src/lib/pepper/input.c @@ -31,8 +31,8 @@ static const struct wl_pointer_interface pointer_interface = static void seat_get_pointer(struct wl_client *client, struct wl_resource *resource, uint32_t id) { - pepper_seat_t *seat = (pepper_seat_t *)wl_resource_get_user_data(resource); - struct wl_resource *r; + pepper_seat_t *seat = (pepper_seat_t *)wl_resource_get_user_data(resource); + struct wl_resource *r; if (!seat->pointer) return; @@ -66,8 +66,8 @@ static const struct wl_keyboard_interface keyboard_interface = static void seat_get_keyboard(struct wl_client *client, struct wl_resource *resource, uint32_t id) { - pepper_seat_t *seat = (pepper_seat_t *)wl_resource_get_user_data(resource); - struct wl_resource *r; + pepper_seat_t *seat = (pepper_seat_t *)wl_resource_get_user_data(resource); + struct wl_resource *r; if (!seat->keyboard) return; @@ -81,7 +81,7 @@ seat_get_keyboard(struct wl_client *client, struct wl_resource *resource, uint32 } wl_list_insert(&seat->keyboard->resources, wl_resource_get_link(r)); - wl_resource_set_implementation(r, &keyboard_interface, seat, unbind_resource); + wl_resource_set_implementation(r, &keyboard_interface, seat->keyboard, unbind_resource); /* TODO */ @@ -101,8 +101,8 @@ static const struct wl_touch_interface touch_interface = static void seat_get_touch(struct wl_client *client, struct wl_resource *resource, uint32_t id) { - pepper_seat_t *seat = (pepper_seat_t *)wl_resource_get_user_data(resource); - struct wl_resource *r; + pepper_seat_t *seat = (pepper_seat_t *)wl_resource_get_user_data(resource); + struct wl_resource *r; if (!seat->touch) return; @@ -115,7 +115,7 @@ seat_get_touch(struct wl_client *client, struct wl_resource *resource, uint32_t } wl_list_insert(&seat->touch->resources, wl_resource_get_link(r)); - wl_resource_set_implementation(r, &touch_interface, seat, unbind_resource); + wl_resource_set_implementation(r, &touch_interface, seat->touch, unbind_resource); /* TODO */ @@ -138,209 +138,135 @@ bind_seat(struct wl_client *client, void *data, uint32_t version, uint32_t id) wl_resource_set_implementation(resource, &seat_interface, data, unbind_resource); wl_seat_send_capabilities(resource, seat->caps); + + if ((seat->name) && (version >= WL_SEAT_NAME_SINCE_VERSION)) + wl_seat_send_name(resource, seat->name); } -static pepper_pointer_t * -pointer_create(pepper_seat_t *seat) +PEPPER_API pepper_seat_t * +pepper_compositor_add_seat(pepper_compositor_t *compositor, + const char *seat_name, + void *data) { - pepper_pointer_t *pointer; + pepper_seat_t *seat; - pointer = (pepper_pointer_t *)pepper_object_alloc(PEPPER_OBJECT_POINTER, - sizeof(pepper_pointer_t)); - if (!pointer) + seat = (pepper_seat_t *)pepper_object_alloc(PEPPER_OBJECT_SEAT, sizeof(pepper_seat_t)); + if (!seat) { PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__); return NULL; } - pointer->seat = seat; - wl_list_init(&pointer->resources); + seat->compositor = compositor; + seat->data = data; - return pointer; -} + wl_list_init(&seat->resources); + wl_list_init(&seat->link); + wl_list_insert(&compositor->seat_list, &seat->link); -static void -pointer_destroy(pepper_seat_t *seat) -{ - struct wl_resource *resource; - struct wl_list *resource_list = &seat->pointer->resources; + if (seat_name) + seat->name = strdup(seat_name); - wl_resource_for_each(resource, resource_list) - wl_resource_destroy(resource); - pepper_free(seat->pointer); + seat->global = wl_global_create(compositor->display, &wl_seat_interface, 4, seat, + bind_seat); + return seat; } -static pepper_keyboard_t * -keyboard_create(pepper_seat_t *seat) +PEPPER_API pepper_pointer_t * +pepper_seat_get_pointer(pepper_seat_t *seat) { - pepper_keyboard_t *keyboard; - - keyboard = (pepper_keyboard_t *)pepper_object_alloc(PEPPER_OBJECT_KEYBOARD, - sizeof(pepper_keyboard_t)); - if (!keyboard) - { - PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__); - return NULL; - } + return seat->pointer; +} - keyboard->seat = seat; - wl_list_init(&keyboard->resources); +PEPPER_API pepper_keyboard_t * +pepper_seat_get_keyboard(pepper_seat_t *seat) +{ + return seat->keyboard; +} - return keyboard; +PEPPER_API pepper_touch_t * +pepper_seat_get_touch(pepper_seat_t *seat) +{ + return seat->touch; } static void -keyboard_destroy(pepper_seat_t *seat) +send_capabilities(pepper_seat_t *seat) { - struct wl_resource *resource; - struct wl_list *resource_list = &seat->keyboard->resources; + struct wl_resource *resource; + struct wl_list *resource_list = &seat->resources; wl_resource_for_each(resource, resource_list) - wl_resource_destroy(resource); - pepper_free(seat->keyboard); + wl_seat_send_capabilities(resource, seat->caps); } -static pepper_touch_t * -touch_create(pepper_seat_t *seat) +PEPPER_API pepper_pointer_device_t * +pepper_pointer_device_create(pepper_compositor_t *compositor) { - pepper_touch_t *touch; + pepper_pointer_device_t *device; - touch = (pepper_touch_t *)pepper_object_alloc(PEPPER_OBJECT_TOUCH, sizeof(pepper_touch_t)); - if (!touch) + device = (pepper_pointer_device_t *)pepper_object_alloc(PEPPER_OBJECT_POINTER_DEVICE, + sizeof(pepper_pointer_device_t)); + if (!device) { - PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__); + PEPPER_ERROR("Failed to allocate memory\n"); return NULL; } - touch->seat = seat; - wl_list_init(&touch->resources); - - return touch; + return device; } -static void -touch_destroy(pepper_seat_t *seat) +PEPPER_API void +pepper_pointer_device_destroy(pepper_pointer_device_t *device) { - struct wl_resource *resource; - struct wl_list *resource_list = &seat->touch->resources; - - wl_resource_for_each(resource, resource_list) - wl_resource_destroy(resource); - pepper_free(seat->touch); + pepper_object_fini((pepper_object_t *)device); + pepper_free(device); } -static void -seat_set_capabilities(pepper_seat_t *seat, uint32_t caps) +PEPPER_API pepper_keyboard_device_t * +pepper_keyboard_device_create(pepper_compositor_t *compositor) { - struct wl_resource *resource; - - seat->caps = caps; - - if ((caps & WL_SEAT_CAPABILITY_POINTER) && (!seat->pointer)) - { - seat->pointer = pointer_create(seat); - if (!seat->pointer) - { - PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__); - return; - } - } - else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && (seat->pointer)) - { - pointer_destroy(seat); - } + pepper_keyboard_device_t *device; - if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && (!seat->keyboard)) - { - seat->keyboard = keyboard_create(seat); - if (!seat->keyboard) - { - PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__); - return; - } - } - else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && (seat->keyboard)) - { - keyboard_destroy(seat); - } - - if ((caps & WL_SEAT_CAPABILITY_TOUCH) && (!seat->touch)) - { - seat->touch = touch_create(seat); - if (!seat->touch) - { - PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__); - return; - } - } - else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && (seat->touch)) + device = (pepper_keyboard_device_t *)pepper_object_alloc(PEPPER_OBJECT_KEYBOARD_DEVICE, + sizeof(pepper_keyboard_device_t)); + if (!device) { - touch_destroy(seat); + PEPPER_ERROR("Failed to allocate memory\n"); + return NULL; } - wl_resource_for_each(resource, &seat->resources) - wl_seat_send_capabilities(resource, caps); + return device; } -static void -handle_seat_set_capabilities(struct wl_listener *listener, void *data) -{ - pepper_seat_t *seat = pepper_container_of(listener, pepper_seat_t, capabilities_listener); - uint32_t caps; - - caps = seat->backend->get_capabilities(data); - seat_set_capabilities(seat, caps); -} - -static void -seat_set_name(pepper_seat_t *seat, const char *name) +PEPPER_API void +pepper_keyboard_device_destroy(pepper_keyboard_device_t *device) { - struct wl_resource *resource; - - seat->name = name; - wl_resource_for_each(resource, &seat->resources) - wl_seat_send_name(resource, name); + pepper_object_fini((pepper_object_t *)device); + pepper_free(device); } -static void -handle_seat_set_name(struct wl_listener *listener, void *data) +PEPPER_API pepper_touch_device_t * +pepper_touch_device_create(pepper_compositor_t *compositor) { - pepper_seat_t *seat = pepper_container_of(listener, pepper_seat_t, name_listener); - const char *name; - - name = seat->backend->get_name(data); - seat_set_name(seat, name); -} + pepper_touch_device_t *device; -PEPPER_API pepper_seat_t * -pepper_compositor_add_seat(pepper_compositor_t *compositor, - const pepper_seat_backend_t *backend, - void *data) -{ - pepper_seat_t *seat = (pepper_seat_t *)pepper_object_alloc(PEPPER_OBJECT_SEAT, - sizeof(pepper_seat_t)); - if (!seat) + device = (pepper_touch_device_t *)pepper_object_alloc(PEPPER_OBJECT_TOUCH_DEVICE, + sizeof(pepper_touch_device_t)); + if (!device) { - PEPPER_ERROR("Failed to allocate memory in %s\n", __FUNCTION__); + PEPPER_ERROR("Failed to allocate memory\n"); return NULL; } - seat->compositor = compositor; - seat->backend = (pepper_seat_backend_t *)backend; - seat->data = data; - - wl_list_init(&seat->resources); - wl_list_init(&seat->link); - wl_list_insert(&compositor->seat_list, &seat->link); - - seat->capabilities_listener.notify = handle_seat_set_capabilities; - seat->backend->add_capabilities_listener(seat->data, &seat->capabilities_listener); - seat->name_listener.notify = handle_seat_set_name; - seat->backend->add_name_listener(seat->data, &seat->name_listener); + return device; +} - seat->global = wl_global_create(compositor->display, &wl_seat_interface, 4, seat, - bind_seat); - return seat; +PEPPER_API void +pepper_touch_device_destroy(pepper_touch_device_t *device) +{ + pepper_object_fini((pepper_object_t *)device); + pepper_free(device); } void diff --git a/src/lib/pepper/pepper-input-backend.h b/src/lib/pepper/pepper-input-backend.h index 36a8fe8..8ccc9fe 100644 --- a/src/lib/pepper/pepper-input-backend.h +++ b/src/lib/pepper/pepper-input-backend.h @@ -7,22 +7,23 @@ extern "C" { #endif -typedef struct pepper_seat_backend pepper_seat_backend_t; - -struct pepper_seat_backend -{ - void (*destroy)(void *data); - void (*add_capabilities_listener)(void *data, struct wl_listener *listener); - void (*add_name_listener)(void *data, struct wl_listener *listener); - - uint32_t (*get_capabilities)(void *data); - const char * (*get_name)(void *data); -}; - -PEPPER_API pepper_seat_t * -pepper_compositor_add_seat(pepper_compositor_t *compositor, - const pepper_seat_backend_t *backend, - void *data); +PEPPER_API pepper_pointer_device_t * +pepper_pointer_device_create(pepper_compositor_t *compositor); + +PEPPER_API void +pepper_pointer_device_destroy(pepper_pointer_device_t *device); + +PEPPER_API pepper_keyboard_device_t * +pepper_keyboard_device_create(pepper_compositor_t *compositor); + +PEPPER_API void +pepper_keyboard_device_destroy(pepper_keyboard_device_t *device); + +PEPPER_API pepper_touch_device_t * +pepper_touch_device_create(pepper_compositor_t *compositor); + +PEPPER_API void +pepper_touch_device_destroy(pepper_touch_device_t *device); #ifdef __cplusplus } diff --git a/src/lib/pepper/pepper-internal.h b/src/lib/pepper/pepper-internal.h index 152a8ff..b773c28 100644 --- a/src/lib/pepper/pepper-internal.h +++ b/src/lib/pepper/pepper-internal.h @@ -191,6 +191,7 @@ struct pepper_seat { pepper_object_t base; pepper_compositor_t *compositor; + pepper_pointer_t *pointer; pepper_keyboard_t *keyboard; pepper_touch_t *touch; @@ -199,16 +200,12 @@ struct pepper_seat struct wl_list resources; struct wl_list link; - struct wl_listener capabilities_listener; - struct wl_listener name_listener; - enum wl_seat_capability caps; - const char *name; + char *name; uint32_t modifier; /* Backend-specific variables. */ - pepper_seat_backend_t *backend; void *data; }; @@ -216,21 +213,69 @@ struct pepper_pointer { pepper_object_t base; pepper_seat_t *seat; + + pepper_view_t *focus; + wl_fixed_t x; + wl_fixed_t y; + + struct wl_list devices; struct wl_list resources; + struct wl_list link; }; struct pepper_keyboard { pepper_object_t base; pepper_seat_t *seat; + + pepper_view_t *focus; + + struct wl_list devices; struct wl_list resources; + struct wl_list link; }; struct pepper_touch { pepper_object_t base; pepper_seat_t *seat; + + pepper_output_t *output; + pepper_view_t *focus; + + struct wl_list devices; struct wl_list resources; + struct wl_list link; +}; + +struct pepper_pointer_device +{ + pepper_object_t base; + pepper_pointer_t *pointer; + struct wl_list link; + + /* Backend-specific variables. */ + void *data; +}; + +struct pepper_keyboard_device +{ + pepper_object_t base; + pepper_keyboard_t *keyboard; + struct wl_list link; + + /* Backend-specific variables. */ + void *data; +}; + +struct pepper_touch_device +{ + pepper_object_t base; + pepper_touch_t *touch; + struct wl_list link; + + /* Backend-specific variables. */ + void *data; }; void diff --git a/src/lib/pepper/pepper.h b/src/lib/pepper/pepper.h index 2c554d1..f810f69 100644 --- a/src/lib/pepper/pepper.h +++ b/src/lib/pepper/pepper.h @@ -21,6 +21,9 @@ typedef struct pepper_seat pepper_seat_t; typedef struct pepper_pointer pepper_pointer_t; typedef struct pepper_keyboard pepper_keyboard_t; typedef struct pepper_touch pepper_touch_t; +typedef struct pepper_pointer_device pepper_pointer_device_t; +typedef struct pepper_keyboard_device pepper_keyboard_device_t; +typedef struct pepper_touch_device pepper_touch_device_t; typedef struct pepper_output_geometry pepper_output_geometry_t; typedef struct pepper_output_mode pepper_output_mode_t; @@ -57,6 +60,9 @@ typedef enum pepper_object_type PEPPER_OBJECT_POINTER, PEPPER_OBJECT_KEYBOARD, PEPPER_OBJECT_TOUCH, + PEPPER_OBJECT_POINTER_DEVICE, + PEPPER_OBJECT_KEYBOARD_DEVICE, + PEPPER_OBJECT_TOUCH_DEVICE, PEPPER_OBJECT_PLANE, } pepper_object_type_t; @@ -146,6 +152,23 @@ struct pepper_input_event wl_fixed_t y; }; +PEPPER_API pepper_seat_t * +pepper_compositor_add_seat(pepper_compositor_t *compositor, + const char *seat_name, + void *data); + +PEPPER_API void +pepper_seat_destroy(pepper_seat_t *seat); + +PEPPER_API pepper_pointer_t * +pepper_seat_get_pointer(pepper_seat_t *seat); + +PEPPER_API pepper_keyboard_t * +pepper_seat_get_keyboard(pepper_seat_t *seat); + +PEPPER_API pepper_touch_t * +pepper_seat_get_touch(pepper_seat_t *seat); + PEPPER_API pepper_bool_t pepper_seat_handle_event(pepper_seat_t *seat, pepper_input_event_t *event); diff --git a/src/lib/wayland/wayland-input.c b/src/lib/wayland/wayland-input.c index f82099e..07275c0 100644 --- a/src/lib/wayland/wayland-input.c +++ b/src/lib/wayland/wayland-input.c @@ -6,11 +6,6 @@ pointer_handle_enter(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface, wl_fixed_t surface_x, wl_fixed_t surface_y) { - wayland_seat_t *seat = (wayland_seat_t *)data; - - seat->pointer_x_last = surface_x; - seat->pointer_y_last = surface_y; - /* TODO */ } @@ -18,64 +13,28 @@ static void pointer_handle_leave(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface) { - /* TODO: */ + /* TODO */ } static void pointer_handle_motion(void *data, struct wl_pointer *pointer, uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y) { - wayland_seat_t *seat = (wayland_seat_t *)data; - pepper_input_event_t event; - - event.type = PEPPER_INPUT_EVENT_POINTER_MOTION; - event.time = time; - event.serial = 0; - event.index = 0; - event.state = 0; - event.value = 0; - event.x = seat->pointer_x_last = surface_x; - event.y = seat->pointer_y_last = surface_y; - - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static void pointer_handle_button(void *data, struct wl_pointer *pointer, uint32_t serial, uint32_t time, uint32_t button, uint32_t state) { - wayland_seat_t *seat = (wayland_seat_t *)data; - pepper_input_event_t event; - - event.type = PEPPER_INPUT_EVENT_POINTER_BUTTON; - event.time = time; - event.serial = serial; /* FIXME */ - event.index = button; - event.state = state; - event.value = 0; - event.x = seat->pointer_x_last; - event.y = seat->pointer_y_last; - - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static void pointer_handle_axis(void *data, struct wl_pointer *pointer, uint32_t time, uint32_t axis, wl_fixed_t value) { - wayland_seat_t *seat = (wayland_seat_t *)data; - pepper_input_event_t event; - - event.type = PEPPER_INPUT_EVENT_POINTER_AXIS; - event.time = time; - event.serial = 0; - event.index = axis; - event.value = value; - event.state = 0; - event.x = 0; - event.y = 0; - - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static const struct wl_pointer_listener pointer_listener = @@ -88,10 +47,10 @@ static const struct wl_pointer_listener pointer_listener = }; static void -keyboard_handle_key_map(void *data, struct wl_keyboard *keyboard, +keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int32_t fd, uint32_t size) { - /* TODO: */ + /* TODO */ } static void @@ -99,33 +58,21 @@ keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface, struct wl_array *keys) { - /* TODO: */ + /* TODO */ } static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) { - /* TODO: */ + /* TODO */ } static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key, uint32_t state) { - wayland_seat_t *seat = (wayland_seat_t *)data; - pepper_input_event_t event; - - event.type = PEPPER_INPUT_EVENT_KEYBOARD_KEY; - event.time = time; - event.serial = serial; /* FIXME */ - event.index = key; - event.value = 0; - event.state = state; - event.x = 0; - event.y = 0; - - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static void @@ -133,19 +80,19 @@ keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) { - /* TODO: */ + /* TODO */ } static void keyboard_handle_repeat_info(void *data, struct wl_keyboard *keyboard, int32_t rate, int32_t delay) { - /* TODO: */ + /* TODO */ } static const struct wl_keyboard_listener keyboard_listener = { - keyboard_handle_key_map, + keyboard_handle_keymap, keyboard_handle_enter, keyboard_handle_leave, keyboard_handle_key, @@ -158,77 +105,33 @@ touch_handle_down(void *data, struct wl_touch *touch, uint32_t serial, uint32_t time, struct wl_surface *surface, int32_t id, wl_fixed_t x, wl_fixed_t y) { - wayland_seat_t *seat = (wayland_seat_t *)data; - pepper_input_event_t event; - - event.type = PEPPER_INPUT_EVENT_TOUCH_DOWN; - event.time = time; - event.serial = serial; /* FIXME */ - event.index = id; - event.value = 0; - event.state = 0; - event.x = seat->touch_x_last = x; - event.y = seat->touch_y_last = y; - - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static void touch_handle_up(void *data, struct wl_touch *touch, uint32_t serial, uint32_t time, int32_t id) { - wayland_seat_t *seat = (wayland_seat_t *)data; - pepper_input_event_t event; - - event.type = PEPPER_INPUT_EVENT_TOUCH_UP; - event.time = time; - event.serial = serial; /* FIXME */ - event.index = id; - event.value = 0; - event.state = 0; - event.x = seat->touch_x_last; - event.y = seat->touch_y_last; - - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static void touch_handle_motion(void *data, struct wl_touch *touch, uint32_t time, int32_t id, wl_fixed_t x, wl_fixed_t y) { - wayland_seat_t *seat = (wayland_seat_t *)data; - pepper_input_event_t event; - - event.type = PEPPER_INPUT_EVENT_TOUCH_MOTION; - event.time = time; - event.serial = 0; - event.index = id; - event.value = 0; - event.state = 0; - event.x = seat->touch_x_last = x; - event.y = seat->touch_y_last = y; - - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static void touch_handle_frame(void *data, struct wl_touch *touch) { - wayland_seat_t *seat = (wayland_seat_t *)data; - pepper_input_event_t event; - - event.type = PEPPER_INPUT_EVENT_TOUCH_FRAME; - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static void touch_handle_cancel(void *data, struct wl_touch *touch) { - wayland_seat_t *seat = (wayland_seat_t *)data; - pepper_input_event_t event; - - event.type = PEPPER_INPUT_EVENT_TOUCH_CANCEL; - pepper_seat_handle_event(seat->base, &event); + /* TODO */ } static const struct wl_touch_listener touch_listener = @@ -248,56 +151,56 @@ seat_handle_caps(void *data, struct wl_seat *s, enum wl_seat_capability caps) if (seat->seat != s) /* FIXME */ return; - if ((caps & WL_SEAT_CAPABILITY_POINTER) && (!seat->pointer)) + if ((caps & WL_SEAT_CAPABILITY_POINTER) && (!seat->pointer.wl_pointer)) { - seat->pointer = wl_seat_get_pointer(seat->seat); - if (seat->pointer) - wl_pointer_add_listener(seat->pointer, &pointer_listener, seat); + seat->pointer.wl_pointer = wl_seat_get_pointer(seat->seat); + if (seat->pointer.wl_pointer) + wl_pointer_add_listener(seat->pointer.wl_pointer, &pointer_listener, seat); + + seat->pointer.base = pepper_pointer_device_create(seat->conn->pepper); } - else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && (seat->pointer)) + else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && (seat->pointer.wl_pointer)) { - wl_pointer_release(seat->pointer); - seat->pointer = NULL; + pepper_pointer_device_destroy(seat->pointer.base); + wl_pointer_release(seat->pointer.wl_pointer); + seat->pointer.wl_pointer = NULL; } - if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && (!seat->keyboard)) + if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && (!seat->keyboard.wl_keyboard)) { - seat->keyboard = wl_seat_get_keyboard(seat->seat); - if (seat->keyboard) - wl_keyboard_add_listener(seat->keyboard, &keyboard_listener, seat); + seat->keyboard.wl_keyboard = wl_seat_get_keyboard(seat->seat); + if (seat->keyboard.wl_keyboard) + wl_keyboard_add_listener(seat->keyboard.wl_keyboard, &keyboard_listener, seat); + + seat->keyboard.base = pepper_keyboard_device_create(seat->conn->pepper); } - else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && (seat->keyboard)) + else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && (seat->keyboard.wl_keyboard)) { - wl_keyboard_release(seat->keyboard); - seat->keyboard = NULL; + pepper_keyboard_device_destroy(seat->keyboard.base); + wl_keyboard_release(seat->keyboard.wl_keyboard); + seat->keyboard.wl_keyboard = NULL; } - if ((caps & WL_SEAT_CAPABILITY_TOUCH) && (!seat->touch)) + if ((caps & WL_SEAT_CAPABILITY_TOUCH) && (!seat->touch.wl_touch)) { - seat->touch = wl_seat_get_touch(seat->seat); - if (seat->touch) - wl_touch_add_listener(seat->touch, &touch_listener, seat); + seat->touch.wl_touch = wl_seat_get_touch(seat->seat); + if (seat->touch.wl_touch) + wl_touch_add_listener(seat->touch.wl_touch, &touch_listener, seat); + + seat->touch.base = pepper_touch_device_create(seat->conn->pepper); } - else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && (seat->touch)) + else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && (seat->touch.wl_touch)) { - wl_touch_release(seat->touch); - seat->touch = NULL; + pepper_touch_device_destroy(seat->touch.base); + wl_touch_release(seat->touch.wl_touch); + seat->touch.wl_touch = NULL; } - - seat->caps = caps; - wl_signal_emit(&seat->capabilities_signal, seat); } static void seat_handle_name(void *data, struct wl_seat *s, const char *name) { - wayland_seat_t *seat = (wayland_seat_t *)data; - - if (seat->seat != s) /* FIXME */ - return; - - seat->name = string_copy(name); - wl_signal_emit(&seat->name_signal, seat); + /* TODO */ } static const struct wl_seat_listener seat_listener = @@ -306,49 +209,6 @@ static const struct wl_seat_listener seat_listener = seat_handle_name, }; -static void -wayland_seat_destroy(void *data) -{ - /* TODO: */ -} - -static void -wayland_seat_add_capability_listener(void *data, struct wl_listener *listener) -{ - wayland_seat_t *seat = (wayland_seat_t *)data; - wl_signal_add(&seat->capabilities_signal, listener); -} - -static void -wayland_seat_add_name_listener(void *data, struct wl_listener *listener) -{ - wayland_seat_t *seat = (wayland_seat_t *)data; - wl_signal_add(&seat->name_signal, listener); -} - -static uint32_t -wayland_seat_get_capabilities(void *data) -{ - wayland_seat_t *seat = (wayland_seat_t *)data; - return seat->caps; -} - -static const char * -wayland_seat_get_name(void *data) -{ - wayland_seat_t *seat = (wayland_seat_t *)data; - return seat->name; -} - -static const pepper_seat_backend_t wayland_seat_backend = -{ - wayland_seat_destroy, - wayland_seat_add_capability_listener, - wayland_seat_add_name_listener, - wayland_seat_get_capabilities, - wayland_seat_get_name, -}; - void wayland_handle_global_seat(pepper_wayland_t *conn, struct wl_registry *registry, uint32_t name, uint32_t version) @@ -365,12 +225,8 @@ wayland_handle_global_seat(pepper_wayland_t *conn, struct wl_registry *registry, seat->seat = wl_registry_bind(registry, name, &wl_seat_interface, 1); wl_seat_add_listener(seat->seat, &seat_listener, seat); - wl_signal_init(&seat->capabilities_signal); - wl_signal_init(&seat->name_signal); - - seat->base = pepper_compositor_add_seat(conn->pepper, &wayland_seat_backend, seat); + seat->conn = conn; seat->id = name; - wl_list_init(&seat->link); wl_list_insert(&conn->seat_list, &seat->link); } diff --git a/src/lib/wayland/wayland-internal.h b/src/lib/wayland/wayland-internal.h index f576028..8071c91 100644 --- a/src/lib/wayland/wayland-internal.h +++ b/src/lib/wayland/wayland-internal.h @@ -109,25 +109,29 @@ struct wayland_output struct wayland_seat { - pepper_seat_t *base; - + pepper_wayland_t *conn; + struct wl_seat *seat; uint32_t id; - uint32_t caps; - char *name; - struct wl_seat *seat; - struct wl_pointer *pointer; - struct wl_keyboard *keyboard; - struct wl_touch *touch; + struct + { + pepper_pointer_device_t *base; + struct wl_pointer *wl_pointer; + } pointer; + + struct + { + pepper_keyboard_device_t *base; + struct wl_keyboard *wl_keyboard; + } keyboard; - wl_fixed_t pointer_x_last; - wl_fixed_t pointer_y_last; - wl_fixed_t touch_x_last; /* FIXME */ - wl_fixed_t touch_y_last; /* FIXME */ + struct + { + pepper_touch_device_t *base; + struct wl_touch *wl_touch; + } touch; struct wl_list link; - struct wl_signal capabilities_signal; - struct wl_signal name_signal; }; void diff --git a/src/lib/x11/pepper-x11.h b/src/lib/x11/pepper-x11.h index 771a6f1..daedd45 100644 --- a/src/lib/x11/pepper-x11.h +++ b/src/lib/x11/pepper-x11.h @@ -19,8 +19,8 @@ PEPPER_API pepper_output_t * pepper_x11_output_create(pepper_x11_connection_t *connection, int32_t w, int32_t h, const char *renderer); -PEPPER_API void -pepper_x11_seat_create(pepper_x11_connection_t* connection); +PEPPER_API pepper_bool_t +pepper_x11_input_init(pepper_x11_connection_t* connection); #ifdef __cplusplus } diff --git a/src/lib/x11/x11-input.c b/src/lib/x11/x11-input.c index 272b8b9..c0272b0 100644 --- a/src/lib/x11/x11-input.c +++ b/src/lib/x11/x11-input.c @@ -91,7 +91,7 @@ x11_handle_input_event(x11_seat_t* seat, uint32_t type, xcb_generic_event_t* xev PEPPER_ERROR("unknown input event, [0x%x]\n", type); } - pepper_seat_handle_event(seat->base, &event); + /* TODO: send input event */ } void @@ -124,43 +124,6 @@ x11_seat_destroy(void *data) } static void -x11_seat_add_capability_listener(void *data, struct wl_listener *listener) -{ - x11_seat_t *seat = (x11_seat_t *)data; - wl_signal_add(&seat->capabilities_signal, listener); -} - -static void -x11_seat_add_name_listener(void *data, struct wl_listener *listener) -{ - x11_seat_t *seat = (x11_seat_t *)data; - wl_signal_add(&seat->name_signal, listener); -} - -static uint32_t -x11_seat_get_capabilities(void *data) -{ - x11_seat_t *seat = (x11_seat_t *)data; - return seat->caps; -} - -static const char * -x11_seat_get_name(void *data) -{ - x11_seat_t *seat = (x11_seat_t *)data; - return seat->name; -} - -static const pepper_seat_backend_t x11_seat_backend = -{ - x11_seat_destroy, - x11_seat_add_capability_listener, - x11_seat_add_name_listener, - x11_seat_get_capabilities, - x11_seat_get_name, -}; - -static void handle_connection_destroy(struct wl_listener *listener, void *data) { x11_seat_t *seat = wl_container_of(listener, seat, conn_destroy_listener); @@ -194,19 +157,26 @@ pepper_x11_seat_create(pepper_x11_connection_t* conn) /* XXX: if x-input-module used without x-output-module, * need to create dummy window for input with output-size */ - wl_signal_init(&seat->capabilities_signal); - wl_signal_init(&seat->name_signal); - seat->conn_destroy_listener.notify = handle_connection_destroy; wl_signal_add(&conn->destroy_signal, &seat->conn_destroy_listener); - seat->base = pepper_compositor_add_seat(conn->compositor, &x11_seat_backend, seat); seat->id = X11_BACKEND_INPUT_ID; /* Hard-coded: */ + seat->pointer = pepper_pointer_device_create(conn->compositor); + if (!seat->pointer) + { + PEPPER_ERROR("failed to create pepper pointer device\n"); + /* TODO: error handling */ + } seat->caps |= WL_SEAT_CAPABILITY_POINTER; + seat->keyboard = pepper_keyboard_device_create(conn->compositor); + if (!seat->keyboard) + { + PEPPER_ERROR("failed to create pepper keyboard device\n"); + /* TODO: error handling */ + } seat->caps |= WL_SEAT_CAPABILITY_KEYBOARD; - wl_signal_emit(&seat->capabilities_signal, seat); /* x-connection has only 1 seat */ conn->seat = seat; diff --git a/src/lib/x11/x11-internal.h b/src/lib/x11/x11-internal.h index 07ac0c3..068e5bf 100644 --- a/src/lib/x11/x11-internal.h +++ b/src/lib/x11/x11-internal.h @@ -77,22 +77,17 @@ struct x11_output struct x11_seat { - pepper_seat_t *base; + pepper_pointer_device_t *pointer; + pepper_keyboard_device_t *keyboard; + pepper_touch_device_t *touch; - uint32_t id; - uint32_t caps; - char *name; + uint32_t id; + uint32_t caps; + char *name; - wl_fixed_t pointer_x_last; - wl_fixed_t pointer_y_last; - wl_fixed_t touch_x_last; /* FIXME */ - wl_fixed_t touch_y_last; /* FIXME */ + struct wl_list link; - struct wl_list link; - struct wl_signal capabilities_signal; - struct wl_signal name_signal; - - struct wl_listener conn_destroy_listener; + struct wl_listener conn_destroy_listener; }; struct pepper_x11_connection diff --git a/src/lib/x11/x11-output.c b/src/lib/x11/x11-output.c index 2dba69d..4c10433 100644 --- a/src/lib/x11/x11-output.c +++ b/src/lib/x11/x11-output.c @@ -687,9 +687,5 @@ pepper_x11_output_create(pepper_x11_connection_t *connection, output->base = base; output->primary_plane = pepper_output_add_plane(output->base, NULL); - /* X11 input seat create */ - if (!connection->use_xinput) - pepper_x11_seat_create(connection); - return base; }