363 lines
12 KiB
C
363 lines
12 KiB
C
|
#include <assert.h>
|
||
|
#include <limits.h>
|
||
|
#include <stdbool.h>
|
||
|
#include <stdlib.h>
|
||
|
#include <pixman.h>
|
||
|
#include <wayland-server.h>
|
||
|
#include <wlr/types/wlr_box.h>
|
||
|
#include <wlr/types/wlr_pointer_constraints_v1.h>
|
||
|
#include <wlr/types/wlr_region.h>
|
||
|
#include <wlr/util/log.h>
|
||
|
|
||
|
#include "util/signal.h"
|
||
|
|
||
|
static const struct zwp_locked_pointer_v1_interface locked_pointer_impl;
|
||
|
static const struct zwp_confined_pointer_v1_interface confined_pointer_impl;
|
||
|
static const struct zwp_pointer_constraints_v1_interface pointer_constraints_impl;
|
||
|
static void pointer_constraint_destroy(struct wlr_pointer_constraint_v1 *constraint);
|
||
|
|
||
|
static struct wlr_pointer_constraint_v1 *pointer_constraint_from_resource(
|
||
|
struct wl_resource *resource) {
|
||
|
assert(
|
||
|
wl_resource_instance_of(
|
||
|
resource, &zwp_confined_pointer_v1_interface,
|
||
|
&confined_pointer_impl) ||
|
||
|
wl_resource_instance_of(
|
||
|
resource, &zwp_locked_pointer_v1_interface,
|
||
|
&locked_pointer_impl));
|
||
|
return wl_resource_get_user_data(resource);
|
||
|
}
|
||
|
|
||
|
static struct wlr_pointer_constraints_v1 *pointer_constraints_from_resource(
|
||
|
struct wl_resource *resource) {
|
||
|
assert(wl_resource_instance_of(resource, &zwp_pointer_constraints_v1_interface,
|
||
|
&pointer_constraints_impl));
|
||
|
return wl_resource_get_user_data(resource);
|
||
|
}
|
||
|
|
||
|
static void resource_destroy(struct wl_client *client,
|
||
|
struct wl_resource *resource) {
|
||
|
wl_resource_destroy(resource);
|
||
|
}
|
||
|
|
||
|
static void pointer_constraint_destroy(struct wlr_pointer_constraint_v1 *constraint) {
|
||
|
if (constraint == NULL) {
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
wlr_log(WLR_DEBUG, "destroying constraint %p", constraint);
|
||
|
|
||
|
wl_resource_set_user_data(constraint->resource, NULL);
|
||
|
wl_list_remove(&constraint->link);
|
||
|
wl_list_remove(&constraint->surface_commit.link);
|
||
|
wl_list_remove(&constraint->surface_destroy.link);
|
||
|
wl_list_remove(&constraint->seat_destroy.link);
|
||
|
|
||
|
wlr_signal_emit_safe(
|
||
|
&constraint->pointer_constraints->events.constraint_destroy,
|
||
|
constraint);
|
||
|
|
||
|
if (constraint->current.region) {
|
||
|
pixman_region32_fini(constraint->current.region);
|
||
|
free(constraint->current.region);
|
||
|
}
|
||
|
if (constraint->pending.region &&
|
||
|
constraint->current.region != constraint->pending.region) {
|
||
|
pixman_region32_fini(constraint->pending.region);
|
||
|
free(constraint->pending.region);
|
||
|
}
|
||
|
pixman_region32_fini(&constraint->region);
|
||
|
free(constraint);
|
||
|
}
|
||
|
|
||
|
static void pointer_constraint_destroy_resource(struct wl_resource *resource) {
|
||
|
struct wlr_pointer_constraint_v1 *constraint =
|
||
|
pointer_constraint_from_resource(resource);
|
||
|
|
||
|
pointer_constraint_destroy(constraint);
|
||
|
}
|
||
|
|
||
|
static void pointer_constraint_set_region(
|
||
|
struct wlr_pointer_constraint_v1 *constraint,
|
||
|
struct wl_resource *region_resource) {
|
||
|
if (constraint->pending.region &&
|
||
|
constraint->current.region != constraint->pending.region) {
|
||
|
pixman_region32_fini(constraint->pending.region);
|
||
|
free(constraint->pending.region);
|
||
|
}
|
||
|
|
||
|
if (region_resource) {
|
||
|
constraint->pending.region = calloc(1, sizeof(pixman_region32_t));
|
||
|
pixman_region32_init(constraint->pending.region);
|
||
|
|
||
|
pixman_region32_t *region = wlr_region_from_resource(region_resource);
|
||
|
pixman_region32_copy(constraint->pending.region, region);
|
||
|
} else {
|
||
|
constraint->pending.region = NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void pointer_constraint_set_region_wrapper(struct wl_client *client,
|
||
|
struct wl_resource *resource, struct wl_resource *region_resource) {
|
||
|
struct wlr_pointer_constraint_v1 *constraint =
|
||
|
pointer_constraint_from_resource(resource);
|
||
|
|
||
|
pointer_constraint_set_region(constraint, region_resource);
|
||
|
}
|
||
|
|
||
|
static void pointer_constraint_set_cursor_position_hint(struct wl_client *client,
|
||
|
struct wl_resource *resource, wl_fixed_t x, wl_fixed_t y) {
|
||
|
struct wlr_pointer_constraint_v1 *constraint =
|
||
|
pointer_constraint_from_resource(resource);
|
||
|
|
||
|
constraint->pending.cursor_hint.x = wl_fixed_to_double(x);
|
||
|
constraint->pending.cursor_hint.y = wl_fixed_to_double(y);
|
||
|
constraint->pending.cursor_hint.valid = true;
|
||
|
}
|
||
|
|
||
|
static void pointer_constraint_handle_commit(
|
||
|
struct wlr_pointer_constraint_v1 *constraint) {
|
||
|
constraint->current.cursor_hint = constraint->pending.cursor_hint;
|
||
|
|
||
|
if (constraint->current.region != constraint->pending.region) {
|
||
|
if (constraint->current.region) {
|
||
|
pixman_region32_fini(constraint->current.region);
|
||
|
free(constraint->current.region);
|
||
|
}
|
||
|
|
||
|
constraint->current.region = constraint->pending.region;
|
||
|
}
|
||
|
|
||
|
pixman_region32_clear(&constraint->region);
|
||
|
|
||
|
if (constraint->current.region) {
|
||
|
pixman_region32_intersect(&constraint->region,
|
||
|
&constraint->surface->input_region, constraint->current.region);
|
||
|
} else {
|
||
|
pixman_region32_copy(&constraint->region,
|
||
|
&constraint->surface->input_region);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void handle_surface_commit(struct wl_listener *listener, void *data) {
|
||
|
struct wlr_pointer_constraint_v1 *constraint =
|
||
|
wl_container_of(listener, constraint, surface_commit);
|
||
|
|
||
|
pointer_constraint_handle_commit(constraint);
|
||
|
}
|
||
|
|
||
|
static void handle_surface_destroy(struct wl_listener *listener, void *data) {
|
||
|
struct wlr_pointer_constraint_v1 *constraint =
|
||
|
wl_container_of(listener, constraint, surface_destroy);
|
||
|
|
||
|
pointer_constraint_destroy(constraint);
|
||
|
}
|
||
|
|
||
|
static void handle_seat_destroy(struct wl_listener *listener, void *data) {
|
||
|
struct wlr_pointer_constraint_v1 *constraint =
|
||
|
wl_container_of(listener, constraint, seat_destroy);
|
||
|
|
||
|
pointer_constraint_destroy(constraint);
|
||
|
}
|
||
|
|
||
|
static const struct zwp_confined_pointer_v1_interface confined_pointer_impl = {
|
||
|
.destroy = resource_destroy,
|
||
|
.set_region = pointer_constraint_set_region_wrapper,
|
||
|
};
|
||
|
|
||
|
static const struct zwp_locked_pointer_v1_interface locked_pointer_impl = {
|
||
|
.destroy = resource_destroy,
|
||
|
.set_region = pointer_constraint_set_region_wrapper,
|
||
|
.set_cursor_position_hint = pointer_constraint_set_cursor_position_hint,
|
||
|
};
|
||
|
|
||
|
static void pointer_constraint_create(struct wl_client *client,
|
||
|
struct wl_resource *pointer_constraints_resource, uint32_t id,
|
||
|
struct wl_resource *surface_resource, struct wl_resource *pointer_resource,
|
||
|
struct wl_resource *region_resource,
|
||
|
enum zwp_pointer_constraints_v1_lifetime lifetime,
|
||
|
enum wlr_pointer_constraint_v1_type type) {
|
||
|
struct wlr_pointer_constraints_v1 *pointer_constraints =
|
||
|
pointer_constraints_from_resource(pointer_constraints_resource);
|
||
|
|
||
|
struct wlr_surface *surface = wlr_surface_from_resource(surface_resource);
|
||
|
struct wlr_seat *seat = wlr_seat_client_from_pointer_resource(pointer_resource)->seat;
|
||
|
|
||
|
if (wlr_pointer_constraints_v1_constraint_for_surface(pointer_constraints,
|
||
|
surface, seat)) {
|
||
|
wl_resource_post_error(pointer_constraints_resource,
|
||
|
ZWP_POINTER_CONSTRAINTS_V1_ERROR_ALREADY_CONSTRAINED,
|
||
|
"a pointer constraint with a wl_pointer of the same wl_seat"
|
||
|
" is already on this surface");
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
uint32_t version = wl_resource_get_version(pointer_constraints_resource);
|
||
|
|
||
|
bool locked_pointer = type == WLR_POINTER_CONSTRAINT_V1_LOCKED;
|
||
|
|
||
|
struct wl_resource *resource = locked_pointer ?
|
||
|
wl_resource_create(client, &zwp_locked_pointer_v1_interface, version, id) :
|
||
|
wl_resource_create(client, &zwp_confined_pointer_v1_interface, version, id);
|
||
|
|
||
|
if (resource == NULL) {
|
||
|
wl_client_post_no_memory(client);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
struct wlr_pointer_constraint_v1 *constraint = calloc(1, sizeof(*constraint));
|
||
|
if (constraint == NULL) {
|
||
|
wl_client_post_no_memory(client);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
constraint->resource = resource;
|
||
|
constraint->surface = surface;
|
||
|
constraint->seat = seat;
|
||
|
constraint->lifetime = lifetime;
|
||
|
constraint->type = type;
|
||
|
constraint->pointer_constraints = pointer_constraints;
|
||
|
|
||
|
pixman_region32_init(&constraint->region);
|
||
|
|
||
|
pointer_constraint_set_region(constraint, region_resource);
|
||
|
pointer_constraint_handle_commit(constraint);
|
||
|
|
||
|
constraint->surface_commit.notify = handle_surface_commit;
|
||
|
wl_signal_add(&surface->events.commit, &constraint->surface_commit);
|
||
|
|
||
|
constraint->surface_destroy.notify = handle_surface_destroy;
|
||
|
wl_signal_add(&surface->events.destroy, &constraint->surface_destroy);
|
||
|
|
||
|
constraint->seat_destroy.notify = handle_seat_destroy;
|
||
|
wl_signal_add(&seat->events.destroy, &constraint->seat_destroy);
|
||
|
|
||
|
wl_resource_set_implementation(constraint->resource,
|
||
|
locked_pointer ? (void*)&locked_pointer_impl : (void*)&confined_pointer_impl,
|
||
|
constraint, pointer_constraint_destroy_resource);
|
||
|
|
||
|
wlr_log(WLR_DEBUG, "new %s_pointer %p (res %p)",
|
||
|
locked_pointer ? "locked" : "confined", constraint, constraint->resource);
|
||
|
|
||
|
wl_list_insert(&pointer_constraints->constraints, &constraint->link);
|
||
|
|
||
|
wlr_signal_emit_safe(&pointer_constraints->events.constraint_create,
|
||
|
constraint);
|
||
|
}
|
||
|
|
||
|
static void pointer_constraints_lock_pointer(struct wl_client *client,
|
||
|
struct wl_resource *cons_resource, uint32_t id,
|
||
|
struct wl_resource *surface, struct wl_resource *pointer,
|
||
|
struct wl_resource *region, enum zwp_pointer_constraints_v1_lifetime lifetime) {
|
||
|
pointer_constraint_create(client, cons_resource, id, surface, pointer,
|
||
|
region, lifetime, WLR_POINTER_CONSTRAINT_V1_LOCKED);
|
||
|
}
|
||
|
|
||
|
static void pointer_constraints_confine_pointer(struct wl_client *client,
|
||
|
struct wl_resource *cons_resource, uint32_t id,
|
||
|
struct wl_resource *surface, struct wl_resource *pointer,
|
||
|
struct wl_resource *region, enum zwp_pointer_constraints_v1_lifetime lifetime) {
|
||
|
pointer_constraint_create(client, cons_resource, id, surface, pointer,
|
||
|
region, lifetime, WLR_POINTER_CONSTRAINT_V1_CONFINED);
|
||
|
}
|
||
|
|
||
|
static const struct zwp_pointer_constraints_v1_interface pointer_constraints_impl = {
|
||
|
.destroy = resource_destroy,
|
||
|
.lock_pointer = pointer_constraints_lock_pointer,
|
||
|
.confine_pointer = pointer_constraints_confine_pointer,
|
||
|
};
|
||
|
|
||
|
static void pointer_constraints_destroy(struct wl_resource *resource) {
|
||
|
wl_list_remove(wl_resource_get_link(resource));
|
||
|
}
|
||
|
|
||
|
static void pointer_constraints_bind(struct wl_client *client, void *data,
|
||
|
uint32_t version, uint32_t id) {
|
||
|
struct wlr_pointer_constraints_v1 *pointer_constraints = data;
|
||
|
assert(client && pointer_constraints);
|
||
|
|
||
|
struct wl_resource *resource = wl_resource_create(client,
|
||
|
&zwp_pointer_constraints_v1_interface, version, id);
|
||
|
if (resource == NULL) {
|
||
|
wl_client_post_no_memory(client);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
wl_list_insert(&pointer_constraints->wl_resources, wl_resource_get_link(resource));
|
||
|
wl_resource_set_implementation(resource, &pointer_constraints_impl,
|
||
|
pointer_constraints, pointer_constraints_destroy);
|
||
|
}
|
||
|
|
||
|
struct wlr_pointer_constraints_v1 *wlr_pointer_constraints_v1_create(
|
||
|
struct wl_display *display) {
|
||
|
struct wlr_pointer_constraints_v1 *pointer_constraints =
|
||
|
calloc(1, sizeof(*pointer_constraints));
|
||
|
|
||
|
if (!pointer_constraints) {
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
struct wl_global *wl_global = wl_global_create(display,
|
||
|
&zwp_pointer_constraints_v1_interface, 1, pointer_constraints,
|
||
|
pointer_constraints_bind);
|
||
|
if (!wl_global) {
|
||
|
free(pointer_constraints);
|
||
|
return NULL;
|
||
|
}
|
||
|
pointer_constraints->wl_global = wl_global;
|
||
|
|
||
|
wl_list_init(&pointer_constraints->wl_resources);
|
||
|
wl_list_init(&pointer_constraints->constraints);
|
||
|
wl_signal_init(&pointer_constraints->events.constraint_create);
|
||
|
wl_signal_init(&pointer_constraints->events.constraint_destroy);
|
||
|
|
||
|
return pointer_constraints;
|
||
|
}
|
||
|
|
||
|
void wlr_pointer_constraints_v1_destroy(
|
||
|
struct wlr_pointer_constraints_v1 *pointer_constraints) {
|
||
|
struct wl_resource *resource, *_tmp_res;
|
||
|
wl_resource_for_each_safe(resource, _tmp_res, &pointer_constraints->wl_resources) {
|
||
|
wl_resource_destroy(resource);
|
||
|
}
|
||
|
|
||
|
struct wlr_pointer_constraint_v1 *constraint, *_tmp_cons;
|
||
|
wl_list_for_each_safe(constraint, _tmp_cons, &pointer_constraints->constraints, link) {
|
||
|
wl_resource_destroy(constraint->resource);
|
||
|
}
|
||
|
|
||
|
wl_global_destroy(pointer_constraints->wl_global);
|
||
|
free(pointer_constraints);
|
||
|
}
|
||
|
|
||
|
struct wlr_pointer_constraint_v1 *wlr_pointer_constraints_v1_constraint_for_surface(
|
||
|
struct wlr_pointer_constraints_v1 *pointer_constraints,
|
||
|
struct wlr_surface *surface, struct wlr_seat *seat) {
|
||
|
struct wlr_pointer_constraint_v1 *constraint;
|
||
|
wl_list_for_each(constraint, &pointer_constraints->constraints, link) {
|
||
|
if (constraint->surface == surface && constraint->seat == seat) {
|
||
|
return constraint;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
// Thankfully zwp_confined_pointer_v1_send_{un,}confined work
|
||
|
// on both locked and confined pointer constraints.
|
||
|
void wlr_pointer_constraint_v1_send_activated(
|
||
|
struct wlr_pointer_constraint_v1 *constraint) {
|
||
|
wlr_log(WLR_DEBUG, "constrained %p", constraint);
|
||
|
zwp_confined_pointer_v1_send_confined(constraint->resource);
|
||
|
}
|
||
|
|
||
|
void wlr_pointer_constraint_v1_send_deactivated(struct wlr_pointer_constraint_v1 *constraint) {
|
||
|
if (wl_resource_get_user_data(constraint->resource)) {
|
||
|
wlr_log(WLR_DEBUG, "unconstrained %p", constraint);
|
||
|
zwp_confined_pointer_v1_send_unconfined(constraint->resource);
|
||
|
if (constraint->lifetime == ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT) {
|
||
|
pointer_constraint_destroy(constraint);
|
||
|
}
|
||
|
}
|
||
|
}
|