lkn
/
windowmaker-wl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
windowmaker-wl/WINGs/wclient_wl.c

1035 lines
36 KiB
C
Raw Blame History

#define WRASTER_NO_XLIB /* Wayland-only file: no libX11 deps */
/*
* wclient_wl.c — Wayland *client* backend for WINGs.
*
* This is the counterpart to wevent_wl.c / wview_wl.c / wfont_wl.c /
* wrender_wl.c, but used when a WINGs program runs as a *client* of an
* external Wayland compositor (e.g. WPrefs.app under wmaker-wl, sway,
* or any wlroots-based compositor).
*
* In compositor mode the WM owns the rendering pipeline and the same
* Wayland backend files run inside the compositor process; surfaces
* are scene-graph nodes managed by wlroots.
*
* In client mode (this file), the program connects via libwayland-client,
* binds the standard globals (wl_compositor, wl_shm, xdg_wm_base, wl_seat),
* creates an xdg_toplevel for each top-level W_View, and submits buffers
* via wl_shm. Pixman backing images are allocated over a memfd-mapped
* region wrapped in a wl_buffer so paints can be done with the same
* pixman calls used everywhere else.
*
* Input dispatch translates wl_pointer / wl_keyboard events into
* WMEvent and feeds them to the existing W_EventBackendWL ring buffer
* via W_WL_EnqueueEvent — the same mechanism the compositor-internal
* Wayland backend uses.
*/
#include "wconfig.h"
#ifdef USE_WAYLAND_CLIENT
#include "WINGsP.h"
#include <wayland-client.h>
#include "xdg-shell-client-protocol.h"
#include <xkbcommon/xkbcommon.h>
#include <pixman.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
/* ------------------------------------------------------------------ */
/* Per-screen Wayland-client context */
/* ------------------------------------------------------------------ */
typedef struct WLClientCtx {
struct wl_display *display;
struct wl_registry *registry;
struct wl_compositor *compositor;
struct wl_shm *shm;
struct wl_seat *seat;
struct xdg_wm_base *wm_base;
struct wl_pointer *pointer;
struct wl_keyboard *keyboard;
struct xkb_context *xkb_ctx;
struct xkb_keymap *xkb_keymap;
struct xkb_state *xkb_state;
/* Back-reference for input handlers */
struct W_Screen *scr;
} WLClientCtx;
/* Storage for the active context — for now we only support one screen. */
static WLClientCtx *g_wlclient_ctx = NULL;
/* Forward decl — defined in wview_wl.c */
extern void W_SetViewBacking(WNativeWindow id, void *img);
/* ------------------------------------------------------------------ */
/* wl_shm-backed buffer allocator */
/* */
/* A WLClientShmBuffer pairs a wl_buffer with the pixman_image_t that */
/* shares the same memfd-mapped region. Painting into the pixman */
/* image touches the same memory the compositor will read on commit, */
/* so no copy is needed. wl_buffer.release marks the buffer as */
/* available for reuse — the surface code may then double-buffer if */
/* it wants, or re-attach the same buffer. */
/* ------------------------------------------------------------------ */
typedef struct WLClientShmBuffer {
struct wl_buffer *wl_buf;
pixman_image_t *image;
void *map;
size_t map_size;
int width;
int height;
int stride; /* bytes per row */
int busy; /* 1 = still owned by compositor */
} WLClientShmBuffer;
static void
shm_buffer_release(void *data, struct wl_buffer *wl_buf)
{
(void)wl_buf;
WLClientShmBuffer *b = data;
if (b) b->busy = 0;
}
static const struct wl_buffer_listener shm_buffer_listener = {
.release = shm_buffer_release,
};
/*
* Create an anonymous, sealed memfd of the given size. We use memfd_create
* with MFD_CLOEXEC because shm_open + unlink is slower and the resulting
* file lingers in /dev/shm. This requires Linux >= 3.17, kernel default
* everywhere we care about.
*/
static int
shm_create_memfd(size_t size)
{
int fd = memfd_create("wings-wl-shm", MFD_CLOEXEC);
if (fd < 0) return -1;
if (ftruncate(fd, size) < 0) {
int saved = errno;
close(fd);
errno = saved;
return -1;
}
return fd;
}
static WLClientShmBuffer *
wlclient_create_shm_buffer(WLClientCtx *ctx, int width, int height)
{
if (!ctx || !ctx->shm || width <= 0 || height <= 0) return NULL;
int stride = width * 4; /* ARGB32, 4 bytes/pixel */
size_t size = (size_t)stride * (size_t)height;
int fd = shm_create_memfd(size);
if (fd < 0) {
wwarning(_("WINGs: memfd_create failed: %s"), strerror(errno));
return NULL;
}
void *map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (map == MAP_FAILED) {
wwarning(_("WINGs: mmap of shm pool failed: %s"), strerror(errno));
close(fd);
return NULL;
}
struct wl_shm_pool *pool = wl_shm_create_pool(ctx->shm, fd, size);
if (!pool) {
munmap(map, size);
close(fd);
return NULL;
}
/* WL_SHM_FORMAT_ARGB8888 matches PIXMAN_a8r8g8b8 byte-for-byte on
* little-endian. WINGs is little-endian-only in practice. */
struct wl_buffer *wl_buf = wl_shm_pool_create_buffer(pool, 0,
width, height, stride, WL_SHM_FORMAT_ARGB8888);
/* Pool can be destroyed immediately after creating the buffer; the
* compositor keeps the fd mapping alive on its side. */
wl_shm_pool_destroy(pool);
/* The fd is duplicated by the compositor; we close ours. */
close(fd);
if (!wl_buf) {
munmap(map, size);
return NULL;
}
WLClientShmBuffer *b = wmalloc(sizeof(*b));
memset(b, 0, sizeof(*b));
b->wl_buf = wl_buf;
b->map = map;
b->map_size = size;
b->width = width;
b->height = height;
b->stride = stride;
b->image = pixman_image_create_bits(PIXMAN_a8r8g8b8, width, height,
(uint32_t *)map, stride);
if (!b->image) {
wl_buffer_destroy(wl_buf);
munmap(map, size);
wfree(b);
return NULL;
}
wl_buffer_add_listener(wl_buf, &shm_buffer_listener, b);
return b;
}
static void
wlclient_destroy_shm_buffer(WLClientShmBuffer *b)
{
if (!b) return;
if (b->image) pixman_image_unref(b->image);
if (b->wl_buf) wl_buffer_destroy(b->wl_buf);
if (b->map && b->map != MAP_FAILED) munmap(b->map, b->map_size);
wfree(b);
}
/* ------------------------------------------------------------------ */
/* Per-toplevel state */
/* */
/* One WLClientToplevel per top-level W_View. Holds the wl_surface, */
/* xdg_surface, xdg_toplevel, and a single shm-backed buffer that */
/* doubles as the view's pixman backing image. */
/* ------------------------------------------------------------------ */
typedef struct WLClientToplevel {
WLClientCtx *ctx;
struct W_View *view;
struct wl_surface *surface;
struct xdg_surface *xdg_surface;
struct xdg_toplevel *xdg_toplevel;
WLClientShmBuffer *buf; /* current backing */
int pending_w;
int pending_h;
int configured; /* received first xdg_surface.configure */
int mapped; /* surface has at least one buffer */
int want_close;
} WLClientToplevel;
#define WLC_TOPTABLE_SIZE 128
static struct {
WNativeWindow id;
WLClientToplevel *top;
} wlc_toptable[WLC_TOPTABLE_SIZE];
static void
wlc_top_put(WNativeWindow id, WLClientToplevel *top)
{
unsigned idx = ((unsigned)id) % WLC_TOPTABLE_SIZE;
for (int i = 0; i < WLC_TOPTABLE_SIZE; i++) {
unsigned slot = (idx + i) % WLC_TOPTABLE_SIZE;
if (wlc_toptable[slot].id == 0 || wlc_toptable[slot].id == id) {
wlc_toptable[slot].id = id;
wlc_toptable[slot].top = top;
return;
}
}
}
static WLClientToplevel *
wlc_top_find(WNativeWindow id)
{
unsigned idx = ((unsigned)id) % WLC_TOPTABLE_SIZE;
for (int i = 0; i < WLC_TOPTABLE_SIZE; i++) {
unsigned slot = (idx + i) % WLC_TOPTABLE_SIZE;
if (wlc_toptable[slot].id == id) return wlc_toptable[slot].top;
if (wlc_toptable[slot].id == 0) return NULL;
}
return NULL;
}
static void
wlc_top_remove(WNativeWindow id)
{
unsigned idx = ((unsigned)id) % WLC_TOPTABLE_SIZE;
for (int i = 0; i < WLC_TOPTABLE_SIZE; i++) {
unsigned slot = (idx + i) % WLC_TOPTABLE_SIZE;
if (wlc_toptable[slot].id == id) {
wlc_toptable[slot].id = 0;
wlc_toptable[slot].top = NULL;
return;
}
if (wlc_toptable[slot].id == 0) return;
}
}
/* Forward declarations */
static void wl_client_toplevel_commit_locked(WLClientToplevel *top);
/* ------------------------------------------------------------------ */
/* xdg_surface listener */
/* ------------------------------------------------------------------ */
static void
xdg_surface_handle_configure(void *data, struct xdg_surface *xs, uint32_t serial)
{
WLClientToplevel *top = data;
xdg_surface_ack_configure(xs, serial);
top->configured = 1;
/* If the compositor configured a new size, resize our backing.
* (Pending size of 0 means "you decide" — keep current.) */
if (top->pending_w > 0 && top->pending_h > 0 &&
(top->pending_w != top->buf->width ||
top->pending_h != top->buf->height)) {
WLClientShmBuffer *nb =
wlclient_create_shm_buffer(top->ctx, top->pending_w, top->pending_h);
if (nb) {
wlclient_destroy_shm_buffer(top->buf);
top->buf = nb;
/* Tell WINGs the backing pointer changed so subsequent
* draws hit the new buffer. */
W_SetViewBacking(top->view->window, nb->image);
top->view->size.width = top->pending_w;
top->view->size.height = top->pending_h;
}
}
/* On the very first configure, attach the buffer and commit so
* the surface becomes mapped. */
wl_client_toplevel_commit_locked(top);
}
static const struct xdg_surface_listener xdg_surface_listener = {
.configure = xdg_surface_handle_configure,
};
/* ------------------------------------------------------------------ */
/* xdg_toplevel listener */
/* ------------------------------------------------------------------ */
static void
xdg_toplevel_handle_configure(void *data, struct xdg_toplevel *xt,
int32_t width, int32_t height,
struct wl_array *states)
{
(void)xt; (void)states;
WLClientToplevel *top = data;
/* Width/height of 0 means the compositor leaves sizing to us. */
top->pending_w = width > 0 ? width : top->buf ? top->buf->width : top->view->size.width;
top->pending_h = height > 0 ? height : top->buf ? top->buf->height : top->view->size.height;
}
static void
xdg_toplevel_handle_close(void *data, struct xdg_toplevel *xt)
{
(void)xt;
WLClientToplevel *top = data;
top->want_close = 1;
/* TODO: synthesize a WMEvent close so the WINGs app can shut down
* gracefully. For now we just exit on next event-loop turn. */
}
static void
xdg_toplevel_handle_configure_bounds(void *data, struct xdg_toplevel *xt,
int32_t width, int32_t height)
{
(void)data; (void)xt; (void)width; (void)height;
}
static void
xdg_toplevel_handle_wm_capabilities(void *data, struct xdg_toplevel *xt,
struct wl_array *capabilities)
{
(void)data; (void)xt; (void)capabilities;
}
static const struct xdg_toplevel_listener xdg_toplevel_listener = {
.configure = xdg_toplevel_handle_configure,
.close = xdg_toplevel_handle_close,
.configure_bounds = xdg_toplevel_handle_configure_bounds,
.wm_capabilities = xdg_toplevel_handle_wm_capabilities,
};
/* ------------------------------------------------------------------ */
/* Commit / realize / resize / destroy */
/* ------------------------------------------------------------------ */
static void
wl_client_toplevel_commit_locked(WLClientToplevel *top)
{
if (!top || !top->configured || !top->buf || !top->buf->wl_buf)
return;
wl_surface_attach(top->surface, top->buf->wl_buf, 0, 0);
wl_surface_damage_buffer(top->surface, 0, 0,
top->buf->width, top->buf->height);
wl_surface_commit(top->surface);
top->buf->busy = 1;
top->mapped = 1;
}
static void
wl_client_view_commit(unsigned long id)
{
WLClientToplevel *top = wlc_top_find((WNativeWindow)id);
if (top) wl_client_toplevel_commit_locked(top);
}
static void
wl_client_view_destroy_backing(unsigned long id)
{
WLClientToplevel *top = wlc_top_find((WNativeWindow)id);
if (!top) return;
if (top->xdg_toplevel) xdg_toplevel_destroy(top->xdg_toplevel);
if (top->xdg_surface) xdg_surface_destroy(top->xdg_surface);
if (top->surface) wl_surface_destroy(top->surface);
if (top->buf) wlclient_destroy_shm_buffer(top->buf);
wlc_top_remove((WNativeWindow)id);
wfree(top);
}
static void *
wl_client_toplevel_realize(struct W_View *view, int width, int height)
{
WLClientCtx *ctx = g_wlclient_ctx;
if (!ctx || !ctx->compositor || !ctx->wm_base) return NULL;
WLClientToplevel *top = wmalloc(sizeof(*top));
memset(top, 0, sizeof(*top));
top->ctx = ctx;
top->view = view;
top->pending_w = width;
top->pending_h = height;
top->buf = wlclient_create_shm_buffer(ctx, width, height);
if (!top->buf) goto fail;
top->surface = wl_compositor_create_surface(ctx->compositor);
if (!top->surface) goto fail;
top->xdg_surface = xdg_wm_base_get_xdg_surface(ctx->wm_base, top->surface);
if (!top->xdg_surface) goto fail;
xdg_surface_add_listener(top->xdg_surface, &xdg_surface_listener, top);
top->xdg_toplevel = xdg_surface_get_toplevel(top->xdg_surface);
if (!top->xdg_toplevel) goto fail;
xdg_toplevel_add_listener(top->xdg_toplevel, &xdg_toplevel_listener, top);
/* Default app_id; the application can override via xdg_toplevel_set_app_id.
* WPrefs and friends ought to call WMSetApplicationIconImage / set_title;
* we'll plumb that next. */
xdg_toplevel_set_app_id(top->xdg_toplevel, "WINGs");
xdg_toplevel_set_title(top->xdg_toplevel, "WINGs Application");
/* Initial commit with no buffer so the compositor sends the first
* configure. We attach a real buffer in the configure handler. */
wl_surface_commit(top->surface);
/* view->window may not be assigned yet at this point — wl_realize sets
* it AFTER allocating the backing. We register the toplevel under
* view->window here using a deferred-association: the caller sets the
* window field first. Actually wview_wl.c assigns view->window BEFORE
* calling W_WLClientToplevelRealizeFn, so we can use it now. */
wlc_top_put((WNativeWindow)view->window, top);
return top->buf->image;
fail:
if (top->xdg_toplevel) xdg_toplevel_destroy(top->xdg_toplevel);
if (top->xdg_surface) xdg_surface_destroy(top->xdg_surface);
if (top->surface) wl_surface_destroy(top->surface);
if (top->buf) wlclient_destroy_shm_buffer(top->buf);
wfree(top);
return NULL;
}
static void
wl_client_toplevel_resize(struct W_View *view, int width, int height)
{
WLClientToplevel *top = wlc_top_find((WNativeWindow)view->window);
if (!top) return;
if (top->buf && top->buf->width == width && top->buf->height == height)
return;
WLClientShmBuffer *nb = wlclient_create_shm_buffer(top->ctx, width, height);
if (!nb) return;
if (top->buf) wlclient_destroy_shm_buffer(top->buf);
top->buf = nb;
W_SetViewBacking(view->window, nb->image);
}
static void
wl_client_toplevel_destroy(struct W_View *view)
{
wl_client_view_destroy_backing((unsigned long)view->window);
}
/* ------------------------------------------------------------------ */
/* Input: wl_pointer / wl_keyboard listeners */
/* ------------------------------------------------------------------ */
#include "WMEvent.h"
/* Map an X11-style state mask from xkbcommon modifier state. */
static unsigned int
wlc_xkb_mod_mask(struct xkb_state *state)
{
if (!state) return 0;
unsigned int mask = 0;
if (xkb_state_mod_name_is_active(state, XKB_MOD_NAME_SHIFT,
XKB_STATE_MODS_EFFECTIVE) > 0)
mask |= WM_MOD_SHIFT;
if (xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
XKB_STATE_MODS_EFFECTIVE) > 0)
mask |= WM_MOD_CONTROL;
if (xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
XKB_STATE_MODS_EFFECTIVE) > 0)
mask |= WM_MOD_MOD1;
if (xkb_state_mod_name_is_active(state, XKB_MOD_NAME_LOGO,
XKB_STATE_MODS_EFFECTIVE) > 0)
mask |= WM_MOD_MOD4;
return mask;
}
/* Pointer state */
static double wlc_ptr_x, wlc_ptr_y;
static uint32_t wlc_ptr_focus_serial;
static WLClientToplevel *wlc_ptr_focused;
static unsigned int wlc_ptr_button_state;
static unsigned int wlc_ptr_mods;
static WLClientToplevel *
wlc_top_for_surface(struct wl_surface *surf)
{
for (int i = 0; i < WLC_TOPTABLE_SIZE; i++) {
if (wlc_toptable[i].id && wlc_toptable[i].top &&
wlc_toptable[i].top->surface == surf)
return wlc_toptable[i].top;
}
return NULL;
}
static void
pointer_handle_enter(void *data, struct wl_pointer *p, uint32_t serial,
struct wl_surface *surface, wl_fixed_t sx, wl_fixed_t sy)
{
(void)p;
WLClientCtx *ctx = data;
wlc_ptr_focus_serial = serial;
wlc_ptr_focused = wlc_top_for_surface(surface);
wlc_ptr_x = wl_fixed_to_double(sx);
wlc_ptr_y = wl_fixed_to_double(sy);
if (!wlc_ptr_focused) return;
WMEvent ev;
memset(&ev, 0, sizeof(ev));
ev.type = WME_ENTER;
ev.window = wlc_ptr_focused->view->window;
ev.u.crossing.window = ev.window;
ev.u.crossing.x = (int)wlc_ptr_x;
ev.u.crossing.y = (int)wlc_ptr_y;
ev.u.crossing.x_root = (int)wlc_ptr_x;
ev.u.crossing.y_root = (int)wlc_ptr_y;
ev.u.crossing.mode = WM_NOTIFY_NORMAL;
ev.u.crossing.detail = WM_NOTIFY_ANCESTOR;
W_WL_EnqueueEvent(ctx->scr, &ev, NULL);
}
static void
pointer_handle_leave(void *data, struct wl_pointer *p, uint32_t serial,
struct wl_surface *surface)
{
(void)p; (void)serial; (void)surface;
WLClientCtx *ctx = data;
if (!wlc_ptr_focused) return;
WMEvent ev;
memset(&ev, 0, sizeof(ev));
ev.type = WME_LEAVE;
ev.window = wlc_ptr_focused->view->window;
ev.u.crossing.window = ev.window;
ev.u.crossing.mode = WM_NOTIFY_NORMAL;
ev.u.crossing.detail = WM_NOTIFY_ANCESTOR;
W_WL_EnqueueEvent(ctx->scr, &ev, NULL);
wlc_ptr_focused = NULL;
}
static void
pointer_handle_motion(void *data, struct wl_pointer *p, uint32_t time,
wl_fixed_t sx, wl_fixed_t sy)
{
(void)p;
WLClientCtx *ctx = data;
wlc_ptr_x = wl_fixed_to_double(sx);
wlc_ptr_y = wl_fixed_to_double(sy);
if (!wlc_ptr_focused) return;
WMEvent ev;
memset(&ev, 0, sizeof(ev));
ev.type = WME_MOTION;
ev.window = wlc_ptr_focused->view->window;
ev.u.motion.window = ev.window;
ev.u.motion.time = time;
ev.u.motion.x = (int)wlc_ptr_x;
ev.u.motion.y = (int)wlc_ptr_y;
ev.u.motion.x_root = (int)wlc_ptr_x;
ev.u.motion.y_root = (int)wlc_ptr_y;
ev.u.motion.state = wlc_ptr_button_state | wlc_ptr_mods;
W_WL_EnqueueEvent(ctx->scr, &ev, NULL);
}
static void
pointer_handle_button(void *data, struct wl_pointer *p, uint32_t serial,
uint32_t time, uint32_t button, uint32_t state)
{
(void)p; (void)serial;
WLClientCtx *ctx = data;
if (!wlc_ptr_focused) return;
/* Linux input event codes -> X-style button numbers. */
unsigned int wmb;
switch (button) {
case 0x110 /*BTN_LEFT*/: wmb = 1; break;
case 0x112 /*BTN_MIDDLE*/: wmb = 2; break;
case 0x111 /*BTN_RIGHT*/: wmb = 3; break;
case 0x113 /*BTN_SIDE*/: wmb = 8; break;
case 0x114 /*BTN_EXTRA*/: wmb = 9; break;
default: wmb = 0; break;
}
if (!wmb) return;
unsigned int mask = (wmb == 1) ? WM_BUTTON1_MASK :
(wmb == 2) ? WM_BUTTON2_MASK :
(wmb == 3) ? WM_BUTTON3_MASK : 0;
if (state == WL_POINTER_BUTTON_STATE_PRESSED)
wlc_ptr_button_state |= mask;
else
wlc_ptr_button_state &= ~mask;
WMEvent ev;
memset(&ev, 0, sizeof(ev));
ev.type = (state == WL_POINTER_BUTTON_STATE_PRESSED)
? WME_BUTTON_PRESS : WME_BUTTON_RELEASE;
ev.window = wlc_ptr_focused->view->window;
ev.u.button.window = ev.window;
ev.u.button.button = wmb;
ev.u.button.state = wlc_ptr_button_state | wlc_ptr_mods;
ev.u.button.time = time;
ev.u.button.x = (int)wlc_ptr_x;
ev.u.button.y = (int)wlc_ptr_y;
ev.u.button.x_root = (int)wlc_ptr_x;
ev.u.button.y_root = (int)wlc_ptr_y;
W_WL_EnqueueEvent(ctx->scr, &ev, NULL);
}
static void
pointer_handle_axis(void *data, struct wl_pointer *p, uint32_t time,
uint32_t axis, wl_fixed_t value)
{
(void)data; (void)p; (void)time; (void)axis; (void)value;
/* TODO: synthesize button 4/5 events for vertical scroll once we
* verify the basic flow. For now scroll is dropped. */
}
static void pointer_handle_frame(void *d, struct wl_pointer *p) { (void)d; (void)p; }
static void pointer_handle_axis_source(void *d, struct wl_pointer *p, uint32_t s) { (void)d; (void)p; (void)s; }
static void pointer_handle_axis_stop(void *d, struct wl_pointer *p, uint32_t t, uint32_t a) { (void)d; (void)p; (void)t; (void)a; }
static void pointer_handle_axis_discrete(void *d, struct wl_pointer *p, uint32_t a, int32_t v) { (void)d; (void)p; (void)a; (void)v; }
static const struct wl_pointer_listener pointer_listener = {
.enter = pointer_handle_enter,
.leave = pointer_handle_leave,
.motion = pointer_handle_motion,
.button = pointer_handle_button,
.axis = pointer_handle_axis,
.frame = pointer_handle_frame,
.axis_source = pointer_handle_axis_source,
.axis_stop = pointer_handle_axis_stop,
.axis_discrete = pointer_handle_axis_discrete,
};
/* ------------------------------------------------------------------ */
/* Keyboard */
/* ------------------------------------------------------------------ */
static WLClientToplevel *wlc_kbd_focused;
static void
keyboard_handle_keymap(void *data, struct wl_keyboard *k,
uint32_t format, int fd, uint32_t size)
{
(void)k;
WLClientCtx *ctx = data;
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
close(fd);
return;
}
char *map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
close(fd);
if (map == MAP_FAILED) return;
struct xkb_keymap *km = xkb_keymap_new_from_string(ctx->xkb_ctx, map,
XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
munmap(map, size);
if (!km) return;
if (ctx->xkb_state) xkb_state_unref(ctx->xkb_state);
if (ctx->xkb_keymap) xkb_keymap_unref(ctx->xkb_keymap);
ctx->xkb_keymap = km;
ctx->xkb_state = xkb_state_new(km);
}
static void
keyboard_handle_enter(void *data, struct wl_keyboard *k, uint32_t serial,
struct wl_surface *surface, struct wl_array *keys)
{
(void)k; (void)serial; (void)keys;
WLClientCtx *ctx = data;
wlc_kbd_focused = wlc_top_for_surface(surface);
if (!wlc_kbd_focused) return;
WMEvent ev;
memset(&ev, 0, sizeof(ev));
ev.type = WME_FOCUS_IN;
ev.window = wlc_kbd_focused->view->window;
ev.u.focus.window = ev.window;
W_WL_EnqueueEvent(ctx->scr, &ev, NULL);
}
static void
keyboard_handle_leave(void *data, struct wl_keyboard *k, uint32_t serial,
struct wl_surface *surface)
{
(void)k; (void)serial; (void)surface;
WLClientCtx *ctx = data;
if (!wlc_kbd_focused) return;
WMEvent ev;
memset(&ev, 0, sizeof(ev));
ev.type = WME_FOCUS_OUT;
ev.window = wlc_kbd_focused->view->window;
ev.u.focus.window = ev.window;
W_WL_EnqueueEvent(ctx->scr, &ev, NULL);
wlc_kbd_focused = NULL;
}
static void
keyboard_handle_key(void *data, struct wl_keyboard *k, uint32_t serial,
uint32_t time, uint32_t key, uint32_t state)
{
(void)k; (void)serial;
WLClientCtx *ctx = data;
if (!wlc_kbd_focused || !ctx->xkb_state) return;
/* wl_keyboard.key gives a Linux evdev keycode; xkbcommon expects +8. */
uint32_t xkb_keycode = key + 8;
xkb_keysym_t sym = xkb_state_key_get_one_sym(ctx->xkb_state, xkb_keycode);
char utf8[8] = {0};
int utf8_len = 0;
if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
utf8_len = xkb_state_key_get_utf8(ctx->xkb_state, xkb_keycode,
utf8, sizeof(utf8));
if (utf8_len < 0) utf8_len = 0;
if (utf8_len > 7) utf8_len = 7;
}
WMEvent ev;
memset(&ev, 0, sizeof(ev));
ev.type = (state == WL_KEYBOARD_KEY_STATE_PRESSED)
? WME_KEY_PRESS : WME_KEY_RELEASE;
ev.window = wlc_kbd_focused->view->window;
ev.u.key.window = ev.window;
ev.u.key.keycode = xkb_keycode;
ev.u.key.state = wlc_ptr_button_state | wlc_ptr_mods;
ev.u.key.time = time;
ev.u.key.keysym = sym;
if (utf8_len > 0) {
memcpy(ev.u.key.utf8, utf8, utf8_len);
ev.u.key.utf8_len = utf8_len;
}
W_WL_EnqueueEvent(ctx->scr, &ev, NULL);
}
static void
keyboard_handle_modifiers(void *data, struct wl_keyboard *k, uint32_t serial,
uint32_t mods_depressed, uint32_t mods_latched,
uint32_t mods_locked, uint32_t group)
{
(void)k; (void)serial;
WLClientCtx *ctx = data;
if (ctx->xkb_state) {
xkb_state_update_mask(ctx->xkb_state,
mods_depressed, mods_latched, mods_locked,
0, 0, group);
wlc_ptr_mods = wlc_xkb_mod_mask(ctx->xkb_state);
}
}
static void
keyboard_handle_repeat_info(void *data, struct wl_keyboard *k,
int32_t rate, int32_t delay)
{
(void)data; (void)k; (void)rate; (void)delay;
}
static const struct wl_keyboard_listener keyboard_listener = {
.keymap = keyboard_handle_keymap,
.enter = keyboard_handle_enter,
.leave = keyboard_handle_leave,
.key = keyboard_handle_key,
.modifiers = keyboard_handle_modifiers,
.repeat_info = keyboard_handle_repeat_info,
};
/* ------------------------------------------------------------------ */
/* Seat capabilities */
/* ------------------------------------------------------------------ */
static void
seat_handle_capabilities(void *data, struct wl_seat *seat, uint32_t caps)
{
WLClientCtx *ctx = data;
if ((caps & WL_SEAT_CAPABILITY_POINTER) && !ctx->pointer) {
ctx->pointer = wl_seat_get_pointer(seat);
wl_pointer_add_listener(ctx->pointer, &pointer_listener, ctx);
} else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && ctx->pointer) {
wl_pointer_release(ctx->pointer);
ctx->pointer = NULL;
}
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !ctx->keyboard) {
ctx->keyboard = wl_seat_get_keyboard(seat);
wl_keyboard_add_listener(ctx->keyboard, &keyboard_listener, ctx);
} else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && ctx->keyboard) {
wl_keyboard_release(ctx->keyboard);
ctx->keyboard = NULL;
}
}
static void
seat_handle_name(void *data, struct wl_seat *seat, const char *name)
{
(void)data; (void)seat; (void)name;
}
static const struct wl_seat_listener seat_listener = {
.capabilities = seat_handle_capabilities,
.name = seat_handle_name,
};
/* ------------------------------------------------------------------ */
/* xdg_wm_base ping */
/* ------------------------------------------------------------------ */
static void
wm_base_ping(void *data, struct xdg_wm_base *base, uint32_t serial)
{
(void)data;
xdg_wm_base_pong(base, serial);
}
static const struct xdg_wm_base_listener wm_base_listener = {
.ping = wm_base_ping,
};
/* ------------------------------------------------------------------ */
/* Registry — bind required globals */
/* ------------------------------------------------------------------ */
static void
registry_handle_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version)
{
WLClientCtx *ctx = data;
if (strcmp(interface, wl_compositor_interface.name) == 0) {
uint32_t v = version < 4 ? version : 4;
ctx->compositor = wl_registry_bind(registry, name,
&wl_compositor_interface, v);
} else if (strcmp(interface, wl_shm_interface.name) == 0) {
ctx->shm = wl_registry_bind(registry, name,
&wl_shm_interface, 1);
} else if (strcmp(interface, wl_seat_interface.name) == 0) {
uint32_t v = version < 5 ? version : 5;
ctx->seat = wl_registry_bind(registry, name,
&wl_seat_interface, v);
wl_seat_add_listener(ctx->seat, &seat_listener, ctx);
} else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
uint32_t v = version < 3 ? version : 3;
ctx->wm_base = wl_registry_bind(registry, name,
&xdg_wm_base_interface, v);
xdg_wm_base_add_listener(ctx->wm_base, &wm_base_listener, ctx);
}
}
static void
registry_handle_global_remove(void *data, struct wl_registry *registry,
uint32_t name)
{
(void)data; (void)registry; (void)name;
/* Globals like seat or output may go away on hotplug; ignore for now. */
}
static const struct wl_registry_listener registry_listener = {
.global = registry_handle_global,
.global_remove = registry_handle_global_remove,
};
/* ------------------------------------------------------------------ */
/* Event-loop dispatch (used by W_EventBackendWL when queue is empty) */
/* ------------------------------------------------------------------ */
static void
wlclient_dispatch(int timeout_ms, void *userdata)
{
WLClientCtx *ctx = userdata;
if (!ctx || !ctx->display) return;
/* Standard libwayland-client event-pumping idiom:
* 1. Prepare a read.
* 2. Flush outgoing requests.
* 3. Poll the fd.
* 4. read_events / cancel_read.
* 5. Dispatch any queued events.
*
* We don't need the prepare/read split when we're only blocking
* here, but doing it correctly keeps us safe if multiple threads
* ever want to share the wl_display.
*/
while (wl_display_prepare_read(ctx->display) != 0) {
if (wl_display_dispatch_pending(ctx->display) < 0) return;
}
if (wl_display_flush(ctx->display) < 0 && errno != EAGAIN) {
wl_display_cancel_read(ctx->display);
return;
}
struct pollfd pfd = {
.fd = wl_display_get_fd(ctx->display),
.events = POLLIN,
};
int n = poll(&pfd, 1, timeout_ms);
if (n <= 0) {
wl_display_cancel_read(ctx->display);
return;
}
if (wl_display_read_events(ctx->display) < 0) return;
wl_display_dispatch_pending(ctx->display);
}
/* ------------------------------------------------------------------ */
/* Public API */
/* ------------------------------------------------------------------ */
Bool
W_WLClientInit(struct W_Screen *scrPtr, const char *display)
{
WLClientCtx *ctx = wmalloc(sizeof(*ctx));
memset(ctx, 0, sizeof(*ctx));
ctx->scr = scrPtr;
ctx->display = wl_display_connect(display);
if (!ctx->display) {
wwarning(_("WINGs: wl_display_connect() failed"));
goto fail;
}
ctx->registry = wl_display_get_registry(ctx->display);
if (!ctx->registry) goto fail;
wl_registry_add_listener(ctx->registry, &registry_listener, ctx);
/* Two roundtrips: first to receive globals, second to settle any
* follow-up events from those globals (e.g. wl_seat capabilities). */
if (wl_display_roundtrip(ctx->display) < 0) goto fail;
if (wl_display_roundtrip(ctx->display) < 0) goto fail;
if (!ctx->compositor || !ctx->shm || !ctx->wm_base) {
wwarning(_("WINGs: compositor missing required globals "
"(wl_compositor / wl_shm / xdg_wm_base)"));
goto fail;
}
ctx->xkb_ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
if (!ctx->xkb_ctx) goto fail;
/* Hook event-loop dispatch into the WINGs Wayland event backend so
* WMNextEvent / waitForEvent will pump the compositor when idle. */
W_WL_SetLoopDispatch(scrPtr,
wl_display_get_fd(ctx->display),
wlclient_dispatch,
ctx);
/* Wire surface lifecycle into wview_wl.c: top-level views will
* acquire wl_surface + xdg_toplevel on realize, attach + commit on
* paint, and tear down on destroy. */
W_WLClientToplevelRealizeFn = wl_client_toplevel_realize;
W_WLClientToplevelResizeFn = wl_client_toplevel_resize;
W_WLClientToplevelDestroyFn = wl_client_toplevel_destroy;
{
extern void (*W_ViewCommitBackingFn)(unsigned long id);
extern void (*W_ViewDestroyBackingFn)(unsigned long id);
W_ViewCommitBackingFn = wl_client_view_commit;
W_ViewDestroyBackingFn = wl_client_view_destroy_backing;
}
g_wlclient_ctx = ctx;
return True;
fail:
if (ctx->xkb_ctx) xkb_context_unref(ctx->xkb_ctx);
if (ctx->wm_base) xdg_wm_base_destroy(ctx->wm_base);
if (ctx->seat) wl_seat_destroy(ctx->seat);
if (ctx->shm) wl_shm_destroy(ctx->shm);
if (ctx->compositor) wl_compositor_destroy(ctx->compositor);
if (ctx->registry) wl_registry_destroy(ctx->registry);
if (ctx->display) wl_display_disconnect(ctx->display);
wfree(ctx);
return False;
}
void
W_WLClientShutdown(struct W_Screen *scrPtr)
{
(void)scrPtr;
WLClientCtx *ctx = g_wlclient_ctx;
if (!ctx) return;
g_wlclient_ctx = NULL;
if (ctx->xkb_state) xkb_state_unref(ctx->xkb_state);
if (ctx->xkb_keymap) xkb_keymap_unref(ctx->xkb_keymap);
if (ctx->xkb_ctx) xkb_context_unref(ctx->xkb_ctx);
if (ctx->pointer) wl_pointer_destroy(ctx->pointer);
if (ctx->keyboard) wl_keyboard_destroy(ctx->keyboard);
if (ctx->wm_base) xdg_wm_base_destroy(ctx->wm_base);
if (ctx->seat) wl_seat_destroy(ctx->seat);
if (ctx->shm) wl_shm_destroy(ctx->shm);
if (ctx->compositor) wl_compositor_destroy(ctx->compositor);
if (ctx->registry) wl_registry_destroy(ctx->registry);
if (ctx->display) wl_display_disconnect(ctx->display);
wfree(ctx);
}
#else /* !USE_WAYLAND_CLIENT */
#include "WINGsP.h"
Bool W_WLClientInit(struct W_Screen *scrPtr, const char *display)
{
(void)scrPtr; (void)display;
return False;
}
void W_WLClientShutdown(struct W_Screen *scrPtr) { (void)scrPtr; }
#endif /* USE_WAYLAND_CLIENT */
Reference in New Issue View Git Blame Copy Permalink