mirrors/wlroots
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wlroots/wlroots.git synced 2025-11-18 06:59:44 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Implement pointer-constraints protocol in wlroots and rootston

Browse source
This commit is contained in:
Las 2018-08-10 18:19:16 +02:00
parent 437f538772
commit fa2e6e7d9d
23 changed files with 1134 additions and 20 deletions
Download patch file Download diff file Expand all files Collapse all files

1
types/meson.build
View file

@ -39,6 +39,7 @@ lib_wlr_types = static_library(
'wlr_output_layout.c',
'wlr_output.c',
'wlr_pointer.c',
'wlr_pointer_constraints_v1.c',
'wlr_primary_selection.c',
'wlr_region.c',
'wlr_screenshooter.c',

9
types/wlr_box.c
View file

@ -143,3 +143,12 @@ void wlr_box_rotated_bounds(const struct wlr_box *box, float rotation,
dest->y = floor(fmin(y1, y2));
dest->height = ceil(fmax(y1, y2) - fmin(y1, y2));
}
void wlr_box_from_pixman_box32(const pixman_box32_t box, struct wlr_box *dest) {
*dest = (struct wlr_box){
.x = box.x1,
.y = box.y1,
.width = box.x2 - box.x1,
.height = box.y2 - box.y1,
};
}

6
types/wlr_cursor.c
View file

@ -252,7 +252,7 @@ bool wlr_cursor_warp(struct wlr_cursor *cur, struct wlr_input_device *dev,
return result;
}
static void cursor_warp_closest(struct wlr_cursor *cur,
void wlr_cursor_warp_closest(struct wlr_cursor *cur,
struct wlr_input_device *dev, double lx, double ly) {
struct wlr_box *mapping = get_mapping(cur, dev);
if (mapping) {
@ -286,7 +286,7 @@ void wlr_cursor_warp_absolute(struct wlr_cursor *cur,
double lx, ly;
wlr_cursor_absolute_to_layout_coords(cur, dev, x, y, &lx, &ly);
cursor_warp_closest(cur, dev, lx, ly);
wlr_cursor_warp_closest(cur, dev, lx, ly);
}
void wlr_cursor_move(struct wlr_cursor *cur, struct wlr_input_device *dev,
@ -296,7 +296,7 @@ void wlr_cursor_move(struct wlr_cursor *cur, struct wlr_input_device *dev,
double lx = !isnan(delta_x) ? cur->x + delta_x : cur->x;
double ly = !isnan(delta_y) ? cur->y + delta_y : cur->y;
cursor_warp_closest(cur, dev, lx, ly);
wlr_cursor_warp_closest(cur, dev, lx, ly);
}
void wlr_cursor_set_image(struct wlr_cursor *cur, const uint8_t *pixels,

362
types/wlr_pointer_constraints_v1.c Normal file
View file

@ -0,0 +1,362 @@
#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);
}
}
}