mainnika
/
weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Implement pointer locking and confinement

Browse Source 
This patch implements the wp_pointer_constraints protocol used for
locking or confining a pointer. It consists of a new global object with
two requests; one for locking the surface to a position, one for
confining the pointer to a given region.

In this patch, only the locking part is fully implemented as in
specified in the protocol, while confinement is only implemented for
when the union of the passed region and the input region of the confined
surface is a single rectangle.

Note that the pointer constraints protocol is still unstable and as
such has the unstable protocol naming conventions applied.

Signed-off-by: Jonas Ådahl <jadahl@gmail.com>
Acked-by: Peter Hutterer <peter.hutterer@who-t.net>
Acked-by: Daniel Stone <daniels@collabora.com>
dev
Jonas Ådahl 8 years ago
parent c02ac11bd6
commit d3414f23c3
4 changed files with 845 additions and 1 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      Makefile.am
  2. 8
      libweston/compositor.c
  3. 35
      libweston/compositor.h
  4. 799
      libweston/input.c

4
Makefile.am
Unescape View File

@ -137,7 +137,9 @@ nodist_libweston_la_SOURCES = \
protocol/linux-dmabuf-unstable-v1-protocol.c \
protocol/linux-dmabuf-unstable-v1-server-protocol.h \
protocol/relative-pointer-unstable-v1-protocol.c \
protocol/relative-pointer-unstable-v1-server-protocol.h
protocol/relative-pointer-unstable-v1-server-protocol.h \
protocol/pointer-constraints-unstable-v1-protocol.c \
protocol/pointer-constraints-unstable-v1-server-protocol.h
BUILT_SOURCES += $(nodist_libweston_la_SOURCES)

8
libweston/compositor.c
Unescape View File

@ -482,6 +482,8 @@ weston_surface_create(struct weston_compositor *compositor)
weston_matrix_init(&surface->buffer_to_surface_matrix);
weston_matrix_init(&surface->surface_to_buffer_matrix);
wl_list_init(&surface->pointer_constraints);
return surface;
}
@ -1828,6 +1830,7 @@ weston_surface_destroy(struct weston_surface *surface)
{
struct weston_frame_callback *cb, *next;
struct weston_view *ev, *nv;
struct weston_pointer_constraint *constraint, *next_constraint;
if (--surface->ref_count > 0)
return;
@ -1855,6 +1858,11 @@ weston_surface_destroy(struct weston_surface *surface)
weston_presentation_feedback_discard_list(&surface->feedback_list);
wl_list_for_each_safe(constraint, next_constraint,
&surface->pointer_constraints,
link)
weston_pointer_constraint_destroy(constraint);
free(surface);
}

35
libweston/compositor.h
Unescape View File

