2 * Copyright © 2013 Intel Corporation
3 * Copyright 2017-2018 Collabora, Ltd.
4 * Copyright 2017-2018 General Electric Company
6 * Permission is hereby granted, free of charge, to any person obtaining
7 * a copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sublicense, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial
16 * portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
22 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
23 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
41 #include "shared/helpers.h"
42 #include "shared/os-compatibility.h"
43 #include "shared/timespec-util.h"
44 #include "compositor.h"
45 #include "relative-pointer-unstable-v1-server-protocol.h"
46 #include "pointer-constraints-unstable-v1-server-protocol.h"
47 #include "input-timestamps-unstable-v1-server-protocol.h"
49 enum pointer_constraint_type {
50 POINTER_CONSTRAINT_TYPE_LOCK,
51 POINTER_CONSTRAINT_TYPE_CONFINE,
54 enum motion_direction {
55 MOTION_DIRECTION_POSITIVE_X = 1 << 0,
56 MOTION_DIRECTION_NEGATIVE_X = 1 << 1,
57 MOTION_DIRECTION_POSITIVE_Y = 1 << 2,
58 MOTION_DIRECTION_NEGATIVE_Y = 1 << 3,
72 enum motion_direction blocking_dir;
76 maybe_warp_confined_pointer(struct weston_pointer_constraint *constraint);
79 empty_region(pixman_region32_t *region)
81 pixman_region32_fini(region);
82 pixman_region32_init(region);
86 region_init_infinite(pixman_region32_t *region)
88 pixman_region32_init_rect(region, INT32_MIN, INT32_MIN,
89 UINT32_MAX, UINT32_MAX);
93 send_timestamp(struct wl_resource *resource,
94 const struct timespec *time)
96 uint32_t tv_sec_hi, tv_sec_lo, tv_nsec;
98 timespec_to_proto(time, &tv_sec_hi, &tv_sec_lo, &tv_nsec);
99 zwp_input_timestamps_v1_send_timestamp(resource, tv_sec_hi, tv_sec_lo,
104 send_timestamps_for_input_resource(struct wl_resource *input_resource,
105 struct wl_list *list,
106 const struct timespec *time)
108 struct wl_resource *resource;
110 wl_resource_for_each(resource, list) {
111 if (wl_resource_get_user_data(resource) == input_resource)
112 send_timestamp(resource, time);
117 remove_input_resource_from_timestamps(struct wl_resource *input_resource,
118 struct wl_list *list)
120 struct wl_resource *resource;
122 wl_resource_for_each(resource, list) {
123 if (wl_resource_get_user_data(resource) == input_resource)
124 wl_resource_set_user_data(resource, NULL);
128 /** Register a touchscreen input device
130 * \param touch The parent weston_touch that identifies the seat.
131 * \param syspath Unique device name.
132 * \param backend_data Backend private data if necessary.
133 * \param ops Calibration operations, or NULL for not able to run calibration.
134 * \return New touch device, or NULL on failure.
136 WL_EXPORT struct weston_touch_device *
137 weston_touch_create_touch_device(struct weston_touch *touch,
140 const struct weston_touch_device_ops *ops)
142 struct weston_touch_device *device;
146 assert(ops->get_output);
147 assert(ops->get_calibration_head_name);
148 assert(ops->get_calibration);
149 assert(ops->set_calibration);
152 device = zalloc(sizeof *device);
156 wl_signal_init(&device->destroy_signal);
158 device->syspath = strdup(syspath);
159 if (!device->syspath) {
164 device->backend_data = backend_data;
167 device->aggregate = touch;
168 wl_list_insert(touch->device_list.prev, &device->link);
173 /** Destroy the touch device. */
175 weston_touch_device_destroy(struct weston_touch_device *device)
177 wl_list_remove(&device->link);
178 wl_signal_emit(&device->destroy_signal, device);
179 free(device->syspath);
183 /** Is it possible to run calibration on this touch device? */
185 weston_touch_device_can_calibrate(struct weston_touch_device *device)
187 return !!device->ops;
190 static struct weston_pointer_client *
191 weston_pointer_client_create(struct wl_client *client)
193 struct weston_pointer_client *pointer_client;
195 pointer_client = zalloc(sizeof *pointer_client);
199 pointer_client->client = client;
200 wl_list_init(&pointer_client->pointer_resources);
201 wl_list_init(&pointer_client->relative_pointer_resources);
203 return pointer_client;
207 weston_pointer_client_destroy(struct weston_pointer_client *pointer_client)
209 struct wl_resource *resource;
211 wl_resource_for_each(resource, &pointer_client->pointer_resources) {
212 wl_resource_set_user_data(resource, NULL);
215 wl_resource_for_each(resource,
216 &pointer_client->relative_pointer_resources) {
217 wl_resource_set_user_data(resource, NULL);
220 wl_list_remove(&pointer_client->pointer_resources);
221 wl_list_remove(&pointer_client->relative_pointer_resources);
222 free(pointer_client);
226 weston_pointer_client_is_empty(struct weston_pointer_client *pointer_client)
228 return (wl_list_empty(&pointer_client->pointer_resources) &&
229 wl_list_empty(&pointer_client->relative_pointer_resources));
232 static struct weston_pointer_client *
233 weston_pointer_get_pointer_client(struct weston_pointer *pointer,
234 struct wl_client *client)
236 struct weston_pointer_client *pointer_client;
238 wl_list_for_each(pointer_client, &pointer->pointer_clients, link) {
239 if (pointer_client->client == client)
240 return pointer_client;
246 static struct weston_pointer_client *
247 weston_pointer_ensure_pointer_client(struct weston_pointer *pointer,
248 struct wl_client *client)
250 struct weston_pointer_client *pointer_client;
252 pointer_client = weston_pointer_get_pointer_client(pointer, client);
254 return pointer_client;
256 pointer_client = weston_pointer_client_create(client);
257 wl_list_insert(&pointer->pointer_clients, &pointer_client->link);
259 if (pointer->focus &&
260 pointer->focus->surface->resource &&
261 wl_resource_get_client(pointer->focus->surface->resource) == client) {
262 pointer->focus_client = pointer_client;
265 return pointer_client;
269 weston_pointer_cleanup_pointer_client(struct weston_pointer *pointer,
270 struct weston_pointer_client *pointer_client)
272 if (weston_pointer_client_is_empty(pointer_client)) {
273 if (pointer->focus_client == pointer_client)
274 pointer->focus_client = NULL;
275 wl_list_remove(&pointer_client->link);
276 weston_pointer_client_destroy(pointer_client);
281 unbind_pointer_client_resource(struct wl_resource *resource)
283 struct weston_pointer *pointer = wl_resource_get_user_data(resource);
284 struct wl_client *client = wl_resource_get_client(resource);
285 struct weston_pointer_client *pointer_client;
287 wl_list_remove(wl_resource_get_link(resource));
290 pointer_client = weston_pointer_get_pointer_client(pointer,
292 assert(pointer_client);
293 remove_input_resource_from_timestamps(resource,
294 &pointer->timestamps_list);
295 weston_pointer_cleanup_pointer_client(pointer, pointer_client);
299 static void unbind_resource(struct wl_resource *resource)
301 wl_list_remove(wl_resource_get_link(resource));
305 weston_pointer_motion_to_abs(struct weston_pointer *pointer,
306 struct weston_pointer_motion_event *event,
307 wl_fixed_t *x, wl_fixed_t *y)
309 if (event->mask & WESTON_POINTER_MOTION_ABS) {
310 *x = wl_fixed_from_double(event->x);
311 *y = wl_fixed_from_double(event->y);
312 } else if (event->mask & WESTON_POINTER_MOTION_REL) {
313 *x = pointer->x + wl_fixed_from_double(event->dx);
314 *y = pointer->y + wl_fixed_from_double(event->dy);
316 assert(!"invalid motion event");
322 weston_pointer_motion_to_rel(struct weston_pointer *pointer,
323 struct weston_pointer_motion_event *event,
324 double *dx, double *dy,
325 double *dx_unaccel, double *dy_unaccel)
327 if (event->mask & WESTON_POINTER_MOTION_REL &&
328 event->mask & WESTON_POINTER_MOTION_REL_UNACCEL) {
331 *dx_unaccel = event->dx_unaccel;
332 *dy_unaccel = event->dy_unaccel;
334 } else if (event->mask & WESTON_POINTER_MOTION_REL) {
335 *dx_unaccel = *dx = event->dx;
336 *dy_unaccel = *dy = event->dy;
338 } else if (event->mask & WESTON_POINTER_MOTION_REL_UNACCEL) {
339 *dx_unaccel = *dx = event->dx_unaccel;
340 *dy_unaccel = *dy = event->dy_unaccel;
348 weston_seat_repick(struct weston_seat *seat)
350 const struct weston_pointer *pointer = weston_seat_get_pointer(seat);
355 pointer->grab->interface->focus(pointer->grab);
359 weston_compositor_idle_inhibit(struct weston_compositor *compositor)
361 weston_compositor_wake(compositor);
362 compositor->idle_inhibit++;
366 weston_compositor_idle_release(struct weston_compositor *compositor)
368 compositor->idle_inhibit--;
369 weston_compositor_wake(compositor);
373 pointer_focus_view_destroyed(struct wl_listener *listener, void *data)
375 struct weston_pointer *pointer =
376 container_of(listener, struct weston_pointer,
377 focus_view_listener);
379 weston_pointer_clear_focus(pointer);
383 pointer_focus_resource_destroyed(struct wl_listener *listener, void *data)
385 struct weston_pointer *pointer =
386 container_of(listener, struct weston_pointer,
387 focus_resource_listener);
389 weston_pointer_clear_focus(pointer);
393 keyboard_focus_resource_destroyed(struct wl_listener *listener, void *data)
395 struct weston_keyboard *keyboard =
396 container_of(listener, struct weston_keyboard,
397 focus_resource_listener);
399 weston_keyboard_set_focus(keyboard, NULL);
403 touch_focus_view_destroyed(struct wl_listener *listener, void *data)
405 struct weston_touch *touch =
406 container_of(listener, struct weston_touch,
407 focus_view_listener);
409 weston_touch_set_focus(touch, NULL);
413 touch_focus_resource_destroyed(struct wl_listener *listener, void *data)
415 struct weston_touch *touch =
416 container_of(listener, struct weston_touch,
417 focus_resource_listener);
419 weston_touch_set_focus(touch, NULL);
423 move_resources(struct wl_list *destination, struct wl_list *source)
425 wl_list_insert_list(destination, source);
426 wl_list_init(source);
430 move_resources_for_client(struct wl_list *destination,
431 struct wl_list *source,
432 struct wl_client *client)
434 struct wl_resource *resource, *tmp;
435 wl_resource_for_each_safe(resource, tmp, source) {
436 if (wl_resource_get_client(resource) == client) {
437 wl_list_remove(wl_resource_get_link(resource));
438 wl_list_insert(destination,
439 wl_resource_get_link(resource));
445 default_grab_pointer_focus(struct weston_pointer_grab *grab)
447 struct weston_pointer *pointer = grab->pointer;
448 struct weston_view *view;
451 if (pointer->button_count > 0)
454 view = weston_compositor_pick_view(pointer->seat->compositor,
455 pointer->x, pointer->y,
458 if (pointer->focus != view || pointer->sx != sx || pointer->sy != sy)
459 weston_pointer_set_focus(pointer, view, sx, sy);
463 pointer_send_relative_motion(struct weston_pointer *pointer,
464 const struct timespec *time,
465 struct weston_pointer_motion_event *event)
468 double dx, dy, dx_unaccel, dy_unaccel;
469 wl_fixed_t dxf, dyf, dxf_unaccel, dyf_unaccel;
470 struct wl_list *resource_list;
471 struct wl_resource *resource;
473 if (!pointer->focus_client)
476 if (!weston_pointer_motion_to_rel(pointer, event,
478 &dx_unaccel, &dy_unaccel))
481 resource_list = &pointer->focus_client->relative_pointer_resources;
482 time_usec = timespec_to_usec(&event->time);
484 time_usec = timespec_to_usec(time);
486 dxf = wl_fixed_from_double(dx);
487 dyf = wl_fixed_from_double(dy);
488 dxf_unaccel = wl_fixed_from_double(dx_unaccel);
489 dyf_unaccel = wl_fixed_from_double(dy_unaccel);
491 wl_resource_for_each(resource, resource_list) {
492 zwp_relative_pointer_v1_send_relative_motion(
494 (uint32_t) (time_usec >> 32),
495 (uint32_t) time_usec,
497 dxf_unaccel, dyf_unaccel);
502 pointer_send_motion(struct weston_pointer *pointer,
503 const struct timespec *time,
504 wl_fixed_t sx, wl_fixed_t sy)
506 struct wl_list *resource_list;
507 struct wl_resource *resource;
510 if (!pointer->focus_client)
513 resource_list = &pointer->focus_client->pointer_resources;
514 msecs = timespec_to_msec(time);
515 wl_resource_for_each(resource, resource_list) {
516 send_timestamps_for_input_resource(resource,
517 &pointer->timestamps_list,
519 wl_pointer_send_motion(resource, msecs, sx, sy);
524 weston_pointer_send_motion(struct weston_pointer *pointer,
525 const struct timespec *time,
526 struct weston_pointer_motion_event *event)
529 wl_fixed_t old_sx = pointer->sx;
530 wl_fixed_t old_sy = pointer->sy;
532 if (pointer->focus) {
533 weston_pointer_motion_to_abs(pointer, event, &x, &y);
534 weston_view_from_global_fixed(pointer->focus, x, y,
535 &pointer->sx, &pointer->sy);
538 weston_pointer_move(pointer, event);
540 if (old_sx != pointer->sx || old_sy != pointer->sy) {
541 pointer_send_motion(pointer, time,
542 pointer->sx, pointer->sy);
545 pointer_send_relative_motion(pointer, time, event);
549 default_grab_pointer_motion(struct weston_pointer_grab *grab,
550 const struct timespec *time,
551 struct weston_pointer_motion_event *event)
553 weston_pointer_send_motion(grab->pointer, time, event);
556 /** Check if the pointer has focused resources.
558 * \param pointer The pointer to check for focused resources.
559 * \return Whether or not this pointer has focused resources
562 weston_pointer_has_focus_resource(struct weston_pointer *pointer)
564 if (!pointer->focus_client)
567 if (wl_list_empty(&pointer->focus_client->pointer_resources))
573 /** Send wl_pointer.button events to focused resources.
575 * \param pointer The pointer where the button events originates from.
576 * \param time The timestamp of the event
577 * \param button The button value of the event
578 * \param value The state enum value of the event
580 * For every resource that is currently in focus, send a wl_pointer.button event
581 * with the passed parameters. The focused resources are the wl_pointer
582 * resources of the client which currently has the surface with pointer focus.
585 weston_pointer_send_button(struct weston_pointer *pointer,
586 const struct timespec *time, uint32_t button,
587 enum wl_pointer_button_state state)
589 struct wl_display *display = pointer->seat->compositor->wl_display;
590 struct wl_list *resource_list;
591 struct wl_resource *resource;
595 if (!weston_pointer_has_focus_resource(pointer))
598 resource_list = &pointer->focus_client->pointer_resources;
599 serial = wl_display_next_serial(display);
600 msecs = timespec_to_msec(time);
601 wl_resource_for_each(resource, resource_list) {
602 send_timestamps_for_input_resource(resource,
603 &pointer->timestamps_list,
605 wl_pointer_send_button(resource, serial, msecs, button, state);
610 default_grab_pointer_button(struct weston_pointer_grab *grab,
611 const struct timespec *time, uint32_t button,
612 enum wl_pointer_button_state state)
614 struct weston_pointer *pointer = grab->pointer;
615 struct weston_compositor *compositor = pointer->seat->compositor;
616 struct weston_view *view;
619 weston_pointer_send_button(pointer, time, button, state);
621 if (pointer->button_count == 0 &&
622 state == WL_POINTER_BUTTON_STATE_RELEASED) {
623 view = weston_compositor_pick_view(compositor,
624 pointer->x, pointer->y,
627 weston_pointer_set_focus(pointer, view, sx, sy);
631 /** Send wl_pointer.axis events to focused resources.
633 * \param pointer The pointer where the axis events originates from.
634 * \param time The timestamp of the event
635 * \param axis The axis enum value of the event
636 * \param value The axis value of the event
638 * For every resource that is currently in focus, send a wl_pointer.axis event
639 * with the passed parameters. The focused resources are the wl_pointer
640 * resources of the client which currently has the surface with pointer focus.
643 weston_pointer_send_axis(struct weston_pointer *pointer,
644 const struct timespec *time,
645 struct weston_pointer_axis_event *event)
647 struct wl_resource *resource;
648 struct wl_list *resource_list;
651 if (!weston_pointer_has_focus_resource(pointer))
654 resource_list = &pointer->focus_client->pointer_resources;
655 msecs = timespec_to_msec(time);
656 wl_resource_for_each(resource, resource_list) {
657 if (event->has_discrete &&
658 wl_resource_get_version(resource) >=
659 WL_POINTER_AXIS_DISCRETE_SINCE_VERSION)
660 wl_pointer_send_axis_discrete(resource, event->axis,
664 send_timestamps_for_input_resource(resource,
665 &pointer->timestamps_list,
667 wl_pointer_send_axis(resource, msecs,
669 wl_fixed_from_double(event->value));
670 } else if (wl_resource_get_version(resource) >=
671 WL_POINTER_AXIS_STOP_SINCE_VERSION) {
672 send_timestamps_for_input_resource(resource,
673 &pointer->timestamps_list,
675 wl_pointer_send_axis_stop(resource, msecs,
681 /** Send wl_pointer.axis_source events to focused resources.
683 * \param pointer The pointer where the axis_source events originates from.
684 * \param source The axis_source enum value of the event
686 * For every resource that is currently in focus, send a wl_pointer.axis_source
687 * event with the passed parameter. The focused resources are the wl_pointer
688 * resources of the client which currently has the surface with pointer focus.
691 weston_pointer_send_axis_source(struct weston_pointer *pointer,
692 enum wl_pointer_axis_source source)
694 struct wl_resource *resource;
695 struct wl_list *resource_list;
697 if (!weston_pointer_has_focus_resource(pointer))
700 resource_list = &pointer->focus_client->pointer_resources;
701 wl_resource_for_each(resource, resource_list) {
702 if (wl_resource_get_version(resource) >=
703 WL_POINTER_AXIS_SOURCE_SINCE_VERSION) {
704 wl_pointer_send_axis_source(resource, source);
710 pointer_send_frame(struct wl_resource *resource)
712 if (wl_resource_get_version(resource) >=
713 WL_POINTER_FRAME_SINCE_VERSION) {
714 wl_pointer_send_frame(resource);
718 /** Send wl_pointer.frame events to focused resources.
720 * \param pointer The pointer where the frame events originates from.
722 * For every resource that is currently in focus, send a wl_pointer.frame event.
723 * The focused resources are the wl_pointer resources of the client which
724 * currently has the surface with pointer focus.
727 weston_pointer_send_frame(struct weston_pointer *pointer)
729 struct wl_resource *resource;
730 struct wl_list *resource_list;
732 if (!weston_pointer_has_focus_resource(pointer))
735 resource_list = &pointer->focus_client->pointer_resources;
736 wl_resource_for_each(resource, resource_list)
737 pointer_send_frame(resource);
741 default_grab_pointer_axis(struct weston_pointer_grab *grab,
742 const struct timespec *time,
743 struct weston_pointer_axis_event *event)
745 weston_pointer_send_axis(grab->pointer, time, event);
749 default_grab_pointer_axis_source(struct weston_pointer_grab *grab,
750 enum wl_pointer_axis_source source)
752 weston_pointer_send_axis_source(grab->pointer, source);
756 default_grab_pointer_frame(struct weston_pointer_grab *grab)
758 weston_pointer_send_frame(grab->pointer);
762 default_grab_pointer_cancel(struct weston_pointer_grab *grab)
766 static const struct weston_pointer_grab_interface
767 default_pointer_grab_interface = {
768 default_grab_pointer_focus,
769 default_grab_pointer_motion,
770 default_grab_pointer_button,
771 default_grab_pointer_axis,
772 default_grab_pointer_axis_source,
773 default_grab_pointer_frame,
774 default_grab_pointer_cancel,
777 /** Check if the touch has focused resources.
779 * \param touch The touch to check for focused resources.
780 * \return Whether or not this touch has focused resources
783 weston_touch_has_focus_resource(struct weston_touch *touch)
788 if (wl_list_empty(&touch->focus_resource_list))
794 /** Send wl_touch.down events to focused resources.
796 * \param touch The touch where the down events originates from.
797 * \param time The timestamp of the event
798 * \param touch_id The touch_id value of the event
799 * \param x The x value of the event
800 * \param y The y value of the event
802 * For every resource that is currently in focus, send a wl_touch.down event
803 * with the passed parameters. The focused resources are the wl_touch
804 * resources of the client which currently has the surface with touch focus.
807 weston_touch_send_down(struct weston_touch *touch, const struct timespec *time,
808 int touch_id, wl_fixed_t x, wl_fixed_t y)
810 struct wl_display *display = touch->seat->compositor->wl_display;
812 struct wl_resource *resource;
813 struct wl_list *resource_list;
817 if (!weston_touch_has_focus_resource(touch))
820 weston_view_from_global_fixed(touch->focus, x, y, &sx, &sy);
822 resource_list = &touch->focus_resource_list;
823 serial = wl_display_next_serial(display);
824 msecs = timespec_to_msec(time);
825 wl_resource_for_each(resource, resource_list) {
826 send_timestamps_for_input_resource(resource,
827 &touch->timestamps_list,
829 wl_touch_send_down(resource, serial, msecs,
830 touch->focus->surface->resource,
836 default_grab_touch_down(struct weston_touch_grab *grab,
837 const struct timespec *time, int touch_id,
838 wl_fixed_t x, wl_fixed_t y)
840 weston_touch_send_down(grab->touch, time, touch_id, x, y);
843 /** Send wl_touch.up events to focused resources.
845 * \param touch The touch where the up events originates from.
846 * \param time The timestamp of the event
847 * \param touch_id The touch_id value of the event
849 * For every resource that is currently in focus, send a wl_touch.up event
850 * with the passed parameters. The focused resources are the wl_touch
851 * resources of the client which currently has the surface with touch focus.
854 weston_touch_send_up(struct weston_touch *touch, const struct timespec *time,
857 struct wl_display *display = touch->seat->compositor->wl_display;
859 struct wl_resource *resource;
860 struct wl_list *resource_list;
863 if (!weston_touch_has_focus_resource(touch))
866 resource_list = &touch->focus_resource_list;
867 serial = wl_display_next_serial(display);
868 msecs = timespec_to_msec(time);
869 wl_resource_for_each(resource, resource_list) {
870 send_timestamps_for_input_resource(resource,
871 &touch->timestamps_list,
873 wl_touch_send_up(resource, serial, msecs, touch_id);
878 default_grab_touch_up(struct weston_touch_grab *grab,
879 const struct timespec *time, int touch_id)
881 weston_touch_send_up(grab->touch, time, touch_id);
884 /** Send wl_touch.motion events to focused resources.
886 * \param touch The touch where the motion events originates from.
887 * \param time The timestamp of the event
888 * \param touch_id The touch_id value of the event
889 * \param x The x value of the event
890 * \param y The y value of the event
892 * For every resource that is currently in focus, send a wl_touch.motion event
893 * with the passed parameters. The focused resources are the wl_touch
894 * resources of the client which currently has the surface with touch focus.
897 weston_touch_send_motion(struct weston_touch *touch,
898 const struct timespec *time, int touch_id,
899 wl_fixed_t x, wl_fixed_t y)
901 struct wl_resource *resource;
902 struct wl_list *resource_list;
906 if (!weston_touch_has_focus_resource(touch))
909 weston_view_from_global_fixed(touch->focus, x, y, &sx, &sy);
911 resource_list = &touch->focus_resource_list;
912 msecs = timespec_to_msec(time);
913 wl_resource_for_each(resource, resource_list) {
914 send_timestamps_for_input_resource(resource,
915 &touch->timestamps_list,
917 wl_touch_send_motion(resource, msecs,
923 default_grab_touch_motion(struct weston_touch_grab *grab,
924 const struct timespec *time, int touch_id,
925 wl_fixed_t x, wl_fixed_t y)
927 weston_touch_send_motion(grab->touch, time, touch_id, x, y);
931 /** Send wl_touch.frame events to focused resources.
933 * \param touch The touch where the frame events originates from.
935 * For every resource that is currently in focus, send a wl_touch.frame event.
936 * The focused resources are the wl_touch resources of the client which
937 * currently has the surface with touch focus.
940 weston_touch_send_frame(struct weston_touch *touch)
942 struct wl_resource *resource;
944 if (!weston_touch_has_focus_resource(touch))
947 wl_resource_for_each(resource, &touch->focus_resource_list)
948 wl_touch_send_frame(resource);
952 default_grab_touch_frame(struct weston_touch_grab *grab)
954 weston_touch_send_frame(grab->touch);
958 default_grab_touch_cancel(struct weston_touch_grab *grab)
962 static const struct weston_touch_grab_interface default_touch_grab_interface = {
963 default_grab_touch_down,
964 default_grab_touch_up,
965 default_grab_touch_motion,
966 default_grab_touch_frame,
967 default_grab_touch_cancel,
970 /** Check if the keyboard has focused resources.
972 * \param keyboard The keyboard to check for focused resources.
973 * \return Whether or not this keyboard has focused resources
976 weston_keyboard_has_focus_resource(struct weston_keyboard *keyboard)
978 if (!keyboard->focus)
981 if (wl_list_empty(&keyboard->focus_resource_list))
987 /** Send wl_keyboard.key events to focused resources.
989 * \param keyboard The keyboard where the key events originates from.
990 * \param time The timestamp of the event
991 * \param key The key value of the event
992 * \param state The state enum value of the event
994 * For every resource that is currently in focus, send a wl_keyboard.key event
995 * with the passed parameters. The focused resources are the wl_keyboard
996 * resources of the client which currently has the surface with keyboard focus.
999 weston_keyboard_send_key(struct weston_keyboard *keyboard,
1000 const struct timespec *time, uint32_t key,
1001 enum wl_keyboard_key_state state)
1003 struct wl_resource *resource;
1004 struct wl_display *display = keyboard->seat->compositor->wl_display;
1006 struct wl_list *resource_list;
1009 if (!weston_keyboard_has_focus_resource(keyboard))
1012 resource_list = &keyboard->focus_resource_list;
1013 serial = wl_display_next_serial(display);
1014 msecs = timespec_to_msec(time);
1015 wl_resource_for_each(resource, resource_list) {
1016 send_timestamps_for_input_resource(resource,
1017 &keyboard->timestamps_list,
1019 wl_keyboard_send_key(resource, serial, msecs, key, state);
1024 default_grab_keyboard_key(struct weston_keyboard_grab *grab,
1025 const struct timespec *time, uint32_t key,
1028 weston_keyboard_send_key(grab->keyboard, time, key, state);
1032 send_modifiers_to_resource(struct weston_keyboard *keyboard,
1033 struct wl_resource *resource,
1036 wl_keyboard_send_modifiers(resource,
1038 keyboard->modifiers.mods_depressed,
1039 keyboard->modifiers.mods_latched,
1040 keyboard->modifiers.mods_locked,
1041 keyboard->modifiers.group);
1045 send_modifiers_to_client_in_list(struct wl_client *client,
1046 struct wl_list *list,
1048 struct weston_keyboard *keyboard)
1050 struct wl_resource *resource;
1052 wl_resource_for_each(resource, list) {
1053 if (wl_resource_get_client(resource) == client)
1054 send_modifiers_to_resource(keyboard,
1060 static struct weston_pointer_client *
1061 find_pointer_client_for_surface(struct weston_pointer *pointer,
1062 struct weston_surface *surface)
1064 struct wl_client *client;
1069 if (!surface->resource)
1072 client = wl_resource_get_client(surface->resource);
1073 return weston_pointer_get_pointer_client(pointer, client);
1076 static struct weston_pointer_client *
1077 find_pointer_client_for_view(struct weston_pointer *pointer, struct weston_view *view)
1082 return find_pointer_client_for_surface(pointer, view->surface);
1085 static struct wl_resource *
1086 find_resource_for_surface(struct wl_list *list, struct weston_surface *surface)
1091 if (!surface->resource)
1094 return wl_resource_find_for_client(list, wl_resource_get_client(surface->resource));
1097 /** Send wl_keyboard.modifiers events to focused resources and pointer
1098 * focused resources.
1100 * \param keyboard The keyboard where the modifiers events originates from.
1101 * \param serial The serial of the event
1102 * \param mods_depressed The mods_depressed value of the event
1103 * \param mods_latched The mods_latched value of the event
1104 * \param mods_locked The mods_locked value of the event
1105 * \param group The group value of the event
1107 * For every resource that is currently in focus, send a wl_keyboard.modifiers
1108 * event with the passed parameters. The focused resources are the wl_keyboard
1109 * resources of the client which currently has the surface with keyboard focus.
1110 * This also sends wl_keyboard.modifiers events to the wl_keyboard resources of
1111 * the client having pointer focus (if different from the keyboard focus client).
1114 weston_keyboard_send_modifiers(struct weston_keyboard *keyboard,
1115 uint32_t serial, uint32_t mods_depressed,
1116 uint32_t mods_latched,
1117 uint32_t mods_locked, uint32_t group)
1119 struct weston_pointer *pointer =
1120 weston_seat_get_pointer(keyboard->seat);
1122 if (weston_keyboard_has_focus_resource(keyboard)) {
1123 struct wl_list *resource_list;
1124 struct wl_resource *resource;
1126 resource_list = &keyboard->focus_resource_list;
1127 wl_resource_for_each(resource, resource_list) {
1128 wl_keyboard_send_modifiers(resource, serial,
1129 mods_depressed, mods_latched,
1130 mods_locked, group);
1134 if (pointer && pointer->focus && pointer->focus->surface->resource &&
1135 pointer->focus->surface != keyboard->focus) {
1136 struct wl_client *pointer_client =
1137 wl_resource_get_client(pointer->focus->surface->resource);
1139 send_modifiers_to_client_in_list(pointer_client,
1140 &keyboard->resource_list,
1147 default_grab_keyboard_modifiers(struct weston_keyboard_grab *grab,
1148 uint32_t serial, uint32_t mods_depressed,
1149 uint32_t mods_latched,
1150 uint32_t mods_locked, uint32_t group)
1152 weston_keyboard_send_modifiers(grab->keyboard, serial, mods_depressed,
1153 mods_latched, mods_locked, group);
1157 default_grab_keyboard_cancel(struct weston_keyboard_grab *grab)
1161 static const struct weston_keyboard_grab_interface
1162 default_keyboard_grab_interface = {
1163 default_grab_keyboard_key,
1164 default_grab_keyboard_modifiers,
1165 default_grab_keyboard_cancel,
1169 pointer_unmap_sprite(struct weston_pointer *pointer)
1171 struct weston_surface *surface = pointer->sprite->surface;
1173 if (weston_surface_is_mapped(surface))
1174 weston_surface_unmap(surface);
1176 wl_list_remove(&pointer->sprite_destroy_listener.link);
1177 surface->committed = NULL;
1178 surface->committed_private = NULL;
1179 weston_surface_set_label_func(surface, NULL);
1180 weston_view_destroy(pointer->sprite);
1181 pointer->sprite = NULL;
1185 pointer_handle_sprite_destroy(struct wl_listener *listener, void *data)
1187 struct weston_pointer *pointer =
1188 container_of(listener, struct weston_pointer,
1189 sprite_destroy_listener);
1191 pointer->sprite = NULL;
1195 weston_pointer_reset_state(struct weston_pointer *pointer)
1197 pointer->button_count = 0;
1201 weston_pointer_handle_output_destroy(struct wl_listener *listener, void *data);
1203 static struct weston_pointer *
1204 weston_pointer_create(struct weston_seat *seat)
1206 struct weston_pointer *pointer;
1208 pointer = zalloc(sizeof *pointer);
1209 if (pointer == NULL)
1212 wl_list_init(&pointer->pointer_clients);
1213 weston_pointer_set_default_grab(pointer,
1214 seat->compositor->default_pointer_grab);
1215 wl_list_init(&pointer->focus_resource_listener.link);
1216 pointer->focus_resource_listener.notify = pointer_focus_resource_destroyed;
1217 pointer->default_grab.pointer = pointer;
1218 pointer->grab = &pointer->default_grab;
1219 wl_signal_init(&pointer->motion_signal);
1220 wl_signal_init(&pointer->focus_signal);
1221 wl_list_init(&pointer->focus_view_listener.link);
1222 wl_signal_init(&pointer->destroy_signal);
1223 wl_list_init(&pointer->timestamps_list);
1225 pointer->sprite_destroy_listener.notify = pointer_handle_sprite_destroy;
1227 /* FIXME: Pick better co-ords. */
1228 pointer->x = wl_fixed_from_int(100);
1229 pointer->y = wl_fixed_from_int(100);
1231 pointer->output_destroy_listener.notify =
1232 weston_pointer_handle_output_destroy;
1233 wl_signal_add(&seat->compositor->output_destroyed_signal,
1234 &pointer->output_destroy_listener);
1236 pointer->sx = wl_fixed_from_int(-1000000);
1237 pointer->sy = wl_fixed_from_int(-1000000);
1243 weston_pointer_destroy(struct weston_pointer *pointer)
1245 struct weston_pointer_client *pointer_client, *tmp;
1247 wl_signal_emit(&pointer->destroy_signal, pointer);
1249 if (pointer->sprite)
1250 pointer_unmap_sprite(pointer);
1252 wl_list_for_each_safe(pointer_client, tmp, &pointer->pointer_clients,
1254 wl_list_remove(&pointer_client->link);
1255 weston_pointer_client_destroy(pointer_client);
1258 wl_list_remove(&pointer->focus_resource_listener.link);
1259 wl_list_remove(&pointer->focus_view_listener.link);
1260 wl_list_remove(&pointer->output_destroy_listener.link);
1261 wl_list_remove(&pointer->timestamps_list);
1266 weston_pointer_set_default_grab(struct weston_pointer *pointer,
1267 const struct weston_pointer_grab_interface *interface)
1270 pointer->default_grab.interface = interface;
1272 pointer->default_grab.interface =
1273 &default_pointer_grab_interface;
1276 static struct weston_keyboard *
1277 weston_keyboard_create(void)
1279 struct weston_keyboard *keyboard;
1281 keyboard = zalloc(sizeof *keyboard);
1282 if (keyboard == NULL)
1285 wl_list_init(&keyboard->resource_list);
1286 wl_list_init(&keyboard->focus_resource_list);
1287 wl_list_init(&keyboard->focus_resource_listener.link);
1288 keyboard->focus_resource_listener.notify = keyboard_focus_resource_destroyed;
1289 wl_array_init(&keyboard->keys);
1290 keyboard->default_grab.interface = &default_keyboard_grab_interface;
1291 keyboard->default_grab.keyboard = keyboard;
1292 keyboard->grab = &keyboard->default_grab;
1293 wl_signal_init(&keyboard->focus_signal);
1294 wl_list_init(&keyboard->timestamps_list);
1300 weston_xkb_info_destroy(struct weston_xkb_info *xkb_info);
1303 weston_keyboard_destroy(struct weston_keyboard *keyboard)
1305 struct wl_resource *resource;
1307 wl_resource_for_each(resource, &keyboard->resource_list) {
1308 wl_resource_set_user_data(resource, NULL);
1311 wl_resource_for_each(resource, &keyboard->focus_resource_list) {
1312 wl_resource_set_user_data(resource, NULL);
1315 wl_list_remove(&keyboard->resource_list);
1316 wl_list_remove(&keyboard->focus_resource_list);
1318 xkb_state_unref(keyboard->xkb_state.state);
1319 if (keyboard->xkb_info)
1320 weston_xkb_info_destroy(keyboard->xkb_info);
1321 xkb_keymap_unref(keyboard->pending_keymap);
1323 wl_array_release(&keyboard->keys);
1324 wl_list_remove(&keyboard->focus_resource_listener.link);
1325 wl_list_remove(&keyboard->timestamps_list);
1330 weston_touch_reset_state(struct weston_touch *touch)
1335 static struct weston_touch *
1336 weston_touch_create(void)
1338 struct weston_touch *touch;
1340 touch = zalloc(sizeof *touch);
1344 wl_list_init(&touch->device_list);
1345 wl_list_init(&touch->resource_list);
1346 wl_list_init(&touch->focus_resource_list);
1347 wl_list_init(&touch->focus_view_listener.link);
1348 touch->focus_view_listener.notify = touch_focus_view_destroyed;
1349 wl_list_init(&touch->focus_resource_listener.link);
1350 touch->focus_resource_listener.notify = touch_focus_resource_destroyed;
1351 touch->default_grab.interface = &default_touch_grab_interface;
1352 touch->default_grab.touch = touch;
1353 touch->grab = &touch->default_grab;
1354 wl_signal_init(&touch->focus_signal);
1355 wl_list_init(&touch->timestamps_list);
1361 weston_touch_destroy(struct weston_touch *touch)
1363 struct wl_resource *resource;
1365 assert(wl_list_empty(&touch->device_list));
1367 wl_resource_for_each(resource, &touch->resource_list) {
1368 wl_resource_set_user_data(resource, NULL);
1371 wl_resource_for_each(resource, &touch->focus_resource_list) {
1372 wl_resource_set_user_data(resource, NULL);
1375 wl_list_remove(&touch->resource_list);
1376 wl_list_remove(&touch->focus_resource_list);
1377 wl_list_remove(&touch->focus_view_listener.link);
1378 wl_list_remove(&touch->focus_resource_listener.link);
1379 wl_list_remove(&touch->timestamps_list);
1384 seat_send_updated_caps(struct weston_seat *seat)
1386 enum wl_seat_capability caps = 0;
1387 struct wl_resource *resource;
1389 if (seat->pointer_device_count > 0)
1390 caps |= WL_SEAT_CAPABILITY_POINTER;
1391 if (seat->keyboard_device_count > 0)
1392 caps |= WL_SEAT_CAPABILITY_KEYBOARD;
1393 if (seat->touch_device_count > 0)
1394 caps |= WL_SEAT_CAPABILITY_TOUCH;
1396 wl_resource_for_each(resource, &seat->base_resource_list) {
1397 wl_seat_send_capabilities(resource, caps);
1399 wl_signal_emit(&seat->updated_caps_signal, seat);
1403 /** Clear the pointer focus
1405 * \param pointer the pointer to clear focus for.
1407 * This can be used to unset pointer focus and set the co-ordinates to the
1408 * arbitrary values we use for the no focus case.
1410 * There's no requirement to use this function. For example, passing the
1411 * results of a weston_compositor_pick_view() directly to
1412 * weston_pointer_set_focus() will do the right thing when no view is found.
1415 weston_pointer_clear_focus(struct weston_pointer *pointer)
1417 weston_pointer_set_focus(pointer, NULL,
1418 wl_fixed_from_int(-1000000),
1419 wl_fixed_from_int(-1000000));
1423 weston_pointer_set_focus(struct weston_pointer *pointer,
1424 struct weston_view *view,
1425 wl_fixed_t sx, wl_fixed_t sy)
1427 struct weston_pointer_client *pointer_client;
1428 struct weston_keyboard *kbd = weston_seat_get_keyboard(pointer->seat);
1429 struct wl_resource *resource;
1430 struct wl_resource *surface_resource;
1431 struct wl_display *display = pointer->seat->compositor->wl_display;
1433 struct wl_list *focus_resource_list;
1436 if ((!pointer->focus && view) ||
1437 (pointer->focus && !view) ||
1438 (pointer->focus && pointer->focus->surface != view->surface) ||
1439 pointer->sx != sx || pointer->sy != sy)
1442 if (pointer->focus_client && refocus) {
1443 focus_resource_list = &pointer->focus_client->pointer_resources;
1444 if (!wl_list_empty(focus_resource_list)) {
1445 serial = wl_display_next_serial(display);
1446 surface_resource = pointer->focus->surface->resource;
1447 wl_resource_for_each(resource, focus_resource_list) {
1448 wl_pointer_send_leave(resource, serial,
1450 pointer_send_frame(resource);
1454 pointer->focus_client = NULL;
1457 pointer_client = find_pointer_client_for_view(pointer, view);
1458 if (pointer_client && refocus) {
1459 struct wl_client *surface_client = pointer_client->client;
1461 serial = wl_display_next_serial(display);
1463 if (kbd && kbd->focus != view->surface)
1464 send_modifiers_to_client_in_list(surface_client,
1465 &kbd->resource_list,
1469 pointer->focus_client = pointer_client;
1471 focus_resource_list = &pointer->focus_client->pointer_resources;
1472 wl_resource_for_each(resource, focus_resource_list) {
1473 wl_pointer_send_enter(resource,
1475 view->surface->resource,
1477 pointer_send_frame(resource);
1480 pointer->focus_serial = serial;
1483 wl_list_remove(&pointer->focus_view_listener.link);
1484 wl_list_init(&pointer->focus_view_listener.link);
1485 wl_list_remove(&pointer->focus_resource_listener.link);
1486 wl_list_init(&pointer->focus_resource_listener.link);
1488 wl_signal_add(&view->destroy_signal, &pointer->focus_view_listener);
1489 if (view && view->surface->resource)
1490 wl_resource_add_destroy_listener(view->surface->resource,
1491 &pointer->focus_resource_listener);
1493 pointer->focus = view;
1494 pointer->focus_view_listener.notify = pointer_focus_view_destroyed;
1498 assert(view || sx == wl_fixed_from_int(-1000000));
1499 assert(view || sy == wl_fixed_from_int(-1000000));
1501 wl_signal_emit(&pointer->focus_signal, pointer);
1505 send_enter_to_resource_list(struct wl_list *list,
1506 struct weston_keyboard *keyboard,
1507 struct weston_surface *surface,
1510 struct wl_resource *resource;
1512 wl_resource_for_each(resource, list) {
1513 send_modifiers_to_resource(keyboard, resource, serial);
1514 wl_keyboard_send_enter(resource, serial,
1521 weston_keyboard_set_focus(struct weston_keyboard *keyboard,
1522 struct weston_surface *surface)
1524 struct weston_seat *seat = keyboard->seat;
1525 struct wl_resource *resource;
1526 struct wl_display *display = keyboard->seat->compositor->wl_display;
1528 struct wl_list *focus_resource_list;
1530 /* Keyboard focus on a surface without a client is equivalent to NULL
1531 * focus as nothing would react to the keyboard events anyway.
1532 * Just set focus to NULL instead - the destroy listener hangs on the
1533 * wl_resource anyway.
1535 if (surface && !surface->resource)
1538 focus_resource_list = &keyboard->focus_resource_list;
1540 if (!wl_list_empty(focus_resource_list) && keyboard->focus != surface) {
1541 serial = wl_display_next_serial(display);
1542 wl_resource_for_each(resource, focus_resource_list) {
1543 wl_keyboard_send_leave(resource, serial,
1544 keyboard->focus->resource);
1546 move_resources(&keyboard->resource_list, focus_resource_list);
1549 if (find_resource_for_surface(&keyboard->resource_list, surface) &&
1550 keyboard->focus != surface) {
1551 struct wl_client *surface_client =
1552 wl_resource_get_client(surface->resource);
1554 serial = wl_display_next_serial(display);
1556 move_resources_for_client(focus_resource_list,
1557 &keyboard->resource_list,
1559 send_enter_to_resource_list(focus_resource_list,
1563 keyboard->focus_serial = serial;
1566 if (seat->saved_kbd_focus) {
1567 wl_list_remove(&seat->saved_kbd_focus_listener.link);
1568 seat->saved_kbd_focus = NULL;
1571 wl_list_remove(&keyboard->focus_resource_listener.link);
1572 wl_list_init(&keyboard->focus_resource_listener.link);
1574 wl_resource_add_destroy_listener(surface->resource,
1575 &keyboard->focus_resource_listener);
1577 keyboard->focus = surface;
1578 wl_signal_emit(&keyboard->focus_signal, keyboard);
1581 /* Users of this function must manually manage the keyboard focus */
1583 weston_keyboard_start_grab(struct weston_keyboard *keyboard,
1584 struct weston_keyboard_grab *grab)
1586 keyboard->grab = grab;
1587 grab->keyboard = keyboard;
1591 weston_keyboard_end_grab(struct weston_keyboard *keyboard)
1593 keyboard->grab = &keyboard->default_grab;
1597 weston_keyboard_cancel_grab(struct weston_keyboard *keyboard)
1599 keyboard->grab->interface->cancel(keyboard->grab);
1603 weston_pointer_start_grab(struct weston_pointer *pointer,
1604 struct weston_pointer_grab *grab)
1606 pointer->grab = grab;
1607 grab->pointer = pointer;
1608 pointer->grab->interface->focus(pointer->grab);
1612 weston_pointer_end_grab(struct weston_pointer *pointer)
1614 pointer->grab = &pointer->default_grab;
1615 pointer->grab->interface->focus(pointer->grab);
1619 weston_pointer_cancel_grab(struct weston_pointer *pointer)
1621 pointer->grab->interface->cancel(pointer->grab);
1625 weston_touch_start_grab(struct weston_touch *touch, struct weston_touch_grab *grab)
1628 grab->touch = touch;
1632 weston_touch_end_grab(struct weston_touch *touch)
1634 touch->grab = &touch->default_grab;
1638 weston_touch_cancel_grab(struct weston_touch *touch)
1640 touch->grab->interface->cancel(touch->grab);
1644 weston_pointer_clamp_for_output(struct weston_pointer *pointer,
1645 struct weston_output *output,
1646 wl_fixed_t *fx, wl_fixed_t *fy)
1650 x = wl_fixed_to_int(*fx);
1651 y = wl_fixed_to_int(*fy);
1654 *fx = wl_fixed_from_int(output->x);
1655 else if (x >= output->x + output->width)
1656 *fx = wl_fixed_from_int(output->x +
1659 *fy = wl_fixed_from_int(output->y);
1660 else if (y >= output->y + output->height)
1661 *fy = wl_fixed_from_int(output->y +
1662 output->height - 1);
1666 weston_pointer_clamp(struct weston_pointer *pointer, wl_fixed_t *fx, wl_fixed_t *fy)
1668 struct weston_compositor *ec = pointer->seat->compositor;
1669 struct weston_output *output, *prev = NULL;
1670 int x, y, old_x, old_y, valid = 0;
1672 x = wl_fixed_to_int(*fx);
1673 y = wl_fixed_to_int(*fy);
1674 old_x = wl_fixed_to_int(pointer->x);
1675 old_y = wl_fixed_to_int(pointer->y);
1677 wl_list_for_each(output, &ec->output_list, link) {
1678 if (pointer->seat->output && pointer->seat->output != output)
1680 if (pixman_region32_contains_point(&output->region,
1683 if (pixman_region32_contains_point(&output->region,
1684 old_x, old_y, NULL))
1689 prev = pointer->seat->output;
1692 weston_pointer_clamp_for_output(pointer, prev, fx, fy);
1696 weston_pointer_move_to(struct weston_pointer *pointer,
1697 wl_fixed_t x, wl_fixed_t y)
1701 weston_pointer_clamp (pointer, &x, &y);
1706 ix = wl_fixed_to_int(x);
1707 iy = wl_fixed_to_int(y);
1709 if (pointer->sprite) {
1710 weston_view_set_position(pointer->sprite,
1711 ix - pointer->hotspot_x,
1712 iy - pointer->hotspot_y);
1713 weston_view_schedule_repaint(pointer->sprite);
1716 pointer->grab->interface->focus(pointer->grab);
1717 wl_signal_emit(&pointer->motion_signal, pointer);
1721 weston_pointer_move(struct weston_pointer *pointer,
1722 struct weston_pointer_motion_event *event)
1726 weston_pointer_motion_to_abs(pointer, event, &x, &y);
1727 weston_pointer_move_to(pointer, x, y);
1730 /** Verify if the pointer is in a valid position and move it if it isn't.
1733 weston_pointer_handle_output_destroy(struct wl_listener *listener, void *data)
1735 struct weston_pointer *pointer;
1736 struct weston_compositor *ec;
1737 struct weston_output *output, *closest = NULL;
1738 int x, y, distance, min = INT_MAX;
1741 pointer = container_of(listener, struct weston_pointer,
1742 output_destroy_listener);
1743 ec = pointer->seat->compositor;
1745 x = wl_fixed_to_int(pointer->x);
1746 y = wl_fixed_to_int(pointer->y);
1748 wl_list_for_each(output, &ec->output_list, link) {
1749 if (pixman_region32_contains_point(&output->region,
1753 /* Aproximante the distance from the pointer to the center of
1755 distance = abs(output->x + output->width / 2 - x) +
1756 abs(output->y + output->height / 2 - y);
1757 if (distance < min) {
1763 /* Nothing to do if there's no output left. */
1770 weston_pointer_clamp_for_output(pointer, closest, &fx, &fy);
1771 weston_pointer_move_to(pointer, fx, fy);
1775 notify_motion(struct weston_seat *seat,
1776 const struct timespec *time,
1777 struct weston_pointer_motion_event *event)
1779 struct weston_compositor *ec = seat->compositor;
1780 struct weston_pointer *pointer = weston_seat_get_pointer(seat);
1782 weston_compositor_wake(ec);
1783 pointer->grab->interface->motion(pointer->grab, time, event);
1787 run_modifier_bindings(struct weston_seat *seat, uint32_t old, uint32_t new)
1789 struct weston_compositor *compositor = seat->compositor;
1790 struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
1795 enum weston_keyboard_modifier weston;
1797 { keyboard->xkb_info->ctrl_mod, MODIFIER_CTRL },
1798 { keyboard->xkb_info->alt_mod, MODIFIER_ALT },
1799 { keyboard->xkb_info->super_mod, MODIFIER_SUPER },
1800 { keyboard->xkb_info->shift_mod, MODIFIER_SHIFT },
1804 for (i = 0; i < ARRAY_LENGTH(mods); i++) {
1805 if (diff & (1 << mods[i].xkb))
1806 weston_compositor_run_modifier_binding(compositor,
1809 WL_KEYBOARD_KEY_STATE_PRESSED);
1813 for (i = 0; i < ARRAY_LENGTH(mods); i++) {
1814 if (diff & (1 << mods[i].xkb))
1815 weston_compositor_run_modifier_binding(compositor,
1818 WL_KEYBOARD_KEY_STATE_RELEASED);
1823 notify_motion_absolute(struct weston_seat *seat, const struct timespec *time,
1826 struct weston_compositor *ec = seat->compositor;
1827 struct weston_pointer *pointer = weston_seat_get_pointer(seat);
1828 struct weston_pointer_motion_event event = { 0 };
1830 weston_compositor_wake(ec);
1832 event = (struct weston_pointer_motion_event) {
1833 .mask = WESTON_POINTER_MOTION_ABS,
1838 pointer->grab->interface->motion(pointer->grab, time, &event);
1842 peek_next_activate_serial(struct weston_compositor *c)
1844 unsigned serial = c->activate_serial + 1;
1846 return serial == 0 ? 1 : serial;
1850 inc_activate_serial(struct weston_compositor *c)
1852 c->activate_serial = peek_next_activate_serial (c);
1856 weston_view_activate(struct weston_view *view,
1857 struct weston_seat *seat,
1860 struct weston_compositor *compositor = seat->compositor;
1862 if (flags & WESTON_ACTIVATE_FLAG_CLICKED) {
1863 view->click_to_activate_serial =
1864 peek_next_activate_serial(compositor);
1867 weston_seat_set_keyboard_focus(seat, view->surface);
1871 notify_button(struct weston_seat *seat, const struct timespec *time,
1872 int32_t button, enum wl_pointer_button_state state)
1874 struct weston_compositor *compositor = seat->compositor;
1875 struct weston_pointer *pointer = weston_seat_get_pointer(seat);
1877 if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
1878 weston_compositor_idle_inhibit(compositor);
1879 if (pointer->button_count == 0) {
1880 pointer->grab_button = button;
1881 pointer->grab_time = *time;
1882 pointer->grab_x = pointer->x;
1883 pointer->grab_y = pointer->y;
1885 pointer->button_count++;
1887 weston_compositor_idle_release(compositor);
1888 pointer->button_count--;
1891 weston_compositor_run_button_binding(compositor, pointer, time, button,
1894 pointer->grab->interface->button(pointer->grab, time, button, state);
1896 if (pointer->button_count == 1)
1897 pointer->grab_serial =
1898 wl_display_get_serial(compositor->wl_display);
1902 notify_axis(struct weston_seat *seat, const struct timespec *time,
1903 struct weston_pointer_axis_event *event)
1905 struct weston_compositor *compositor = seat->compositor;
1906 struct weston_pointer *pointer = weston_seat_get_pointer(seat);
1908 weston_compositor_wake(compositor);
1910 if (weston_compositor_run_axis_binding(compositor, pointer,
1914 pointer->grab->interface->axis(pointer->grab, time, event);
1918 notify_axis_source(struct weston_seat *seat, uint32_t source)
1920 struct weston_compositor *compositor = seat->compositor;
1921 struct weston_pointer *pointer = weston_seat_get_pointer(seat);
1923 weston_compositor_wake(compositor);
1925 pointer->grab->interface->axis_source(pointer->grab, source);
1929 notify_pointer_frame(struct weston_seat *seat)
1931 struct weston_compositor *compositor = seat->compositor;
1932 struct weston_pointer *pointer = weston_seat_get_pointer(seat);
1934 weston_compositor_wake(compositor);
1936 pointer->grab->interface->frame(pointer->grab);
1940 weston_keyboard_set_locks(struct weston_keyboard *keyboard,
1941 uint32_t mask, uint32_t value)
1944 xkb_mod_mask_t mods_depressed, mods_latched, mods_locked, group;
1945 xkb_mod_mask_t num, caps;
1947 /* We don't want the leds to go out of sync with the actual state
1948 * so if the backend has no way to change the leds don't try to
1949 * change the state */
1950 if (!keyboard->seat->led_update)
1953 mods_depressed = xkb_state_serialize_mods(keyboard->xkb_state.state,
1954 XKB_STATE_DEPRESSED);
1955 mods_latched = xkb_state_serialize_mods(keyboard->xkb_state.state,
1957 mods_locked = xkb_state_serialize_mods(keyboard->xkb_state.state,
1959 group = xkb_state_serialize_group(keyboard->xkb_state.state,
1960 XKB_STATE_EFFECTIVE);
1962 num = (1 << keyboard->xkb_info->mod2_mod);
1963 caps = (1 << keyboard->xkb_info->caps_mod);
1964 if (mask & WESTON_NUM_LOCK) {
1965 if (value & WESTON_NUM_LOCK)
1968 mods_locked &= ~num;
1970 if (mask & WESTON_CAPS_LOCK) {
1971 if (value & WESTON_CAPS_LOCK)
1972 mods_locked |= caps;
1974 mods_locked &= ~caps;
1977 xkb_state_update_mask(keyboard->xkb_state.state, mods_depressed,
1978 mods_latched, mods_locked, 0, 0, group);
1980 serial = wl_display_next_serial(
1981 keyboard->seat->compositor->wl_display);
1982 notify_modifiers(keyboard->seat, serial);
1988 notify_modifiers(struct weston_seat *seat, uint32_t serial)
1990 struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
1991 struct weston_keyboard_grab *grab = keyboard->grab;
1992 uint32_t mods_depressed, mods_latched, mods_locked, group;
1993 uint32_t mods_lookup;
1994 enum weston_led leds = 0;
1997 /* Serialize and update our internal state, checking to see if it's
1998 * different to the previous state. */
1999 mods_depressed = xkb_state_serialize_mods(keyboard->xkb_state.state,
2000 XKB_STATE_MODS_DEPRESSED);
2001 mods_latched = xkb_state_serialize_mods(keyboard->xkb_state.state,
2002 XKB_STATE_MODS_LATCHED);
2003 mods_locked = xkb_state_serialize_mods(keyboard->xkb_state.state,
2004 XKB_STATE_MODS_LOCKED);
2005 group = xkb_state_serialize_layout(keyboard->xkb_state.state,
2006 XKB_STATE_LAYOUT_EFFECTIVE);
2008 if (mods_depressed != keyboard->modifiers.mods_depressed ||
2009 mods_latched != keyboard->modifiers.mods_latched ||
2010 mods_locked != keyboard->modifiers.mods_locked ||
2011 group != keyboard->modifiers.group)
2014 run_modifier_bindings(seat, keyboard->modifiers.mods_depressed,
2017 keyboard->modifiers.mods_depressed = mods_depressed;
2018 keyboard->modifiers.mods_latched = mods_latched;
2019 keyboard->modifiers.mods_locked = mods_locked;
2020 keyboard->modifiers.group = group;
2022 /* And update the modifier_state for bindings. */
2023 mods_lookup = mods_depressed | mods_latched;
2024 seat->modifier_state = 0;
2025 if (mods_lookup & (1 << keyboard->xkb_info->ctrl_mod))
2026 seat->modifier_state |= MODIFIER_CTRL;
2027 if (mods_lookup & (1 << keyboard->xkb_info->alt_mod))
2028 seat->modifier_state |= MODIFIER_ALT;
2029 if (mods_lookup & (1 << keyboard->xkb_info->super_mod))
2030 seat->modifier_state |= MODIFIER_SUPER;
2031 if (mods_lookup & (1 << keyboard->xkb_info->shift_mod))
2032 seat->modifier_state |= MODIFIER_SHIFT;
2034 /* Finally, notify the compositor that LEDs have changed. */
2035 if (xkb_state_led_index_is_active(keyboard->xkb_state.state,
2036 keyboard->xkb_info->num_led))
2037 leds |= LED_NUM_LOCK;
2038 if (xkb_state_led_index_is_active(keyboard->xkb_state.state,
2039 keyboard->xkb_info->caps_led))
2040 leds |= LED_CAPS_LOCK;
2041 if (xkb_state_led_index_is_active(keyboard->xkb_state.state,
2042 keyboard->xkb_info->scroll_led))
2043 leds |= LED_SCROLL_LOCK;
2044 if (leds != keyboard->xkb_state.leds && seat->led_update)
2045 seat->led_update(seat, leds);
2046 keyboard->xkb_state.leds = leds;
2049 grab->interface->modifiers(grab,
2051 keyboard->modifiers.mods_depressed,
2052 keyboard->modifiers.mods_latched,
2053 keyboard->modifiers.mods_locked,
2054 keyboard->modifiers.group);
2059 update_modifier_state(struct weston_seat *seat, uint32_t serial, uint32_t key,
2060 enum wl_keyboard_key_state state)
2062 struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
2063 enum xkb_key_direction direction;
2065 if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
2066 direction = XKB_KEY_DOWN;
2068 direction = XKB_KEY_UP;
2070 /* Offset the keycode by 8, as the evdev XKB rules reflect X's
2071 * broken keycode system, which starts at 8. */
2072 xkb_state_update_key(keyboard->xkb_state.state, key + 8, direction);
2074 notify_modifiers(seat, serial);
2078 send_keymap(struct wl_resource *resource, struct weston_xkb_info *xkb_info)
2080 wl_keyboard_send_keymap(resource,
2081 WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
2082 xkb_info->keymap_fd,
2083 xkb_info->keymap_size);
2087 send_modifiers(struct wl_resource *resource, uint32_t serial, struct weston_keyboard *keyboard)
2089 wl_keyboard_send_modifiers(resource, serial,
2090 keyboard->modifiers.mods_depressed,
2091 keyboard->modifiers.mods_latched,
2092 keyboard->modifiers.mods_locked,
2093 keyboard->modifiers.group);
2096 static struct weston_xkb_info *
2097 weston_xkb_info_create(struct xkb_keymap *keymap);
2100 update_keymap(struct weston_seat *seat)
2102 struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
2103 struct wl_resource *resource;
2104 struct weston_xkb_info *xkb_info;
2105 struct xkb_state *state;
2106 xkb_mod_mask_t latched_mods;
2107 xkb_mod_mask_t locked_mods;
2109 xkb_info = weston_xkb_info_create(keyboard->pending_keymap);
2111 xkb_keymap_unref(keyboard->pending_keymap);
2112 keyboard->pending_keymap = NULL;
2115 weston_log("failed to create XKB info\n");
2119 state = xkb_state_new(xkb_info->keymap);
2121 weston_log("failed to initialise XKB state\n");
2122 weston_xkb_info_destroy(xkb_info);
2126 latched_mods = xkb_state_serialize_mods(keyboard->xkb_state.state,
2127 XKB_STATE_MODS_LATCHED);
2128 locked_mods = xkb_state_serialize_mods(keyboard->xkb_state.state,
2129 XKB_STATE_MODS_LOCKED);
2130 xkb_state_update_mask(state,
2136 weston_xkb_info_destroy(keyboard->xkb_info);
2137 keyboard->xkb_info = xkb_info;
2139 xkb_state_unref(keyboard->xkb_state.state);
2140 keyboard->xkb_state.state = state;
2142 wl_resource_for_each(resource, &keyboard->resource_list)
2143 send_keymap(resource, xkb_info);
2144 wl_resource_for_each(resource, &keyboard->focus_resource_list)
2145 send_keymap(resource, xkb_info);
2147 notify_modifiers(seat, wl_display_next_serial(seat->compositor->wl_display));
2149 if (!latched_mods && !locked_mods)
2152 wl_resource_for_each(resource, &keyboard->resource_list)
2153 send_modifiers(resource, wl_display_get_serial(seat->compositor->wl_display), keyboard);
2154 wl_resource_for_each(resource, &keyboard->focus_resource_list)
2155 send_modifiers(resource, wl_display_get_serial(seat->compositor->wl_display), keyboard);
2159 notify_key(struct weston_seat *seat, const struct timespec *time, uint32_t key,
2160 enum wl_keyboard_key_state state,
2161 enum weston_key_state_update update_state)
2163 struct weston_compositor *compositor = seat->compositor;
2164 struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
2165 struct weston_keyboard_grab *grab = keyboard->grab;
2168 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
2169 weston_compositor_idle_inhibit(compositor);
2171 weston_compositor_idle_release(compositor);
2174 end = keyboard->keys.data + keyboard->keys.size;
2175 for (k = keyboard->keys.data; k < end; k++) {
2177 /* Ignore server-generated repeats. */
2178 if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
2183 keyboard->keys.size = (void *) end - keyboard->keys.data;
2184 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
2185 k = wl_array_add(&keyboard->keys, sizeof *k);
2189 if (grab == &keyboard->default_grab ||
2190 grab == &keyboard->input_method_grab) {
2191 weston_compositor_run_key_binding(compositor, keyboard, time,
2193 grab = keyboard->grab;
2196 grab->interface->key(grab, time, key, state);
2198 if (keyboard->pending_keymap &&
2199 keyboard->keys.size == 0)
2200 update_keymap(seat);
2202 if (update_state == STATE_UPDATE_AUTOMATIC) {
2203 update_modifier_state(seat,
2204 wl_display_get_serial(compositor->wl_display),
2209 keyboard->grab_serial = wl_display_get_serial(compositor->wl_display);
2210 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
2211 keyboard->grab_time = *time;
2212 keyboard->grab_key = key;
2217 notify_pointer_focus(struct weston_seat *seat, struct weston_output *output,
2220 struct weston_pointer *pointer = weston_seat_get_pointer(seat);
2223 weston_pointer_move_to(pointer,
2224 wl_fixed_from_double(x),
2225 wl_fixed_from_double(y));
2227 /* FIXME: We should call weston_pointer_set_focus(seat,
2228 * NULL) here, but somehow that breaks re-entry... */
2233 destroy_device_saved_kbd_focus(struct wl_listener *listener, void *data)
2235 struct weston_seat *ws;
2237 ws = container_of(listener, struct weston_seat,
2238 saved_kbd_focus_listener);
2240 ws->saved_kbd_focus = NULL;
2244 notify_keyboard_focus_in(struct weston_seat *seat, struct wl_array *keys,
2245 enum weston_key_state_update update_state)
2247 struct weston_compositor *compositor = seat->compositor;
2248 struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
2249 struct weston_surface *surface;
2250 uint32_t *k, serial;
2252 serial = wl_display_next_serial(compositor->wl_display);
2253 wl_array_copy(&keyboard->keys, keys);
2254 wl_array_for_each(k, &keyboard->keys) {
2255 weston_compositor_idle_inhibit(compositor);
2256 if (update_state == STATE_UPDATE_AUTOMATIC)
2257 update_modifier_state(seat, serial, *k,
2258 WL_KEYBOARD_KEY_STATE_PRESSED);
2261 surface = seat->saved_kbd_focus;
2263 weston_keyboard_set_focus(keyboard, surface);
2268 notify_keyboard_focus_out(struct weston_seat *seat)
2270 struct weston_compositor *compositor = seat->compositor;
2271 struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
2272 struct weston_pointer *pointer = weston_seat_get_pointer(seat);
2273 struct weston_surface *focus = keyboard->focus;
2274 uint32_t *k, serial;
2276 serial = wl_display_next_serial(compositor->wl_display);
2277 wl_array_for_each(k, &keyboard->keys) {
2278 weston_compositor_idle_release(compositor);
2279 update_modifier_state(seat, serial, *k,
2280 WL_KEYBOARD_KEY_STATE_RELEASED);
2283 seat->modifier_state = 0;
2285 weston_keyboard_set_focus(keyboard, NULL);
2286 weston_keyboard_cancel_grab(keyboard);
2288 weston_pointer_cancel_grab(pointer);
2291 seat->saved_kbd_focus = focus;
2292 seat->saved_kbd_focus_listener.notify =
2293 destroy_device_saved_kbd_focus;
2294 wl_signal_add(&focus->destroy_signal,
2295 &seat->saved_kbd_focus_listener);
2300 weston_touch_set_focus(struct weston_touch *touch, struct weston_view *view)
2302 struct wl_list *focus_resource_list;
2304 focus_resource_list = &touch->focus_resource_list;
2306 if (view && touch->focus &&
2307 touch->focus->surface == view->surface) {
2308 touch->focus = view;
2312 wl_list_remove(&touch->focus_resource_listener.link);
2313 wl_list_init(&touch->focus_resource_listener.link);
2314 wl_list_remove(&touch->focus_view_listener.link);
2315 wl_list_init(&touch->focus_view_listener.link);
2317 if (!wl_list_empty(focus_resource_list)) {
2318 move_resources(&touch->resource_list,
2319 focus_resource_list);
2323 struct wl_client *surface_client;
2325 if (!view->surface->resource) {
2326 touch->focus = NULL;
2330 surface_client = wl_resource_get_client(view->surface->resource);
2331 move_resources_for_client(focus_resource_list,
2332 &touch->resource_list,
2334 wl_resource_add_destroy_listener(view->surface->resource,
2335 &touch->focus_resource_listener);
2336 wl_signal_add(&view->destroy_signal, &touch->focus_view_listener);
2338 touch->focus = view;
2342 * notify_touch - emulates button touches and notifies surfaces accordingly.
2344 * It assumes always the correct cycle sequence until it gets here: touch_down
2345 * → touch_update → ... → touch_update → touch_end. The driver is responsible
2346 * for sending along such order.
2350 notify_touch(struct weston_seat *seat, const struct timespec *time,
2351 int touch_id, double double_x, double double_y, int touch_type)
2353 struct weston_compositor *ec = seat->compositor;
2354 struct weston_touch *touch = weston_seat_get_touch(seat);
2355 struct weston_touch_grab *grab = touch->grab;
2356 struct weston_view *ev;
2358 wl_fixed_t x = wl_fixed_from_double(double_x);
2359 wl_fixed_t y = wl_fixed_from_double(double_y);
2361 /* Update grab's global coordinates. */
2362 if (touch_id == touch->grab_touch_id && touch_type != WL_TOUCH_UP) {
2367 switch (touch_type) {
2369 weston_compositor_idle_inhibit(ec);
2373 /* the first finger down picks the view, and all further go
2374 * to that view for the remainder of the touch session i.e.
2375 * until all touch points are up again. */
2376 if (touch->num_tp == 1) {
2377 ev = weston_compositor_pick_view(ec, x, y, &sx, &sy);
2378 weston_touch_set_focus(touch, ev);
2379 } else if (!touch->focus) {
2380 /* Unexpected condition: We have non-initial touch but
2381 * there is no focused surface.
2383 weston_log("touch event received with %d points down "
2384 "but no surface focused\n", touch->num_tp);
2388 weston_compositor_run_touch_binding(ec, touch,
2391 grab->interface->down(grab, time, touch_id, x, y);
2392 if (touch->num_tp == 1) {
2393 touch->grab_serial =
2394 wl_display_get_serial(ec->wl_display);
2395 touch->grab_touch_id = touch_id;
2396 touch->grab_time = *time;
2402 case WL_TOUCH_MOTION:
2407 grab->interface->motion(grab, time, touch_id, x, y);
2410 if (touch->num_tp == 0) {
2411 /* This can happen if we start out with one or
2412 * more fingers on the touch screen, in which
2413 * case we didn't get the corresponding down
2415 weston_log("unmatched touch up event\n");
2418 weston_compositor_idle_release(ec);
2421 grab->interface->up(grab, time, touch_id);
2422 if (touch->num_tp == 0)
2423 weston_touch_set_focus(touch, NULL);
2429 notify_touch_frame(struct weston_seat *seat)
2431 struct weston_touch *touch = weston_seat_get_touch(seat);
2432 struct weston_touch_grab *grab = touch->grab;
2434 grab->interface->frame(grab);
2438 notify_touch_cancel(struct weston_seat *seat)
2440 struct weston_touch *touch = weston_seat_get_touch(seat);
2441 struct weston_touch_grab *grab = touch->grab;
2443 grab->interface->cancel(grab);
2447 pointer_cursor_surface_get_label(struct weston_surface *surface,
2448 char *buf, size_t len)
2450 return snprintf(buf, len, "cursor");
2454 pointer_cursor_surface_committed(struct weston_surface *es,
2455 int32_t dx, int32_t dy)
2457 struct weston_pointer *pointer = es->committed_private;
2463 assert(es == pointer->sprite->surface);
2465 pointer->hotspot_x -= dx;
2466 pointer->hotspot_y -= dy;
2468 x = wl_fixed_to_int(pointer->x) - pointer->hotspot_x;
2469 y = wl_fixed_to_int(pointer->y) - pointer->hotspot_y;
2471 weston_view_set_position(pointer->sprite, x, y);
2473 empty_region(&es->pending.input);
2474 empty_region(&es->input);
2476 if (!weston_surface_is_mapped(es)) {
2477 weston_layer_entry_insert(&es->compositor->cursor_layer.view_list,
2478 &pointer->sprite->layer_link);
2479 weston_view_update_transform(pointer->sprite);
2480 es->is_mapped = true;
2481 pointer->sprite->is_mapped = true;
2486 pointer_set_cursor(struct wl_client *client, struct wl_resource *resource,
2487 uint32_t serial, struct wl_resource *surface_resource,
2488 int32_t x, int32_t y)
2490 struct weston_pointer *pointer = wl_resource_get_user_data(resource);
2491 struct weston_surface *surface = NULL;
2496 if (surface_resource)
2497 surface = wl_resource_get_user_data(surface_resource);
2499 if (pointer->focus == NULL)
2501 /* pointer->focus->surface->resource can be NULL. Surfaces like the
2502 black_surface used in shell.c for fullscreen don't have
2503 a resource, but can still have focus */
2504 if (pointer->focus->surface->resource == NULL)
2506 if (wl_resource_get_client(pointer->focus->surface->resource) != client)
2508 if (pointer->focus_serial - serial > UINT32_MAX / 2)
2512 if (pointer->sprite)
2513 pointer_unmap_sprite(pointer);
2517 if (pointer->sprite && pointer->sprite->surface == surface &&
2518 pointer->hotspot_x == x && pointer->hotspot_y == y)
2521 if (!pointer->sprite || pointer->sprite->surface != surface) {
2522 if (weston_surface_set_role(surface, "wl_pointer-cursor",
2524 WL_POINTER_ERROR_ROLE) < 0)
2527 if (pointer->sprite)
2528 pointer_unmap_sprite(pointer);
2530 wl_signal_add(&surface->destroy_signal,
2531 &pointer->sprite_destroy_listener);
2533 surface->committed = pointer_cursor_surface_committed;
2534 surface->committed_private = pointer;
2535 weston_surface_set_label_func(surface,
2536 pointer_cursor_surface_get_label);
2537 pointer->sprite = weston_view_create(surface);
2540 pointer->hotspot_x = x;
2541 pointer->hotspot_y = y;
2543 if (surface->buffer_ref.buffer) {
2544 pointer_cursor_surface_committed(surface, 0, 0);
2545 weston_view_schedule_repaint(pointer->sprite);
2550 pointer_release(struct wl_client *client, struct wl_resource *resource)
2552 wl_resource_destroy(resource);
2555 static const struct wl_pointer_interface pointer_interface = {
2561 seat_get_pointer(struct wl_client *client, struct wl_resource *resource,
2564 struct weston_seat *seat = wl_resource_get_user_data(resource);
2565 /* We use the pointer_state directly, which means we'll
2566 * give a wl_pointer if the seat has ever had one - even though
2567 * the spec explicitly states that this request only takes effect
2568 * if the seat has the pointer capability.
2570 * This prevents a race between the compositor sending new
2571 * capabilities and the client trying to use the old ones.
2573 struct weston_pointer *pointer = seat ? seat->pointer_state : NULL;
2574 struct wl_resource *cr;
2575 struct weston_pointer_client *pointer_client;
2577 cr = wl_resource_create(client, &wl_pointer_interface,
2578 wl_resource_get_version(resource), id);
2580 wl_client_post_no_memory(client);
2584 wl_list_init(wl_resource_get_link(cr));
2585 wl_resource_set_implementation(cr, &pointer_interface, pointer,
2586 unbind_pointer_client_resource);
2588 /* If we don't have a pointer_state, the resource is inert, so there
2589 * is nothing more to set up */
2593 pointer_client = weston_pointer_ensure_pointer_client(pointer, client);
2594 if (!pointer_client) {
2595 wl_client_post_no_memory(client);
2599 wl_list_insert(&pointer_client->pointer_resources,
2600 wl_resource_get_link(cr));
2602 if (pointer->focus && pointer->focus->surface->resource &&
2603 wl_resource_get_client(pointer->focus->surface->resource) == client) {
2606 weston_view_from_global_fixed(pointer->focus,
2611 wl_pointer_send_enter(cr,
2612 pointer->focus_serial,
2613 pointer->focus->surface->resource,
2615 pointer_send_frame(cr);
2620 destroy_keyboard_resource(struct wl_resource *resource)
2622 struct weston_keyboard *keyboard = wl_resource_get_user_data(resource);
2624 wl_list_remove(wl_resource_get_link(resource));
2627 remove_input_resource_from_timestamps(resource,
2628 &keyboard->timestamps_list);
2633 keyboard_release(struct wl_client *client, struct wl_resource *resource)
2635 wl_resource_destroy(resource);
2638 static const struct wl_keyboard_interface keyboard_interface = {
2643 should_send_modifiers_to_client(struct weston_seat *seat,
2644 struct wl_client *client)
2646 struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
2647 struct weston_pointer *pointer = weston_seat_get_pointer(seat);
2651 keyboard->focus->resource &&
2652 wl_resource_get_client(keyboard->focus->resource) == client)
2657 pointer->focus->surface->resource &&
2658 wl_resource_get_client(pointer->focus->surface->resource) == client)
2665 seat_get_keyboard(struct wl_client *client, struct wl_resource *resource,
2668 struct weston_seat *seat = wl_resource_get_user_data(resource);
2669 /* We use the keyboard_state directly, which means we'll
2670 * give a wl_keyboard if the seat has ever had one - even though
2671 * the spec explicitly states that this request only takes effect
2672 * if the seat has the keyboard capability.
2674 * This prevents a race between the compositor sending new
2675 * capabilities and the client trying to use the old ones.
2677 struct weston_keyboard *keyboard = seat ? seat->keyboard_state : NULL;
2678 struct wl_resource *cr;
2680 cr = wl_resource_create(client, &wl_keyboard_interface,
2681 wl_resource_get_version(resource), id);
2683 wl_client_post_no_memory(client);
2687 wl_list_init(wl_resource_get_link(cr));
2688 wl_resource_set_implementation(cr, &keyboard_interface,
2689 keyboard, destroy_keyboard_resource);
2691 /* If we don't have a keyboard_state, the resource is inert, so there
2692 * is nothing more to set up */
2696 /* May be moved to focused list later by either
2697 * weston_keyboard_set_focus or directly if this client is already
2699 wl_list_insert(&keyboard->resource_list, wl_resource_get_link(cr));
2701 if (wl_resource_get_version(cr) >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION) {
2702 wl_keyboard_send_repeat_info(cr,
2703 seat->compositor->kb_repeat_rate,
2704 seat->compositor->kb_repeat_delay);
2707 wl_keyboard_send_keymap(cr, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
2708 keyboard->xkb_info->keymap_fd,
2709 keyboard->xkb_info->keymap_size);
2711 if (should_send_modifiers_to_client(seat, client)) {
2712 send_modifiers_to_resource(keyboard,
2714 keyboard->focus_serial);
2717 if (keyboard->focus && keyboard->focus->resource &&
2718 wl_resource_get_client(keyboard->focus->resource) == client) {
2719 struct weston_surface *surface =
2720 (struct weston_surface *)keyboard->focus;
2722 wl_list_remove(wl_resource_get_link(cr));
2723 wl_list_insert(&keyboard->focus_resource_list,
2724 wl_resource_get_link(cr));
2725 wl_keyboard_send_enter(cr,
2726 keyboard->focus_serial,
2730 /* If this is the first keyboard resource for this
2732 if (keyboard->focus_resource_list.prev ==
2733 wl_resource_get_link(cr))
2734 wl_data_device_set_keyboard_focus(seat);
2739 destroy_touch_resource(struct wl_resource *resource)
2741 struct weston_touch *touch = wl_resource_get_user_data(resource);
2743 wl_list_remove(wl_resource_get_link(resource));
2746 remove_input_resource_from_timestamps(resource,
2747 &touch->timestamps_list);
2752 touch_release(struct wl_client *client, struct wl_resource *resource)
2754 wl_resource_destroy(resource);
2757 static const struct wl_touch_interface touch_interface = {
2762 seat_get_touch(struct wl_client *client, struct wl_resource *resource,
2765 struct weston_seat *seat = wl_resource_get_user_data(resource);
2766 /* We use the touch_state directly, which means we'll
2767 * give a wl_touch if the seat has ever had one - even though
2768 * the spec explicitly states that this request only takes effect
2769 * if the seat has the touch capability.
2771 * This prevents a race between the compositor sending new
2772 * capabilities and the client trying to use the old ones.
2774 struct weston_touch *touch = seat ? seat->touch_state : NULL;
2775 struct wl_resource *cr;
2777 cr = wl_resource_create(client, &wl_touch_interface,
2778 wl_resource_get_version(resource), id);
2780 wl_client_post_no_memory(client);
2784 wl_list_init(wl_resource_get_link(cr));
2785 wl_resource_set_implementation(cr, &touch_interface,
2786 touch, destroy_touch_resource);
2788 /* If we don't have a touch_state, the resource is inert, so there
2789 * is nothing more to set up */
2794 wl_resource_get_client(touch->focus->surface->resource) == client) {
2795 wl_list_insert(&touch->focus_resource_list,
2796 wl_resource_get_link(cr));
2798 wl_list_insert(&touch->resource_list,
2799 wl_resource_get_link(cr));
2804 seat_release(struct wl_client *client, struct wl_resource *resource)
2806 wl_resource_destroy(resource);
2809 static const struct wl_seat_interface seat_interface = {
2817 bind_seat(struct wl_client *client, void *data, uint32_t version, uint32_t id)
2819 struct weston_seat *seat = data;
2820 struct wl_resource *resource;
2821 enum wl_seat_capability caps = 0;
2823 resource = wl_resource_create(client,
2824 &wl_seat_interface, version, id);
2825 wl_list_insert(&seat->base_resource_list, wl_resource_get_link(resource));
2826 wl_resource_set_implementation(resource, &seat_interface, data,
2829 if (weston_seat_get_pointer(seat))
2830 caps |= WL_SEAT_CAPABILITY_POINTER;
2831 if (weston_seat_get_keyboard(seat))
2832 caps |= WL_SEAT_CAPABILITY_KEYBOARD;
2833 if (weston_seat_get_touch(seat))
2834 caps |= WL_SEAT_CAPABILITY_TOUCH;
2836 wl_seat_send_capabilities(resource, caps);
2837 if (version >= WL_SEAT_NAME_SINCE_VERSION)
2838 wl_seat_send_name(resource, seat->seat_name);
2842 relative_pointer_destroy(struct wl_client *client,
2843 struct wl_resource *resource)
2845 wl_resource_destroy(resource);
2848 static const struct zwp_relative_pointer_v1_interface relative_pointer_interface = {
2849 relative_pointer_destroy
2853 relative_pointer_manager_destroy(struct wl_client *client,
2854 struct wl_resource *resource)
2856 wl_resource_destroy(resource);
2860 relative_pointer_manager_get_relative_pointer(struct wl_client *client,
2861 struct wl_resource *resource,
2863 struct wl_resource *pointer_resource)
2865 struct weston_pointer *pointer =
2866 wl_resource_get_user_data(pointer_resource);
2867 struct weston_pointer_client *pointer_client;
2868 struct wl_resource *cr;
2870 cr = wl_resource_create(client, &zwp_relative_pointer_v1_interface,
2871 wl_resource_get_version(resource), id);
2873 wl_client_post_no_memory(client);
2877 pointer_client = weston_pointer_ensure_pointer_client(pointer, client);
2878 if (!pointer_client) {
2879 wl_client_post_no_memory(client);
2883 wl_list_insert(&pointer_client->relative_pointer_resources,
2884 wl_resource_get_link(cr));
2885 wl_resource_set_implementation(cr, &relative_pointer_interface,
2887 unbind_pointer_client_resource);
2890 static const struct zwp_relative_pointer_manager_v1_interface relative_pointer_manager = {
2891 relative_pointer_manager_destroy,
2892 relative_pointer_manager_get_relative_pointer,
2896 bind_relative_pointer_manager(struct wl_client *client, void *data,
2897 uint32_t version, uint32_t id)
2899 struct weston_compositor *compositor = data;
2900 struct wl_resource *resource;
2902 resource = wl_resource_create(client,
2903 &zwp_relative_pointer_manager_v1_interface,
2906 wl_resource_set_implementation(resource, &relative_pointer_manager,
2912 weston_compositor_set_xkb_rule_names(struct weston_compositor *ec,
2913 struct xkb_rule_names *names)
2915 if (ec->xkb_context == NULL) {
2916 ec->xkb_context = xkb_context_new(0);
2917 if (ec->xkb_context == NULL) {
2918 weston_log("failed to create XKB context\n");
2924 ec->xkb_names = *names;
2925 if (!ec->xkb_names.rules)
2926 ec->xkb_names.rules = strdup("evdev");
2927 if (!ec->xkb_names.model)
2928 ec->xkb_names.model = strdup("pc105");
2929 if (!ec->xkb_names.layout)
2930 ec->xkb_names.layout = strdup("us");
2936 weston_xkb_info_destroy(struct weston_xkb_info *xkb_info)
2938 if (--xkb_info->ref_count > 0)
2941 xkb_keymap_unref(xkb_info->keymap);
2943 if (xkb_info->keymap_area)
2944 munmap(xkb_info->keymap_area, xkb_info->keymap_size);
2945 if (xkb_info->keymap_fd >= 0)
2946 close(xkb_info->keymap_fd);
2951 weston_compositor_xkb_destroy(struct weston_compositor *ec)
2953 free((char *) ec->xkb_names.rules);
2954 free((char *) ec->xkb_names.model);
2955 free((char *) ec->xkb_names.layout);
2956 free((char *) ec->xkb_names.variant);
2957 free((char *) ec->xkb_names.options);
2960 weston_xkb_info_destroy(ec->xkb_info);
2961 xkb_context_unref(ec->xkb_context);
2964 static struct weston_xkb_info *
2965 weston_xkb_info_create(struct xkb_keymap *keymap)
2967 struct weston_xkb_info *xkb_info = zalloc(sizeof *xkb_info);
2968 if (xkb_info == NULL)
2971 xkb_info->keymap = xkb_keymap_ref(keymap);
2972 xkb_info->ref_count = 1;
2976 xkb_info->shift_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
2977 XKB_MOD_NAME_SHIFT);
2978 xkb_info->caps_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
2980 xkb_info->ctrl_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
2982 xkb_info->alt_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
2984 xkb_info->mod2_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
2986 xkb_info->mod3_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
2988 xkb_info->super_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
2990 xkb_info->mod5_mod = xkb_keymap_mod_get_index(xkb_info->keymap,
2993 xkb_info->num_led = xkb_keymap_led_get_index(xkb_info->keymap,
2995 xkb_info->caps_led = xkb_keymap_led_get_index(xkb_info->keymap,
2997 xkb_info->scroll_led = xkb_keymap_led_get_index(xkb_info->keymap,
2998 XKB_LED_NAME_SCROLL);
3000 keymap_str = xkb_keymap_get_as_string(xkb_info->keymap,
3001 XKB_KEYMAP_FORMAT_TEXT_V1);
3002 if (keymap_str == NULL) {
3003 weston_log("failed to get string version of keymap\n");
3006 xkb_info->keymap_size = strlen(keymap_str) + 1;
3008 xkb_info->keymap_fd = os_create_anonymous_file(xkb_info->keymap_size);
3009 if (xkb_info->keymap_fd < 0) {
3010 weston_log("creating a keymap file for %lu bytes failed: %m\n",
3011 (unsigned long) xkb_info->keymap_size);
3012 goto err_keymap_str;
3015 xkb_info->keymap_area = mmap(NULL, xkb_info->keymap_size,
3016 PROT_READ | PROT_WRITE,
3017 MAP_SHARED, xkb_info->keymap_fd, 0);
3018 if (xkb_info->keymap_area == MAP_FAILED) {
3019 weston_log("failed to mmap() %lu bytes\n",
3020 (unsigned long) xkb_info->keymap_size);
3023 strcpy(xkb_info->keymap_area, keymap_str);
3029 close(xkb_info->keymap_fd);
3033 xkb_keymap_unref(xkb_info->keymap);
3039 weston_compositor_build_global_keymap(struct weston_compositor *ec)
3041 struct xkb_keymap *keymap;
3043 if (ec->xkb_info != NULL)
3046 keymap = xkb_keymap_new_from_names(ec->xkb_context,
3049 if (keymap == NULL) {
3050 weston_log("failed to compile global XKB keymap\n");
3051 weston_log(" tried rules %s, model %s, layout %s, variant %s, "
3053 ec->xkb_names.rules, ec->xkb_names.model,
3054 ec->xkb_names.layout, ec->xkb_names.variant,
3055 ec->xkb_names.options);
3059 ec->xkb_info = weston_xkb_info_create(keymap);
3060 xkb_keymap_unref(keymap);
3061 if (ec->xkb_info == NULL)
3068 weston_seat_update_keymap(struct weston_seat *seat, struct xkb_keymap *keymap)
3070 struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
3072 if (!keyboard || !keymap)
3075 xkb_keymap_unref(keyboard->pending_keymap);
3076 keyboard->pending_keymap = xkb_keymap_ref(keymap);
3078 if (keyboard->keys.size == 0)
3079 update_keymap(seat);
3083 weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap)
3085 struct weston_keyboard *keyboard;
3087 if (seat->keyboard_state) {
3088 seat->keyboard_device_count += 1;
3089 if (seat->keyboard_device_count == 1)
3090 seat_send_updated_caps(seat);
3094 keyboard = weston_keyboard_create();
3095 if (keyboard == NULL) {
3096 weston_log("failed to allocate weston keyboard struct\n");
3100 if (keymap != NULL) {
3101 keyboard->xkb_info = weston_xkb_info_create(keymap);
3102 if (keyboard->xkb_info == NULL)
3105 if (weston_compositor_build_global_keymap(seat->compositor) < 0)
3107 keyboard->xkb_info = seat->compositor->xkb_info;
3108 keyboard->xkb_info->ref_count++;
3111 keyboard->xkb_state.state = xkb_state_new(keyboard->xkb_info->keymap);
3112 if (keyboard->xkb_state.state == NULL) {
3113 weston_log("failed to initialise XKB state\n");
3117 keyboard->xkb_state.leds = 0;
3119 seat->keyboard_state = keyboard;
3120 seat->keyboard_device_count = 1;
3121 keyboard->seat = seat;
3123 seat_send_updated_caps(seat);
3128 if (keyboard->xkb_info)
3129 weston_xkb_info_destroy(keyboard->xkb_info);
3136 weston_keyboard_reset_state(struct weston_keyboard *keyboard)
3138 struct weston_seat *seat = keyboard->seat;
3139 struct xkb_state *state;
3141 state = xkb_state_new(keyboard->xkb_info->keymap);
3143 weston_log("failed to reset XKB state\n");
3146 xkb_state_unref(keyboard->xkb_state.state);
3147 keyboard->xkb_state.state = state;
3149 keyboard->xkb_state.leds = 0;
3151 seat->modifier_state = 0;
3155 weston_seat_release_keyboard(struct weston_seat *seat)
3157 seat->keyboard_device_count--;
3158 assert(seat->keyboard_device_count >= 0);
3159 if (seat->keyboard_device_count == 0) {
3160 weston_keyboard_set_focus(seat->keyboard_state, NULL);
3161 weston_keyboard_cancel_grab(seat->keyboard_state);
3162 weston_keyboard_reset_state(seat->keyboard_state);
3163 seat_send_updated_caps(seat);
3168 weston_seat_init_pointer(struct weston_seat *seat)
3170 struct weston_pointer *pointer;
3172 if (seat->pointer_state) {
3173 seat->pointer_device_count += 1;
3174 if (seat->pointer_device_count == 1)
3175 seat_send_updated_caps(seat);
3179 pointer = weston_pointer_create(seat);
3180 if (pointer == NULL)
3183 seat->pointer_state = pointer;
3184 seat->pointer_device_count = 1;
3185 pointer->seat = seat;
3187 seat_send_updated_caps(seat);
3191 weston_seat_release_pointer(struct weston_seat *seat)
3193 struct weston_pointer *pointer = seat->pointer_state;
3195 seat->pointer_device_count--;
3196 if (seat->pointer_device_count == 0) {
3197 weston_pointer_clear_focus(pointer);
3198 weston_pointer_cancel_grab(pointer);
3200 if (pointer->sprite)
3201 pointer_unmap_sprite(pointer);
3203 weston_pointer_reset_state(pointer);
3204 seat_send_updated_caps(seat);
3206 /* seat->pointer is intentionally not destroyed so that
3207 * a newly attached pointer on this seat will retain
3208 * the previous cursor co-ordinates.
3214 weston_seat_init_touch(struct weston_seat *seat)
3216 struct weston_touch *touch;
3218 if (seat->touch_state) {
3219 seat->touch_device_count += 1;
3220 if (seat->touch_device_count == 1)
3221 seat_send_updated_caps(seat);
3225 touch = weston_touch_create();
3229 seat->touch_state = touch;
3230 seat->touch_device_count = 1;
3233 seat_send_updated_caps(seat);
3237 weston_seat_release_touch(struct weston_seat *seat)
3239 seat->touch_device_count--;
3240 if (seat->touch_device_count == 0) {
3241 weston_touch_set_focus(seat->touch_state, NULL);
3242 weston_touch_cancel_grab(seat->touch_state);
3243 weston_touch_reset_state(seat->touch_state);
3244 seat_send_updated_caps(seat);
3249 weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec,
3250 const char *seat_name)
3252 memset(seat, 0, sizeof *seat);
3254 seat->selection_data_source = NULL;
3255 wl_list_init(&seat->base_resource_list);
3256 wl_signal_init(&seat->selection_signal);
3257 wl_list_init(&seat->drag_resource_list);
3258 wl_signal_init(&seat->destroy_signal);
3259 wl_signal_init(&seat->updated_caps_signal);
3261 seat->global = wl_global_create(ec->wl_display, &wl_seat_interface, 5,
3264 seat->compositor = ec;
3265 seat->modifier_state = 0;
3266 seat->seat_name = strdup(seat_name);
3268 wl_list_insert(ec->seat_list.prev, &seat->link);
3270 clipboard_create(seat);
3272 wl_signal_emit(&ec->seat_created_signal, seat);
3276 weston_seat_release(struct weston_seat *seat)
3278 struct wl_resource *resource;
3280 wl_resource_for_each(resource, &seat->base_resource_list) {
3281 wl_resource_set_user_data(resource, NULL);
3284 wl_resource_for_each(resource, &seat->drag_resource_list) {
3285 wl_resource_set_user_data(resource, NULL);
3288 wl_list_remove(&seat->base_resource_list);
3289 wl_list_remove(&seat->drag_resource_list);
3291 wl_list_remove(&seat->link);
3293 if (seat->saved_kbd_focus)
3294 wl_list_remove(&seat->saved_kbd_focus_listener.link);
3296 if (seat->pointer_state)
3297 weston_pointer_destroy(seat->pointer_state);
3298 if (seat->keyboard_state)
3299 weston_keyboard_destroy(seat->keyboard_state);
3300 if (seat->touch_state)
3301 weston_touch_destroy(seat->touch_state);
3303 free (seat->seat_name);
3305 wl_global_destroy(seat->global);
3307 wl_signal_emit(&seat->destroy_signal, seat);
3310 /** Get a seat's keyboard pointer
3312 * \param seat The seat to query
3313 * \return The seat's keyboard pointer, or NULL if no keyboard is present
3315 * The keyboard pointer for a seat isn't freed when all keyboards are removed,
3316 * so it should only be used when the seat's keyboard_device_count is greater
3317 * than zero. This function does that test and only returns a pointer
3318 * when a keyboard is present.
3320 WL_EXPORT struct weston_keyboard *
3321 weston_seat_get_keyboard(struct weston_seat *seat)
3326 if (seat->keyboard_device_count)
3327 return seat->keyboard_state;
3332 /** Get a seat's pointer pointer
3334 * \param seat The seat to query
3335 * \return The seat's pointer pointer, or NULL if no pointer device is present
3337 * The pointer pointer for a seat isn't freed when all mice are removed,
3338 * so it should only be used when the seat's pointer_device_count is greater
3339 * than zero. This function does that test and only returns a pointer
3340 * when a pointing device is present.
3342 WL_EXPORT struct weston_pointer *
3343 weston_seat_get_pointer(struct weston_seat *seat)
3348 if (seat->pointer_device_count)
3349 return seat->pointer_state;
3354 static const struct zwp_locked_pointer_v1_interface locked_pointer_interface;
3355 static const struct zwp_confined_pointer_v1_interface confined_pointer_interface;
3357 static enum pointer_constraint_type
3358 pointer_constraint_get_type(struct weston_pointer_constraint *constraint)
3360 if (wl_resource_instance_of(constraint->resource,
3361 &zwp_locked_pointer_v1_interface,
3362 &locked_pointer_interface)) {
3363 return POINTER_CONSTRAINT_TYPE_LOCK;
3364 } else if (wl_resource_instance_of(constraint->resource,
3365 &zwp_confined_pointer_v1_interface,
3366 &confined_pointer_interface)) {
3367 return POINTER_CONSTRAINT_TYPE_CONFINE;
3375 pointer_constraint_notify_activated(struct weston_pointer_constraint *constraint)
3377 struct wl_resource *resource = constraint->resource;
3379 switch (pointer_constraint_get_type(constraint)) {
3380 case POINTER_CONSTRAINT_TYPE_LOCK:
3381 zwp_locked_pointer_v1_send_locked(resource);
3383 case POINTER_CONSTRAINT_TYPE_CONFINE:
3384 zwp_confined_pointer_v1_send_confined(resource);
3390 pointer_constraint_notify_deactivated(struct weston_pointer_constraint *constraint)
3392 struct wl_resource *resource = constraint->resource;
3394 switch (pointer_constraint_get_type(constraint)) {
3395 case POINTER_CONSTRAINT_TYPE_LOCK:
3396 zwp_locked_pointer_v1_send_unlocked(resource);
3398 case POINTER_CONSTRAINT_TYPE_CONFINE:
3399 zwp_confined_pointer_v1_send_unconfined(resource);
3404 static struct weston_pointer_constraint *
3405 get_pointer_constraint_for_pointer(struct weston_surface *surface,
3406 struct weston_pointer *pointer)
3408 struct weston_pointer_constraint *constraint;
3410 wl_list_for_each(constraint, &surface->pointer_constraints, link) {
3411 if (constraint->pointer == pointer)
3418 /** Get a seat's touch pointer
3420 * \param seat The seat to query
3421 * \return The seat's touch pointer, or NULL if no touch device is present
3423 * The touch pointer for a seat isn't freed when all touch devices are removed,
3424 * so it should only be used when the seat's touch_device_count is greater
3425 * than zero. This function does that test and only returns a pointer
3426 * when a touch device is present.
3428 WL_EXPORT struct weston_touch *
3429 weston_seat_get_touch(struct weston_seat *seat)
3434 if (seat->touch_device_count)
3435 return seat->touch_state;
3440 /** Sets the keyboard focus to the given surface
3442 * \param seat The seat to query
3445 weston_seat_set_keyboard_focus(struct weston_seat *seat,
3446 struct weston_surface *surface)
3448 struct weston_compositor *compositor = seat->compositor;
3449 struct weston_keyboard *keyboard = weston_seat_get_keyboard(seat);
3450 struct weston_surface_activation_data activation_data;
3452 if (keyboard && keyboard->focus != surface) {
3453 weston_keyboard_set_focus(keyboard, surface);
3454 wl_data_device_set_keyboard_focus(seat);
3457 inc_activate_serial(compositor);
3459 activation_data = (struct weston_surface_activation_data) {
3463 wl_signal_emit(&compositor->activate_signal, &activation_data);
3467 enable_pointer_constraint(struct weston_pointer_constraint *constraint,
3468 struct weston_view *view)
3470 assert(constraint->view == NULL);
3471 constraint->view = view;
3472 pointer_constraint_notify_activated(constraint);
3473 weston_pointer_start_grab(constraint->pointer, &constraint->grab);
3474 wl_list_remove(&constraint->surface_destroy_listener.link);
3475 wl_list_init(&constraint->surface_destroy_listener.link);
3479 is_pointer_constraint_enabled(struct weston_pointer_constraint *constraint)
3481 return constraint->view != NULL;
3485 weston_pointer_constraint_disable(struct weston_pointer_constraint *constraint)
3487 constraint->view = NULL;
3488 pointer_constraint_notify_deactivated(constraint);
3489 weston_pointer_end_grab(constraint->grab.pointer);
3493 weston_pointer_constraint_destroy(struct weston_pointer_constraint *constraint)
3495 if (is_pointer_constraint_enabled(constraint))
3496 weston_pointer_constraint_disable(constraint);
3498 wl_list_remove(&constraint->pointer_destroy_listener.link);
3499 wl_list_remove(&constraint->surface_destroy_listener.link);
3500 wl_list_remove(&constraint->surface_commit_listener.link);
3501 wl_list_remove(&constraint->surface_activate_listener.link);
3503 wl_resource_set_user_data(constraint->resource, NULL);
3504 pixman_region32_fini(&constraint->region);
3505 wl_list_remove(&constraint->link);
3510 disable_pointer_constraint(struct weston_pointer_constraint *constraint)
3512 switch (constraint->lifetime) {
3513 case ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT:
3514 weston_pointer_constraint_destroy(constraint);
3516 case ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT:
3517 weston_pointer_constraint_disable(constraint);
3523 is_within_constraint_region(struct weston_pointer_constraint *constraint,
3524 wl_fixed_t sx, wl_fixed_t sy)
3526 struct weston_surface *surface = constraint->surface;
3527 pixman_region32_t constraint_region;
3530 pixman_region32_init(&constraint_region);
3531 pixman_region32_intersect(&constraint_region,
3533 &constraint->region);
3534 result = pixman_region32_contains_point(&constraint_region,
3535 wl_fixed_to_int(sx),
3536 wl_fixed_to_int(sy),
3538 pixman_region32_fini(&constraint_region);
3544 maybe_enable_pointer_constraint(struct weston_pointer_constraint *constraint)
3546 struct weston_surface *surface = constraint->surface;
3547 struct weston_view *vit;
3548 struct weston_view *view = NULL;
3549 struct weston_pointer *pointer = constraint->pointer;
3550 struct weston_keyboard *keyboard;
3551 struct weston_seat *seat = pointer->seat;
3554 /* Postpone if no view of the surface was most recently clicked. */
3555 wl_list_for_each(vit, &surface->views, surface_link) {
3556 if (vit->click_to_activate_serial ==
3557 surface->compositor->activate_serial) {
3564 /* Postpone if surface doesn't have keyboard focus. */
3565 keyboard = weston_seat_get_keyboard(seat);
3566 if (!keyboard || keyboard->focus != surface)
3569 /* Postpone constraint if the pointer is not within the
3570 * constraint region.
3572 weston_view_from_global(view,
3573 wl_fixed_to_int(pointer->x),
3574 wl_fixed_to_int(pointer->y),
3576 if (!is_within_constraint_region(constraint,
3577 wl_fixed_from_int(x),
3578 wl_fixed_from_int(y)))
3581 enable_pointer_constraint(constraint, view);
3585 locked_pointer_grab_pointer_focus(struct weston_pointer_grab *grab)
3590 locked_pointer_grab_pointer_motion(struct weston_pointer_grab *grab,
3591 const struct timespec *time,
3592 struct weston_pointer_motion_event *event)
3594 pointer_send_relative_motion(grab->pointer, time, event);
3598 locked_pointer_grab_pointer_button(struct weston_pointer_grab *grab,
3599 const struct timespec *time,
3603 weston_pointer_send_button(grab->pointer, time, button, state_w);
3607 locked_pointer_grab_pointer_axis(struct weston_pointer_grab *grab,
3608 const struct timespec *time,
3609 struct weston_pointer_axis_event *event)
3611 weston_pointer_send_axis(grab->pointer, time, event);
3615 locked_pointer_grab_pointer_axis_source(struct weston_pointer_grab *grab,
3618 weston_pointer_send_axis_source(grab->pointer, source);
3622 locked_pointer_grab_pointer_frame(struct weston_pointer_grab *grab)
3624 weston_pointer_send_frame(grab->pointer);
3628 locked_pointer_grab_pointer_cancel(struct weston_pointer_grab *grab)
3630 struct weston_pointer_constraint *constraint =
3631 container_of(grab, struct weston_pointer_constraint, grab);
3633 disable_pointer_constraint(constraint);
3636 static const struct weston_pointer_grab_interface
3637 locked_pointer_grab_interface = {
3638 locked_pointer_grab_pointer_focus,
3639 locked_pointer_grab_pointer_motion,
3640 locked_pointer_grab_pointer_button,
3641 locked_pointer_grab_pointer_axis,
3642 locked_pointer_grab_pointer_axis_source,
3643 locked_pointer_grab_pointer_frame,
3644 locked_pointer_grab_pointer_cancel,
3648 pointer_constraint_constrain_resource_destroyed(struct wl_resource *resource)
3650 struct weston_pointer_constraint *constraint =
3651 wl_resource_get_user_data(resource);
3656 weston_pointer_constraint_destroy(constraint);
3660 pointer_constraint_surface_activate(struct wl_listener *listener, void *data)
3662 struct weston_surface_activation_data *activation = data;
3663 struct weston_pointer *pointer;
3664 struct weston_surface *focus = activation->surface;
3665 struct weston_pointer_constraint *constraint =
3666 container_of(listener, struct weston_pointer_constraint,
3667 surface_activate_listener);
3668 bool is_constraint_surface;
3670 pointer = weston_seat_get_pointer(activation->seat);
3674 is_constraint_surface =
3675 get_pointer_constraint_for_pointer(focus, pointer) == constraint;
3677 if (is_constraint_surface &&
3678 !is_pointer_constraint_enabled(constraint))
3679 maybe_enable_pointer_constraint(constraint);
3680 else if (!is_constraint_surface &&
3681 is_pointer_constraint_enabled(constraint))
3682 disable_pointer_constraint(constraint);
3686 pointer_constraint_pointer_destroyed(struct wl_listener *listener, void *data)
3688 struct weston_pointer_constraint *constraint =
3689 container_of(listener, struct weston_pointer_constraint,
3690 pointer_destroy_listener);
3692 weston_pointer_constraint_destroy(constraint);
3696 pointer_constraint_surface_destroyed(struct wl_listener *listener, void *data)
3698 struct weston_pointer_constraint *constraint =
3699 container_of(listener, struct weston_pointer_constraint,
3700 surface_destroy_listener);
3702 weston_pointer_constraint_destroy(constraint);
3706 pointer_constraint_surface_committed(struct wl_listener *listener, void *data)
3708 struct weston_pointer_constraint *constraint =
3709 container_of(listener, struct weston_pointer_constraint,
3710 surface_commit_listener);
3712 if (constraint->region_is_pending) {
3713 constraint->region_is_pending = false;
3714 pixman_region32_copy(&constraint->region,
3715 &constraint->region_pending);
3716 pixman_region32_fini(&constraint->region_pending);
3717 pixman_region32_init(&constraint->region_pending);
3720 if (constraint->hint_is_pending) {
3721 constraint->hint_is_pending = false;
3723 constraint->hint_is_pending = true;
3724 constraint->hint_x = constraint->hint_x_pending;
3725 constraint->hint_y = constraint->hint_y_pending;
3728 if (pointer_constraint_get_type(constraint) ==
3729 POINTER_CONSTRAINT_TYPE_CONFINE &&
3730 is_pointer_constraint_enabled(constraint))
3731 maybe_warp_confined_pointer(constraint);
3734 static struct weston_pointer_constraint *
3735 weston_pointer_constraint_create(struct weston_surface *surface,
3736 struct weston_pointer *pointer,
3737 struct weston_region *region,
3738 enum zwp_pointer_constraints_v1_lifetime lifetime,
3739 struct wl_resource *cr,
3740 const struct weston_pointer_grab_interface *grab_interface)
3742 struct weston_pointer_constraint *constraint;
3744 constraint = zalloc(sizeof *constraint);
3748 constraint->lifetime = lifetime;
3749 pixman_region32_init(&constraint->region);
3750 pixman_region32_init(&constraint->region_pending);
3751 wl_list_insert(&surface->pointer_constraints, &constraint->link);
3752 constraint->surface = surface;
3753 constraint->pointer = pointer;
3754 constraint->resource = cr;
3755 constraint->grab.interface = grab_interface;
3757 pixman_region32_copy(&constraint->region,
3760 pixman_region32_fini(&constraint->region);
3761 region_init_infinite(&constraint->region);
3764 constraint->surface_activate_listener.notify =
3765 pointer_constraint_surface_activate;
3766 constraint->surface_destroy_listener.notify =
3767 pointer_constraint_surface_destroyed;
3768 constraint->surface_commit_listener.notify =
3769 pointer_constraint_surface_committed;
3770 constraint->pointer_destroy_listener.notify =
3771 pointer_constraint_pointer_destroyed;
3773 wl_signal_add(&surface->compositor->activate_signal,
3774 &constraint->surface_activate_listener);
3775 wl_signal_add(&pointer->destroy_signal,
3776 &constraint->pointer_destroy_listener);
3777 wl_signal_add(&surface->destroy_signal,
3778 &constraint->surface_destroy_listener);
3779 wl_signal_add(&surface->commit_signal,
3780 &constraint->surface_commit_listener);
3786 init_pointer_constraint(struct wl_resource *pointer_constraints_resource,
3788 struct weston_surface *surface,
3789 struct weston_pointer *pointer,
3790 struct weston_region *region,
3791 enum zwp_pointer_constraints_v1_lifetime lifetime,
3792 const struct wl_interface *interface,
3793 const void *implementation,
3794 const struct weston_pointer_grab_interface *grab_interface)
3796 struct wl_client *client =
3797 wl_resource_get_client(pointer_constraints_resource);
3798 struct wl_resource *cr;
3799 struct weston_pointer_constraint *constraint;
3801 if (pointer && get_pointer_constraint_for_pointer(surface, pointer)) {
3802 wl_resource_post_error(pointer_constraints_resource,
3803 ZWP_POINTER_CONSTRAINTS_V1_ERROR_ALREADY_CONSTRAINED,
3804 "the pointer has a lock/confine request on this surface");
3808 cr = wl_resource_create(client, interface,
3809 wl_resource_get_version(pointer_constraints_resource),
3812 wl_client_post_no_memory(client);
3817 constraint = weston_pointer_constraint_create(surface, pointer,
3819 cr, grab_interface);
3820 if (constraint == NULL) {
3821 wl_client_post_no_memory(client);
3828 wl_resource_set_implementation(cr, implementation, constraint,
3829 pointer_constraint_constrain_resource_destroyed);
3832 maybe_enable_pointer_constraint(constraint);
3836 pointer_constraints_destroy(struct wl_client *client,
3837 struct wl_resource *resource)
3839 wl_resource_destroy(resource);
3843 locked_pointer_destroy(struct wl_client *client,
3844 struct wl_resource *resource)
3846 struct weston_pointer_constraint *constraint =
3847 wl_resource_get_user_data(resource);
3850 if (constraint && constraint->view && constraint->hint_is_pending &&
3851 is_within_constraint_region(constraint,
3853 constraint->hint_y)) {
3854 weston_view_to_global_fixed(constraint->view,
3858 weston_pointer_move_to(constraint->pointer, x, y);
3860 wl_resource_destroy(resource);
3864 locked_pointer_set_cursor_position_hint(struct wl_client *client,
3865 struct wl_resource *resource,
3866 wl_fixed_t surface_x,
3867 wl_fixed_t surface_y)
3869 struct weston_pointer_constraint *constraint =
3870 wl_resource_get_user_data(resource);
3872 /* Ignore a set cursor hint that was sent after the lock was cancelled.
3875 !constraint->resource ||
3876 constraint->resource != resource)
3879 constraint->hint_is_pending = true;
3880 constraint->hint_x_pending = surface_x;
3881 constraint->hint_y_pending = surface_y;
3885 locked_pointer_set_region(struct wl_client *client,
3886 struct wl_resource *resource,
3887 struct wl_resource *region_resource)
3889 struct weston_pointer_constraint *constraint =
3890 wl_resource_get_user_data(resource);
3891 struct weston_region *region = region_resource ?
3892 wl_resource_get_user_data(region_resource) : NULL;
3898 pixman_region32_copy(&constraint->region_pending,
3901 pixman_region32_fini(&constraint->region_pending);
3902 region_init_infinite(&constraint->region_pending);
3904 constraint->region_is_pending = true;
3908 static const struct zwp_locked_pointer_v1_interface locked_pointer_interface = {
3909 locked_pointer_destroy,
3910 locked_pointer_set_cursor_position_hint,
3911 locked_pointer_set_region,
3915 pointer_constraints_lock_pointer(struct wl_client *client,
3916 struct wl_resource *resource,
3918 struct wl_resource *surface_resource,
3919 struct wl_resource *pointer_resource,
3920 struct wl_resource *region_resource,
3923 struct weston_surface *surface =
3924 wl_resource_get_user_data(surface_resource);
3925 struct weston_pointer *pointer = wl_resource_get_user_data(pointer_resource);
3926 struct weston_region *region = region_resource ?
3927 wl_resource_get_user_data(region_resource) : NULL;
3929 init_pointer_constraint(resource, id, surface, pointer, region, lifetime,
3930 &zwp_locked_pointer_v1_interface,
3931 &locked_pointer_interface,
3932 &locked_pointer_grab_interface);
3936 confined_pointer_grab_pointer_focus(struct weston_pointer_grab *grab)
3941 vec2d_cross_product(struct vec2d a, struct vec2d b)
3943 return a.x * b.y - a.y * b.x;
3947 vec2d_add(struct vec2d a, struct vec2d b)
3949 return (struct vec2d) {
3956 vec2d_subtract(struct vec2d a, struct vec2d b)
3958 return (struct vec2d) {
3965 vec2d_multiply_constant(double c, struct vec2d a)
3967 return (struct vec2d) {
3974 lines_intersect(struct line *line1, struct line *line2,
3975 struct vec2d *intersection)
3977 struct vec2d p = line1->a;
3978 struct vec2d r = vec2d_subtract(line1->b, line1->a);
3979 struct vec2d q = line2->a;
3980 struct vec2d s = vec2d_subtract(line2->b, line2->a);
3987 * The line (p, r) and (q, s) intersects where
3993 * (p + t r) × s = (q + u s) × s
3994 * p × s + t (r × s) = q × s + u (s × s)
3995 * p × s + t (r × s) = q × s
3996 * t (r × s) = q × s - p × s
3997 * t (r × s) = (q - p) × s
3998 * t = ((q - p) × s) / (r × s)
4000 * Using the same method, for u we get:
4002 * u = ((p - q) × r) / (s × r)
4005 rxs = vec2d_cross_product(r, s);
4006 sxr = vec2d_cross_product(s, r);
4008 /* If r × s = 0 then the lines are either parallel or collinear. */
4009 if (fabs(rxs) < DBL_MIN)
4012 t = vec2d_cross_product(vec2d_subtract(q, p), s) / rxs;
4013 u = vec2d_cross_product(vec2d_subtract(p, q), r) / sxr;
4015 /* The lines only intersect if 0 ≤ t ≤ 1 and 0 ≤ u ≤ 1. */
4016 if (t < 0.0 || t > 1.0 || u < 0.0 || u > 1.0)
4019 *intersection = vec2d_add(p, vec2d_multiply_constant(t, r));
4023 static struct border *
4024 add_border(struct wl_array *array,
4025 double x1, double y1,
4026 double x2, double y2,
4027 enum motion_direction blocking_dir)
4029 struct border *border = wl_array_add(array, sizeof *border);
4031 *border = (struct border) {
4032 .line = (struct line) {
4033 .a = (struct vec2d) {
4037 .b = (struct vec2d) {
4042 .blocking_dir = blocking_dir,
4049 compare_lines_x(const void *a, const void *b)
4051 const struct border *border_a = a;
4052 const struct border *border_b = b;
4055 if (border_a->line.a.x == border_b->line.a.x)
4056 return border_a->line.b.x < border_b->line.b.x;
4058 return border_a->line.a.x > border_b->line.a.x;
4062 add_non_overlapping_edges(pixman_box32_t *boxes,
4063 int band_above_start,
4064 int band_below_start,
4066 struct wl_array *borders)
4069 struct wl_array band_merge;
4070 struct border *border;
4071 struct border *prev_border;
4072 struct border *new_border;
4074 wl_array_init(&band_merge);
4076 /* Add bottom band of previous row, and top band of current row, and
4077 * sort them so lower left x coordinate comes first. If there are two
4078 * borders with the same left x coordinate, the wider one comes first.
4080 for (i = band_above_start; i < band_below_start; i++) {
4081 pixman_box32_t *box = &boxes[i];
4082 add_border(&band_merge, box->x1, box->y2, box->x2, box->y2,
4083 MOTION_DIRECTION_POSITIVE_Y);
4085 for (i = band_below_start; i < band_below_end; i++) {
4086 pixman_box32_t *box= &boxes[i];
4087 add_border(&band_merge, box->x1, box->y1, box->x2, box->y1,
4088 MOTION_DIRECTION_NEGATIVE_Y);
4090 qsort(band_merge.data,
4091 band_merge.size / sizeof *border,
4095 /* Combine the two combined bands so that any overlapping border is
4098 wl_array_for_each(border, &band_merge) {
4099 assert(border->line.a.y == border->line.b.y);
4100 assert(!prev_border ||
4101 prev_border->line.a.y == border->line.a.y);
4102 assert(!prev_border ||
4103 (prev_border->line.a.x != border->line.a.x ||
4104 prev_border->line.b.x != border->line.b.x));
4105 assert(!prev_border ||
4106 prev_border->line.a.x <= border->line.a.x);
4109 prev_border->line.a.x == border->line.a.x) {
4115 prev_border->line.a.x = border->line.b.x;
4116 } else if (prev_border &&
4117 prev_border->line.b.x == border->line.b.x) {
4123 prev_border->line.b.x = border->line.a.x;
4124 } else if (prev_border &&
4125 prev_border->line.b.x == border->line.a.x) {
4131 prev_border->line.b.x = border->line.b.x;
4132 } else if (prev_border &&
4133 prev_border->line.b.x >= border->line.a.x) {
4139 new_border = add_border(borders,
4142 prev_border->line.b.x,
4143 prev_border->line.b.y,
4144 prev_border->blocking_dir);
4145 prev_border->line.b.x = border->line.a.x;
4146 prev_border = new_border;
4148 assert(!prev_border ||
4149 prev_border->line.b.x < border->line.a.x);
4151 * First border or non-overlapping.
4157 new_border = wl_array_add(borders, sizeof *border);
4158 *new_border = *border;
4159 prev_border = new_border;
4163 wl_array_release(&band_merge);
4167 add_band_bottom_edges(pixman_box32_t *boxes,
4170 struct wl_array *borders)
4174 for (i = band_start; i < band_end; i++) {
4176 boxes[i].x1, boxes[i].y2,
4177 boxes[i].x2, boxes[i].y2,
4178 MOTION_DIRECTION_POSITIVE_Y);
4183 region_to_outline(pixman_region32_t *region, struct wl_array *borders)
4185 pixman_box32_t *boxes;
4188 int top_most, bottom_most;
4191 int band_start, prev_band_start;
4194 * Remove any overlapping lines from the set of rectangles. Note that
4195 * pixman regions are grouped as rows of rectangles, where rectangles
4196 * in one row never touch or overlap and are all of the same height.
4198 * -------- --- -------- ---
4200 * ----------====---- --- ----------- ----- ---
4202 * ----==========--------- ----- ----------
4204 * ------------------- -------------------
4208 boxes = pixman_region32_rectangles(region, &num_boxes);
4210 top_most = boxes[0].y1;
4211 current_roof = top_most;
4212 bottom_most = boxes[num_boxes - 1].y2;
4214 prev_band_start = 0;
4215 for (i = 0; i < num_boxes; i++) {
4216 /* Detect if there is a vertical empty space, and add the lower
4217 * level of the previous band if so was the case. */
4219 boxes[i].y1 != prev_top &&
4220 boxes[i].y1 != boxes[i - 1].y2) {
4221 current_roof = boxes[i].y1;
4222 add_band_bottom_edges(boxes,
4228 /* Special case adding the last band, since it won't be handled
4229 * by the band change detection below. */
4230 if (boxes[i].y1 != current_roof && i == num_boxes - 1) {
4231 if (boxes[i].y1 != prev_top) {
4232 /* The last band is a single box, so we don't
4233 * have a prev_band_start to tell us when the
4234 * previous band started. */
4235 add_non_overlapping_edges(boxes,
4241 add_non_overlapping_edges(boxes,
4249 /* Detect when passing a band and combine the top border of the
4250 * just passed band with the bottom band of the previous band.
4252 if (boxes[i].y1 != top_most && boxes[i].y1 != prev_top) {
4253 /* Combine the two passed bands. */
4254 if (prev_top != current_roof) {
4255 add_non_overlapping_edges(boxes,
4262 prev_band_start = band_start;
4266 /* Add the top border if the box is part of the current roof. */
4267 if (boxes[i].y1 == current_roof) {
4269 boxes[i].x1, boxes[i].y1,
4270 boxes[i].x2, boxes[i].y1,
4271 MOTION_DIRECTION_NEGATIVE_Y);
4274 /* Add the bottom border of the last band. */
4275 if (boxes[i].y2 == bottom_most) {
4277 boxes[i].x1, boxes[i].y2,
4278 boxes[i].x2, boxes[i].y2,
4279 MOTION_DIRECTION_POSITIVE_Y);
4282 /* Always add the left border. */
4284 boxes[i].x1, boxes[i].y1,
4285 boxes[i].x1, boxes[i].y2,
4286 MOTION_DIRECTION_NEGATIVE_X);
4288 /* Always add the right border. */
4290 boxes[i].x2, boxes[i].y1,
4291 boxes[i].x2, boxes[i].y2,
4292 MOTION_DIRECTION_POSITIVE_X);
4294 prev_top = boxes[i].y1;
4299 is_border_horizontal (struct border *border)
4301 return border->line.a.y == border->line.b.y;
4305 is_border_blocking_directions(struct border *border,
4306 uint32_t directions)
4308 /* Don't block parallel motions. */
4309 if (is_border_horizontal(border)) {
4310 if ((directions & (MOTION_DIRECTION_POSITIVE_Y |
4311 MOTION_DIRECTION_NEGATIVE_Y)) == 0)
4314 if ((directions & (MOTION_DIRECTION_POSITIVE_X |
4315 MOTION_DIRECTION_NEGATIVE_X)) == 0)
4319 return (~border->blocking_dir & directions) != directions;
4322 static struct border *
4323 get_closest_border(struct wl_array *borders,
4324 struct line *motion,
4325 uint32_t directions)
4327 struct border *border;
4328 struct vec2d intersection;
4331 struct border *closest_border = NULL;
4332 double closest_distance_2 = DBL_MAX;
4334 wl_array_for_each(border, borders) {
4335 if (!is_border_blocking_directions(border, directions))
4338 if (!lines_intersect(&border->line, motion, &intersection))
4341 delta = vec2d_subtract(intersection, motion->a);
4342 distance_2 = delta.x*delta.x + delta.y*delta.y;
4343 if (distance_2 < closest_distance_2) {
4344 closest_border = border;
4345 closest_distance_2 = distance_2;
4349 return closest_border;
4353 clamp_to_border(struct border *border,
4354 struct line *motion,
4355 uint32_t *motion_dir)
4358 * When clamping either rightward or downward motions, the motion needs
4359 * to be clamped so that the destination coordinate does not end up on
4360 * the border (see weston_pointer_clamp_event_to_region). Do this by
4361 * clamping such motions to the border minus the smallest possible
4364 if (is_border_horizontal(border)) {
4365 if (*motion_dir & MOTION_DIRECTION_POSITIVE_Y)
4366 motion->b.y = border->line.a.y - wl_fixed_to_double(1);
4368 motion->b.y = border->line.a.y;
4369 *motion_dir &= ~(MOTION_DIRECTION_POSITIVE_Y |
4370 MOTION_DIRECTION_NEGATIVE_Y);
4372 if (*motion_dir & MOTION_DIRECTION_POSITIVE_X)
4373 motion->b.x = border->line.a.x - wl_fixed_to_double(1);
4375 motion->b.x = border->line.a.x;
4376 *motion_dir &= ~(MOTION_DIRECTION_POSITIVE_X |
4377 MOTION_DIRECTION_NEGATIVE_X);
4382 get_motion_directions(struct line *motion)
4384 uint32_t directions = 0;
4386 if (motion->a.x < motion->b.x)
4387 directions |= MOTION_DIRECTION_POSITIVE_X;
4388 else if (motion->a.x > motion->b.x)
4389 directions |= MOTION_DIRECTION_NEGATIVE_X;
4390 if (motion->a.y < motion->b.y)
4391 directions |= MOTION_DIRECTION_POSITIVE_Y;
4392 else if (motion->a.y > motion->b.y)
4393 directions |= MOTION_DIRECTION_NEGATIVE_Y;
4399 weston_pointer_clamp_event_to_region(struct weston_pointer *pointer,
4400 struct weston_pointer_motion_event *event,
4401 pixman_region32_t *region,
4402 wl_fixed_t *clamped_x,
4403 wl_fixed_t *clamped_y)
4407 wl_fixed_t old_sx = pointer->sx;
4408 wl_fixed_t old_sy = pointer->sy;
4409 struct wl_array borders;
4411 struct border *closest_border;
4412 float new_x_f, new_y_f;
4413 uint32_t directions;
4415 weston_pointer_motion_to_abs(pointer, event, &x, &y);
4416 weston_view_from_global_fixed(pointer->focus, x, y, &sx, &sy);
4418 wl_array_init(&borders);
4421 * Generate borders given the confine region we are to use. The borders
4422 * are defined to be the outer region of the allowed area. This means
4423 * top/left borders are "within" the allowed area, while bottom/right
4424 * borders are outside. This needs to be considered when clamping
4425 * confined motion vectors.
4427 region_to_outline(region, &borders);
4429 motion = (struct line) {
4430 .a = (struct vec2d) {
4431 .x = wl_fixed_to_double(old_sx),
4432 .y = wl_fixed_to_double(old_sy),
4434 .b = (struct vec2d) {
4435 .x = wl_fixed_to_double(sx),
4436 .y = wl_fixed_to_double(sy),
4439 directions = get_motion_directions(&motion);
4441 while (directions) {
4442 closest_border = get_closest_border(&borders,
4446 clamp_to_border(closest_border, &motion, &directions);
4451 weston_view_to_global_float(pointer->focus,
4452 (float) motion.b.x, (float) motion.b.y,
4453 &new_x_f, &new_y_f);
4454 *clamped_x = wl_fixed_from_double(new_x_f);
4455 *clamped_y = wl_fixed_from_double(new_y_f);
4457 wl_array_release(&borders);
4461 point_to_border_distance_2(struct border *border, double x, double y)
4463 double orig_x, orig_y;
4466 if (is_border_horizontal(border)) {
4467 if (x < border->line.a.x)
4468 orig_x = border->line.a.x;
4469 else if (x > border->line.b.x)
4470 orig_x = border->line.b.x;
4473 orig_y = border->line.a.y;
4475 if (y < border->line.a.y)
4476 orig_y = border->line.a.y;
4477 else if (y > border->line.b.y)
4478 orig_y = border->line.b.y;
4481 orig_x = border->line.a.x;
4485 dx = fabs(orig_x - x);
4486 dy = fabs(orig_y - y);
4487 return dx*dx + dy*dy;
4491 warp_to_behind_border(struct border *border, wl_fixed_t *sx, wl_fixed_t *sy)
4493 switch (border->blocking_dir) {
4494 case MOTION_DIRECTION_POSITIVE_X:
4495 case MOTION_DIRECTION_NEGATIVE_X:
4496 if (border->blocking_dir == MOTION_DIRECTION_POSITIVE_X)
4497 *sx = wl_fixed_from_double(border->line.a.x) - 1;
4499 *sx = wl_fixed_from_double(border->line.a.x) + 1;
4500 if (*sy < wl_fixed_from_double(border->line.a.y))
4501 *sy = wl_fixed_from_double(border->line.a.y) + 1;
4502 else if (*sy > wl_fixed_from_double(border->line.b.y))
4503 *sy = wl_fixed_from_double(border->line.b.y) - 1;
4505 case MOTION_DIRECTION_POSITIVE_Y:
4506 case MOTION_DIRECTION_NEGATIVE_Y:
4507 if (border->blocking_dir == MOTION_DIRECTION_POSITIVE_Y)
4508 *sy = wl_fixed_from_double(border->line.a.y) - 1;
4510 *sy = wl_fixed_from_double(border->line.a.y) + 1;
4511 if (*sx < wl_fixed_from_double(border->line.a.x))
4512 *sx = wl_fixed_from_double(border->line.a.x) + 1;
4513 else if (*sx > wl_fixed_from_double(border->line.b.x))
4514 *sx = wl_fixed_from_double(border->line.b.x) - 1;
4520 maybe_warp_confined_pointer(struct weston_pointer_constraint *constraint)
4527 weston_view_from_global_fixed(constraint->view,
4528 constraint->pointer->x,
4529 constraint->pointer->y,
4533 if (!is_within_constraint_region(constraint, sx, sy)) {
4534 double xf = wl_fixed_to_double(sx);
4535 double yf = wl_fixed_to_double(sy);
4536 pixman_region32_t confine_region;
4537 struct wl_array borders;
4538 struct border *border;
4539 double closest_distance_2 = DBL_MAX;
4540 struct border *closest_border = NULL;
4542 wl_array_init(&borders);
4544 pixman_region32_init(&confine_region);
4545 pixman_region32_intersect(&confine_region,
4546 &constraint->view->surface->input,
4547 &constraint->region);
4548 region_to_outline(&confine_region, &borders);
4549 pixman_region32_fini(&confine_region);
4551 wl_array_for_each(border, &borders) {
4554 distance_2 = point_to_border_distance_2(border, xf, yf);
4555 if (distance_2 < closest_distance_2) {
4556 closest_border = border;
4557 closest_distance_2 = distance_2;
4560 assert(closest_border);
4562 warp_to_behind_border(closest_border, &sx, &sy);
4564 wl_array_release(&borders);
4566 weston_view_to_global_fixed(constraint->view, sx, sy, &x, &y);
4567 weston_pointer_move_to(constraint->pointer, x, y);
4572 confined_pointer_grab_pointer_motion(struct weston_pointer_grab *grab,
4573 const struct timespec *time,
4574 struct weston_pointer_motion_event *event)
4576 struct weston_pointer_constraint *constraint =
4577 container_of(grab, struct weston_pointer_constraint, grab);
4578 struct weston_pointer *pointer = grab->pointer;
4579 struct weston_surface *surface;
4581 wl_fixed_t old_sx = pointer->sx;
4582 wl_fixed_t old_sy = pointer->sy;
4583 pixman_region32_t confine_region;
4585 assert(pointer->focus);
4586 assert(pointer->focus->surface == constraint->surface);
4588 surface = pointer->focus->surface;
4590 pixman_region32_init(&confine_region);
4591 pixman_region32_intersect(&confine_region,
4593 &constraint->region);
4594 weston_pointer_clamp_event_to_region(pointer, event,
4595 &confine_region, &x, &y);
4596 weston_pointer_move_to(pointer, x, y);
4597 pixman_region32_fini(&confine_region);
4599 weston_view_from_global_fixed(pointer->focus, x, y,
4600 &pointer->sx, &pointer->sy);
4602 if (old_sx != pointer->sx || old_sy != pointer->sy) {
4603 pointer_send_motion(pointer, time,
4604 pointer->sx, pointer->sy);
4607 pointer_send_relative_motion(pointer, time, event);
4611 confined_pointer_grab_pointer_button(struct weston_pointer_grab *grab,
4612 const struct timespec *time,
4616 weston_pointer_send_button(grab->pointer, time, button, state_w);
4620 confined_pointer_grab_pointer_axis(struct weston_pointer_grab *grab,
4621 const struct timespec *time,
4622 struct weston_pointer_axis_event *event)
4624 weston_pointer_send_axis(grab->pointer, time, event);
4628 confined_pointer_grab_pointer_axis_source(struct weston_pointer_grab *grab,
4631 weston_pointer_send_axis_source(grab->pointer, source);
4635 confined_pointer_grab_pointer_frame(struct weston_pointer_grab *grab)
4637 weston_pointer_send_frame(grab->pointer);
4641 confined_pointer_grab_pointer_cancel(struct weston_pointer_grab *grab)
4643 struct weston_pointer_constraint *constraint =
4644 container_of(grab, struct weston_pointer_constraint, grab);
4646 disable_pointer_constraint(constraint);
4649 static const struct weston_pointer_grab_interface
4650 confined_pointer_grab_interface = {
4651 confined_pointer_grab_pointer_focus,
4652 confined_pointer_grab_pointer_motion,
4653 confined_pointer_grab_pointer_button,
4654 confined_pointer_grab_pointer_axis,
4655 confined_pointer_grab_pointer_axis_source,
4656 confined_pointer_grab_pointer_frame,
4657 confined_pointer_grab_pointer_cancel,
4661 confined_pointer_destroy(struct wl_client *client,
4662 struct wl_resource *resource)
4664 wl_resource_destroy(resource);
4668 confined_pointer_set_region(struct wl_client *client,
4669 struct wl_resource *resource,
4670 struct wl_resource *region_resource)
4672 struct weston_pointer_constraint *constraint =
4673 wl_resource_get_user_data(resource);
4674 struct weston_region *region = region_resource ?
4675 wl_resource_get_user_data(region_resource) : NULL;
4681 pixman_region32_copy(&constraint->region_pending,
4684 pixman_region32_fini(&constraint->region_pending);
4685 region_init_infinite(&constraint->region_pending);
4687 constraint->region_is_pending = true;
4690 static const struct zwp_confined_pointer_v1_interface confined_pointer_interface = {
4691 confined_pointer_destroy,
4692 confined_pointer_set_region,
4696 pointer_constraints_confine_pointer(struct wl_client *client,
4697 struct wl_resource *resource,
4699 struct wl_resource *surface_resource,
4700 struct wl_resource *pointer_resource,
4701 struct wl_resource *region_resource,
4704 struct weston_surface *surface =
4705 wl_resource_get_user_data(surface_resource);
4706 struct weston_pointer *pointer = wl_resource_get_user_data(pointer_resource);
4707 struct weston_region *region = region_resource ?
4708 wl_resource_get_user_data(region_resource) : NULL;
4710 init_pointer_constraint(resource, id, surface, pointer, region, lifetime,
4711 &zwp_confined_pointer_v1_interface,
4712 &confined_pointer_interface,
4713 &confined_pointer_grab_interface);
4716 static const struct zwp_pointer_constraints_v1_interface pointer_constraints_interface = {
4717 pointer_constraints_destroy,
4718 pointer_constraints_lock_pointer,
4719 pointer_constraints_confine_pointer,
4723 bind_pointer_constraints(struct wl_client *client, void *data,
4724 uint32_t version, uint32_t id)
4726 struct wl_resource *resource;
4728 resource = wl_resource_create(client,
4729 &zwp_pointer_constraints_v1_interface,
4732 wl_resource_set_implementation(resource, &pointer_constraints_interface,
4737 input_timestamps_destroy(struct wl_client *client,
4738 struct wl_resource *resource)
4740 wl_resource_destroy(resource);
4743 static const struct zwp_input_timestamps_v1_interface
4744 input_timestamps_interface = {
4745 input_timestamps_destroy,
4749 input_timestamps_manager_destroy(struct wl_client *client,
4750 struct wl_resource *resource)
4752 wl_resource_destroy(resource);
4756 input_timestamps_manager_get_keyboard_timestamps(struct wl_client *client,
4757 struct wl_resource *resource,
4759 struct wl_resource *keyboard_resource)
4761 struct weston_keyboard *keyboard =
4762 wl_resource_get_user_data(keyboard_resource);
4763 struct wl_resource *input_ts;
4765 input_ts = wl_resource_create(client,
4766 &zwp_input_timestamps_v1_interface,
4769 wl_client_post_no_memory(client);
4774 wl_list_insert(&keyboard->timestamps_list,
4775 wl_resource_get_link(input_ts));
4777 wl_list_init(wl_resource_get_link(input_ts));
4780 wl_resource_set_implementation(input_ts,
4781 &input_timestamps_interface,
4787 input_timestamps_manager_get_pointer_timestamps(struct wl_client *client,
4788 struct wl_resource *resource,
4790 struct wl_resource *pointer_resource)
4792 struct weston_pointer *pointer =
4793 wl_resource_get_user_data(pointer_resource);
4794 struct wl_resource *input_ts;
4796 input_ts = wl_resource_create(client,
4797 &zwp_input_timestamps_v1_interface,
4800 wl_client_post_no_memory(client);
4805 wl_list_insert(&pointer->timestamps_list,
4806 wl_resource_get_link(input_ts));
4808 wl_list_init(wl_resource_get_link(input_ts));
4811 wl_resource_set_implementation(input_ts,
4812 &input_timestamps_interface,
4818 input_timestamps_manager_get_touch_timestamps(struct wl_client *client,
4819 struct wl_resource *resource,
4821 struct wl_resource *touch_resource)
4823 struct weston_touch *touch = wl_resource_get_user_data(touch_resource);
4824 struct wl_resource *input_ts;
4826 input_ts = wl_resource_create(client,
4827 &zwp_input_timestamps_v1_interface,
4830 wl_client_post_no_memory(client);
4835 wl_list_insert(&touch->timestamps_list,
4836 wl_resource_get_link(input_ts));
4838 wl_list_init(wl_resource_get_link(input_ts));
4841 wl_resource_set_implementation(input_ts,
4842 &input_timestamps_interface,
4847 static const struct zwp_input_timestamps_manager_v1_interface
4848 input_timestamps_manager_interface = {
4849 input_timestamps_manager_destroy,
4850 input_timestamps_manager_get_keyboard_timestamps,
4851 input_timestamps_manager_get_pointer_timestamps,
4852 input_timestamps_manager_get_touch_timestamps,
4856 bind_input_timestamps_manager(struct wl_client *client, void *data,
4857 uint32_t version, uint32_t id)
4859 struct wl_resource *resource =
4860 wl_resource_create(client,
4861 &zwp_input_timestamps_manager_v1_interface,
4864 if (resource == NULL) {
4865 wl_client_post_no_memory(client);
4869 wl_resource_set_implementation(resource,
4870 &input_timestamps_manager_interface,
4875 weston_input_init(struct weston_compositor *compositor)
4877 if (!wl_global_create(compositor->wl_display,
4878 &zwp_relative_pointer_manager_v1_interface, 1,
4879 compositor, bind_relative_pointer_manager))
4882 if (!wl_global_create(compositor->wl_display,
4883 &zwp_pointer_constraints_v1_interface, 1,
4884 NULL, bind_pointer_constraints))
4887 if (!wl_global_create(compositor->wl_display,
4888 &zwp_input_timestamps_manager_v1_interface, 1,
4889 NULL, bind_input_timestamps_manager))