weston/clients/constraints.c

1024 lines
27 KiB
C

/*
* Copyright © 2023 Sergio Gómez for Collabora Ltd
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include "config.h"
#include <stdio.h>
#include <stdbool.h>
#include <getopt.h>
#include <sys/mman.h>
#include <linux/input.h>
#include <wayland-cursor.h>
#include "shared/helpers.h"
#include "shared/xalloc.h"
#include "shared/os-compatibility.h"
#include "shared/cairo-util.h"
#include "xdg-shell-client-protocol.h"
#include "pointer-constraints-unstable-v1-client-protocol.h"
#include "relative-pointer-unstable-v1-client-protocol.h"
#define NUM_BUFFERS 3
#define SURFACE_WIDTH 500
#define SURFACE_HEIGHT 400
#define SUBSURFACE_WIDTH (SURFACE_WIDTH / 4)
#define SUBSURFACE_HEIGHT (SURFACE_HEIGHT / 4)
#define SUBSURFACE_X_POS ((SURFACE_WIDTH-SUBSURFACE_WIDTH) / 2)
#define SUBSURFACE_Y_POS ((SURFACE_HEIGHT-SUBSURFACE_HEIGHT) / 2)
static float rgb_surface[3] = { 1, 1, 1 };
static float rgb_subsurface[3] = { 0.5, 0.5, 0.5 };
struct buffer {
struct wl_buffer *wl_buffer;
bool used;
void *data;
cairo_surface_t *cairo_surface;
};
struct shm_pool {
struct wl_shm_pool *wl_shm_pool;
size_t size;
void *data;
struct buffer buffers[NUM_BUFFERS];
};
struct surface {
struct constraints *constraints;
struct wl_surface *wl_surface;
struct wl_callback *cb;
struct wl_subsurface *wl_subsurface;
struct wl_surface *wl_surface_cursor;
uint32_t serial;
int width, height, stride;
float rgb[3];
struct {
int32_t x1, y1;
int32_t x2, y2;
} line;
struct shm_pool pool;
struct buffer *current_buffer;
bool needs_reset;
bool needs_redraw;
};
struct window {
struct wl_display *wl_display;
struct wl_registry *wl_registry;
struct wl_compositor *wl_compositor;
struct wl_subcompositor *wl_subcompositor;
struct wl_seat *wl_seat;
struct wl_pointer *wl_pointer;
struct wl_keyboard *wl_keyboard;
struct wl_shm *wl_shm;
struct wl_cursor_theme *wl_cursor_theme;
struct wl_cursor *wl_cursor;
struct xdg_wm_base *xdg_wm_base;
struct xdg_surface *xdg_surface;
struct xdg_toplevel *xdg_toplevel;
struct surface surface;
struct surface subsurface;
struct surface *surface_constrained;
};
enum constraints_state {
STATE_UNCONSTRAINED,
STATE_CONFINED,
STATE_LOCKED
};
struct constraints {
struct window window;
struct zwp_relative_pointer_manager_v1 *zwp_relative_pointer_manager;
struct zwp_pointer_constraints_v1 *zwp_pointer_constraints;
struct zwp_confined_pointer_v1 *zwp_confined_pointer;
struct zwp_relative_pointer_v1 *zwp_relative_pointer;
struct zwp_locked_pointer_v1 *zwp_locked_pointer;
bool running;
bool argb8888_supported;
enum constraints_state state;
};
/*
* Forward declarations for functions used by Wayland event handlers (since
* these events are defined first).
*/
static void surface_redraw(struct surface *surface);
static void surface_set_cursor(const struct surface *surface, bool hide);
static void constraints_reset_state(struct constraints *constraints);
void (*constraints_transition_state[])(struct constraints *constraints);
static void
relative_pointer_handle_motion(void *data, struct zwp_relative_pointer_v1 *pointer,
uint32_t utime_hi, uint32_t utime_lo,
wl_fixed_t dx, wl_fixed_t dy,
wl_fixed_t dx_unaccel, wl_fixed_t dy_unaccel)
{
struct constraints *c = data;
struct surface *sc = c->window.surface_constrained;
sc->line.x2 = sc->line.x1 + wl_fixed_to_double(dx);
sc->line.y2 = sc->line.y1 + wl_fixed_to_double(dy);
c->window.surface_constrained->needs_reset = true;
c->window.surface_constrained->needs_redraw = true;
}
static const struct zwp_relative_pointer_v1_listener relative_pointer_listener = {
relative_pointer_handle_motion,
};
static void
pointer_locked(void *data, struct zwp_locked_pointer_v1 *locked_pointer)
{
struct constraints *c = data;
struct surface *sc = c->window.surface_constrained;
c->state = STATE_LOCKED;
c->zwp_locked_pointer = locked_pointer;
sc->line.x1 = sc->line.x2;
sc->line.y1 = sc->line.y2;
sc->needs_reset = true;
sc->needs_redraw = true;
surface_set_cursor(sc, true);
c->zwp_relative_pointer =
zwp_relative_pointer_manager_v1_get_relative_pointer(
c->zwp_relative_pointer_manager,
c->window.wl_pointer);
zwp_relative_pointer_v1_add_listener(c->zwp_relative_pointer,
&relative_pointer_listener, c);
}
static void
pointer_unlocked(void *data, struct zwp_locked_pointer_v1 *locked_pointer)
{
struct constraints *c = data;
constraints_reset_state(c);
}
static const struct zwp_locked_pointer_v1_listener locked_pointer_listener = {
pointer_locked,
pointer_unlocked,
};
static void
pointer_confined(void *data, struct zwp_confined_pointer_v1 *confined_pointer)
{
struct constraints *c = data;
c->state = STATE_CONFINED;
c->zwp_confined_pointer = confined_pointer;
}
static void
pointer_unconfined(void *data, struct zwp_confined_pointer_v1 *confined_pointer)
{
struct constraints *c = data;
constraints_reset_state(c);
}
static const struct zwp_confined_pointer_v1_listener confined_pointer_listener = {
pointer_confined,
pointer_unconfined,
};
static void
pointer_handle_enter(void *data, struct wl_pointer *pointer, uint32_t serial,
struct wl_surface *surface, wl_fixed_t sx_w, wl_fixed_t sy_w)
{
struct constraints *c = data;
struct surface *surface_constrained =
(surface == c->window.surface.wl_surface) ?
&c->window.surface :
&c->window.subsurface;
surface_constrained->serial = serial;
surface_set_cursor(surface_constrained, false);
c->window.surface_constrained = surface_constrained;
}
static void
pointer_handle_leave(void *data, struct wl_pointer *pointer, uint32_t serial,
struct wl_surface *wl_surface)
{
struct constraints *c = data;
struct surface *sc = c->window.surface_constrained;
sc->line.x1 = -1;
sc->line.y1 = -1;
sc->line.x2 = -1;
sc->line.y2 = -1;
sc->needs_reset = true;
sc->needs_redraw = true;
if (c->state != STATE_UNCONSTRAINED)
constraints_reset_state(c);
}
static void
pointer_handle_motion(void *data, struct wl_pointer *pointer, uint32_t time,
wl_fixed_t sx_w, wl_fixed_t sy_w)
{
struct surface *sc = ((struct constraints *)data)->window.surface_constrained;
sc->line.x2 = wl_fixed_to_double(sx_w);
sc->line.y2 = wl_fixed_to_double(sy_w);
sc->needs_redraw = true;
}
static void
pointer_handle_button(void *data, struct wl_pointer *pointer, uint32_t serial,
uint32_t time, uint32_t btn, uint32_t button_state)
{
struct constraints *c = data;
if (button_state == WL_POINTER_BUTTON_STATE_RELEASED || btn != BTN_LEFT)
return;
constraints_transition_state[c->state](c);
}
static void
pointer_handle_axis(void *data, struct wl_pointer *pointer, uint32_t time,
uint32_t axis, wl_fixed_t value)
{
}
static void
pointer_handle_frame(void *data, struct wl_pointer *pointer)
{
}
static void
pointer_handle_axis_source(void *data, struct wl_pointer *pointer,
uint32_t source)
{
}
static void
pointer_handle_axis_stop(void *data, struct wl_pointer *pointer, uint32_t time,
uint32_t axis)
{
}
static void
pointer_handle_axis_discrete(void *data, struct wl_pointer *pointer,
uint32_t axis, int32_t discrete)
{
}
static const struct wl_pointer_listener pointer_listener = {
pointer_handle_enter,
pointer_handle_leave,
pointer_handle_motion,
pointer_handle_button,
pointer_handle_axis,
pointer_handle_frame,
pointer_handle_axis_source,
pointer_handle_axis_stop,
pointer_handle_axis_discrete,
};
static void
keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format,
int fd, uint32_t size)
{
close(fd);
}
static void
keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial,
struct wl_surface *surface, struct wl_array *keys)
{
}
static void
keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial,
struct wl_surface *surface)
{
}
static void
keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial,
uint32_t time, uint32_t key, uint32_t state)
{
struct constraints *c = data;
if (key == KEY_ESC && state)
c->running = false;
}
static void
keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
uint32_t serial, uint32_t mods_depressed,
uint32_t mods_latched, uint32_t mods_locked,
uint32_t group)
{
}
static const struct wl_keyboard_listener keyboard_listener = {
keyboard_handle_keymap,
keyboard_handle_enter,
keyboard_handle_leave,
keyboard_handle_key,
keyboard_handle_modifiers,
};
static void
seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
enum wl_seat_capability caps)
{
struct constraints *c = data;
if ((caps & WL_SEAT_CAPABILITY_POINTER) && !c->window.wl_pointer) {
c->window.wl_pointer = wl_seat_get_pointer(wl_seat);
wl_pointer_add_listener(c->window.wl_pointer, &pointer_listener, c);
}
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !c->window.wl_keyboard) {
c->window.wl_keyboard = wl_seat_get_keyboard(wl_seat);
wl_keyboard_add_listener(c->window.wl_keyboard, &keyboard_listener, c);
}
}
static const struct wl_seat_listener seat_listener = {
seat_handle_capabilities,
};
static void
handle_xdg_surface_configure(void *data, struct xdg_surface *surface,
uint32_t serial)
{
struct constraints *c = data;
xdg_surface_ack_configure(surface, serial);
surface_redraw(&c->window.surface);
surface_redraw(&c->window.subsurface);
}
static const struct xdg_surface_listener xdg_surface_listener = {
handle_xdg_surface_configure,
};
static void
xdg_wm_base_ping(void *data, struct xdg_wm_base *shell, uint32_t serial)
{
xdg_wm_base_pong(shell, serial);
}
static const struct xdg_wm_base_listener wm_base_listener = {
xdg_wm_base_ping,
};
static void
shm_format(void *data, struct wl_shm *wl_shm, uint32_t format)
{
struct constraints *c = data;
if (format == WL_SHM_FORMAT_ARGB8888)
c->argb8888_supported = true;
}
struct wl_shm_listener shm_listener = {
shm_format
};
static void
handle_global(void *data, struct wl_registry *registry, uint32_t name,
const char *interface, uint32_t version)
{
struct constraints *c = data;
if (strcmp(interface, "wl_compositor") == 0) {
c->window.wl_compositor =
wl_registry_bind(registry, name,
&wl_compositor_interface, 1);
} else if (strcmp(interface, "xdg_wm_base") == 0) {
c->window.xdg_wm_base =
wl_registry_bind(registry, name,
&xdg_wm_base_interface, 1);
xdg_wm_base_add_listener(c->window.xdg_wm_base,
&wm_base_listener, c);
} else if (strcmp(interface, "wl_shm") == 0) {
c->window.wl_shm = wl_registry_bind(registry, name,
&wl_shm_interface, 1);
wl_shm_add_listener(c->window.wl_shm, &shm_listener, c);
c->window.wl_cursor_theme = wl_cursor_theme_load(NULL, 32, c->window.wl_shm);
c->window.wl_cursor =
wl_cursor_theme_get_cursor(c->window.wl_cursor_theme, "left_ptr");
} else if (strcmp(interface, "wl_seat") == 0) {
c->window.wl_seat = wl_registry_bind(c->window.wl_registry, name,
&wl_seat_interface, 1);
wl_seat_add_listener(c->window.wl_seat, &seat_listener,
c);
} else if (strcmp(interface, "zwp_relative_pointer_manager_v1") == 0) {
c->zwp_relative_pointer_manager =
wl_registry_bind(registry, name,
&zwp_relative_pointer_manager_v1_interface,
1);
} else if (strcmp(interface, "zwp_pointer_constraints_v1") == 0) {
c->zwp_pointer_constraints =
wl_registry_bind(registry, name,
&zwp_pointer_constraints_v1_interface,
1);
} else if (strcmp(interface, wl_subcompositor_interface.name) == 0) {
c->window.wl_subcompositor =
wl_registry_bind(registry, name,
&wl_subcompositor_interface, 1);
}
}
static void
handle_global_remove(void *data, struct wl_registry *registry, uint32_t name)
{
}
static const struct wl_registry_listener registry_listener = {
handle_global,
handle_global_remove
};
static void
handle_toplevel_configure(void *data, struct xdg_toplevel *xdg_toplevel,
int32_t width, int32_t height,
struct wl_array *state)
{
}
static void
handle_toplevel_close(void *data, struct xdg_toplevel *xdg_toplevel)
{
struct constraints *c = data;
c->running = false;
}
static const struct xdg_toplevel_listener xdg_toplevel_listener = {
handle_toplevel_configure,
handle_toplevel_close,
};
static void
buffer_release(void *data, struct wl_buffer *wl_buffer)
{
struct buffer *buffer = data;
buffer->used = false;
}
static const struct wl_buffer_listener buffer_listener = {
buffer_release
};
static void
frame_done(void *data, struct wl_callback *cb, uint32_t time)
{
struct surface *surface = data;
wl_callback_destroy(cb);
surface_redraw(surface);
}
static const struct wl_callback_listener frame_listener = {
.done = frame_done,
};
static struct buffer *
shm_pool_get_buffer(struct shm_pool *pool, const struct surface *surface)
{
size_t i, offset;
struct buffer *buffer = surface->current_buffer;
cairo_surface_t *prev_surface = buffer ? buffer->cairo_surface : NULL;
cairo_t *cr;
/* reuse current buffer if possible */
if (buffer && !buffer->used)
return buffer;
buffer = NULL;
for (i = 0; i < ARRAY_LENGTH(pool->buffers); i++) {
if (!pool->buffers[i].used) {
buffer = &pool->buffers[i];
/* ARRAY_LENGTH(pool->buffers) is a factor of pool->size */
offset = pool->size / ARRAY_LENGTH(pool->buffers) * i;
break;
}
}
if (!buffer) {
fprintf(stderr, "no buffers available\n");
return NULL;
}
if (!buffer->wl_buffer) {
buffer->wl_buffer = wl_shm_pool_create_buffer(pool->wl_shm_pool,
offset,
surface->width,
surface->height,
surface->stride,
WL_SHM_FORMAT_ARGB8888);
wl_buffer_add_listener(buffer->wl_buffer,
&buffer_listener, buffer);
buffer->data = (char *)pool->data + offset;
buffer->cairo_surface =
cairo_image_surface_create_for_data(buffer->data,
CAIRO_FORMAT_ARGB32,
surface->width,
surface->height,
surface->stride);
if (cairo_surface_status(buffer->cairo_surface) !=
CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "cairo failed to create surface\n");
wl_buffer_destroy(buffer->wl_buffer);
buffer->data = NULL;
return NULL;
}
}
/* we need to preserve the contents of the old buffer, if any */
if (prev_surface) {
cr = cairo_create(buffer->cairo_surface);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface(cr, prev_surface, 0, 0);
cairo_rectangle(cr, 0, 0, surface->width, surface->height);
cairo_clip(cr);
cairo_paint(cr);
cairo_destroy(cr);
}
return buffer;
}
static void
shm_pool_deinit(const struct shm_pool *pool)
{
size_t i;
for (i = 0; i < ARRAY_LENGTH(pool->buffers); i++) {
const struct buffer *b = &pool->buffers[i];
if (b->wl_buffer) {
wl_buffer_destroy(b->wl_buffer);
cairo_surface_destroy(b->cairo_surface);
}
}
if (pool->data) {
if (munmap(pool->data, pool->size) < 0) {
fprintf(stderr, "failed to unmap: %s\n", strerror(errno));
}
wl_shm_pool_destroy(pool->wl_shm_pool);
}
}
static int
shm_pool_init(struct shm_pool *pool, size_t size, struct wl_shm *wl_shm)
{
size_t pool_size = size * ARRAY_LENGTH(pool->buffers);
int fd = os_create_anonymous_file(pool_size);
if (fd < 0) {
fprintf(stderr, "creating a buffer file for %zu B failed: %s\n",
pool_size, strerror(errno));
return -1;
}
pool->data = mmap(NULL, pool_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (pool->data == MAP_FAILED) {
fprintf(stderr, "mmap failed: %s\n", strerror(errno));
close(fd);
return -1;
}
pool->wl_shm_pool = wl_shm_create_pool(wl_shm, fd, pool_size);
close(fd);
pool->size = pool_size;
return 0;
}
static void
surface_set_cursor(const struct surface *surface, bool hide)
{
const struct constraints *c = surface->constraints;
struct wl_cursor_image *image = c->window.wl_cursor->images[0];
struct wl_buffer *buffer = wl_cursor_image_get_buffer(image);
wl_pointer_set_cursor(c->window.wl_pointer, surface->serial,
hide ? NULL : surface->wl_surface_cursor,
image->hotspot_x, image->hotspot_y);
if (!hide) {
wl_surface_attach(surface->wl_surface_cursor, buffer, 0, 0);
wl_surface_damage(surface->wl_surface_cursor, 0, 0,
image->width, image->height);
}
wl_surface_commit(surface->wl_surface_cursor);
}
static void
surface_draw_line(struct surface *surface, const enum constraints_state state)
{
if (surface->line.x1 != -1 && surface->line.y1 != -1) {
cairo_t *cr = cairo_create(surface->current_buffer->cairo_surface);
cairo_set_line_width(cr, 2.0);
cairo_set_source_rgb(cr, 0, 0, 0);
cairo_move_to(cr, surface->line.x1, surface->line.y1);
cairo_line_to(cr, surface->line.x2, surface->line.y2);
cairo_stroke(cr);
cairo_destroy(cr);
}
if (state != STATE_LOCKED) {
surface->line.x1 = surface->line.x2;
surface->line.y1 = surface->line.y2;
}
}
static void
surface_reset(const struct surface *surface)
{
cairo_t *cr = cairo_create(surface->current_buffer->cairo_surface);
cairo_rectangle(cr, 0, 0, surface->width, surface->height);
cairo_set_source_rgb(cr, surface->rgb[0], surface->rgb[1],
surface->rgb[2]);
cairo_fill(cr);
cairo_destroy(cr);
}
static void
surface_redraw(struct surface *surface)
{
struct buffer *buffer;
if (!(buffer = shm_pool_get_buffer(&surface->pool, surface)))
return;
surface->current_buffer = buffer;
surface->cb = wl_surface_frame(surface->wl_surface);
wl_callback_add_listener(surface->cb, &frame_listener, surface);
if (surface->needs_redraw) {
if (surface->needs_reset) {
surface_reset(surface);
surface->needs_reset = false;
}
surface_draw_line(surface, surface->constraints->state);
surface->needs_redraw = false;
buffer->used = true;
wl_surface_attach(surface->wl_surface, buffer->wl_buffer, 0, 0);
wl_surface_damage(surface->wl_surface, 0, 0, surface->width, surface->height);
}
wl_surface_commit(surface->wl_surface);
}
static void
surface_deinit(const struct surface *surface)
{
shm_pool_deinit(&surface->pool);
if (surface->wl_subsurface)
wl_subsurface_destroy(surface->wl_subsurface);
if (surface->wl_surface)
wl_surface_destroy(surface->wl_surface);
if (surface->wl_surface_cursor)
wl_surface_destroy(surface->wl_surface_cursor);
if (surface->cb)
wl_callback_destroy(surface->cb);
}
static int
surface_init(struct surface *surface, struct constraints *constraints,
const float *rgb, int width, int height,
const struct surface *parent_surface, int pos_x, int pos_y)
{
struct window *window = &constraints->window;
surface->wl_surface = wl_compositor_create_surface(window->wl_compositor);
surface->rgb[0] = rgb[0];
surface->rgb[1] = rgb[1];
surface->rgb[2] = rgb[2];
surface->width = width;
surface->height = height;
surface->stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32,
surface->width);
surface->line.x1 = surface->line.y1 = -1;
surface->line.x2 = surface->line.y2 = -1;
surface->needs_reset = true;
surface->needs_redraw = true;
if (parent_surface) {
surface->wl_subsurface =
wl_subcompositor_get_subsurface(window->wl_subcompositor,
surface->wl_surface,
parent_surface->wl_surface);
wl_subsurface_set_position(window->subsurface.wl_subsurface,
pos_x, pos_y);
}
surface->wl_surface_cursor = wl_compositor_create_surface(window->wl_compositor);
surface->constraints = constraints;
return shm_pool_init(&surface->pool, surface->stride * surface->height,
window->wl_shm);
}
static void
constraints_reset_state(struct constraints *constraints)
{
if (constraints->zwp_confined_pointer) {
zwp_confined_pointer_v1_destroy(constraints->zwp_confined_pointer);
constraints->zwp_confined_pointer = NULL;
}
if (constraints->zwp_relative_pointer) {
zwp_relative_pointer_v1_destroy(constraints->zwp_relative_pointer);
constraints->zwp_relative_pointer = NULL;
}
if (constraints->zwp_locked_pointer) {
zwp_locked_pointer_v1_destroy(constraints->zwp_locked_pointer);
constraints->zwp_locked_pointer = NULL;
}
constraints->state = STATE_UNCONSTRAINED;
}
static void
constraints_transition_unconstrained(struct constraints *constraints)
{
const struct surface *sc = constraints->window.surface_constrained;
struct zwp_confined_pointer_v1 *confined_pointer;
confined_pointer =
zwp_pointer_constraints_v1_confine_pointer(constraints->zwp_pointer_constraints,
sc->wl_surface,
constraints->window.wl_pointer,
NULL,
ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT);
zwp_confined_pointer_v1_add_listener(confined_pointer,
&confined_pointer_listener,
constraints);
}
static void
constraints_transition_confined(struct constraints *constraints)
{
const struct surface *sc = constraints->window.surface_constrained;
struct zwp_locked_pointer_v1 *locked_pointer;
zwp_confined_pointer_v1_destroy(constraints->zwp_confined_pointer);
constraints->zwp_confined_pointer = NULL;
locked_pointer =
zwp_pointer_constraints_v1_lock_pointer(constraints->zwp_pointer_constraints,
sc->wl_surface,
constraints->window.wl_pointer,
NULL,
ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT);
zwp_locked_pointer_v1_add_listener(locked_pointer,
&locked_pointer_listener,
constraints);
}
static void
constraints_transition_locked(struct constraints *constraints)
{
struct surface *sc = constraints->window.surface_constrained;
constraints_reset_state(constraints);
surface_set_cursor(sc, false);
}
void (*constraints_transition_state[])(struct constraints *constraints) =
{
constraints_transition_unconstrained,
constraints_transition_confined,
constraints_transition_locked
};
static void
constraints_deinit(const struct constraints *constraints)
{
surface_deinit(&constraints->window.subsurface);
surface_deinit(&constraints->window.surface);
if (constraints->zwp_locked_pointer)
zwp_locked_pointer_v1_destroy(constraints->zwp_locked_pointer);
if (constraints->zwp_confined_pointer)
zwp_confined_pointer_v1_destroy(constraints->zwp_confined_pointer);
if (constraints->zwp_relative_pointer)
zwp_relative_pointer_v1_destroy(constraints->zwp_relative_pointer);
if (constraints->zwp_relative_pointer_manager)
zwp_relative_pointer_manager_v1_destroy(constraints->zwp_relative_pointer_manager);
if (constraints->zwp_pointer_constraints)
zwp_pointer_constraints_v1_destroy(constraints->zwp_pointer_constraints);
if (constraints->window.xdg_toplevel)
xdg_toplevel_destroy(constraints->window.xdg_toplevel);
if (constraints->window.xdg_surface)
xdg_surface_destroy(constraints->window.xdg_surface);
if (constraints->window.xdg_wm_base)
xdg_wm_base_destroy(constraints->window.xdg_wm_base);
if (constraints->window.wl_cursor_theme)
wl_cursor_theme_destroy(constraints->window.wl_cursor_theme);
if (constraints->window.wl_shm)
wl_shm_destroy(constraints->window.wl_shm);
if (constraints->window.wl_keyboard)
wl_keyboard_destroy(constraints->window.wl_keyboard);
if (constraints->window.wl_pointer)
wl_pointer_destroy(constraints->window.wl_pointer);
if (constraints->window.wl_seat)
wl_seat_destroy(constraints->window.wl_seat);
if (constraints->window.wl_subcompositor)
wl_subcompositor_destroy(constraints->window.wl_subcompositor);
if (constraints->window.wl_compositor)
wl_compositor_destroy(constraints->window.wl_compositor);
if (constraints->window.wl_registry)
wl_registry_destroy(constraints->window.wl_registry);
if (constraints->window.wl_display)
wl_display_disconnect(constraints->window.wl_display);
}
static int
constraints_check_globals(const struct constraints *c)
{
if (!c->window.xdg_wm_base) {
fprintf(stderr, "no xdg-shell found\n");
return -1;
}
if (!c->zwp_pointer_constraints) {
fprintf(stderr, "no pointer constraints found\n");
return -1;
}
if (!c->zwp_relative_pointer_manager) {
fprintf(stderr, "no relative pointer manager found\n");
return -1;
}
if (!c->window.wl_seat || !c->window.wl_pointer || !c->window.wl_keyboard) {
fprintf(stderr, "no valid seat found\n");
return -1;
}
if (!c->argb8888_supported) {
fprintf(stderr, "WL_SHM_FORMAT_ARGB8888 not supported\n");
return -1;
}
return 0;
}
static int
constraints_init(struct constraints *constraints)
{
struct window *window = &constraints->window;
window->wl_display = wl_display_connect(NULL);
if (!window->wl_display) {
fprintf(stderr, "failed to connect to Wayland display: %s\n",
strerror(errno));
goto fail;
}
/* get globals */
window->wl_registry = wl_display_get_registry(window->wl_display);
wl_registry_add_listener(window->wl_registry, &registry_listener,
constraints);
/* double roundtrip to get all initial events */
if (wl_display_roundtrip(window->wl_display) == -1 ||
wl_display_roundtrip(window->wl_display) == -1) {
fprintf(stderr, "wl_display_roundtrip() failed: %s\n",
strerror(errno));
goto fail;
}
if (constraints_check_globals(constraints) == -1) {
goto fail;
}
/* surface setup */
if (surface_init(&window->surface, constraints, rgb_surface, SURFACE_WIDTH,
SURFACE_HEIGHT, NULL, 0, 0) == -1) {
fprintf(stderr, "failed to initialize surface\n");
goto fail;
}
/* xdg surface setup */
window->xdg_surface = xdg_wm_base_get_xdg_surface(window->xdg_wm_base,
window->surface.wl_surface);
xdg_surface_add_listener(window->xdg_surface, &xdg_surface_listener,
constraints);
window->xdg_toplevel = xdg_surface_get_toplevel(window->xdg_surface);
xdg_toplevel_add_listener(window->xdg_toplevel, &xdg_toplevel_listener,
constraints);
xdg_toplevel_set_title(window->xdg_toplevel, "simple-constraints");
xdg_toplevel_set_app_id(window->xdg_toplevel, "org.freedesktop.weston.simple-contrains");
/* sub-surface setup */
if (surface_init(&window->subsurface, constraints, rgb_subsurface,
SUBSURFACE_WIDTH, SUBSURFACE_HEIGHT, &window->surface,
SUBSURFACE_X_POS, SUBSURFACE_Y_POS) == -1) {
fprintf(stderr, "failed to initialize sub-surface\n");
goto fail;
}
wl_surface_commit(window->surface.wl_surface);
constraints->running = true;
return 0;
fail:
if (constraints)
constraints_deinit(constraints);
return -1;
}
static void
print_usage(void)
{
printf("\nDemo client that showcases the Wayland Pointer Constraints"
" protocol:\n\n");
printf("The gray rectangle represents a Wayland subsurface for the"
" surface in white.\n");
printf("Click on any surface to cycle between unconstrained-confined"
"-locked states.\n\n");
}
int
main()
{
static struct constraints constraints;
int ret = 0;
print_usage();
if (constraints_init(&constraints) < 0)
return -1;
while (ret != -1 && constraints.running)
ret = wl_display_dispatch(constraints.window.wl_display);
constraints_deinit(&constraints);
return ret;
}