/*
 * 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.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

#define WL_DISPLAY_SYNC_SINCE_VERSION	1
#define WL_DISPLAY_GET_REGISTRY_SINCE_VERSION	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 uint32_t
wl_display_get_version(struct wl_display *wl_display)
{
	return wl_proxy_get_version((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

#define WL_REGISTRY_BIND_SINCE_VERSION	1

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 uint32_t
wl_registry_get_version(struct wl_registry *wl_registry)
{
	return wl_proxy_get_version((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_versioned((struct wl_proxy *) wl_registry,
			 WL_REGISTRY_BIND, interface, version, 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 uint32_t
wl_callback_get_version(struct wl_callback *wl_callback)
{
	return wl_proxy_get_version((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

#define WL_COMPOSITOR_CREATE_SURFACE_SINCE_VERSION	1
#define WL_COMPOSITOR_CREATE_REGION_SINCE_VERSION	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 uint32_t
wl_compositor_get_version(struct wl_compositor *wl_compositor)
{
	return wl_proxy_get_version((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

#define WL_SHM_POOL_CREATE_BUFFER_SINCE_VERSION	1
#define WL_SHM_POOL_DESTROY_SINCE_VERSION	1
#define WL_SHM_POOL_RESIZE_SINCE_VERSION	1

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 uint32_t
wl_shm_pool_get_version(struct wl_shm_pool *wl_shm_pool)
{
	return wl_proxy_get_version((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

#define WL_SHM_CREATE_POOL_SINCE_VERSION	1

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 uint32_t
wl_shm_get_version(struct wl_shm *wl_shm)
{
	return wl_proxy_get_version((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

#define WL_BUFFER_DESTROY_SINCE_VERSION	1

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 uint32_t
wl_buffer_get_version(struct wl_buffer *wl_buffer)
{
	return wl_proxy_get_version((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);
}

#ifndef WL_DATA_OFFER_ERROR_ENUM
#define WL_DATA_OFFER_ERROR_ENUM
enum wl_data_offer_error {
	WL_DATA_OFFER_ERROR_INVALID_FINISH = 0,
	WL_DATA_OFFER_ERROR_INVALID_ACTION_MASK = 1,
	WL_DATA_OFFER_ERROR_INVALID_ACTION = 2,
	WL_DATA_OFFER_ERROR_INVALID_OFFER = 3,
};
#endif /* WL_DATA_OFFER_ERROR_ENUM */

/**
 * wl_data_offer - offer to transfer data
 * @offer: advertise offered mime type
 * @source_actions: notify the source-side available actions
 * @action: notify the selected action
 *
 * 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);
	/**
	 * source_actions - notify the source-side available actions
	 * @source_actions: (none)
	 *
	 * This event indicates the actions offered by the data source.
	 * It will be sent right after wl_data_device.enter, or anytime the
	 * source side changes its offered actions through
	 * wl_data_source.set_actions.
	 * @since: 3
	 */
	void (*source_actions)(void *data,
			       struct wl_data_offer *wl_data_offer,
			       uint32_t source_actions);
	/**
	 * action - notify the selected action
	 * @dnd_action: (none)
	 *
	 * This event indicates the action selected by the compositor
	 * after matching the source/destination side actions. Only one
	 * action (or none) will be offered here.
	 *
	 * This event can be emitted multiple times during the
	 * drag-and-drop operation in response to destination side action
	 * changes through wl_data_offer.set_actions.
	 *
	 * This event will no longer be emitted after wl_data_device.drop
	 * happened on the drag-and-drop destination, the client must honor
	 * the last action received, or the last preferred one set through
	 * wl_data_offer.set_actions when handling an "ask" action.
	 *
	 * Compositors may also change the selected action on the fly,
	 * mainly in response to keyboard modifier changes during the
	 * drag-and-drop operation.
	 *
	 * The most recent action received is always the valid one. Prior
	 * to receiving wl_data_device.drop, the chosen action may change
	 * (e.g. due to keyboard modifiers being pressed). At the time of
	 * receiving wl_data_device.drop the drag-and-drop destination must
	 * honor the last action received.
	 *
	 * Action changes may still happen after wl_data_device.drop,
	 * especially on "ask" actions, where the drag-and-drop destination
	 * may choose another action afterwards. Action changes happening
	 * at this stage are always the result of inter-client negotiation,
	 * the compositor shall no longer be able to induce a different
	 * action.
	 *
	 * Upon "ask" actions, it is expected that the drag-and-drop
	 * destination may potentially choose different a different action
	 * and/or mime type, based on wl_data_offer.source_actions and
	 * finally chosen by the user (e.g. popping up a menu with the
	 * available options). The final wl_data_offer.set_actions and
	 * wl_data_offer.accept requests must happen before the call to
	 * wl_data_offer.finish.
	 * @since: 3
	 */
	void (*action)(void *data,
		       struct wl_data_offer *wl_data_offer,
		       uint32_t dnd_action);
};

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
#define WL_DATA_OFFER_FINISH	3
#define WL_DATA_OFFER_SET_ACTIONS	4

