| Index: third_party/wayland/include/protocol/wayland-server-protocol.h
|
| diff --git a/third_party/wayland/include/protocol/wayland-server-protocol.h b/third_party/wayland/include/protocol/wayland-server-protocol.h
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..16e3d27178d37be2a614cce1f63b09e724926b0c
|
| --- /dev/null
|
| +++ b/third_party/wayland/include/protocol/wayland-server-protocol.h
|
| @@ -0,0 +1,2404 @@
|
| +/*
|
| + * Copyright © 2008-2011 Kristian Høgsberg
|
| + * Copyright © 2010-2011 Intel Corporation
|
| + * Copyright © 2012-2013 Collabora, Ltd.
|
| + *
|
| + * Permission is hereby granted, free of charge, to any person
|
| + * obtaining a copy of this software and associated documentation files
|
| + * (the "Software"), to deal in the Software without restriction,
|
| + * including without limitation the rights to use, copy, modify, merge,
|
| + * publish, distribute, sublicense, and/or sell copies of the Software,
|
| + * and to permit persons to whom the Software is furnished to do so,
|
| + * subject to the following conditions:
|
| + *
|
| + * The above copyright notice and this permission notice (including the
|
| + * next paragraph) shall be included in all copies or substantial
|
| + * portions of the Software.
|
| + *
|
| + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
| + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
| + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
| + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
| + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
| + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
| + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
| + * SOFTWARE.
|
| + */
|
| +
|
| +#ifndef WAYLAND_SERVER_PROTOCOL_H
|
| +#define WAYLAND_SERVER_PROTOCOL_H
|
| +
|
| +#ifdef __cplusplus
|
| +extern "C" {
|
| +#endif
|
| +
|
| +#include <stdint.h>
|
| +#include <stddef.h>
|
| +#include "wayland-server.h"
|
| +
|
| +struct wl_client;
|
| +struct wl_resource;
|
| +
|
| +struct wl_buffer;
|
| +struct wl_callback;
|
| +struct wl_compositor;
|
| +struct wl_data_device;
|
| +struct wl_data_device_manager;
|
| +struct wl_data_offer;
|
| +struct wl_data_source;
|
| +struct wl_display;
|
| +struct wl_keyboard;
|
| +struct wl_output;
|
| +struct wl_pointer;
|
| +struct wl_region;
|
| +struct wl_registry;
|
| +struct wl_seat;
|
| +struct wl_shell;
|
| +struct wl_shell_surface;
|
| +struct wl_shm;
|
| +struct wl_shm_pool;
|
| +struct wl_subcompositor;
|
| +struct wl_subsurface;
|
| +struct wl_surface;
|
| +struct wl_touch;
|
| +
|
| +extern const struct wl_interface wl_display_interface;
|
| +extern const struct wl_interface wl_registry_interface;
|
| +extern const struct wl_interface wl_callback_interface;
|
| +extern const struct wl_interface wl_compositor_interface;
|
| +extern const struct wl_interface wl_shm_pool_interface;
|
| +extern const struct wl_interface wl_shm_interface;
|
| +extern const struct wl_interface wl_buffer_interface;
|
| +extern const struct wl_interface wl_data_offer_interface;
|
| +extern const struct wl_interface wl_data_source_interface;
|
| +extern const struct wl_interface wl_data_device_interface;
|
| +extern const struct wl_interface wl_data_device_manager_interface;
|
| +extern const struct wl_interface wl_shell_interface;
|
| +extern const struct wl_interface wl_shell_surface_interface;
|
| +extern const struct wl_interface wl_surface_interface;
|
| +extern const struct wl_interface wl_seat_interface;
|
| +extern const struct wl_interface wl_pointer_interface;
|
| +extern const struct wl_interface wl_keyboard_interface;
|
| +extern const struct wl_interface wl_touch_interface;
|
| +extern const struct wl_interface wl_output_interface;
|
| +extern const struct wl_interface wl_region_interface;
|
| +extern const struct wl_interface wl_subcompositor_interface;
|
| +extern const struct wl_interface wl_subsurface_interface;
|
| +
|
| +#ifndef WL_DISPLAY_ERROR_ENUM
|
| +#define WL_DISPLAY_ERROR_ENUM
|
| +/**
|
| + * wl_display_error - global error values
|
| + * @WL_DISPLAY_ERROR_INVALID_OBJECT: server couldn't find object
|
| + * @WL_DISPLAY_ERROR_INVALID_METHOD: method doesn't exist on the
|
| + * specified interface
|
| + * @WL_DISPLAY_ERROR_NO_MEMORY: server is out of memory
|
| + *
|
| + * These errors are global and can be emitted in response to any server
|
| + * request.
|
| + */
|
| +enum wl_display_error {
|
| + WL_DISPLAY_ERROR_INVALID_OBJECT = 0,
|
| + WL_DISPLAY_ERROR_INVALID_METHOD = 1,
|
| + WL_DISPLAY_ERROR_NO_MEMORY = 2,
|
| +};
|
| +#endif /* WL_DISPLAY_ERROR_ENUM */
|
| +
|
| +/**
|
| + * wl_display - core global object
|
| + * @sync: asynchronous roundtrip
|
| + * @get_registry: get global registry object
|
| + *
|
| + * The core global object. This is a special singleton object. It is used
|
| + * for internal Wayland protocol features.
|
| + */
|
| +struct wl_display_interface {
|
| + /**
|
| + * sync - asynchronous roundtrip
|
| + * @callback: (none)
|
| + *
|
| + * The sync request asks the server to emit the 'done' event on
|
| + * the returned wl_callback object. Since requests are handled
|
| + * in-order and events are delivered in-order, this can be used as
|
| + * a barrier to ensure all previous requests and the resulting
|
| + * events have been handled.
|
| + *
|
| + * The object returned by this request will be destroyed by the
|
| + * compositor after the callback is fired and as such the client
|
| + * must not attempt to use it after that point.
|
| + *
|
| + * The callback_data passed in the callback is the event serial.
|
| + */
|
| + void (*sync)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t callback);
|
| + /**
|
| + * get_registry - get global registry object
|
| + * @registry: (none)
|
| + *
|
| + * This request creates a registry object that allows the client
|
| + * to list and bind the global objects available from the
|
| + * compositor.
|
| + */
|
| + void (*get_registry)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t registry);
|
| +};
|
| +
|
| +#define WL_DISPLAY_ERROR 0
|
| +#define WL_DISPLAY_DELETE_ID 1
|
| +
|
| +#define WL_DISPLAY_ERROR_SINCE_VERSION 1
|
| +#define WL_DISPLAY_DELETE_ID_SINCE_VERSION 1
|
| +
|
| +/**
|
| + * wl_registry - global registry object
|
| + * @bind: bind an object to the display
|
| + *
|
| + * The global registry object. The server has a number of global objects
|
| + * that are available to all clients. These objects typically represent an
|
| + * actual object in the server (for example, an input device) or they are
|
| + * singleton objects that provide extension functionality.
|
| + *
|
| + * When a client creates a registry object, the registry object will emit a
|
| + * global event for each global currently in the registry. Globals come and
|
| + * go as a result of device or monitor hotplugs, reconfiguration or other
|
| + * events, and the registry will send out global and global_remove events
|
| + * to keep the client up to date with the changes. To mark the end of the
|
| + * initial burst of events, the client can use the wl_display.sync request
|
| + * immediately after calling wl_display.get_registry.
|
| + *
|
| + * A client can bind to a global object by using the bind request. This
|
| + * creates a client-side handle that lets the object emit events to the
|
| + * client and lets the client invoke requests on the object.
|
| + */
|
| +struct wl_registry_interface {
|
| + /**
|
| + * bind - bind an object to the display
|
| + * @name: unique name for the object
|
| + * @interface: name of the objects interface
|
| + * @version: version of the objects interface
|
| + * @id: (none)
|
| + *
|
| + * Binds a new, client-created object to the server using the
|
| + * specified name as the identifier.
|
| + */
|
| + void (*bind)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t name,
|
| + const char *interface, uint32_t version, uint32_t id);
|
| +};
|
| +
|
| +#define WL_REGISTRY_GLOBAL 0
|
| +#define WL_REGISTRY_GLOBAL_REMOVE 1
|
| +
|
| +#define WL_REGISTRY_GLOBAL_SINCE_VERSION 1
|
| +#define WL_REGISTRY_GLOBAL_REMOVE_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_registry_send_global(struct wl_resource *resource_, uint32_t name, const char *interface, uint32_t version)
|
| +{
|
| + wl_resource_post_event(resource_, WL_REGISTRY_GLOBAL, name, interface, version);
|
| +}
|
| +
|
| +static inline void
|
| +wl_registry_send_global_remove(struct wl_resource *resource_, uint32_t name)
|
| +{
|
| + wl_resource_post_event(resource_, WL_REGISTRY_GLOBAL_REMOVE, name);
|
| +}
|
| +
|
| +#define WL_CALLBACK_DONE 0
|
| +
|
| +#define WL_CALLBACK_DONE_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_callback_send_done(struct wl_resource *resource_, uint32_t callback_data)
|
| +{
|
| + wl_resource_post_event(resource_, WL_CALLBACK_DONE, callback_data);
|
| +}
|
| +
|
| +/**
|
| + * wl_compositor - the compositor singleton
|
| + * @create_surface: create new surface
|
| + * @create_region: create new region
|
| + *
|
| + * A compositor. This object is a singleton global. The compositor is in
|
| + * charge of combining the contents of multiple surfaces into one
|
| + * displayable output.
|
| + */
|
| +struct wl_compositor_interface {
|
| + /**
|
| + * create_surface - create new surface
|
| + * @id: (none)
|
| + *
|
| + * Ask the compositor to create a new surface.
|
| + */
|
| + void (*create_surface)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id);
|
| + /**
|
| + * create_region - create new region
|
| + * @id: (none)
|
| + *
|
| + * Ask the compositor to create a new region.
|
| + */
|
| + void (*create_region)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id);
|
| +};
|
| +
|
| +
|
| +/**
|
| + * wl_shm_pool - a shared memory pool
|
| + * @create_buffer: create a buffer from the pool
|
| + * @destroy: destroy the pool
|
| + * @resize: change the size of the pool mapping
|
| + *
|
| + * The wl_shm_pool object encapsulates a piece of memory shared between
|
| + * the compositor and client. Through the wl_shm_pool object, the client
|
| + * can allocate shared memory wl_buffer objects. All objects created
|
| + * through the same pool share the same underlying mapped memory. Reusing
|
| + * the mapped memory avoids the setup/teardown overhead and is useful when
|
| + * interactively resizing a surface or for many small buffers.
|
| + */
|
| +struct wl_shm_pool_interface {
|
| + /**
|
| + * create_buffer - create a buffer from the pool
|
| + * @id: (none)
|
| + * @offset: (none)
|
| + * @width: (none)
|
| + * @height: (none)
|
| + * @stride: (none)
|
| + * @format: (none)
|
| + *
|
| + * Create a wl_buffer object from the pool.
|
| + *
|
| + * The buffer is created offset bytes into the pool and has width
|
| + * and height as specified. The stride arguments specifies the
|
| + * number of bytes from beginning of one row to the beginning of
|
| + * the next. The format is the pixel format of the buffer and must
|
| + * be one of those advertised through the wl_shm.format event.
|
| + *
|
| + * A buffer will keep a reference to the pool it was created from
|
| + * so it is valid to destroy the pool immediately after creating a
|
| + * buffer from it.
|
| + */
|
| + void (*create_buffer)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id,
|
| + int32_t offset,
|
| + int32_t width,
|
| + int32_t height,
|
| + int32_t stride,
|
| + uint32_t format);
|
| + /**
|
| + * destroy - destroy the pool
|
| + *
|
| + * Destroy the shared memory pool.
|
| + *
|
| + * The mmapped memory will be released when all buffers that have
|
| + * been created from this pool are gone.
|
| + */
|
| + void (*destroy)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| + /**
|
| + * resize - change the size of the pool mapping
|
| + * @size: (none)
|
| + *
|
| + * This request will cause the server to remap the backing memory
|
| + * for the pool from the file descriptor passed when the pool was
|
| + * created, but using the new size. This request can only be used
|
| + * to make the pool bigger.
|
| + */
|
| + void (*resize)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + int32_t size);
|
| +};
|
| +
|
| +
|
| +#ifndef WL_SHM_ERROR_ENUM
|
| +#define WL_SHM_ERROR_ENUM
|
| +/**
|
| + * wl_shm_error - wl_shm error values
|
| + * @WL_SHM_ERROR_INVALID_FORMAT: buffer format is not known
|
| + * @WL_SHM_ERROR_INVALID_STRIDE: invalid size or stride during pool or
|
| + * buffer creation
|
| + * @WL_SHM_ERROR_INVALID_FD: mmapping the file descriptor failed
|
| + *
|
| + * These errors can be emitted in response to wl_shm requests.
|
| + */
|
| +enum wl_shm_error {
|
| + WL_SHM_ERROR_INVALID_FORMAT = 0,
|
| + WL_SHM_ERROR_INVALID_STRIDE = 1,
|
| + WL_SHM_ERROR_INVALID_FD = 2,
|
| +};
|
| +#endif /* WL_SHM_ERROR_ENUM */
|
| +
|
| +#ifndef WL_SHM_FORMAT_ENUM
|
| +#define WL_SHM_FORMAT_ENUM
|
| +/**
|
| + * wl_shm_format - pixel formats
|
| + * @WL_SHM_FORMAT_ARGB8888: 32-bit ARGB format
|
| + * @WL_SHM_FORMAT_XRGB8888: 32-bit RGB format
|
| + * @WL_SHM_FORMAT_C8: (none)
|
| + * @WL_SHM_FORMAT_RGB332: (none)
|
| + * @WL_SHM_FORMAT_BGR233: (none)
|
| + * @WL_SHM_FORMAT_XRGB4444: (none)
|
| + * @WL_SHM_FORMAT_XBGR4444: (none)
|
| + * @WL_SHM_FORMAT_RGBX4444: (none)
|
| + * @WL_SHM_FORMAT_BGRX4444: (none)
|
| + * @WL_SHM_FORMAT_ARGB4444: (none)
|
| + * @WL_SHM_FORMAT_ABGR4444: (none)
|
| + * @WL_SHM_FORMAT_RGBA4444: (none)
|
| + * @WL_SHM_FORMAT_BGRA4444: (none)
|
| + * @WL_SHM_FORMAT_XRGB1555: (none)
|
| + * @WL_SHM_FORMAT_XBGR1555: (none)
|
| + * @WL_SHM_FORMAT_RGBX5551: (none)
|
| + * @WL_SHM_FORMAT_BGRX5551: (none)
|
| + * @WL_SHM_FORMAT_ARGB1555: (none)
|
| + * @WL_SHM_FORMAT_ABGR1555: (none)
|
| + * @WL_SHM_FORMAT_RGBA5551: (none)
|
| + * @WL_SHM_FORMAT_BGRA5551: (none)
|
| + * @WL_SHM_FORMAT_RGB565: (none)
|
| + * @WL_SHM_FORMAT_BGR565: (none)
|
| + * @WL_SHM_FORMAT_RGB888: (none)
|
| + * @WL_SHM_FORMAT_BGR888: (none)
|
| + * @WL_SHM_FORMAT_XBGR8888: (none)
|
| + * @WL_SHM_FORMAT_RGBX8888: (none)
|
| + * @WL_SHM_FORMAT_BGRX8888: (none)
|
| + * @WL_SHM_FORMAT_ABGR8888: (none)
|
| + * @WL_SHM_FORMAT_RGBA8888: (none)
|
| + * @WL_SHM_FORMAT_BGRA8888: (none)
|
| + * @WL_SHM_FORMAT_XRGB2101010: (none)
|
| + * @WL_SHM_FORMAT_XBGR2101010: (none)
|
| + * @WL_SHM_FORMAT_RGBX1010102: (none)
|
| + * @WL_SHM_FORMAT_BGRX1010102: (none)
|
| + * @WL_SHM_FORMAT_ARGB2101010: (none)
|
| + * @WL_SHM_FORMAT_ABGR2101010: (none)
|
| + * @WL_SHM_FORMAT_RGBA1010102: (none)
|
| + * @WL_SHM_FORMAT_BGRA1010102: (none)
|
| + * @WL_SHM_FORMAT_YUYV: (none)
|
| + * @WL_SHM_FORMAT_YVYU: (none)
|
| + * @WL_SHM_FORMAT_UYVY: (none)
|
| + * @WL_SHM_FORMAT_VYUY: (none)
|
| + * @WL_SHM_FORMAT_AYUV: (none)
|
| + * @WL_SHM_FORMAT_NV12: (none)
|
| + * @WL_SHM_FORMAT_NV21: (none)
|
| + * @WL_SHM_FORMAT_NV16: (none)
|
| + * @WL_SHM_FORMAT_NV61: (none)
|
| + * @WL_SHM_FORMAT_YUV410: (none)
|
| + * @WL_SHM_FORMAT_YVU410: (none)
|
| + * @WL_SHM_FORMAT_YUV411: (none)
|
| + * @WL_SHM_FORMAT_YVU411: (none)
|
| + * @WL_SHM_FORMAT_YUV420: (none)
|
| + * @WL_SHM_FORMAT_YVU420: (none)
|
| + * @WL_SHM_FORMAT_YUV422: (none)
|
| + * @WL_SHM_FORMAT_YVU422: (none)
|
| + * @WL_SHM_FORMAT_YUV444: (none)
|
| + * @WL_SHM_FORMAT_YVU444: (none)
|
| + *
|
| + * This describes the memory layout of an individual pixel.
|
| + *
|
| + * All renderers should support argb8888 and xrgb8888 but any other formats
|
| + * are optional and may not be supported by the particular renderer in use.
|
| + */
|
| +enum wl_shm_format {
|
| + WL_SHM_FORMAT_ARGB8888 = 0,
|
| + WL_SHM_FORMAT_XRGB8888 = 1,
|
| + WL_SHM_FORMAT_C8 = 0x20203843,
|
| + WL_SHM_FORMAT_RGB332 = 0x38424752,
|
| + WL_SHM_FORMAT_BGR233 = 0x38524742,
|
| + WL_SHM_FORMAT_XRGB4444 = 0x32315258,
|
| + WL_SHM_FORMAT_XBGR4444 = 0x32314258,
|
| + WL_SHM_FORMAT_RGBX4444 = 0x32315852,
|
| + WL_SHM_FORMAT_BGRX4444 = 0x32315842,
|
| + WL_SHM_FORMAT_ARGB4444 = 0x32315241,
|
| + WL_SHM_FORMAT_ABGR4444 = 0x32314241,
|
| + WL_SHM_FORMAT_RGBA4444 = 0x32314152,
|
| + WL_SHM_FORMAT_BGRA4444 = 0x32314142,
|
| + WL_SHM_FORMAT_XRGB1555 = 0x35315258,
|
| + WL_SHM_FORMAT_XBGR1555 = 0x35314258,
|
| + WL_SHM_FORMAT_RGBX5551 = 0x35315852,
|
| + WL_SHM_FORMAT_BGRX5551 = 0x35315842,
|
| + WL_SHM_FORMAT_ARGB1555 = 0x35315241,
|
| + WL_SHM_FORMAT_ABGR1555 = 0x35314241,
|
| + WL_SHM_FORMAT_RGBA5551 = 0x35314152,
|
| + WL_SHM_FORMAT_BGRA5551 = 0x35314142,
|
| + WL_SHM_FORMAT_RGB565 = 0x36314752,
|
| + WL_SHM_FORMAT_BGR565 = 0x36314742,
|
| + WL_SHM_FORMAT_RGB888 = 0x34324752,
|
| + WL_SHM_FORMAT_BGR888 = 0x34324742,
|
| + WL_SHM_FORMAT_XBGR8888 = 0x34324258,
|
| + WL_SHM_FORMAT_RGBX8888 = 0x34325852,
|
| + WL_SHM_FORMAT_BGRX8888 = 0x34325842,
|
| + WL_SHM_FORMAT_ABGR8888 = 0x34324241,
|
| + WL_SHM_FORMAT_RGBA8888 = 0x34324152,
|
| + WL_SHM_FORMAT_BGRA8888 = 0x34324142,
|
| + WL_SHM_FORMAT_XRGB2101010 = 0x30335258,
|
| + WL_SHM_FORMAT_XBGR2101010 = 0x30334258,
|
| + WL_SHM_FORMAT_RGBX1010102 = 0x30335852,
|
| + WL_SHM_FORMAT_BGRX1010102 = 0x30335842,
|
| + WL_SHM_FORMAT_ARGB2101010 = 0x30335241,
|
| + WL_SHM_FORMAT_ABGR2101010 = 0x30334241,
|
| + WL_SHM_FORMAT_RGBA1010102 = 0x30334152,
|
| + WL_SHM_FORMAT_BGRA1010102 = 0x30334142,
|
| + WL_SHM_FORMAT_YUYV = 0x56595559,
|
| + WL_SHM_FORMAT_YVYU = 0x55595659,
|
| + WL_SHM_FORMAT_UYVY = 0x59565955,
|
| + WL_SHM_FORMAT_VYUY = 0x59555956,
|
| + WL_SHM_FORMAT_AYUV = 0x56555941,
|
| + WL_SHM_FORMAT_NV12 = 0x3231564e,
|
| + WL_SHM_FORMAT_NV21 = 0x3132564e,
|
| + WL_SHM_FORMAT_NV16 = 0x3631564e,
|
| + WL_SHM_FORMAT_NV61 = 0x3136564e,
|
| + WL_SHM_FORMAT_YUV410 = 0x39565559,
|
| + WL_SHM_FORMAT_YVU410 = 0x39555659,
|
| + WL_SHM_FORMAT_YUV411 = 0x31315559,
|
| + WL_SHM_FORMAT_YVU411 = 0x31315659,
|
| + WL_SHM_FORMAT_YUV420 = 0x32315559,
|
| + WL_SHM_FORMAT_YVU420 = 0x32315659,
|
| + WL_SHM_FORMAT_YUV422 = 0x36315559,
|
| + WL_SHM_FORMAT_YVU422 = 0x36315659,
|
| + WL_SHM_FORMAT_YUV444 = 0x34325559,
|
| + WL_SHM_FORMAT_YVU444 = 0x34325659,
|
| +};
|
| +#endif /* WL_SHM_FORMAT_ENUM */
|
| +
|
| +/**
|
| + * wl_shm - shared memory support
|
| + * @create_pool: create a shm pool
|
| + *
|
| + * A global singleton object that provides support for shared memory.
|
| + *
|
| + * Clients can create wl_shm_pool objects using the create_pool request.
|
| + *
|
| + * At connection setup time, the wl_shm object emits one or more format
|
| + * events to inform clients about the valid pixel formats that can be used
|
| + * for buffers.
|
| + */
|
| +struct wl_shm_interface {
|
| + /**
|
| + * create_pool - create a shm pool
|
| + * @id: (none)
|
| + * @fd: (none)
|
| + * @size: (none)
|
| + *
|
| + * Create a new wl_shm_pool object.
|
| + *
|
| + * The pool can be used to create shared memory based buffer
|
| + * objects. The server will mmap size bytes of the passed file
|
| + * descriptor, to use as backing memory for the pool.
|
| + */
|
| + void (*create_pool)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id,
|
| + int32_t fd,
|
| + int32_t size);
|
| +};
|
| +
|
| +#define WL_SHM_FORMAT 0
|
| +
|
| +#define WL_SHM_FORMAT_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_shm_send_format(struct wl_resource *resource_, uint32_t format)
|
| +{
|
| + wl_resource_post_event(resource_, WL_SHM_FORMAT, format);
|
| +}
|
| +
|
| +/**
|
| + * wl_buffer - content for a wl_surface
|
| + * @destroy: destroy a buffer
|
| + *
|
| + * A buffer provides the content for a wl_surface. Buffers are created
|
| + * through factory interfaces such as wl_drm, wl_shm or similar. It has a
|
| + * width and a height and can be attached to a wl_surface, but the
|
| + * mechanism by which a client provides and updates the contents is defined
|
| + * by the buffer factory interface.
|
| + */
|
| +struct wl_buffer_interface {
|
| + /**
|
| + * destroy - destroy a buffer
|
| + *
|
| + * Destroy a buffer. If and how you need to release the backing
|
| + * storage is defined by the buffer factory interface.
|
| + *
|
| + * For possible side-effects to a surface, see wl_surface.attach.
|
| + */
|
| + void (*destroy)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| +};
|
| +
|
| +#define WL_BUFFER_RELEASE 0
|
| +
|
| +#define WL_BUFFER_RELEASE_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_buffer_send_release(struct wl_resource *resource_)
|
| +{
|
| + wl_resource_post_event(resource_, WL_BUFFER_RELEASE);
|
| +}
|
| +
|
| +/**
|
| + * wl_data_offer - offer to transfer data
|
| + * @accept: accept one of the offered mime types
|
| + * @receive: request that the data is transferred
|
| + * @destroy: destroy data offer
|
| + *
|
| + * A wl_data_offer represents a piece of data offered for transfer by
|
| + * another client (the source client). It is used by the copy-and-paste and
|
| + * drag-and-drop mechanisms. The offer describes the different mime types
|
| + * that the data can be converted to and provides the mechanism for
|
| + * transferring the data directly from the source client.
|
| + */
|
| +struct wl_data_offer_interface {
|
| + /**
|
| + * accept - accept one of the offered mime types
|
| + * @serial: (none)
|
| + * @mime_type: (none)
|
| + *
|
| + * Indicate that the client can accept the given mime type, or
|
| + * NULL for not accepted.
|
| + *
|
| + * Used for feedback during drag-and-drop.
|
| + */
|
| + void (*accept)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t serial,
|
| + const char *mime_type);
|
| + /**
|
| + * receive - request that the data is transferred
|
| + * @mime_type: (none)
|
| + * @fd: (none)
|
| + *
|
| + * To transfer the offered data, the client issues this request
|
| + * and indicates the mime type it wants to receive. The transfer
|
| + * happens through the passed file descriptor (typically created
|
| + * with the pipe system call). The source client writes the data in
|
| + * the mime type representation requested and then closes the file
|
| + * descriptor.
|
| + *
|
| + * The receiving client reads from the read end of the pipe until
|
| + * EOF and then closes its end, at which point the transfer is
|
| + * complete.
|
| + */
|
| + void (*receive)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + const char *mime_type,
|
| + int32_t fd);
|
| + /**
|
| + * destroy - destroy data offer
|
| + *
|
| + * Destroy the data offer.
|
| + */
|
| + void (*destroy)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| +};
|
| +
|
| +#define WL_DATA_OFFER_OFFER 0
|
| +
|
| +#define WL_DATA_OFFER_OFFER_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_data_offer_send_offer(struct wl_resource *resource_, const char *mime_type)
|
| +{
|
| + wl_resource_post_event(resource_, WL_DATA_OFFER_OFFER, mime_type);
|
| +}
|
| +
|
| +/**
|
| + * wl_data_source - offer to transfer data
|
| + * @offer: add an offered mime type
|
| + * @destroy: destroy the data source
|
| + *
|
| + * The wl_data_source object is the source side of a wl_data_offer. It is
|
| + * created by the source client in a data transfer and provides a way to
|
| + * describe the offered data and a way to respond to requests to transfer
|
| + * the data.
|
| + */
|
| +struct wl_data_source_interface {
|
| + /**
|
| + * offer - add an offered mime type
|
| + * @mime_type: (none)
|
| + *
|
| + * This request adds a mime type to the set of mime types
|
| + * advertised to targets. Can be called several times to offer
|
| + * multiple types.
|
| + */
|
| + void (*offer)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + const char *mime_type);
|
| + /**
|
| + * destroy - destroy the data source
|
| + *
|
| + * Destroy the data source.
|
| + */
|
| + void (*destroy)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| +};
|
| +
|
| +#define WL_DATA_SOURCE_TARGET 0
|
| +#define WL_DATA_SOURCE_SEND 1
|
| +#define WL_DATA_SOURCE_CANCELLED 2
|
| +
|
| +#define WL_DATA_SOURCE_TARGET_SINCE_VERSION 1
|
| +#define WL_DATA_SOURCE_SEND_SINCE_VERSION 1
|
| +#define WL_DATA_SOURCE_CANCELLED_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_data_source_send_target(struct wl_resource *resource_, const char *mime_type)
|
| +{
|
| + wl_resource_post_event(resource_, WL_DATA_SOURCE_TARGET, mime_type);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_source_send_send(struct wl_resource *resource_, const char *mime_type, int32_t fd)
|
| +{
|
| + wl_resource_post_event(resource_, WL_DATA_SOURCE_SEND, mime_type, fd);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_source_send_cancelled(struct wl_resource *resource_)
|
| +{
|
| + wl_resource_post_event(resource_, WL_DATA_SOURCE_CANCELLED);
|
| +}
|
| +
|
| +#ifndef WL_DATA_DEVICE_ERROR_ENUM
|
| +#define WL_DATA_DEVICE_ERROR_ENUM
|
| +enum wl_data_device_error {
|
| + WL_DATA_DEVICE_ERROR_ROLE = 0,
|
| +};
|
| +#endif /* WL_DATA_DEVICE_ERROR_ENUM */
|
| +
|
| +/**
|
| + * wl_data_device - data transfer device
|
| + * @start_drag: start drag-and-drop operation
|
| + * @set_selection: copy data to the selection
|
| + * @release: destroy data device
|
| + *
|
| + * There is one wl_data_device per seat which can be obtained from the
|
| + * global wl_data_device_manager singleton.
|
| + *
|
| + * A wl_data_device provides access to inter-client data transfer
|
| + * mechanisms such as copy-and-paste and drag-and-drop.
|
| + */
|
| +struct wl_data_device_interface {
|
| + /**
|
| + * start_drag - start drag-and-drop operation
|
| + * @source: (none)
|
| + * @origin: (none)
|
| + * @icon: (none)
|
| + * @serial: serial of the implicit grab on the origin
|
| + *
|
| + * This request asks the compositor to start a drag-and-drop
|
| + * operation on behalf of the client.
|
| + *
|
| + * The source argument is the data source that provides the data
|
| + * for the eventual data transfer. If source is NULL, enter, leave
|
| + * and motion events are sent only to the client that initiated the
|
| + * drag and the client is expected to handle the data passing
|
| + * internally.
|
| + *
|
| + * The origin surface is the surface where the drag originates and
|
| + * the client must have an active implicit grab that matches the
|
| + * serial.
|
| + *
|
| + * The icon surface is an optional (can be NULL) surface that
|
| + * provides an icon to be moved around with the cursor. Initially,
|
| + * the top-left corner of the icon surface is placed at the cursor
|
| + * hotspot, but subsequent wl_surface.attach request can move the
|
| + * relative position. Attach requests must be confirmed with
|
| + * wl_surface.commit as usual. The icon surface is given the role
|
| + * of a drag-and-drop icon. If the icon surface already has another
|
| + * role, it raises a protocol error.
|
| + *
|
| + * The current and pending input regions of the icon wl_surface are
|
| + * cleared, and wl_surface.set_input_region is ignored until the
|
| + * wl_surface is no longer used as the icon surface. When the use
|
| + * as an icon ends, the current and pending input regions become
|
| + * undefined, and the wl_surface is unmapped.
|
| + */
|
| + void (*start_drag)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *source,
|
| + struct wl_resource *origin,
|
| + struct wl_resource *icon,
|
| + uint32_t serial);
|
| + /**
|
| + * set_selection - copy data to the selection
|
| + * @source: (none)
|
| + * @serial: serial of the event that triggered this request
|
| + *
|
| + * This request asks the compositor to set the selection to the
|
| + * data from the source on behalf of the client.
|
| + *
|
| + * To unset the selection, set the source to NULL.
|
| + */
|
| + void (*set_selection)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *source,
|
| + uint32_t serial);
|
| + /**
|
| + * release - destroy data device
|
| + *
|
| + * This request destroys the data device.
|
| + * @since: 2
|
| + */
|
| + void (*release)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| +};
|
| +
|
| +#define WL_DATA_DEVICE_DATA_OFFER 0
|
| +#define WL_DATA_DEVICE_ENTER 1
|
| +#define WL_DATA_DEVICE_LEAVE 2
|
| +#define WL_DATA_DEVICE_MOTION 3
|
| +#define WL_DATA_DEVICE_DROP 4
|
| +#define WL_DATA_DEVICE_SELECTION 5
|
| +
|
| +#define WL_DATA_DEVICE_DATA_OFFER_SINCE_VERSION 1
|
| +#define WL_DATA_DEVICE_ENTER_SINCE_VERSION 1
|
| +#define WL_DATA_DEVICE_LEAVE_SINCE_VERSION 1
|
| +#define WL_DATA_DEVICE_MOTION_SINCE_VERSION 1
|
| +#define WL_DATA_DEVICE_DROP_SINCE_VERSION 1
|
| +#define WL_DATA_DEVICE_SELECTION_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_data_device_send_data_offer(struct wl_resource *resource_, struct wl_resource *id)
|
| +{
|
| + wl_resource_post_event(resource_, WL_DATA_DEVICE_DATA_OFFER, id);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_device_send_enter(struct wl_resource *resource_, uint32_t serial, struct wl_resource *surface, wl_fixed_t x, wl_fixed_t y, struct wl_resource *id)
|
| +{
|
| + wl_resource_post_event(resource_, WL_DATA_DEVICE_ENTER, serial, surface, x, y, id);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_device_send_leave(struct wl_resource *resource_)
|
| +{
|
| + wl_resource_post_event(resource_, WL_DATA_DEVICE_LEAVE);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_device_send_motion(struct wl_resource *resource_, uint32_t time, wl_fixed_t x, wl_fixed_t y)
|
| +{
|
| + wl_resource_post_event(resource_, WL_DATA_DEVICE_MOTION, time, x, y);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_device_send_drop(struct wl_resource *resource_)
|
| +{
|
| + wl_resource_post_event(resource_, WL_DATA_DEVICE_DROP);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_device_send_selection(struct wl_resource *resource_, struct wl_resource *id)
|
| +{
|
| + wl_resource_post_event(resource_, WL_DATA_DEVICE_SELECTION, id);
|
| +}
|
| +
|
| +/**
|
| + * wl_data_device_manager - data transfer interface
|
| + * @create_data_source: create a new data source
|
| + * @get_data_device: create a new data device
|
| + *
|
| + * The wl_data_device_manager is a singleton global object that provides
|
| + * access to inter-client data transfer mechanisms such as copy-and-paste
|
| + * and drag-and-drop. These mechanisms are tied to a wl_seat and this
|
| + * interface lets a client get a wl_data_device corresponding to a wl_seat.
|
| + */
|
| +struct wl_data_device_manager_interface {
|
| + /**
|
| + * create_data_source - create a new data source
|
| + * @id: (none)
|
| + *
|
| + * Create a new data source.
|
| + */
|
| + void (*create_data_source)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id);
|
| + /**
|
| + * get_data_device - create a new data device
|
| + * @id: (none)
|
| + * @seat: (none)
|
| + *
|
| + * Create a new data device for a given seat.
|
| + */
|
| + void (*get_data_device)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id,
|
| + struct wl_resource *seat);
|
| +};
|
| +
|
| +
|
| +#ifndef WL_SHELL_ERROR_ENUM
|
| +#define WL_SHELL_ERROR_ENUM
|
| +enum wl_shell_error {
|
| + WL_SHELL_ERROR_ROLE = 0,
|
| +};
|
| +#endif /* WL_SHELL_ERROR_ENUM */
|
| +
|
| +/**
|
| + * wl_shell - create desktop-style surfaces
|
| + * @get_shell_surface: create a shell surface from a surface
|
| + *
|
| + * This interface is implemented by servers that provide desktop-style
|
| + * user interfaces.
|
| + *
|
| + * It allows clients to associate a wl_shell_surface with a basic surface.
|
| + */
|
| +struct wl_shell_interface {
|
| + /**
|
| + * get_shell_surface - create a shell surface from a surface
|
| + * @id: (none)
|
| + * @surface: (none)
|
| + *
|
| + * Create a shell surface for an existing surface. This gives the
|
| + * wl_surface the role of a shell surface. If the wl_surface
|
| + * already has another role, it raises a protocol error.
|
| + *
|
| + * Only one shell surface can be associated with a given surface.
|
| + */
|
| + void (*get_shell_surface)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id,
|
| + struct wl_resource *surface);
|
| +};
|
| +
|
| +
|
| +#ifndef WL_SHELL_SURFACE_RESIZE_ENUM
|
| +#define WL_SHELL_SURFACE_RESIZE_ENUM
|
| +/**
|
| + * wl_shell_surface_resize - edge values for resizing
|
| + * @WL_SHELL_SURFACE_RESIZE_NONE: (none)
|
| + * @WL_SHELL_SURFACE_RESIZE_TOP: (none)
|
| + * @WL_SHELL_SURFACE_RESIZE_BOTTOM: (none)
|
| + * @WL_SHELL_SURFACE_RESIZE_LEFT: (none)
|
| + * @WL_SHELL_SURFACE_RESIZE_TOP_LEFT: (none)
|
| + * @WL_SHELL_SURFACE_RESIZE_BOTTOM_LEFT: (none)
|
| + * @WL_SHELL_SURFACE_RESIZE_RIGHT: (none)
|
| + * @WL_SHELL_SURFACE_RESIZE_TOP_RIGHT: (none)
|
| + * @WL_SHELL_SURFACE_RESIZE_BOTTOM_RIGHT: (none)
|
| + *
|
| + * These values are used to indicate which edge of a surface is being
|
| + * dragged in a resize operation. The server may use this information to
|
| + * adapt its behavior, e.g. choose an appropriate cursor image.
|
| + */
|
| +enum wl_shell_surface_resize {
|
| + WL_SHELL_SURFACE_RESIZE_NONE = 0,
|
| + WL_SHELL_SURFACE_RESIZE_TOP = 1,
|
| + WL_SHELL_SURFACE_RESIZE_BOTTOM = 2,
|
| + WL_SHELL_SURFACE_RESIZE_LEFT = 4,
|
| + WL_SHELL_SURFACE_RESIZE_TOP_LEFT = 5,
|
| + WL_SHELL_SURFACE_RESIZE_BOTTOM_LEFT = 6,
|
| + WL_SHELL_SURFACE_RESIZE_RIGHT = 8,
|
| + WL_SHELL_SURFACE_RESIZE_TOP_RIGHT = 9,
|
| + WL_SHELL_SURFACE_RESIZE_BOTTOM_RIGHT = 10,
|
| +};
|
| +#endif /* WL_SHELL_SURFACE_RESIZE_ENUM */
|
| +
|
| +#ifndef WL_SHELL_SURFACE_TRANSIENT_ENUM
|
| +#define WL_SHELL_SURFACE_TRANSIENT_ENUM
|
| +/**
|
| + * wl_shell_surface_transient - details of transient behaviour
|
| + * @WL_SHELL_SURFACE_TRANSIENT_INACTIVE: do not set keyboard focus
|
| + *
|
| + * These flags specify details of the expected behaviour of transient
|
| + * surfaces. Used in the set_transient request.
|
| + */
|
| +enum wl_shell_surface_transient {
|
| + WL_SHELL_SURFACE_TRANSIENT_INACTIVE = 0x1,
|
| +};
|
| +#endif /* WL_SHELL_SURFACE_TRANSIENT_ENUM */
|
| +
|
| +#ifndef WL_SHELL_SURFACE_FULLSCREEN_METHOD_ENUM
|
| +#define WL_SHELL_SURFACE_FULLSCREEN_METHOD_ENUM
|
| +/**
|
| + * wl_shell_surface_fullscreen_method - different method to set the
|
| + * surface fullscreen
|
| + * @WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT: no preference, apply
|
| + * default policy
|
| + * @WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE: scale, preserve the
|
| + * surface's aspect ratio and center on output
|
| + * @WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER: switch output mode to the
|
| + * smallest mode that can fit the surface, add black borders to compensate
|
| + * size mismatch
|
| + * @WL_SHELL_SURFACE_FULLSCREEN_METHOD_FILL: no upscaling, center on
|
| + * output and add black borders to compensate size mismatch
|
| + *
|
| + * Hints to indicate to the compositor how to deal with a conflict
|
| + * between the dimensions of the surface and the dimensions of the output.
|
| + * The compositor is free to ignore this parameter.
|
| + */
|
| +enum wl_shell_surface_fullscreen_method {
|
| + WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT = 0,
|
| + WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE = 1,
|
| + WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER = 2,
|
| + WL_SHELL_SURFACE_FULLSCREEN_METHOD_FILL = 3,
|
| +};
|
| +#endif /* WL_SHELL_SURFACE_FULLSCREEN_METHOD_ENUM */
|
| +
|
| +/**
|
| + * wl_shell_surface - desktop-style metadata interface
|
| + * @pong: respond to a ping event
|
| + * @move: start an interactive move
|
| + * @resize: start an interactive resize
|
| + * @set_toplevel: make the surface a toplevel surface
|
| + * @set_transient: make the surface a transient surface
|
| + * @set_fullscreen: make the surface a fullscreen surface
|
| + * @set_popup: make the surface a popup surface
|
| + * @set_maximized: make the surface a maximized surface
|
| + * @set_title: set surface title
|
| + * @set_class: set surface class
|
| + *
|
| + * An interface that may be implemented by a wl_surface, for
|
| + * implementations that provide a desktop-style user interface.
|
| + *
|
| + * It provides requests to treat surfaces like toplevel, fullscreen or
|
| + * popup windows, move, resize or maximize them, associate metadata like
|
| + * title and class, etc.
|
| + *
|
| + * On the server side the object is automatically destroyed when the
|
| + * related wl_surface is destroyed. On client side,
|
| + * wl_shell_surface_destroy() must be called before destroying the
|
| + * wl_surface object.
|
| + */
|
| +struct wl_shell_surface_interface {
|
| + /**
|
| + * pong - respond to a ping event
|
| + * @serial: serial of the ping event
|
| + *
|
| + * A client must respond to a ping event with a pong request or
|
| + * the client may be deemed unresponsive.
|
| + */
|
| + void (*pong)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t serial);
|
| + /**
|
| + * move - start an interactive move
|
| + * @seat: the wl_seat whose pointer is used
|
| + * @serial: serial of the implicit grab on the pointer
|
| + *
|
| + * Start a pointer-driven move of the surface.
|
| + *
|
| + * This request must be used in response to a button press event.
|
| + * The server may ignore move requests depending on the state of
|
| + * the surface (e.g. fullscreen or maximized).
|
| + */
|
| + void (*move)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *seat,
|
| + uint32_t serial);
|
| + /**
|
| + * resize - start an interactive resize
|
| + * @seat: the wl_seat whose pointer is used
|
| + * @serial: serial of the implicit grab on the pointer
|
| + * @edges: which edge or corner is being dragged
|
| + *
|
| + * Start a pointer-driven resizing of the surface.
|
| + *
|
| + * This request must be used in response to a button press event.
|
| + * The server may ignore resize requests depending on the state of
|
| + * the surface (e.g. fullscreen or maximized).
|
| + */
|
| + void (*resize)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *seat,
|
| + uint32_t serial,
|
| + uint32_t edges);
|
| + /**
|
| + * set_toplevel - make the surface a toplevel surface
|
| + *
|
| + * Map the surface as a toplevel surface.
|
| + *
|
| + * A toplevel surface is not fullscreen, maximized or transient.
|
| + */
|
| + void (*set_toplevel)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| + /**
|
| + * set_transient - make the surface a transient surface
|
| + * @parent: (none)
|
| + * @x: (none)
|
| + * @y: (none)
|
| + * @flags: (none)
|
| + *
|
| + * Map the surface relative to an existing surface.
|
| + *
|
| + * The x and y arguments specify the locations of the upper left
|
| + * corner of the surface relative to the upper left corner of the
|
| + * parent surface, in surface local coordinates.
|
| + *
|
| + * The flags argument controls details of the transient behaviour.
|
| + */
|
| + void (*set_transient)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *parent,
|
| + int32_t x,
|
| + int32_t y,
|
| + uint32_t flags);
|
| + /**
|
| + * set_fullscreen - make the surface a fullscreen surface
|
| + * @method: (none)
|
| + * @framerate: (none)
|
| + * @output: (none)
|
| + *
|
| + * Map the surface as a fullscreen surface.
|
| + *
|
| + * If an output parameter is given then the surface will be made
|
| + * fullscreen on that output. If the client does not specify the
|
| + * output then the compositor will apply its policy - usually
|
| + * choosing the output on which the surface has the biggest surface
|
| + * area.
|
| + *
|
| + * The client may specify a method to resolve a size conflict
|
| + * between the output size and the surface size - this is provided
|
| + * through the method parameter.
|
| + *
|
| + * The framerate parameter is used only when the method is set to
|
| + * "driver", to indicate the preferred framerate. A value of 0
|
| + * indicates that the app does not care about framerate. The
|
| + * framerate is specified in mHz, that is framerate of 60000 is
|
| + * 60Hz.
|
| + *
|
| + * A method of "scale" or "driver" implies a scaling operation of
|
| + * the surface, either via a direct scaling operation or a change
|
| + * of the output mode. This will override any kind of output
|
| + * scaling, so that mapping a surface with a buffer size equal to
|
| + * the mode can fill the screen independent of buffer_scale.
|
| + *
|
| + * A method of "fill" means we don't scale up the buffer, however
|
| + * any output scale is applied. This means that you may run into an
|
| + * edge case where the application maps a buffer with the same size
|
| + * of the output mode but buffer_scale 1 (thus making a surface
|
| + * larger than the output). In this case it is allowed to downscale
|
| + * the results to fit the screen.
|
| + *
|
| + * The compositor must reply to this request with a configure event
|
| + * with the dimensions for the output on which the surface will be
|
| + * made fullscreen.
|
| + */
|
| + void (*set_fullscreen)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t method,
|
| + uint32_t framerate,
|
| + struct wl_resource *output);
|
| + /**
|
| + * set_popup - make the surface a popup surface
|
| + * @seat: the wl_seat whose pointer is used
|
| + * @serial: serial of the implicit grab on the pointer
|
| + * @parent: (none)
|
| + * @x: (none)
|
| + * @y: (none)
|
| + * @flags: (none)
|
| + *
|
| + * Map the surface as a popup.
|
| + *
|
| + * A popup surface is a transient surface with an added pointer
|
| + * grab.
|
| + *
|
| + * An existing implicit grab will be changed to owner-events mode,
|
| + * and the popup grab will continue after the implicit grab ends
|
| + * (i.e. releasing the mouse button does not cause the popup to be
|
| + * unmapped).
|
| + *
|
| + * The popup grab continues until the window is destroyed or a
|
| + * mouse button is pressed in any other clients window. A click in
|
| + * any of the clients surfaces is reported as normal, however,
|
| + * clicks in other clients surfaces will be discarded and trigger
|
| + * the callback.
|
| + *
|
| + * The x and y arguments specify the locations of the upper left
|
| + * corner of the surface relative to the upper left corner of the
|
| + * parent surface, in surface local coordinates.
|
| + */
|
| + void (*set_popup)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *seat,
|
| + uint32_t serial,
|
| + struct wl_resource *parent,
|
| + int32_t x,
|
| + int32_t y,
|
| + uint32_t flags);
|
| + /**
|
| + * set_maximized - make the surface a maximized surface
|
| + * @output: (none)
|
| + *
|
| + * Map the surface as a maximized surface.
|
| + *
|
| + * If an output parameter is given then the surface will be
|
| + * maximized on that output. If the client does not specify the
|
| + * output then the compositor will apply its policy - usually
|
| + * choosing the output on which the surface has the biggest surface
|
| + * area.
|
| + *
|
| + * The compositor will reply with a configure event telling the
|
| + * expected new surface size. The operation is completed on the
|
| + * next buffer attach to this surface.
|
| + *
|
| + * A maximized surface typically fills the entire output it is
|
| + * bound to, except for desktop element such as panels. This is the
|
| + * main difference between a maximized shell surface and a
|
| + * fullscreen shell surface.
|
| + *
|
| + * The details depend on the compositor implementation.
|
| + */
|
| + void (*set_maximized)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *output);
|
| + /**
|
| + * set_title - set surface title
|
| + * @title: (none)
|
| + *
|
| + * 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.
|
| + */
|
| + void (*set_title)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + const char *title);
|
| + /**
|
| + * set_class - set surface class
|
| + * @class_: (none)
|
| + *
|
| + * Set a class for the surface.
|
| + *
|
| + * The surface class identifies the general class of applications
|
| + * to which the surface belongs. A common convention is to use the
|
| + * file name (or the full path if it is a non-standard location) of
|
| + * the application's .desktop file as the class.
|
| + */
|
| + void (*set_class)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + const char *class_);
|
| +};
|
| +
|
| +#define WL_SHELL_SURFACE_PING 0
|
| +#define WL_SHELL_SURFACE_CONFIGURE 1
|
| +#define WL_SHELL_SURFACE_POPUP_DONE 2
|
| +
|
| +#define WL_SHELL_SURFACE_PING_SINCE_VERSION 1
|
| +#define WL_SHELL_SURFACE_CONFIGURE_SINCE_VERSION 1
|
| +#define WL_SHELL_SURFACE_POPUP_DONE_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_shell_surface_send_ping(struct wl_resource *resource_, uint32_t serial)
|
| +{
|
| + wl_resource_post_event(resource_, WL_SHELL_SURFACE_PING, serial);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_send_configure(struct wl_resource *resource_, uint32_t edges, int32_t width, int32_t height)
|
| +{
|
| + wl_resource_post_event(resource_, WL_SHELL_SURFACE_CONFIGURE, edges, width, height);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_send_popup_done(struct wl_resource *resource_)
|
| +{
|
| + wl_resource_post_event(resource_, WL_SHELL_SURFACE_POPUP_DONE);
|
| +}
|
| +
|
| +#ifndef WL_SURFACE_ERROR_ENUM
|
| +#define WL_SURFACE_ERROR_ENUM
|
| +/**
|
| + * wl_surface_error - wl_surface error values
|
| + * @WL_SURFACE_ERROR_INVALID_SCALE: buffer scale value is invalid
|
| + * @WL_SURFACE_ERROR_INVALID_TRANSFORM: buffer transform value is invalid
|
| + *
|
| + * These errors can be emitted in response to wl_surface requests.
|
| + */
|
| +enum wl_surface_error {
|
| + WL_SURFACE_ERROR_INVALID_SCALE = 0,
|
| + WL_SURFACE_ERROR_INVALID_TRANSFORM = 1,
|
| +};
|
| +#endif /* WL_SURFACE_ERROR_ENUM */
|
| +
|
| +/**
|
| + * wl_surface - an onscreen surface
|
| + * @destroy: delete surface
|
| + * @attach: set the surface contents
|
| + * @damage: mark part of the surface damaged
|
| + * @frame: request a frame throttling hint
|
| + * @set_opaque_region: set opaque region
|
| + * @set_input_region: set input region
|
| + * @commit: commit pending surface state
|
| + * @set_buffer_transform: sets the buffer transformation
|
| + * @set_buffer_scale: sets the buffer scaling factor
|
| + *
|
| + * A surface is a rectangular area that is displayed on the screen. It
|
| + * has a location, size and pixel contents.
|
| + *
|
| + * The size of a surface (and relative positions on it) is described in
|
| + * surface local coordinates, which may differ from the buffer local
|
| + * coordinates of the pixel content, in case a buffer_transform or a
|
| + * buffer_scale is used.
|
| + *
|
| + * A surface without a "role" is fairly useless, a compositor does not know
|
| + * where, when or how to present it. The role is the purpose of a
|
| + * wl_surface. Examples of roles are a cursor for a pointer (as set by
|
| + * wl_pointer.set_cursor), a drag icon (wl_data_device.start_drag), a
|
| + * sub-surface (wl_subcompositor.get_subsurface), and a window as defined
|
| + * by a shell protocol (e.g. wl_shell.get_shell_surface).
|
| + *
|
| + * A surface can have only one role at a time. Initially a wl_surface does
|
| + * not have a role. Once a wl_surface is given a role, it is set
|
| + * permanently for the whole lifetime of the wl_surface object. Giving the
|
| + * current role again is allowed, unless explicitly forbidden by the
|
| + * relevant interface specification.
|
| + *
|
| + * Surface roles are given by requests in other interfaces such as
|
| + * wl_pointer.set_cursor. The request should explicitly mention that this
|
| + * request gives a role to a wl_surface. Often, this request also creates a
|
| + * new protocol object that represents the role and adds additional
|
| + * functionality to wl_surface. When a client wants to destroy a
|
| + * wl_surface, they must destroy this 'role object' before the wl_surface.
|
| + *
|
| + * Destroying the role object does not remove the role from the wl_surface,
|
| + * but it may stop the wl_surface from "playing the role". For instance, if
|
| + * a wl_subsurface object is destroyed, the wl_surface it was created for
|
| + * will be unmapped and forget its position and z-order. It is allowed to
|
| + * create a wl_subsurface for the same wl_surface again, but it is not
|
| + * allowed to use the wl_surface as a cursor (cursor is a different role
|
| + * than sub-surface, and role switching is not allowed).
|
| + */
|
| +struct wl_surface_interface {
|
| + /**
|
| + * destroy - delete surface
|
| + *
|
| + * Deletes the surface and invalidates its object ID.
|
| + */
|
| + void (*destroy)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| + /**
|
| + * attach - set the surface contents
|
| + * @buffer: (none)
|
| + * @x: (none)
|
| + * @y: (none)
|
| + *
|
| + * Set a buffer as the content of this surface.
|
| + *
|
| + * The new size of the surface is calculated based on the buffer
|
| + * size transformed by the inverse buffer_transform and the inverse
|
| + * buffer_scale. This means that the supplied buffer must be an
|
| + * integer multiple of the buffer_scale.
|
| + *
|
| + * The x and y arguments specify the location of the new pending
|
| + * buffer's upper left corner, relative to the current buffer's
|
| + * upper left corner, in surface local coordinates. In other words,
|
| + * the x and y, combined with the new surface size define in which
|
| + * directions the surface's size changes.
|
| + *
|
| + * Surface contents are double-buffered state, see
|
| + * wl_surface.commit.
|
| + *
|
| + * The initial surface contents are void; there is no content.
|
| + * wl_surface.attach assigns the given wl_buffer as the pending
|
| + * wl_buffer. wl_surface.commit makes the pending wl_buffer the new
|
| + * surface contents, and the size of the surface becomes the size
|
| + * calculated from the wl_buffer, as described above. After commit,
|
| + * there is no pending buffer until the next attach.
|
| + *
|
| + * Committing a pending wl_buffer allows the compositor to read the
|
| + * pixels in the wl_buffer. The compositor may access the pixels at
|
| + * any time after the wl_surface.commit request. When the
|
| + * compositor will not access the pixels anymore, it will send the
|
| + * wl_buffer.release event. Only after receiving wl_buffer.release,
|
| + * the client may re-use the wl_buffer. A wl_buffer that has been
|
| + * attached and then replaced by another attach instead of
|
| + * committed will not receive a release event, and is not used by
|
| + * the compositor.
|
| + *
|
| + * Destroying the wl_buffer after wl_buffer.release does not change
|
| + * the surface contents. However, if the client destroys the
|
| + * wl_buffer before receiving the wl_buffer.release event, the
|
| + * surface contents become undefined immediately.
|
| + *
|
| + * If wl_surface.attach is sent with a NULL wl_buffer, the
|
| + * following wl_surface.commit will remove the surface content.
|
| + */
|
| + void (*attach)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *buffer,
|
| + int32_t x,
|
| + int32_t y);
|
| + /**
|
| + * damage - mark part of the surface damaged
|
| + * @x: (none)
|
| + * @y: (none)
|
| + * @width: (none)
|
| + * @height: (none)
|
| + *
|
| + * This request is used to describe the regions where the pending
|
| + * buffer is different from the current surface contents, and where
|
| + * the surface therefore needs to be repainted. The pending buffer
|
| + * must be set by wl_surface.attach before sending damage. The
|
| + * compositor ignores the parts of the damage that fall outside of
|
| + * the surface.
|
| + *
|
| + * Damage is double-buffered state, see wl_surface.commit.
|
| + *
|
| + * The damage rectangle is specified in surface local coordinates.
|
| + *
|
| + * The initial value for pending damage is empty: no damage.
|
| + * wl_surface.damage adds pending damage: the new pending damage is
|
| + * the union of old pending damage and the given rectangle.
|
| + *
|
| + * wl_surface.commit assigns pending damage as the current damage,
|
| + * and clears pending damage. The server will clear the current
|
| + * damage as it repaints the surface.
|
| + */
|
| + void (*damage)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + int32_t x,
|
| + int32_t y,
|
| + int32_t width,
|
| + int32_t height);
|
| + /**
|
| + * frame - request a frame throttling hint
|
| + * @callback: (none)
|
| + *
|
| + * Request a notification when it is a good time start drawing a
|
| + * new frame, by creating a frame callback. This is useful for
|
| + * throttling redrawing operations, and driving animations.
|
| + *
|
| + * When a client is animating on a wl_surface, it can use the
|
| + * 'frame' request to get notified when it is a good time to draw
|
| + * and commit the next frame of animation. If the client commits an
|
| + * update earlier than that, it is likely that some updates will
|
| + * not make it to the display, and the client is wasting resources
|
| + * by drawing too often.
|
| + *
|
| + * The frame request will take effect on the next
|
| + * wl_surface.commit. The notification will only be posted for one
|
| + * frame unless requested again. For a wl_surface, the
|
| + * notifications are posted in the order the frame requests were
|
| + * committed.
|
| + *
|
| + * The server must send the notifications so that a client will not
|
| + * send excessive updates, while still allowing the highest
|
| + * possible update rate for clients that wait for the reply before
|
| + * drawing again. The server should give some time for the client
|
| + * to draw and commit after sending the frame callback events to
|
| + * let them hit the next output refresh.
|
| + *
|
| + * A server should avoid signalling the frame callbacks if the
|
| + * surface is not visible in any way, e.g. the surface is
|
| + * off-screen, or completely obscured by other opaque surfaces.
|
| + *
|
| + * The object returned by this request will be destroyed by the
|
| + * compositor after the callback is fired and as such the client
|
| + * must not attempt to use it after that point.
|
| + *
|
| + * The callback_data passed in the callback is the current time, in
|
| + * milliseconds, with an undefined base.
|
| + */
|
| + void (*frame)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t callback);
|
| + /**
|
| + * set_opaque_region - set opaque region
|
| + * @region: (none)
|
| + *
|
| + * This request sets the region of the surface that contains
|
| + * opaque content.
|
| + *
|
| + * The opaque region is an optimization hint for the compositor
|
| + * that lets it optimize out redrawing of content behind opaque
|
| + * regions. Setting an opaque region is not required for correct
|
| + * behaviour, but marking transparent content as opaque will result
|
| + * in repaint artifacts.
|
| + *
|
| + * The opaque region is specified in surface local coordinates.
|
| + *
|
| + * The compositor ignores the parts of the opaque region that fall
|
| + * outside of the surface.
|
| + *
|
| + * Opaque region is double-buffered state, see wl_surface.commit.
|
| + *
|
| + * wl_surface.set_opaque_region changes the pending opaque region.
|
| + * wl_surface.commit copies the pending region to the current
|
| + * region. Otherwise, the pending and current regions are never
|
| + * changed.
|
| + *
|
| + * The initial value for opaque region is empty. Setting the
|
| + * pending opaque region has copy semantics, and the wl_region
|
| + * object can be destroyed immediately. A NULL wl_region causes the
|
| + * pending opaque region to be set to empty.
|
| + */
|
| + void (*set_opaque_region)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *region);
|
| + /**
|
| + * set_input_region - set input region
|
| + * @region: (none)
|
| + *
|
| + * This request sets the region of the surface that can receive
|
| + * pointer and touch events.
|
| + *
|
| + * Input events happening outside of this region will try the next
|
| + * surface in the server surface stack. The compositor ignores the
|
| + * parts of the input region that fall outside of the surface.
|
| + *
|
| + * The input region is specified in surface local coordinates.
|
| + *
|
| + * Input region is double-buffered state, see wl_surface.commit.
|
| + *
|
| + * wl_surface.set_input_region changes the pending input region.
|
| + * wl_surface.commit copies the pending region to the current
|
| + * region. Otherwise the pending and current regions are never
|
| + * changed, except cursor and icon surfaces are special cases, see
|
| + * wl_pointer.set_cursor and wl_data_device.start_drag.
|
| + *
|
| + * The initial value for input region is infinite. That means the
|
| + * whole surface will accept input. Setting the pending input
|
| + * region has copy semantics, and the wl_region object can be
|
| + * destroyed immediately. A NULL wl_region causes the input region
|
| + * to be set to infinite.
|
| + */
|
| + void (*set_input_region)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *region);
|
| + /**
|
| + * commit - commit pending surface state
|
| + *
|
| + * Surface state (input, opaque, and damage regions, attached
|
| + * buffers, etc.) is double-buffered. Protocol requests modify the
|
| + * pending state, as opposed to current state in use by the
|
| + * compositor. Commit request atomically applies all pending state,
|
| + * replacing the current state. After commit, the new pending state
|
| + * is as documented for each related request.
|
| + *
|
| + * On commit, a pending wl_buffer is applied first, all other state
|
| + * second. This means that all coordinates in double-buffered state
|
| + * are relative to the new wl_buffer coming into use, except for
|
| + * wl_surface.attach itself. If there is no pending wl_buffer, the
|
| + * coordinates are relative to the current surface contents.
|
| + *
|
| + * All requests that need a commit to become effective are
|
| + * documented to affect double-buffered state.
|
| + *
|
| + * Other interfaces may add further double-buffered surface state.
|
| + */
|
| + void (*commit)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| + /**
|
| + * set_buffer_transform - sets the buffer transformation
|
| + * @transform: (none)
|
| + *
|
| + * This request sets an optional transformation on how the
|
| + * compositor interprets the contents of the buffer attached to the
|
| + * surface. The accepted values for the transform parameter are the
|
| + * values for wl_output.transform.
|
| + *
|
| + * Buffer transform is double-buffered state, see
|
| + * wl_surface.commit.
|
| + *
|
| + * A newly created surface has its buffer transformation set to
|
| + * normal.
|
| + *
|
| + * wl_surface.set_buffer_transform changes the pending buffer
|
| + * transformation. wl_surface.commit copies the pending buffer
|
| + * transformation to the current one. Otherwise, the pending and
|
| + * current values are never changed.
|
| + *
|
| + * The purpose of this request is to allow clients to render
|
| + * content according to the output transform, thus permiting the
|
| + * compositor to use certain optimizations even if the display is
|
| + * rotated. Using hardware overlays and scanning out a client
|
| + * buffer for fullscreen surfaces are examples of such
|
| + * optimizations. Those optimizations are highly dependent on the
|
| + * compositor implementation, so the use of this request should be
|
| + * considered on a case-by-case basis.
|
| + *
|
| + * Note that if the transform value includes 90 or 270 degree
|
| + * rotation, the width of the buffer will become the surface height
|
| + * and the height of the buffer will become the surface width.
|
| + *
|
| + * If transform is not one of the values from the
|
| + * wl_output.transform enum the invalid_transform protocol error is
|
| + * raised.
|
| + * @since: 2
|
| + */
|
| + void (*set_buffer_transform)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + int32_t transform);
|
| + /**
|
| + * set_buffer_scale - sets the buffer scaling factor
|
| + * @scale: (none)
|
| + *
|
| + * This request sets an optional scaling factor on how the
|
| + * compositor interprets the contents of the buffer attached to the
|
| + * window.
|
| + *
|
| + * Buffer scale is double-buffered state, see wl_surface.commit.
|
| + *
|
| + * A newly created surface has its buffer scale set to 1.
|
| + *
|
| + * wl_surface.set_buffer_scale changes the pending buffer scale.
|
| + * wl_surface.commit copies the pending buffer scale to the current
|
| + * one. Otherwise, the pending and current values are never
|
| + * changed.
|
| + *
|
| + * The purpose of this request is to allow clients to supply higher
|
| + * resolution buffer data for use on high resolution outputs. Its
|
| + * intended that you pick the same buffer scale as the scale of the
|
| + * output that the surface is displayed on.This means the
|
| + * compositor can avoid scaling when rendering the surface on that
|
| + * output.
|
| + *
|
| + * Note that if the scale is larger than 1, then you have to attach
|
| + * a buffer that is larger (by a factor of scale in each dimension)
|
| + * than the desired surface size.
|
| + *
|
| + * If scale is not positive the invalid_scale protocol error is
|
| + * raised.
|
| + * @since: 3
|
| + */
|
| + void (*set_buffer_scale)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + int32_t scale);
|
| +};
|
| +
|
| +#define WL_SURFACE_ENTER 0
|
| +#define WL_SURFACE_LEAVE 1
|
| +
|
| +#define WL_SURFACE_ENTER_SINCE_VERSION 1
|
| +#define WL_SURFACE_LEAVE_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_surface_send_enter(struct wl_resource *resource_, struct wl_resource *output)
|
| +{
|
| + wl_resource_post_event(resource_, WL_SURFACE_ENTER, output);
|
| +}
|
| +
|
| +static inline void
|
| +wl_surface_send_leave(struct wl_resource *resource_, struct wl_resource *output)
|
| +{
|
| + wl_resource_post_event(resource_, WL_SURFACE_LEAVE, output);
|
| +}
|
| +
|
| +#ifndef WL_SEAT_CAPABILITY_ENUM
|
| +#define WL_SEAT_CAPABILITY_ENUM
|
| +/**
|
| + * wl_seat_capability - seat capability bitmask
|
| + * @WL_SEAT_CAPABILITY_POINTER: The seat has pointer devices
|
| + * @WL_SEAT_CAPABILITY_KEYBOARD: The seat has one or more keyboards
|
| + * @WL_SEAT_CAPABILITY_TOUCH: The seat has touch devices
|
| + *
|
| + * This is a bitmask of capabilities this seat has; if a member is set,
|
| + * then it is present on the seat.
|
| + */
|
| +enum wl_seat_capability {
|
| + WL_SEAT_CAPABILITY_POINTER = 1,
|
| + WL_SEAT_CAPABILITY_KEYBOARD = 2,
|
| + WL_SEAT_CAPABILITY_TOUCH = 4,
|
| +};
|
| +#endif /* WL_SEAT_CAPABILITY_ENUM */
|
| +
|
| +/**
|
| + * wl_seat - group of input devices
|
| + * @get_pointer: return pointer object
|
| + * @get_keyboard: return keyboard object
|
| + * @get_touch: return touch object
|
| + *
|
| + * A seat is a group of keyboards, pointer and touch devices. This object
|
| + * is published as a global during start up, or when such a device is hot
|
| + * plugged. A seat typically has a pointer and maintains a keyboard focus
|
| + * and a pointer focus.
|
| + */
|
| +struct wl_seat_interface {
|
| + /**
|
| + * get_pointer - return pointer object
|
| + * @id: (none)
|
| + *
|
| + * The ID provided will be initialized to the wl_pointer
|
| + * interface for this seat.
|
| + *
|
| + * This request only takes effect if the seat has the pointer
|
| + * capability.
|
| + */
|
| + void (*get_pointer)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id);
|
| + /**
|
| + * get_keyboard - return keyboard object
|
| + * @id: (none)
|
| + *
|
| + * The ID provided will be initialized to the wl_keyboard
|
| + * interface for this seat.
|
| + *
|
| + * This request only takes effect if the seat has the keyboard
|
| + * capability.
|
| + */
|
| + void (*get_keyboard)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id);
|
| + /**
|
| + * get_touch - return touch object
|
| + * @id: (none)
|
| + *
|
| + * The ID provided will be initialized to the wl_touch interface
|
| + * for this seat.
|
| + *
|
| + * This request only takes effect if the seat has the touch
|
| + * capability.
|
| + */
|
| + void (*get_touch)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id);
|
| +};
|
| +
|
| +#define WL_SEAT_CAPABILITIES 0
|
| +#define WL_SEAT_NAME 1
|
| +
|
| +#define WL_SEAT_CAPABILITIES_SINCE_VERSION 1
|
| +#define WL_SEAT_NAME_SINCE_VERSION 2
|
| +
|
| +static inline void
|
| +wl_seat_send_capabilities(struct wl_resource *resource_, uint32_t capabilities)
|
| +{
|
| + wl_resource_post_event(resource_, WL_SEAT_CAPABILITIES, capabilities);
|
| +}
|
| +
|
| +static inline void
|
| +wl_seat_send_name(struct wl_resource *resource_, const char *name)
|
| +{
|
| + wl_resource_post_event(resource_, WL_SEAT_NAME, name);
|
| +}
|
| +
|
| +#ifndef WL_POINTER_ERROR_ENUM
|
| +#define WL_POINTER_ERROR_ENUM
|
| +enum wl_pointer_error {
|
| + WL_POINTER_ERROR_ROLE = 0,
|
| +};
|
| +#endif /* WL_POINTER_ERROR_ENUM */
|
| +
|
| +#ifndef WL_POINTER_BUTTON_STATE_ENUM
|
| +#define WL_POINTER_BUTTON_STATE_ENUM
|
| +/**
|
| + * wl_pointer_button_state - physical button state
|
| + * @WL_POINTER_BUTTON_STATE_RELEASED: The button is not pressed
|
| + * @WL_POINTER_BUTTON_STATE_PRESSED: The button is pressed
|
| + *
|
| + * Describes the physical state of a button which provoked the button
|
| + * event.
|
| + */
|
| +enum wl_pointer_button_state {
|
| + WL_POINTER_BUTTON_STATE_RELEASED = 0,
|
| + WL_POINTER_BUTTON_STATE_PRESSED = 1,
|
| +};
|
| +#endif /* WL_POINTER_BUTTON_STATE_ENUM */
|
| +
|
| +#ifndef WL_POINTER_AXIS_ENUM
|
| +#define WL_POINTER_AXIS_ENUM
|
| +/**
|
| + * wl_pointer_axis - axis types
|
| + * @WL_POINTER_AXIS_VERTICAL_SCROLL: (none)
|
| + * @WL_POINTER_AXIS_HORIZONTAL_SCROLL: (none)
|
| + *
|
| + * Describes the axis types of scroll events.
|
| + */
|
| +enum wl_pointer_axis {
|
| + WL_POINTER_AXIS_VERTICAL_SCROLL = 0,
|
| + WL_POINTER_AXIS_HORIZONTAL_SCROLL = 1,
|
| +};
|
| +#endif /* WL_POINTER_AXIS_ENUM */
|
| +
|
| +/**
|
| + * wl_pointer - pointer input device
|
| + * @set_cursor: set the pointer surface
|
| + * @release: release the pointer object
|
| + *
|
| + * The wl_pointer interface represents one or more input devices, such as
|
| + * mice, which control the pointer location and pointer_focus of a seat.
|
| + *
|
| + * The wl_pointer interface generates motion, enter and leave events for
|
| + * the surfaces that the pointer is located over, and button and axis
|
| + * events for button presses, button releases and scrolling.
|
| + */
|
| +struct wl_pointer_interface {
|
| + /**
|
| + * set_cursor - set the pointer surface
|
| + * @serial: serial of the enter event
|
| + * @surface: (none)
|
| + * @hotspot_x: x coordinate in surface-relative coordinates
|
| + * @hotspot_y: y coordinate in surface-relative coordinates
|
| + *
|
| + * Set the pointer surface, i.e., the surface that contains the
|
| + * pointer image (cursor). This request gives the surface the role
|
| + * of a cursor. If the surface already has another role, it raises
|
| + * a protocol error.
|
| + *
|
| + * The cursor actually changes only if the pointer focus for this
|
| + * device is one of the requesting client's surfaces or the surface
|
| + * parameter is the current pointer surface. If there was a
|
| + * previous surface set with this request it is replaced. If
|
| + * surface is NULL, the pointer image is hidden.
|
| + *
|
| + * The parameters hotspot_x and hotspot_y define the position of
|
| + * the pointer surface relative to the pointer location. Its
|
| + * top-left corner is always at (x, y) - (hotspot_x, hotspot_y),
|
| + * where (x, y) are the coordinates of the pointer location, in
|
| + * surface local coordinates.
|
| + *
|
| + * On surface.attach requests to the pointer surface, hotspot_x and
|
| + * hotspot_y are decremented by the x and y parameters passed to
|
| + * the request. Attach must be confirmed by wl_surface.commit as
|
| + * usual.
|
| + *
|
| + * The hotspot can also be updated by passing the currently set
|
| + * pointer surface to this request with new values for hotspot_x
|
| + * and hotspot_y.
|
| + *
|
| + * The current and pending input regions of the wl_surface are
|
| + * cleared, and wl_surface.set_input_region is ignored until the
|
| + * wl_surface is no longer used as the cursor. When the use as a
|
| + * cursor ends, the current and pending input regions become
|
| + * undefined, and the wl_surface is unmapped.
|
| + */
|
| + void (*set_cursor)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t serial,
|
| + struct wl_resource *surface,
|
| + int32_t hotspot_x,
|
| + int32_t hotspot_y);
|
| + /**
|
| + * release - release the pointer object
|
| + *
|
| + * Using this request client can tell the server that it is not
|
| + * going to use the pointer object anymore.
|
| + *
|
| + * This request destroys the pointer proxy object, so user must not
|
| + * call wl_pointer_destroy() after using this request.
|
| + * @since: 3
|
| + */
|
| + void (*release)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| +};
|
| +
|
| +#define WL_POINTER_ENTER 0
|
| +#define WL_POINTER_LEAVE 1
|
| +#define WL_POINTER_MOTION 2
|
| +#define WL_POINTER_BUTTON 3
|
| +#define WL_POINTER_AXIS 4
|
| +
|
| +#define WL_POINTER_ENTER_SINCE_VERSION 1
|
| +#define WL_POINTER_LEAVE_SINCE_VERSION 1
|
| +#define WL_POINTER_MOTION_SINCE_VERSION 1
|
| +#define WL_POINTER_BUTTON_SINCE_VERSION 1
|
| +#define WL_POINTER_AXIS_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_pointer_send_enter(struct wl_resource *resource_, uint32_t serial, struct wl_resource *surface, wl_fixed_t surface_x, wl_fixed_t surface_y)
|
| +{
|
| + wl_resource_post_event(resource_, WL_POINTER_ENTER, serial, surface, surface_x, surface_y);
|
| +}
|
| +
|
| +static inline void
|
| +wl_pointer_send_leave(struct wl_resource *resource_, uint32_t serial, struct wl_resource *surface)
|
| +{
|
| + wl_resource_post_event(resource_, WL_POINTER_LEAVE, serial, surface);
|
| +}
|
| +
|
| +static inline void
|
| +wl_pointer_send_motion(struct wl_resource *resource_, uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y)
|
| +{
|
| + wl_resource_post_event(resource_, WL_POINTER_MOTION, time, surface_x, surface_y);
|
| +}
|
| +
|
| +static inline void
|
| +wl_pointer_send_button(struct wl_resource *resource_, uint32_t serial, uint32_t time, uint32_t button, uint32_t state)
|
| +{
|
| + wl_resource_post_event(resource_, WL_POINTER_BUTTON, serial, time, button, state);
|
| +}
|
| +
|
| +static inline void
|
| +wl_pointer_send_axis(struct wl_resource *resource_, uint32_t time, uint32_t axis, wl_fixed_t value)
|
| +{
|
| + wl_resource_post_event(resource_, WL_POINTER_AXIS, time, axis, value);
|
| +}
|
| +
|
| +#ifndef WL_KEYBOARD_KEYMAP_FORMAT_ENUM
|
| +#define WL_KEYBOARD_KEYMAP_FORMAT_ENUM
|
| +/**
|
| + * wl_keyboard_keymap_format - keyboard mapping format
|
| + * @WL_KEYBOARD_KEYMAP_FORMAT_NO_KEYMAP: no keymap; client must
|
| + * understand how to interpret the raw keycode
|
| + * @WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1: libxkbcommon compatible; to
|
| + * determine the xkb keycode, clients must add 8 to the key event keycode
|
| + *
|
| + * This specifies the format of the keymap provided to the client with
|
| + * the wl_keyboard.keymap event.
|
| + */
|
| +enum wl_keyboard_keymap_format {
|
| + WL_KEYBOARD_KEYMAP_FORMAT_NO_KEYMAP = 0,
|
| + WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1 = 1,
|
| +};
|
| +#endif /* WL_KEYBOARD_KEYMAP_FORMAT_ENUM */
|
| +
|
| +#ifndef WL_KEYBOARD_KEY_STATE_ENUM
|
| +#define WL_KEYBOARD_KEY_STATE_ENUM
|
| +/**
|
| + * wl_keyboard_key_state - physical key state
|
| + * @WL_KEYBOARD_KEY_STATE_RELEASED: key is not pressed
|
| + * @WL_KEYBOARD_KEY_STATE_PRESSED: key is pressed
|
| + *
|
| + * Describes the physical state of a key which provoked the key event.
|
| + */
|
| +enum wl_keyboard_key_state {
|
| + WL_KEYBOARD_KEY_STATE_RELEASED = 0,
|
| + WL_KEYBOARD_KEY_STATE_PRESSED = 1,
|
| +};
|
| +#endif /* WL_KEYBOARD_KEY_STATE_ENUM */
|
| +
|
| +/**
|
| + * wl_keyboard - keyboard input device
|
| + * @release: release the keyboard object
|
| + *
|
| + * The wl_keyboard interface represents one or more keyboards associated
|
| + * with a seat.
|
| + */
|
| +struct wl_keyboard_interface {
|
| + /**
|
| + * release - release the keyboard object
|
| + *
|
| + *
|
| + * @since: 3
|
| + */
|
| + void (*release)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| +};
|
| +
|
| +#define WL_KEYBOARD_KEYMAP 0
|
| +#define WL_KEYBOARD_ENTER 1
|
| +#define WL_KEYBOARD_LEAVE 2
|
| +#define WL_KEYBOARD_KEY 3
|
| +#define WL_KEYBOARD_MODIFIERS 4
|
| +#define WL_KEYBOARD_REPEAT_INFO 5
|
| +
|
| +#define WL_KEYBOARD_KEYMAP_SINCE_VERSION 1
|
| +#define WL_KEYBOARD_ENTER_SINCE_VERSION 1
|
| +#define WL_KEYBOARD_LEAVE_SINCE_VERSION 1
|
| +#define WL_KEYBOARD_KEY_SINCE_VERSION 1
|
| +#define WL_KEYBOARD_MODIFIERS_SINCE_VERSION 1
|
| +#define WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION 4
|
| +
|
| +static inline void
|
| +wl_keyboard_send_keymap(struct wl_resource *resource_, uint32_t format, int32_t fd, uint32_t size)
|
| +{
|
| + wl_resource_post_event(resource_, WL_KEYBOARD_KEYMAP, format, fd, size);
|
| +}
|
| +
|
| +static inline void
|
| +wl_keyboard_send_enter(struct wl_resource *resource_, uint32_t serial, struct wl_resource *surface, struct wl_array *keys)
|
| +{
|
| + wl_resource_post_event(resource_, WL_KEYBOARD_ENTER, serial, surface, keys);
|
| +}
|
| +
|
| +static inline void
|
| +wl_keyboard_send_leave(struct wl_resource *resource_, uint32_t serial, struct wl_resource *surface)
|
| +{
|
| + wl_resource_post_event(resource_, WL_KEYBOARD_LEAVE, serial, surface);
|
| +}
|
| +
|
| +static inline void
|
| +wl_keyboard_send_key(struct wl_resource *resource_, uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
|
| +{
|
| + wl_resource_post_event(resource_, WL_KEYBOARD_KEY, serial, time, key, state);
|
| +}
|
| +
|
| +static inline void
|
| +wl_keyboard_send_modifiers(struct wl_resource *resource_, uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group)
|
| +{
|
| + wl_resource_post_event(resource_, WL_KEYBOARD_MODIFIERS, serial, mods_depressed, mods_latched, mods_locked, group);
|
| +}
|
| +
|
| +static inline void
|
| +wl_keyboard_send_repeat_info(struct wl_resource *resource_, int32_t rate, int32_t delay)
|
| +{
|
| + wl_resource_post_event(resource_, WL_KEYBOARD_REPEAT_INFO, rate, delay);
|
| +}
|
| +
|
| +/**
|
| + * wl_touch - touchscreen input device
|
| + * @release: release the touch object
|
| + *
|
| + * The wl_touch interface represents a touchscreen associated with a
|
| + * seat.
|
| + *
|
| + * Touch interactions can consist of one or more contacts. For each
|
| + * contact, a series of events is generated, starting with a down event,
|
| + * followed by zero or more motion events, and ending with an up event.
|
| + * Events relating to the same contact point can be identified by the ID of
|
| + * the sequence.
|
| + */
|
| +struct wl_touch_interface {
|
| + /**
|
| + * release - release the touch object
|
| + *
|
| + *
|
| + * @since: 3
|
| + */
|
| + void (*release)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| +};
|
| +
|
| +#define WL_TOUCH_DOWN 0
|
| +#define WL_TOUCH_UP 1
|
| +#define WL_TOUCH_MOTION 2
|
| +#define WL_TOUCH_FRAME 3
|
| +#define WL_TOUCH_CANCEL 4
|
| +
|
| +#define WL_TOUCH_DOWN_SINCE_VERSION 1
|
| +#define WL_TOUCH_UP_SINCE_VERSION 1
|
| +#define WL_TOUCH_MOTION_SINCE_VERSION 1
|
| +#define WL_TOUCH_FRAME_SINCE_VERSION 1
|
| +#define WL_TOUCH_CANCEL_SINCE_VERSION 1
|
| +
|
| +static inline void
|
| +wl_touch_send_down(struct wl_resource *resource_, uint32_t serial, uint32_t time, struct wl_resource *surface, int32_t id, wl_fixed_t x, wl_fixed_t y)
|
| +{
|
| + wl_resource_post_event(resource_, WL_TOUCH_DOWN, serial, time, surface, id, x, y);
|
| +}
|
| +
|
| +static inline void
|
| +wl_touch_send_up(struct wl_resource *resource_, uint32_t serial, uint32_t time, int32_t id)
|
| +{
|
| + wl_resource_post_event(resource_, WL_TOUCH_UP, serial, time, id);
|
| +}
|
| +
|
| +static inline void
|
| +wl_touch_send_motion(struct wl_resource *resource_, uint32_t time, int32_t id, wl_fixed_t x, wl_fixed_t y)
|
| +{
|
| + wl_resource_post_event(resource_, WL_TOUCH_MOTION, time, id, x, y);
|
| +}
|
| +
|
| +static inline void
|
| +wl_touch_send_frame(struct wl_resource *resource_)
|
| +{
|
| + wl_resource_post_event(resource_, WL_TOUCH_FRAME);
|
| +}
|
| +
|
| +static inline void
|
| +wl_touch_send_cancel(struct wl_resource *resource_)
|
| +{
|
| + wl_resource_post_event(resource_, WL_TOUCH_CANCEL);
|
| +}
|
| +
|
| +#ifndef WL_OUTPUT_SUBPIXEL_ENUM
|
| +#define WL_OUTPUT_SUBPIXEL_ENUM
|
| +/**
|
| + * wl_output_subpixel - subpixel geometry information
|
| + * @WL_OUTPUT_SUBPIXEL_UNKNOWN: (none)
|
| + * @WL_OUTPUT_SUBPIXEL_NONE: (none)
|
| + * @WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB: (none)
|
| + * @WL_OUTPUT_SUBPIXEL_HORIZONTAL_BGR: (none)
|
| + * @WL_OUTPUT_SUBPIXEL_VERTICAL_RGB: (none)
|
| + * @WL_OUTPUT_SUBPIXEL_VERTICAL_BGR: (none)
|
| + *
|
| + * This enumeration describes how the physical pixels on an output are
|
| + * laid out.
|
| + */
|
| +enum wl_output_subpixel {
|
| + WL_OUTPUT_SUBPIXEL_UNKNOWN = 0,
|
| + WL_OUTPUT_SUBPIXEL_NONE = 1,
|
| + WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB = 2,
|
| + WL_OUTPUT_SUBPIXEL_HORIZONTAL_BGR = 3,
|
| + WL_OUTPUT_SUBPIXEL_VERTICAL_RGB = 4,
|
| + WL_OUTPUT_SUBPIXEL_VERTICAL_BGR = 5,
|
| +};
|
| +#endif /* WL_OUTPUT_SUBPIXEL_ENUM */
|
| +
|
| +#ifndef WL_OUTPUT_TRANSFORM_ENUM
|
| +#define WL_OUTPUT_TRANSFORM_ENUM
|
| +/**
|
| + * wl_output_transform - transform from framebuffer to output
|
| + * @WL_OUTPUT_TRANSFORM_NORMAL: (none)
|
| + * @WL_OUTPUT_TRANSFORM_90: (none)
|
| + * @WL_OUTPUT_TRANSFORM_180: (none)
|
| + * @WL_OUTPUT_TRANSFORM_270: (none)
|
| + * @WL_OUTPUT_TRANSFORM_FLIPPED: (none)
|
| + * @WL_OUTPUT_TRANSFORM_FLIPPED_90: (none)
|
| + * @WL_OUTPUT_TRANSFORM_FLIPPED_180: (none)
|
| + * @WL_OUTPUT_TRANSFORM_FLIPPED_270: (none)
|
| + *
|
| + * This describes the transform that a compositor will apply to a surface
|
| + * to compensate for the rotation or mirroring of an output device.
|
| + *
|
| + * The flipped values correspond to an initial flip around a vertical axis
|
| + * followed by rotation.
|
| + *
|
| + * The purpose is mainly to allow clients render accordingly and tell the
|
| + * compositor, so that for fullscreen surfaces, the compositor will still
|
| + * be able to scan out directly from client surfaces.
|
| + */
|
| +enum wl_output_transform {
|
| + WL_OUTPUT_TRANSFORM_NORMAL = 0,
|
| + WL_OUTPUT_TRANSFORM_90 = 1,
|
| + WL_OUTPUT_TRANSFORM_180 = 2,
|
| + WL_OUTPUT_TRANSFORM_270 = 3,
|
| + WL_OUTPUT_TRANSFORM_FLIPPED = 4,
|
| + WL_OUTPUT_TRANSFORM_FLIPPED_90 = 5,
|
| + WL_OUTPUT_TRANSFORM_FLIPPED_180 = 6,
|
| + WL_OUTPUT_TRANSFORM_FLIPPED_270 = 7,
|
| +};
|
| +#endif /* WL_OUTPUT_TRANSFORM_ENUM */
|
| +
|
| +#ifndef WL_OUTPUT_MODE_ENUM
|
| +#define WL_OUTPUT_MODE_ENUM
|
| +/**
|
| + * wl_output_mode - mode information
|
| + * @WL_OUTPUT_MODE_CURRENT: indicates this is the current mode
|
| + * @WL_OUTPUT_MODE_PREFERRED: indicates this is the preferred mode
|
| + *
|
| + * These flags describe properties of an output mode. They are used in
|
| + * the flags bitfield of the mode event.
|
| + */
|
| +enum wl_output_mode {
|
| + WL_OUTPUT_MODE_CURRENT = 0x1,
|
| + WL_OUTPUT_MODE_PREFERRED = 0x2,
|
| +};
|
| +#endif /* WL_OUTPUT_MODE_ENUM */
|
| +
|
| +#define WL_OUTPUT_GEOMETRY 0
|
| +#define WL_OUTPUT_MODE 1
|
| +#define WL_OUTPUT_DONE 2
|
| +#define WL_OUTPUT_SCALE 3
|
| +
|
| +#define WL_OUTPUT_GEOMETRY_SINCE_VERSION 1
|
| +#define WL_OUTPUT_MODE_SINCE_VERSION 1
|
| +#define WL_OUTPUT_DONE_SINCE_VERSION 2
|
| +#define WL_OUTPUT_SCALE_SINCE_VERSION 2
|
| +
|
| +static inline void
|
| +wl_output_send_geometry(struct wl_resource *resource_, int32_t x, int32_t y, int32_t physical_width, int32_t physical_height, int32_t subpixel, const char *make, const char *model, int32_t transform)
|
| +{
|
| + wl_resource_post_event(resource_, WL_OUTPUT_GEOMETRY, x, y, physical_width, physical_height, subpixel, make, model, transform);
|
| +}
|
| +
|
| +static inline void
|
| +wl_output_send_mode(struct wl_resource *resource_, uint32_t flags, int32_t width, int32_t height, int32_t refresh)
|
| +{
|
| + wl_resource_post_event(resource_, WL_OUTPUT_MODE, flags, width, height, refresh);
|
| +}
|
| +
|
| +static inline void
|
| +wl_output_send_done(struct wl_resource *resource_)
|
| +{
|
| + wl_resource_post_event(resource_, WL_OUTPUT_DONE);
|
| +}
|
| +
|
| +static inline void
|
| +wl_output_send_scale(struct wl_resource *resource_, int32_t factor)
|
| +{
|
| + wl_resource_post_event(resource_, WL_OUTPUT_SCALE, factor);
|
| +}
|
| +
|
| +/**
|
| + * wl_region - region interface
|
| + * @destroy: destroy region
|
| + * @add: add rectangle to region
|
| + * @subtract: subtract rectangle from region
|
| + *
|
| + * A region object describes an area.
|
| + *
|
| + * Region objects are used to describe the opaque and input regions of a
|
| + * surface.
|
| + */
|
| +struct wl_region_interface {
|
| + /**
|
| + * destroy - destroy region
|
| + *
|
| + * Destroy the region. This will invalidate the object ID.
|
| + */
|
| + void (*destroy)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| + /**
|
| + * add - add rectangle to region
|
| + * @x: (none)
|
| + * @y: (none)
|
| + * @width: (none)
|
| + * @height: (none)
|
| + *
|
| + * Add the specified rectangle to the region.
|
| + */
|
| + void (*add)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + int32_t x,
|
| + int32_t y,
|
| + int32_t width,
|
| + int32_t height);
|
| + /**
|
| + * subtract - subtract rectangle from region
|
| + * @x: (none)
|
| + * @y: (none)
|
| + * @width: (none)
|
| + * @height: (none)
|
| + *
|
| + * Subtract the specified rectangle from the region.
|
| + */
|
| + void (*subtract)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + int32_t x,
|
| + int32_t y,
|
| + int32_t width,
|
| + int32_t height);
|
| +};
|
| +
|
| +
|
| +#ifndef WL_SUBCOMPOSITOR_ERROR_ENUM
|
| +#define WL_SUBCOMPOSITOR_ERROR_ENUM
|
| +enum wl_subcompositor_error {
|
| + WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE = 0,
|
| +};
|
| +#endif /* WL_SUBCOMPOSITOR_ERROR_ENUM */
|
| +
|
| +/**
|
| + * wl_subcompositor - sub-surface compositing
|
| + * @destroy: unbind from the subcompositor interface
|
| + * @get_subsurface: give a surface the role sub-surface
|
| + *
|
| + * The global interface exposing sub-surface compositing capabilities. A
|
| + * wl_surface, that has sub-surfaces associated, is called the parent
|
| + * surface. Sub-surfaces can be arbitrarily nested and create a tree of
|
| + * sub-surfaces.
|
| + *
|
| + * The root surface in a tree of sub-surfaces is the main surface. The main
|
| + * surface cannot be a sub-surface, because sub-surfaces must always have a
|
| + * parent.
|
| + *
|
| + * A main surface with its sub-surfaces forms a (compound) window. For
|
| + * window management purposes, this set of wl_surface objects is to be
|
| + * considered as a single window, and it should also behave as such.
|
| + *
|
| + * The aim of sub-surfaces is to offload some of the compositing work
|
| + * within a window from clients to the compositor. A prime example is a
|
| + * video player with decorations and video in separate wl_surface objects.
|
| + * This should allow the compositor to pass YUV video buffer processing to
|
| + * dedicated overlay hardware when possible.
|
| + */
|
| +struct wl_subcompositor_interface {
|
| + /**
|
| + * destroy - unbind from the subcompositor interface
|
| + *
|
| + * Informs the server that the client will not be using this
|
| + * protocol object anymore. This does not affect any other objects,
|
| + * wl_subsurface objects included.
|
| + */
|
| + void (*destroy)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| + /**
|
| + * get_subsurface - give a surface the role sub-surface
|
| + * @id: the new subsurface object id
|
| + * @surface: the surface to be turned into a sub-surface
|
| + * @parent: the parent surface
|
| + *
|
| + * Create a sub-surface interface for the given surface, and
|
| + * associate it with the given parent surface. This turns a plain
|
| + * wl_surface into a sub-surface.
|
| + *
|
| + * The to-be sub-surface must not already have another role, and it
|
| + * must not have an existing wl_subsurface object. Otherwise a
|
| + * protocol error is raised.
|
| + */
|
| + void (*get_subsurface)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + uint32_t id,
|
| + struct wl_resource *surface,
|
| + struct wl_resource *parent);
|
| +};
|
| +
|
| +
|
| +#ifndef WL_SUBSURFACE_ERROR_ENUM
|
| +#define WL_SUBSURFACE_ERROR_ENUM
|
| +enum wl_subsurface_error {
|
| + WL_SUBSURFACE_ERROR_BAD_SURFACE = 0,
|
| +};
|
| +#endif /* WL_SUBSURFACE_ERROR_ENUM */
|
| +
|
| +/**
|
| + * wl_subsurface - sub-surface interface to a wl_surface
|
| + * @destroy: remove sub-surface interface
|
| + * @set_position: reposition the sub-surface
|
| + * @place_above: restack the sub-surface
|
| + * @place_below: restack the sub-surface
|
| + * @set_sync: set sub-surface to synchronized mode
|
| + * @set_desync: set sub-surface to desynchronized mode
|
| + *
|
| + * An additional interface to a wl_surface object, which has been made a
|
| + * sub-surface. A sub-surface has one parent surface. A sub-surface's size
|
| + * and position are not limited to that of the parent. Particularly, a
|
| + * sub-surface is not automatically clipped to its parent's area.
|
| + *
|
| + * A sub-surface becomes mapped, when a non-NULL wl_buffer is applied and
|
| + * the parent surface is mapped. The order of which one happens first is
|
| + * irrelevant. A sub-surface is hidden if the parent becomes hidden, or if
|
| + * a NULL wl_buffer is applied. These rules apply recursively through the
|
| + * tree of surfaces.
|
| + *
|
| + * The behaviour of wl_surface.commit request on a sub-surface depends on
|
| + * the sub-surface's mode. The possible modes are synchronized and
|
| + * desynchronized, see methods wl_subsurface.set_sync and
|
| + * wl_subsurface.set_desync. Synchronized mode caches the wl_surface state
|
| + * to be applied when the parent's state gets applied, and desynchronized
|
| + * mode applies the pending wl_surface state directly. A sub-surface is
|
| + * initially in the synchronized mode.
|
| + *
|
| + * Sub-surfaces have also other kind of state, which is managed by
|
| + * wl_subsurface requests, as opposed to wl_surface requests. This state
|
| + * includes the sub-surface position relative to the parent surface
|
| + * (wl_subsurface.set_position), and the stacking order of the parent and
|
| + * its sub-surfaces (wl_subsurface.place_above and .place_below). This
|
| + * state is applied when the parent surface's wl_surface state is applied,
|
| + * regardless of the sub-surface's mode. As the exception, set_sync and
|
| + * set_desync are effective immediately.
|
| + *
|
| + * The main surface can be thought to be always in desynchronized mode,
|
| + * since it does not have a parent in the sub-surfaces sense.
|
| + *
|
| + * Even if a sub-surface is in desynchronized mode, it will behave as in
|
| + * synchronized mode, if its parent surface behaves as in synchronized
|
| + * mode. This rule is applied recursively throughout the tree of surfaces.
|
| + * This means, that one can set a sub-surface into synchronized mode, and
|
| + * then assume that all its child and grand-child sub-surfaces are
|
| + * synchronized, too, without explicitly setting them.
|
| + *
|
| + * If the wl_surface associated with the wl_subsurface is destroyed, the
|
| + * wl_subsurface object becomes inert. Note, that destroying either object
|
| + * takes effect immediately. If you need to synchronize the removal of a
|
| + * sub-surface to the parent surface update, unmap the sub-surface first by
|
| + * attaching a NULL wl_buffer, update parent, and then destroy the
|
| + * sub-surface.
|
| + *
|
| + * If the parent wl_surface object is destroyed, the sub-surface is
|
| + * unmapped.
|
| + */
|
| +struct wl_subsurface_interface {
|
| + /**
|
| + * destroy - remove sub-surface interface
|
| + *
|
| + * The sub-surface interface is removed from the wl_surface
|
| + * object that was turned into a sub-surface with
|
| + * wl_subcompositor.get_subsurface request. The wl_surface's
|
| + * association to the parent is deleted, and the wl_surface loses
|
| + * its role as a sub-surface. The wl_surface is unmapped.
|
| + */
|
| + void (*destroy)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| + /**
|
| + * set_position - reposition the sub-surface
|
| + * @x: coordinate in the parent surface
|
| + * @y: coordinate in the parent surface
|
| + *
|
| + * This schedules a sub-surface position change. The sub-surface
|
| + * will be moved so, that its origin (top-left corner pixel) will
|
| + * be at the location x, y of the parent surface coordinate system.
|
| + * The coordinates are not restricted to the parent surface area.
|
| + * Negative values are allowed.
|
| + *
|
| + * The scheduled coordinates will take effect whenever the state of
|
| + * the parent surface is applied. When this happens depends on
|
| + * whether the parent surface is in synchronized mode or not. See
|
| + * wl_subsurface.set_sync and wl_subsurface.set_desync for details.
|
| + *
|
| + * If more than one set_position request is invoked by the client
|
| + * before the commit of the parent surface, the position of a new
|
| + * request always replaces the scheduled position from any previous
|
| + * request.
|
| + *
|
| + * The initial position is 0, 0.
|
| + */
|
| + void (*set_position)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + int32_t x,
|
| + int32_t y);
|
| + /**
|
| + * place_above - restack the sub-surface
|
| + * @sibling: the reference surface
|
| + *
|
| + * This sub-surface is taken from the stack, and put back just
|
| + * above the reference surface, changing the z-order of the
|
| + * sub-surfaces. The reference surface must be one of the sibling
|
| + * surfaces, or the parent surface. Using any other surface,
|
| + * including this sub-surface, will cause a protocol error.
|
| + *
|
| + * The z-order is double-buffered. Requests are handled in order
|
| + * and applied immediately to a pending state. The final pending
|
| + * state is copied to the active state the next time the state of
|
| + * the parent surface is applied. When this happens depends on
|
| + * whether the parent surface is in synchronized mode or not. See
|
| + * wl_subsurface.set_sync and wl_subsurface.set_desync for details.
|
| + *
|
| + * A new sub-surface is initially added as the top-most in the
|
| + * stack of its siblings and parent.
|
| + */
|
| + void (*place_above)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *sibling);
|
| + /**
|
| + * place_below - restack the sub-surface
|
| + * @sibling: the reference surface
|
| + *
|
| + * The sub-surface is placed just below of the reference surface.
|
| + * See wl_subsurface.place_above.
|
| + */
|
| + void (*place_below)(struct wl_client *client,
|
| + struct wl_resource *resource,
|
| + struct wl_resource *sibling);
|
| + /**
|
| + * set_sync - set sub-surface to synchronized mode
|
| + *
|
| + * Change the commit behaviour of the sub-surface to synchronized
|
| + * mode, also described as the parent dependent mode.
|
| + *
|
| + * In synchronized mode, wl_surface.commit on a sub-surface will
|
| + * accumulate the committed state in a cache, but the state will
|
| + * not be applied and hence will not change the compositor output.
|
| + * The cached state is applied to the sub-surface immediately after
|
| + * the parent surface's state is applied. This ensures atomic
|
| + * updates of the parent and all its synchronized sub-surfaces.
|
| + * Applying the cached state will invalidate the cache, so further
|
| + * parent surface commits do not (re-)apply old state.
|
| + *
|
| + * See wl_subsurface for the recursive effect of this mode.
|
| + */
|
| + void (*set_sync)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| + /**
|
| + * set_desync - set sub-surface to desynchronized mode
|
| + *
|
| + * Change the commit behaviour of the sub-surface to
|
| + * desynchronized mode, also described as independent or freely
|
| + * running mode.
|
| + *
|
| + * In desynchronized mode, wl_surface.commit on a sub-surface will
|
| + * apply the pending state directly, without caching, as happens
|
| + * normally with a wl_surface. Calling wl_surface.commit on the
|
| + * parent surface has no effect on the sub-surface's wl_surface
|
| + * state. This mode allows a sub-surface to be updated on its own.
|
| + *
|
| + * If cached state exists when wl_surface.commit is called in
|
| + * desynchronized mode, the pending state is added to the cached
|
| + * state, and applied as whole. This invalidates the cache.
|
| + *
|
| + * Note: even if a sub-surface is set to desynchronized, a parent
|
| + * sub-surface may override it to behave as synchronized. For
|
| + * details, see wl_subsurface.
|
| + *
|
| + * If a surface's parent surface behaves as desynchronized, then
|
| + * the cached state is applied on set_desync.
|
| + */
|
| + void (*set_desync)(struct wl_client *client,
|
| + struct wl_resource *resource);
|
| +};
|
| +
|
| +
|
| +#ifdef __cplusplus
|
| +}
|
| +#endif
|
| +
|
| +#endif
|
|
|
Chromium Code Reviews
Issue 1426583009:
third_party: Add wayland library. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master