From a661eddfd8e0f68e3e5327b9a7f21a0cfa8e9d8d Mon Sep 17 00:00:00 2001 From: Derek Christ Date: Sun, 28 Aug 2022 15:57:08 +0200 Subject: [PATCH] Init --- build.sh | 1 + client | Bin 0 -> 23960 bytes client.c | 16 + common/shm.c | 52 + common/shm.h | 5 + compositor | Bin 0 -> 43456 bytes compositor.c | 180 ++ globals | Bin 0 -> 22976 bytes globals.c | 34 + protocols/xdg-shell-client-protocol.h | 2224 +++++++++++++++++++++++++ protocols/xdg-shell-protocol.c | 183 ++ server | Bin 0 -> 23432 bytes server.c | 86 + 13 files changed, 2781 insertions(+) create mode 100755 build.sh create mode 100755 client create mode 100644 client.c create mode 100644 common/shm.c create mode 100644 common/shm.h create mode 100755 compositor create mode 100644 compositor.c create mode 100755 globals create mode 100644 globals.c create mode 100644 protocols/xdg-shell-client-protocol.h create mode 100644 protocols/xdg-shell-protocol.c create mode 100755 server create mode 100644 server.c diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..e67bf69 --- /dev/null +++ b/build.sh @@ -0,0 +1 @@ +gcc compositor.c common/shm.c protocols/xdg-shell-protocol.c -o compositor -lwayland-client -lrt -g diff --git a/client b/client new file mode 100755 index 0000000000000000000000000000000000000000..f6e39cf12912b2167068315661cd05876d6f738b GIT binary patch literal 23960 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 +#include + +int +main(int argc, char *argv[]) +{ + struct wl_display *display = wl_display_connect(NULL); + if (!display) { + fprintf(stderr, "Failed to connect to Wayland display.\n"); + return 1; + } + fprintf(stderr, "Connection established!\n"); + + wl_display_disconnect(display); + return 0; +} diff --git a/common/shm.c b/common/shm.c new file mode 100644 index 0000000..d0f0e45 --- /dev/null +++ b/common/shm.c @@ -0,0 +1,52 @@ +#define _POSIX_C_SOURCE 200112L +#include +#include +#include +#include +#include + +static void +randname(char *buf) +{ + struct timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + long r = ts.tv_nsec; + for (int i = 0; i < 6; ++i) { + buf[i] = 'A'+(r&15)+(r&16)*2; + r >>= 5; + } +} + +static int +create_shm_file(void) +{ + int retries = 100; + do { + char name[] = "/wl_shm-XXXXXX"; + randname(name + sizeof(name) - 7); + --retries; + int fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600); + if (fd >= 0) { + shm_unlink(name); + return fd; + } + } while (retries > 0 && errno == EEXIST); + return -1; +} + +int +allocate_shm_file(size_t size) +{ + int fd = create_shm_file(); + if (fd < 0) + return -1; + int ret; + do { + ret = ftruncate(fd, size); + } while (ret < 0 && errno == EINTR); + if (ret < 0) { + close(fd); + return -1; + } + return fd; +} \ No newline at end of file diff --git a/common/shm.h b/common/shm.h new file mode 100644 index 0000000..36b0ee5 --- /dev/null +++ b/common/shm.h @@ -0,0 +1,5 @@ +#pragma once + +#include + +int allocate_shm_file(size_t size); diff --git a/compositor b/compositor new file mode 100755 index 0000000000000000000000000000000000000000..d4119394faa41cee8bc557f19025272dc22645a3 GIT binary patch literal 43456 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 g!<_a#fX){Ggam)|2kg%O)f1JHgv;Y7A literal 0 HcmV?d00001 diff --git a/compositor.c b/compositor.c new file mode 100644 index 0000000..030a46a --- /dev/null +++ b/compositor.c @@ -0,0 +1,180 @@ +#include "common/shm.h" +#include "protocols/xdg-shell-client-protocol.h" + +#include +#include +#include +#include +#include + +struct client_state +{ + /* Globals */ + struct wl_display *wl_display; + struct wl_registry *wl_registry; + struct wl_shm *wl_shm; + struct wl_compositor *wl_compositor; + struct xdg_wm_base *xdg_wm_base; + + /* Objects */ + struct wl_surface *wl_surface; + struct xdg_surface *xdg_surface; + struct xdg_toplevel *xdg_toplevel; +}; + +static struct wl_buffer *draw_frame(struct client_state *state); + +static void registry_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, + uint32_t version) +{ + struct client_state *state = data; + + printf("interface: '%s', version: %d, name: %d\n", interface, version, name); + + if (strcmp(interface, wl_compositor_interface.name) == 0) { + state->wl_compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 5); + printf("Bound to compositor!\n"); + } + + if (strcmp(interface, wl_shm_interface.name) == 0) { + state->wl_shm = wl_registry_bind(registry, name, &wl_shm_interface, 1); + printf("Bound to shm!\n"); + } + + if (strcmp(interface, xdg_wm_base_interface.name) == 0) { + state->xdg_wm_base = wl_registry_bind(registry, name, &xdg_wm_base_interface, 4); + printf("Bound to wm_base!\n"); + } +} + +static void registry_handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) +{ + // This space deliberately left blank +} + +static void shm_handle_format(void *data, struct wl_shm *wl_shm, uint32_t format) +{ + struct client_state *state = data; + + printf("shm_handle_format: supported format is [%d]\n", format); +} + +static void wm_base_handle_ping(void *data, struct xdg_wm_base *xdg_wm_base, uint32_t serial) +{ + struct client_state *state = data; + + // TODO ! +} + +static void surface_handle_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial) +{ + struct client_state *state = data; + + xdg_surface_ack_configure(xdg_surface, serial); + + struct wl_buffer *buffer = draw_frame(state); + wl_surface_attach(state->wl_surface, buffer, 0, 0); + wl_surface_commit(state->wl_surface); +} + +static const struct wl_registry_listener wl_registry_listener = { + .global = registry_handle_global, + .global_remove = registry_handle_global_remove, +}; + +static const struct wl_shm_listener wl_shm_listener = { + .format = shm_handle_format, +}; + +static const struct xdg_wm_base_listener xdg_wm_base_listener = { + .ping = wm_base_handle_ping, +}; + +static const struct xdg_surface_listener xdg_surface_listener = { + .configure = surface_handle_configure, +}; + +static void wl_buffer_release(void *data, struct wl_buffer *wl_buffer) +{ + /* Sent by the compositor when it's no longer using this buffer */ + wl_buffer_destroy(wl_buffer); +} + +static const struct wl_buffer_listener wl_buffer_listener = { + .release = wl_buffer_release, +}; + +static struct wl_buffer *draw_frame(struct client_state *state) +{ + const int width = 640, height = 480; + int stride = width * 4; + int size = stride * height; + int offset = 0; + + int fd = allocate_shm_file(size); + if (fd == -1) { + return NULL; + } + + uint32_t *data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (data == MAP_FAILED) { + close(fd); + return NULL; + } + + struct wl_shm_pool *pool = wl_shm_create_pool(state->wl_shm, fd, size); + struct wl_buffer *buffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride, WL_SHM_FORMAT_XRGB8888); + wl_shm_pool_destroy(pool); + close(fd); + + // Solid white + // uint32_t *pixels = (uint32_t *)&data[offset]; + // memset(pixels, 255, width * height * 4); + + // Checkerboard pattern + uint32_t *pixels = (uint32_t *)&data[offset]; + for (int y = 0; y < height; ++y) { + for (int x = 0; x < width; ++x) { + if ((x + y / 8 * 8) % 16 < 8) { + pixels[y * width + x] = 0xFF666666; + } else { + pixels[y * width + x] = 0xFFEEEEEE; + } + } + } + + munmap(data, size); + wl_buffer_add_listener(buffer, &wl_buffer_listener, NULL); + return buffer; +} + +int main(int argc, char *argv[]) +{ + struct client_state state = {0}; + + state.wl_display = wl_display_connect(NULL); + + state.wl_registry = wl_display_get_registry(state.wl_display); + + wl_registry_add_listener(state.wl_registry, &wl_registry_listener, &state); + + wl_display_roundtrip(state.wl_display); + + state.wl_surface = wl_compositor_create_surface(state.wl_compositor); + + wl_shm_add_listener(state.wl_shm, &wl_shm_listener, &state); + + state.xdg_surface = xdg_wm_base_get_xdg_surface(state.xdg_wm_base, state.wl_surface); + xdg_surface_add_listener(state.xdg_surface, &xdg_surface_listener, &state); + + state.xdg_toplevel = xdg_surface_get_toplevel(state.xdg_surface); + + xdg_toplevel_set_title(state.xdg_toplevel, "Example client"); + wl_surface_commit(state.wl_surface); + + while (wl_display_dispatch(state.wl_display)) { + /* This space deliberately left blank */ + } + + return 0; +} diff --git a/globals b/globals new file mode 100755 index 0000000000000000000000000000000000000000..57a83adbb5a4052c825daab73f2bb34bb158634e GIT binary patch literal 22976 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 +#include +#include + +static void +registry_handle_global(void *data, struct wl_registry *registry, + uint32_t name, const char *interface, uint32_t version) +{ + printf("interface: '%s', version: %d, name: %d\n", + interface, version, name); +} + +static void +registry_handle_global_remove(void *data, struct wl_registry *registry, + uint32_t name) +{ + // This space deliberately left blank +} + +static const struct wl_registry_listener +registry_listener = { + .global = registry_handle_global, + .global_remove = registry_handle_global_remove, +}; + +int +main(int argc, char *argv[]) +{ + struct wl_display *display = wl_display_connect(NULL); + struct wl_registry *registry = wl_display_get_registry(display); + wl_registry_add_listener(registry, ®istry_listener, NULL); + wl_display_roundtrip(display); + return 0; +} diff --git a/protocols/xdg-shell-client-protocol.h b/protocols/xdg-shell-client-protocol.h new file mode 100644 index 0000000..83d5a7d --- /dev/null +++ b/protocols/xdg-shell-client-protocol.h @@ -0,0 +1,2224 @@ +/* Generated by wayland-scanner 1.21.0 */ + +#ifndef XDG_SHELL_CLIENT_PROTOCOL_H +#define XDG_SHELL_CLIENT_PROTOCOL_H + +#include +#include +#include + +#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 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 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, the client must + * perform an initial commit without any buffer attached. The compositor + * will reply with 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, the client must + * perform an initial commit without any buffer attached. The compositor + * will reply with 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. + * + * 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 perfoming 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. + * + * 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 perfoming 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, +}; +#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. + * + * 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 protocol 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. 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 an + * assigned role and this will result in a protocol error. + * + * 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. + * + * 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. + */ +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 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. + */ +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 { + XDG_SURFACE_ERROR_NOT_CONSTRUCTED = 1, + XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED = 2, + XDG_SURFACE_ERROR_UNCONFIGURED_BUFFER = 3, +}; +#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. + */ +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. + * + * The window geometry is double buffered, and will be applied at the + * time wl_surface.commit of the corresponding wl_surface is called. + * + * 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. + * + * The width and height must be greater than zero. Setting an invalid size + * will raise an error. 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. + */ +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. + * + * 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. + */ +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, +}; +#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. They will get applied on + * the next 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. + * + * 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. + * @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. + * @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. + * @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. + * @since 2 + */ + XDG_TOPLEVEL_STATE_TILED_BOTTOM = 8, +}; +/** + * @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 +#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. + * + * Clients must send an ack_configure in response to this event. + * See xdg_surface.configure and xdg_surface.ack_configure for + * details. + */ + 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. + * @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. + * @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. + */ +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] http://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. + * + * 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 a 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. They will get applied + * on the next 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 a protocol error. + * + * The width and height must be greater than or equal to zero. Using + * strictly negative values for width and height will result in a + * protocol 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. They will get applied + * on the next 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 a protocol error. + * + * The width and height must be greater than or equal to zero. Using + * strictly negative values for width and height will result in a + * protocol 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 + * 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, a 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/protocols/xdg-shell-protocol.c b/protocols/xdg-shell-protocol.c new file mode 100644 index 0000000..e68e61c --- /dev/null +++ b/protocols/xdg-shell-protocol.c @@ -0,0 +1,183 @@ +/* Generated by wayland-scanner 1.21.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 + +#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", 5, + 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", 5, + 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", 5, + 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", 5, + 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", 5, + 3, xdg_popup_requests, + 3, xdg_popup_events, +}; + diff --git a/server b/server new file mode 100755 index 0000000000000000000000000000000000000000..bc07285c7a163b5810852c05388448b7fd77c341 GIT binary patch literal 23432 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 literal 0 HcmV?d00001 diff --git a/server.c b/server.c new file mode 100644 index 0000000..cd1bc32 --- /dev/null +++ b/server.c @@ -0,0 +1,86 @@ +#include +#include +#include +#include + +typedef struct my_state_t { + int x; + struct wl_list client_outputs; +} my_state; + +typedef struct my_output_t { + my_state *state; + struct wl_resource *resource; +} my_output; + +static void +wl_output_handle_resource_destroy(struct wl_resource *resource) +{ + my_output *client_output = wl_resource_get_user_data(resource); + + // TODO: Clean up resource + + // remove_to_list(client_output->state->client_outputs, client_output); +} + +static void +wl_output_handle_release(struct wl_client *client, struct wl_resource *resource) +{ + wl_resource_destroy(resource); +} + +static const struct wl_output_interface +wl_output_implementation = { + .release = wl_output_handle_release, +}; + +static void wl_output_handle_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id) +{ + my_state *state = data; + printf("wl_output_handle_bind: State Variable: %d", state->x); + + my_output *client_output = malloc(sizeof *client_output); + + struct wl_resource *resource = wl_resource_create( + client, &wl_output_implementation, wl_output_interface.version, id); + + wl_resource_set_implementation(resource, &wl_output_implementation, + client_output, wl_output_handle_resource_destroy); + + client_output->resource = resource; + client_output->state = state; + + // Send geometry event, et al + wl_output_send_geometry(resource, 0, 0, 1920, 1080, + WL_OUTPUT_SUBPIXEL_UNKNOWN, "Foobar, Inc", + "Fancy Monitor 9001 4K HD 120 FPS Noscope", + WL_OUTPUT_TRANSFORM_NORMAL); + + // add_to_list(state->client_outputs, client_output); +} + +int main(int argc, char *argv[]) +{ + struct wl_display *display = wl_display_create(); + if (!display) { + fprintf(stderr, "Unable to create Wayland display.\n"); + return 1; + } + + const char *socket = wl_display_add_socket_auto(display); + if (!socket) { + fprintf(stderr, "Unable to add socket to Wayland display.\n"); + return 1; + } + + fprintf(stderr, "Running Wayland display on %s\n", socket); + + my_state state = { 0 }; + + wl_global_create(display, &wl_output_interface, 1, &state, wl_output_handle_bind); + + wl_display_run(display); + + wl_display_destroy(display); + return 0; +}