#define WL_DATA_OFFER_ACCEPT_SINCE_VERSION	1
#define WL_DATA_OFFER_RECEIVE_SINCE_VERSION	1
#define WL_DATA_OFFER_DESTROY_SINCE_VERSION	1
#define WL_DATA_OFFER_FINISH_SINCE_VERSION	3
#define WL_DATA_OFFER_SET_ACTIONS_SINCE_VERSION	3

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 uint32_t
wl_data_offer_get_version(struct wl_data_offer *wl_data_offer)
{
	return wl_proxy_get_version((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);
}

static inline void
wl_data_offer_finish(struct wl_data_offer *wl_data_offer)
{
	wl_proxy_marshal((struct wl_proxy *) wl_data_offer,
			 WL_DATA_OFFER_FINISH);
}

static inline void
wl_data_offer_set_actions(struct wl_data_offer *wl_data_offer, uint32_t dnd_actions, uint32_t preferred_action)
{
	wl_proxy_marshal((struct wl_proxy *) wl_data_offer,
			 WL_DATA_OFFER_SET_ACTIONS, dnd_actions, preferred_action);
}

#ifndef WL_DATA_SOURCE_ERROR_ENUM
#define WL_DATA_SOURCE_ERROR_ENUM
enum wl_data_source_error {
	WL_DATA_SOURCE_ERROR_INVALID_ACTION_MASK = 0,
	WL_DATA_SOURCE_ERROR_INVALID_SOURCE = 1,
};
#endif /* WL_DATA_SOURCE_ERROR_ENUM */

/**
 * wl_data_source - offer to transfer data
 * @target: a target accepts an offered mime type
 * @send: send the data
 * @cancelled: selection was cancelled
 * @dnd_drop_performed: the drag-and-drop operation physically finished
 * @dnd_finished: the drag-and-drop operation concluded
 * @action: notify the selected action
 *
 * 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 is no longer valid. There are several reasons
	 * why this could happen:
	 *
	 * - The data source has been replaced by another data source. -
	 * The drag-and-drop operation was performed, but the drop
	 * destination did not accept any of the mimetypes offered through
	 * wl_data_source.target. - The drag-and-drop operation was
	 * performed, but the drop destination did not select any of the
	 * actions present in the mask offered through
	 * wl_data_source.action. - The drag-and-drop operation was
	 * performed but didn't happen over a surface. - The compositor
	 * cancelled the drag-and-drop operation (e.g. compositor dependent
	 * timeouts to avoid stale drag-and-drop transfers).
	 *
	 * The client should clean up and destroy this data source.
	 *
	 * For objects of version 2 or older, wl_data_source.cancelled will
	 * only be emitted if the data source was replaced by another data
	 * source.
	 */
	void (*cancelled)(void *data,
			  struct wl_data_source *wl_data_source);
	/**
	 * dnd_drop_performed - the drag-and-drop operation physically
	 *	finished
	 *
	 * The user performed the drop action. This event does not
	 * indicate acceptance, wl_data_source.cancelled may still be
	 * emitted afterwards if the drop destination does not accept any
	 * mimetype.
	 *
	 * However, this event might however not be received if the
	 * compositor cancelled the drag-and-drop operation before this
	 * event could happen.
	 *
	 * Note that the data_source may still be used in the future and
	 * should not be destroyed here.
	 * @since: 3
	 */
	void (*dnd_drop_performed)(void *data,
				   struct wl_data_source *wl_data_source);
	/**
	 * dnd_finished - the drag-and-drop operation concluded
	 *
	 * The drop destination finished interoperating with this data
	 * source, so the client is now free to destroy this data source
	 * and free all associated data.
	 *
	 * If the action used to perform the operation was "move", the
	 * source can now delete the transferred data.
	 * @since: 3
	 */
	void (*dnd_finished)(void *data,
			     struct wl_data_source *wl_data_source);
	/**
	 * action - notify the selected action
	 * @dnd_action: (none)
	 *
	 * This event indicates the action selected by the compositor
	 * after matching the source/destination side actions. Only one
	 * action (or none) will be offered here.
	 *
	 * This event can be emitted multiple times during the
	 * drag-and-drop operation, mainly in response to destination side
	 * changes through wl_data_offer.set_actions, and as the data
	 * device enters/leaves surfaces.
	 *
	 * It is only possible to receive this event after
	 * wl_data_source.dnd_drop_performed if the drag-and-drop operation
	 * ended in an "ask" action, in which case the final
	 * wl_data_source.action event will happen immediately before
	 * wl_data_source.dnd_finished.
	 *
	 * Compositors may also change the selected action on the fly,
	 * mainly in response to keyboard modifier changes during the
	 * drag-and-drop operation.
	 *
	 * The most recent action received is always the valid one. The
	 * chosen action may change alongside negotiation (e.g. an "ask"
	 * action can turn into a "move" operation), so the effects of the
	 * final action must always be applied in
	 * wl_data_offer.dnd_finished.
	 *
	 * Clients can trigger cursor surface changes from this point, so
	 * they reflect the current action.
	 * @since: 3
	 */
	void (*action)(void *data,
		       struct wl_data_source *wl_data_source,
		       uint32_t dnd_action);
};

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
#define WL_DATA_SOURCE_SET_ACTIONS	2

