From b3ef2f00460d4f11cae4aa0b89249681eb3f9997 Mon Sep 17 00:00:00 2001 From: Annika Date: Fri, 3 Jul 2026 22:29:37 -0700 Subject: [PATCH] init with waymini --- Makefile | 33 + example | Bin 0 -> 36880 bytes example.c | 54 + gen-protocols.sh | 17 + libwaymini.a | Bin 0 -> 23038 bytes waymini | Bin 0 -> 36896 bytes waymini.c | 366 ++++++ waymini.h | 53 + waymini.o | Bin 0 -> 13936 bytes waymini_standalone.c | 39 + xdg-shell-client-protocol.c | 184 +++ xdg-shell-client-protocol.h | 2392 +++++++++++++++++++++++++++++++++++ xdg-shell-client-protocol.o | Bin 0 -> 8448 bytes 13 files changed, 3138 insertions(+) create mode 100644 Makefile create mode 100755 example create mode 100644 example.c create mode 100755 gen-protocols.sh create mode 100644 libwaymini.a create mode 100755 waymini create mode 100644 waymini.c create mode 100644 waymini.h create mode 100644 waymini.o create mode 100644 waymini_standalone.c create mode 100644 xdg-shell-client-protocol.c create mode 100644 xdg-shell-client-protocol.h create mode 100644 xdg-shell-client-protocol.o diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..b7fd218 --- /dev/null +++ b/Makefile @@ -0,0 +1,33 @@ +CC ?= gcc +CFLAGS := -Wall -Wextra -O2 $(shell pkg-config --cflags wayland-client 2>/dev/null) +LDFLAGS := $(shell pkg-config --libs wayland-client 2>/dev/null) + +# Fallback if pkg-config is unavailable or returns nothing. +ifeq ($(LDFLAGS),) + LDFLAGS := -lwayland-client -lm +endif + +LIB_SRC := waymini.c xdg-shell-client-protocol.c +LIB_OBJ := $(LIB_SRC:.c=.o) + +.PHONY: all clean + +all: libwaymini.a example waymini + +libwaymini.a: $(LIB_OBJ) + ar rcs $@ $^ + +example: example.c libwaymini.a + $(CC) $(CFLAGS) -o $@ example.c -L. -lwaymini $(LDFLAGS) + +waymini: waymini_standalone.c waymini.c xdg-shell-client-protocol.c + $(CC) $(CFLAGS) -o $@ waymini_standalone.c waymini.c xdg-shell-client-protocol.c $(LDFLAGS) + +%.o: %.c + $(CC) $(CFLAGS) -c -o $@ $< + +clean: + rm -f $(LIB_OBJ) libwaymini.a example waymini + +xdg-shell-client-protocol.c xdg-shell-client-protocol.h: gen-protocols.sh + bash gen-protocols.sh diff --git a/example b/example new file mode 100755 index 0000000000000000000000000000000000000000..a2fad60e84544c0deff972de3fc0abd05be8a99d GIT binary patch literal 36880 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 literal 0 HcmV?d00001 diff --git a/example.c b/example.c new file mode 100644 index 0000000..358cd8d --- /dev/null +++ b/example.c @@ -0,0 +1,54 @@ +/* Example program that links against the waymini library. + * No external dependencies beyond waymini itself and the C standard library. + */ + +#include "waymini.h" + +#include +#include +#include +#include + +static void on_key(void *user, uint32_t keycode, uint32_t state) { + (void)user; + const char *label = state ? "down" : "up "; + printf("key %s: %u\n", label, keycode); + fflush(stdout); +} + +int main(void) { + uint32_t w = 800, h = 480; + + struct waymini *wm = waymini_create(w, h, on_key, NULL); + if (!wm) return 1; + + printf("surface: %ux%u stride=%u\n", + waymini_get_width(wm), waymini_get_height(wm), waymini_get_stride(wm)); + + uint8_t *pixels = (uint8_t *)waymini_get_pixels(wm); + if (!pixels) { + waymini_destroy(wm); + return 1; + } + + /* Fill a simple gradient. Each row is stride bytes. */ + for (uint32_t y = 0; y < h; y++) { + for (uint32_t x = 0; x < w; x++) { + size_t i = (size_t)y * waymini_get_stride(wm) + (size_t)x * 4; + pixels[i + 0] = (uint8_t)(y * 255 / h); /* B */ + pixels[i + 1] = 0x00; /* G */ + pixels[i + 2] = (uint8_t)(x * 255 / w); /* R */ + pixels[i + 3] = 0xFF; /* A (ignored for XRGB) */ + } + } + + waymini_present(wm); + pixels[200001] = 255; + + while (!waymini_should_close(wm)) { + if (waymini_dispatch(wm) < 0) break; + } + + waymini_destroy(wm); + return 0; +} diff --git a/gen-protocols.sh b/gen-protocols.sh new file mode 100755 index 0000000..9e9b9ff --- /dev/null +++ b/gen-protocols.sh @@ -0,0 +1,17 @@ +#!/usr/bin/env bash +set -euo pipefail + +XML="/usr/share/wayland-protocols/stable/xdg-shell/xdg-shell.xml" +if [ ! -f "$XML" ]; then + echo "Cannot find xdg-shell XML at: $XML" >&2 + exit 1 +fi + +OUTDIR="." +mkdir -p "$OUTDIR" + +wayland-scanner client-header "$XML" "$OUTDIR/xdg-shell-client-protocol.h" +wayland-scanner private-code "$XML" "$OUTDIR/xdg-shell-client-protocol.c" + +echo "Generated:" +ls -l "$OUTDIR/xdg-shell-client-protocol.h" "$OUTDIR/xdg-shell-client-protocol.c" diff --git a/libwaymini.a b/libwaymini.a new file mode 100644 index 0000000000000000000000000000000000000000..a5a964ab893fb2a78dffbe4d8d71b78c72b20f20 GIT binary patch literal 23038 zcmeI44|H5royTAPw1gBV0o09xGDy&LkuXCG1d1?e6Z(p&1ZX8nF_~s2&5%iEc4k6T zTMyBsf8I`uafLlSyZ(tQXDvru8ur;Mvin`iUaP8u1ql*ewr5u+(3U2oIz3=y% z`ORfU5O>$r-FwcPd++D{?(hEY@7{OcpZngNeR(v~KX^s`1;Nq~QdvK(e}lm#mt4#e zef5sxG&)Z8t6%!ocAw*vZX2VUh7%)+-u_HHnu|M<-4M_9ZcM~-gC%4zp4c#$D?!;@ zCJ`$wmrjhuli7k)Iup;vM~bCliEKKW>o00fr;^EnbSD01qw#F6w?CQ67S(14Q=`e4 z1!E+aNo{h*VjFtXsq|>NH!+fnX9lAEal>+{bTWQRJZa(Vs1dPfI+ac25~-1R#@exQ zxOaUt8&}l1!0t5FXXTPh3Z2?lPsW~~9gHWF=l3TQQuI+SidS z4i$aI`xZ*N6F;ppLhi)|J$)zam~nw#3auTT7{ zYIMN$lFf}B-d9}ji7rY8jmlM&Cnvqr-TJfKg|4@*xi0*jm-mEE@}#?qeu5;{m8V+C))r$`_(=F^f|l6vZ%_Q7 zI(L#gaciBEt3`XsUaIR7*W1!uM@@IVrOjOC^5)L)gT`m>u2-R<``{;bTvvV#$?v)d z-1Qz<s9FDj*4$h*f1%&piTi`D*GaDE zj3^}oQQ{o$uE4lC5}{iM*+&LC-NA+P!^@f|A1o3f`=Ux)W( z``g2_V$ZHSrqFudp~wGjpiqA6e8c2NsqNGO&yli5H~;0`klZ?-TfjYkk149aW*58P zUb;H($^YinMpF=-|{xJJ}2kkia zAM^9azd^fb9#!Ml#eCAz?mhoycp8&PsNH*N-(I+rrjDjAFW20*%KJta9mA1T-nacK zy#qAEG)$gKQ&o5#laN32xL%EGCZC4M_tGvJWk%dT)M<|L_Ln)@UGI^?=v+b5gkQ$Z zFXPq?k)M9nFzGKZ%+eeCJJ}R+ruxQ~BrFFG0sfB4(p3+ht6F;i-_IK@i1;x~=qTxf9 zAkGkF1UtO`vG)CsR=fG3o-Xg6X_D&lKDWnL*5M6pd0=9kGMHOBypK;(#6Fwdw~#X7 zBh>mrt?zutaXNhcPN2Tt(T!tmVh735%=x4I1d8Xc-(u!%ch_4e=eP}@zK=W{GFrVA zEhuI<9k1N28g=AXw2<%3T=^w5DLijVl8QEW;#rzX{K7+#uKZA_Bi~QcmhZ0iwSJ$q zuc349(=X_05*_Qve-6bv@eI)#dfOF3y&&cNAyK7Mx6*aQ+N+<>?seqTz+v z-#t(~f4ORj*Z
  • MNUqimXl?HtmE;KIp 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�V6951J literal 0 HcmV?d00001 diff --git a/waymini.c b/waymini.c new file mode 100644 index 0000000..4916681 --- /dev/null +++ b/waymini.c @@ -0,0 +1,366 @@ +#define _GNU_SOURCE +#define _POSIX_C_SOURCE 200809L + +#include "waymini.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "xdg-shell-client-protocol.h" + +struct shm_state { + int fd; + size_t size; + void *map; + struct wl_shm *shm_iface; + struct wl_buffer *wl_buffer; +}; + +struct window_state { + struct wl_compositor *compositor; + struct wl_surface *surface; + struct xdg_wm_base *wm_base; + struct xdg_surface *xdg_surface; + struct xdg_toplevel *xdg_toplevel; + + uint32_t width, height; + uint32_t bpp; + uint32_t stride; + int configured; +}; + +struct input_state { + struct wl_seat *seat; + struct wl_keyboard *keyboard; + + waymini_key_cb on_keycode; + void *user; +}; + +struct waymini { + struct wl_display *display; + struct wl_registry *registry; + + struct wl_compositor *compositor; + struct wl_shm *shm_iface; + struct xdg_wm_base *wm_base; + + struct shm_state shm; + struct window_state win; + struct input_state in; + + int should_close; +}; + +static void on_xdg_surface_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial) { + struct waymini *wm = data; + xdg_surface_ack_configure(xdg_surface, serial); + wm->win.configured = 1; +} + +static const struct xdg_surface_listener xdg_surface_listener = { + .configure = on_xdg_surface_configure, +}; + +static void on_toplevel_configure(void *data, struct xdg_toplevel *toplevel, + int32_t width, int32_t height, + struct wl_array *states) { + (void)data; (void)toplevel; (void)width; (void)height; (void)states; +} + +static void on_toplevel_close(void *data, struct xdg_toplevel *toplevel) { + (void)toplevel; + struct waymini *wm = data; + wm->should_close = 1; +} + +static const struct xdg_toplevel_listener xdg_toplevel_listener = { + .configure = on_toplevel_configure, + .close = on_toplevel_close, +}; + +static void on_wm_base_ping(void *data, struct xdg_wm_base *wm_base, uint32_t serial) { + (void)data; + xdg_wm_base_pong(wm_base, serial); +} + +static const struct xdg_wm_base_listener wm_base_listener = { + .ping = on_wm_base_ping, +}; + +static void on_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) { + (void)keyboard; + struct input_state *in = data; + + if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) { + close(fd); + return; + } + char *buf = malloc(size); + if (buf) { + size_t off = 0; + while (off < size) { + ssize_t r = read(fd, buf + off, size - off); + if (r <= 0) break; + off += (size_t)r; + } + free(buf); + } else { + (void)read(fd, buf, 0); + } + close(fd); + (void)in; +} + +static void on_keyboard_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, + uint32_t time, uint32_t key, uint32_t state) { + (void)keyboard; (void)serial; (void)time; + struct input_state *in = data; + if (in->on_keycode) in->on_keycode(in->user, key, state); +} + +static void on_keyboard_enter(void *data, struct wl_keyboard *keyboard, + uint32_t serial, struct wl_surface *surface, + struct wl_array *keys) { + (void)data; (void)keyboard; (void)serial; (void)surface; (void)keys; +} + +static void on_keyboard_leave(void *data, struct wl_keyboard *keyboard, + uint32_t serial, struct wl_surface *surface) { + (void)data; (void)keyboard; (void)serial; (void)surface; +} + +static void on_keyboard_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) { + (void)data; (void)keyboard; (void)serial; + (void)mods_depressed; (void)mods_latched; (void)mods_locked; (void)group; +} + +static void on_keyboard_repeat_info(void *data, struct wl_keyboard *keyboard, + int32_t rate, int32_t delay) { + (void)data; (void)keyboard; (void)rate; (void)delay; +} + +static const struct wl_keyboard_listener keyboard_listener = { + .keymap = on_keymap, + .enter = on_keyboard_enter, + .leave = on_keyboard_leave, + .key = on_keyboard_key, + .modifiers = on_keyboard_modifiers, + .repeat_info = on_keyboard_repeat_info, +}; + +static void on_seat_capabilities(void *data, struct wl_seat *seat, enum wl_seat_capability caps) { + struct input_state *in = data; + if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !in->keyboard) { + in->seat = seat; + in->keyboard = wl_seat_get_keyboard(seat); + wl_keyboard_add_listener(in->keyboard, &keyboard_listener, in); + } +} + +static void on_seat_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 = on_seat_capabilities, + .name = on_seat_name, +}; + +static void on_registry_global(void *data, struct wl_registry *registry, + uint32_t name, const char *interface, uint32_t version) { + struct waymini *wm = data; + (void)registry; + + if (strcmp(interface, "wl_compositor") == 0) { + wm->compositor = wl_registry_bind(wm->registry, name, &wl_compositor_interface, 4); + } else if (strcmp(interface, "wl_shm") == 0) { + wm->shm_iface = wl_registry_bind(wm->registry, name, &wl_shm_interface, 1); + wm->shm.shm_iface = wm->shm_iface; + } else if (strcmp(interface, "xdg_wm_base") == 0) { + wm->wm_base = wl_registry_bind(wm->registry, name, &xdg_wm_base_interface, 1); + xdg_wm_base_add_listener(wm->wm_base, &wm_base_listener, wm); + } else if (strcmp(interface, "wl_seat") == 0) { + struct wl_seat *seat = wl_registry_bind(wm->registry, name, &wl_seat_interface, version); + wl_seat_add_listener(seat, &seat_listener, &wm->in); + } +} + +static void on_registry_global_remove(void *data, struct wl_registry *registry, uint32_t name) { + (void)data; (void)registry; (void)name; +} + +static const struct wl_registry_listener registry_listener = { + .global = on_registry_global, + .global_remove = on_registry_global_remove, +}; + +static void waymini_destroy_internal(struct waymini *wm); + +static int create_shm_buffer(struct waymini *wm) { + struct shm_state *s = &wm->shm; + struct window_state *w = &wm->win; + + s->size = (size_t)w->stride * (size_t)w->height; + s->fd = memfd_create("waymini-shm", MFD_CLOEXEC); + if (s->fd < 0) { perror("memfd_create"); return -1; } + + if (ftruncate(s->fd, (off_t)s->size) < 0) { perror("ftruncate"); return -1; } + + s->map = mmap(NULL, s->size, PROT_READ | PROT_WRITE, MAP_SHARED, s->fd, 0); + if (s->map == MAP_FAILED) { perror("mmap"); return -1; } + + struct wl_buffer *buf; + struct wl_shm_pool *pool = wl_shm_create_pool(s->shm_iface, s->fd, (int)s->size); + buf = wl_shm_pool_create_buffer(pool, 0, w->width, w->height, (int)w->stride, WL_SHM_FORMAT_XRGB8888); + wl_shm_pool_destroy(pool); + if (!buf) { fprintf(stderr, "wl_shm_pool_create_buffer failed\n"); return -1; } + + s->wl_buffer = buf; + return 0; +} + +struct waymini *waymini_create(uint32_t width, uint32_t height, + waymini_key_cb key_cb, void *user) { + struct waymini *wm = calloc(1, sizeof(*wm)); + if (!wm) return NULL; + + wm->display = wl_display_connect(NULL); + if (!wm->display) { fprintf(stderr, "wl_display_connect failed\n"); free(wm); return NULL; } + + wm->registry = wl_display_get_registry(wm->display); + wl_registry_add_listener(wm->registry, ®istry_listener, wm); + wl_display_roundtrip(wm->display); + + if (!wm->compositor || !wm->shm_iface || !wm->wm_base) { + fprintf(stderr, "missing globals\n"); + waymini_destroy_internal(wm); + return NULL; + } + + wm->win.compositor = wm->compositor; + wm->win.surface = wl_compositor_create_surface(wm->compositor); + + wm->win.xdg_surface = xdg_wm_base_get_xdg_surface(wm->wm_base, wm->win.surface); + xdg_surface_add_listener(wm->win.xdg_surface, &xdg_surface_listener, wm); + + wm->win.xdg_toplevel = xdg_surface_get_toplevel(wm->win.xdg_surface); + xdg_toplevel_add_listener(wm->win.xdg_toplevel, &xdg_toplevel_listener, wm); + xdg_toplevel_set_title(wm->win.xdg_toplevel, "waymini"); + xdg_toplevel_set_app_id(wm->win.xdg_toplevel, "waymini"); + + wm->in.on_keycode = key_cb; + wm->in.user = user; + + wm->win.width = width; + wm->win.height = height; + wm->win.bpp = 4; + wm->win.stride = width * wm->win.bpp; + + wl_surface_commit(wm->win.surface); + + while (!wm->win.configured) { + if (wl_display_dispatch(wm->display) < 0) { + fprintf(stderr, "dispatch failed waiting for configure\n"); + waymini_destroy_internal(wm); + return NULL; + } + } + + if (create_shm_buffer(wm) < 0) { + fprintf(stderr, "create_shm_buffer failed\n"); + waymini_destroy_internal(wm); + return NULL; + } + + return wm; +} + +uint32_t waymini_get_width(const struct waymini *wm) { return wm ? wm->win.width : 0; } +uint32_t waymini_get_height(const struct waymini *wm) { return wm ? wm->win.height : 0; } +uint32_t waymini_get_stride(const struct waymini *wm) { return wm ? wm->win.stride : 0; } +void *waymini_get_pixels(const struct waymini *wm) { return wm ? wm->shm.map : NULL; } + +void waymini_present(struct waymini *wm) { + if (!wm || !wm->win.configured) return; + wl_surface_attach(wm->win.surface, wm->shm.wl_buffer, 0, 0); + wl_surface_commit(wm->win.surface); + wl_display_flush(wm->display); +} + +int waymini_dispatch(struct waymini *wm) { + if (!wm || !wm->display) return -1; + return wl_display_dispatch(wm->display); +} + +int waymini_poll(struct waymini *wm) { + if (!wm || !wm->display) return -1; + wl_display_dispatch_pending(wm->display); + wl_display_flush(wm->display); + int ret = wl_display_prepare_read(wm->display); + if (ret < 0) return wl_display_dispatch_pending(wm->display) >= 0 ? 1 : -1; + + int fd = wl_display_get_fd(wm->display); + fd_set rfds; + FD_ZERO(&rfds); + FD_SET(fd, &rfds); + struct timeval tv = { 0, 0 }; + ret = select(fd + 1, &rfds, NULL, NULL, &tv); + if (ret > 0) { + wl_display_read_events(wm->display); + wl_display_dispatch_pending(wm->display); + return 1; + } + wl_display_cancel_read(wm->display); + return 0; +} + +void waymini_request_close(struct waymini *wm) { + if (wm) wm->should_close = 1; +} + +int waymini_should_close(const struct waymini *wm) { + return wm ? wm->should_close : 0; +} + +static void waymini_destroy_internal(struct waymini *wm) { + if (!wm) return; + + if (wm->in.keyboard) wl_keyboard_destroy(wm->in.keyboard); + if (wm->in.seat) wl_seat_destroy(wm->in.seat); + + if (wm->shm.wl_buffer) wl_buffer_destroy(wm->shm.wl_buffer); + if (wm->shm.map && wm->shm.size) munmap(wm->shm.map, wm->shm.size); + if (wm->shm.fd >= 0) close(wm->shm.fd); + + if (wm->win.xdg_toplevel) xdg_toplevel_destroy(wm->win.xdg_toplevel); + if (wm->win.xdg_surface) xdg_surface_destroy(wm->win.xdg_surface); + if (wm->win.surface) wl_surface_destroy(wm->win.surface); + + if (wm->wm_base) xdg_wm_base_destroy(wm->wm_base); + if (wm->compositor) wl_compositor_destroy(wm->compositor); + if (wm->shm_iface) wl_shm_destroy(wm->shm_iface); + + if (wm->registry) wl_registry_destroy(wm->registry); + if (wm->display) wl_display_disconnect(wm->display); + free(wm); +} + +void waymini_destroy(struct waymini *wm) { + waymini_destroy_internal(wm); +} + \ No newline at end of file diff --git a/waymini.h b/waymini.h new file mode 100644 index 0000000..74b8b34 --- /dev/null +++ b/waymini.h @@ -0,0 +1,53 @@ +#ifndef WAYMINI_H +#define WAYMINI_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct waymini; + +typedef void (*waymini_key_cb)(void *user, uint32_t keycode, uint32_t state); + +/* Create a Wayland surface of the requested dimensions. + * key_cb may be NULL if keyboard input is not needed. + */ +struct waymini *waymini_create(uint32_t width, uint32_t height, + waymini_key_cb key_cb, void *user); + +/* Dimensions and pixel access. */ +uint32_t waymini_get_width(const struct waymini *wm); +uint32_t waymini_get_height(const struct waymini *wm); +uint32_t waymini_get_stride(const struct waymini *wm); +void *waymini_get_pixels(const struct waymini *wm); + +/* Mark the SHM buffer as changed and commit it to the compositor. */ +void waymini_present(struct waymini *wm); + +/* Dispatch one or more Wayland events. Returns 0 on success, -1 on error. + * Blocks until at least one event is processed. + */ +int waymini_dispatch(struct waymini *wm); + +/* Non-blocking poll for events. Returns 1 if events were dispatched, 0 if no + * events were available, and -1 on error. + */ +int waymini_poll(struct waymini *wm); + +/* Request a graceful close (e.g. from the toplevel close button). */ +void waymini_request_close(struct waymini *wm); + +/* Returns non-zero when the compositor asked us to close. */ +int waymini_should_close(const struct waymini *wm); + +/* Clean up. */ +void waymini_destroy(struct waymini *wm); + +#ifdef __cplusplus +} +#endif + +#endif /* WAYMINI_H */ diff --git a/waymini.o b/waymini.o new file mode 100644 index 0000000000000000000000000000000000000000..d469f0a906650768182a2f58d161ada0b030ebfa GIT binary patch literal 13936 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 kng~Qu&g08DgnQ_@(#U<>*J!s^`S;0j- +#include +#include + +static void on_keycode(void *user, uint32_t keycode, uint32_t state) { + (void)user; + printf("key=%u state=%u\n", keycode, state); + fflush(stdout); +} + +int main(void) { + uint32_t w = 320, h = 200; + struct waymini *wm = waymini_create(w, h, on_keycode, NULL); + if (!wm) return 1; + + uint8_t *p = (uint8_t *)waymini_get_pixels(wm); + for (uint32_t y = 0; y < h; y++) { + for (uint32_t x = 0; x < w; x++) { + size_t i = (size_t)y * waymini_get_stride(wm) + (size_t)x * 4; + p[i + 0] = 0x20; + p[i + 1] = (uint8_t)(y * 255 / h); + p[i + 2] = (uint8_t)(x * 255 / w); + p[i + 3] = 0xff; + } + } + + waymini_present(wm); + + while (!waymini_should_close(wm)) { + if (waymini_dispatch(wm) < 0) break; + } + + waymini_destroy(wm); + return 0; +} diff --git a/xdg-shell-client-protocol.c b/xdg-shell-client-protocol.c new file mode 100644 index 0000000..102e36f --- /dev/null +++ b/xdg-shell-client-protocol.c @@ -0,0 +1,184 @@ +/* Generated by wayland-scanner 1.25.0 */ + +/* + * Copyright © 2008-2013 Kristian Høgsberg + * Copyright © 2013 Rafael Antognolli + * Copyright © 2013 Jasper St. Pierre + * Copyright © 2010-2013 Intel Corporation + * Copyright © 2015-2017 Samsung Electronics Co., Ltd + * Copyright © 2015-2017 Red Hat Inc. + * + * 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 +#include +#include +#include "wayland-util.h" + +#ifndef __has_attribute +# define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */ +#endif + +#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4) +#define WL_PRIVATE __attribute__ ((visibility("hidden"))) +#else +#define WL_PRIVATE +#endif + +extern const struct wl_interface wl_output_interface; +extern const struct wl_interface wl_seat_interface; +extern const struct wl_interface wl_surface_interface; +extern const struct wl_interface xdg_popup_interface; +extern const struct wl_interface xdg_positioner_interface; +extern const struct wl_interface xdg_surface_interface; +extern const struct wl_interface xdg_toplevel_interface; + +static const struct wl_interface *xdg_shell_types[] = { + NULL, + NULL, + NULL, + NULL, + &xdg_positioner_interface, + &xdg_surface_interface, + &wl_surface_interface, + &xdg_toplevel_interface, + &xdg_popup_interface, + &xdg_surface_interface, + &xdg_positioner_interface, + &xdg_toplevel_interface, + &wl_seat_interface, + NULL, + NULL, + NULL, + &wl_seat_interface, + NULL, + &wl_seat_interface, + NULL, + NULL, + &wl_output_interface, + &wl_seat_interface, + NULL, + &xdg_positioner_interface, + NULL, +}; + +static const struct wl_message xdg_wm_base_requests[] = { + { "destroy", "", xdg_shell_types + 0 }, + { "create_positioner", "n", xdg_shell_types + 4 }, + { "get_xdg_surface", "no", xdg_shell_types + 5 }, + { "pong", "u", xdg_shell_types + 0 }, +}; + +static const struct wl_message xdg_wm_base_events[] = { + { "ping", "u", xdg_shell_types + 0 }, +}; + +WL_PRIVATE const struct wl_interface xdg_wm_base_interface = { + "xdg_wm_base", 7, + 4, xdg_wm_base_requests, + 1, xdg_wm_base_events, +}; + +static const struct wl_message xdg_positioner_requests[] = { + { "destroy", "", xdg_shell_types + 0 }, + { "set_size", "ii", xdg_shell_types + 0 }, + { "set_anchor_rect", "iiii", xdg_shell_types + 0 }, + { "set_anchor", "u", xdg_shell_types + 0 }, + { "set_gravity", "u", xdg_shell_types + 0 }, + { "set_constraint_adjustment", "u", xdg_shell_types + 0 }, + { "set_offset", "ii", xdg_shell_types + 0 }, + { "set_reactive", "3", xdg_shell_types + 0 }, + { "set_parent_size", "3ii", xdg_shell_types + 0 }, + { "set_parent_configure", "3u", xdg_shell_types + 0 }, +}; + +WL_PRIVATE const struct wl_interface xdg_positioner_interface = { + "xdg_positioner", 7, + 10, xdg_positioner_requests, + 0, NULL, +}; + +static const struct wl_message xdg_surface_requests[] = { + { "destroy", "", xdg_shell_types + 0 }, + { "get_toplevel", "n", xdg_shell_types + 7 }, + { "get_popup", "n?oo", xdg_shell_types + 8 }, + { "set_window_geometry", "iiii", xdg_shell_types + 0 }, + { "ack_configure", "u", xdg_shell_types + 0 }, +}; + +static const struct wl_message xdg_surface_events[] = { + { "configure", "u", xdg_shell_types + 0 }, +}; + +WL_PRIVATE const struct wl_interface xdg_surface_interface = { + "xdg_surface", 7, + 5, xdg_surface_requests, + 1, xdg_surface_events, +}; + +static const struct wl_message xdg_toplevel_requests[] = { + { "destroy", "", xdg_shell_types + 0 }, + { "set_parent", "?o", xdg_shell_types + 11 }, + { "set_title", "s", xdg_shell_types + 0 }, + { "set_app_id", "s", xdg_shell_types + 0 }, + { "show_window_menu", "ouii", xdg_shell_types + 12 }, + { "move", "ou", xdg_shell_types + 16 }, + { "resize", "ouu", xdg_shell_types + 18 }, + { "set_max_size", "ii", xdg_shell_types + 0 }, + { "set_min_size", "ii", xdg_shell_types + 0 }, + { "set_maximized", "", xdg_shell_types + 0 }, + { "unset_maximized", "", xdg_shell_types + 0 }, + { "set_fullscreen", "?o", xdg_shell_types + 21 }, + { "unset_fullscreen", "", xdg_shell_types + 0 }, + { "set_minimized", "", xdg_shell_types + 0 }, +}; + +static const struct wl_message xdg_toplevel_events[] = { + { "configure", "iia", xdg_shell_types + 0 }, + { "close", "", xdg_shell_types + 0 }, + { "configure_bounds", "4ii", xdg_shell_types + 0 }, + { "wm_capabilities", "5a", xdg_shell_types + 0 }, +}; + +WL_PRIVATE const struct wl_interface xdg_toplevel_interface = { + "xdg_toplevel", 7, + 14, xdg_toplevel_requests, + 4, xdg_toplevel_events, +}; + +static const struct wl_message xdg_popup_requests[] = { + { "destroy", "", xdg_shell_types + 0 }, + { "grab", "ou", xdg_shell_types + 22 }, + { "reposition", "3ou", xdg_shell_types + 24 }, +}; + +static const struct wl_message xdg_popup_events[] = { + { "configure", "iiii", xdg_shell_types + 0 }, + { "popup_done", "", xdg_shell_types + 0 }, + { "repositioned", "3u", xdg_shell_types + 0 }, +}; + +WL_PRIVATE const struct wl_interface xdg_popup_interface = { + "xdg_popup", 7, + 3, xdg_popup_requests, + 3, xdg_popup_events, +}; + diff --git a/xdg-shell-client-protocol.h b/xdg-shell-client-protocol.h new file mode 100644 index 0000000..0e396ac --- /dev/null +++ b/xdg-shell-client-protocol.h @@ -0,0 +1,2392 @@ +/* Generated by wayland-scanner 1.25.0 */ + +#ifndef XDG_SHELL_CLIENT_PROTOCOL_H +#define XDG_SHELL_CLIENT_PROTOCOL_H + +#include +#include +#include "wayland-client.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @page page_xdg_shell The xdg_shell protocol + * @section page_ifaces_xdg_shell Interfaces + * - @subpage page_iface_xdg_wm_base - create desktop-style surfaces + * - @subpage page_iface_xdg_positioner - child surface positioner + * - @subpage page_iface_xdg_surface - desktop user interface surface base interface + * - @subpage page_iface_xdg_toplevel - toplevel surface + * - @subpage page_iface_xdg_popup - short-lived, popup surfaces for menus + * @section page_copyright_xdg_shell Copyright + * 
    + *
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ * Copyright © 2015-2017 Samsung Electronics Co., Ltd
+ * Copyright © 2015-2017 Red Hat Inc.
+ *
+ * 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.
+ *
    + */ +struct wl_output; +struct wl_seat; +struct wl_surface; +struct xdg_popup; +struct xdg_positioner; +struct xdg_surface; +struct xdg_toplevel; +struct xdg_wm_base; + +#ifndef XDG_WM_BASE_INTERFACE +#define XDG_WM_BASE_INTERFACE +/** + * @page page_iface_xdg_wm_base xdg_wm_base + * @section page_iface_xdg_wm_base_desc Description + * + * The xdg_wm_base interface is exposed as a global object enabling clients + * to turn their wl_surfaces into windows in a desktop environment. It + * defines the basic functionality needed for clients and the compositor to + * create windows that can be dragged, resized, maximized, etc, as well as + * creating transient windows such as popup menus. + * @section page_iface_xdg_wm_base_api API + * See @ref iface_xdg_wm_base. + */ +/** + * @defgroup iface_xdg_wm_base The xdg_wm_base interface + * + * The xdg_wm_base interface is exposed as a global object enabling clients + * to turn their wl_surfaces into windows in a desktop environment. It + * defines the basic functionality needed for clients and the compositor to + * create windows that can be dragged, resized, maximized, etc, as well as + * creating transient windows such as popup menus. + */ +extern const struct wl_interface xdg_wm_base_interface; +#endif +#ifndef XDG_POSITIONER_INTERFACE +#define XDG_POSITIONER_INTERFACE +/** + * @page page_iface_xdg_positioner xdg_positioner + * @section page_iface_xdg_positioner_desc Description + * + * The xdg_positioner provides a collection of rules for the placement of a + * child surface relative to a parent surface. Rules can be defined to ensure + * the child surface remains within the visible area's borders, and to + * specify how the child surface changes its position, such as sliding along + * an axis, or flipping around a rectangle. These positioner-created rules are + * constrained by the requirement that a child surface must intersect with or + * be at least partially adjacent to its parent surface. + * + * See the various requests for details about possible rules. + * + * At the time of the request, the compositor makes a copy of the rules + * specified by the xdg_positioner. Thus, after the request is complete the + * xdg_positioner object can be destroyed or reused; further changes to the + * object will have no effect on previous usages. + * + * For an xdg_positioner object to be considered complete, it must have a + * non-zero size set by set_size, and a non-zero anchor rectangle set by + * set_anchor_rect. Passing an incomplete xdg_positioner object when + * positioning a surface raises an invalid_positioner error. + * @section page_iface_xdg_positioner_api API + * See @ref iface_xdg_positioner. + */ +/** + * @defgroup iface_xdg_positioner The xdg_positioner interface + * + * The xdg_positioner provides a collection of rules for the placement of a + * child surface relative to a parent surface. Rules can be defined to ensure + * the child surface remains within the visible area's borders, and to + * specify how the child surface changes its position, such as sliding along + * an axis, or flipping around a rectangle. These positioner-created rules are + * constrained by the requirement that a child surface must intersect with or + * be at least partially adjacent to its parent surface. + * + * See the various requests for details about possible rules. + * + * At the time of the request, the compositor makes a copy of the rules + * specified by the xdg_positioner. Thus, after the request is complete the + * xdg_positioner object can be destroyed or reused; further changes to the + * object will have no effect on previous usages. + * + * For an xdg_positioner object to be considered complete, it must have a + * non-zero size set by set_size, and a non-zero anchor rectangle set by + * set_anchor_rect. Passing an incomplete xdg_positioner object when + * positioning a surface raises an invalid_positioner error. + */ +extern const struct wl_interface xdg_positioner_interface; +#endif +#ifndef XDG_SURFACE_INTERFACE +#define XDG_SURFACE_INTERFACE +/** + * @page page_iface_xdg_surface xdg_surface + * @section page_iface_xdg_surface_desc Description + * + * An interface that may be implemented by a wl_surface, for + * implementations that provide a desktop-style user interface. + * + * It provides a base set of functionality required to construct user + * interface elements requiring management by the compositor, such as + * toplevel windows, menus, etc. The types of functionality are split into + * xdg_surface roles. + * + * Creating an xdg_surface does not set the role for a wl_surface. In order + * to map an xdg_surface, the client must create a role-specific object + * using, e.g., get_toplevel, get_popup. The wl_surface for any given + * xdg_surface can have at most one role, and may not be assigned any role + * not based on xdg_surface. + * + * A role must be assigned before any other requests are made to the + * xdg_surface object. + * + * The client must call wl_surface.commit on the corresponding wl_surface + * for the xdg_surface state to take effect. + * + * Creating an xdg_surface from a wl_surface which has a buffer attached or + * committed is a client error, and any attempts by a client to attach or + * manipulate a buffer prior to the first xdg_surface.configure call must + * also be treated as errors. + * + * After creating a role-specific object and setting it up (e.g. by sending + * the title, app ID, size constraints, parent, etc), the client must + * perform an initial commit without any buffer attached. The compositor + * will reply with initial wl_surface state such as + * wl_surface.preferred_buffer_scale followed by an xdg_surface.configure + * event. The client must acknowledge it and is then allowed to attach a + * buffer to map the surface. + * + * Mapping an xdg_surface-based role surface is defined as making it + * possible for the surface to be shown by the compositor. Note that + * a mapped surface is not guaranteed to be visible once it is mapped. + * + * For an xdg_surface to be mapped by the compositor, the following + * conditions must be met: + * (1) the client has assigned an xdg_surface-based role to the surface + * (2) the client has set and committed the xdg_surface state and the + * role-dependent state to the surface + * (3) the client has committed a buffer to the surface + * + * A newly-unmapped surface is considered to have met condition (1) out + * of the 3 required conditions for mapping a surface if its role surface + * has not been destroyed, i.e. the client must perform the initial commit + * again before attaching a buffer. + * @section page_iface_xdg_surface_api API + * See @ref iface_xdg_surface. + */ +/** + * @defgroup iface_xdg_surface The xdg_surface interface + * + * An interface that may be implemented by a wl_surface, for + * implementations that provide a desktop-style user interface. + * + * It provides a base set of functionality required to construct user + * interface elements requiring management by the compositor, such as + * toplevel windows, menus, etc. The types of functionality are split into + * xdg_surface roles. + * + * Creating an xdg_surface does not set the role for a wl_surface. In order + * to map an xdg_surface, the client must create a role-specific object + * using, e.g., get_toplevel, get_popup. The wl_surface for any given + * xdg_surface can have at most one role, and may not be assigned any role + * not based on xdg_surface. + * + * A role must be assigned before any other requests are made to the + * xdg_surface object. + * + * The client must call wl_surface.commit on the corresponding wl_surface + * for the xdg_surface state to take effect. + * + * Creating an xdg_surface from a wl_surface which has a buffer attached or + * committed is a client error, and any attempts by a client to attach or + * manipulate a buffer prior to the first xdg_surface.configure call must + * also be treated as errors. + * + * After creating a role-specific object and setting it up (e.g. by sending + * the title, app ID, size constraints, parent, etc), the client must + * perform an initial commit without any buffer attached. The compositor + * will reply with initial wl_surface state such as + * wl_surface.preferred_buffer_scale followed by an xdg_surface.configure + * event. The client must acknowledge it and is then allowed to attach a + * buffer to map the surface. + * + * Mapping an xdg_surface-based role surface is defined as making it + * possible for the surface to be shown by the compositor. Note that + * a mapped surface is not guaranteed to be visible once it is mapped. + * + * For an xdg_surface to be mapped by the compositor, the following + * conditions must be met: + * (1) the client has assigned an xdg_surface-based role to the surface + * (2) the client has set and committed the xdg_surface state and the + * role-dependent state to the surface + * (3) the client has committed a buffer to the surface + * + * A newly-unmapped surface is considered to have met condition (1) out + * of the 3 required conditions for mapping a surface if its role surface + * has not been destroyed, i.e. the client must perform the initial commit + * again before attaching a buffer. + */ +extern const struct wl_interface xdg_surface_interface; +#endif +#ifndef XDG_TOPLEVEL_INTERFACE +#define XDG_TOPLEVEL_INTERFACE +/** + * @page page_iface_xdg_toplevel xdg_toplevel + * @section page_iface_xdg_toplevel_desc Description + * + * This interface defines an xdg_surface role which allows a surface to, + * among other things, set window-like properties such as maximize, + * fullscreen, and minimize, set application-specific metadata like title and + * id, and well as trigger user interactive operations such as interactive + * resize and move. + * + * An xdg_toplevel by default is responsible for providing the full intended + * visual representation of the toplevel, which depending on the window + * state, may mean things like a title bar, window controls and drop shadow. + * + * Unmapping an xdg_toplevel means that the surface cannot be shown + * by the compositor until it is explicitly mapped again. + * All active operations (e.g., move, resize) are canceled and all + * attributes (e.g. title, state, stacking, ...) are discarded for + * an xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to + * the state it had right after xdg_surface.get_toplevel. The client + * can re-map the toplevel by performing a commit without any buffer + * attached, waiting for a configure event and handling it as usual (see + * xdg_surface description). + * + * Attaching a null buffer to a toplevel unmaps the surface. + * @section page_iface_xdg_toplevel_api API + * See @ref iface_xdg_toplevel. + */ +/** + * @defgroup iface_xdg_toplevel The xdg_toplevel interface + * + * This interface defines an xdg_surface role which allows a surface to, + * among other things, set window-like properties such as maximize, + * fullscreen, and minimize, set application-specific metadata like title and + * id, and well as trigger user interactive operations such as interactive + * resize and move. + * + * An xdg_toplevel by default is responsible for providing the full intended + * visual representation of the toplevel, which depending on the window + * state, may mean things like a title bar, window controls and drop shadow. + * + * Unmapping an xdg_toplevel means that the surface cannot be shown + * by the compositor until it is explicitly mapped again. + * All active operations (e.g., move, resize) are canceled and all + * attributes (e.g. title, state, stacking, ...) are discarded for + * an xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to + * the state it had right after xdg_surface.get_toplevel. The client + * can re-map the toplevel by performing a commit without any buffer + * attached, waiting for a configure event and handling it as usual (see + * xdg_surface description). + * + * Attaching a null buffer to a toplevel unmaps the surface. + */ +extern const struct wl_interface xdg_toplevel_interface; +#endif +#ifndef XDG_POPUP_INTERFACE +#define XDG_POPUP_INTERFACE +/** + * @page page_iface_xdg_popup xdg_popup + * @section page_iface_xdg_popup_desc Description + * + * A popup surface is a short-lived, temporary surface. It can be used to + * implement for example menus, popovers, tooltips and other similar user + * interface concepts. + * + * A popup can be made to take an explicit grab. See xdg_popup.grab for + * details. + * + * When the popup is dismissed, a popup_done event will be sent out, and at + * the same time the surface will be unmapped. See the xdg_popup.popup_done + * event for details. + * + * Explicitly destroying the xdg_popup object will also dismiss the popup and + * unmap the surface. Clients that want to dismiss the popup when another + * surface of their own is clicked should dismiss the popup using the destroy + * request. + * + * A newly created xdg_popup will be stacked on top of all previously created + * xdg_popup surfaces associated with the same xdg_toplevel. + * + * The parent of an xdg_popup must be mapped (see the xdg_surface + * description) before the xdg_popup itself. + * + * The client must call wl_surface.commit on the corresponding wl_surface + * for the xdg_popup state to take effect. + * @section page_iface_xdg_popup_api API + * See @ref iface_xdg_popup. + */ +/** + * @defgroup iface_xdg_popup The xdg_popup interface + * + * A popup surface is a short-lived, temporary surface. It can be used to + * implement for example menus, popovers, tooltips and other similar user + * interface concepts. + * + * A popup can be made to take an explicit grab. See xdg_popup.grab for + * details. + * + * When the popup is dismissed, a popup_done event will be sent out, and at + * the same time the surface will be unmapped. See the xdg_popup.popup_done + * event for details. + * + * Explicitly destroying the xdg_popup object will also dismiss the popup and + * unmap the surface. Clients that want to dismiss the popup when another + * surface of their own is clicked should dismiss the popup using the destroy + * request. + * + * A newly created xdg_popup will be stacked on top of all previously created + * xdg_popup surfaces associated with the same xdg_toplevel. + * + * The parent of an xdg_popup must be mapped (see the xdg_surface + * description) before the xdg_popup itself. + * + * The client must call wl_surface.commit on the corresponding wl_surface + * for the xdg_popup state to take effect. + */ +extern const struct wl_interface xdg_popup_interface; +#endif + +#ifndef XDG_WM_BASE_ERROR_ENUM +#define XDG_WM_BASE_ERROR_ENUM +enum xdg_wm_base_error { + /** + * given wl_surface has another role + */ + XDG_WM_BASE_ERROR_ROLE = 0, + /** + * xdg_wm_base was destroyed before children + */ + XDG_WM_BASE_ERROR_DEFUNCT_SURFACES = 1, + /** + * the client tried to map or destroy a non-topmost popup + */ + XDG_WM_BASE_ERROR_NOT_THE_TOPMOST_POPUP = 2, + /** + * the client specified an invalid popup parent surface + */ + XDG_WM_BASE_ERROR_INVALID_POPUP_PARENT = 3, + /** + * the client provided an invalid surface state + */ + XDG_WM_BASE_ERROR_INVALID_SURFACE_STATE = 4, + /** + * the client provided an invalid positioner + */ + XDG_WM_BASE_ERROR_INVALID_POSITIONER = 5, + /** + * the client didn’t respond to a ping event in time + */ + XDG_WM_BASE_ERROR_UNRESPONSIVE = 6, +}; +#endif /* XDG_WM_BASE_ERROR_ENUM */ + +/** + * @ingroup iface_xdg_wm_base + * @struct xdg_wm_base_listener + */ +struct xdg_wm_base_listener { + /** + * check if the client is alive + * + * The ping event asks the client if it's still alive. Pass the + * serial specified in the event back to the compositor by sending + * a "pong" request back with the specified serial. See + * xdg_wm_base.pong. + * + * Compositors can use this to determine if the client is still + * alive. It's unspecified what will happen if the client doesn't + * respond to the ping request, or in what timeframe. Clients + * should try to respond in a reasonable amount of time. The + * “unresponsive” error is provided for compositors that wish + * to disconnect unresponsive clients. + * + * A compositor is free to ping in any way it wants, but a client + * must always respond to any xdg_wm_base object it created. + * @param serial pass this to the pong request + */ + void (*ping)(void *data, + struct xdg_wm_base *xdg_wm_base, + uint32_t serial); +}; + +/** + * @ingroup iface_xdg_wm_base + */ +static inline int +xdg_wm_base_add_listener(struct xdg_wm_base *xdg_wm_base, + const struct xdg_wm_base_listener *listener, void *data) +{ + return wl_proxy_add_listener((struct wl_proxy *) xdg_wm_base, + (void (**)(void)) listener, data); +} + +#define XDG_WM_BASE_DESTROY 0 +#define XDG_WM_BASE_CREATE_POSITIONER 1 +#define XDG_WM_BASE_GET_XDG_SURFACE 2 +#define XDG_WM_BASE_PONG 3 + +/** + * @ingroup iface_xdg_wm_base + */ +#define XDG_WM_BASE_PING_SINCE_VERSION 1 + +/** + * @ingroup iface_xdg_wm_base + */ +#define XDG_WM_BASE_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_wm_base + */ +#define XDG_WM_BASE_CREATE_POSITIONER_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_wm_base + */ +#define XDG_WM_BASE_GET_XDG_SURFACE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_wm_base + */ +#define XDG_WM_BASE_PONG_SINCE_VERSION 1 + +/** @ingroup iface_xdg_wm_base */ +static inline void +xdg_wm_base_set_user_data(struct xdg_wm_base *xdg_wm_base, void *user_data) +{ + wl_proxy_set_user_data((struct wl_proxy *) xdg_wm_base, user_data); +} + +/** @ingroup iface_xdg_wm_base */ +static inline void * +xdg_wm_base_get_user_data(struct xdg_wm_base *xdg_wm_base) +{ + return wl_proxy_get_user_data((struct wl_proxy *) xdg_wm_base); +} + +static inline uint32_t +xdg_wm_base_get_version(struct xdg_wm_base *xdg_wm_base) +{ + return wl_proxy_get_version((struct wl_proxy *) xdg_wm_base); +} + +/** + * @ingroup iface_xdg_wm_base + * + * Destroy this xdg_wm_base object. + * + * Destroying a bound xdg_wm_base object while there are surfaces + * still alive created by this xdg_wm_base object instance is illegal + * and will result in a defunct_surfaces error. + */ +static inline void +xdg_wm_base_destroy(struct xdg_wm_base *xdg_wm_base) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base, + XDG_WM_BASE_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), WL_MARSHAL_FLAG_DESTROY); +} + +/** + * @ingroup iface_xdg_wm_base + * + * Create a positioner object. A positioner object is used to position + * surfaces relative to some parent surface. See the interface description + * and xdg_surface.get_popup for details. + */ +static inline struct xdg_positioner * +xdg_wm_base_create_positioner(struct xdg_wm_base *xdg_wm_base) +{ + struct wl_proxy *id; + + id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base, + XDG_WM_BASE_CREATE_POSITIONER, &xdg_positioner_interface, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), 0, NULL); + + return (struct xdg_positioner *) id; +} + +/** + * @ingroup iface_xdg_wm_base + * + * This creates an xdg_surface for the given surface. An xdg_surface is + * used as basis to define a role to a given surface, such as xdg_toplevel + * or xdg_popup. It also manages functionality shared between xdg_surface + * based surface roles. + * + * While xdg_surface itself is not a role, the corresponding surface may + * only be assigned a role extending xdg_surface, such as xdg_toplevel or + * xdg_popup. It is illegal to create an xdg_surface for a wl_surface which + * already has anassigned role and this will result in a role error. + * + * See the documentation of xdg_surface for more details about what an + * xdg_surface is and how it is used. + */ +static inline struct xdg_surface * +xdg_wm_base_get_xdg_surface(struct xdg_wm_base *xdg_wm_base, struct wl_surface *surface) +{ + struct wl_proxy *id; + + id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base, + XDG_WM_BASE_GET_XDG_SURFACE, &xdg_surface_interface, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), 0, NULL, surface); + + return (struct xdg_surface *) id; +} + +/** + * @ingroup iface_xdg_wm_base + * + * A client must respond to a ping event with a pong request or + * the client may be deemed unresponsive. See xdg_wm_base.ping + * and xdg_wm_base.error.unresponsive. + */ +static inline void +xdg_wm_base_pong(struct xdg_wm_base *xdg_wm_base, uint32_t serial) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base, + XDG_WM_BASE_PONG, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), 0, serial); +} + +#ifndef XDG_POSITIONER_ERROR_ENUM +#define XDG_POSITIONER_ERROR_ENUM +enum xdg_positioner_error { + /** + * invalid input provided + */ + XDG_POSITIONER_ERROR_INVALID_INPUT = 0, +}; +#endif /* XDG_POSITIONER_ERROR_ENUM */ + +#ifndef XDG_POSITIONER_ANCHOR_ENUM +#define XDG_POSITIONER_ANCHOR_ENUM +enum xdg_positioner_anchor { + XDG_POSITIONER_ANCHOR_NONE = 0, + XDG_POSITIONER_ANCHOR_TOP = 1, + XDG_POSITIONER_ANCHOR_BOTTOM = 2, + XDG_POSITIONER_ANCHOR_LEFT = 3, + XDG_POSITIONER_ANCHOR_RIGHT = 4, + XDG_POSITIONER_ANCHOR_TOP_LEFT = 5, + XDG_POSITIONER_ANCHOR_BOTTOM_LEFT = 6, + XDG_POSITIONER_ANCHOR_TOP_RIGHT = 7, + XDG_POSITIONER_ANCHOR_BOTTOM_RIGHT = 8, +}; +#endif /* XDG_POSITIONER_ANCHOR_ENUM */ + +#ifndef XDG_POSITIONER_GRAVITY_ENUM +#define XDG_POSITIONER_GRAVITY_ENUM +enum xdg_positioner_gravity { + XDG_POSITIONER_GRAVITY_NONE = 0, + XDG_POSITIONER_GRAVITY_TOP = 1, + XDG_POSITIONER_GRAVITY_BOTTOM = 2, + XDG_POSITIONER_GRAVITY_LEFT = 3, + XDG_POSITIONER_GRAVITY_RIGHT = 4, + XDG_POSITIONER_GRAVITY_TOP_LEFT = 5, + XDG_POSITIONER_GRAVITY_BOTTOM_LEFT = 6, + XDG_POSITIONER_GRAVITY_TOP_RIGHT = 7, + XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT = 8, +}; +#endif /* XDG_POSITIONER_GRAVITY_ENUM */ + +#ifndef XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM +#define XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM +/** + * @ingroup iface_xdg_positioner + * constraint adjustments + * + * The constraint adjustment value define ways the compositor will adjust + * the position of the surface, if the unadjusted position would result + * in the surface being partly constrained. + * + * Whether a surface is considered 'constrained' is left to the compositor + * to determine. For example, the surface may be partly outside the + * compositor's defined 'work area', thus necessitating the child surface's + * position be adjusted until it is entirely inside the work area. + * + * The adjustments can be combined, according to a defined precedence: 1) + * Flip, 2) Slide, 3) Resize. + */ +enum xdg_positioner_constraint_adjustment { + /** + * don't move the child surface when constrained + * + * Don't alter the surface position even if it is constrained on + * some axis, for example partially outside the edge of an output. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_NONE = 0, + /** + * move along the x axis until unconstrained + * + * Slide the surface along the x axis until it is no longer + * constrained. + * + * First try to slide towards the direction of the gravity on the x + * axis until either the edge in the opposite direction of the + * gravity is unconstrained or the edge in the direction of the + * gravity is constrained. + * + * Then try to slide towards the opposite direction of the gravity + * on the x axis until either the edge in the direction of the + * gravity is unconstrained or the edge in the opposite direction + * of the gravity is constrained. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X = 1, + /** + * move along the y axis until unconstrained + * + * Slide the surface along the y axis until it is no longer + * constrained. + * + * First try to slide towards the direction of the gravity on the y + * axis until either the edge in the opposite direction of the + * gravity is unconstrained or the edge in the direction of the + * gravity is constrained. + * + * Then try to slide towards the opposite direction of the gravity + * on the y axis until either the edge in the direction of the + * gravity is unconstrained or the edge in the opposite direction + * of the gravity is constrained. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y = 2, + /** + * invert the anchor and gravity on the x axis + * + * Invert the anchor and gravity on the x axis if the surface is + * constrained on the x axis. For example, if the left edge of the + * surface is constrained, the gravity is 'left' and the anchor is + * 'left', change the gravity to 'right' and the anchor to 'right'. + * + * If the adjusted position also ends up being constrained, the + * resulting position of the flip_x adjustment will be the one + * before the adjustment. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X = 4, + /** + * invert the anchor and gravity on the y axis + * + * Invert the anchor and gravity on the y axis if the surface is + * constrained on the y axis. For example, if the bottom edge of + * the surface is constrained, the gravity is 'bottom' and the + * anchor is 'bottom', change the gravity to 'top' and the anchor + * to 'top'. + * + * The adjusted position is calculated given the original anchor + * rectangle and offset, but with the new flipped anchor and + * gravity values. + * + * If the adjusted position also ends up being constrained, the + * resulting position of the flip_y adjustment will be the one + * before the adjustment. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y = 8, + /** + * horizontally resize the surface + * + * Resize the surface horizontally so that it is completely + * unconstrained. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X = 16, + /** + * vertically resize the surface + * + * Resize the surface vertically so that it is completely + * unconstrained. + */ + XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y = 32, +}; +#endif /* XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM */ + +#define XDG_POSITIONER_DESTROY 0 +#define XDG_POSITIONER_SET_SIZE 1 +#define XDG_POSITIONER_SET_ANCHOR_RECT 2 +#define XDG_POSITIONER_SET_ANCHOR 3 +#define XDG_POSITIONER_SET_GRAVITY 4 +#define XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT 5 +#define XDG_POSITIONER_SET_OFFSET 6 +#define XDG_POSITIONER_SET_REACTIVE 7 +#define XDG_POSITIONER_SET_PARENT_SIZE 8 +#define XDG_POSITIONER_SET_PARENT_CONFIGURE 9 + + +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_SIZE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_ANCHOR_RECT_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_ANCHOR_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_GRAVITY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_OFFSET_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_REACTIVE_SINCE_VERSION 3 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_PARENT_SIZE_SINCE_VERSION 3 +/** + * @ingroup iface_xdg_positioner + */ +#define XDG_POSITIONER_SET_PARENT_CONFIGURE_SINCE_VERSION 3 + +/** @ingroup iface_xdg_positioner */ +static inline void +xdg_positioner_set_user_data(struct xdg_positioner *xdg_positioner, void *user_data) +{ + wl_proxy_set_user_data((struct wl_proxy *) xdg_positioner, user_data); +} + +/** @ingroup iface_xdg_positioner */ +static inline void * +xdg_positioner_get_user_data(struct xdg_positioner *xdg_positioner) +{ + return wl_proxy_get_user_data((struct wl_proxy *) xdg_positioner); +} + +static inline uint32_t +xdg_positioner_get_version(struct xdg_positioner *xdg_positioner) +{ + return wl_proxy_get_version((struct wl_proxy *) xdg_positioner); +} + +/** + * @ingroup iface_xdg_positioner + * + * Notify the compositor that the xdg_positioner will no longer be used. + */ +static inline void +xdg_positioner_destroy(struct xdg_positioner *xdg_positioner) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner, + XDG_POSITIONER_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), WL_MARSHAL_FLAG_DESTROY); +} + +/** + * @ingroup iface_xdg_positioner + * + * Set the size of the surface that is to be positioned with the positioner + * object. The size is in surface-local coordinates and corresponds to the + * window geometry. See xdg_surface.set_window_geometry. + * + * If a zero or negative size is set the invalid_input error is raised. + */ +static inline void +xdg_positioner_set_size(struct xdg_positioner *xdg_positioner, int32_t width, int32_t height) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner, + XDG_POSITIONER_SET_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, width, height); +} + +/** + * @ingroup iface_xdg_positioner + * + * Specify the anchor rectangle within the parent surface that the child + * surface will be placed relative to. The rectangle is relative to the + * window geometry as defined by xdg_surface.set_window_geometry of the + * parent surface. + * + * When the xdg_positioner object is used to position a child surface, the + * anchor rectangle may not extend outside the window geometry of the + * positioned child's parent surface. + * + * If a negative size is set the invalid_input error is raised. + */ +static inline void +xdg_positioner_set_anchor_rect(struct xdg_positioner *xdg_positioner, int32_t x, int32_t y, int32_t width, int32_t height) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner, + XDG_POSITIONER_SET_ANCHOR_RECT, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, x, y, width, height); +} + +/** + * @ingroup iface_xdg_positioner + * + * Defines the anchor point for the anchor rectangle. The specified anchor + * is used to derive an anchor point that the child surface will be + * positioned relative to. If a corner anchor is set (e.g. 'top_left' or + * 'bottom_right'), the anchor point will be at the specified corner; + * otherwise, the derived anchor point will be centered on the specified + * edge, or in the center of the anchor rectangle if no edge is specified. + */ +static inline void +xdg_positioner_set_anchor(struct xdg_positioner *xdg_positioner, uint32_t anchor) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner, + XDG_POSITIONER_SET_ANCHOR, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, anchor); +} + +/** + * @ingroup iface_xdg_positioner + * + * Defines in what direction a surface should be positioned, relative to + * the anchor point of the parent surface. If a corner gravity is + * specified (e.g. 'bottom_right' or 'top_left'), then the child surface + * will be placed towards the specified gravity; otherwise, the child + * surface will be centered over the anchor point on any axis that had no + * gravity specified. If the gravity is not in the ‘gravity’ enum, an + * invalid_input error is raised. + */ +static inline void +xdg_positioner_set_gravity(struct xdg_positioner *xdg_positioner, uint32_t gravity) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner, + XDG_POSITIONER_SET_GRAVITY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, gravity); +} + +/** + * @ingroup iface_xdg_positioner + * + * Specify how the window should be positioned if the originally intended + * position caused the surface to be constrained, meaning at least + * partially outside positioning boundaries set by the compositor. The + * adjustment is set by constructing a bitmask describing the adjustment to + * be made when the surface is constrained on that axis. + * + * If no bit for one axis is set, the compositor will assume that the child + * surface should not change its position on that axis when constrained. + * + * If more than one bit for one axis is set, the order of how adjustments + * are applied is specified in the corresponding adjustment descriptions. + * + * The default adjustment is none. + */ +static inline void +xdg_positioner_set_constraint_adjustment(struct xdg_positioner *xdg_positioner, uint32_t constraint_adjustment) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner, + XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, constraint_adjustment); +} + +/** + * @ingroup iface_xdg_positioner + * + * Specify the surface position offset relative to the position of the + * anchor on the anchor rectangle and the anchor on the surface. For + * example if the anchor of the anchor rectangle is at (x, y), the surface + * has the gravity bottom|right, and the offset is (ox, oy), the calculated + * surface position will be (x + ox, y + oy). The offset position of the + * surface is the one used for constraint testing. See + * set_constraint_adjustment. + * + * An example use case is placing a popup menu on top of a user interface + * element, while aligning the user interface element of the parent surface + * with some user interface element placed somewhere in the popup surface. + */ +static inline void +xdg_positioner_set_offset(struct xdg_positioner *xdg_positioner, int32_t x, int32_t y) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner, + XDG_POSITIONER_SET_OFFSET, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, x, y); +} + +/** + * @ingroup iface_xdg_positioner + * + * When set reactive, the surface is reconstrained if the conditions used + * for constraining changed, e.g. the parent window moved. + * + * If the conditions changed and the popup was reconstrained, an + * xdg_popup.configure event is sent with updated geometry, followed by an + * xdg_surface.configure event. + */ +static inline void +xdg_positioner_set_reactive(struct xdg_positioner *xdg_positioner) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner, + XDG_POSITIONER_SET_REACTIVE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0); +} + +/** + * @ingroup iface_xdg_positioner + * + * Set the parent window geometry the compositor should use when + * positioning the popup. The compositor may use this information to + * determine the future state the popup should be constrained using. If + * this doesn't match the dimension of the parent the popup is eventually + * positioned against, the behavior is undefined. + * + * The arguments are given in the surface-local coordinate space. + */ +static inline void +xdg_positioner_set_parent_size(struct xdg_positioner *xdg_positioner, int32_t parent_width, int32_t parent_height) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner, + XDG_POSITIONER_SET_PARENT_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, parent_width, parent_height); +} + +/** + * @ingroup iface_xdg_positioner + * + * Set the serial of an xdg_surface.configure event this positioner will be + * used in response to. The compositor may use this information together + * with set_parent_size to determine what future state the popup should be + * constrained using. + */ +static inline void +xdg_positioner_set_parent_configure(struct xdg_positioner *xdg_positioner, uint32_t serial) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner, + XDG_POSITIONER_SET_PARENT_CONFIGURE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, serial); +} + +#ifndef XDG_SURFACE_ERROR_ENUM +#define XDG_SURFACE_ERROR_ENUM +enum xdg_surface_error { + /** + * Surface was not fully constructed + */ + XDG_SURFACE_ERROR_NOT_CONSTRUCTED = 1, + /** + * Surface was already constructed + */ + XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED = 2, + /** + * Attaching a buffer to an unconfigured surface + */ + XDG_SURFACE_ERROR_UNCONFIGURED_BUFFER = 3, + /** + * Invalid serial number when acking a configure event + */ + XDG_SURFACE_ERROR_INVALID_SERIAL = 4, + /** + * Width or height was zero or negative + */ + XDG_SURFACE_ERROR_INVALID_SIZE = 5, + /** + * Surface was destroyed before its role object + */ + XDG_SURFACE_ERROR_DEFUNCT_ROLE_OBJECT = 6, +}; +#endif /* XDG_SURFACE_ERROR_ENUM */ + +/** + * @ingroup iface_xdg_surface + * @struct xdg_surface_listener + */ +struct xdg_surface_listener { + /** + * suggest a surface change + * + * The configure event marks the end of a configure sequence. A + * configure sequence is a set of one or more events configuring + * the state of the xdg_surface, including the final + * xdg_surface.configure event. + * + * Where applicable, xdg_surface surface roles will during a + * configure sequence extend this event as a latched state sent as + * events before the xdg_surface.configure event. Such events + * should be considered to make up a set of atomically applied + * configuration states, where the xdg_surface.configure commits + * the accumulated state. + * + * Clients should arrange their surface for the new states, and + * then send an ack_configure request with the serial sent in this + * configure event at some point before committing the new surface. + * + * If the client receives multiple configure events before it can + * respond to one, it is free to discard all but the last event it + * received. + * @param serial serial of the configure event + */ + void (*configure)(void *data, + struct xdg_surface *xdg_surface, + uint32_t serial); +}; + +/** + * @ingroup iface_xdg_surface + */ +static inline int +xdg_surface_add_listener(struct xdg_surface *xdg_surface, + const struct xdg_surface_listener *listener, void *data) +{ + return wl_proxy_add_listener((struct wl_proxy *) xdg_surface, + (void (**)(void)) listener, data); +} + +#define XDG_SURFACE_DESTROY 0 +#define XDG_SURFACE_GET_TOPLEVEL 1 +#define XDG_SURFACE_GET_POPUP 2 +#define XDG_SURFACE_SET_WINDOW_GEOMETRY 3 +#define XDG_SURFACE_ACK_CONFIGURE 4 + +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_CONFIGURE_SINCE_VERSION 1 + +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_GET_TOPLEVEL_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_GET_POPUP_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_SET_WINDOW_GEOMETRY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_surface + */ +#define XDG_SURFACE_ACK_CONFIGURE_SINCE_VERSION 1 + +/** @ingroup iface_xdg_surface */ +static inline void +xdg_surface_set_user_data(struct xdg_surface *xdg_surface, void *user_data) +{ + wl_proxy_set_user_data((struct wl_proxy *) xdg_surface, user_data); +} + +/** @ingroup iface_xdg_surface */ +static inline void * +xdg_surface_get_user_data(struct xdg_surface *xdg_surface) +{ + return wl_proxy_get_user_data((struct wl_proxy *) xdg_surface); +} + +static inline uint32_t +xdg_surface_get_version(struct xdg_surface *xdg_surface) +{ + return wl_proxy_get_version((struct wl_proxy *) xdg_surface); +} + +/** + * @ingroup iface_xdg_surface + * + * Destroy the xdg_surface object. An xdg_surface must only be destroyed + * after its role object has been destroyed, otherwise + * a defunct_role_object error is raised. + */ +static inline void +xdg_surface_destroy(struct xdg_surface *xdg_surface) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface, + XDG_SURFACE_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_surface), WL_MARSHAL_FLAG_DESTROY); +} + +/** + * @ingroup iface_xdg_surface + * + * This creates an xdg_toplevel object for the given xdg_surface and gives + * the associated wl_surface the xdg_toplevel role. + * + * See the documentation of xdg_toplevel for more details about what an + * xdg_toplevel is and how it is used. + */ +static inline struct xdg_toplevel * +xdg_surface_get_toplevel(struct xdg_surface *xdg_surface) +{ + struct wl_proxy *id; + + id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface, + XDG_SURFACE_GET_TOPLEVEL, &xdg_toplevel_interface, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, NULL); + + return (struct xdg_toplevel *) id; +} + +/** + * @ingroup iface_xdg_surface + * + * This creates an xdg_popup object for the given xdg_surface and gives + * the associated wl_surface the xdg_popup role. + * + * If null is passed as a parent, a parent surface must be specified using + * some other protocol, before committing the initial state. + * + * See the documentation of xdg_popup for more details about what an + * xdg_popup is and how it is used. + */ +static inline struct xdg_popup * +xdg_surface_get_popup(struct xdg_surface *xdg_surface, struct xdg_surface *parent, struct xdg_positioner *positioner) +{ + struct wl_proxy *id; + + id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface, + XDG_SURFACE_GET_POPUP, &xdg_popup_interface, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, NULL, parent, positioner); + + return (struct xdg_popup *) id; +} + +/** + * @ingroup iface_xdg_surface + * + * The window geometry of a surface is its "visible bounds" from the + * user's perspective. Client-side decorations often have invisible + * portions like drop-shadows which should be ignored for the + * purposes of aligning, placing and constraining windows. Note that + * in some situations, compositors may clip rendering to the window + * geometry, so the client should avoid putting functional elements + * outside of it. + * + * The window geometry is double-buffered state, see wl_surface.commit. + * + * When maintaining a position, the compositor should treat the (x, y) + * coordinate of the window geometry as the top left corner of the window. + * A client changing the (x, y) window geometry coordinate should in + * general not alter the position of the window. + * + * Once the window geometry of the surface is set, it is not possible to + * unset it, and it will remain the same until set_window_geometry is + * called again, even if a new subsurface or buffer is attached. + * + * If never set, the value is the full bounds of the surface, + * including any subsurfaces. This updates dynamically on every + * commit. This unset is meant for extremely simple clients. + * + * The arguments are given in the surface-local coordinate space of + * the wl_surface associated with this xdg_surface, and may extend outside + * of the wl_surface itself to mark parts of the subsurface tree as part of + * the window geometry. + * + * When applied, the effective window geometry will be the set window + * geometry clamped to the bounding rectangle of the combined + * geometry of the surface of the xdg_surface and the associated + * subsurfaces. + * + * The effective geometry will not be recalculated unless a new call to + * set_window_geometry is done and the new pending surface state is + * subsequently applied. + * + * The width and height of the effective window geometry must be + * greater than zero. Setting an invalid size will raise an + * invalid_size error. + */ +static inline void +xdg_surface_set_window_geometry(struct xdg_surface *xdg_surface, int32_t x, int32_t y, int32_t width, int32_t height) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface, + XDG_SURFACE_SET_WINDOW_GEOMETRY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, x, y, width, height); +} + +/** + * @ingroup iface_xdg_surface + * + * When a configure event is received, if a client commits the + * surface in response to the configure event, then the client + * must make an ack_configure request sometime before the commit + * request, passing along the serial of the configure event. + * + * For instance, for toplevel surfaces the compositor might use this + * information to move a surface to the top left only when the client has + * drawn itself for the maximized or fullscreen state. + * + * If the client receives multiple configure events before it + * can respond to one, it only has to ack the last configure event. + * Acking a configure event that was never sent raises an invalid_serial + * error. + * + * A client is not required to commit immediately after sending + * an ack_configure request - it may even ack_configure several times + * before its next surface commit. + * + * A client may send multiple ack_configure requests before committing, but + * only the last request sent before a commit indicates which configure + * event the client really is responding to. + * + * Sending an ack_configure request consumes the serial number sent with + * the request, as well as serial numbers sent by all configure events + * sent on this xdg_surface prior to the configure event referenced by + * the committed serial. + * + * It is an error to issue multiple ack_configure requests referencing a + * serial from the same configure event, or to issue an ack_configure + * request referencing a serial from a configure event issued before the + * event identified by the last ack_configure request for the same + * xdg_surface. Doing so will raise an invalid_serial error. + */ +static inline void +xdg_surface_ack_configure(struct xdg_surface *xdg_surface, uint32_t serial) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface, + XDG_SURFACE_ACK_CONFIGURE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, serial); +} + +#ifndef XDG_TOPLEVEL_ERROR_ENUM +#define XDG_TOPLEVEL_ERROR_ENUM +enum xdg_toplevel_error { + /** + * provided value is not a valid variant of the resize_edge enum + */ + XDG_TOPLEVEL_ERROR_INVALID_RESIZE_EDGE = 0, + /** + * invalid parent toplevel + */ + XDG_TOPLEVEL_ERROR_INVALID_PARENT = 1, + /** + * client provided an invalid min or max size + */ + XDG_TOPLEVEL_ERROR_INVALID_SIZE = 2, +}; +#endif /* XDG_TOPLEVEL_ERROR_ENUM */ + +#ifndef XDG_TOPLEVEL_RESIZE_EDGE_ENUM +#define XDG_TOPLEVEL_RESIZE_EDGE_ENUM +/** + * @ingroup iface_xdg_toplevel + * edge values for resizing + * + * These values are used to indicate which edge of a surface + * is being dragged in a resize operation. + */ +enum xdg_toplevel_resize_edge { + XDG_TOPLEVEL_RESIZE_EDGE_NONE = 0, + XDG_TOPLEVEL_RESIZE_EDGE_TOP = 1, + XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM = 2, + XDG_TOPLEVEL_RESIZE_EDGE_LEFT = 4, + XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT = 5, + XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT = 6, + XDG_TOPLEVEL_RESIZE_EDGE_RIGHT = 8, + XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT = 9, + XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT = 10, +}; +#endif /* XDG_TOPLEVEL_RESIZE_EDGE_ENUM */ + +#ifndef XDG_TOPLEVEL_STATE_ENUM +#define XDG_TOPLEVEL_STATE_ENUM +/** + * @ingroup iface_xdg_toplevel + * types of state on the surface + * + * The different state values used on the surface. This is designed for + * state values like maximized, fullscreen. It is paired with the + * configure event to ensure that both the client and the compositor + * setting the state can be synchronized. + * + * States set in this way are double-buffered, see wl_surface.commit. + */ +enum xdg_toplevel_state { + /** + * the surface is maximized + * the surface is maximized + * + * The surface is maximized. The window geometry specified in the + * configure event must be obeyed by the client, or the + * xdg_wm_base.invalid_surface_state error is raised. + * + * The client should draw without shadow or other decoration + * outside of the window geometry. + */ + XDG_TOPLEVEL_STATE_MAXIMIZED = 1, + /** + * the surface is fullscreen + * the surface is fullscreen + * + * The surface is fullscreen. The window geometry specified in + * the configure event is a maximum; the client cannot resize + * beyond it. For a surface to cover the whole fullscreened area, + * the geometry dimensions must be obeyed by the client. For more + * details, see xdg_toplevel.set_fullscreen. + */ + XDG_TOPLEVEL_STATE_FULLSCREEN = 2, + /** + * the surface is being resized + * the surface is being resized + * + * The surface is being resized. The window geometry specified in + * the configure event is a maximum; the client cannot resize + * beyond it. Clients that have aspect ratio or cell sizing + * configuration can use a smaller size, however. + */ + XDG_TOPLEVEL_STATE_RESIZING = 3, + /** + * the surface is now activated + * the surface is now activated + * + * Client window decorations should be painted as if the window + * is active. Do not assume this means that the window actually has + * keyboard or pointer focus. + */ + XDG_TOPLEVEL_STATE_ACTIVATED = 4, + /** + * the surface’s left edge is tiled + * + * The window is currently in a tiled layout and the left edge is + * considered to be adjacent to another part of the tiling grid. + * + * The client should draw without shadow or other decoration + * outside of the window geometry on the left edge. + * @since 2 + */ + XDG_TOPLEVEL_STATE_TILED_LEFT = 5, + /** + * the surface’s right edge is tiled + * + * The window is currently in a tiled layout and the right edge + * is considered to be adjacent to another part of the tiling grid. + * + * The client should draw without shadow or other decoration + * outside of the window geometry on the right edge. + * @since 2 + */ + XDG_TOPLEVEL_STATE_TILED_RIGHT = 6, + /** + * the surface’s top edge is tiled + * + * The window is currently in a tiled layout and the top edge is + * considered to be adjacent to another part of the tiling grid. + * + * The client should draw without shadow or other decoration + * outside of the window geometry on the top edge. + * @since 2 + */ + XDG_TOPLEVEL_STATE_TILED_TOP = 7, + /** + * the surface’s bottom edge is tiled + * + * The window is currently in a tiled layout and the bottom edge + * is considered to be adjacent to another part of the tiling grid. + * + * The client should draw without shadow or other decoration + * outside of the window geometry on the bottom edge. + * @since 2 + */ + XDG_TOPLEVEL_STATE_TILED_BOTTOM = 8, + /** + * surface repaint is suspended + * + * The surface is currently not ordinarily being repainted; for + * example because its content is occluded by another window, or + * its outputs are switched off due to screen locking. + * @since 6 + */ + XDG_TOPLEVEL_STATE_SUSPENDED = 9, + /** + * the surface’s left edge is constrained + * + * The left edge of the window is currently constrained, meaning + * it shouldn't attempt to resize from that edge. It can for + * example mean it's tiled next to a monitor edge on the + * constrained side of the window. + * @since 7 + */ + XDG_TOPLEVEL_STATE_CONSTRAINED_LEFT = 10, + /** + * the surface’s right edge is constrained + * + * The right edge of the window is currently constrained, meaning + * it shouldn't attempt to resize from that edge. It can for + * example mean it's tiled next to a monitor edge on the + * constrained side of the window. + * @since 7 + */ + XDG_TOPLEVEL_STATE_CONSTRAINED_RIGHT = 11, + /** + * the surface’s top edge is constrained + * + * The top edge of the window is currently constrained, meaning + * it shouldn't attempt to resize from that edge. It can for + * example mean it's tiled next to a monitor edge on the + * constrained side of the window. + * @since 7 + */ + XDG_TOPLEVEL_STATE_CONSTRAINED_TOP = 12, + /** + * the surface’s bottom edge is constrained + * + * The bottom edge of the window is currently constrained, + * meaning it shouldn't attempt to resize from that edge. It can + * for example mean it's tiled next to a monitor edge on the + * constrained side of the window. + * @since 7 + */ + XDG_TOPLEVEL_STATE_CONSTRAINED_BOTTOM = 13, +}; +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_TILED_LEFT_SINCE_VERSION 2 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION 2 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_TILED_TOP_SINCE_VERSION 2 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_TILED_BOTTOM_SINCE_VERSION 2 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_SUSPENDED_SINCE_VERSION 6 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_CONSTRAINED_LEFT_SINCE_VERSION 7 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_CONSTRAINED_RIGHT_SINCE_VERSION 7 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_CONSTRAINED_TOP_SINCE_VERSION 7 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_STATE_CONSTRAINED_BOTTOM_SINCE_VERSION 7 +#endif /* XDG_TOPLEVEL_STATE_ENUM */ + +#ifndef XDG_TOPLEVEL_WM_CAPABILITIES_ENUM +#define XDG_TOPLEVEL_WM_CAPABILITIES_ENUM +enum xdg_toplevel_wm_capabilities { + /** + * show_window_menu is available + */ + XDG_TOPLEVEL_WM_CAPABILITIES_WINDOW_MENU = 1, + /** + * set_maximized and unset_maximized are available + */ + XDG_TOPLEVEL_WM_CAPABILITIES_MAXIMIZE = 2, + /** + * set_fullscreen and unset_fullscreen are available + */ + XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN = 3, + /** + * set_minimized is available + */ + XDG_TOPLEVEL_WM_CAPABILITIES_MINIMIZE = 4, +}; +#endif /* XDG_TOPLEVEL_WM_CAPABILITIES_ENUM */ + +/** + * @ingroup iface_xdg_toplevel + * @struct xdg_toplevel_listener + */ +struct xdg_toplevel_listener { + /** + * suggest a surface change + * + * This configure event asks the client to resize its toplevel + * surface or to change its state. The configured state should not + * be applied immediately. See xdg_surface.configure for details. + * + * The width and height arguments specify a hint to the window + * about how its surface should be resized in window geometry + * coordinates. See set_window_geometry. + * + * If the width or height arguments are zero, it means the client + * should decide its own window dimension. This may happen when the + * compositor needs to configure the state of the surface but + * doesn't have any information about any previous or expected + * dimension. + * + * The states listed in the event specify how the width/height + * arguments should be interpreted, and possibly how it should be + * drawn. + * + * The states are sent as an array of 32-bit unsigned integers in + * native endianness. State values are defined in the state enum. + * + * Clients must send an ack_configure in response to this event. + * See xdg_surface.configure and xdg_surface.ack_configure for + * details. + * @param width suggested width of window + * @param height suggested height of window + * @param states suggested states of the window + */ + void (*configure)(void *data, + struct xdg_toplevel *xdg_toplevel, + int32_t width, + int32_t height, + struct wl_array *states); + /** + * surface wants to be closed + * + * The close event is sent by the compositor when the user wants + * the surface to be closed. This should be equivalent to the user + * clicking the close button in client-side decorations, if your + * application has any. + * + * This is only a request that the user intends to close the + * window. The client may choose to ignore this request, or show a + * dialog to ask the user to save their data, etc. + */ + void (*close)(void *data, + struct xdg_toplevel *xdg_toplevel); + /** + * recommended window geometry bounds + * + * The configure_bounds event may be sent prior to a + * xdg_toplevel.configure event to communicate the bounds a window + * geometry size is recommended to constrain to. + * + * The passed width and height are in surface coordinate space. If + * width and height are 0, it means bounds is unknown and + * equivalent to as if no configure_bounds event was ever sent for + * this surface. + * + * The bounds can for example correspond to the size of a monitor + * excluding any panels or other shell components, so that a + * surface isn't created in a way that it cannot fit. + * + * The bounds may change at any point, and in such a case, a new + * xdg_toplevel.configure_bounds will be sent, followed by + * xdg_toplevel.configure and xdg_surface.configure. + * @param width suggested maximum width of surface + * @param height suggested maximum height of surface + * @since 4 + */ + void (*configure_bounds)(void *data, + struct xdg_toplevel *xdg_toplevel, + int32_t width, + int32_t height); + /** + * compositor capabilities + * + * This event advertises the capabilities supported by the + * compositor. If a capability isn't supported, clients should hide + * or disable the UI elements that expose this functionality. For + * instance, if the compositor doesn't advertise support for + * minimized toplevels, a button triggering the set_minimized + * request should not be displayed. + * + * The compositor will ignore requests it doesn't support. For + * instance, a compositor which doesn't advertise support for + * minimized will ignore set_minimized requests. + * + * Compositors must send this event once before the first + * xdg_surface.configure event. When the capabilities change, + * compositors must send this event again and then send an + * xdg_surface.configure event. + * + * The configured state should not be applied immediately. See + * xdg_surface.configure for details. + * + * The capabilities are sent as an array of 32-bit unsigned + * integers in native endianness. Capability values are defined in + * the wm_capabilities enum. + * @param capabilities array of 32-bit capabilities + * @since 5 + */ + void (*wm_capabilities)(void *data, + struct xdg_toplevel *xdg_toplevel, + struct wl_array *capabilities); +}; + +/** + * @ingroup iface_xdg_toplevel + */ +static inline int +xdg_toplevel_add_listener(struct xdg_toplevel *xdg_toplevel, + const struct xdg_toplevel_listener *listener, void *data) +{ + return wl_proxy_add_listener((struct wl_proxy *) xdg_toplevel, + (void (**)(void)) listener, data); +} + +#define XDG_TOPLEVEL_DESTROY 0 +#define XDG_TOPLEVEL_SET_PARENT 1 +#define XDG_TOPLEVEL_SET_TITLE 2 +#define XDG_TOPLEVEL_SET_APP_ID 3 +#define XDG_TOPLEVEL_SHOW_WINDOW_MENU 4 +#define XDG_TOPLEVEL_MOVE 5 +#define XDG_TOPLEVEL_RESIZE 6 +#define XDG_TOPLEVEL_SET_MAX_SIZE 7 +#define XDG_TOPLEVEL_SET_MIN_SIZE 8 +#define XDG_TOPLEVEL_SET_MAXIMIZED 9 +#define XDG_TOPLEVEL_UNSET_MAXIMIZED 10 +#define XDG_TOPLEVEL_SET_FULLSCREEN 11 +#define XDG_TOPLEVEL_UNSET_FULLSCREEN 12 +#define XDG_TOPLEVEL_SET_MINIMIZED 13 + +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_CONFIGURE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_CLOSE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION 4 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_WM_CAPABILITIES_SINCE_VERSION 5 + +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_PARENT_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_TITLE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_APP_ID_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SHOW_WINDOW_MENU_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_MOVE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_RESIZE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_MAX_SIZE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_MIN_SIZE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_MAXIMIZED_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_UNSET_MAXIMIZED_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_FULLSCREEN_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_UNSET_FULLSCREEN_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_toplevel + */ +#define XDG_TOPLEVEL_SET_MINIMIZED_SINCE_VERSION 1 + +/** @ingroup iface_xdg_toplevel */ +static inline void +xdg_toplevel_set_user_data(struct xdg_toplevel *xdg_toplevel, void *user_data) +{ + wl_proxy_set_user_data((struct wl_proxy *) xdg_toplevel, user_data); +} + +/** @ingroup iface_xdg_toplevel */ +static inline void * +xdg_toplevel_get_user_data(struct xdg_toplevel *xdg_toplevel) +{ + return wl_proxy_get_user_data((struct wl_proxy *) xdg_toplevel); +} + +static inline uint32_t +xdg_toplevel_get_version(struct xdg_toplevel *xdg_toplevel) +{ + return wl_proxy_get_version((struct wl_proxy *) xdg_toplevel); +} + +/** + * @ingroup iface_xdg_toplevel + * + * This request destroys the role surface and unmaps the surface; + * see "Unmapping" behavior in interface section for details. + */ +static inline void +xdg_toplevel_destroy(struct xdg_toplevel *xdg_toplevel) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), WL_MARSHAL_FLAG_DESTROY); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Set the "parent" of this surface. This surface should be stacked + * above the parent surface and all other ancestor surfaces. + * + * Parent surfaces should be set on dialogs, toolboxes, or other + * "auxiliary" surfaces, so that the parent is raised when the dialog + * is raised. + * + * Setting a null parent for a child surface unsets its parent. Setting + * a null parent for a surface which currently has no parent is a no-op. + * + * Only mapped surfaces can have child surfaces. Setting a parent which + * is not mapped is equivalent to setting a null parent. If a surface + * becomes unmapped, its children's parent is set to the parent of + * the now-unmapped surface. If the now-unmapped surface has no parent, + * its children's parent is unset. If the now-unmapped surface becomes + * mapped again, its parent-child relationship is not restored. + * + * The parent toplevel must not be one of the child toplevel's + * descendants, and the parent must be different from the child toplevel, + * otherwise the invalid_parent protocol error is raised. + */ +static inline void +xdg_toplevel_set_parent(struct xdg_toplevel *xdg_toplevel, struct xdg_toplevel *parent) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_SET_PARENT, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, parent); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Set a short title for the surface. + * + * This string may be used to identify the surface in a task bar, + * window list, or other user interface elements provided by the + * compositor. + * + * The string must be encoded in UTF-8. + */ +static inline void +xdg_toplevel_set_title(struct xdg_toplevel *xdg_toplevel, const char *title) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_SET_TITLE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, title); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Set an application identifier for the surface. + * + * The app ID identifies the general class of applications to which + * the surface belongs. The compositor can use this to group multiple + * surfaces together, or to determine how to launch a new application. + * + * For D-Bus activatable applications, the app ID is used as the D-Bus + * service name. + * + * The compositor shell will try to group application surfaces together + * by their app ID. As a best practice, it is suggested to select app + * ID's that match the basename of the application's .desktop file. + * For example, "org.freedesktop.FooViewer" where the .desktop file is + * "org.freedesktop.FooViewer.desktop". + * + * Like other properties, a set_app_id request can be sent after the + * xdg_toplevel has been mapped to update the property. + * + * See the desktop-entry specification [0] for more details on + * application identifiers and how they relate to well-known D-Bus + * names and .desktop files. + * + * [0] https://standards.freedesktop.org/desktop-entry-spec/ + */ +static inline void +xdg_toplevel_set_app_id(struct xdg_toplevel *xdg_toplevel, const char *app_id) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_SET_APP_ID, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, app_id); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Clients implementing client-side decorations might want to show + * a context menu when right-clicking on the decorations, giving the + * user a menu that they can use to maximize or minimize the window. + * + * This request asks the compositor to pop up such a window menu at + * the given position, relative to the local surface coordinates of + * the parent surface. There are no guarantees as to what menu items + * the window menu contains, or even if a window menu will be drawn + * at all. + * + * This request must be used in response to some sort of user action + * like a button press, key press, or touch down event. + */ +static inline void +xdg_toplevel_show_window_menu(struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial, int32_t x, int32_t y) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_SHOW_WINDOW_MENU, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, seat, serial, x, y); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Start an interactive, user-driven move of the surface. + * + * This request must be used in response to some sort of user action + * like a button press, key press, or touch down event. The passed + * serial is used to determine the type of interactive move (touch, + * pointer, etc). + * + * The server may ignore move requests depending on the state of + * the surface (e.g. fullscreen or maximized), or if the passed serial + * is no longer valid. + * + * If triggered, the surface will lose the focus of the device + * (wl_pointer, wl_touch, etc) used for the move. It is up to the + * compositor to visually indicate that the move is taking place, such as + * updating a pointer cursor, during the move. There is no guarantee + * that the device focus will return when the move is completed. + */ +static inline void +xdg_toplevel_move(struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_MOVE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, seat, serial); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Start a user-driven, interactive resize of the surface. + * + * This request must be used in response to some sort of user action + * like a button press, key press, or touch down event. The passed + * serial is used to determine the type of interactive resize (touch, + * pointer, etc). + * + * The server may ignore resize requests depending on the state of + * the surface (e.g. fullscreen or maximized). + * + * If triggered, the client will receive configure events with the + * "resize" state enum value and the expected sizes. See the "resize" + * enum value for more details about what is required. The client + * must also acknowledge configure events using "ack_configure". After + * the resize is completed, the client will receive another "configure" + * event without the resize state. + * + * If triggered, the surface also will lose the focus of the device + * (wl_pointer, wl_touch, etc) used for the resize. It is up to the + * compositor to visually indicate that the resize is taking place, + * such as updating a pointer cursor, during the resize. There is no + * guarantee that the device focus will return when the resize is + * completed. + * + * The edges parameter specifies how the surface should be resized, and + * is one of the values of the resize_edge enum. Values not matching + * a variant of the enum will cause the invalid_resize_edge protocol error. + * The compositor may use this information to update the surface position + * for example when dragging the top left corner. The compositor may also + * use this information to adapt its behavior, e.g. choose an appropriate + * cursor image. + */ +static inline void +xdg_toplevel_resize(struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial, uint32_t edges) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_RESIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, seat, serial, edges); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Set a maximum size for the window. + * + * The client can specify a maximum size so that the compositor does + * not try to configure the window beyond this size. + * + * The width and height arguments are in window geometry coordinates. + * See xdg_surface.set_window_geometry. + * + * Values set in this way are double-buffered, see wl_surface.commit. + * + * The compositor can use this information to allow or disallow + * different states like maximize or fullscreen and draw accurate + * animations. + * + * Similarly, a tiling window manager may use this information to + * place and resize client windows in a more effective way. + * + * The client should not rely on the compositor to obey the maximum + * size. The compositor may decide to ignore the values set by the + * client and request a larger size. + * + * If never set, or a value of zero in the request, means that the + * client has no expected maximum size in the given dimension. + * As a result, a client wishing to reset the maximum size + * to an unspecified state can use zero for width and height in the + * request. + * + * Requesting a maximum size to be smaller than the minimum size of + * a surface is illegal and will result in an invalid_size error. + * + * The width and height must be greater than or equal to zero. Using + * strictly negative values for width or height will result in an + * invalid_size error. + */ +static inline void +xdg_toplevel_set_max_size(struct xdg_toplevel *xdg_toplevel, int32_t width, int32_t height) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_SET_MAX_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, width, height); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Set a minimum size for the window. + * + * The client can specify a minimum size so that the compositor does + * not try to configure the window below this size. + * + * The width and height arguments are in window geometry coordinates. + * See xdg_surface.set_window_geometry. + * + * Values set in this way are double-buffered, see wl_surface.commit. + * + * The compositor can use this information to allow or disallow + * different states like maximize or fullscreen and draw accurate + * animations. + * + * Similarly, a tiling window manager may use this information to + * place and resize client windows in a more effective way. + * + * The client should not rely on the compositor to obey the minimum + * size. The compositor may decide to ignore the values set by the + * client and request a smaller size. + * + * If never set, or a value of zero in the request, means that the + * client has no expected minimum size in the given dimension. + * As a result, a client wishing to reset the minimum size + * to an unspecified state can use zero for width and height in the + * request. + * + * Requesting a minimum size to be larger than the maximum size of + * a surface is illegal and will result in an invalid_size error. + * + * The width and height must be greater than or equal to zero. Using + * strictly negative values for width and height will result in an + * invalid_size error. + */ +static inline void +xdg_toplevel_set_min_size(struct xdg_toplevel *xdg_toplevel, int32_t width, int32_t height) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_SET_MIN_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, width, height); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Maximize the surface. + * + * After requesting that the surface should be maximized, the compositor + * will respond by emitting a configure event. Whether this configure + * actually sets the window maximized is subject to compositor policies. + * The client must then update its content, drawing in the configured + * state. The client must also acknowledge the configure when committing + * the new content (see ack_configure). + * + * It is up to the compositor to decide how and where to maximize the + * surface, for example which output and what region of the screen should + * be used. + * + * If the surface was already maximized, the compositor will still emit + * a configure event with the "maximized" state. + * + * If the surface is in a fullscreen state, this request has no direct + * effect. It may alter the state the surface is returned to when + * unmaximized unless overridden by the compositor. + */ +static inline void +xdg_toplevel_set_maximized(struct xdg_toplevel *xdg_toplevel) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_SET_MAXIMIZED, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Unmaximize the surface. + * + * After requesting that the surface should be unmaximized, the compositor + * will respond by emitting a configure event. Whether this actually + * un-maximizes the window is subject to compositor policies. + * If available and applicable, the compositor will include the window + * geometry dimensions the window had prior to being maximized in the + * configure event. The client must then update its content, drawing it in + * the configured state. The client must also acknowledge the configure + * when committing the new content (see ack_configure). + * + * It is up to the compositor to position the surface after it was + * unmaximized; usually the position the surface had before maximizing, if + * applicable. + * + * If the surface was already not maximized, the compositor will still + * emit a configure event without the "maximized" state. + * + * If the surface is in a fullscreen state, this request has no direct + * effect. It may alter the state the surface is returned to when + * unmaximized unless overridden by the compositor. + */ +static inline void +xdg_toplevel_unset_maximized(struct xdg_toplevel *xdg_toplevel) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_UNSET_MAXIMIZED, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Make the surface fullscreen. + * + * After requesting that the surface should be fullscreened, the + * compositor will respond by emitting a configure event. Whether the + * client is actually put into a fullscreen state is subject to compositor + * policies. The client must also acknowledge the configure when + * committing the new content (see ack_configure). + * + * The output passed by the request indicates the client's preference as + * to which display it should be set fullscreen on. If this value is NULL, + * it's up to the compositor to choose which display will be used to map + * this surface. + * + * If the surface doesn't cover the whole output, the compositor will + * position the surface in the center of the output and compensate with + * border fill covering the rest of the output. The content of the + * border fill is undefined, but should be assumed to be in some way that + * attempts to blend into the surrounding area (e.g. solid black). + * + * If the fullscreened surface is not opaque, the compositor must make + * sure that other screen content not part of the same surface tree (made + * up of subsurfaces, popups or similarly coupled surfaces) are not + * visible below the fullscreened surface. + */ +static inline void +xdg_toplevel_set_fullscreen(struct xdg_toplevel *xdg_toplevel, struct wl_output *output) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_SET_FULLSCREEN, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, output); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Make the surface no longer fullscreen. + * + * After requesting that the surface should be unfullscreened, the + * compositor will respond by emitting a configure event. + * Whether this actually removes the fullscreen state of the client is + * subject to compositor policies. + * + * Making a surface unfullscreen sets states for the surface based on the following: + * * the state(s) it may have had before becoming fullscreen + * * any state(s) decided by the compositor + * * any state(s) requested by the client while the surface was fullscreen + * + * The compositor may include the previous window geometry dimensions in + * the configure event, if applicable. + * + * The client must also acknowledge the configure when committing the new + * content (see ack_configure). + */ +static inline void +xdg_toplevel_unset_fullscreen(struct xdg_toplevel *xdg_toplevel) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_UNSET_FULLSCREEN, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0); +} + +/** + * @ingroup iface_xdg_toplevel + * + * Request that the compositor minimize your surface. There is no + * way to know if the surface is currently minimized, nor is there + * any way to unset minimization on this surface. + * + * If you are looking to throttle redrawing when minimized, please + * instead use the wl_surface.frame event for this, as this will + * also work with live previews on windows in Alt-Tab, Expose or + * similar compositor features. + */ +static inline void +xdg_toplevel_set_minimized(struct xdg_toplevel *xdg_toplevel) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, + XDG_TOPLEVEL_SET_MINIMIZED, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0); +} + +#ifndef XDG_POPUP_ERROR_ENUM +#define XDG_POPUP_ERROR_ENUM +enum xdg_popup_error { + /** + * tried to grab after being mapped + */ + XDG_POPUP_ERROR_INVALID_GRAB = 0, +}; +#endif /* XDG_POPUP_ERROR_ENUM */ + +/** + * @ingroup iface_xdg_popup + * @struct xdg_popup_listener + */ +struct xdg_popup_listener { + /** + * configure the popup surface + * + * This event asks the popup surface to configure itself given + * the configuration. The configured state should not be applied + * immediately. See xdg_surface.configure for details. + * + * The x and y arguments represent the position the popup was + * placed at given the xdg_positioner rule, relative to the upper + * left corner of the window geometry of the parent surface. + * + * For version 2 or older, the configure event for an xdg_popup is + * only ever sent once for the initial configuration. Starting with + * version 3, it may be sent again if the popup is setup with an + * xdg_positioner with set_reactive requested, or in response to + * xdg_popup.reposition requests. + * @param x x position relative to parent surface window geometry + * @param y y position relative to parent surface window geometry + * @param width window geometry width + * @param height window geometry height + */ + void (*configure)(void *data, + struct xdg_popup *xdg_popup, + int32_t x, + int32_t y, + int32_t width, + int32_t height); + /** + * popup interaction is done + * + * The popup_done event is sent out when a popup is dismissed by + * the compositor. The client should destroy the xdg_popup object + * at this point. + */ + void (*popup_done)(void *data, + struct xdg_popup *xdg_popup); + /** + * signal the completion of a repositioned request + * + * The repositioned event is sent as part of a popup + * configuration sequence, together with xdg_popup.configure and + * lastly xdg_surface.configure to notify the completion of a + * reposition request. + * + * The repositioned event is to notify about the completion of a + * xdg_popup.reposition request. The token argument is the token + * passed in the xdg_popup.reposition request. + * + * Immediately after this event is emitted, xdg_popup.configure and + * xdg_surface.configure will be sent with the updated size and + * position, as well as a new configure serial. + * + * The client should optionally update the content of the popup, + * but must acknowledge the new popup configuration for the new + * position to take effect. See xdg_surface.ack_configure for + * details. + * @param token reposition request token + * @since 3 + */ + void (*repositioned)(void *data, + struct xdg_popup *xdg_popup, + uint32_t token); +}; + +/** + * @ingroup iface_xdg_popup + */ +static inline int +xdg_popup_add_listener(struct xdg_popup *xdg_popup, + const struct xdg_popup_listener *listener, void *data) +{ + return wl_proxy_add_listener((struct wl_proxy *) xdg_popup, + (void (**)(void)) listener, data); +} + +#define XDG_POPUP_DESTROY 0 +#define XDG_POPUP_GRAB 1 +#define XDG_POPUP_REPOSITION 2 + +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_CONFIGURE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_POPUP_DONE_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_REPOSITIONED_SINCE_VERSION 3 + +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_GRAB_SINCE_VERSION 1 +/** + * @ingroup iface_xdg_popup + */ +#define XDG_POPUP_REPOSITION_SINCE_VERSION 3 + +/** @ingroup iface_xdg_popup */ +static inline void +xdg_popup_set_user_data(struct xdg_popup *xdg_popup, void *user_data) +{ + wl_proxy_set_user_data((struct wl_proxy *) xdg_popup, user_data); +} + +/** @ingroup iface_xdg_popup */ +static inline void * +xdg_popup_get_user_data(struct xdg_popup *xdg_popup) +{ + return wl_proxy_get_user_data((struct wl_proxy *) xdg_popup); +} + +static inline uint32_t +xdg_popup_get_version(struct xdg_popup *xdg_popup) +{ + return wl_proxy_get_version((struct wl_proxy *) xdg_popup); +} + +/** + * @ingroup iface_xdg_popup + * + * This destroys the popup. Explicitly destroying the xdg_popup + * object will also dismiss the popup, and unmap the surface. + * + * If this xdg_popup is not the "topmost" popup, the + * xdg_wm_base.not_the_topmost_popup protocol error will be sent. + */ +static inline void +xdg_popup_destroy(struct xdg_popup *xdg_popup) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_popup, + XDG_POPUP_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_popup), WL_MARSHAL_FLAG_DESTROY); +} + +/** + * @ingroup iface_xdg_popup + * + * This request makes the created popup take an explicit grab. An explicit + * grab will be dismissed when the user dismisses the popup, or when the + * client destroys the xdg_popup. This can be done by the user clicking + * outside the surface, using the keyboard, or even locking the screen + * through closing the lid or a timeout. + * + * If the compositor denies the grab, the popup will be immediately + * dismissed. + * + * This request must be used in response to some sort of user action like a + * button press, key press, or touch down event. The serial number of the + * event should be passed as 'serial'. + * + * The parent of a grabbing popup must either be an xdg_toplevel surface or + * another xdg_popup with an explicit grab. If the parent is another + * xdg_popup it means that the popups are nested, with this popup now being + * the topmost popup. + * + * Nested popups must be destroyed in the reverse order they were created + * in, e.g. the only popup you are allowed to destroy at all times is the + * topmost one. + * + * When compositors choose to dismiss a popup, they may dismiss every + * nested grabbing popup as well. When a compositor dismisses popups, it + * will follow the same dismissing order as required from the client. + * + * If the topmost grabbing popup is destroyed, the grab will be returned to + * the parent of the popup, if that parent previously had an explicit grab. + * + * If the parent is a grabbing popup which has already been dismissed, this + * popup will be immediately dismissed. If the parent is a popup that did + * not take an explicit grab, an error will be raised. + * + * During a popup grab, the client owning the grab will receive pointer + * and touch events for all their surfaces as normal (similar to an + * "owner-events" grab in X11 parlance), while the top most grabbing popup + * will always have keyboard focus. + */ +static inline void +xdg_popup_grab(struct xdg_popup *xdg_popup, struct wl_seat *seat, uint32_t serial) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_popup, + XDG_POPUP_GRAB, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_popup), 0, seat, serial); +} + +/** + * @ingroup iface_xdg_popup + * + * Reposition an already-mapped popup. The popup will be placed given the + * details in the passed xdg_positioner object, and a + * xdg_popup.repositioned followed by xdg_popup.configure and + * xdg_surface.configure will be emitted in response. Any parameters set + * by the previous positioner will be discarded. + * + * The passed token will be sent in the corresponding + * xdg_popup.repositioned event. The new popup position will not take + * effect until the corresponding configure event is acknowledged by the + * client. See xdg_popup.repositioned for details. The token itself is + * opaque, and has no other special meaning. + * + * If multiple reposition requests are sent, the compositor may skip all + * but the last one. + * + * If the popup is repositioned in response to a configure event for its + * parent, the client should send an xdg_positioner.set_parent_configure + * and possibly an xdg_positioner.set_parent_size request to allow the + * compositor to properly constrain the popup. + * + * If the popup is repositioned together with a parent that is being + * resized, but not in response to a configure event, the client should + * send an xdg_positioner.set_parent_size request. + */ +static inline void +xdg_popup_reposition(struct xdg_popup *xdg_popup, struct xdg_positioner *positioner, uint32_t token) +{ + wl_proxy_marshal_flags((struct wl_proxy *) xdg_popup, + XDG_POPUP_REPOSITION, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_popup), 0, positioner, token); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xdg-shell-client-protocol.o b/xdg-shell-client-protocol.o new file mode 100644 index 0000000000000000000000000000000000000000..3d321b776c9445757893fa1ac32c6f07ec36df25 GIT binary patch literal 8448 zcmeI1PlzMO6~=3JH_keL*5i`CiO@?lDtxP zN8Q@h*oNqqIhlbFm{XXL90r0x$AJ)->uef7GkyHt{X{_>B1bZ%+MSy^&FaC6V7bM>#2?ajJ-%3X5fcBhf0*(h_Z zG}-EPM#I?kq&N>7?KFv<8^&3h_lll4ZMQmd?Km%n>9*?(qfM8NsNJoK3(X?U`tjYk zFJh5v_0v3_575|5M@c((&&e?N28~vfMVr08=*PKxK5}_nG_q(ICxv@4^p=+oF~9G;m6j*^PN+%Y4+HP0gP=6W8~-PhHlZoP;rd zyeB+v_s1t^ravN++b_NJy~@h%pS0&oAsCCC4#uN%+2ot!a&H!RrD4q35{U%5tLh zPo?%cn)tfb9p!cPn;QS7@}_=}kCpE#uPMK*{I|+0I#~~t|3UdgH^-)O2GCPwl zcAHV|S)OGV1NDI0pt$*|Z!uI)h>wN~{pG7iLr$r2d3IjNauM6;i+A3FSgd;xJCB0siL*Gs|0v+M z)ITN;9n(D_4xN|PKMnZ0`e($UbELj(I=qnsND{4M1Z;+)S8ap+7memCH|%J+z~&OUMI z%bmX)+;sMdv(5o=n9r!rG~jkW9}p2T9%%=L4fZKV}YSXcO^#;X5ALlZZI&sd&#xWh+f4US89lNfK zIO~jwBmOlVcM|YT*7&`EC(8GUL#Hk;lmp_>$u)i&a64}t66fnW zA`YEjsLpY~ZJtkvv(6cD==@4`9uS9V-wUip7~*YRRxXGm#kj3YjW~~cgE(}4r{mTG zZu`R;an@NU4xM*YXCvS?pH1Sd(oxak}aXPqf==)9*ohXJ>FJ|fOK$HbxYZ`C;o_!DT9a!Q73_+{k} zh_lW^;s||KvvyOdVwD@bPQ=@p?{}c7=0k`kJR-4XE)!CqUAX~2{ zan8raF&%rpb|@Y?SLB7VOPqD~h$H@%=CdDg+xHHLL#HAylqqpYysA2f0dFfmA`YDu zh)6jmj?j+Ap9I|I=ae{KR|R5HFh5`NR{3V*fIm&VrZ%|k0YJ8|gD(SUscQ}Xl-j7) z)DHF6iE}=7ZVmOD6#o^qQBBlFJaapjh1|{&;9u3gsHSR%@khitPgl*i2Zj7?Se3u0 z%DQV-5swR3ZAV4qs+)Q4s>2ixBIS2CapQjEn_)>~wV$@4e!yL|l@9!$UDYHl;;Q^8 zcQr5M|20?oon%y%pHi}TDF2jw{PH!Cz_mXSNYw-1T*PwuhB#pQ@i%L#&#Xlw?Efuk zz9_H%wf}ddFEnl664RHu)_r|$)b+8jEswg|;rMnwJ=5n3eNZa?eg5`+F|oDQ=g3># zFP7k;)?W}8Qn*%>%Vp)iuOXLk{9O$^(KxFrW@!D2)Q=j!iG`K2t`~~&@hf9E{-!X5 z)a1pb`DE!m%TR2Uo7H!Sap+sxpBZfHZ~RR$kXNuwZle9eyexm~552H2+NRonMH{gU o*q^Mw%|F7zxfkS4KaY3k-VPEDT)%fds{d3c?(I@$_8#{C01+W+z5oCK literal 0 HcmV?d00001