| Index: third_party/wayland/include/protocol/wayland-client-protocol-core.h
|
| diff --git a/third_party/wayland/include/protocol/wayland-client-protocol-core.h b/third_party/wayland/include/protocol/wayland-client-protocol-core.h
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..fbf170facb88c39e39fa7d5f189ac17e059f1b0a
|
| --- /dev/null
|
| +++ b/third_party/wayland/include/protocol/wayland-client-protocol-core.h
|
| @@ -0,0 +1,2523 @@
|
| +/*
|
| + * 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_CLIENT_PROTOCOL_H
|
| +#define WAYLAND_CLIENT_PROTOCOL_H
|
| +
|
| +#ifdef __cplusplus
|
| +extern "C" {
|
| +#endif
|
| +
|
| +#include <stdint.h>
|
| +#include <stddef.h>
|
| +#include "wayland-client-core.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
|
| + * @error: fatal error event
|
| + * @delete_id: acknowledge object ID deletion
|
| + *
|
| + * The core global object. This is a special singleton object. It is used
|
| + * for internal Wayland protocol features.
|
| + */
|
| +struct wl_display_listener {
|
| + /**
|
| + * error - fatal error event
|
| + * @object_id: (none)
|
| + * @code: (none)
|
| + * @message: (none)
|
| + *
|
| + * The error event is sent out when a fatal (non-recoverable)
|
| + * error has occurred. The object_id argument is the object where
|
| + * the error occurred, most often in response to a request to that
|
| + * object. The code identifies the error and is defined by the
|
| + * object interface. As such, each interface defines its own set of
|
| + * error codes. The message is an brief description of the error,
|
| + * for (debugging) convenience.
|
| + */
|
| + void (*error)(void *data,
|
| + struct wl_display *wl_display,
|
| + void *object_id,
|
| + uint32_t code,
|
| + const char *message);
|
| + /**
|
| + * delete_id - acknowledge object ID deletion
|
| + * @id: (none)
|
| + *
|
| + * This event is used internally by the object ID management
|
| + * logic. When a client deletes an object, the server will send
|
| + * this event to acknowledge that it has seen the delete request.
|
| + * When the client receive this event, it will know that it can
|
| + * safely reuse the object ID.
|
| + */
|
| + void (*delete_id)(void *data,
|
| + struct wl_display *wl_display,
|
| + uint32_t id);
|
| +};
|
| +
|
| +static inline int
|
| +wl_display_add_listener(struct wl_display *wl_display,
|
| + const struct wl_display_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_display,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_DISPLAY_SYNC 0
|
| +#define WL_DISPLAY_GET_REGISTRY 1
|
| +
|
| +static inline void
|
| +wl_display_set_user_data(struct wl_display *wl_display, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_display, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_display_get_user_data(struct wl_display *wl_display)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_display);
|
| +}
|
| +
|
| +static inline struct wl_callback *
|
| +wl_display_sync(struct wl_display *wl_display)
|
| +{
|
| + struct wl_proxy *callback;
|
| +
|
| + callback = wl_proxy_marshal_constructor((struct wl_proxy *) wl_display,
|
| + WL_DISPLAY_SYNC, &wl_callback_interface, NULL);
|
| +
|
| + return (struct wl_callback *) callback;
|
| +}
|
| +
|
| +static inline struct wl_registry *
|
| +wl_display_get_registry(struct wl_display *wl_display)
|
| +{
|
| + struct wl_proxy *registry;
|
| +
|
| + registry = wl_proxy_marshal_constructor((struct wl_proxy *) wl_display,
|
| + WL_DISPLAY_GET_REGISTRY, &wl_registry_interface, NULL);
|
| +
|
| + return (struct wl_registry *) registry;
|
| +}
|
| +
|
| +/**
|
| + * wl_registry - global registry object
|
| + * @global: announce global object
|
| + * @global_remove: announce removal of global object
|
| + *
|
| + * 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_listener {
|
| + /**
|
| + * global - announce global object
|
| + * @name: (none)
|
| + * @interface: (none)
|
| + * @version: (none)
|
| + *
|
| + * Notify the client of global objects.
|
| + *
|
| + * The event notifies the client that a global object with the
|
| + * given name is now available, and it implements the given version
|
| + * of the given interface.
|
| + */
|
| + void (*global)(void *data,
|
| + struct wl_registry *wl_registry,
|
| + uint32_t name,
|
| + const char *interface,
|
| + uint32_t version);
|
| + /**
|
| + * global_remove - announce removal of global object
|
| + * @name: (none)
|
| + *
|
| + * Notify the client of removed global objects.
|
| + *
|
| + * This event notifies the client that the global identified by
|
| + * name is no longer available. If the client bound to the global
|
| + * using the bind request, the client should now destroy that
|
| + * object.
|
| + *
|
| + * The object remains valid and requests to the object will be
|
| + * ignored until the client destroys it, to avoid races between the
|
| + * global going away and a client sending a request to it.
|
| + */
|
| + void (*global_remove)(void *data,
|
| + struct wl_registry *wl_registry,
|
| + uint32_t name);
|
| +};
|
| +
|
| +static inline int
|
| +wl_registry_add_listener(struct wl_registry *wl_registry,
|
| + const struct wl_registry_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_registry,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_REGISTRY_BIND 0
|
| +
|
| +static inline void
|
| +wl_registry_set_user_data(struct wl_registry *wl_registry, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_registry, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_registry_get_user_data(struct wl_registry *wl_registry)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_registry);
|
| +}
|
| +
|
| +static inline void
|
| +wl_registry_destroy(struct wl_registry *wl_registry)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_registry);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_registry_bind(struct wl_registry *wl_registry, uint32_t name, const struct wl_interface *interface, uint32_t version)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_registry,
|
| + WL_REGISTRY_BIND, interface, name, interface->name, version, NULL);
|
| +
|
| + return (void *) id;
|
| +}
|
| +
|
| +/**
|
| + * wl_callback - callback object
|
| + * @done: done event
|
| + *
|
| + * Clients can handle the 'done' event to get notified when the related
|
| + * request is done.
|
| + */
|
| +struct wl_callback_listener {
|
| + /**
|
| + * done - done event
|
| + * @callback_data: request-specific data for the wl_callback
|
| + *
|
| + * Notify the client when the related request is done.
|
| + */
|
| + void (*done)(void *data,
|
| + struct wl_callback *wl_callback,
|
| + uint32_t callback_data);
|
| +};
|
| +
|
| +static inline int
|
| +wl_callback_add_listener(struct wl_callback *wl_callback,
|
| + const struct wl_callback_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_callback,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +static inline void
|
| +wl_callback_set_user_data(struct wl_callback *wl_callback, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_callback, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_callback_get_user_data(struct wl_callback *wl_callback)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_callback);
|
| +}
|
| +
|
| +static inline void
|
| +wl_callback_destroy(struct wl_callback *wl_callback)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_callback);
|
| +}
|
| +
|
| +#define WL_COMPOSITOR_CREATE_SURFACE 0
|
| +#define WL_COMPOSITOR_CREATE_REGION 1
|
| +
|
| +static inline void
|
| +wl_compositor_set_user_data(struct wl_compositor *wl_compositor, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_compositor, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_compositor_get_user_data(struct wl_compositor *wl_compositor)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_compositor);
|
| +}
|
| +
|
| +static inline void
|
| +wl_compositor_destroy(struct wl_compositor *wl_compositor)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_compositor);
|
| +}
|
| +
|
| +static inline struct wl_surface *
|
| +wl_compositor_create_surface(struct wl_compositor *wl_compositor)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_compositor,
|
| + WL_COMPOSITOR_CREATE_SURFACE, &wl_surface_interface, NULL);
|
| +
|
| + return (struct wl_surface *) id;
|
| +}
|
| +
|
| +static inline struct wl_region *
|
| +wl_compositor_create_region(struct wl_compositor *wl_compositor)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_compositor,
|
| + WL_COMPOSITOR_CREATE_REGION, &wl_region_interface, NULL);
|
| +
|
| + return (struct wl_region *) id;
|
| +}
|
| +
|
| +#define WL_SHM_POOL_CREATE_BUFFER 0
|
| +#define WL_SHM_POOL_DESTROY 1
|
| +#define WL_SHM_POOL_RESIZE 2
|
| +
|
| +static inline void
|
| +wl_shm_pool_set_user_data(struct wl_shm_pool *wl_shm_pool, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_shm_pool, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_shm_pool_get_user_data(struct wl_shm_pool *wl_shm_pool)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_shm_pool);
|
| +}
|
| +
|
| +static inline struct wl_buffer *
|
| +wl_shm_pool_create_buffer(struct wl_shm_pool *wl_shm_pool, int32_t offset, int32_t width, int32_t height, int32_t stride, uint32_t format)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_shm_pool,
|
| + WL_SHM_POOL_CREATE_BUFFER, &wl_buffer_interface, NULL, offset, width, height, stride, format);
|
| +
|
| + return (struct wl_buffer *) id;
|
| +}
|
| +
|
| +static inline void
|
| +wl_shm_pool_destroy(struct wl_shm_pool *wl_shm_pool)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shm_pool,
|
| + WL_SHM_POOL_DESTROY);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_shm_pool);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shm_pool_resize(struct wl_shm_pool *wl_shm_pool, int32_t size)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shm_pool,
|
| + WL_SHM_POOL_RESIZE, 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
|
| + * @format: pixel format description
|
| + *
|
| + * 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_listener {
|
| + /**
|
| + * format - pixel format description
|
| + * @format: (none)
|
| + *
|
| + * Informs the client about a valid pixel format that can be used
|
| + * for buffers. Known formats include argb8888 and xrgb8888.
|
| + */
|
| + void (*format)(void *data,
|
| + struct wl_shm *wl_shm,
|
| + uint32_t format);
|
| +};
|
| +
|
| +static inline int
|
| +wl_shm_add_listener(struct wl_shm *wl_shm,
|
| + const struct wl_shm_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_shm,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_SHM_CREATE_POOL 0
|
| +
|
| +static inline void
|
| +wl_shm_set_user_data(struct wl_shm *wl_shm, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_shm, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_shm_get_user_data(struct wl_shm *wl_shm)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_shm);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shm_destroy(struct wl_shm *wl_shm)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_shm);
|
| +}
|
| +
|
| +static inline struct wl_shm_pool *
|
| +wl_shm_create_pool(struct wl_shm *wl_shm, int32_t fd, int32_t size)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_shm,
|
| + WL_SHM_CREATE_POOL, &wl_shm_pool_interface, NULL, fd, size);
|
| +
|
| + return (struct wl_shm_pool *) id;
|
| +}
|
| +
|
| +/**
|
| + * wl_buffer - content for a wl_surface
|
| + * @release: compositor releases 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_listener {
|
| + /**
|
| + * release - compositor releases buffer
|
| + *
|
| + * Sent when this wl_buffer is no longer used by the compositor.
|
| + * The client is now free to re-use or destroy this buffer and its
|
| + * backing storage.
|
| + *
|
| + * If a client receives a release event before the frame callback
|
| + * requested in the same wl_surface.commit that attaches this
|
| + * wl_buffer to a surface, then the client is immediately free to
|
| + * re-use the buffer and its backing storage, and does not need a
|
| + * second buffer for the next surface content update. Typically
|
| + * this is possible, when the compositor maintains a copy of the
|
| + * wl_surface contents, e.g. as a GL texture. This is an important
|
| + * optimization for GL(ES) compositors with wl_shm clients.
|
| + */
|
| + void (*release)(void *data,
|
| + struct wl_buffer *wl_buffer);
|
| +};
|
| +
|
| +static inline int
|
| +wl_buffer_add_listener(struct wl_buffer *wl_buffer,
|
| + const struct wl_buffer_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_buffer,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_BUFFER_DESTROY 0
|
| +
|
| +static inline void
|
| +wl_buffer_set_user_data(struct wl_buffer *wl_buffer, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_buffer, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_buffer_get_user_data(struct wl_buffer *wl_buffer)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_buffer);
|
| +}
|
| +
|
| +static inline void
|
| +wl_buffer_destroy(struct wl_buffer *wl_buffer)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_buffer,
|
| + WL_BUFFER_DESTROY);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_buffer);
|
| +}
|
| +
|
| +/**
|
| + * wl_data_offer - offer to transfer data
|
| + * @offer: advertise offered mime type
|
| + *
|
| + * 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_listener {
|
| + /**
|
| + * offer - advertise offered mime type
|
| + * @mime_type: (none)
|
| + *
|
| + * Sent immediately after creating the wl_data_offer object. One
|
| + * event per offered mime type.
|
| + */
|
| + void (*offer)(void *data,
|
| + struct wl_data_offer *wl_data_offer,
|
| + const char *mime_type);
|
| +};
|
| +
|
| +static inline int
|
| +wl_data_offer_add_listener(struct wl_data_offer *wl_data_offer,
|
| + const struct wl_data_offer_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_data_offer,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_DATA_OFFER_ACCEPT 0
|
| +#define WL_DATA_OFFER_RECEIVE 1
|
| +#define WL_DATA_OFFER_DESTROY 2
|
| +
|
| +static inline void
|
| +wl_data_offer_set_user_data(struct wl_data_offer *wl_data_offer, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_data_offer, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_data_offer_get_user_data(struct wl_data_offer *wl_data_offer)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_data_offer);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_offer_accept(struct wl_data_offer *wl_data_offer, uint32_t serial, const char *mime_type)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_data_offer,
|
| + WL_DATA_OFFER_ACCEPT, serial, mime_type);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_offer_receive(struct wl_data_offer *wl_data_offer, const char *mime_type, int32_t fd)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_data_offer,
|
| + WL_DATA_OFFER_RECEIVE, mime_type, fd);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_offer_destroy(struct wl_data_offer *wl_data_offer)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_data_offer,
|
| + WL_DATA_OFFER_DESTROY);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_data_offer);
|
| +}
|
| +
|
| +/**
|
| + * wl_data_source - offer to transfer data
|
| + * @target: a target accepts an offered mime type
|
| + * @send: send the data
|
| + * @cancelled: selection was cancelled
|
| + *
|
| + * 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_listener {
|
| + /**
|
| + * target - a target accepts an offered mime type
|
| + * @mime_type: (none)
|
| + *
|
| + * Sent when a target accepts pointer_focus or motion events. If
|
| + * a target does not accept any of the offered types, type is NULL.
|
| + *
|
| + * Used for feedback during drag-and-drop.
|
| + */
|
| + void (*target)(void *data,
|
| + struct wl_data_source *wl_data_source,
|
| + const char *mime_type);
|
| + /**
|
| + * send - send the data
|
| + * @mime_type: (none)
|
| + * @fd: (none)
|
| + *
|
| + * Request for data from the client. Send the data as the
|
| + * specified mime type over the passed file descriptor, then close
|
| + * it.
|
| + */
|
| + void (*send)(void *data,
|
| + struct wl_data_source *wl_data_source,
|
| + const char *mime_type,
|
| + int32_t fd);
|
| + /**
|
| + * cancelled - selection was cancelled
|
| + *
|
| + * This data source has been replaced by another data source. The
|
| + * client should clean up and destroy this data source.
|
| + */
|
| + void (*cancelled)(void *data,
|
| + struct wl_data_source *wl_data_source);
|
| +};
|
| +
|
| +static inline int
|
| +wl_data_source_add_listener(struct wl_data_source *wl_data_source,
|
| + const struct wl_data_source_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_data_source,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_DATA_SOURCE_OFFER 0
|
| +#define WL_DATA_SOURCE_DESTROY 1
|
| +
|
| +static inline void
|
| +wl_data_source_set_user_data(struct wl_data_source *wl_data_source, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_data_source, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_data_source_get_user_data(struct wl_data_source *wl_data_source)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_data_source);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_source_offer(struct wl_data_source *wl_data_source, const char *mime_type)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_data_source,
|
| + WL_DATA_SOURCE_OFFER, mime_type);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_source_destroy(struct wl_data_source *wl_data_source)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_data_source,
|
| + WL_DATA_SOURCE_DESTROY);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_data_source);
|
| +}
|
| +
|
| +#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
|
| + * @data_offer: introduce a new wl_data_offer
|
| + * @enter: initiate drag-and-drop session
|
| + * @leave: end drag-and-drop session
|
| + * @motion: drag-and-drop session motion
|
| + * @drop: end drag-and-drag session successfully
|
| + * @selection: advertise new selection
|
| + *
|
| + * 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_listener {
|
| + /**
|
| + * data_offer - introduce a new wl_data_offer
|
| + * @id: (none)
|
| + *
|
| + * The data_offer event introduces a new wl_data_offer object,
|
| + * which will subsequently be used in either the data_device.enter
|
| + * event (for drag-and-drop) or the data_device.selection event
|
| + * (for selections). Immediately following the
|
| + * data_device_data_offer event, the new data_offer object will
|
| + * send out data_offer.offer events to describe the mime types it
|
| + * offers.
|
| + */
|
| + void (*data_offer)(void *data,
|
| + struct wl_data_device *wl_data_device,
|
| + struct wl_data_offer *id);
|
| + /**
|
| + * enter - initiate drag-and-drop session
|
| + * @serial: (none)
|
| + * @surface: (none)
|
| + * @x: (none)
|
| + * @y: (none)
|
| + * @id: (none)
|
| + *
|
| + * This event is sent when an active drag-and-drop pointer enters
|
| + * a surface owned by the client. The position of the pointer at
|
| + * enter time is provided by the x and y arguments, in surface
|
| + * local coordinates.
|
| + */
|
| + void (*enter)(void *data,
|
| + struct wl_data_device *wl_data_device,
|
| + uint32_t serial,
|
| + struct wl_surface *surface,
|
| + wl_fixed_t x,
|
| + wl_fixed_t y,
|
| + struct wl_data_offer *id);
|
| + /**
|
| + * leave - end drag-and-drop session
|
| + *
|
| + * This event is sent when the drag-and-drop pointer leaves the
|
| + * surface and the session ends. The client must destroy the
|
| + * wl_data_offer introduced at enter time at this point.
|
| + */
|
| + void (*leave)(void *data,
|
| + struct wl_data_device *wl_data_device);
|
| + /**
|
| + * motion - drag-and-drop session motion
|
| + * @time: timestamp with millisecond granularity
|
| + * @x: (none)
|
| + * @y: (none)
|
| + *
|
| + * This event is sent when the drag-and-drop pointer moves within
|
| + * the currently focused surface. The new position of the pointer
|
| + * is provided by the x and y arguments, in surface local
|
| + * coordinates.
|
| + */
|
| + void (*motion)(void *data,
|
| + struct wl_data_device *wl_data_device,
|
| + uint32_t time,
|
| + wl_fixed_t x,
|
| + wl_fixed_t y);
|
| + /**
|
| + * drop - end drag-and-drag session successfully
|
| + *
|
| + * The event is sent when a drag-and-drop operation is ended
|
| + * because the implicit grab is removed.
|
| + */
|
| + void (*drop)(void *data,
|
| + struct wl_data_device *wl_data_device);
|
| + /**
|
| + * selection - advertise new selection
|
| + * @id: (none)
|
| + *
|
| + * The selection event is sent out to notify the client of a new
|
| + * wl_data_offer for the selection for this device. The
|
| + * data_device.data_offer and the data_offer.offer events are sent
|
| + * out immediately before this event to introduce the data offer
|
| + * object. The selection event is sent to a client immediately
|
| + * before receiving keyboard focus and when a new selection is set
|
| + * while the client has keyboard focus. The data_offer is valid
|
| + * until a new data_offer or NULL is received or until the client
|
| + * loses keyboard focus. The client must destroy the previous
|
| + * selection data_offer, if any, upon receiving this event.
|
| + */
|
| + void (*selection)(void *data,
|
| + struct wl_data_device *wl_data_device,
|
| + struct wl_data_offer *id);
|
| +};
|
| +
|
| +static inline int
|
| +wl_data_device_add_listener(struct wl_data_device *wl_data_device,
|
| + const struct wl_data_device_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_data_device,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_DATA_DEVICE_START_DRAG 0
|
| +#define WL_DATA_DEVICE_SET_SELECTION 1
|
| +#define WL_DATA_DEVICE_RELEASE 2
|
| +
|
| +static inline void
|
| +wl_data_device_set_user_data(struct wl_data_device *wl_data_device, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_data_device, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_data_device_get_user_data(struct wl_data_device *wl_data_device)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_data_device);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_device_destroy(struct wl_data_device *wl_data_device)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_data_device);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_device_start_drag(struct wl_data_device *wl_data_device, struct wl_data_source *source, struct wl_surface *origin, struct wl_surface *icon, uint32_t serial)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_data_device,
|
| + WL_DATA_DEVICE_START_DRAG, source, origin, icon, serial);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_device_set_selection(struct wl_data_device *wl_data_device, struct wl_data_source *source, uint32_t serial)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_data_device,
|
| + WL_DATA_DEVICE_SET_SELECTION, source, serial);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_device_release(struct wl_data_device *wl_data_device)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_data_device,
|
| + WL_DATA_DEVICE_RELEASE);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_data_device);
|
| +}
|
| +
|
| +#define WL_DATA_DEVICE_MANAGER_CREATE_DATA_SOURCE 0
|
| +#define WL_DATA_DEVICE_MANAGER_GET_DATA_DEVICE 1
|
| +
|
| +static inline void
|
| +wl_data_device_manager_set_user_data(struct wl_data_device_manager *wl_data_device_manager, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_data_device_manager, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_data_device_manager_get_user_data(struct wl_data_device_manager *wl_data_device_manager)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_data_device_manager);
|
| +}
|
| +
|
| +static inline void
|
| +wl_data_device_manager_destroy(struct wl_data_device_manager *wl_data_device_manager)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_data_device_manager);
|
| +}
|
| +
|
| +static inline struct wl_data_source *
|
| +wl_data_device_manager_create_data_source(struct wl_data_device_manager *wl_data_device_manager)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_data_device_manager,
|
| + WL_DATA_DEVICE_MANAGER_CREATE_DATA_SOURCE, &wl_data_source_interface, NULL);
|
| +
|
| + return (struct wl_data_source *) id;
|
| +}
|
| +
|
| +static inline struct wl_data_device *
|
| +wl_data_device_manager_get_data_device(struct wl_data_device_manager *wl_data_device_manager, struct wl_seat *seat)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_data_device_manager,
|
| + WL_DATA_DEVICE_MANAGER_GET_DATA_DEVICE, &wl_data_device_interface, NULL, seat);
|
| +
|
| + return (struct wl_data_device *) id;
|
| +}
|
| +
|
| +#ifndef WL_SHELL_ERROR_ENUM
|
| +#define WL_SHELL_ERROR_ENUM
|
| +enum wl_shell_error {
|
| + WL_SHELL_ERROR_ROLE = 0,
|
| +};
|
| +#endif /* WL_SHELL_ERROR_ENUM */
|
| +
|
| +#define WL_SHELL_GET_SHELL_SURFACE 0
|
| +
|
| +static inline void
|
| +wl_shell_set_user_data(struct wl_shell *wl_shell, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_shell, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_shell_get_user_data(struct wl_shell *wl_shell)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_shell);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_destroy(struct wl_shell *wl_shell)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_shell);
|
| +}
|
| +
|
| +static inline struct wl_shell_surface *
|
| +wl_shell_get_shell_surface(struct wl_shell *wl_shell, struct wl_surface *surface)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_shell,
|
| + WL_SHELL_GET_SHELL_SURFACE, &wl_shell_surface_interface, NULL, surface);
|
| +
|
| + return (struct wl_shell_surface *) id;
|
| +}
|
| +
|
| +#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
|
| + * @ping: ping client
|
| + * @configure: suggest resize
|
| + * @popup_done: popup interaction is done
|
| + *
|
| + * 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_listener {
|
| + /**
|
| + * ping - ping client
|
| + * @serial: (none)
|
| + *
|
| + * Ping a client to check if it is receiving events and sending
|
| + * requests. A client is expected to reply with a pong request.
|
| + */
|
| + void (*ping)(void *data,
|
| + struct wl_shell_surface *wl_shell_surface,
|
| + uint32_t serial);
|
| + /**
|
| + * configure - suggest resize
|
| + * @edges: (none)
|
| + * @width: (none)
|
| + * @height: (none)
|
| + *
|
| + * The configure event asks the client to resize its surface.
|
| + *
|
| + * The size is a hint, in the sense that the client is free to
|
| + * ignore it if it doesn't resize, pick a smaller size (to satisfy
|
| + * aspect ratio or resize in steps of NxM pixels).
|
| + *
|
| + * The edges parameter provides a hint about how the surface was
|
| + * resized. The client may use this information to decide how to
|
| + * adjust its content to the new size (e.g. a scrolling area might
|
| + * adjust its content position to leave the viewable content
|
| + * unmoved).
|
| + *
|
| + * The client is free to dismiss all but the last configure event
|
| + * it received.
|
| + *
|
| + * The width and height arguments specify the size of the window in
|
| + * surface local coordinates.
|
| + */
|
| + void (*configure)(void *data,
|
| + struct wl_shell_surface *wl_shell_surface,
|
| + uint32_t edges,
|
| + int32_t width,
|
| + int32_t height);
|
| + /**
|
| + * popup_done - popup interaction is done
|
| + *
|
| + * The popup_done event is sent out when a popup grab is broken,
|
| + * that is, when the user clicks a surface that doesn't belong to
|
| + * the client owning the popup surface.
|
| + */
|
| + void (*popup_done)(void *data,
|
| + struct wl_shell_surface *wl_shell_surface);
|
| +};
|
| +
|
| +static inline int
|
| +wl_shell_surface_add_listener(struct wl_shell_surface *wl_shell_surface,
|
| + const struct wl_shell_surface_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_shell_surface,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_SHELL_SURFACE_PONG 0
|
| +#define WL_SHELL_SURFACE_MOVE 1
|
| +#define WL_SHELL_SURFACE_RESIZE 2
|
| +#define WL_SHELL_SURFACE_SET_TOPLEVEL 3
|
| +#define WL_SHELL_SURFACE_SET_TRANSIENT 4
|
| +#define WL_SHELL_SURFACE_SET_FULLSCREEN 5
|
| +#define WL_SHELL_SURFACE_SET_POPUP 6
|
| +#define WL_SHELL_SURFACE_SET_MAXIMIZED 7
|
| +#define WL_SHELL_SURFACE_SET_TITLE 8
|
| +#define WL_SHELL_SURFACE_SET_CLASS 9
|
| +
|
| +static inline void
|
| +wl_shell_surface_set_user_data(struct wl_shell_surface *wl_shell_surface, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_shell_surface, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_shell_surface_get_user_data(struct wl_shell_surface *wl_shell_surface)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_shell_surface);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_destroy(struct wl_shell_surface *wl_shell_surface)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_shell_surface);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_pong(struct wl_shell_surface *wl_shell_surface, uint32_t serial)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shell_surface,
|
| + WL_SHELL_SURFACE_PONG, serial);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_move(struct wl_shell_surface *wl_shell_surface, struct wl_seat *seat, uint32_t serial)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shell_surface,
|
| + WL_SHELL_SURFACE_MOVE, seat, serial);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_resize(struct wl_shell_surface *wl_shell_surface, struct wl_seat *seat, uint32_t serial, uint32_t edges)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shell_surface,
|
| + WL_SHELL_SURFACE_RESIZE, seat, serial, edges);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_set_toplevel(struct wl_shell_surface *wl_shell_surface)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shell_surface,
|
| + WL_SHELL_SURFACE_SET_TOPLEVEL);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_set_transient(struct wl_shell_surface *wl_shell_surface, struct wl_surface *parent, int32_t x, int32_t y, uint32_t flags)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shell_surface,
|
| + WL_SHELL_SURFACE_SET_TRANSIENT, parent, x, y, flags);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_set_fullscreen(struct wl_shell_surface *wl_shell_surface, uint32_t method, uint32_t framerate, struct wl_output *output)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shell_surface,
|
| + WL_SHELL_SURFACE_SET_FULLSCREEN, method, framerate, output);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_set_popup(struct wl_shell_surface *wl_shell_surface, struct wl_seat *seat, uint32_t serial, struct wl_surface *parent, int32_t x, int32_t y, uint32_t flags)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shell_surface,
|
| + WL_SHELL_SURFACE_SET_POPUP, seat, serial, parent, x, y, flags);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_set_maximized(struct wl_shell_surface *wl_shell_surface, struct wl_output *output)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shell_surface,
|
| + WL_SHELL_SURFACE_SET_MAXIMIZED, output);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_set_title(struct wl_shell_surface *wl_shell_surface, const char *title)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shell_surface,
|
| + WL_SHELL_SURFACE_SET_TITLE, title);
|
| +}
|
| +
|
| +static inline void
|
| +wl_shell_surface_set_class(struct wl_shell_surface *wl_shell_surface, const char *class_)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_shell_surface,
|
| + WL_SHELL_SURFACE_SET_CLASS, class_);
|
| +}
|
| +
|
| +#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
|
| + * @enter: surface enters an output
|
| + * @leave: surface leaves an output
|
| + *
|
| + * 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_listener {
|
| + /**
|
| + * enter - surface enters an output
|
| + * @output: (none)
|
| + *
|
| + * This is emitted whenever a surface's creation, movement, or
|
| + * resizing results in some part of it being within the scanout
|
| + * region of an output.
|
| + *
|
| + * Note that a surface may be overlapping with zero or more
|
| + * outputs.
|
| + */
|
| + void (*enter)(void *data,
|
| + struct wl_surface *wl_surface,
|
| + struct wl_output *output);
|
| + /**
|
| + * leave - surface leaves an output
|
| + * @output: (none)
|
| + *
|
| + * This is emitted whenever a surface's creation, movement, or
|
| + * resizing results in it no longer having any part of it within
|
| + * the scanout region of an output.
|
| + */
|
| + void (*leave)(void *data,
|
| + struct wl_surface *wl_surface,
|
| + struct wl_output *output);
|
| +};
|
| +
|
| +static inline int
|
| +wl_surface_add_listener(struct wl_surface *wl_surface,
|
| + const struct wl_surface_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_surface,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_SURFACE_DESTROY 0
|
| +#define WL_SURFACE_ATTACH 1
|
| +#define WL_SURFACE_DAMAGE 2
|
| +#define WL_SURFACE_FRAME 3
|
| +#define WL_SURFACE_SET_OPAQUE_REGION 4
|
| +#define WL_SURFACE_SET_INPUT_REGION 5
|
| +#define WL_SURFACE_COMMIT 6
|
| +#define WL_SURFACE_SET_BUFFER_TRANSFORM 7
|
| +#define WL_SURFACE_SET_BUFFER_SCALE 8
|
| +
|
| +static inline void
|
| +wl_surface_set_user_data(struct wl_surface *wl_surface, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_surface, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_surface_get_user_data(struct wl_surface *wl_surface)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_surface);
|
| +}
|
| +
|
| +static inline void
|
| +wl_surface_destroy(struct wl_surface *wl_surface)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_surface,
|
| + WL_SURFACE_DESTROY);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_surface);
|
| +}
|
| +
|
| +static inline void
|
| +wl_surface_attach(struct wl_surface *wl_surface, struct wl_buffer *buffer, int32_t x, int32_t y)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_surface,
|
| + WL_SURFACE_ATTACH, buffer, x, y);
|
| +}
|
| +
|
| +static inline void
|
| +wl_surface_damage(struct wl_surface *wl_surface, int32_t x, int32_t y, int32_t width, int32_t height)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_surface,
|
| + WL_SURFACE_DAMAGE, x, y, width, height);
|
| +}
|
| +
|
| +static inline struct wl_callback *
|
| +wl_surface_frame(struct wl_surface *wl_surface)
|
| +{
|
| + struct wl_proxy *callback;
|
| +
|
| + callback = wl_proxy_marshal_constructor((struct wl_proxy *) wl_surface,
|
| + WL_SURFACE_FRAME, &wl_callback_interface, NULL);
|
| +
|
| + return (struct wl_callback *) callback;
|
| +}
|
| +
|
| +static inline void
|
| +wl_surface_set_opaque_region(struct wl_surface *wl_surface, struct wl_region *region)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_surface,
|
| + WL_SURFACE_SET_OPAQUE_REGION, region);
|
| +}
|
| +
|
| +static inline void
|
| +wl_surface_set_input_region(struct wl_surface *wl_surface, struct wl_region *region)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_surface,
|
| + WL_SURFACE_SET_INPUT_REGION, region);
|
| +}
|
| +
|
| +static inline void
|
| +wl_surface_commit(struct wl_surface *wl_surface)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_surface,
|
| + WL_SURFACE_COMMIT);
|
| +}
|
| +
|
| +static inline void
|
| +wl_surface_set_buffer_transform(struct wl_surface *wl_surface, int32_t transform)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_surface,
|
| + WL_SURFACE_SET_BUFFER_TRANSFORM, transform);
|
| +}
|
| +
|
| +static inline void
|
| +wl_surface_set_buffer_scale(struct wl_surface *wl_surface, int32_t scale)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_surface,
|
| + WL_SURFACE_SET_BUFFER_SCALE, scale);
|
| +}
|
| +
|
| +#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
|
| + * @capabilities: seat capabilities changed
|
| + * @name: unique identifier for this seat
|
| + *
|
| + * 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_listener {
|
| + /**
|
| + * capabilities - seat capabilities changed
|
| + * @capabilities: (none)
|
| + *
|
| + * This is emitted whenever a seat gains or loses the pointer,
|
| + * keyboard or touch capabilities. The argument is a capability
|
| + * enum containing the complete set of capabilities this seat has.
|
| + */
|
| + void (*capabilities)(void *data,
|
| + struct wl_seat *wl_seat,
|
| + uint32_t capabilities);
|
| + /**
|
| + * name - unique identifier for this seat
|
| + * @name: (none)
|
| + *
|
| + * In a multiseat configuration this can be used by the client to
|
| + * help identify which physical devices the seat represents. Based
|
| + * on the seat configuration used by the compositor.
|
| + * @since: 2
|
| + */
|
| + void (*name)(void *data,
|
| + struct wl_seat *wl_seat,
|
| + const char *name);
|
| +};
|
| +
|
| +static inline int
|
| +wl_seat_add_listener(struct wl_seat *wl_seat,
|
| + const struct wl_seat_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_seat,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_SEAT_GET_POINTER 0
|
| +#define WL_SEAT_GET_KEYBOARD 1
|
| +#define WL_SEAT_GET_TOUCH 2
|
| +
|
| +static inline void
|
| +wl_seat_set_user_data(struct wl_seat *wl_seat, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_seat, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_seat_get_user_data(struct wl_seat *wl_seat)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_seat);
|
| +}
|
| +
|
| +static inline void
|
| +wl_seat_destroy(struct wl_seat *wl_seat)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_seat);
|
| +}
|
| +
|
| +static inline struct wl_pointer *
|
| +wl_seat_get_pointer(struct wl_seat *wl_seat)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_seat,
|
| + WL_SEAT_GET_POINTER, &wl_pointer_interface, NULL);
|
| +
|
| + return (struct wl_pointer *) id;
|
| +}
|
| +
|
| +static inline struct wl_keyboard *
|
| +wl_seat_get_keyboard(struct wl_seat *wl_seat)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_seat,
|
| + WL_SEAT_GET_KEYBOARD, &wl_keyboard_interface, NULL);
|
| +
|
| + return (struct wl_keyboard *) id;
|
| +}
|
| +
|
| +static inline struct wl_touch *
|
| +wl_seat_get_touch(struct wl_seat *wl_seat)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_seat,
|
| + WL_SEAT_GET_TOUCH, &wl_touch_interface, NULL);
|
| +
|
| + return (struct wl_touch *) id;
|
| +}
|
| +
|
| +#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
|
| + * @enter: enter event
|
| + * @leave: leave event
|
| + * @motion: pointer motion event
|
| + * @button: pointer button event
|
| + * @axis: axis event
|
| + *
|
| + * 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_listener {
|
| + /**
|
| + * enter - enter event
|
| + * @serial: (none)
|
| + * @surface: (none)
|
| + * @surface_x: x coordinate in surface-relative coordinates
|
| + * @surface_y: y coordinate in surface-relative coordinates
|
| + *
|
| + * Notification that this seat's pointer is focused on a certain
|
| + * surface.
|
| + *
|
| + * When an seat's focus enters a surface, the pointer image is
|
| + * undefined and a client should respond to this event by setting
|
| + * an appropriate pointer image with the set_cursor request.
|
| + */
|
| + void (*enter)(void *data,
|
| + struct wl_pointer *wl_pointer,
|
| + uint32_t serial,
|
| + struct wl_surface *surface,
|
| + wl_fixed_t surface_x,
|
| + wl_fixed_t surface_y);
|
| + /**
|
| + * leave - leave event
|
| + * @serial: (none)
|
| + * @surface: (none)
|
| + *
|
| + * Notification that this seat's pointer is no longer focused on
|
| + * a certain surface.
|
| + *
|
| + * The leave notification is sent before the enter notification for
|
| + * the new focus.
|
| + */
|
| + void (*leave)(void *data,
|
| + struct wl_pointer *wl_pointer,
|
| + uint32_t serial,
|
| + struct wl_surface *surface);
|
| + /**
|
| + * motion - pointer motion event
|
| + * @time: timestamp with millisecond granularity
|
| + * @surface_x: x coordinate in surface-relative coordinates
|
| + * @surface_y: y coordinate in surface-relative coordinates
|
| + *
|
| + * Notification of pointer location change. The arguments
|
| + * surface_x and surface_y are the location relative to the focused
|
| + * surface.
|
| + */
|
| + void (*motion)(void *data,
|
| + struct wl_pointer *wl_pointer,
|
| + uint32_t time,
|
| + wl_fixed_t surface_x,
|
| + wl_fixed_t surface_y);
|
| + /**
|
| + * button - pointer button event
|
| + * @serial: (none)
|
| + * @time: timestamp with millisecond granularity
|
| + * @button: (none)
|
| + * @state: (none)
|
| + *
|
| + * Mouse button click and release notifications.
|
| + *
|
| + * The location of the click is given by the last motion or enter
|
| + * event. The time argument is a timestamp with millisecond
|
| + * granularity, with an undefined base.
|
| + */
|
| + void (*button)(void *data,
|
| + struct wl_pointer *wl_pointer,
|
| + uint32_t serial,
|
| + uint32_t time,
|
| + uint32_t button,
|
| + uint32_t state);
|
| + /**
|
| + * axis - axis event
|
| + * @time: timestamp with millisecond granularity
|
| + * @axis: (none)
|
| + * @value: (none)
|
| + *
|
| + * Scroll and other axis notifications.
|
| + *
|
| + * For scroll events (vertical and horizontal scroll axes), the
|
| + * value parameter is the length of a vector along the specified
|
| + * axis in a coordinate space identical to those of motion events,
|
| + * representing a relative movement along the specified axis.
|
| + *
|
| + * For devices that support movements non-parallel to axes multiple
|
| + * axis events will be emitted.
|
| + *
|
| + * When applicable, for example for touch pads, the server can
|
| + * choose to emit scroll events where the motion vector is
|
| + * equivalent to a motion event vector.
|
| + *
|
| + * When applicable, clients can transform its view relative to the
|
| + * scroll distance.
|
| + */
|
| + void (*axis)(void *data,
|
| + struct wl_pointer *wl_pointer,
|
| + uint32_t time,
|
| + uint32_t axis,
|
| + wl_fixed_t value);
|
| +};
|
| +
|
| +static inline int
|
| +wl_pointer_add_listener(struct wl_pointer *wl_pointer,
|
| + const struct wl_pointer_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_pointer,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_POINTER_SET_CURSOR 0
|
| +#define WL_POINTER_RELEASE 1
|
| +
|
| +static inline void
|
| +wl_pointer_set_user_data(struct wl_pointer *wl_pointer, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_pointer, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_pointer_get_user_data(struct wl_pointer *wl_pointer)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_pointer);
|
| +}
|
| +
|
| +static inline void
|
| +wl_pointer_destroy(struct wl_pointer *wl_pointer)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_pointer);
|
| +}
|
| +
|
| +static inline void
|
| +wl_pointer_set_cursor(struct wl_pointer *wl_pointer, uint32_t serial, struct wl_surface *surface, int32_t hotspot_x, int32_t hotspot_y)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_pointer,
|
| + WL_POINTER_SET_CURSOR, serial, surface, hotspot_x, hotspot_y);
|
| +}
|
| +
|
| +static inline void
|
| +wl_pointer_release(struct wl_pointer *wl_pointer)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_pointer,
|
| + WL_POINTER_RELEASE);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_pointer);
|
| +}
|
| +
|
| +#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
|
| + * @keymap: keyboard mapping
|
| + * @enter: enter event
|
| + * @leave: leave event
|
| + * @key: key event
|
| + * @modifiers: modifier and group state
|
| + * @repeat_info: repeat rate and delay
|
| + *
|
| + * The wl_keyboard interface represents one or more keyboards associated
|
| + * with a seat.
|
| + */
|
| +struct wl_keyboard_listener {
|
| + /**
|
| + * keymap - keyboard mapping
|
| + * @format: (none)
|
| + * @fd: (none)
|
| + * @size: (none)
|
| + *
|
| + * This event provides a file descriptor to the client which can
|
| + * be memory-mapped to provide a keyboard mapping description.
|
| + */
|
| + void (*keymap)(void *data,
|
| + struct wl_keyboard *wl_keyboard,
|
| + uint32_t format,
|
| + int32_t fd,
|
| + uint32_t size);
|
| + /**
|
| + * enter - enter event
|
| + * @serial: (none)
|
| + * @surface: (none)
|
| + * @keys: the currently pressed keys
|
| + *
|
| + * Notification that this seat's keyboard focus is on a certain
|
| + * surface.
|
| + */
|
| + void (*enter)(void *data,
|
| + struct wl_keyboard *wl_keyboard,
|
| + uint32_t serial,
|
| + struct wl_surface *surface,
|
| + struct wl_array *keys);
|
| + /**
|
| + * leave - leave event
|
| + * @serial: (none)
|
| + * @surface: (none)
|
| + *
|
| + * Notification that this seat's keyboard focus is no longer on a
|
| + * certain surface.
|
| + *
|
| + * The leave notification is sent before the enter notification for
|
| + * the new focus.
|
| + */
|
| + void (*leave)(void *data,
|
| + struct wl_keyboard *wl_keyboard,
|
| + uint32_t serial,
|
| + struct wl_surface *surface);
|
| + /**
|
| + * key - key event
|
| + * @serial: (none)
|
| + * @time: timestamp with millisecond granularity
|
| + * @key: (none)
|
| + * @state: (none)
|
| + *
|
| + * A key was pressed or released. The time argument is a
|
| + * timestamp with millisecond granularity, with an undefined base.
|
| + */
|
| + void (*key)(void *data,
|
| + struct wl_keyboard *wl_keyboard,
|
| + uint32_t serial,
|
| + uint32_t time,
|
| + uint32_t key,
|
| + uint32_t state);
|
| + /**
|
| + * modifiers - modifier and group state
|
| + * @serial: (none)
|
| + * @mods_depressed: (none)
|
| + * @mods_latched: (none)
|
| + * @mods_locked: (none)
|
| + * @group: (none)
|
| + *
|
| + * Notifies clients that the modifier and/or group state has
|
| + * changed, and it should update its local state.
|
| + */
|
| + void (*modifiers)(void *data,
|
| + struct wl_keyboard *wl_keyboard,
|
| + uint32_t serial,
|
| + uint32_t mods_depressed,
|
| + uint32_t mods_latched,
|
| + uint32_t mods_locked,
|
| + uint32_t group);
|
| + /**
|
| + * repeat_info - repeat rate and delay
|
| + * @rate: the rate of repeating keys in characters per second
|
| + * @delay: delay in milliseconds since key down until repeating
|
| + * starts
|
| + *
|
| + * Informs the client about the keyboard's repeat rate and delay.
|
| + *
|
| + * This event is sent as soon as the wl_keyboard object has been
|
| + * created, and is guaranteed to be received by the client before
|
| + * any key press event.
|
| + *
|
| + * Negative values for either rate or delay are illegal. A rate of
|
| + * zero will disable any repeating (regardless of the value of
|
| + * delay).
|
| + *
|
| + * This event can be sent later on as well with a new value if
|
| + * necessary, so clients should continue listening for the event
|
| + * past the creation of wl_keyboard.
|
| + * @since: 4
|
| + */
|
| + void (*repeat_info)(void *data,
|
| + struct wl_keyboard *wl_keyboard,
|
| + int32_t rate,
|
| + int32_t delay);
|
| +};
|
| +
|
| +static inline int
|
| +wl_keyboard_add_listener(struct wl_keyboard *wl_keyboard,
|
| + const struct wl_keyboard_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_keyboard,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_KEYBOARD_RELEASE 0
|
| +
|
| +static inline void
|
| +wl_keyboard_set_user_data(struct wl_keyboard *wl_keyboard, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_keyboard, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_keyboard_get_user_data(struct wl_keyboard *wl_keyboard)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_keyboard);
|
| +}
|
| +
|
| +static inline void
|
| +wl_keyboard_destroy(struct wl_keyboard *wl_keyboard)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_keyboard);
|
| +}
|
| +
|
| +static inline void
|
| +wl_keyboard_release(struct wl_keyboard *wl_keyboard)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_keyboard,
|
| + WL_KEYBOARD_RELEASE);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_keyboard);
|
| +}
|
| +
|
| +/**
|
| + * wl_touch - touchscreen input device
|
| + * @down: touch down event and beginning of a touch sequence
|
| + * @up: end of a touch event sequence
|
| + * @motion: update of touch point coordinates
|
| + * @frame: end of touch frame event
|
| + * @cancel: touch session cancelled
|
| + *
|
| + * 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_listener {
|
| + /**
|
| + * down - touch down event and beginning of a touch sequence
|
| + * @serial: (none)
|
| + * @time: timestamp with millisecond granularity
|
| + * @surface: (none)
|
| + * @id: the unique ID of this touch point
|
| + * @x: x coordinate in surface-relative coordinates
|
| + * @y: y coordinate in surface-relative coordinates
|
| + *
|
| + * A new touch point has appeared on the surface. This touch
|
| + * point is assigned a unique @id. Future events from this
|
| + * touchpoint reference this ID. The ID ceases to be valid after a
|
| + * touch up event and may be re-used in the future.
|
| + */
|
| + void (*down)(void *data,
|
| + struct wl_touch *wl_touch,
|
| + uint32_t serial,
|
| + uint32_t time,
|
| + struct wl_surface *surface,
|
| + int32_t id,
|
| + wl_fixed_t x,
|
| + wl_fixed_t y);
|
| + /**
|
| + * up - end of a touch event sequence
|
| + * @serial: (none)
|
| + * @time: timestamp with millisecond granularity
|
| + * @id: the unique ID of this touch point
|
| + *
|
| + * The touch point has disappeared. No further events will be
|
| + * sent for this touchpoint and the touch point's ID is released
|
| + * and may be re-used in a future touch down event.
|
| + */
|
| + void (*up)(void *data,
|
| + struct wl_touch *wl_touch,
|
| + uint32_t serial,
|
| + uint32_t time,
|
| + int32_t id);
|
| + /**
|
| + * motion - update of touch point coordinates
|
| + * @time: timestamp with millisecond granularity
|
| + * @id: the unique ID of this touch point
|
| + * @x: x coordinate in surface-relative coordinates
|
| + * @y: y coordinate in surface-relative coordinates
|
| + *
|
| + * A touchpoint has changed coordinates.
|
| + */
|
| + void (*motion)(void *data,
|
| + struct wl_touch *wl_touch,
|
| + uint32_t time,
|
| + int32_t id,
|
| + wl_fixed_t x,
|
| + wl_fixed_t y);
|
| + /**
|
| + * frame - end of touch frame event
|
| + *
|
| + * Indicates the end of a contact point list.
|
| + */
|
| + void (*frame)(void *data,
|
| + struct wl_touch *wl_touch);
|
| + /**
|
| + * cancel - touch session cancelled
|
| + *
|
| + * Sent if the compositor decides the touch stream is a global
|
| + * gesture. No further events are sent to the clients from that
|
| + * particular gesture. Touch cancellation applies to all touch
|
| + * points currently active on this client's surface. The client is
|
| + * responsible for finalizing the touch points, future touch points
|
| + * on this surface may re-use the touch point ID.
|
| + */
|
| + void (*cancel)(void *data,
|
| + struct wl_touch *wl_touch);
|
| +};
|
| +
|
| +static inline int
|
| +wl_touch_add_listener(struct wl_touch *wl_touch,
|
| + const struct wl_touch_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_touch,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +#define WL_TOUCH_RELEASE 0
|
| +
|
| +static inline void
|
| +wl_touch_set_user_data(struct wl_touch *wl_touch, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_touch, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_touch_get_user_data(struct wl_touch *wl_touch)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_touch);
|
| +}
|
| +
|
| +static inline void
|
| +wl_touch_destroy(struct wl_touch *wl_touch)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_touch);
|
| +}
|
| +
|
| +static inline void
|
| +wl_touch_release(struct wl_touch *wl_touch)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_touch,
|
| + WL_TOUCH_RELEASE);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_touch);
|
| +}
|
| +
|
| +#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 */
|
| +
|
| +/**
|
| + * wl_output - compositor output region
|
| + * @geometry: properties of the output
|
| + * @mode: advertise available modes for the output
|
| + * @done: sent all information about output
|
| + * @scale: output scaling properties
|
| + *
|
| + * An output describes part of the compositor geometry. The compositor
|
| + * works in the 'compositor coordinate system' and an output corresponds to
|
| + * rectangular area in that space that is actually visible. This typically
|
| + * corresponds to a monitor that displays part of the compositor space.
|
| + * This object is published as global during start up, or when a monitor is
|
| + * hotplugged.
|
| + */
|
| +struct wl_output_listener {
|
| + /**
|
| + * geometry - properties of the output
|
| + * @x: x position within the global compositor space
|
| + * @y: y position within the global compositor space
|
| + * @physical_width: width in millimeters of the output
|
| + * @physical_height: height in millimeters of the output
|
| + * @subpixel: subpixel orientation of the output
|
| + * @make: textual description of the manufacturer
|
| + * @model: textual description of the model
|
| + * @transform: transform that maps framebuffer to output
|
| + *
|
| + * The geometry event describes geometric properties of the
|
| + * output. The event is sent when binding to the output object and
|
| + * whenever any of the properties change.
|
| + */
|
| + void (*geometry)(void *data,
|
| + struct wl_output *wl_output,
|
| + 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);
|
| + /**
|
| + * mode - advertise available modes for the output
|
| + * @flags: bitfield of mode flags
|
| + * @width: width of the mode in hardware units
|
| + * @height: height of the mode in hardware units
|
| + * @refresh: vertical refresh rate in mHz
|
| + *
|
| + * The mode event describes an available mode for the output.
|
| + *
|
| + * The event is sent when binding to the output object and there
|
| + * will always be one mode, the current mode. The event is sent
|
| + * again if an output changes mode, for the mode that is now
|
| + * current. In other words, the current mode is always the last
|
| + * mode that was received with the current flag set.
|
| + *
|
| + * The size of a mode is given in physical hardware units of the
|
| + * output device. This is not necessarily the same as the output
|
| + * size in the global compositor space. For instance, the output
|
| + * may be scaled, as described in wl_output.scale, or transformed ,
|
| + * as described in wl_output.transform.
|
| + */
|
| + void (*mode)(void *data,
|
| + struct wl_output *wl_output,
|
| + uint32_t flags,
|
| + int32_t width,
|
| + int32_t height,
|
| + int32_t refresh);
|
| + /**
|
| + * done - sent all information about output
|
| + *
|
| + * This event is sent after all other properties has been sent
|
| + * after binding to the output object and after any other property
|
| + * changes done after that. This allows changes to the output
|
| + * properties to be seen as atomic, even if they happen via
|
| + * multiple events.
|
| + * @since: 2
|
| + */
|
| + void (*done)(void *data,
|
| + struct wl_output *wl_output);
|
| + /**
|
| + * scale - output scaling properties
|
| + * @factor: scaling factor of output
|
| + *
|
| + * This event contains scaling geometry information that is not
|
| + * in the geometry event. It may be sent after binding the output
|
| + * object or if the output scale changes later. If it is not sent,
|
| + * the client should assume a scale of 1.
|
| + *
|
| + * A scale larger than 1 means that the compositor will
|
| + * automatically scale surface buffers by this amount when
|
| + * rendering. This is used for very high resolution displays where
|
| + * applications rendering at the native resolution would be too
|
| + * small to be legible.
|
| + *
|
| + * It is intended that scaling aware clients track the current
|
| + * output of a surface, and if it is on a scaled output it should
|
| + * use wl_surface.set_buffer_scale with the scale of the output.
|
| + * That way the compositor can avoid scaling the surface, and the
|
| + * client can supply a higher detail image.
|
| + * @since: 2
|
| + */
|
| + void (*scale)(void *data,
|
| + struct wl_output *wl_output,
|
| + int32_t factor);
|
| +};
|
| +
|
| +static inline int
|
| +wl_output_add_listener(struct wl_output *wl_output,
|
| + const struct wl_output_listener *listener, void *data)
|
| +{
|
| + return wl_proxy_add_listener((struct wl_proxy *) wl_output,
|
| + (void (**)(void)) listener, data);
|
| +}
|
| +
|
| +static inline void
|
| +wl_output_set_user_data(struct wl_output *wl_output, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_output, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_output_get_user_data(struct wl_output *wl_output)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_output);
|
| +}
|
| +
|
| +static inline void
|
| +wl_output_destroy(struct wl_output *wl_output)
|
| +{
|
| + wl_proxy_destroy((struct wl_proxy *) wl_output);
|
| +}
|
| +
|
| +#define WL_REGION_DESTROY 0
|
| +#define WL_REGION_ADD 1
|
| +#define WL_REGION_SUBTRACT 2
|
| +
|
| +static inline void
|
| +wl_region_set_user_data(struct wl_region *wl_region, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_region, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_region_get_user_data(struct wl_region *wl_region)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_region);
|
| +}
|
| +
|
| +static inline void
|
| +wl_region_destroy(struct wl_region *wl_region)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_region,
|
| + WL_REGION_DESTROY);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_region);
|
| +}
|
| +
|
| +static inline void
|
| +wl_region_add(struct wl_region *wl_region, int32_t x, int32_t y, int32_t width, int32_t height)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_region,
|
| + WL_REGION_ADD, x, y, width, height);
|
| +}
|
| +
|
| +static inline void
|
| +wl_region_subtract(struct wl_region *wl_region, int32_t x, int32_t y, int32_t width, int32_t height)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_region,
|
| + WL_REGION_SUBTRACT, x, y, width, 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 */
|
| +
|
| +#define WL_SUBCOMPOSITOR_DESTROY 0
|
| +#define WL_SUBCOMPOSITOR_GET_SUBSURFACE 1
|
| +
|
| +static inline void
|
| +wl_subcompositor_set_user_data(struct wl_subcompositor *wl_subcompositor, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_subcompositor, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_subcompositor_get_user_data(struct wl_subcompositor *wl_subcompositor)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_subcompositor);
|
| +}
|
| +
|
| +static inline void
|
| +wl_subcompositor_destroy(struct wl_subcompositor *wl_subcompositor)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_subcompositor,
|
| + WL_SUBCOMPOSITOR_DESTROY);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_subcompositor);
|
| +}
|
| +
|
| +static inline struct wl_subsurface *
|
| +wl_subcompositor_get_subsurface(struct wl_subcompositor *wl_subcompositor, struct wl_surface *surface, struct wl_surface *parent)
|
| +{
|
| + struct wl_proxy *id;
|
| +
|
| + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_subcompositor,
|
| + WL_SUBCOMPOSITOR_GET_SUBSURFACE, &wl_subsurface_interface, NULL, surface, parent);
|
| +
|
| + return (struct wl_subsurface *) id;
|
| +}
|
| +
|
| +#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 */
|
| +
|
| +#define WL_SUBSURFACE_DESTROY 0
|
| +#define WL_SUBSURFACE_SET_POSITION 1
|
| +#define WL_SUBSURFACE_PLACE_ABOVE 2
|
| +#define WL_SUBSURFACE_PLACE_BELOW 3
|
| +#define WL_SUBSURFACE_SET_SYNC 4
|
| +#define WL_SUBSURFACE_SET_DESYNC 5
|
| +
|
| +static inline void
|
| +wl_subsurface_set_user_data(struct wl_subsurface *wl_subsurface, void *user_data)
|
| +{
|
| + wl_proxy_set_user_data((struct wl_proxy *) wl_subsurface, user_data);
|
| +}
|
| +
|
| +static inline void *
|
| +wl_subsurface_get_user_data(struct wl_subsurface *wl_subsurface)
|
| +{
|
| + return wl_proxy_get_user_data((struct wl_proxy *) wl_subsurface);
|
| +}
|
| +
|
| +static inline void
|
| +wl_subsurface_destroy(struct wl_subsurface *wl_subsurface)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_subsurface,
|
| + WL_SUBSURFACE_DESTROY);
|
| +
|
| + wl_proxy_destroy((struct wl_proxy *) wl_subsurface);
|
| +}
|
| +
|
| +static inline void
|
| +wl_subsurface_set_position(struct wl_subsurface *wl_subsurface, int32_t x, int32_t y)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_subsurface,
|
| + WL_SUBSURFACE_SET_POSITION, x, y);
|
| +}
|
| +
|
| +static inline void
|
| +wl_subsurface_place_above(struct wl_subsurface *wl_subsurface, struct wl_surface *sibling)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_subsurface,
|
| + WL_SUBSURFACE_PLACE_ABOVE, sibling);
|
| +}
|
| +
|
| +static inline void
|
| +wl_subsurface_place_below(struct wl_subsurface *wl_subsurface, struct wl_surface *sibling)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_subsurface,
|
| + WL_SUBSURFACE_PLACE_BELOW, sibling);
|
| +}
|
| +
|
| +static inline void
|
| +wl_subsurface_set_sync(struct wl_subsurface *wl_subsurface)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_subsurface,
|
| + WL_SUBSURFACE_SET_SYNC);
|
| +}
|
| +
|
| +static inline void
|
| +wl_subsurface_set_desync(struct wl_subsurface *wl_subsurface)
|
| +{
|
| + wl_proxy_marshal((struct wl_proxy *) wl_subsurface,
|
| + WL_SUBSURFACE_SET_DESYNC);
|
| +}
|
| +
|
| +#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