#define WL_DATA_SOURCE_OFFER_SINCE_VERSION	1
#define WL_DATA_SOURCE_DESTROY_SINCE_VERSION	1
#define WL_DATA_SOURCE_SET_ACTIONS_SINCE_VERSION	3

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 uint32_t
wl_data_source_get_version(struct wl_data_source *wl_data_source)
{
	return wl_proxy_get_version((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);
}

static inline void
wl_data_source_set_actions(struct wl_data_source *wl_data_source, uint32_t dnd_actions)
{
	wl_proxy_marshal((struct wl_proxy *) wl_data_source,
			 WL_DATA_SOURCE_SET_ACTIONS, dnd_actions);
}

#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.
	 *
	 * The drag-and-drop destination is expected to honor the last
	 * action received through wl_data_offer.action, if the resulting
	 * action is "copy" or "move", the destination can still perform
	 * wl_data_offer.receive requests, and is expected to end all
	 * transfers with a wl_data_offer.finish request.
	 *
	 * If the resulting action is "ask", the action will not be
	 * considered final. The drag-and-drop destination is expected to
	 * perform one last wl_data_offer.set_actions request, or
	 * wl_data_offer.destroy in order to cancel the operation.
	 */
	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

#define WL_DATA_DEVICE_START_DRAG_SINCE_VERSION	1
#define WL_DATA_DEVICE_SET_SELECTION_SINCE_VERSION	1
#define WL_DATA_DEVICE_RELEASE_SINCE_VERSION	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 uint32_t
wl_data_device_get_version(struct wl_data_device *wl_data_device)
{
	return wl_proxy_get_version((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);
}

#ifndef WL_DATA_DEVICE_MANAGER_DND_ACTION_ENUM
#define WL_DATA_DEVICE_MANAGER_DND_ACTION_ENUM
/**
 * wl_data_device_manager_dnd_action - drag and drop actions
 * @WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE: (none)
 * @WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY: (none)
 * @WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE: (none)
 * @WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK: (none)
 *
 * This is a bitmask of the available/preferred actions in a
 * drag-and-drop operation.
 *
 * In the compositor, the selected action is a result of matching the
 * actions offered by the source and destination sides. "action" events
 * with a "none" action will be sent to both source and destination if
 * there is no match. All further checks will effectively happen on (source
 * actions ∩ destination actions).
 *
 * In addition, compositors may also pick different actions in reaction to
 * key modifiers being pressed, one common design that is used in major
 * toolkits (and the behavior recommended for compositors) is:
 *
 * - If no modifiers are pressed, the first match (in bit order) will be
 * used. - Pressing Shift selects "move", if enabled in the mask. -
 * Pressing Control selects "copy", if enabled in the mask.
 *
 * Behavior beyond that is considered implementation-dependent. Compositors
 * may for example bind other modifiers (like Alt/Meta) or drags initiated
 * with other buttons than BTN_LEFT to specific actions (e.g. "ask").
 */
enum wl_data_device_manager_dnd_action {
	WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE = 0,
	WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY = 1,
	WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE = 2,
	WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK = 4,
};
#endif /* WL_DATA_DEVICE_MANAGER_DND_ACTION_ENUM */

#define WL_DATA_DEVICE_MANAGER_CREATE_DATA_SOURCE	0
#define WL_DATA_DEVICE_MANAGER_GET_DATA_DEVICE	1

#define WL_DATA_DEVICE_MANAGER_CREATE_DATA_SOURCE_SINCE_VERSION	1
#define WL_DATA_DEVICE_MANAGER_GET_DATA_DEVICE_SINCE_VERSION	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 uint32_t
wl_data_device_manager_get_version(struct wl_data_device_manager *wl_data_device_manager)
{
	return wl_proxy_get_version((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

#define WL_SHELL_GET_SHELL_SURFACE_SINCE_VERSION	1

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 uint32_t
wl_shell_get_version(struct wl_shell *wl_shell)
{
	return wl_proxy_get_version((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

#define WL_SHELL_SURFACE_PONG_SINCE_VERSION	1
#define WL_SHELL_SURFACE_MOVE_SINCE_VERSION	1
#define WL_SHELL_SURFACE_RESIZE_SINCE_VERSION	1
#define WL_SHELL_SURFACE_SET_TOPLEVEL_SINCE_VERSION	1
#define WL_SHELL_SURFACE_SET_TRANSIENT_SINCE_VERSION	1
#define WL_SHELL_SURFACE_SET_FULLSCREEN_SINCE_VERSION	1
#define WL_SHELL_SURFACE_SET_POPUP_SINCE_VERSION	1
#define WL_SHELL_SURFACE_SET_MAXIMIZED_SINCE_VERSION	1
#define WL_SHELL_SURFACE_SET_TITLE_SINCE_VERSION	1
#define WL_SHELL_SURFACE_SET_CLASS_SINCE_VERSION	1

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 uint32_t
wl_shell_surface_get_version(struct wl_shell_surface *wl_shell_surface)
{
	return wl_proxy_get_version((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
#define WL_SURFACE_DAMAGE_BUFFER	9

#define WL_SURFACE_DESTROY_SINCE_VERSION	1
#define WL_SURFACE_ATTACH_SINCE_VERSION	1
#define WL_SURFACE_DAMAGE_SINCE_VERSION	1
#define WL_SURFACE_FRAME_SINCE_VERSION	1
#define WL_SURFACE_SET_OPAQUE_REGION_SINCE_VERSION	1
#define WL_SURFACE_SET_INPUT_REGION_SINCE_VERSION	1
#define WL_SURFACE_COMMIT_SINCE_VERSION	1
#define WL_SURFACE_SET_BUFFER_TRANSFORM_SINCE_VERSION	2
#define WL_SURFACE_SET_BUFFER_SCALE_SINCE_VERSION	3
#define WL_SURFACE_DAMAGE_BUFFER_SINCE_VERSION	4

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 uint32_t
wl_surface_get_version(struct wl_surface *wl_surface)
{
	return wl_proxy_get_version((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);
}

static inline void
wl_surface_damage_buffer(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_BUFFER, x, y, width, height);
}

#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.
	 *
	 * When the pointer capability is added, a client may create a
	 * wl_pointer object using the wl_seat.get_pointer request. This
	 * object will receive pointer events until the capability is
	 * removed in the future.
	 *
	 * When the pointer capability is removed, a client should destroy
	 * the wl_pointer objects associated with the seat where the
	 * capability was removed, using the wl_pointer.release request. No
	 * further pointer events will be received on these objects.
	 *
	 * In some compositors, if a seat regains the pointer capability
	 * and a client has a previously obtained wl_pointer object of
	 * version 4 or less, that object may start sending pointer events
	 * again. This behavior is considered a misinterpretation of the
	 * intended behavior and must not be relied upon by the client.
	 * wl_pointer objects of version 5 or later must not send events if
	 * created before the most recent event notifying the client of an
	 * added pointer capability.
	 *
	 * The above behavior also applies to wl_keyboard and wl_touch with
	 * the keyboard and touch capabilities, respectively.
	 */
	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
#define WL_SEAT_RELEASE	3

#define WL_SEAT_GET_POINTER_SINCE_VERSION	1
#define WL_SEAT_GET_KEYBOARD_SINCE_VERSION	1
#define WL_SEAT_GET_TOUCH_SINCE_VERSION	1
#define WL_SEAT_RELEASE_SINCE_VERSION	5

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 uint32_t
wl_seat_get_version(struct wl_seat *wl_seat)
{
	return wl_proxy_get_version((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;
}

static inline void
wl_seat_release(struct wl_seat *wl_seat)
{
	wl_proxy_marshal((struct wl_proxy *) wl_seat,
			 WL_SEAT_RELEASE);

	wl_proxy_destroy((struct wl_proxy *) wl_seat);
}

#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 */

#ifndef WL_POINTER_AXIS_SOURCE_ENUM
#define WL_POINTER_AXIS_SOURCE_ENUM
/**
 * wl_pointer_axis_source - axis source types
 * @WL_POINTER_AXIS_SOURCE_WHEEL: A physical wheel
 * @WL_POINTER_AXIS_SOURCE_FINGER: Finger on a touch surface
 * @WL_POINTER_AXIS_SOURCE_CONTINUOUS: Continuous coordinate space
 *
 * Describes the source types for axis events. This indicates to the
 * client how an axis event was physically generated; a client may adjust
 * the user interface accordingly. For example, scroll events from a
 * "finger" source may be in a smooth coordinate space with kinetic
 * scrolling whereas a "wheel" source may be in discrete steps of a number
 * of lines.
 *
 * The "continuous" axis source is a device generating events in a
 * continuous coordinate space, but using something other than a finger.
 * One example for this source is button-based scrolling where the vertical
 * motion of a device is converted to scroll events while a button is held
 * down.
 */
enum wl_pointer_axis_source {
	WL_POINTER_AXIS_SOURCE_WHEEL = 0,
	WL_POINTER_AXIS_SOURCE_FINGER = 1,
	WL_POINTER_AXIS_SOURCE_CONTINUOUS = 2,
};
#endif /* WL_POINTER_AXIS_SOURCE_ENUM */

/**
 * wl_pointer - pointer input device
 * @enter: enter event
 * @leave: leave event
 * @motion: pointer motion event
 * @button: pointer button event
 * @axis: axis event
 * @frame: end of a pointer event sequence
 * @axis_source: axis source event
 * @axis_stop: axis stop event
 * @axis_discrete: axis click 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);
	/**
	 * frame - end of a pointer event sequence
	 *
	 * Indicates the end of a set of events that logically belong
	 * together. A client is expected to accumulate the data in all
	 * events within the frame before proceeding.
	 *
	 * All wl_pointer events before a wl_pointer.frame event belong
	 * logically together. For example, in a diagonal scroll motion the
	 * compositor will send an optional wl_pointer.axis_source event,
	 * two wl_pointer.axis events (horizontal and vertical) and finally
	 * a wl_pointer.frame event. The client may use this information to
	 * calculate a diagonal vector for scrolling.
	 *
	 * When multiple wl_pointer.axis events occur within the same
	 * frame, the motion vector is the combined motion of all events.
	 * When a wl_pointer.axis and a wl_pointer.axis_stop event occur
	 * within the same frame, this indicates that axis movement in one
	 * axis has stopped but continues in the other axis. When multiple
	 * wl_pointer.axis_stop events occur within in the same frame, this
	 * indicates that these axes stopped in the same instance.
	 *
	 * A wl_pointer.frame event is sent for every logical event group,
	 * even if the group only contains a single wl_pointer event.
	 * Specifically, a client may get a sequence: motion, frame,
	 * button, frame, axis, frame, axis_stop, frame.
	 *
	 * The wl_pointer.enter and wl_pointer.leave events are logical
	 * events generated by the compositor and not the hardware. These
	 * events are also grouped by a wl_pointer.frame. When a pointer
	 * moves from one surface to the another, a compositor should group
	 * the wl_pointer.leave event within the same wl_pointer.frame.
	 * However, a client must not rely on wl_pointer.leave and
	 * wl_pointer.enter being in the same wl_pointer.frame.
	 * Compositor-specific policies may require the wl_pointer.leave
	 * and wl_pointer.enter event being split across multiple
	 * wl_pointer.frame groups.
	 * @since: 5
	 */
	void (*frame)(void *data,
		      struct wl_pointer *wl_pointer);
	/**
	 * axis_source - axis source event
	 * @axis_source: (none)
	 *
	 * Source information for scroll and other axes.
	 *
	 * This event does not occur on its own. It is sent before a
	 * wl_pointer.frame event and carries the source information for
	 * all events within that frame.
	 *
	 * The source specifies how this event was generated. If the source
	 * is wl_pointer.axis_source.finger, a wl_pointer.axis_stop event
	 * will be sent when the user lifts the finger off the device.
	 *
	 * If the source is wl_pointer axis_source.wheel or
	 * wl_pointer.axis_source.continuous, a wl_pointer.axis_stop event
	 * may or may not be sent. Whether a compositor sends a axis_stop
	 * event for these sources is hardware-specific and
	 * implementation-dependent; clients must not rely on receiving an
	 * axis_stop event for these scroll sources and should treat scroll
	 * sequences from these scroll sources as unterminated by default.
	 *
	 * This event is optional. If the source is unknown for a
	 * particular axis event sequence, no event is sent. Only one
	 * wl_pointer.axis_source event is permitted per frame.
	 *
	 * The order of wl_pointer.axis_discrete and wl_pointer.axis_source
	 * is not guaranteed.
	 * @since: 5
	 */
	void (*axis_source)(void *data,
			    struct wl_pointer *wl_pointer,
			    uint32_t axis_source);
	/**
	 * axis_stop - axis stop event
	 * @time: timestamp with millisecond granularity
	 * @axis: the axis stopped with this event
	 *
	 * Stop notification for scroll and other axes.
	 *
	 * For some wl_pointer.axis_source types, a wl_pointer.axis_stop
	 * event is sent to notify a client that the axis sequence has
	 * terminated. This enables the client to implement kinetic
	 * scrolling. See the wl_pointer.axis_source documentation for
	 * information on when this event may be generated.
	 *
	 * Any wl_pointer.axis events with the same axis_source after this
	 * event should be considered as the start of a new axis motion.
	 *
	 * The timestamp is to be interpreted identical to the timestamp in
	 * the wl_pointer.axis event. The timestamp value may be the same
	 * as a preceeding wl_pointer.axis event.
	 * @since: 5
	 */
	void (*axis_stop)(void *data,
			  struct wl_pointer *wl_pointer,
			  uint32_t time,
			  uint32_t axis);
	/**
	 * axis_discrete - axis click event
	 * @axis: (none)
	 * @discrete: (none)
	 *
	 * Discrete step information for scroll and other axes.
	 *
	 * This event carries the axis value of the wl_pointer.axis event
	 * in discrete steps (e.g. mouse wheel clicks).
	 *
	 * This event does not occur on its own, it is coupled with a
	 * wl_pointer.axis event that represents this axis value on a
	 * continuous scale. The protocol guarantees that each
	 * axis_discrete event is always followed by exactly one axis event
	 * with the same axis number within the same wl_pointer.frame. Note
	 * that the protocol allows for other events to occur between the
	 * axis_discrete and its coupled axis event, including other
	 * axis_discrete or axis events.
	 *
	 * This event is optional; continuous scrolling devices like
	 * two-finger scrolling on touchpads do not have discrete steps and
	 * do not generate this event.
	 *
	 * The discrete value carries the directional information. e.g. a
	 * value of -2 is two steps towards the negative direction of this
	 * axis.
	 *
	 * The axis number is identical to the axis number in the associate
	 * axis event.
	 *
	 * The order of wl_pointer.axis_discrete and wl_pointer.axis_source
	 * is not guaranteed.
	 * @since: 5
	 */
	void (*axis_discrete)(void *data,
			      struct wl_pointer *wl_pointer,
			      uint32_t axis,
			      int32_t discrete);
};

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

#define WL_POINTER_SET_CURSOR_SINCE_VERSION	1
#define WL_POINTER_RELEASE_SINCE_VERSION	3

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 uint32_t
wl_pointer_get_version(struct wl_pointer *wl_pointer)
{
	return wl_proxy_get_version((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

#define WL_KEYBOARD_RELEASE_SINCE_VERSION	3

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 uint32_t
wl_keyboard_get_version(struct wl_keyboard *wl_keyboard)
{
	return wl_proxy_get_version((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

#define WL_TOUCH_RELEASE_SINCE_VERSION	3

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 uint32_t
wl_touch_get_version(struct wl_touch *wl_touch)
{
	return wl_proxy_get_version((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 uint32_t
wl_output_get_version(struct wl_output *wl_output)
{
	return wl_proxy_get_version((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

#define WL_REGION_DESTROY_SINCE_VERSION	1
#define WL_REGION_ADD_SINCE_VERSION	1
#define WL_REGION_SUBTRACT_SINCE_VERSION	1

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 uint32_t
wl_region_get_version(struct wl_region *wl_region)
{
	return wl_proxy_get_version((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

#define WL_SUBCOMPOSITOR_DESTROY_SINCE_VERSION	1
#define WL_SUBCOMPOSITOR_GET_SUBSURFACE_SINCE_VERSION	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 uint32_t
wl_subcompositor_get_version(struct wl_subcompositor *wl_subcompositor)
{
	return wl_proxy_get_version((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

#define WL_SUBSURFACE_DESTROY_SINCE_VERSION	1
#define WL_SUBSURFACE_SET_POSITION_SINCE_VERSION	1
#define WL_SUBSURFACE_PLACE_ABOVE_SINCE_VERSION	1
#define WL_SUBSURFACE_PLACE_BELOW_SINCE_VERSION	1
#define WL_SUBSURFACE_SET_SYNC_SINCE_VERSION	1
#define WL_SUBSURFACE_SET_DESYNC_SINCE_VERSION	1

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 uint32_t
wl_subsurface_get_version(struct wl_subsurface *wl_subsurface)
{
	return wl_proxy_get_version((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
