2 * Copyright © 2013 Intel Corporation
4 * Permission to use, copy, modify, distribute, and sell this software and
5 * its documentation for any purpose is hereby granted without fee, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the copyright holders not be used in
9 * advertising or publicity pertaining to distribution of the software
10 * without specific, written prior permission. The copyright holders make
11 * no representations about the suitability of this software for any
12 * purpose. It is provided "as is" without express or implied warranty.
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
34 #include "../shared/os-compatibility.h"
35 #include "compositor.h"
38 empty_region(pixman_region32_t *region)
40 pixman_region32_fini(region);
41 pixman_region32_init(region);
44 static void unbind_resource(struct wl_resource *resource)
46 wl_list_remove(wl_resource_get_link(resource));
50 weston_seat_repick(struct weston_seat *seat)
52 const struct weston_pointer *pointer = seat->pointer;
57 pointer->grab->interface->focus(seat->pointer->grab);
61 weston_compositor_idle_inhibit(struct weston_compositor *compositor)
63 weston_compositor_wake(compositor);
64 compositor->idle_inhibit++;
68 weston_compositor_idle_release(struct weston_compositor *compositor)
70 compositor->idle_inhibit--;
71 weston_compositor_wake(compositor);
75 pointer_focus_view_destroyed(struct wl_listener *listener, void *data)
77 struct weston_pointer *pointer =
78 container_of(listener, struct weston_pointer,
81 weston_pointer_set_focus(pointer, NULL, 0, 0);
85 pointer_focus_resource_destroyed(struct wl_listener *listener, void *data)
87 struct weston_pointer *pointer =
88 container_of(listener, struct weston_pointer,
89 focus_resource_listener);
91 weston_pointer_set_focus(pointer, NULL, 0, 0);
95 keyboard_focus_resource_destroyed(struct wl_listener *listener, void *data)
97 struct weston_keyboard *keyboard =
98 container_of(listener, struct weston_keyboard,
99 focus_resource_listener);
101 weston_keyboard_set_focus(keyboard, NULL);
105 touch_focus_view_destroyed(struct wl_listener *listener, void *data)
107 struct weston_touch *touch =
108 container_of(listener, struct weston_touch,
109 focus_view_listener);
111 weston_touch_set_focus(touch->seat, NULL);
115 touch_focus_resource_destroyed(struct wl_listener *listener, void *data)
117 struct weston_touch *touch =
118 container_of(listener, struct weston_touch,
119 focus_resource_listener);
121 weston_touch_set_focus(touch->seat, NULL);
125 move_resources(struct wl_list *destination, struct wl_list *source)
127 wl_list_insert_list(destination, source);
128 wl_list_init(source);
132 move_resources_for_client(struct wl_list *destination,
133 struct wl_list *source,
134 struct wl_client *client)
136 struct wl_resource *resource, *tmp;
137 wl_resource_for_each_safe(resource, tmp, source) {
138 if (wl_resource_get_client(resource) == client) {
139 wl_list_remove(wl_resource_get_link(resource));
140 wl_list_insert(destination,
141 wl_resource_get_link(resource));
147 default_grab_pointer_focus(struct weston_pointer_grab *grab)
149 struct weston_pointer *pointer = grab->pointer;
150 struct weston_view *view;
153 if (pointer->button_count > 0)
156 view = weston_compositor_pick_view(pointer->seat->compositor,
157 pointer->x, pointer->y,
160 if (pointer->focus != view || pointer->sx != sx || pointer->sy != sy)
161 weston_pointer_set_focus(pointer, view, sx, sy);
165 default_grab_pointer_motion(struct weston_pointer_grab *grab, uint32_t time,
166 wl_fixed_t x, wl_fixed_t y)
168 struct weston_pointer *pointer = grab->pointer;
169 struct wl_list *resource_list;
170 struct wl_resource *resource;
173 weston_view_from_global_fixed(pointer->focus, x, y,
174 &pointer->sx, &pointer->sy);
176 weston_pointer_move(pointer, x, y);
178 resource_list = &pointer->focus_resource_list;
179 wl_resource_for_each(resource, resource_list) {
180 wl_pointer_send_motion(resource, time,
181 pointer->sx, pointer->sy);
186 default_grab_pointer_button(struct weston_pointer_grab *grab,
187 uint32_t time, uint32_t button, uint32_t state_w)
189 struct weston_pointer *pointer = grab->pointer;
190 struct weston_compositor *compositor = pointer->seat->compositor;
191 struct weston_view *view;
192 struct wl_resource *resource;
194 enum wl_pointer_button_state state = state_w;
195 struct wl_display *display = compositor->wl_display;
197 struct wl_list *resource_list;
199 resource_list = &pointer->focus_resource_list;
200 if (!wl_list_empty(resource_list)) {
201 serial = wl_display_next_serial(display);
202 wl_resource_for_each(resource, resource_list)
203 wl_pointer_send_button(resource,
210 if (pointer->button_count == 0 &&
211 state == WL_POINTER_BUTTON_STATE_RELEASED) {
212 view = weston_compositor_pick_view(compositor,
213 pointer->x, pointer->y,
216 weston_pointer_set_focus(pointer, view, sx, sy);
221 default_grab_pointer_cancel(struct weston_pointer_grab *grab)
225 static const struct weston_pointer_grab_interface
226 default_pointer_grab_interface = {
227 default_grab_pointer_focus,
228 default_grab_pointer_motion,
229 default_grab_pointer_button,
230 default_grab_pointer_cancel,
234 default_grab_touch_down(struct weston_touch_grab *grab, uint32_t time,
235 int touch_id, wl_fixed_t sx, wl_fixed_t sy)
237 struct weston_touch *touch = grab->touch;
238 struct wl_display *display = touch->seat->compositor->wl_display;
240 struct wl_resource *resource;
241 struct wl_list *resource_list;
243 resource_list = &touch->focus_resource_list;
245 if (!wl_list_empty(resource_list) && touch->focus) {
246 serial = wl_display_next_serial(display);
247 wl_resource_for_each(resource, resource_list)
248 wl_touch_send_down(resource, serial, time,
249 touch->focus->surface->resource,
255 default_grab_touch_up(struct weston_touch_grab *grab,
256 uint32_t time, int touch_id)
258 struct weston_touch *touch = grab->touch;
259 struct wl_display *display = touch->seat->compositor->wl_display;
261 struct wl_resource *resource;
262 struct wl_list *resource_list;
264 resource_list = &touch->focus_resource_list;
266 if (!wl_list_empty(resource_list)) {
267 serial = wl_display_next_serial(display);
268 wl_resource_for_each(resource, resource_list)
269 wl_touch_send_up(resource, serial, time, touch_id);
274 default_grab_touch_motion(struct weston_touch_grab *grab, uint32_t time,
275 int touch_id, wl_fixed_t sx, wl_fixed_t sy)
277 struct weston_touch *touch = grab->touch;
278 struct wl_resource *resource;
279 struct wl_list *resource_list;
281 resource_list = &touch->focus_resource_list;
283 wl_resource_for_each(resource, resource_list) {
284 wl_touch_send_motion(resource, time,
290 default_grab_touch_frame(struct weston_touch_grab *grab)
292 struct wl_resource *resource;
294 wl_resource_for_each(resource, &grab->touch->focus_resource_list)
295 wl_touch_send_frame(resource);
299 default_grab_touch_cancel(struct weston_touch_grab *grab)
303 static const struct weston_touch_grab_interface default_touch_grab_interface = {
304 default_grab_touch_down,
305 default_grab_touch_up,
306 default_grab_touch_motion,
307 default_grab_touch_frame,
308 default_grab_touch_cancel,
312 default_grab_keyboard_key(struct weston_keyboard_grab *grab,
313 uint32_t time, uint32_t key, uint32_t state)
315 struct weston_keyboard *keyboard = grab->keyboard;
316 struct wl_resource *resource;
317 struct wl_display *display = keyboard->seat->compositor->wl_display;
319 struct wl_list *resource_list;
321 resource_list = &keyboard->focus_resource_list;
322 if (!wl_list_empty(resource_list)) {
323 serial = wl_display_next_serial(display);
324 wl_resource_for_each(resource, resource_list)
325 wl_keyboard_send_key(resource,
334 send_modifiers_to_resource(struct weston_keyboard *keyboard,
335 struct wl_resource *resource,
338 wl_keyboard_send_modifiers(resource,
340 keyboard->modifiers.mods_depressed,
341 keyboard->modifiers.mods_latched,
342 keyboard->modifiers.mods_locked,
343 keyboard->modifiers.group);
347 send_modifiers_to_client_in_list(struct wl_client *client,
348 struct wl_list *list,
350 struct weston_keyboard *keyboard)
352 struct wl_resource *resource;
354 wl_resource_for_each(resource, list) {
355 if (wl_resource_get_client(resource) == client)
356 send_modifiers_to_resource(keyboard,
362 static struct wl_resource *
363 find_resource_for_surface(struct wl_list *list, struct weston_surface *surface)
368 if (!surface->resource)
371 return wl_resource_find_for_client(list, wl_resource_get_client(surface->resource));
374 static struct wl_resource *
375 find_resource_for_view(struct wl_list *list, struct weston_view *view)
380 return find_resource_for_surface(list, view->surface);
384 default_grab_keyboard_modifiers(struct weston_keyboard_grab *grab,
385 uint32_t serial, uint32_t mods_depressed,
386 uint32_t mods_latched,
387 uint32_t mods_locked, uint32_t group)
389 struct weston_keyboard *keyboard = grab->keyboard;
390 struct weston_pointer *pointer = grab->keyboard->seat->pointer;
391 struct wl_resource *resource;
392 struct wl_list *resource_list;
394 resource_list = &keyboard->focus_resource_list;
396 wl_resource_for_each(resource, resource_list) {
397 wl_keyboard_send_modifiers(resource, serial, mods_depressed,
398 mods_latched, mods_locked, group);
400 if (pointer && pointer->focus && pointer->focus->surface->resource &&
401 pointer->focus->surface != keyboard->focus) {
402 struct wl_client *pointer_client =
403 wl_resource_get_client(pointer->focus->surface->resource);
404 send_modifiers_to_client_in_list(pointer_client,
405 &keyboard->resource_list,
412 default_grab_keyboard_cancel(struct weston_keyboard_grab *grab)
416 static const struct weston_keyboard_grab_interface
417 default_keyboard_grab_interface = {
418 default_grab_keyboard_key,
419 default_grab_keyboard_modifiers,
420 default_grab_keyboard_cancel,
424 pointer_unmap_sprite(struct weston_pointer *pointer)
426 if (weston_surface_is_mapped(pointer->sprite->surface))
427 weston_surface_unmap(pointer->sprite->surface);
429 wl_list_remove(&pointer->sprite_destroy_listener.link);
430 pointer->sprite->surface->configure = NULL;
431 pointer->sprite->surface->configure_private = NULL;
432 weston_view_destroy(pointer->sprite);
433 pointer->sprite = NULL;
437 pointer_handle_sprite_destroy(struct wl_listener *listener, void *data)
439 struct weston_pointer *pointer =
440 container_of(listener, struct weston_pointer,
441 sprite_destroy_listener);
443 pointer->sprite = NULL;
447 weston_pointer_reset_state(struct weston_pointer *pointer)
449 pointer->button_count = 0;
453 weston_pointer_handle_output_destroy(struct wl_listener *listener, void *data);
455 WL_EXPORT struct weston_pointer *
456 weston_pointer_create(struct weston_seat *seat)
458 struct weston_pointer *pointer;
460 pointer = zalloc(sizeof *pointer);
464 wl_list_init(&pointer->resource_list);
465 wl_list_init(&pointer->focus_resource_list);
466 weston_pointer_set_default_grab(pointer,
467 seat->compositor->default_pointer_grab);
468 wl_list_init(&pointer->focus_resource_listener.link);
469 pointer->focus_resource_listener.notify = pointer_focus_resource_destroyed;
470 pointer->default_grab.pointer = pointer;
471 pointer->grab = &pointer->default_grab;
472 wl_signal_init(&pointer->motion_signal);
473 wl_signal_init(&pointer->focus_signal);
474 wl_list_init(&pointer->focus_view_listener.link);
476 pointer->sprite_destroy_listener.notify = pointer_handle_sprite_destroy;
478 /* FIXME: Pick better co-ords. */
479 pointer->x = wl_fixed_from_int(100);
480 pointer->y = wl_fixed_from_int(100);
482 pointer->output_destroy_listener.notify =
483 weston_pointer_handle_output_destroy;
484 wl_signal_add(&seat->compositor->output_destroyed_signal,
485 &pointer->output_destroy_listener);
491 weston_pointer_destroy(struct weston_pointer *pointer)
494 pointer_unmap_sprite(pointer);
496 /* XXX: What about pointer->resource_list? */
498 wl_list_remove(&pointer->focus_resource_listener.link);
499 wl_list_remove(&pointer->focus_view_listener.link);
500 wl_list_remove(&pointer->output_destroy_listener.link);
505 weston_pointer_set_default_grab(struct weston_pointer *pointer,
506 const struct weston_pointer_grab_interface *interface)
509 pointer->default_grab.interface = interface;
511 pointer->default_grab.interface =
512 &default_pointer_grab_interface;
515 WL_EXPORT struct weston_keyboard *
516 weston_keyboard_create(void)
518 struct weston_keyboard *keyboard;
520 keyboard = zalloc(sizeof *keyboard);
521 if (keyboard == NULL)
524 wl_list_init(&keyboard->resource_list);
525 wl_list_init(&keyboard->focus_resource_list);
526 wl_list_init(&keyboard->focus_resource_listener.link);
527 keyboard->focus_resource_listener.notify = keyboard_focus_resource_destroyed;
528 wl_array_init(&keyboard->keys);
529 keyboard->default_grab.interface = &default_keyboard_grab_interface;
530 keyboard->default_grab.keyboard = keyboard;
531 keyboard->grab = &keyboard->default_grab;
532 wl_signal_init(&keyboard->focus_signal);
538 weston_xkb_info_destroy(struct weston_xkb_info *xkb_info);
541 weston_keyboard_destroy(struct weston_keyboard *keyboard)
543 /* XXX: What about keyboard->resource_list? */
545 #ifdef ENABLE_XKBCOMMON
546 if (keyboard->seat->compositor->use_xkbcommon) {
547 xkb_state_unref(keyboard->xkb_state.state);
548 if (keyboard->xkb_info)
549 weston_xkb_info_destroy(keyboard->xkb_info);
550 xkb_keymap_unref(keyboard->pending_keymap);
554 wl_array_release(&keyboard->keys);
555 wl_list_remove(&keyboard->focus_resource_listener.link);
560 weston_touch_reset_state(struct weston_touch *touch)
565 WL_EXPORT struct weston_touch *
566 weston_touch_create(void)
568 struct weston_touch *touch;
570 touch = zalloc(sizeof *touch);
574 wl_list_init(&touch->resource_list);
575 wl_list_init(&touch->focus_resource_list);
576 wl_list_init(&touch->focus_view_listener.link);
577 touch->focus_view_listener.notify = touch_focus_view_destroyed;
578 wl_list_init(&touch->focus_resource_listener.link);
579 touch->focus_resource_listener.notify = touch_focus_resource_destroyed;
580 touch->default_grab.interface = &default_touch_grab_interface;
581 touch->default_grab.touch = touch;
582 touch->grab = &touch->default_grab;
583 wl_signal_init(&touch->focus_signal);
589 weston_touch_destroy(struct weston_touch *touch)
591 /* XXX: What about touch->resource_list? */
593 wl_list_remove(&touch->focus_view_listener.link);
594 wl_list_remove(&touch->focus_resource_listener.link);
599 seat_send_updated_caps(struct weston_seat *seat)
601 enum wl_seat_capability caps = 0;
602 struct wl_resource *resource;
604 if (seat->pointer_device_count > 0)
605 caps |= WL_SEAT_CAPABILITY_POINTER;
606 if (seat->keyboard_device_count > 0)
607 caps |= WL_SEAT_CAPABILITY_KEYBOARD;
608 if (seat->touch_device_count > 0)
609 caps |= WL_SEAT_CAPABILITY_TOUCH;
611 wl_resource_for_each(resource, &seat->base_resource_list) {
612 wl_seat_send_capabilities(resource, caps);
614 wl_signal_emit(&seat->updated_caps_signal, seat);
618 weston_pointer_set_focus(struct weston_pointer *pointer,
619 struct weston_view *view,
620 wl_fixed_t sx, wl_fixed_t sy)
622 struct weston_keyboard *kbd = pointer->seat->keyboard;
623 struct wl_resource *resource;
624 struct wl_display *display = pointer->seat->compositor->wl_display;
626 struct wl_list *focus_resource_list;
629 if ((!pointer->focus && view) ||
630 (pointer->focus && !view) ||
631 (pointer->focus && pointer->focus->surface != view->surface) ||
632 pointer->sx != sx || pointer->sy != sy)
635 focus_resource_list = &pointer->focus_resource_list;
637 if (!wl_list_empty(focus_resource_list) && refocus) {
638 serial = wl_display_next_serial(display);
639 wl_resource_for_each(resource, focus_resource_list) {
640 wl_pointer_send_leave(resource, serial,
641 pointer->focus->surface->resource);
644 move_resources(&pointer->resource_list, focus_resource_list);
647 if (find_resource_for_view(&pointer->resource_list, view) && refocus) {
648 struct wl_client *surface_client =
649 wl_resource_get_client(view->surface->resource);
651 serial = wl_display_next_serial(display);
653 if (kbd && kbd->focus != view->surface)
654 send_modifiers_to_client_in_list(surface_client,
659 move_resources_for_client(focus_resource_list,
660 &pointer->resource_list,
663 wl_resource_for_each(resource, focus_resource_list) {
664 wl_pointer_send_enter(resource,
666 view->surface->resource,
670 pointer->focus_serial = serial;
673 wl_list_remove(&pointer->focus_view_listener.link);
674 wl_list_init(&pointer->focus_view_listener.link);
675 wl_list_remove(&pointer->focus_resource_listener.link);
676 wl_list_init(&pointer->focus_resource_listener.link);
678 wl_signal_add(&view->destroy_signal, &pointer->focus_view_listener);
679 if (view && view->surface->resource)
680 wl_resource_add_destroy_listener(view->surface->resource,
681 &pointer->focus_resource_listener);
683 pointer->focus = view;
684 pointer->focus_view_listener.notify = pointer_focus_view_destroyed;
688 wl_signal_emit(&pointer->focus_signal, pointer);
692 send_enter_to_resource_list(struct wl_list *list,
693 struct weston_keyboard *keyboard,
694 struct weston_surface *surface,
697 struct wl_resource *resource;
699 wl_resource_for_each(resource, list) {
700 send_modifiers_to_resource(keyboard, resource, serial);
701 wl_keyboard_send_enter(resource, serial,
708 weston_keyboard_set_focus(struct weston_keyboard *keyboard,
709 struct weston_surface *surface)
711 struct wl_resource *resource;
712 struct wl_display *display = keyboard->seat->compositor->wl_display;
714 struct wl_list *focus_resource_list;
716 focus_resource_list = &keyboard->focus_resource_list;
718 if (!wl_list_empty(focus_resource_list) && keyboard->focus != surface) {
719 serial = wl_display_next_serial(display);
720 wl_resource_for_each(resource, focus_resource_list) {
721 wl_keyboard_send_leave(resource, serial,
722 keyboard->focus->resource);
724 move_resources(&keyboard->resource_list, focus_resource_list);
727 if (find_resource_for_surface(&keyboard->resource_list, surface) &&
728 keyboard->focus != surface) {
729 struct wl_client *surface_client =
730 wl_resource_get_client(surface->resource);
732 serial = wl_display_next_serial(display);
734 move_resources_for_client(focus_resource_list,
735 &keyboard->resource_list,
737 send_enter_to_resource_list(focus_resource_list,
741 keyboard->focus_serial = serial;
744 wl_list_remove(&keyboard->focus_resource_listener.link);
745 wl_list_init(&keyboard->focus_resource_listener.link);
746 if (surface && surface->resource)
747 wl_resource_add_destroy_listener(surface->resource,
748 &keyboard->focus_resource_listener);
750 keyboard->focus = surface;
751 wl_signal_emit(&keyboard->focus_signal, keyboard);
755 weston_keyboard_start_grab(struct weston_keyboard *keyboard,
756 struct weston_keyboard_grab *grab)
758 keyboard->grab = grab;
759 grab->keyboard = keyboard;
765 weston_keyboard_end_grab(struct weston_keyboard *keyboard)
767 keyboard->grab = &keyboard->default_grab;
771 weston_keyboard_cancel_grab(struct weston_keyboard *keyboard)
773 keyboard->grab->interface->cancel(keyboard->grab);
777 weston_pointer_start_grab(struct weston_pointer *pointer,
778 struct weston_pointer_grab *grab)
780 pointer->grab = grab;
781 grab->pointer = pointer;
782 pointer->grab->interface->focus(pointer->grab);
786 weston_pointer_end_grab(struct weston_pointer *pointer)
788 pointer->grab = &pointer->default_grab;
789 pointer->grab->interface->focus(pointer->grab);
793 weston_pointer_cancel_grab(struct weston_pointer *pointer)
795 pointer->grab->interface->cancel(pointer->grab);
799 weston_touch_start_grab(struct weston_touch *touch, struct weston_touch_grab *grab)
806 weston_touch_end_grab(struct weston_touch *touch)
808 touch->grab = &touch->default_grab;
812 weston_touch_cancel_grab(struct weston_touch *touch)
814 touch->grab->interface->cancel(touch->grab);
818 weston_pointer_clamp_for_output(struct weston_pointer *pointer,
819 struct weston_output *output,
820 wl_fixed_t *fx, wl_fixed_t *fy)
824 x = wl_fixed_to_int(*fx);
825 y = wl_fixed_to_int(*fy);
828 *fx = wl_fixed_from_int(output->x);
829 else if (x >= output->x + output->width)
830 *fx = wl_fixed_from_int(output->x +
833 *fy = wl_fixed_from_int(output->y);
834 else if (y >= output->y + output->height)
835 *fy = wl_fixed_from_int(output->y +
840 weston_pointer_clamp(struct weston_pointer *pointer, wl_fixed_t *fx, wl_fixed_t *fy)
842 struct weston_compositor *ec = pointer->seat->compositor;
843 struct weston_output *output, *prev = NULL;
844 int x, y, old_x, old_y, valid = 0;
846 x = wl_fixed_to_int(*fx);
847 y = wl_fixed_to_int(*fy);
848 old_x = wl_fixed_to_int(pointer->x);
849 old_y = wl_fixed_to_int(pointer->y);
851 wl_list_for_each(output, &ec->output_list, link) {
852 if (pointer->seat->output && pointer->seat->output != output)
854 if (pixman_region32_contains_point(&output->region,
857 if (pixman_region32_contains_point(&output->region,
863 prev = pointer->seat->output;
866 weston_pointer_clamp_for_output(pointer, prev, fx, fy);
869 /* Takes absolute values */
871 weston_pointer_move(struct weston_pointer *pointer, wl_fixed_t x, wl_fixed_t y)
875 weston_pointer_clamp (pointer, &x, &y);
880 ix = wl_fixed_to_int(x);
881 iy = wl_fixed_to_int(y);
883 if (pointer->sprite) {
884 weston_view_set_position(pointer->sprite,
885 ix - pointer->hotspot_x,
886 iy - pointer->hotspot_y);
887 weston_view_schedule_repaint(pointer->sprite);
890 pointer->grab->interface->focus(pointer->grab);
891 wl_signal_emit(&pointer->motion_signal, pointer);
894 /** Verify if the pointer is in a valid position and move it if it isn't.
897 weston_pointer_handle_output_destroy(struct wl_listener *listener, void *data)
899 struct weston_pointer *pointer;
900 struct weston_compositor *ec;
901 struct weston_output *output, *closest = NULL;
902 int x, y, distance, min = INT_MAX;
905 pointer = container_of(listener, struct weston_pointer,
906 output_destroy_listener);
907 ec = pointer->seat->compositor;
909 x = wl_fixed_to_int(pointer->x);
910 y = wl_fixed_to_int(pointer->y);
912 wl_list_for_each(output, &ec->output_list, link) {
913 if (pixman_region32_contains_point(&output->region,
917 /* Aproximante the distance from the pointer to the center of
919 distance = abs(output->x + output->width / 2 - x) +
920 abs(output->y + output->height / 2 - y);
921 if (distance < min) {
927 /* Nothing to do if there's no output left. */
934 weston_pointer_clamp_for_output(pointer, closest, &fx, &fy);
935 weston_pointer_move(pointer, fx, fy);
939 notify_motion(struct weston_seat *seat,
940 uint32_t time, wl_fixed_t dx, wl_fixed_t dy)
942 struct weston_compositor *ec = seat->compositor;
943 struct weston_pointer *pointer = seat->pointer;
945 weston_compositor_wake(ec);
946 pointer->grab->interface->motion(pointer->grab, time, pointer->x + dx, pointer->y + dy);
950 run_modifier_bindings(struct weston_seat *seat, uint32_t old, uint32_t new)
952 struct weston_compositor *compositor = seat->compositor;
953 struct weston_keyboard *keyboard = seat->keyboard;
958 enum weston_keyboard_modifier weston;
960 { keyboard->xkb_info->ctrl_mod, MODIFIER_CTRL },
961 { keyboard->xkb_info->alt_mod, MODIFIER_ALT },
962 { keyboard->xkb_info->super_mod, MODIFIER_SUPER },
963 { keyboard->xkb_info->shift_mod, MODIFIER_SHIFT },
967 for (i = 0; i < ARRAY_LENGTH(mods); i++) {
968 if (diff & (1 << mods[i].xkb))
969 weston_compositor_run_modifier_binding(compositor,
972 WL_KEYBOARD_KEY_STATE_PRESSED);
976 for (i = 0; i < ARRAY_LENGTH(mods); i++) {
977 if (diff & (1 << mods[i].xkb))
978 weston_compositor_run_modifier_binding(compositor,
981 WL_KEYBOARD_KEY_STATE_RELEASED);
986 notify_motion_absolute(struct weston_seat *seat,
987 uint32_t time, wl_fixed_t x, wl_fixed_t y)
989 struct weston_compositor *ec = seat->compositor;
990 struct weston_pointer *pointer = seat->pointer;
992 weston_compositor_wake(ec);
993 pointer->grab->interface->motion(pointer->grab, time, x, y);
997 weston_surface_activate(struct weston_surface *surface,
998 struct weston_seat *seat)
1000 struct weston_compositor *compositor = seat->compositor;
1002 if (seat->keyboard) {
1003 weston_keyboard_set_focus(seat->keyboard, surface);
1004 wl_data_device_set_keyboard_focus(seat);
1007 wl_signal_emit(&compositor->activate_signal, surface);
1011 notify_button(struct weston_seat *seat, uint32_t time, int32_t button,
1012 enum wl_pointer_button_state state)
1014 struct weston_compositor *compositor = seat->compositor;
1015 struct weston_pointer *pointer = seat->pointer;
1017 if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
1018 weston_compositor_idle_inhibit(compositor);
1019 if (pointer->button_count == 0) {
1020 pointer->grab_button = button;
1021 pointer->grab_time = time;
1022 pointer->grab_x = pointer->x;
1023 pointer->grab_y = pointer->y;
1025 pointer->button_count++;
1027 weston_compositor_idle_release(compositor);
1028 pointer->button_count--;
1031 weston_compositor_run_button_binding(compositor, seat, time, button,
1034 pointer->grab->interface->button(pointer->grab, time, button, state);
1036 if (pointer->button_count == 1)
1037 pointer->grab_serial =
1038 wl_display_get_serial(compositor->wl_display);
1042 notify_axis(struct weston_seat *seat, uint32_t time, uint32_t axis,
1045 struct weston_compositor *compositor = seat->compositor;
1046 struct weston_pointer *pointer = seat->pointer;
1047 struct wl_resource *resource;
1048 struct wl_list *resource_list;
1050 weston_compositor_wake(compositor);
1055 if (weston_compositor_run_axis_binding(compositor, seat,
1059 resource_list = &pointer->focus_resource_list;
1060 wl_resource_for_each(resource, resource_list)
1061 wl_pointer_send_axis(resource, time, axis,
1066 weston_keyboard_set_locks(struct weston_keyboard *keyboard,
1067 uint32_t mask, uint32_t value)
1069 #ifdef ENABLE_XKBCOMMON
1071 xkb_mod_mask_t mods_depressed, mods_latched, mods_locked, group;
1072 xkb_mod_mask_t num, caps;
1074 /* We don't want the leds to go out of sync with the actual state
1075 * so if the backend has no way to change the leds don't try to
1076 * change the state */
1077 if (!keyboard->seat->led_update)
1080 mods_depressed = xkb_state_serialize_mods(keyboard->xkb_state.state,
1081 XKB_STATE_DEPRESSED);
1082 mods_latched = xkb_state_serialize_mods(keyboard->xkb_state.state,
1084 mods_locked = xkb_state_serialize_mods(keyboard->xkb_state.state,
1086 group = xkb_state_serialize_group(keyboard->xkb_state.state,
1087 XKB_STATE_EFFECTIVE);
1089 num = (1 << keyboard->xkb_info->mod2_mod);
1090 caps = (1 << keyboard->xkb_info->caps_mod);
1091 if (mask & WESTON_NUM_LOCK) {
1092 if (value & WESTON_NUM_LOCK)
1095 mods_locked &= ~num;
1097 if (mask & WESTON_CAPS_LOCK) {
1098 if (value & WESTON_CAPS_LOCK)
1099 mods_locked |= caps;
1101 mods_locked &= ~caps;
1104 xkb_state_update_mask(keyboard->xkb_state.state, mods_depressed,
1105 mods_latched, mods_locked, 0, 0, group);
1107 serial = wl_display_next_serial(
1108 keyboard->seat->compositor->wl_display);
1109 notify_modifiers(keyboard->seat, serial);
1117 #ifdef ENABLE_XKBCOMMON
1119 notify_modifiers(struct weston_seat *seat, uint32_t serial)
1121 struct weston_keyboard *keyboard = seat->keyboard;
1122 struct weston_keyboard_grab *grab = keyboard->grab;
1123 uint32_t mods_depressed, mods_latched, mods_locked, group;
1124 uint32_t mods_lookup;
1125 enum weston_led leds = 0;
1128 /* Serialize and update our internal state, checking to see if it's
1129 * different to the previous state. */
1130 mods_depressed = xkb_state_serialize_mods(keyboard->xkb_state.state,
1131 XKB_STATE_MODS_DEPRESSED);
1132 mods_latched = xkb_state_serialize_mods(keyboard->xkb_state.state,
1133 XKB_STATE_MODS_LATCHED);
1134 mods_locked = xkb_state_serialize_mods(keyboard->xkb_state.state,
1135 XKB_STATE_MODS_LOCKED);
1136 group = xkb_state_serialize_layout(keyboard->xkb_state.state,
1137 XKB_STATE_LAYOUT_EFFECTIVE);
1139 if (mods_depressed != seat->keyboard->modifiers.mods_depressed ||
1140 mods_latched != seat->keyboard->modifiers.mods_latched ||
1141 mods_locked != seat->keyboard->modifiers.mods_locked ||
1142 group != seat->keyboard->modifiers.group)
1145 run_modifier_bindings(seat, seat->keyboard->modifiers.mods_depressed,
1148 seat->keyboard->modifiers.mods_depressed = mods_depressed;
1149 seat->keyboard->modifiers.mods_latched = mods_latched;
1150 seat->keyboard->modifiers.mods_locked = mods_locked;
1151 seat->keyboard->modifiers.group = group;
1153 /* And update the modifier_state for bindings. */
1154 mods_lookup = mods_depressed | mods_latched;
1155 seat->modifier_state = 0;
1156 if (mods_lookup & (1 << keyboard->xkb_info->ctrl_mod))
1157 seat->modifier_state |= MODIFIER_CTRL;
1158 if (mods_lookup & (1 << keyboard->xkb_info->alt_mod))
1159 seat->modifier_state |= MODIFIER_ALT;
1160 if (mods_lookup & (1 << keyboard->xkb_info->super_mod))
1161 seat->modifier_state |= MODIFIER_SUPER;
1162 if (mods_lookup & (1 << keyboard->xkb_info->shift_mod))
1163 seat->modifier_state |= MODIFIER_SHIFT;
1165 /* Finally, notify the compositor that LEDs have changed. */
1166 if (xkb_state_led_index_is_active(keyboard->xkb_state.state,
1167 keyboard->xkb_info->num_led))
1168 leds |= LED_NUM_LOCK;
1169 if (xkb_state_led_index_is_active(keyboard->xkb_state.state,
1170 keyboard->xkb_info->caps_led))
1171 leds |= LED_CAPS_LOCK;
1172 if (xkb_state_led_index_is_active(keyboard->xkb_state.state,
1173 keyboard->xkb_info->scroll_led))
1174 leds |= LED_SCROLL_LOCK;
1175 if (leds != keyboard->xkb_state.leds && seat->led_update)
1176 seat->led_update(seat, leds);
1177 keyboard->xkb_state.leds = leds;
1180 grab->interface->modifiers(grab,
1182 keyboard->modifiers.mods_depressed,
1183 keyboard->modifiers.mods_latched,
1184 keyboard->modifiers.mods_locked,
1185 keyboard->modifiers.group);
1190 update_modifier_state(struct weston_seat *seat, uint32_t serial, uint32_t key,
1191 enum wl_keyboard_key_state state)
1193 struct weston_keyboard *keyboard = seat->keyboard;
1194 enum xkb_key_direction direction;
1196 /* Keyboard modifiers don't exist in raw keyboard mode */
1197 if (!seat->compositor->use_xkbcommon)
1200 if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
1201 direction = XKB_KEY_DOWN;
1203 direction = XKB_KEY_UP;
1205 /* Offset the keycode by 8, as the evdev XKB rules reflect X's
1206 * broken keycode system, which starts at 8. */
1207 xkb_state_update_key(keyboard->xkb_state.state, key + 8, direction);
1209 notify_modifiers(seat, serial);
1213 send_keymap(struct wl_resource *resource, struct weston_xkb_info *xkb_info)
1215 wl_keyboard_send_keymap(resource,
1216 WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
1217 xkb_info->keymap_fd,
1218 xkb_info->keymap_size);
1222 send_modifiers(struct wl_resource *resource, uint32_t serial, struct weston_keyboard *keyboard)
1224 wl_keyboard_send_modifiers(resource, serial,
1225 keyboard->modifiers.mods_depressed,
1226 keyboard->modifiers.mods_latched,
1227 keyboard->modifiers.mods_locked,
1228 keyboard->modifiers.group);
1231 static struct weston_xkb_info *
1232 weston_xkb_info_create(struct xkb_keymap *keymap);
1235 update_keymap(struct weston_seat *seat)
1237 struct weston_keyboard *keyboard = seat->keyboard;
1238 struct wl_resource *resource;
1239 struct weston_xkb_info *xkb_info;
1240 struct xkb_state *state;
1241 xkb_mod_mask_t latched_mods;
1242 xkb_mod_mask_t locked_mods;
1244 xkb_info = weston_xkb_info_create(keyboard->pending_keymap);
1246 xkb_keymap_unref(keyboard->pending_keymap);
1247 keyboard->pending_keymap = NULL;
1250 weston_log("failed to create XKB info\n");
1254 state = xkb_state_new(xkb_info->keymap);
1256 weston_log("failed to initialise XKB state\n");
1257 weston_xkb_info_destroy(xkb_info);
1261 latched_mods = xkb_state_serialize_mods(keyboard->xkb_state.state,
1262 XKB_STATE_MODS_LATCHED);
1263 locked_mods = xkb_state_serialize_mods(keyboard->xkb_state.state,
1264 XKB_STATE_MODS_LOCKED);
1265 xkb_state_update_mask(state,
1271 weston_xkb_info_destroy(keyboard->xkb_info);
1272 keyboard->xkb_info = xkb_info;
1274 xkb_state_unref(keyboard->xkb_state.state);
1275 keyboard->xkb_state.state = state;
1277 wl_resource_for_each(resource, &seat->keyboard->resource_list)
1278 send_keymap(resource, xkb_info);
1279 wl_resource_for_each(resource, &seat->keyboard->focus_resource_list)
1280 send_keymap(resource, xkb_info);
1282 notify_modifiers(seat, wl_display_next_serial(seat->compositor->wl_display));
1284 if (!latched_mods && !locked_mods)
1287 wl_resource_for_each(resource, &seat->keyboard->resource_list)
1288 send_modifiers(resource, wl_display_get_serial(seat->compositor->wl_display), seat->keyboard);
1289 wl_resource_for_each(resource, &seat->keyboard->focus_resource_list)
1290 send_modifiers(resource, wl_display_get_serial(seat->compositor->wl_display), seat->keyboard);
1294 notify_modifiers(struct weston_seat *seat, uint32_t serial)
1299 update_modifier_state(struct weston_seat *seat, uint32_t serial, uint32_t key,
1300 enum wl_keyboard_key_state state)
1305 update_keymap(struct weston_seat *seat)
1311 notify_key(struct weston_seat *seat, uint32_t time, uint32_t key,
1312 enum wl_keyboard_key_state state,
1313 enum weston_key_state_update update_state)
1315 struct weston_compositor *compositor = seat->compositor;
1316 struct weston_keyboard *keyboard = seat->keyboard;
1317 struct weston_keyboard_grab *grab = keyboard->grab;
1320 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
1321 weston_compositor_idle_inhibit(compositor);
1322 keyboard->grab_key = key;
1323 keyboard->grab_time = time;
1325 weston_compositor_idle_release(compositor);
1328 end = keyboard->keys.data + keyboard->keys.size;
1329 for (k = keyboard->keys.data; k < end; k++) {
1331 /* Ignore server-generated repeats. */
1332 if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
1337 keyboard->keys.size = (void *) end - keyboard->keys.data;
1338 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
1339 k = wl_array_add(&keyboard->keys, sizeof *k);
1343 if (grab == &keyboard->default_grab ||
1344 grab == &keyboard->input_method_grab) {
1345 weston_compositor_run_key_binding(compositor, seat, time, key,
1347 grab = keyboard->grab;
1350 grab->interface->key(grab, time, key, state);
1352 if (keyboard->pending_keymap &&
1353 keyboard->keys.size == 0)
1354 update_keymap(seat);
1356 if (update_state == STATE_UPDATE_AUTOMATIC) {
1357 update_modifier_state(seat,
1358 wl_display_get_serial(compositor->wl_display),
1365 notify_pointer_focus(struct weston_seat *seat, struct weston_output *output,
1366 wl_fixed_t x, wl_fixed_t y)
1369 weston_pointer_move(seat->pointer, x, y);
1371 /* FIXME: We should call weston_pointer_set_focus(seat,
1372 * NULL) here, but somehow that breaks re-entry... */
1377 destroy_device_saved_kbd_focus(struct wl_listener *listener, void *data)
1379 struct weston_seat *ws;
1381 ws = container_of(listener, struct weston_seat,
1382 saved_kbd_focus_listener);
1384 ws->saved_kbd_focus = NULL;
1388 notify_keyboard_focus_in(struct weston_seat *seat, struct wl_array *keys,
1389 enum weston_key_state_update update_state)
1391 struct weston_compositor *compositor = seat->compositor;
1392 struct weston_keyboard *keyboard = seat->keyboard;
1393 struct weston_surface *surface;
1394 uint32_t *k, serial;
1396 serial = wl_display_next_serial(compositor->wl_display);
1397 wl_array_copy(&keyboard->keys, keys);
1398 wl_array_for_each(k, &keyboard->keys) {
1399 weston_compositor_idle_inhibit(compositor);
1400 if (update_state == STATE_UPDATE_AUTOMATIC)
1401 update_modifier_state(seat, serial, *k,
1402 WL_KEYBOARD_KEY_STATE_PRESSED);
1405 /* Run key bindings after we've updated the state. */
1406 wl_array_for_each(k, &keyboard->keys) {
1407 weston_compositor_run_key_binding(compositor, seat, 0, *k,
1408 WL_KEYBOARD_KEY_STATE_PRESSED);
1411 surface = seat->saved_kbd_focus;
1414 wl_list_remove(&seat->saved_kbd_focus_listener.link);
1415 weston_keyboard_set_focus(keyboard, surface);
1416 seat->saved_kbd_focus = NULL;
1421 notify_keyboard_focus_out(struct weston_seat *seat)
1423 struct weston_compositor *compositor = seat->compositor;
1424 struct weston_keyboard *keyboard = seat->keyboard;
1425 uint32_t *k, serial;
1427 serial = wl_display_next_serial(compositor->wl_display);
1428 wl_array_for_each(k, &keyboard->keys) {
1429 weston_compositor_idle_release(compositor);
1430 update_modifier_state(seat, serial, *k,
1431 WL_KEYBOARD_KEY_STATE_RELEASED);
1434 seat->modifier_state = 0;
1436 if (keyboard->focus) {
1437 seat->saved_kbd_focus = keyboard->focus;
1438 seat->saved_kbd_focus_listener.notify =
1439 destroy_device_saved_kbd_focus;
1440 wl_signal_add(&keyboard->focus->destroy_signal,
1441 &seat->saved_kbd_focus_listener);
1444 weston_keyboard_set_focus(keyboard, NULL);
1445 weston_keyboard_cancel_grab(keyboard);
1447 weston_pointer_cancel_grab(seat->pointer);
1451 weston_touch_set_focus(struct weston_seat *seat, struct weston_view *view)
1453 struct wl_list *focus_resource_list;
1455 focus_resource_list = &seat->touch->focus_resource_list;
1457 if (view && seat->touch->focus &&
1458 seat->touch->focus->surface == view->surface) {
1459 seat->touch->focus = view;
1463 wl_list_remove(&seat->touch->focus_resource_listener.link);
1464 wl_list_init(&seat->touch->focus_resource_listener.link);
1465 wl_list_remove(&seat->touch->focus_view_listener.link);
1466 wl_list_init(&seat->touch->focus_view_listener.link);
1468 if (!wl_list_empty(focus_resource_list)) {
1469 move_resources(&seat->touch->resource_list,
1470 focus_resource_list);
1474 struct wl_client *surface_client;
1476 if (!view->surface->resource) {
1477 seat->touch->focus = NULL;
1481 surface_client = wl_resource_get_client(view->surface->resource);
1482 move_resources_for_client(focus_resource_list,
1483 &seat->touch->resource_list,
1485 wl_resource_add_destroy_listener(view->surface->resource,
1486 &seat->touch->focus_resource_listener);
1487 wl_signal_add(&view->destroy_signal, &seat->touch->focus_view_listener);
1489 seat->touch->focus = view;
1493 * notify_touch - emulates button touches and notifies surfaces accordingly.
1495 * It assumes always the correct cycle sequence until it gets here: touch_down
1496 * → touch_update → ... → touch_update → touch_end. The driver is responsible
1497 * for sending along such order.
1501 notify_touch(struct weston_seat *seat, uint32_t time, int touch_id,
1502 wl_fixed_t x, wl_fixed_t y, int touch_type)
1504 struct weston_compositor *ec = seat->compositor;
1505 struct weston_touch *touch = seat->touch;
1506 struct weston_touch_grab *grab = touch->grab;
1507 struct weston_view *ev;
1510 /* Update grab's global coordinates. */
1511 if (touch_id == touch->grab_touch_id && touch_type != WL_TOUCH_UP) {
1516 switch (touch_type) {
1518 weston_compositor_idle_inhibit(ec);
1522 /* the first finger down picks the view, and all further go
1523 * to that view for the remainder of the touch session i.e.
1524 * until all touch points are up again. */
1525 if (touch->num_tp == 1) {
1526 ev = weston_compositor_pick_view(ec, x, y, &sx, &sy);
1527 weston_touch_set_focus(seat, ev);
1528 } else if (touch->focus) {
1530 weston_view_from_global_fixed(ev, x, y, &sx, &sy);
1532 /* Unexpected condition: We have non-initial touch but
1533 * there is no focused surface.
1535 weston_log("touch event received with %d points down"
1536 "but no surface focused\n", touch->num_tp);
1540 weston_compositor_run_touch_binding(ec, seat,
1543 grab->interface->down(grab, time, touch_id, sx, sy);
1544 if (touch->num_tp == 1) {
1545 touch->grab_serial =
1546 wl_display_get_serial(ec->wl_display);
1547 touch->grab_touch_id = touch_id;
1548 touch->grab_time = time;
1554 case WL_TOUCH_MOTION:
1559 weston_view_from_global_fixed(ev, x, y, &sx, &sy);
1560 grab->interface->motion(grab, time, touch_id, sx, sy);
1563 if (touch->num_tp == 0) {
1564 /* This can happen if we start out with one or
1565 * more fingers on the touch screen, in which
1566 * case we didn't get the corresponding down
1568 weston_log("unmatched touch up event\n");
1571 weston_compositor_idle_release(ec);
1574 grab->interface->up(grab, time, touch_id);
1575 if (touch->num_tp == 0)
1576 weston_touch_set_focus(seat, NULL);
1582 notify_touch_frame(struct weston_seat *seat)
1584 struct weston_touch *touch = seat->touch;
1585 struct weston_touch_grab *grab = touch->grab;
1587 grab->interface->frame(grab);
1591 pointer_cursor_surface_configure(struct weston_surface *es,
1592 int32_t dx, int32_t dy)
1594 struct weston_pointer *pointer = es->configure_private;
1600 assert(es == pointer->sprite->surface);
1602 pointer->hotspot_x -= dx;
1603 pointer->hotspot_y -= dy;
1605 x = wl_fixed_to_int(pointer->x) - pointer->hotspot_x;
1606 y = wl_fixed_to_int(pointer->y) - pointer->hotspot_y;
1608 weston_view_set_position(pointer->sprite, x, y);
1610 empty_region(&es->pending.input);
1611 empty_region(&es->input);
1613 if (!weston_surface_is_mapped(es)) {
1614 weston_layer_entry_insert(&es->compositor->cursor_layer.view_list,
1615 &pointer->sprite->layer_link);
1616 weston_view_update_transform(pointer->sprite);
1621 pointer_set_cursor(struct wl_client *client, struct wl_resource *resource,
1622 uint32_t serial, struct wl_resource *surface_resource,
1623 int32_t x, int32_t y)
1625 struct weston_pointer *pointer = wl_resource_get_user_data(resource);
1626 struct weston_surface *surface = NULL;
1628 if (surface_resource)
1629 surface = wl_resource_get_user_data(surface_resource);
1631 if (pointer->focus == NULL)
1633 /* pointer->focus->surface->resource can be NULL. Surfaces like the
1634 black_surface used in shell.c for fullscreen don't have
1635 a resource, but can still have focus */
1636 if (pointer->focus->surface->resource == NULL)
1638 if (wl_resource_get_client(pointer->focus->surface->resource) != client)
1640 if (pointer->focus_serial - serial > UINT32_MAX / 2)
1643 if (surface && pointer->sprite && surface != pointer->sprite->surface) {
1644 if (surface->configure) {
1645 wl_resource_post_error(surface->resource,
1646 WL_DISPLAY_ERROR_INVALID_OBJECT,
1647 "surface->configure already "
1653 if (pointer->sprite)
1654 pointer_unmap_sprite(pointer);
1659 wl_signal_add(&surface->destroy_signal,
1660 &pointer->sprite_destroy_listener);
1662 surface->configure = pointer_cursor_surface_configure;
1663 surface->configure_private = pointer;
1664 pointer->sprite = weston_view_create(surface);
1665 pointer->hotspot_x = x;
1666 pointer->hotspot_y = y;
1668 if (surface->buffer_ref.buffer) {
1669 pointer_cursor_surface_configure(surface, 0, 0);
1670 weston_view_schedule_repaint(pointer->sprite);
1675 pointer_release(struct wl_client *client, struct wl_resource *resource)
1677 wl_resource_destroy(resource);
1680 static const struct wl_pointer_interface pointer_interface = {
1686 seat_get_pointer(struct wl_client *client, struct wl_resource *resource,
1689 struct weston_seat *seat = wl_resource_get_user_data(resource);
1690 struct wl_resource *cr;
1695 cr = wl_resource_create(client, &wl_pointer_interface,
1696 wl_resource_get_version(resource), id);
1698 wl_client_post_no_memory(client);
1702 /* May be moved to focused list later by either
1703 * weston_pointer_set_focus or directly if this client is already
1705 wl_list_insert(&seat->pointer->resource_list, wl_resource_get_link(cr));
1706 wl_resource_set_implementation(cr, &pointer_interface, seat->pointer,
1709 if (seat->pointer->focus && seat->pointer->focus->surface->resource &&
1710 wl_resource_get_client(seat->pointer->focus->surface->resource) == client) {
1713 weston_view_from_global_fixed(seat->pointer->focus,
1718 wl_list_remove(wl_resource_get_link(cr));
1719 wl_list_insert(&seat->pointer->focus_resource_list,
1720 wl_resource_get_link(cr));
1721 wl_pointer_send_enter(cr,
1722 seat->pointer->focus_serial,
1723 seat->pointer->focus->surface->resource,
1729 keyboard_release(struct wl_client *client, struct wl_resource *resource)
1731 wl_resource_destroy(resource);
1734 static const struct wl_keyboard_interface keyboard_interface = {
1739 should_send_modifiers_to_client(struct weston_seat *seat,
1740 struct wl_client *client)
1742 if (seat->keyboard &&
1743 seat->keyboard->focus &&
1744 seat->keyboard->focus->resource &&
1745 wl_resource_get_client(seat->keyboard->focus->resource) == client)
1748 if (seat->pointer &&
1749 seat->pointer->focus &&
1750 seat->pointer->focus->surface->resource &&
1751 wl_resource_get_client(seat->pointer->focus->surface->resource) == client)
1758 seat_get_keyboard(struct wl_client *client, struct wl_resource *resource,
1761 struct weston_seat *seat = wl_resource_get_user_data(resource);
1762 struct weston_keyboard *keyboard = seat->keyboard;
1763 struct wl_resource *cr;
1765 if (!seat->keyboard)
1768 cr = wl_resource_create(client, &wl_keyboard_interface,
1769 wl_resource_get_version(resource), id);
1771 wl_client_post_no_memory(client);
1775 /* May be moved to focused list later by either
1776 * weston_keyboard_set_focus or directly if this client is already
1778 wl_list_insert(&seat->keyboard->resource_list, wl_resource_get_link(cr));
1779 wl_resource_set_implementation(cr, &keyboard_interface,
1780 seat, unbind_resource);
1782 if (wl_resource_get_version(cr) >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION) {
1783 wl_keyboard_send_repeat_info(cr,
1784 seat->compositor->kb_repeat_rate,
1785 seat->compositor->kb_repeat_delay);
1788 if (seat->compositor->use_xkbcommon) {
1789 wl_keyboard_send_keymap(cr, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
1790 keyboard->xkb_info->keymap_fd,
1791 keyboard->xkb_info->keymap_size);
1793 int null_fd = open("/dev/null", O_RDONLY);
1794 wl_keyboard_send_keymap(cr, WL_KEYBOARD_KEYMAP_FORMAT_NO_KEYMAP,
1800 if (should_send_modifiers_to_client(seat, client)) {
1801 send_modifiers_to_resource(seat->keyboard,
1803 seat->keyboard->focus_serial);
1806 if (seat->keyboard->focus &&
1807 wl_resource_get_client(seat->keyboard->focus->resource) == client) {
1808 struct weston_surface *surface =
1809 (struct weston_surface *) seat->keyboard->focus;
1811 wl_list_remove(wl_resource_get_link(cr));
1812 wl_list_insert(&seat->keyboard->focus_resource_list,
1813 wl_resource_get_link(cr));
1814 wl_keyboard_send_enter(cr,
1815 seat->keyboard->focus_serial,
1817 &seat->keyboard->keys);
1819 /* If this is the first keyboard resource for this
1821 if (seat->keyboard->focus_resource_list.prev ==
1822 wl_resource_get_link(cr))
1823 wl_data_device_set_keyboard_focus(seat);
1828 touch_release(struct wl_client *client, struct wl_resource *resource)
1830 wl_resource_destroy(resource);
1833 static const struct wl_touch_interface touch_interface = {
1838 seat_get_touch(struct wl_client *client, struct wl_resource *resource,
1841 struct weston_seat *seat = wl_resource_get_user_data(resource);
1842 struct wl_resource *cr;
1847 cr = wl_resource_create(client, &wl_touch_interface,
1848 wl_resource_get_version(resource), id);
1850 wl_client_post_no_memory(client);
1854 if (seat->touch->focus &&
1855 wl_resource_get_client(seat->touch->focus->surface->resource) == client) {
1856 wl_list_insert(&seat->touch->resource_list,
1857 wl_resource_get_link(cr));
1859 wl_list_insert(&seat->touch->focus_resource_list,
1860 wl_resource_get_link(cr));
1862 wl_resource_set_implementation(cr, &touch_interface,
1863 seat, unbind_resource);
1866 static const struct wl_seat_interface seat_interface = {
1873 bind_seat(struct wl_client *client, void *data, uint32_t version, uint32_t id)
1875 struct weston_seat *seat = data;
1876 struct wl_resource *resource;
1877 enum wl_seat_capability caps = 0;
1879 resource = wl_resource_create(client,
1880 &wl_seat_interface, MIN(version, 4), id);
1881 wl_list_insert(&seat->base_resource_list, wl_resource_get_link(resource));
1882 wl_resource_set_implementation(resource, &seat_interface, data,
1886 caps |= WL_SEAT_CAPABILITY_POINTER;
1888 caps |= WL_SEAT_CAPABILITY_KEYBOARD;
1890 caps |= WL_SEAT_CAPABILITY_TOUCH;
1892 wl_seat_send_capabilities(resource, caps);
1893 if (version >= WL_SEAT_NAME_SINCE_VERSION)
1894 wl_seat_send_name(resource, seat->seat_name);
1897 #ifdef ENABLE_XKBCOMMON
1899 weston_compositor_xkb_init(struct weston_compositor *ec,
1900 struct xkb_rule_names *names)
1902 ec->use_xkbcommon = 1;
1904 if (ec->xkb_context == NULL) {
1905 ec->xkb_context = xkb_context_new(0);
1906 if (ec->xkb_context == NULL) {
1907 weston_log("failed to create XKB context\n");
1913 ec->xkb_names = *names;
1914 if (!ec->xkb_names.rules)
1915 ec->xkb_names.rules = strdup("evdev");
1916 if (!ec->xkb_names.model)
1917 ec->xkb_names.model = strdup("pc105");
1918 if (!ec->xkb_names.layout)
1919 ec->xkb_names.layout = strdup("us");
1925 weston_xkb_info_destroy(struct weston_xkb_info *xkb_info)
1927 if (--xkb_info->ref_count > 0)
1930 xkb_keymap_unref(xkb_info->keymap);
1932 if (xkb_info->keymap_area)
1933 munmap(xkb_info->keymap_area, xkb_info->keymap_size);
1934 if (xkb_info->keymap_fd >= 0)
1935 close(xkb_info->keymap_fd);
1940 weston_compositor_xkb_destroy(struct weston_compositor *ec)
1943 * If we're operating in raw keyboard mode, we never initialized
1944 * libxkbcommon so there's no cleanup to do either.
1946 if (!ec->use_xkbcommon)
1949 free((char *) ec->xkb_names.rules);
1950 free((char *) ec->xkb_names.model);
1951 free((char *) ec->xkb_names.layout);
1952 free((char *) ec->xkb_names.variant);
1953 free((char *) ec->xkb_names.options);
1956 weston_xkb_info_destroy(ec->xkb_info);
1957 xkb_context_unref(ec->xkb_context);
1960 static struct weston_xkb_info *
1961 weston_xkb_info_create(struct xkb_keymap *keymap)
1963 struct weston_xkb_info *xkb_info = zalloc(sizeof *xkb_info);
1964 if (xkb_info == NULL)
1967 xkb_info->keymap = xkb_keymap_ref(keymap);
1968 xkb_info->ref_count = 1;
1972 xkb_info->shift_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1973 XKB_MOD_NAME_SHIFT);
1974 xkb_info->caps_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1976 xkb_info->ctrl_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1978 xkb_info->alt_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1980 xkb_info->mod2_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1982 xkb_info->mod3_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1984 xkb_info->super_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1986 xkb_info->mod5_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
1989 xkb_info->num_led = xkb_keymap_led_get_index(xkb_info->keymap,
1991 xkb_info->caps_led = xkb_keymap_led_get_index(xkb_info->keymap,
1993 xkb_info->scroll_led = xkb_keymap_led_get_index(xkb_info->keymap,
1994 XKB_LED_NAME_SCROLL);
1996 keymap_str = xkb_keymap_get_as_string(xkb_info->keymap,
1997 XKB_KEYMAP_FORMAT_TEXT_V1);
1998 if (keymap_str == NULL) {
1999 weston_log("failed to get string version of keymap\n");
2002 xkb_info->keymap_size = strlen(keymap_str) + 1;
2004 xkb_info->keymap_fd = os_create_anonymous_file(xkb_info->keymap_size);
2005 if (xkb_info->keymap_fd < 0) {
2006 weston_log("creating a keymap file for %lu bytes failed: %m\n",
2007 (unsigned long) xkb_info->keymap_size);
2008 goto err_keymap_str;
2011 xkb_info->keymap_area = mmap(NULL, xkb_info->keymap_size,
2012 PROT_READ | PROT_WRITE,
2013 MAP_SHARED, xkb_info->keymap_fd, 0);
2014 if (xkb_info->keymap_area == MAP_FAILED) {
2015 weston_log("failed to mmap() %lu bytes\n",
2016 (unsigned long) xkb_info->keymap_size);
2019 strcpy(xkb_info->keymap_area, keymap_str);
2025 close(xkb_info->keymap_fd);
2029 xkb_keymap_unref(xkb_info->keymap);
2035 weston_compositor_build_global_keymap(struct weston_compositor *ec)
2037 struct xkb_keymap *keymap;
2039 if (ec->xkb_info != NULL)
2042 keymap = xkb_keymap_new_from_names(ec->xkb_context,
2045 if (keymap == NULL) {
2046 weston_log("failed to compile global XKB keymap\n");
2047 weston_log(" tried rules %s, model %s, layout %s, variant %s, "
2049 ec->xkb_names.rules, ec->xkb_names.model,
2050 ec->xkb_names.layout, ec->xkb_names.variant,
2051 ec->xkb_names.options);
2055 ec->xkb_info = weston_xkb_info_create(keymap);
2056 xkb_keymap_unref(keymap);
2057 if (ec->xkb_info == NULL)
2064 weston_compositor_xkb_init(struct weston_compositor *ec,
2065 struct xkb_rule_names *names)
2071 weston_compositor_xkb_destroy(struct weston_compositor *ec)
2077 weston_seat_update_keymap(struct weston_seat *seat, struct xkb_keymap *keymap)
2079 if (!seat->keyboard || !keymap)
2082 #ifdef ENABLE_XKBCOMMON
2083 if (!seat->compositor->use_xkbcommon)
2086 xkb_keymap_unref(seat->keyboard->pending_keymap);
2087 seat->keyboard->pending_keymap = xkb_keymap_ref(keymap);
2089 if (seat->keyboard->keys.size == 0)
2090 update_keymap(seat);
2095 weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap)
2097 struct weston_keyboard *keyboard;
2099 if (seat->keyboard) {
2100 seat->keyboard_device_count += 1;
2101 if (seat->keyboard_device_count == 1)
2102 seat_send_updated_caps(seat);
2106 keyboard = weston_keyboard_create();
2107 if (keyboard == NULL) {
2108 weston_log("failed to allocate weston keyboard struct\n");
2112 #ifdef ENABLE_XKBCOMMON
2113 if (seat->compositor->use_xkbcommon) {
2114 if (keymap != NULL) {
2115 keyboard->xkb_info = weston_xkb_info_create(keymap);
2116 if (keyboard->xkb_info == NULL)
2119 if (weston_compositor_build_global_keymap(seat->compositor) < 0)
2121 keyboard->xkb_info = seat->compositor->xkb_info;
2122 keyboard->xkb_info->ref_count++;
2125 keyboard->xkb_state.state = xkb_state_new(keyboard->xkb_info->keymap);
2126 if (keyboard->xkb_state.state == NULL) {
2127 weston_log("failed to initialise XKB state\n");
2131 keyboard->xkb_state.leds = 0;
2135 seat->keyboard = keyboard;
2136 seat->keyboard_device_count = 1;
2137 keyboard->seat = seat;
2139 seat_send_updated_caps(seat);
2144 if (keyboard->xkb_info)
2145 weston_xkb_info_destroy(keyboard->xkb_info);
2152 weston_keyboard_reset_state(struct weston_keyboard *keyboard)
2154 struct weston_seat *seat = keyboard->seat;
2155 struct xkb_state *state;
2157 #ifdef ENABLE_XKBCOMMON
2158 if (seat->compositor->use_xkbcommon) {
2159 state = xkb_state_new(keyboard->xkb_info->keymap);
2161 weston_log("failed to reset XKB state\n");
2164 xkb_state_unref(keyboard->xkb_state.state);
2165 keyboard->xkb_state.state = state;
2167 keyboard->xkb_state.leds = 0;
2171 seat->modifier_state = 0;
2175 weston_seat_release_keyboard(struct weston_seat *seat)
2177 seat->keyboard_device_count--;
2178 if (seat->keyboard_device_count == 0) {
2179 weston_keyboard_set_focus(seat->keyboard, NULL);
2180 weston_keyboard_cancel_grab(seat->keyboard);
2181 weston_keyboard_reset_state(seat->keyboard);
2182 seat_send_updated_caps(seat);
2187 weston_seat_init_pointer(struct weston_seat *seat)
2189 struct weston_pointer *pointer;
2191 if (seat->pointer) {
2192 seat->pointer_device_count += 1;
2193 if (seat->pointer_device_count == 1)
2194 seat_send_updated_caps(seat);
2198 pointer = weston_pointer_create(seat);
2199 if (pointer == NULL)
2202 seat->pointer = pointer;
2203 seat->pointer_device_count = 1;
2204 pointer->seat = seat;
2206 seat_send_updated_caps(seat);
2210 weston_seat_release_pointer(struct weston_seat *seat)
2212 struct weston_pointer *pointer = seat->pointer;
2214 seat->pointer_device_count--;
2215 if (seat->pointer_device_count == 0) {
2216 weston_pointer_set_focus(pointer, NULL,
2217 wl_fixed_from_int(0),
2218 wl_fixed_from_int(0));
2219 weston_pointer_cancel_grab(pointer);
2221 if (pointer->sprite)
2222 pointer_unmap_sprite(pointer);
2224 weston_pointer_reset_state(pointer);
2225 seat_send_updated_caps(seat);
2230 weston_seat_init_touch(struct weston_seat *seat)
2232 struct weston_touch *touch;
2235 seat->touch_device_count += 1;
2236 if (seat->touch_device_count == 1)
2237 seat_send_updated_caps(seat);
2241 touch = weston_touch_create();
2245 seat->touch = touch;
2246 seat->touch_device_count = 1;
2249 seat_send_updated_caps(seat);
2253 weston_seat_release_touch(struct weston_seat *seat)
2255 seat->touch_device_count--;
2256 if (seat->touch_device_count == 0) {
2257 weston_touch_set_focus(seat, NULL);
2258 weston_touch_cancel_grab(seat->touch);
2259 weston_touch_reset_state(seat->touch);
2260 seat_send_updated_caps(seat);
2265 weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec,
2266 const char *seat_name)
2268 memset(seat, 0, sizeof *seat);
2270 seat->selection_data_source = NULL;
2271 wl_list_init(&seat->base_resource_list);
2272 wl_signal_init(&seat->selection_signal);
2273 wl_list_init(&seat->drag_resource_list);
2274 wl_signal_init(&seat->destroy_signal);
2275 wl_signal_init(&seat->updated_caps_signal);
2277 seat->global = wl_global_create(ec->wl_display, &wl_seat_interface, 4,
2280 seat->compositor = ec;
2281 seat->modifier_state = 0;
2282 seat->seat_name = strdup(seat_name);
2284 wl_list_insert(ec->seat_list.prev, &seat->link);
2286 clipboard_create(seat);
2288 wl_signal_emit(&ec->seat_created_signal, seat);
2292 weston_seat_release(struct weston_seat *seat)
2294 wl_list_remove(&seat->link);
2296 if (seat->saved_kbd_focus)
2297 wl_list_remove(&seat->saved_kbd_focus_listener.link);
2300 weston_pointer_destroy(seat->pointer);
2302 weston_keyboard_destroy(seat->keyboard);
2304 weston_touch_destroy(seat->touch);
2306 free (seat->seat_name);
2308 wl_global_destroy(seat->global);
2310 wl_signal_emit(&seat->destroy_signal, seat);