Update Wayland to version 1.9.91.

third_party/wayland/include/protocol/wayland-client-protocol.h

-/* 
+/*
  * 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.
  */
 
@@ skipping 123 matching lines @@
 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;
 }
@@ skipping 72 matching lines @@
 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((struct wl_proxy *) wl_registry,
-                         WL_REGISTRY_BIND, interface, name, interface->name, version, NULL);
+        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.
@@ skipping 11 matching lines @@
 };
 
 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;
@@ skipping 12 matching lines @@
         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;
 }
@@ skipping 190 matching lines @@
 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;
@@ skipping 38 matching lines @@
 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)
@@ skipping 15 matching lines @@
          * specified mime type over the passed file descriptor, then close
          * it.
          */
         void (*send)(void *data,
                      struct wl_data_source *wl_data_source,
                      const char *mime_type,
                      int32_t fd);
         /**
          * cancelled - selection was cancelled
          *
-         * This data source has been replaced by another data source. The
-         * client should clean up and destroy this data source.
+         * 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
@@ skipping 68 matching lines @@
         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
@@ skipping 15 matching lines @@
                             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;
@@ skipping 17 matching lines @@
 
 #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;
@@ skipping 157 matching lines @@
 #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,
@@ skipping 157 matching lines @@
 
 #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
@@ skipping 49 matching lines @@
                          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.
@@ skipping 16 matching lines @@
  * 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;
@@ skipping 19 matching lines @@
 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
 /**
@@ skipping 18 matching lines @@
  * @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 {
         /**
@@ skipping 86 matching lines @@
          * 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,
@@ skipping 162 matching lines @@
 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,
@@ skipping 96 matching lines @@
 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,
@@ skipping 184 matching lines @@
 };
 
 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
@@ skipping 13 matching lines @@
 #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 *
@@ skipping 14 matching lines @@
 };
 #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
@@ skipping 29 matching lines @@
 {
         wl_proxy_marshal((struct wl_proxy *) wl_subsurface,
                          WL_SUBSURFACE_SET_DESYNC);
 }
 
 #ifdef  __cplusplus
 }
 #endif
 
 #endif