@ -59,6 +59,7 @@ struct input_method;
struct weston_pointer;
struct linux_dmabuf_buffer;
struct weston_recorder;
struct weston_pointer_constraint;
enum weston_keyboard_modifier {
MODIFIER_CTRL = (1 << 0),
@ -452,6 +453,9 @@ void
weston_pointer_set_default_grab(struct weston_pointer *pointer,
const struct weston_pointer_grab_interface *interface);
void
weston_pointer_constraint_destroy(struct weston_pointer_constraint *constraint);
struct weston_keyboard *
weston_keyboard_create(void);
void
@ -810,6 +814,8 @@ struct weston_compositor {
unsigned int activate_serial;
struct wl_global *pointer_constraints;
int exit_code;
void *user_data;
@ -1017,6 +1023,32 @@ struct weston_surface_activation_data {
struct weston_seat *seat;
};
struct weston_pointer_constraint {
struct wl_list link;
struct weston_surface *surface;
struct weston_view *view;
struct wl_resource *resource;
struct weston_pointer_grab grab;
struct weston_pointer *pointer;
uint32_t lifetime;
pixman_region32_t region;
pixman_region32_t region_pending;
bool region_is_pending;
wl_fixed_t hint_x;
wl_fixed_t hint_y;
wl_fixed_t hint_x_pending;
wl_fixed_t hint_y_pending;
bool hint_is_pending;
struct wl_listener pointer_destroy_listener;
struct wl_listener surface_destroy_listener;
struct wl_listener surface_commit_listener;
struct wl_listener surface_activate_listener;
};
struct weston_surface {
struct wl_resource *resource;
struct wl_signal destroy_signal; /* callback argument: this surface */
@ -1104,6 +1136,9 @@ struct weston_surface {
struct weston_timeline_object timeline;
bool is_mapped;
/* An list of per seat pointer constraints. */
struct wl_list pointer_constraints;
};
struct weston_subsurface {

799
libweston/input.c
Unescape View File

@ -25,6 +25,7 @@
#include "config.h"
#include <stdbool.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
@ -38,6 +39,15 @@
#include "shared/os-compatibility.h"
#include "compositor.h"
#include "protocol/relative-pointer-unstable-v1-server-protocol.h"
#include "protocol/pointer-constraints-unstable-v1-server-protocol.h"
enum pointer_constraint_type {
POINTER_CONSTRAINT_TYPE_LOCK,
POINTER_CONSTRAINT_TYPE_CONFINE,
};
static void
maybe_warp_confined_pointer(struct weston_pointer_constraint *constraint);
static void
empty_region(pixman_region32_t *region)
@ -46,6 +56,13 @@ empty_region(pixman_region32_t *region)
pixman_region32_init(region);
}
static void
region_init_infinite(pixman_region32_t *region)
{
pixman_region32_init_rect(region, INT32_MIN, INT32_MIN,
UINT32_MAX, UINT32_MAX);
}
static struct weston_pointer_client *
weston_pointer_client_create(struct wl_client *client)
{
@ -2921,6 +2938,70 @@ weston_seat_get_pointer(struct weston_seat *seat)
return NULL;
}
static const struct zwp_locked_pointer_v1_interface locked_pointer_interface;
static const struct zwp_confined_pointer_v1_interface confined_pointer_interface;
static enum pointer_constraint_type
pointer_constraint_get_type(struct weston_pointer_constraint *constraint)
{
if (wl_resource_instance_of(constraint->resource,
&zwp_locked_pointer_v1_interface,
&locked_pointer_interface)) {
return POINTER_CONSTRAINT_TYPE_LOCK;
} else if (wl_resource_instance_of(constraint->resource,
&zwp_confined_pointer_v1_interface,
&confined_pointer_interface)) {
return POINTER_CONSTRAINT_TYPE_CONFINE;
}
abort();
return 0;
}
static void
pointer_constraint_notify_activated(struct weston_pointer_constraint *constraint)
{
struct wl_resource *resource = constraint->resource;
switch (pointer_constraint_get_type(constraint)) {
case POINTER_CONSTRAINT_TYPE_LOCK:
zwp_locked_pointer_v1_send_locked(resource);
break;
case POINTER_CONSTRAINT_TYPE_CONFINE:
zwp_confined_pointer_v1_send_confined(resource);
break;
}
}
static void
pointer_constraint_notify_deactivated(struct weston_pointer_constraint *constraint)
{
struct wl_resource *resource = constraint->resource;
switch (pointer_constraint_get_type(constraint)) {
case POINTER_CONSTRAINT_TYPE_LOCK:
zwp_locked_pointer_v1_send_unlocked(resource);
break;
case POINTER_CONSTRAINT_TYPE_CONFINE:
zwp_confined_pointer_v1_send_unconfined(resource);
break;
}
}
static struct weston_pointer_constraint *
get_pointer_constraint_for_pointer(struct weston_surface *surface,
struct weston_pointer *pointer)
{
struct weston_pointer_constraint *constraint;
wl_list_for_each(constraint, &surface->pointer_constraints, link) {
if (constraint->pointer == pointer)
return constraint;
}
return NULL;
}
/** Get a seat's touch pointer
*
* \param seat The seat to query
@ -2969,6 +3050,719 @@ weston_seat_set_keyboard_focus(struct weston_seat *seat,
wl_signal_emit(&compositor->activate_signal, &activation_data);
}
static void
enable_pointer_constraint(struct weston_pointer_constraint *constraint,
struct weston_view *view)
{
assert(constraint->view == NULL);
constraint->view = view;
pointer_constraint_notify_activated(constraint);
weston_pointer_start_grab(constraint->pointer, &constraint->grab);
wl_list_remove(&constraint->surface_destroy_listener.link);
wl_list_init(&constraint->surface_destroy_listener.link);
}
static bool
is_pointer_constraint_enabled(struct weston_pointer_constraint *constraint)
{
return constraint->view != NULL;
}
static void
weston_pointer_constraint_disable(struct weston_pointer_constraint *constraint)
{
constraint->view = NULL;
pointer_constraint_notify_deactivated(constraint);
weston_pointer_end_grab(constraint->grab.pointer);
}
void
weston_pointer_constraint_destroy(struct weston_pointer_constraint *constraint)
{
if (is_pointer_constraint_enabled(constraint))
weston_pointer_constraint_disable(constraint);
wl_list_remove(&constraint->pointer_destroy_listener.link);
wl_list_remove(&constraint->surface_destroy_listener.link);
wl_list_remove(&constraint->surface_commit_listener.link);
wl_list_remove(&constraint->surface_activate_listener.link);
wl_resource_set_user_data(constraint->resource, NULL);
pixman_region32_fini(&constraint->region);
wl_list_remove(&constraint->link);
free(constraint);
}
static void
disable_pointer_constraint(struct weston_pointer_constraint *constraint)
{
switch (constraint->lifetime) {
case ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT:
weston_pointer_constraint_destroy(constraint);
break;
case ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT:
weston_pointer_constraint_disable(constraint);
break;
}
}
static bool
is_within_constraint_region(struct weston_pointer_constraint *constraint,
wl_fixed_t sx, wl_fixed_t sy)
{
struct weston_surface *surface = constraint->surface;
pixman_region32_t constraint_region;
bool result;
pixman_region32_init(&constraint_region);
pixman_region32_intersect(&constraint_region,
&surface->input,
&constraint->region);
result = pixman_region32_contains_point(&constraint_region,
wl_fixed_to_int(sx),
wl_fixed_to_int(sy),
NULL);
pixman_region32_fini(&constraint_region);
return result;
}
static void
maybe_enable_pointer_constraint(struct weston_pointer_constraint *constraint)
{
struct weston_surface *surface = constraint->surface;
struct weston_view *vit;
struct weston_view *view = NULL;
struct weston_pointer *pointer = constraint->pointer;
struct weston_keyboard *keyboard;
struct weston_seat *seat = pointer->seat;
int32_t x, y;
/* Postpone if no view of the surface was most recently clicked. */
wl_list_for_each(vit, &surface->views, surface_link) {
if (vit->click_to_activate_serial ==
surface->compositor->activate_serial) {
view = vit;
}
}
if (view == NULL)
return;
/* Postpone if surface doesn't have keyboard focus. */
keyboard = weston_seat_get_keyboard(seat);
if (!keyboard || keyboard->focus != surface)
return;
/* Postpone constraint if the pointer is not within the
* constraint region.
*/
weston_view_from_global(view,
wl_fixed_to_int(pointer->x),
wl_fixed_to_int(pointer->y),
&x, &y);
if (!is_within_constraint_region(constraint,
wl_fixed_from_int(x),
wl_fixed_from_int(y)))
return;
enable_pointer_constraint(constraint, view);
}
static void
locked_pointer_grab_pointer_focus(struct weston_pointer_grab *grab)
{
}
static void
locked_pointer_grab_pointer_motion(struct weston_pointer_grab *grab,
uint32_t time,
struct weston_pointer_motion_event *event)
{
weston_pointer_send_relative_motion(grab->pointer, time, event);
}
static void
locked_pointer_grab_pointer_button(struct weston_pointer_grab *grab,
uint32_t time,
uint32_t button,
uint32_t state_w)
{
weston_pointer_send_button(grab->pointer, time, button, state_w);
}
static void
locked_pointer_grab_pointer_axis(struct weston_pointer_grab *grab,
uint32_t time,
struct weston_pointer_axis_event *event)
{
weston_pointer_send_axis(grab->pointer, time, event);
}
static void
locked_pointer_grab_pointer_axis_source(struct weston_pointer_grab *grab,
uint32_t source)
{
weston_pointer_send_axis_source(grab->pointer, source);
}
static void
locked_pointer_grab_pointer_frame(struct weston_pointer_grab *grab)
{
weston_pointer_send_frame(grab->pointer);
}
static void
locked_pointer_grab_pointer_cancel(struct weston_pointer_grab *grab)
{
struct weston_pointer_constraint *constraint =
container_of(grab, struct weston_pointer_constraint, grab);
disable_pointer_constraint(constraint);
}
static const struct weston_pointer_grab_interface
locked_pointer_grab_interface = {
locked_pointer_grab_pointer_focus,
locked_pointer_grab_pointer_motion,
locked_pointer_grab_pointer_button,
locked_pointer_grab_pointer_axis,
locked_pointer_grab_pointer_axis_source,
locked_pointer_grab_pointer_frame,
locked_pointer_grab_pointer_cancel,
};
static void
pointer_constraint_constrain_resource_destroyed(struct wl_resource *resource)
{
struct weston_pointer_constraint *constraint =
wl_resource_get_user_data(resource);
if (!constraint)
return;
weston_pointer_constraint_destroy(constraint);
}
static void
pointer_constraint_surface_activate(struct wl_listener *listener, void *data)
{
struct weston_surface_activation_data *activation = data;
struct weston_pointer *pointer;
struct weston_surface *focus = activation->surface;
struct weston_pointer_constraint *constraint =
container_of(listener, struct weston_pointer_constraint,
surface_activate_listener);
bool is_constraint_surface;
pointer = weston_seat_get_pointer(activation->seat);
if (!pointer)
return;
is_constraint_surface =
get_pointer_constraint_for_pointer(focus, pointer) == constraint;
if (is_constraint_surface &&
!is_pointer_constraint_enabled(constraint))
maybe_enable_pointer_constraint(constraint);
else if (!is_constraint_surface &&
is_pointer_constraint_enabled(constraint))
disable_pointer_constraint(constraint);
}
static void
pointer_constraint_pointer_destroyed(struct wl_listener *listener, void *data)
{
struct weston_pointer_constraint *constraint =
container_of(listener, struct weston_pointer_constraint,
pointer_destroy_listener);
weston_pointer_constraint_destroy(constraint);
}
static void
pointer_constraint_surface_destroyed(struct wl_listener *listener, void *data)
{
struct weston_pointer_constraint *constraint =
container_of(listener, struct weston_pointer_constraint,
surface_destroy_listener);
weston_pointer_constraint_destroy(constraint);
}
static void
pointer_constraint_surface_committed(struct wl_listener *listener, void *data)
{
struct weston_pointer_constraint *constraint =
container_of(listener, struct weston_pointer_constraint,
surface_commit_listener);
if (constraint->region_is_pending) {
constraint->region_is_pending = false;
pixman_region32_copy(&constraint->region,
&constraint->region_pending);
pixman_region32_fini(&constraint->region_pending);
pixman_region32_init(&constraint->region_pending);
}
if (constraint->hint_is_pending) {
constraint->hint_is_pending = false;
constraint->hint_is_pending = true;
constraint->hint_x = constraint->hint_x_pending;
constraint->hint_y = constraint->hint_y_pending;
}
if (pointer_constraint_get_type(constraint) ==
POINTER_CONSTRAINT_TYPE_CONFINE &&
is_pointer_constraint_enabled(constraint))
maybe_warp_confined_pointer(constraint);
}
static struct weston_pointer_constraint *
weston_pointer_constraint_create(struct weston_surface *surface,
struct weston_pointer *pointer,
struct weston_region *region,
enum zwp_pointer_constraints_v1_lifetime lifetime,
struct wl_resource *cr,
const struct weston_pointer_grab_interface *grab_interface)
{
struct weston_pointer_constraint *constraint;
constraint = zalloc(sizeof *constraint);
if (!constraint)
return NULL;
constraint->lifetime = lifetime;
pixman_region32_init(&constraint->region);
pixman_region32_init(&constraint->region_pending);
wl_list_insert(&surface->pointer_constraints, &constraint->link);
constraint->surface = surface;
constraint->pointer = pointer;
constraint->resource = cr;
constraint->grab.interface = grab_interface;
if (region) {
pixman_region32_copy(&constraint->region,
&region->region);
} else {
pixman_region32_fini(&constraint->region);
region_init_infinite(&constraint->region);
}
constraint->surface_activate_listener.notify =
pointer_constraint_surface_activate;
constraint->surface_destroy_listener.notify =
pointer_constraint_surface_destroyed;
constraint->surface_commit_listener.notify =
pointer_constraint_surface_committed;
constraint->pointer_destroy_listener.notify =
pointer_constraint_pointer_destroyed;
wl_signal_add(&surface->compositor->activate_signal,
&constraint->surface_activate_listener);
wl_signal_add(&pointer->destroy_signal,
&constraint->pointer_destroy_listener);
wl_signal_add(&surface->destroy_signal,
&constraint->surface_destroy_listener);
wl_signal_add(&surface->commit_signal,
&constraint->surface_commit_listener);
return constraint;
}
static void
init_pointer_constraint(struct wl_resource *pointer_constraints_resource,
uint32_t id,
struct weston_surface *surface,
struct weston_pointer *pointer,
struct weston_region *region,
enum zwp_pointer_constraints_v1_lifetime lifetime,
const struct wl_interface *interface,
const void *implementation,
const struct weston_pointer_grab_interface *grab_interface)
{
struct wl_client *client =
wl_resource_get_client(pointer_constraints_resource);
struct wl_resource *cr;
struct weston_pointer_constraint *constraint;
if (get_pointer_constraint_for_pointer(surface, pointer)) {
wl_resource_post_error(pointer_constraints_resource,
ZWP_POINTER_CONSTRAINTS_V1_ERROR_ALREADY_CONSTRAINED,
"the pointer has a lock/confine request on this surface");
return;
}
cr = wl_resource_create(client, interface,
wl_resource_get_version(pointer_constraints_resource),
id);
if (cr == NULL) {
wl_client_post_no_memory(client);
return;
}
constraint = weston_pointer_constraint_create(surface, pointer,
region, lifetime,
cr, grab_interface);
if (constraint == NULL) {
wl_client_post_no_memory(client);
return;
}
wl_resource_set_implementation(cr, implementation, constraint,
pointer_constraint_constrain_resource_destroyed);
maybe_enable_pointer_constraint(constraint);
}
static void
pointer_constraints_destroy(struct wl_client *client,
struct wl_resource *resource)
{
wl_resource_destroy(resource);
}
static void
locked_pointer_destroy(struct wl_client *client,
struct wl_resource *resource)
{
struct weston_pointer_constraint *constraint =
wl_resource_get_user_data(resource);
wl_fixed_t x, y;
if (constraint && constraint->view && constraint->hint_is_pending &&
is_within_constraint_region(constraint,
constraint->hint_x,
constraint->hint_y)) {
weston_view_to_global_fixed(constraint->view,
constraint->hint_x,
constraint->hint_y,
&x, &y);
weston_pointer_move_to(constraint->pointer, x, y);
}
wl_resource_destroy(resource);
}
static void
locked_pointer_set_cursor_position_hint(struct wl_client *client,
struct wl_resource *resource,
wl_fixed_t surface_x,
wl_fixed_t surface_y)
{
struct weston_pointer_constraint *constraint =
wl_resource_get_user_data(resource);
/* Ignore a set cursor hint that was sent after the lock was cancelled.
*/
if (!constraint ||
!constraint->resource ||
constraint->resource != resource)
return;
constraint->hint_is_pending = true;
constraint->hint_x_pending = surface_x;
constraint->hint_y_pending = surface_y;
}
static void
locked_pointer_set_region(struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *region_resource)
{
struct weston_pointer_constraint *constraint =
wl_resource_get_user_data(resource);
struct weston_region *region = region_resource ?
wl_resource_get_user_data(region_resource) : NULL;
if (!constraint)
return;
if (region) {
pixman_region32_copy(&constraint->region_pending,
&region->region);
} else {
pixman_region32_fini(&constraint->region_pending);
region_init_infinite(&constraint->region_pending);
}
constraint->region_is_pending = true;
}
static const struct zwp_locked_pointer_v1_interface locked_pointer_interface = {
locked_pointer_destroy,
locked_pointer_set_cursor_position_hint,
locked_pointer_set_region,
};
static void
pointer_constraints_lock_pointer(struct wl_client *client,
struct wl_resource *resource,
uint32_t id,
struct wl_resource *surface_resource,
struct wl_resource *pointer_resource,
struct wl_resource *region_resource,
uint32_t lifetime)
{
struct weston_surface *surface =
wl_resource_get_user_data(surface_resource);
struct weston_pointer *pointer = wl_resource_get_user_data(pointer_resource);
struct weston_region *region = region_resource ?
wl_resource_get_user_data(region_resource) : NULL;
init_pointer_constraint(resource, id, surface, pointer, region, lifetime,
&zwp_locked_pointer_v1_interface,
&locked_pointer_interface,
&locked_pointer_grab_interface);
}
static void
confined_pointer_grab_pointer_focus(struct weston_pointer_grab *grab)
{
}
static void
weston_pointer_clamp_event_to_region(struct weston_pointer *pointer,
struct weston_pointer_motion_event *event,
pixman_region32_t *region,
wl_fixed_t *clamped_x,
wl_fixed_t *clamped_y)
{
wl_fixed_t x, y;
wl_fixed_t sx, sy;
wl_fixed_t min_sx = wl_fixed_from_int(region->extents.x1);
wl_fixed_t max_sx = wl_fixed_from_int(region->extents.x2 - 1);
wl_fixed_t max_sy = wl_fixed_from_int(region->extents.y2 - 1);
wl_fixed_t min_sy = wl_fixed_from_int(region->extents.y1);
weston_pointer_motion_to_abs(pointer, event, &x, &y);
weston_view_from_global_fixed(pointer->focus, x, y, &sx, &sy);
if (sx < min_sx)
sx = min_sx;
else if (sx > max_sx)
sx = max_sx;
if (sy < min_sy)
sy = min_sy;
else if (sy > max_sy)
sy = max_sy;
weston_view_to_global_fixed(pointer->focus, sx, sy,
clamped_x, clamped_y);
}
static void
maybe_warp_confined_pointer(struct weston_pointer_constraint *constraint)
{
wl_fixed_t x;
wl_fixed_t y;
wl_fixed_t sx;
wl_fixed_t sy;
weston_view_from_global_fixed(constraint->view,
constraint->pointer->x,
constraint->pointer->y,
&sx,
&sy);
if (!is_within_constraint_region(constraint, sx, sy)) {
pixman_region32_t *region = &constraint->region;
wl_fixed_t min_sx = wl_fixed_from_int(region->extents.x1);
wl_fixed_t max_sx = wl_fixed_from_int(region->extents.x2 - 1);
wl_fixed_t max_sy = wl_fixed_from_int(region->extents.y2 - 1);
wl_fixed_t min_sy = wl_fixed_from_int(region->extents.y1);
if (sx < min_sx)
sx = min_sx;
else if (sx > max_sx)
sx = max_sx;
if (sy < min_sy)
sy = min_sy;
else if (sy > max_sy)
sy = max_sy;
weston_view_to_global_fixed(constraint->view, sx, sy, &x, &y);
weston_pointer_move_to(constraint->pointer, x, y);
}
}
static void
confined_pointer_grab_pointer_motion(struct weston_pointer_grab *grab,
uint32_t time,
struct weston_pointer_motion_event *event)
{
struct weston_pointer_constraint *constraint =
container_of(grab, struct weston_pointer_constraint, grab);
struct weston_pointer *pointer = grab->pointer;
struct weston_surface *surface;
wl_fixed_t x, y;
wl_fixed_t old_sx = pointer->sx;
wl_fixed_t old_sy = pointer->sy;
pixman_region32_t confine_region;
assert(pointer->focus);
assert(pointer->focus->surface == constraint->surface);
surface = pointer->focus->surface;
pixman_region32_init(&confine_region);
pixman_region32_intersect(&confine_region,
&surface->input,
&constraint->region);
weston_pointer_clamp_event_to_region(pointer, event,
&confine_region, &x, &y);
weston_pointer_move_to(pointer, x, y);
pixman_region32_fini(&confine_region);
weston_view_from_global_fixed(pointer->focus, x, y,
&pointer->sx, &pointer->sy);
if (old_sx != pointer->sx || old_sy != pointer->sy) {
weston_pointer_send_motion(pointer, time,
pointer->sx, pointer->sy);
}
weston_pointer_send_relative_motion(pointer, time, event);
}
static void
confined_pointer_grab_pointer_button(struct weston_pointer_grab *grab,
uint32_t time,
uint32_t button,
uint32_t state_w)
{
weston_pointer_send_button(grab->pointer, time, button, state_w);
}
static void
confined_pointer_grab_pointer_axis(struct weston_pointer_grab *grab,
uint32_t time,
struct weston_pointer_axis_event *event)
{
weston_pointer_send_axis(grab->pointer, time, event);
}
static void
confined_pointer_grab_pointer_axis_source(struct weston_pointer_grab *grab,
uint32_t source)
{
weston_pointer_send_axis_source(grab->pointer, source);
}
static void
confined_pointer_grab_pointer_frame(struct weston_pointer_grab *grab)
{
weston_pointer_send_frame(grab->pointer);
}
static void
confined_pointer_grab_pointer_cancel(struct weston_pointer_grab *grab)
{
struct weston_pointer_constraint *constraint =
container_of(grab, struct weston_pointer_constraint, grab);
disable_pointer_constraint(constraint);
/* If this is a persistent constraint, re-add the surface destroy signal
* listener only if we are currently not destroying the surface. */
switch (constraint->lifetime) {
case ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT:
if (constraint->surface->resource)
wl_signal_add(&constraint->surface->destroy_signal,
&constraint->surface_destroy_listener);
break;
case ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT:
break;
}
}
static const struct weston_pointer_grab_interface
confined_pointer_grab_interface = {
confined_pointer_grab_pointer_focus,
confined_pointer_grab_pointer_motion,
confined_pointer_grab_pointer_button,
confined_pointer_grab_pointer_axis,
confined_pointer_grab_pointer_axis_source,
confined_pointer_grab_pointer_frame,
confined_pointer_grab_pointer_cancel,
};
static void
confined_pointer_destroy(struct wl_client *client,
struct wl_resource *resource)
{
wl_resource_destroy(resource);
}
static void
confined_pointer_set_region(struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *region_resource)
{
struct weston_pointer_constraint *constraint =
wl_resource_get_user_data(resource);
struct weston_region *region = region_resource ?
wl_resource_get_user_data(region_resource) : NULL;
if (!constraint)
return;
if (region) {
pixman_region32_copy(&constraint->region_pending,
&region->region);
} else {
pixman_region32_fini(&constraint->region_pending);
region_init_infinite(&constraint->region_pending);
}
constraint->region_is_pending = true;
}
static const struct zwp_confined_pointer_v1_interface confined_pointer_interface = {
confined_pointer_destroy,
confined_pointer_set_region,
};
static void
pointer_constraints_confine_pointer(struct wl_client *client,
struct wl_resource *resource,
uint32_t id,
struct wl_resource *surface_resource,
struct wl_resource *pointer_resource,
struct wl_resource *region_resource,
uint32_t lifetime)
{
struct weston_surface *surface =
wl_resource_get_user_data(surface_resource);
struct weston_pointer *pointer = wl_resource_get_user_data(pointer_resource);
struct weston_region *region = region_resource ?
wl_resource_get_user_data(region_resource) : NULL;
init_pointer_constraint(resource, id, surface, pointer, region, lifetime,
&zwp_confined_pointer_v1_interface,
&confined_pointer_interface,
&confined_pointer_grab_interface);
}
static const struct zwp_pointer_constraints_v1_interface pointer_constraints_interface = {
pointer_constraints_destroy,
pointer_constraints_lock_pointer,
pointer_constraints_confine_pointer,
};
static void
bind_pointer_constraints(struct wl_client *client, void *data,
uint32_t version, uint32_t id)
{
struct wl_resource *resource;
resource = wl_resource_create(client,
&zwp_pointer_constraints_v1_interface,
1, id);
wl_resource_set_implementation(resource, &pointer_constraints_interface,
NULL, NULL);
}
int
weston_input_init(struct weston_compositor *compositor)
{
@ -2977,5 +3771,10 @@ weston_input_init(struct weston_compositor *compositor)
compositor, bind_relative_pointer_manager))
return -1;
if (!wl_global_create(compositor->wl_display,
&zwp_pointer_constraints_v1_interface, 1,
NULL, bind_pointer_constraints))
return -1;
return 0;
}

Write Preview
Loading…
Cancel
Save