<FUNCTION>
<NAME>file_transfer_portal_register</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>file_transfer_portal_register_files</NAME>
<RETURNS>void</RETURNS>
const char           **files, gboolean               writable, GAsyncReadyCallback    callback, gpointer               data
</FUNCTION>
<FUNCTION>
<NAME>file_transfer_portal_register_files_finish</NAME>
<RETURNS>gboolean</RETURNS>
GAsyncResult          *result, char                 **key, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>file_transfer_portal_retrieve_files</NAME>
<RETURNS>void</RETURNS>
const char            *key, GAsyncReadyCallback    callback, gpointer               data
</FUNCTION>
<FUNCTION>
<NAME>file_transfer_portal_retrieve_files_finish</NAME>
<RETURNS>gboolean</RETURNS>
GAsyncResult          *result, char                ***files, GError               **error
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_APP_LAUNCH_CONTEXT</NAME>
#define GDK_TYPE_APP_LAUNCH_CONTEXT         (gdk_app_launch_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_APP_LAUNCH_CONTEXT</NAME>
#define GDK_APP_LAUNCH_CONTEXT(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_APP_LAUNCH_CONTEXT, GdkAppLaunchContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_APP_LAUNCH_CONTEXT</NAME>
        #define GDK_IS_APP_LAUNCH_CONTEXT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_APP_LAUNCH_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_app_launch_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkAppLaunchContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_desktop</NAME>
<RETURNS>void</RETURNS>
GdkAppLaunchContext *context, gint                 desktop
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_timestamp</NAME>
<RETURNS>void</RETURNS>
GdkAppLaunchContext *context, guint32              timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_icon</NAME>
<RETURNS>void</RETURNS>
GdkAppLaunchContext *context, GIcon               *icon
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_icon_name</NAME>
<RETURNS>void</RETURNS>
GdkAppLaunchContext *context, const char          *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_set_source_rgba</NAME>
<RETURNS>void</RETURNS>
cairo_t              *cr, const GdkRGBA        *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_set_source_pixbuf</NAME>
<RETURNS>void</RETURNS>
cairo_t              *cr, const GdkPixbuf      *pixbuf, gdouble               pixbuf_x, gdouble               pixbuf_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_rectangle</NAME>
<RETURNS>void</RETURNS>
cairo_t              *cr, const GdkRectangle   *rectangle
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_region</NAME>
<RETURNS>void</RETURNS>
cairo_t              *cr, const cairo_region_t *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_region_create_from_surface</NAME>
<RETURNS>cairo_region_t *</RETURNS>
cairo_surface_t      *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_draw_from_gl</NAME>
<RETURNS>void</RETURNS>
cairo_t              *cr, GdkSurface            *surface, int                   source, int                   source_type, int                   buffer_scale, int                   x, int                   y, int                   width, int                   height
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_surface_upload_to_gl</NAME>
<RETURNS>void</RETURNS>
cairo_surface_t *surface, int              target, int              width, int              height, GdkGLContext    *context
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_CAIRO_CONTEXT</NAME>
#define GDK_TYPE_CAIRO_CONTEXT             (gdk_cairo_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CAIRO_CONTEXT</NAME>
#define GDK_CAIRO_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_CAIRO_CONTEXT, GdkCairoContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_CAIRO_CONTEXT</NAME>
#define GDK_IS_CAIRO_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_CAIRO_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_CAIRO_ERROR</NAME>
#define GDK_CAIRO_ERROR                    (gdk_cairo_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gdk_cairo_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_context_cairo_create</NAME>
<RETURNS>cairo_t *</RETURNS>
GdkCairoContext        *self
</FUNCTION>
<MACRO>
<NAME>GDK_CAIRO_CONTEXT_CLASS</NAME>
#define GDK_CAIRO_CONTEXT_CLASS(klass) 	        (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_CAIRO_CONTEXT, GdkCairoContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_CAIRO_CONTEXT_CLASS</NAME>
#define GDK_IS_CAIRO_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_CAIRO_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_CAIRO_CONTEXT_GET_CLASS</NAME>
#define GDK_CAIRO_CONTEXT_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_CAIRO_CONTEXT, GdkCairoContextClass))
</MACRO>
<STRUCT>
<NAME>GdkCairoContext</NAME>
struct _GdkCairoContext
{
  GdkDrawContext parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GdkCairoContextClass</NAME>
struct _GdkCairoContextClass
{
  GdkDrawContextClass parent_class;

  cairo_t *     (* cairo_create)                (GdkCairoContext        *self);
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_CLIPBOARD</NAME>
#define GDK_TYPE_CLIPBOARD            (gdk_clipboard_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CLIPBOARD</NAME>
#define GDK_CLIPBOARD(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_CLIPBOARD, GdkClipboard))
</MACRO>
<MACRO>
<NAME>GDK_IS_CLIPBOARD</NAME>
#define GDK_IS_CLIPBOARD(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_CLIPBOARD))
</MACRO>
<FUNCTION>
<NAME>gdk_clipboard_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkClipboard          *clipboard
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_get_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkClipboard          *clipboard
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_is_local</NAME>
<RETURNS>gboolean</RETURNS>
GdkClipboard          *clipboard
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_get_content</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GdkClipboard          *clipboard
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_store_async</NAME>
<RETURNS>void</RETURNS>
GdkClipboard          *clipboard, int                    io_priority, GCancellable          *cancellable, GAsyncReadyCallback    callback, gpointer               user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_store_finish</NAME>
<RETURNS>gboolean</RETURNS>
GdkClipboard          *clipboard, GAsyncResult          *result, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_read_async</NAME>
<RETURNS>void</RETURNS>
GdkClipboard          *clipboard, const char           **mime_types, int                    io_priority, GCancellable          *cancellable, GAsyncReadyCallback    callback, gpointer               user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_read_finish</NAME>
<RETURNS>GInputStream *</RETURNS>
GdkClipboard          *clipboard, GAsyncResult          *result, const char           **out_mime_type, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_read_value_async</NAME>
<RETURNS>void</RETURNS>
GdkClipboard          *clipboard, GType                  type, int                    io_priority, GCancellable          *cancellable, GAsyncReadyCallback    callback, gpointer               user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_read_value_finish</NAME>
<RETURNS>const GValue *</RETURNS>
GdkClipboard          *clipboard, GAsyncResult          *result, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_read_texture_async</NAME>
<RETURNS>void</RETURNS>
GdkClipboard          *clipboard, GCancellable          *cancellable, GAsyncReadyCallback    callback, gpointer               user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_read_texture_finish</NAME>
<RETURNS>GdkTexture *</RETURNS>
GdkClipboard         *clipboard, GAsyncResult          *result, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_read_text_async</NAME>
<RETURNS>void</RETURNS>
GdkClipboard          *clipboard, GCancellable          *cancellable, GAsyncReadyCallback    callback, gpointer               user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_read_text_finish</NAME>
<RETURNS>char *</RETURNS>
GdkClipboard          *clipboard, GAsyncResult          *result, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_set_content</NAME>
<RETURNS>gboolean</RETURNS>
GdkClipboard          *clipboard, GdkContentProvider    *provider
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_set</NAME>
<RETURNS>void</RETURNS>
GdkClipboard          *clipboard, GType                  type, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_set_valist</NAME>
<RETURNS>void</RETURNS>
GdkClipboard          *clipboard, GType                  type, va_list                args
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_set_value</NAME>
<RETURNS>void</RETURNS>
GdkClipboard          *clipboard, const GValue          *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_set_text</NAME>
<RETURNS>void</RETURNS>
GdkClipboard          *clipboard, const char            *text
</FUNCTION>
<FUNCTION>
<NAME>gdk_clipboard_set_texture</NAME>
<RETURNS>void</RETURNS>
GdkClipboard          *clipboard, GdkTexture            *texture
</FUNCTION>
<MACRO>
<NAME>G_DEFINE_CONSTRUCTOR</NAME>
#define G_DEFINE_CONSTRUCTOR(_func) G_MSVC_CTOR (_func, G_MSVC_SYMBOL_PREFIX)
</MACRO>
<MACRO>
<NAME>G_DEFINE_DESTRUCTOR</NAME>
#define G_DEFINE_DESTRUCTOR(_func) G_MSVC_DTOR (_func, G_MSVC_SYMBOL_PREFIX)
</MACRO>
<MACRO>
<NAME>G_MSVC_CTOR</NAME>
#define G_MSVC_CTOR(_func,_sym_prefix) \
  static void _func(void); \
  extern int (* _array ## _func)(void);              \
  int _func ## _wrapper(void) { _func(); g_slist_find (NULL,  _array ## _func); return 0; } \
  __pragma(comment(linker,"/include:" _sym_prefix # _func "_wrapper")) \
  __pragma(section(".CRT$XCU",read)) \
  __declspec(allocate(".CRT$XCU")) int (* _array ## _func)(void) = _func ## _wrapper;
</MACRO>
<MACRO>
<NAME>G_MSVC_DTOR</NAME>
#define G_MSVC_DTOR(_func,_sym_prefix) \
  static void _func(void); \
  extern int (* _array ## _func)(void);              \
  int _func ## _constructor(void) { atexit (_func); g_slist_find (NULL,  _array ## _func); return 0; } \
   __pragma(comment(linker,"/include:" _sym_prefix # _func "_constructor")) \
  __pragma(section(".CRT$XCU",read)) \
  __declspec(allocate(".CRT$XCU")) int (* _array ## _func)(void) = _func ## _constructor;
</MACRO>
<MACRO>
<NAME>G_HAS_CONSTRUCTORS</NAME>
#define G_HAS_CONSTRUCTORS 1
</MACRO>
<MACRO>
<NAME>G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA</NAME>
#define G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA 1
</MACRO>
<MACRO>
<NAME>G_DEFINE_DESTRUCTOR_NEEDS_PRAGMA</NAME>
#define G_DEFINE_DESTRUCTOR_NEEDS_PRAGMA 1
</MACRO>
<MACRO>
<NAME>G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS</NAME>
#define G_DEFINE_CONSTRUCTOR_PRAGMA_ARGS(_func) \
  section(".CRT$XCU",read)
</MACRO>
<MACRO>
<NAME>G_DEFINE_DESTRUCTOR_PRAGMA_ARGS</NAME>
#define G_DEFINE_DESTRUCTOR_PRAGMA_ARGS(_func) \
  section(".CRT$XCU",read)
</MACRO>
<MACRO>
<NAME>GDK_TYPE_CONTENT_DESERIALIZER</NAME>
#define GDK_TYPE_CONTENT_DESERIALIZER         (gdk_content_deserializer_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_DESERIALIZER</NAME>
#define GDK_CONTENT_DESERIALIZER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_CONTENT_DESERIALIZER, GdkContentDeserializer))
</MACRO>
<MACRO>
<NAME>GDK_IS_CONTENT_DESERIALIZER</NAME>
#define GDK_IS_CONTENT_DESERIALIZER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_CONTENT_DESERIALIZER))
</MACRO>
<USER_FUNCTION>
<NAME>GdkContentDeserializeFunc</NAME>
<RETURNS>void</RETURNS>
GdkContentDeserializer *deserializer
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_get_mime_type</NAME>
<RETURNS>const char *</RETURNS>
GdkContentDeserializer *deserializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_get_gtype</NAME>
<RETURNS>GType</RETURNS>
GdkContentDeserializer *deserializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_get_value</NAME>
<RETURNS>GValue *</RETURNS>
GdkContentDeserializer *deserializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_get_input_stream</NAME>
<RETURNS>GInputStream *</RETURNS>
GdkContentDeserializer *deserializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_get_priority</NAME>
<RETURNS>int</RETURNS>
GdkContentDeserializer *deserializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_get_cancellable</NAME>
<RETURNS>GCancellable *</RETURNS>
GdkContentDeserializer *deserializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_get_user_data</NAME>
<RETURNS>gpointer</RETURNS>
GdkContentDeserializer *deserializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_set_task_data</NAME>
<RETURNS>void</RETURNS>
GdkContentDeserializer *deserializer, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_get_task_data</NAME>
<RETURNS>gpointer</RETURNS>
GdkContentDeserializer *deserializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_return_success</NAME>
<RETURNS>void</RETURNS>
GdkContentDeserializer *deserializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserializer_return_error</NAME>
<RETURNS>void</RETURNS>
GdkContentDeserializer *deserializer, GError                 *error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union_deserialize_gtypes</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union_deserialize_mime_types</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_register_deserializer</NAME>
<RETURNS>void</RETURNS>
const char             *mime_type, GType                   type, GdkContentDeserializeFunc deserialize, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserialize_async</NAME>
<RETURNS>void</RETURNS>
GInputStream           *stream, const char             *mime_type, GType                   type, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_deserialize_finish</NAME>
<RETURNS>gboolean</RETURNS>
GAsyncResult           *result, GValue                 *value, GError                **error
</FUNCTION>
<STRUCT>
<NAME>GdkContentDeserializer</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_CONTENT_FORMATS</NAME>
#define GDK_TYPE_CONTENT_FORMATS    (gdk_content_formats_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_intern_mime_type</NAME>
<RETURNS>const char *</RETURNS>
const char                     *string
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_new</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
const char                    **mime_types, guint                           n_mime_types
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_new_for_gtype</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GType                           type
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_ref</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormats              *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_unref</NAME>
<RETURNS>void</RETURNS>
GdkContentFormats              *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_print</NAME>
<RETURNS>void</RETURNS>
GdkContentFormats              *formats, GString                        *string
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_to_string</NAME>
<RETURNS>char *</RETURNS>
GdkContentFormats              *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_get_gtypes</NAME>
<RETURNS>const GType *</RETURNS>
const GdkContentFormats        *formats, gsize                          *n_gtypes
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_get_mime_types</NAME>
<RETURNS>const char * const *</RETURNS>
const GdkContentFormats        *formats, gsize                          *n_mime_types
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormats              *first, const GdkContentFormats        *second
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_match</NAME>
<RETURNS>gboolean</RETURNS>
const GdkContentFormats        *first, const GdkContentFormats        *second
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_match_gtype</NAME>
<RETURNS>GType</RETURNS>
const GdkContentFormats        *first, const GdkContentFormats        *second
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_match_mime_type</NAME>
<RETURNS>const char *</RETURNS>
const GdkContentFormats        *first, const GdkContentFormats        *second
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_contain_gtype</NAME>
<RETURNS>gboolean</RETURNS>
const GdkContentFormats        *formats, GType                           type
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_contain_mime_type</NAME>
<RETURNS>gboolean</RETURNS>
const GdkContentFormats        *formats, const char                     *mime_type
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_CONTENT_FORMATS_BUILDER</NAME>
#define GDK_TYPE_CONTENT_FORMATS_BUILDER (gdk_content_formats_builder_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_content_formats_builder_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_new</NAME>
<RETURNS>GdkContentFormatsBuilder *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_ref</NAME>
<RETURNS>GdkContentFormatsBuilder *</RETURNS>
GdkContentFormatsBuilder       *builder
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_unref</NAME>
<RETURNS>void</RETURNS>
GdkContentFormatsBuilder       *builder
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_free_to_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormatsBuilder  *builder
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_to_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormatsBuilder  *builder
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_add_formats</NAME>
<RETURNS>void</RETURNS>
GdkContentFormatsBuilder       *builder, const GdkContentFormats        *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_add_mime_type</NAME>
<RETURNS>void</RETURNS>
GdkContentFormatsBuilder      *builder, const char                     *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_add_gtype</NAME>
<RETURNS>void</RETURNS>
GdkContentFormatsBuilder       *builder, GType                           type
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_FILE_LIST</NAME>
#define GDK_TYPE_FILE_LIST (gdk_file_list_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_file_list_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkContentFormatsBuilder</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_CONTENT_PROVIDER</NAME>
#define GDK_TYPE_CONTENT_PROVIDER            (gdk_content_provider_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_PROVIDER</NAME>
#define GDK_CONTENT_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_CONTENT_PROVIDER, GdkContentProvider))
</MACRO>
<MACRO>
<NAME>GDK_IS_CONTENT_PROVIDER</NAME>
#define GDK_IS_CONTENT_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_CONTENT_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_PROVIDER_CLASS</NAME>
#define GDK_CONTENT_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_CONTENT_PROVIDER, GdkContentProviderClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_CONTENT_PROVIDER_CLASS</NAME>
#define GDK_IS_CONTENT_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_CONTENT_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_PROVIDER_GET_CLASS</NAME>
#define GDK_CONTENT_PROVIDER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_CONTENT_PROVIDER, GdkContentProviderClass))
</MACRO>
<STRUCT>
<NAME>GdkContentProvider</NAME>
struct _GdkContentProvider
{
  GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>GdkContentProviderClass</NAME>
struct _GdkContentProviderClass
{
  GObjectClass parent_class;

  /* signals */
  void                  (* content_changed)                             (GdkContentProvider     *provider);

  /* vfuncs */
  void                  (* attach_clipboard)                            (GdkContentProvider     *provider,
                                                                         GdkClipboard           *clipboard);
  void                  (* detach_clipboard)                            (GdkContentProvider     *provider,
                                                                         GdkClipboard           *clipboard);

  GdkContentFormats *   (* ref_formats)                                 (GdkContentProvider     *provider);
  GdkContentFormats *   (* ref_storable_formats)                        (GdkContentProvider     *provider);
  void                  (* write_mime_type_async)                       (GdkContentProvider     *provider,
                                                                         const char             *mime_type,
                                                                         GOutputStream          *stream,
                                                                         int                     io_priority,
                                                                         GCancellable           *cancellable,
                                                                         GAsyncReadyCallback     callback,
                                                                         gpointer                user_data);
  gboolean              (* write_mime_type_finish)                      (GdkContentProvider     *provider,
                                                                         GAsyncResult           *result,
                                                                         GError                **error);
  gboolean              (* get_value)                                   (GdkContentProvider     *provider,
                                                                         GValue                 *value,
                                                                         GError                **error);

  /*< private >*/
  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gdk_content_provider_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_ref_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentProvider     *provider
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_ref_storable_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentProvider     *provider
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_content_changed</NAME>
<RETURNS>void</RETURNS>
GdkContentProvider     *provider
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_write_mime_type_async</NAME>
<RETURNS>void</RETURNS>
GdkContentProvider     *provider, const char             *mime_type, GOutputStream          *stream, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_write_mime_type_finish</NAME>
<RETURNS>gboolean</RETURNS>
GdkContentProvider     *provider, GAsyncResult           *result, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_get_value</NAME>
<RETURNS>gboolean</RETURNS>
GdkContentProvider     *provider, GValue                 *value, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_for_value</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
const GValue           *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_typed</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GType                   type, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_union</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GdkContentProvider    **providers, gsize                   n_providers
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_for_bytes</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
const char             *mime_type, GBytes                 *bytes
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_CONTENT_SERIALIZER</NAME>
#define GDK_TYPE_CONTENT_SERIALIZER         (gdk_content_serializer_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_SERIALIZER</NAME>
#define GDK_CONTENT_SERIALIZER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_CONTENT_SERIALIZER, GdkContentSerializer))
</MACRO>
<MACRO>
<NAME>GDK_IS_CONTENT_SERIALIZER</NAME>
#define GDK_IS_CONTENT_SERIALIZER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_CONTENT_SERIALIZER))
</MACRO>
<USER_FUNCTION>
<NAME>GdkContentSerializeFunc</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer *serializer
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_mime_type</NAME>
<RETURNS>const char *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_gtype</NAME>
<RETURNS>GType</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_value</NAME>
<RETURNS>const GValue *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_output_stream</NAME>
<RETURNS>GOutputStream *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_priority</NAME>
<RETURNS>int</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_cancellable</NAME>
<RETURNS>GCancellable *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_user_data</NAME>
<RETURNS>gpointer</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_set_task_data</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer   *serializer, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_task_data</NAME>
<RETURNS>gpointer</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_return_success</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_return_error</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer   *serializer, GError                 *error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union_serialize_gtypes</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union_serialize_mime_types</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_register_serializer</NAME>
<RETURNS>void</RETURNS>
GType                   type, const char             *mime_type, GdkContentSerializeFunc serialize, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serialize_async</NAME>
<RETURNS>void</RETURNS>
GOutputStream          *stream, const char             *mime_type, const GValue           *value, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serialize_finish</NAME>
<RETURNS>gboolean</RETURNS>
GAsyncResult           *result, GError                **error
</FUNCTION>
<STRUCT>
<NAME>GdkContentSerializer</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_CURSOR</NAME>
#define GDK_TYPE_CURSOR              (gdk_cursor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CURSOR</NAME>
#define GDK_CURSOR(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_CURSOR, GdkCursor))
</MACRO>
<MACRO>
<NAME>GDK_IS_CURSOR</NAME>
#define GDK_IS_CURSOR(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_CURSOR))
</MACRO>
<FUNCTION>
<NAME>gdk_cursor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_new_from_texture</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkTexture      *texture, int              hotspot_x, int              hotspot_y, GdkCursor       *fallback
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_new_from_name</NAME>
<RETURNS>GdkCursor *</RETURNS>
const gchar     *name, GdkCursor       *fallback
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_fallback</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkCursor	  *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_name</NAME>
<RETURNS>const char *</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_texture</NAME>
<RETURNS>GdkTexture *</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_hotspot_x</NAME>
<RETURNS>int</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_hotspot_y</NAME>
<RETURNS>int</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DEVICE</NAME>
#define GDK_TYPE_DEVICE         (gdk_device_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE</NAME>
#define GDK_DEVICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE, GdkDevice))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE</NAME>
#define GDK_IS_DEVICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE))
</MACRO>
<ENUM>
<NAME>GdkInputSource</NAME>
typedef enum
{
  GDK_SOURCE_MOUSE,
  GDK_SOURCE_PEN,
  GDK_SOURCE_ERASER,
  GDK_SOURCE_CURSOR,
  GDK_SOURCE_KEYBOARD,
  GDK_SOURCE_TOUCHSCREEN,
  GDK_SOURCE_TOUCHPAD,
  GDK_SOURCE_TRACKPOINT,
  GDK_SOURCE_TABLET_PAD
} GdkInputSource;
</ENUM>
<ENUM>
<NAME>GdkDeviceType</NAME>
typedef enum {
  GDK_DEVICE_TYPE_MASTER,
  GDK_DEVICE_TYPE_SLAVE,
  GDK_DEVICE_TYPE_FLOATING
} GdkDeviceType;
</ENUM>
<MACRO>
<NAME>GDK_MAX_TIMECOORD_AXES</NAME>
#define GDK_MAX_TIMECOORD_AXES 128
</MACRO>
<STRUCT>
<NAME>GdkTimeCoord</NAME>
struct _GdkTimeCoord
{
  guint32 time;
  gdouble axes[GDK_MAX_TIMECOORD_AXES];
};
</STRUCT>
<FUNCTION>
<NAME>gdk_device_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_has_cursor</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_source</NAME>
<RETURNS>GdkInputSource</RETURNS>
GdkDevice    *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_n_keys</NAME>
<RETURNS>gint</RETURNS>
GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_key</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice       *device, guint            index_, guint           *keyval, GdkModifierType *modifiers
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_set_key</NAME>
<RETURNS>void</RETURNS>
GdkDevice      *device, guint           index_, guint           keyval, GdkModifierType modifiers
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis_use</NAME>
<RETURNS>GdkAxisUse</RETURNS>
GdkDevice         *device, guint              index_
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_set_axis_use</NAME>
<RETURNS>void</RETURNS>
GdkDevice         *device, guint              index_, GdkAxisUse         use
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_state</NAME>
<RETURNS>void</RETURNS>
GdkDevice         *device, GdkSurface         *surface, gdouble           *axes, GdkModifierType   *mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_surface_at_position</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDevice *device, double    *win_x, double    *win_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_history</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice         *device, GdkSurface         *surface, guint32            start, guint32            stop, GdkTimeCoord    ***events, gint              *n_events
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_free_history</NAME>
<RETURNS>void</RETURNS>
GdkTimeCoord     **events, gint               n_events
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_n_axes</NAME>
<RETURNS>gint</RETURNS>
GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis_names</NAME>
<RETURNS>char **</RETURNS>
GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis_value</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice       *device, gdouble         *axes, const char      *axis_label, gdouble         *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice         *device, gdouble           *axes, GdkAxisUse         use, gdouble           *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDevice      *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_associated_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkDevice     *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_list_slave_devices</NAME>
<RETURNS>GList *</RETURNS>
GdkDevice     *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_device_type</NAME>
<RETURNS>GdkDeviceType</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_last_event_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_vendor_id</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_product_id</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_seat</NAME>
<RETURNS>GdkSeat *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axes</NAME>
<RETURNS>GdkAxisFlags</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_num_touches</NAME>
<RETURNS>guint</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_device_tool</NAME>
<RETURNS>GdkDeviceTool *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_caps_lock_state</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_num_lock_state</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_scroll_lock_state</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_modifier_state</NAME>
<RETURNS>GdkModifierType</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_direction</NAME>
<RETURNS>PangoDirection</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_has_bidi_layouts</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DEVICE_PAD</NAME>
#define GDK_TYPE_DEVICE_PAD         (gdk_device_pad_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE_PAD</NAME>
#define GDK_DEVICE_PAD(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_PAD, GdkDevicePad))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE_PAD</NAME>
#define GDK_IS_DEVICE_PAD(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_PAD))
</MACRO>
<ENUM>
<NAME>GdkDevicePadFeature</NAME>
typedef enum {
  GDK_DEVICE_PAD_FEATURE_BUTTON,
  GDK_DEVICE_PAD_FEATURE_RING,
  GDK_DEVICE_PAD_FEATURE_STRIP
} GdkDevicePadFeature;
</ENUM>
<FUNCTION>
<NAME>gdk_device_pad_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_n_groups</NAME>
<RETURNS>gint</RETURNS>
GdkDevicePad *pad
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_group_n_modes</NAME>
<RETURNS>gint</RETURNS>
GdkDevicePad *pad, gint          group_idx
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_n_features</NAME>
<RETURNS>gint</RETURNS>
GdkDevicePad        *pad, GdkDevicePadFeature  feature
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_feature_group</NAME>
<RETURNS>gint</RETURNS>
GdkDevicePad        *pad, GdkDevicePadFeature  feature, gint                 feature_idx
</FUNCTION>
<STRUCT>
<NAME>GdkDevicePad</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDevicePadInterface</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TOOL</NAME>
#define GDK_TYPE_DEVICE_TOOL    (gdk_device_tool_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE_TOOL</NAME>
#define GDK_DEVICE_TOOL(o)      (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_TOOL, GdkDeviceTool))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE_TOOL</NAME>
#define GDK_IS_DEVICE_TOOL(o)   (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_TOOL))
</MACRO>
<ENUM>
<NAME>GdkDeviceToolType</NAME>
typedef enum {
  GDK_DEVICE_TOOL_TYPE_UNKNOWN,
  GDK_DEVICE_TOOL_TYPE_PEN,
  GDK_DEVICE_TOOL_TYPE_ERASER,
  GDK_DEVICE_TOOL_TYPE_BRUSH,
  GDK_DEVICE_TOOL_TYPE_PENCIL,
  GDK_DEVICE_TOOL_TYPE_AIRBRUSH,
  GDK_DEVICE_TOOL_TYPE_MOUSE,
  GDK_DEVICE_TOOL_TYPE_LENS,
} GdkDeviceToolType;
</ENUM>
<FUNCTION>
<NAME>gdk_device_tool_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_serial</NAME>
<RETURNS>guint64</RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_hardware_id</NAME>
<RETURNS>guint64</RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_tool_type</NAME>
<RETURNS>GdkDeviceToolType</RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<STRUCT>
<NAME>GdkDeviceTool</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_DISPLAY</NAME>
#define GDK_TYPE_DISPLAY              (gdk_display_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY</NAME>
#define GDK_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY, GdkDisplay))
</MACRO>
<MACRO>
<NAME>GDK_IS_DISPLAY</NAME>
#define GDK_IS_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY))
</MACRO>
<FUNCTION>
<NAME>gdk_display_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_open</NAME>
<RETURNS>GdkDisplay *</RETURNS>
const gchar *display_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_device_is_grabbed</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display, GdkDevice   *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_beep</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_sync</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_flush</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_close</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_closed</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_composited</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_rgba</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_supports_input_shapes</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default</NAME>
<RETURNS>GdkDisplay *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default_group</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_clipboard</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_primary_clipboard</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_notify_startup_complete</NAME>
<RETURNS>void</RETURNS>
GdkDisplay    *display, const gchar   *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_startup_notification_id</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_app_launch_context</NAME>
<RETURNS>GdkAppLaunchContext *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default_seat</NAME>
<RETURNS>GdkSeat *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_list_seats</NAME>
<RETURNS>GList *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitors</NAME>
<RETURNS>GListModel *</RETURNS>
GdkDisplay *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitor_at_surface</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay *display, GdkSurface  *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_put_event</NAME>
<RETURNS>void</RETURNS>
GdkDisplay     *display, GdkEvent       *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_map_keyval</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display, guint          keyval, GdkKeymapKey **keys, int           *n_keys
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_map_keycode</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display, guint          keycode, GdkKeymapKey **keys, guint        **keyvals, int           *n_entries
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_translate_key</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay      *display, guint            keycode, GdkModifierType  state, int              group, guint           *keyval, int             *effective_group, int             *level, GdkModifierType *consumed
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_setting</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay *display, const char *name, GValue     *value
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DISPLAY_MANAGER</NAME>
#define GDK_TYPE_DISPLAY_MANAGER              (gdk_display_manager_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY_MANAGER</NAME>
#define GDK_DISPLAY_MANAGER(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_MANAGER, GdkDisplayManager))
</MACRO>
<MACRO>
<NAME>GDK_IS_DISPLAY_MANAGER</NAME>
#define GDK_IS_DISPLAY_MANAGER(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY_MANAGER))
</MACRO>
<FUNCTION>
<NAME>gdk_display_manager_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_get</NAME>
<RETURNS>GdkDisplayManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_get_default_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDisplayManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_set_default_display</NAME>
<RETURNS>void</RETURNS>
GdkDisplayManager *manager, GdkDisplay        *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_list_displays</NAME>
<RETURNS>GSList *</RETURNS>
GdkDisplayManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_open_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDisplayManager *manager, const gchar       *name
</FUNCTION>
<FUNCTION>
<NAME>gdk_set_allowed_backends</NAME>
<RETURNS>void</RETURNS>
const gchar       *backends
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DRAG</NAME>
#define GDK_TYPE_DRAG              (gdk_drag_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DRAG</NAME>
#define GDK_DRAG(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAG, GdkDrag))
</MACRO>
<MACRO>
<NAME>GDK_IS_DRAG</NAME>
#define GDK_IS_DRAG(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAG))
</MACRO>
<ENUM>
<NAME>GdkDragCancelReason</NAME>
typedef enum {
  GDK_DRAG_CANCEL_NO_TARGET,
  GDK_DRAG_CANCEL_USER_CANCELLED,
  GDK_DRAG_CANCEL_ERROR
} GdkDragCancelReason;
</ENUM>
<FUNCTION>
<NAME>gdk_drag_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_actions</NAME>
<RETURNS>GdkDragAction</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_selected_action</NAME>
<RETURNS>GdkDragAction</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_action_is_unique</NAME>
<RETURNS>gboolean</RETURNS>
GdkDragAction   action
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_begin</NAME>
<RETURNS>GdkDrag *</RETURNS>
GdkSurface         *surface, GdkDevice          *device, GdkContentProvider *content, GdkDragAction       actions, double              dx, double              dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_drop_done</NAME>
<RETURNS>void</RETURNS>
GdkDrag  *drag, gboolean  success
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_drag_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_set_hotspot</NAME>
<RETURNS>void</RETURNS>
GdkDrag *drag, gint     hot_x, gint     hot_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_content</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrag *drag
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DRAG_SURFACE</NAME>
#define GDK_TYPE_DRAG_SURFACE (gdk_drag_surface_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_drag_surface_present</NAME>
<RETURNS>gboolean</RETURNS>
GdkDragSurface *drag_surface, int             width, int             height
</FUNCTION>
<STRUCT>
<NAME>GdkDragSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDragSurfaceInterface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDragSurfaceInterface</NAME>
struct _GdkDragSurfaceInterface
{
  GTypeInterface g_iface;

  gboolean (* present) (GdkDragSurface *drag_surface,
                        int             width,
                        int             height);
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_DRAW_CONTEXT</NAME>
#define GDK_TYPE_DRAW_CONTEXT             (gdk_draw_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DRAW_CONTEXT</NAME>
#define GDK_DRAW_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_DRAW_CONTEXT, GdkDrawContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_DRAW_CONTEXT</NAME>
#define GDK_IS_DRAW_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_DRAW_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_draw_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDrawContext         *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrawContext         *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_begin_frame</NAME>
<RETURNS>void</RETURNS>
GdkDrawContext         *context, const cairo_region_t   *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_end_frame</NAME>
<RETURNS>void</RETURNS>
GdkDrawContext         *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_is_in_frame</NAME>
<RETURNS>gboolean</RETURNS>
GdkDrawContext         *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_get_frame_region</NAME>
<RETURNS>const cairo_region_t *</RETURNS>
GdkDrawContext         *context
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DROP</NAME>
#define GDK_TYPE_DROP              (gdk_drop_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DROP</NAME>
#define GDK_DROP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DROP, GdkDrop))
</MACRO>
<MACRO>
<NAME>GDK_IS_DROP</NAME>
#define GDK_IS_DROP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DROP))
</MACRO>
<FUNCTION>
<NAME>gdk_drop_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_actions</NAME>
<RETURNS>GdkDragAction</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_drag</NAME>
<RETURNS>GdkDrag *</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_status</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *self, GdkDragAction           actions, GdkDragAction           preferred
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_finish</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *self, GdkDragAction           action
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_read_async</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *self, const char            **mime_types, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_read_finish</NAME>
<RETURNS>GInputStream *</RETURNS>
GdkDrop                *self, GAsyncResult           *result, const char            **out_mime_type, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_read_value_async</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *self, GType                   type, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_read_value_finish</NAME>
<RETURNS>const GValue *</RETURNS>
GdkDrop                *self, GAsyncResult           *result, GError                **error
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_EVENT</NAME>
#define GDK_TYPE_EVENT          (gdk_event_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_EVENT_SEQUENCE</NAME>
#define GDK_TYPE_EVENT_SEQUENCE (gdk_event_sequence_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_IS_EVENT</NAME>
#define GDK_IS_EVENT(obj)       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_EVENT))
</MACRO>
<MACRO>
<NAME>GDK_EVENT</NAME>
#define GDK_EVENT(obj)          (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_EVENT, GdkEvent))
</MACRO>
<MACRO>
<NAME>GDK_IS_EVENT_TYPE</NAME>
#define GDK_IS_EVENT_TYPE(event, type)  (gdk_event_get_event_type ((event)) == (type))
</MACRO>
<MACRO>
<NAME>GDK_PRIORITY_EVENTS</NAME>
#define GDK_PRIORITY_EVENTS	(G_PRIORITY_DEFAULT)
</MACRO>
<MACRO>
<NAME>GDK_PRIORITY_REDRAW</NAME>
#define GDK_PRIORITY_REDRAW     (G_PRIORITY_HIGH_IDLE + 20)
</MACRO>
<MACRO>
<NAME>GDK_EVENT_PROPAGATE</NAME>
#define GDK_EVENT_PROPAGATE     (FALSE)
</MACRO>
<MACRO>
<NAME>GDK_EVENT_STOP</NAME>
#define GDK_EVENT_STOP          (TRUE)
</MACRO>
<MACRO>
<NAME>GDK_BUTTON_PRIMARY</NAME>
#define GDK_BUTTON_PRIMARY      (1)
</MACRO>
<MACRO>
<NAME>GDK_BUTTON_MIDDLE</NAME>
#define GDK_BUTTON_MIDDLE       (2)
</MACRO>
<MACRO>
<NAME>GDK_BUTTON_SECONDARY</NAME>
#define GDK_BUTTON_SECONDARY    (3)
</MACRO>
<MACRO>
<NAME>GDK_TYPE_BUTTON_EVENT</NAME>
#define GDK_TYPE_BUTTON_EVENT (gdk_button_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_CONFIGURE_EVENT</NAME>
#define GDK_TYPE_CONFIGURE_EVENT (gdk_configure_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_CROSSING_EVENT</NAME>
#define GDK_TYPE_CROSSING_EVENT (gdk_crossing_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DELETE_EVENT</NAME>
#define GDK_TYPE_DELETE_EVENT (gdk_delete_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DND_EVENT</NAME>
#define GDK_TYPE_DND_EVENT (gdk_dnd_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_FOCUS_EVENT</NAME>
#define GDK_TYPE_FOCUS_EVENT (gdk_focus_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAB_BROKEN_EVENT</NAME>
#define GDK_TYPE_GRAB_BROKEN_EVENT (gdk_grab_broken_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_KEY_EVENT</NAME>
#define GDK_TYPE_KEY_EVENT (gdk_key_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MOTION_EVENT</NAME>
#define GDK_TYPE_MOTION_EVENT (gdk_motion_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_PAD_EVENT</NAME>
#define GDK_TYPE_PAD_EVENT (gdk_pad_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_PROXIMITY_EVENT</NAME>
#define GDK_TYPE_PROXIMITY_EVENT (gdk_proximity_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SCROLL_EVENT</NAME>
#define GDK_TYPE_SCROLL_EVENT (gdk_scroll_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_TOUCH_EVENT</NAME>
#define GDK_TYPE_TOUCH_EVENT (gdk_touch_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_TOUCHPAD_EVENT</NAME>
#define GDK_TYPE_TOUCHPAD_EVENT (gdk_touchpad_event_get_type())
</MACRO>
<ENUM>
<NAME>GdkEventType</NAME>
typedef enum
{
  GDK_DELETE,
  GDK_MOTION_NOTIFY,
  GDK_BUTTON_PRESS,
  GDK_BUTTON_RELEASE,
  GDK_KEY_PRESS,
  GDK_KEY_RELEASE,
  GDK_ENTER_NOTIFY,
  GDK_LEAVE_NOTIFY,
  GDK_FOCUS_CHANGE,
  GDK_CONFIGURE,
  GDK_PROXIMITY_IN,
  GDK_PROXIMITY_OUT,
  GDK_DRAG_ENTER,
  GDK_DRAG_LEAVE,
  GDK_DRAG_MOTION,
  GDK_DROP_START,
  GDK_SCROLL,
  GDK_GRAB_BROKEN,
  GDK_TOUCH_BEGIN,
  GDK_TOUCH_UPDATE,
  GDK_TOUCH_END,
  GDK_TOUCH_CANCEL,
  GDK_TOUCHPAD_SWIPE,
  GDK_TOUCHPAD_PINCH,
  GDK_PAD_BUTTON_PRESS,
  GDK_PAD_BUTTON_RELEASE,
  GDK_PAD_RING,
  GDK_PAD_STRIP,
  GDK_PAD_GROUP_MODE,
  GDK_EVENT_LAST        /* helper variable for decls */
} GdkEventType;
</ENUM>
<ENUM>
<NAME>GdkTouchpadGesturePhase</NAME>
typedef enum
{
  GDK_TOUCHPAD_GESTURE_PHASE_BEGIN,
  GDK_TOUCHPAD_GESTURE_PHASE_UPDATE,
  GDK_TOUCHPAD_GESTURE_PHASE_END,
  GDK_TOUCHPAD_GESTURE_PHASE_CANCEL
} GdkTouchpadGesturePhase;
</ENUM>
<ENUM>
<NAME>GdkScrollDirection</NAME>
typedef enum
{
  GDK_SCROLL_UP,
  GDK_SCROLL_DOWN,
  GDK_SCROLL_LEFT,
  GDK_SCROLL_RIGHT,
  GDK_SCROLL_SMOOTH
} GdkScrollDirection;
</ENUM>
<ENUM>
<NAME>GdkNotifyType</NAME>
typedef enum
{
  GDK_NOTIFY_ANCESTOR		= 0,
  GDK_NOTIFY_VIRTUAL		= 1,
  GDK_NOTIFY_INFERIOR		= 2,
  GDK_NOTIFY_NONLINEAR		= 3,
  GDK_NOTIFY_NONLINEAR_VIRTUAL	= 4,
  GDK_NOTIFY_UNKNOWN		= 5
} GdkNotifyType;
</ENUM>
<ENUM>
<NAME>GdkCrossingMode</NAME>
typedef enum
{
  GDK_CROSSING_NORMAL,
  GDK_CROSSING_GRAB,
  GDK_CROSSING_UNGRAB,
  GDK_CROSSING_GTK_GRAB,
  GDK_CROSSING_GTK_UNGRAB,
  GDK_CROSSING_STATE_CHANGED,
  GDK_CROSSING_TOUCH_BEGIN,
  GDK_CROSSING_TOUCH_END,
  GDK_CROSSING_DEVICE_SWITCH
} GdkCrossingMode;
</ENUM>
<FUNCTION>
<NAME>gdk_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_sequence_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_ref</NAME>
<RETURNS>GdkEvent *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_unref</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_event_type</NAME>
<RETURNS>GdkEventType</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_source_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_device_tool</NAME>
<RETURNS>GdkDeviceTool *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_time</NAME>
<RETURNS>guint32</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_event_sequence</NAME>
<RETURNS>GdkEventSequence *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_modifier_state</NAME>
<RETURNS>GdkModifierType</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_position</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent  *event, double	   *x, double	   *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_axes</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent  *event, double   **axes, guint     *n_axes
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_axis</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent   *event, GdkAxisUse  axis_use, double     *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_pointer_emulated</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_button_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_button_event_get_button</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_scroll_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_scroll_event_get_direction</NAME>
<RETURNS>GdkScrollDirection</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_scroll_event_get_deltas</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event, double   *delta_x, double   *delta_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_scroll_event_is_stop</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_keyval</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_keycode</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_consumed_modifiers</NAME>
<RETURNS>GdkModifierType</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_layout</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_level</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_is_modifier</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_focus_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_focus_event_get_in</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touch_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_touch_event_get_emulating_pointer</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_crossing_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_crossing_event_get_mode</NAME>
<RETURNS>GdkCrossingMode</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_crossing_event_get_detail</NAME>
<RETURNS>GdkNotifyType</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_crossing_event_get_focus</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_configure_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_configure_event_get_size</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event, int      *width, int      *height
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_gesture_phase</NAME>
<RETURNS>GdkTouchpadGesturePhase</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_n_fingers</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_deltas</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event, double   *dx, double   *dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_pinch_angle_delta</NAME>
<RETURNS>double</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_pinch_scale</NAME>
<RETURNS>double</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_pad_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pad_event_get_button</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_pad_event_get_axis_value</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event, guint    *index, double   *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_pad_event_get_group_mode</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event, guint    *group, guint    *mode
</FUNCTION>
<FUNCTION>
<NAME>gdk_dnd_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_dnd_event_get_drop</NAME>
<RETURNS>GdkDrop *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_grab_broken_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_grab_broken_event_get_grab_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_grab_broken_event_get_implicit</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_motion_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_motion_event_get_history</NAME>
<RETURNS>GdkTimeCoord *</RETURNS>
GdkEvent *event, guint    *out_n_coords
</FUNCTION>
<FUNCTION>
<NAME>gdk_delete_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_proximity_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_triggers_context_menu</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_events_get_distance</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event1, GdkEvent *event2, double   *distance
</FUNCTION>
<FUNCTION>
<NAME>gdk_events_get_angle</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event1, GdkEvent *event2, double   *angle
</FUNCTION>
<FUNCTION>
<NAME>gdk_events_get_center</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event1, GdkEvent *event2, double   *x, double   *y
</FUNCTION>
<ENUM>
<NAME>GdkKeyMatch</NAME>
typedef enum {
  GDK_KEY_MATCH_NONE,
  GDK_KEY_MATCH_PARTIAL,
  GDK_KEY_MATCH_EXACT
} GdkKeyMatch;
</ENUM>
<FUNCTION>
<NAME>gdk_key_event_matches</NAME>
<RETURNS>GdkKeyMatch</RETURNS>
GdkEvent        *event, guint            keyval, GdkModifierType  modifiers
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_match</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent        *event, guint           *keyval, GdkModifierType *modifiers
</FUNCTION>
<STRUCT>
<NAME>GdkButtonEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkConfigureEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkCrossingEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDNDEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDeleteEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventSequence</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkFocusEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGrabBrokenEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkKeyEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMotionEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPadEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkProximityEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkScrollEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkTouchEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkTouchpadEvent</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_FRAME_CLOCK</NAME>
#define GDK_TYPE_FRAME_CLOCK            (gdk_frame_clock_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK</NAME>
#define GDK_FRAME_CLOCK(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_FRAME_CLOCK, GdkFrameClock))
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_CLASS</NAME>
#define GDK_FRAME_CLOCK_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_FRAME_CLOCK, GdkFrameClockClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_FRAME_CLOCK</NAME>
#define GDK_IS_FRAME_CLOCK(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_FRAME_CLOCK))
</MACRO>
<MACRO>
<NAME>GDK_IS_FRAME_CLOCK_CLASS</NAME>
#define GDK_IS_FRAME_CLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_FRAME_CLOCK))
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_GET_CLASS</NAME>
#define GDK_FRAME_CLOCK_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_FRAME_CLOCK, GdkFrameClockClass))
</MACRO>
<ENUM>
<NAME>GdkFrameClockPhase</NAME>
typedef enum {
  GDK_FRAME_CLOCK_PHASE_NONE          = 0,
  GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS  = 1 << 0,
  GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT  = 1 << 1,
  GDK_FRAME_CLOCK_PHASE_UPDATE        = 1 << 2,
  GDK_FRAME_CLOCK_PHASE_LAYOUT        = 1 << 3,
  GDK_FRAME_CLOCK_PHASE_PAINT         = 1 << 4,
  GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS = 1 << 5,
  GDK_FRAME_CLOCK_PHASE_AFTER_PAINT   = 1 << 6
} GdkFrameClockPhase;
</ENUM>
<FUNCTION>
<NAME>gdk_frame_clock_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_frame_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_request_phase</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock      *frame_clock, GdkFrameClockPhase  phase
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_begin_updating</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock      *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_end_updating</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock      *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_frame_counter</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_history_start</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_timings</NAME>
<RETURNS>GdkFrameTimings *</RETURNS>
GdkFrameClock *frame_clock, gint64         frame_counter
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_current_timings</NAME>
<RETURNS>GdkFrameTimings *</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_refresh_info</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock *frame_clock, gint64         base_time, gint64        *refresh_interval_return, gint64        *presentation_time_return
</FUNCTION>
<STRUCT>
<NAME>GdkFrameClock</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkFrameClockClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkFrameClockPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_frame_timings_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_ref</NAME>
<RETURNS>GdkFrameTimings *</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_unref</NAME>
<RETURNS>void</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_frame_counter</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_complete</NAME>
<RETURNS>gboolean</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_frame_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_presentation_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_refresh_interval</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_predicted_presentation_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<STRUCT>
<NAME>GdkFrameTimings</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_GL_CONTEXT</NAME>
#define GDK_TYPE_GL_CONTEXT             (gdk_gl_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_GL_CONTEXT</NAME>
#define GDK_GL_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_GL_CONTEXT, GdkGLContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_GL_CONTEXT</NAME>
#define GDK_IS_GL_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_GL_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_GL_ERROR</NAME>
#define GDK_GL_ERROR       (gdk_gl_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gdk_gl_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_shared_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_version</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int           *major, int           *minor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_is_legacy</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_required_version</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int            major, int            minor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_required_version</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int           *major, int           *minor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_debug_enabled</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, gboolean       enabled
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_debug_enabled</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_forward_compatible</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, gboolean       compatible
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_forward_compatible</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_use_es</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int            use_es
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_use_es</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_realize</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_make_current</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_current</NAME>
<RETURNS>GdkGLContext *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_clear_current</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_GL_TEXTURE</NAME>
#define GDK_TYPE_GL_TEXTURE (gdk_gl_texture_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_GL_TEXTURE</NAME>
#define GDK_GL_TEXTURE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_GL_TEXTURE, GdkGLTexture))
</MACRO>
<MACRO>
<NAME>GDK_IS_GL_TEXTURE</NAME>
#define GDK_IS_GL_TEXTURE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_GL_TEXTURE))
</MACRO>
<FUNCTION>
<NAME>gdk_gl_texture_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_texture_new</NAME>
<RETURNS>GdkTexture *</RETURNS>
GdkGLContext    *context, guint            id, int              width, int              height, GDestroyNotify   destroy, gpointer         data
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_texture_release</NAME>
<RETURNS>void</RETURNS>
GdkGLTexture    *self
</FUNCTION>
<STRUCT>
<NAME>GdkGLTexture</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGLTextureClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_keyval_name</NAME>
<RETURNS>const char *</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_from_name</NAME>
<RETURNS>guint</RETURNS>
const gchar *keyval_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_convert_case</NAME>
<RETURNS>void</RETURNS>
guint        symbol, guint       *lower, guint       *upper
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_upper</NAME>
<RETURNS>guint</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_lower</NAME>
<RETURNS>guint</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_is_upper</NAME>
<RETURNS>gboolean</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_is_lower</NAME>
<RETURNS>gboolean</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_unicode</NAME>
<RETURNS>guint32</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_unicode_to_keyval</NAME>
<RETURNS>guint</RETURNS>
guint32      wc
</FUNCTION>
<ENUM>
<NAME>GdkMemoryFormat</NAME>
typedef enum {
  GDK_MEMORY_B8G8R8A8_PREMULTIPLIED,
  GDK_MEMORY_A8R8G8B8_PREMULTIPLIED,
  GDK_MEMORY_B8G8R8A8,
  GDK_MEMORY_A8R8G8B8,
  GDK_MEMORY_R8G8B8A8,
  GDK_MEMORY_A8B8G8R8,
  GDK_MEMORY_R8G8B8,
  GDK_MEMORY_B8G8R8,

  GDK_MEMORY_N_FORMATS
} GdkMemoryFormat;
</ENUM>
<MACRO>
<NAME>GDK_MEMORY_DEFAULT</NAME>
#define GDK_MEMORY_DEFAULT GDK_MEMORY_B8G8R8A8_PREMULTIPLIED
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MEMORY_TEXTURE</NAME>
#define GDK_TYPE_MEMORY_TEXTURE (gdk_memory_texture_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_MEMORY_TEXTURE</NAME>
#define GDK_MEMORY_TEXTURE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_MEMORY_TEXTURE, GdkMemoryTexture))
</MACRO>
<MACRO>
<NAME>GDK_IS_MEMORY_TEXTURE</NAME>
#define GDK_IS_MEMORY_TEXTURE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_MEMORY_TEXTURE))
</MACRO>
<FUNCTION>
<NAME>gdk_memory_texture_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_memory_texture_new</NAME>
<RETURNS>GdkTexture *</RETURNS>
int                width, int                height, GdkMemoryFormat    format, GBytes            *bytes, gsize              stride
</FUNCTION>
<STRUCT>
<NAME>GdkMemoryTexture</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMemoryTextureClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_MONITOR</NAME>
#define GDK_TYPE_MONITOR           (gdk_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_MONITOR</NAME>
#define GDK_MONITOR(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MONITOR, GdkMonitor))
</MACRO>
<MACRO>
<NAME>GDK_IS_MONITOR</NAME>
#define GDK_IS_MONITOR(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MONITOR))
</MACRO>
<ENUM>
<NAME>GdkSubpixelLayout</NAME>
typedef enum {
  GDK_SUBPIXEL_LAYOUT_UNKNOWN,
  GDK_SUBPIXEL_LAYOUT_NONE,
  GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB,
  GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR,
  GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB,
  GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR
} GdkSubpixelLayout;
</ENUM>
<FUNCTION>
<NAME>gdk_monitor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_geometry</NAME>
<RETURNS>void</RETURNS>
GdkMonitor   *monitor, GdkRectangle *geometry
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_workarea</NAME>
<RETURNS>void</RETURNS>
GdkMonitor   *monitor, GdkRectangle *workarea
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_width_mm</NAME>
<RETURNS>int</RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_height_mm</NAME>
<RETURNS>int</RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_manufacturer</NAME>
<RETURNS>const char *</RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_model</NAME>
<RETURNS>const char *</RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_connector</NAME>
<RETURNS>const char *</RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_scale_factor</NAME>
<RETURNS>int</RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_refresh_rate</NAME>
<RETURNS>int</RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_subpixel_layout</NAME>
<RETURNS>GdkSubpixelLayout</RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_is_valid</NAME>
<RETURNS>gboolean</RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<STRUCT>
<NAME>GdkMonitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMonitorClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_PAINTABLE</NAME>
#define GDK_TYPE_PAINTABLE               (gdk_paintable_get_type ())
</MACRO>
<ENUM>
<NAME>GdkPaintableFlags</NAME>
typedef enum {
  GDK_PAINTABLE_STATIC_SIZE = 1 << 0,
  GDK_PAINTABLE_STATIC_CONTENTS = 1 << 1
} GdkPaintableFlags;
</ENUM>
<STRUCT>
<NAME>GdkPaintableInterface</NAME>
struct _GdkPaintableInterface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/
  /* draw to 0,0 with the given width and height */
  void                  (* snapshot)                    (GdkPaintable           *paintable,
                                                         GdkSnapshot            *snapshot,
                                                         double                  width,
                                                         double                  height);
  /* get the current contents in an immutable form (optional) */
  GdkPaintable *        (* get_current_image)           (GdkPaintable           *paintable);
   
  /* get flags for potential optimizations (optional) */
  GdkPaintableFlags     (* get_flags)                   (GdkPaintable           *paintable);
  /* preferred width of paintable or 0 if it has no width (optional) */
  int                   (* get_intrinsic_width)         (GdkPaintable           *paintable);
  /* preferred height of paintable or 0 if it has no height (optional) */
  int                   (* get_intrinsic_height)        (GdkPaintable           *paintable);
  /* aspect ratio (width / height) of paintable or 0 if it has no aspect ratio (optional) */
  double                (* get_intrinsic_aspect_ratio)  (GdkPaintable           *paintable);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_paintable_snapshot</NAME>
<RETURNS>void</RETURNS>
GdkPaintable           *paintable, GdkSnapshot            *snapshot, double                  width, double                  height
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_get_current_image</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_get_flags</NAME>
<RETURNS>GdkPaintableFlags</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_get_intrinsic_width</NAME>
<RETURNS>int</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_get_intrinsic_height</NAME>
<RETURNS>int</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_get_intrinsic_aspect_ratio</NAME>
<RETURNS>double</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_compute_concrete_size</NAME>
<RETURNS>void</RETURNS>
GdkPaintable           *paintable, double                  specified_width, double                  specified_height, double                  default_width, double                  default_height, double                 *concrete_width, double                 *concrete_height
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_invalidate_contents</NAME>
<RETURNS>void</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_invalidate_size</NAME>
<RETURNS>void</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_new_empty</NAME>
<RETURNS>GdkPaintable *</RETURNS>
int                     intrinsic_width, int                     intrinsic_height
</FUNCTION>
<STRUCT>
<NAME>GdkPaintable</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_pango_layout_line_get_clip_region</NAME>
<RETURNS>cairo_region_t *</RETURNS>
PangoLayoutLine *line, gint             x_origin, gint             y_origin, const gint      *index_ranges, gint             n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gdk_pango_layout_get_clip_region</NAME>
<RETURNS>cairo_region_t *</RETURNS>
PangoLayout     *layout, gint             x_origin, gint             y_origin, const gint      *index_ranges, gint             n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_from_surface</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
cairo_surface_t *surface, gint             src_x, gint             src_y, gint             width, gint             height
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_from_texture</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GdkTexture      *texture
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_POPUP</NAME>
#define GDK_TYPE_POPUP (gdk_popup_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_popup_present</NAME>
<RETURNS>gboolean</RETURNS>
GdkPopup       *popup, int             width, int             height, GdkPopupLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_surface_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_rect_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_parent</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_position_x</NAME>
<RETURNS>int</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_position_y</NAME>
<RETURNS>int</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_autohide</NAME>
<RETURNS>gboolean</RETURNS>
GdkPopup       *popup
</FUNCTION>
<STRUCT>
<NAME>GdkPopup</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPopupInterface</NAME>
</STRUCT>
<ENUM>
<NAME>GdkAnchorHints</NAME>
typedef enum
{
  GDK_ANCHOR_FLIP_X   = 1 << 0,
  GDK_ANCHOR_FLIP_Y   = 1 << 1,
  GDK_ANCHOR_SLIDE_X  = 1 << 2,
  GDK_ANCHOR_SLIDE_Y  = 1 << 3,
  GDK_ANCHOR_RESIZE_X = 1 << 4,
  GDK_ANCHOR_RESIZE_Y = 1 << 5,
  GDK_ANCHOR_FLIP     = GDK_ANCHOR_FLIP_X | GDK_ANCHOR_FLIP_Y,
  GDK_ANCHOR_SLIDE    = GDK_ANCHOR_SLIDE_X | GDK_ANCHOR_SLIDE_Y,
  GDK_ANCHOR_RESIZE   = GDK_ANCHOR_RESIZE_X | GDK_ANCHOR_RESIZE_Y,
} GdkAnchorHints;
</ENUM>
<MACRO>
<NAME>GDK_TYPE_POPUP_LAYOUT</NAME>
#define GDK_TYPE_POPUP_LAYOUT (gdk_popup_layout_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_popup_layout_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_new</NAME>
<RETURNS>GdkPopupLayout *</RETURNS>
const GdkRectangle     *anchor_rect, GdkGravity              rect_anchor, GdkGravity              surface_anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_ref</NAME>
<RETURNS>GdkPopupLayout *</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_unref</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_copy</NAME>
<RETURNS>GdkPopupLayout *</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_equal</NAME>
<RETURNS>gboolean</RETURNS>
GdkPopupLayout         *layout, GdkPopupLayout         *other
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_anchor_rect</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, const GdkRectangle     *anchor_rect
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_anchor_rect</NAME>
<RETURNS>const GdkRectangle *</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_rect_anchor</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, GdkGravity              anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_rect_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_surface_anchor</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, GdkGravity              anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_surface_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_anchor_hints</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, GdkAnchorHints          anchor_hints
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_anchor_hints</NAME>
<RETURNS>GdkAnchorHints</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_offset</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, int                     dx, int                     dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_offset</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, int                    *dx, int                    *dy
</FUNCTION>
<STRUCT>
<NAME>GdkPopupLayout</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_rectangle_intersect</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRectangle *src1, const GdkRectangle *src2, GdkRectangle       *dest
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_union</NAME>
<RETURNS>void</RETURNS>
const GdkRectangle *src1, const GdkRectangle *src2, GdkRectangle       *dest
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_equal</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRectangle *rect1, const GdkRectangle *rect2
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_contains_point</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRectangle *rect, int                 x, int                 y
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_RECTANGLE</NAME>
#define GDK_TYPE_RECTANGLE (gdk_rectangle_get_type ())
</MACRO>
<STRUCT>
<NAME>GdkRGBA</NAME>
struct _GdkRGBA
{
  float red;
  float green;
  float blue;
  float alpha;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_RGBA</NAME>
#define GDK_TYPE_RGBA (gdk_rgba_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_rgba_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_copy</NAME>
<RETURNS>GdkRGBA *</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_free</NAME>
<RETURNS>void</RETURNS>
GdkRGBA       *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_is_clear</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_is_opaque</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_hash</NAME>
<RETURNS>guint</RETURNS>
gconstpointer  p
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_equal</NAME>
<RETURNS>gboolean</RETURNS>
gconstpointer  p1, gconstpointer  p2
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_parse</NAME>
<RETURNS>gboolean</RETURNS>
GdkRGBA       *rgba, const gchar   *spec
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_to_string</NAME>
<RETURNS>gchar *</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<MACRO>
<NAME>GDK_RGBA</NAME>
#define GDK_RGBA(str) ((GdkRGBA) {\
    ((_GDK_RGBA_SELECT_COLOR(str, 0, 0) << 4) | _GDK_RGBA_SELECT_COLOR(str, 0, 1)) / 255., \
    ((_GDK_RGBA_SELECT_COLOR(str, 1, 2) << 4) | _GDK_RGBA_SELECT_COLOR(str, 1, 3)) / 255., \
    ((_GDK_RGBA_SELECT_COLOR(str, 2, 4) << 4) | _GDK_RGBA_SELECT_COLOR(str, 2, 5)) / 255., \
    ((sizeof(str) % 4 == 1) ? ((_GDK_RGBA_SELECT_COLOR(str, 3, 6) << 4) | _GDK_RGBA_SELECT_COLOR(str, 3, 7)) : 0xFF) / 255 })
</MACRO>
<FUNCTION>
<NAME>gdk_rgba_parser_parse</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser           *parser, GdkRGBA                *rgba
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_SEAT</NAME>
#define GDK_TYPE_SEAT  (gdk_seat_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_SEAT</NAME>
#define GDK_SEAT(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_SEAT, GdkSeat))
</MACRO>
<MACRO>
<NAME>GDK_IS_SEAT</NAME>
#define GDK_IS_SEAT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_SEAT))
</MACRO>
<ENUM>
<NAME>GdkSeatCapabilities</NAME>
typedef enum {
  GDK_SEAT_CAPABILITY_NONE          = 0,
  GDK_SEAT_CAPABILITY_POINTER       = 1 << 0,
  GDK_SEAT_CAPABILITY_TOUCH         = 1 << 1,
  GDK_SEAT_CAPABILITY_TABLET_STYLUS = 1 << 2,
  GDK_SEAT_CAPABILITY_KEYBOARD      = 1 << 3,
  GDK_SEAT_CAPABILITY_TABLET_PAD    = 1 << 4,
  GDK_SEAT_CAPABILITY_ALL_POINTING  = (GDK_SEAT_CAPABILITY_POINTER | GDK_SEAT_CAPABILITY_TOUCH | GDK_SEAT_CAPABILITY_TABLET_STYLUS),
  GDK_SEAT_CAPABILITY_ALL           = (GDK_SEAT_CAPABILITY_ALL_POINTING | GDK_SEAT_CAPABILITY_KEYBOARD)
} GdkSeatCapabilities;
</ENUM>
<STRUCT>
<NAME>GdkSeat</NAME>
struct _GdkSeat
{
  GObject parent_instance;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_seat_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_capabilities</NAME>
<RETURNS>GdkSeatCapabilities</RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_slaves</NAME>
<RETURNS>GList *</RETURNS>
GdkSeat             *seat, GdkSeatCapabilities  capabilities
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_pointer</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_keyboard</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_master_pointers</NAME>
<RETURNS>GList *</RETURNS>
GdkSeat             *seat, GdkSeatCapabilities  capabilities
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_SNAPSHOT</NAME>
#define GDK_TYPE_SNAPSHOT               (gdk_snapshot_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_SNAPSHOT</NAME>
#define GDK_SNAPSHOT(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_SNAPSHOT, GdkSnapshot))
</MACRO>
<MACRO>
<NAME>GDK_IS_SNAPSHOT</NAME>
#define GDK_IS_SNAPSHOT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_SNAPSHOT))
</MACRO>
<FUNCTION>
<NAME>gdk_snapshot_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkSnapshotClass</NAME>
</STRUCT>
<ENUM>
<NAME>GdkSurfaceEdge</NAME>
typedef enum
{
  GDK_SURFACE_EDGE_NORTH_WEST,
  GDK_SURFACE_EDGE_NORTH,
  GDK_SURFACE_EDGE_NORTH_EAST,
  GDK_SURFACE_EDGE_WEST,
  GDK_SURFACE_EDGE_EAST,
  GDK_SURFACE_EDGE_SOUTH_WEST,
  GDK_SURFACE_EDGE_SOUTH,
  GDK_SURFACE_EDGE_SOUTH_EAST
} GdkSurfaceEdge;
</ENUM>
<ENUM>
<NAME>GdkFullscreenMode</NAME>
typedef enum
{
  GDK_FULLSCREEN_ON_CURRENT_MONITOR,
  GDK_FULLSCREEN_ON_ALL_MONITORS
} GdkFullscreenMode;
</ENUM>
<ENUM>
<NAME>GdkSurfaceState</NAME>
typedef enum
{
  GDK_SURFACE_STATE_WITHDRAWN        = 1 << 0,
  GDK_SURFACE_STATE_MINIMIZED        = 1 << 1,
  GDK_SURFACE_STATE_MAXIMIZED        = 1 << 2,
  GDK_SURFACE_STATE_STICKY           = 1 << 3,
  GDK_SURFACE_STATE_FULLSCREEN       = 1 << 4,
  GDK_SURFACE_STATE_ABOVE            = 1 << 5,
  GDK_SURFACE_STATE_BELOW            = 1 << 6,
  GDK_SURFACE_STATE_FOCUSED          = 1 << 7,
  GDK_SURFACE_STATE_TILED            = 1 << 8,
  GDK_SURFACE_STATE_TOP_TILED        = 1 << 9,
  GDK_SURFACE_STATE_TOP_RESIZABLE    = 1 << 10,
  GDK_SURFACE_STATE_RIGHT_TILED      = 1 << 11,
  GDK_SURFACE_STATE_RIGHT_RESIZABLE  = 1 << 12,
  GDK_SURFACE_STATE_BOTTOM_TILED     = 1 << 13,
  GDK_SURFACE_STATE_BOTTOM_RESIZABLE = 1 << 14,
  GDK_SURFACE_STATE_LEFT_TILED       = 1 << 15,
  GDK_SURFACE_STATE_LEFT_RESIZABLE   = 1 << 16
} GdkSurfaceState;
</ENUM>
<MACRO>
<NAME>GDK_TYPE_SURFACE</NAME>
#define GDK_TYPE_SURFACE              (gdk_surface_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_SURFACE</NAME>
#define GDK_SURFACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_SURFACE, GdkSurface))
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_CLASS</NAME>
#define GDK_SURFACE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_SURFACE, GdkSurfaceClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_SURFACE</NAME>
#define GDK_IS_SURFACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_IS_SURFACE_CLASS</NAME>
#define GDK_IS_SURFACE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_GET_CLASS</NAME>
#define GDK_SURFACE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_SURFACE, GdkSurfaceClass))
</MACRO>
<FUNCTION>
<NAME>gdk_surface_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_new_toplevel</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay    *display, int            width, int            height
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_new_popup</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkSurface    *parent, gboolean       autohide
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_destroy</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_is_destroyed</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_hide</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_input_region</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface, cairo_region_t *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_mapped</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_cursor</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_cursor</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_device_cursor</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, GdkDevice     *device, GdkCursor     *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_device_cursor</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkSurface     *surface, GdkDevice     *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_width</NAME>
<RETURNS>int</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_height</NAME>
<RETURNS>int</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_translate_coordinates</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *from, GdkSurface *to, double     *x, double     *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_scale_factor</NAME>
<RETURNS>gint</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_device_position</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, GdkDevice       *device, double          *x, double          *y, GdkModifierType *mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_similar_surface</NAME>
<RETURNS>cairo_surface_t *</RETURNS>
GdkSurface *surface, cairo_content_t  content, int              width, int              height
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_beep</NAME>
<RETURNS>void</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_queue_expose</NAME>
<RETURNS>void</RETURNS>
GdkSurface          *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_freeze_updates</NAME>
<RETURNS>void</RETURNS>
GdkSurface    *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_thaw_updates</NAME>
<RETURNS>void</RETURNS>
GdkSurface    *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_support_multidevice</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean   support_multidevice
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_support_multidevice</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_frame_clock</NAME>
<RETURNS>GdkFrameClock *</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_opaque_region</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, cairo_region_t *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_shadow_width</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, gint            left, gint            right, gint            top, gint            bottom
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_cairo_context</NAME>
<RETURNS>GdkCairoContext *</RETURNS>
GdkSurface    *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_gl_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GdkSurface     *surface, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_vulkan_context</NAME>
<RETURNS>GdkVulkanContext *</RETURNS>
GdkSurface     *surface, GError        **error
</FUNCTION>
<STRUCT>
<NAME>GdkSurfaceClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_TEXTURE</NAME>
#define GDK_TYPE_TEXTURE (gdk_texture_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TEXTURE</NAME>
#define GDK_TEXTURE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_TEXTURE, GdkTexture))
</MACRO>
<MACRO>
<NAME>GDK_IS_TEXTURE</NAME>
#define GDK_IS_TEXTURE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_TEXTURE))
</MACRO>
<FUNCTION>
<NAME>gdk_texture_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_new_for_pixbuf</NAME>
<RETURNS>GdkTexture *</RETURNS>
GdkPixbuf       *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_new_from_resource</NAME>
<RETURNS>GdkTexture *</RETURNS>
const char      *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_new_from_file</NAME>
<RETURNS>GdkTexture *</RETURNS>
GFile           *file, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_get_width</NAME>
<RETURNS>int</RETURNS>
GdkTexture      *texture
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_get_height</NAME>
<RETURNS>int</RETURNS>
GdkTexture      *texture
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_download</NAME>
<RETURNS>void</RETURNS>
GdkTexture      *texture, guchar          *data, gsize            stride
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_save_to_png</NAME>
<RETURNS>gboolean</RETURNS>
GdkTexture      *texture, const char      *filename
</FUNCTION>
<STRUCT>
<NAME>GdkTextureClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_TOPLEVEL</NAME>
#define GDK_TYPE_TOPLEVEL (gdk_toplevel_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_toplevel_present</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel       *toplevel, int                width, int                height, GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_minimize</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel       *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_lower</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel       *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_focus</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, guint32            timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_get_state</NAME>
<RETURNS>GdkSurfaceState</RETURNS>
GdkToplevel       *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_title</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, const char        *title
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_startup_id</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, const char        *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_transient_for</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, GdkSurface        *parent
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_modal</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, gboolean           modal
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_icon_list</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, GList             *surfaces
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_show_window_menu</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel       *toplevel, GdkEvent          *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_decorated</NAME>
<RETURNS>void</RETURNS>
GdkToplevel      *toplevel, gboolean          decorated
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_deletable</NAME>
<RETURNS>void</RETURNS>
GdkToplevel      *toplevel, gboolean          deletable
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_supports_edge_constraints</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_inhibit_system_shortcuts</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel, GdkEvent    *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_restore_system_shortcuts</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_begin_resize</NAME>
<RETURNS>void</RETURNS>
GdkToplevel    *toplevel, GdkSurfaceEdge  edge, GdkDevice      *device, int             button, double          x, double          y, guint32         timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_begin_move</NAME>
<RETURNS>void</RETURNS>
GdkToplevel    *toplevel, GdkDevice      *device, int             button, double          x, double          y, guint32         timestamp
</FUNCTION>
<STRUCT>
<NAME>GdkToplevel</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkToplevelInterface</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_TOPLEVEL_LAYOUT</NAME>
#define GDK_TYPE_TOPLEVEL_LAYOUT (gdk_toplevel_layout_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_new</NAME>
<RETURNS>GdkToplevelLayout *</RETURNS>
int min_width, int min_height
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_ref</NAME>
<RETURNS>GdkToplevelLayout *</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_unref</NAME>
<RETURNS>void</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_copy</NAME>
<RETURNS>GdkToplevelLayout *</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_equal</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout, GdkToplevelLayout *other
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_set_maximized</NAME>
<RETURNS>void</RETURNS>
GdkToplevelLayout *layout, gboolean           maximized
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_set_fullscreen</NAME>
<RETURNS>void</RETURNS>
GdkToplevelLayout *layout, gboolean           fullscreen, GdkMonitor        *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_min_width</NAME>
<RETURNS>int</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_min_height</NAME>
<RETURNS>int</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_maximized</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_fullscreen</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_fullscreen_monitor</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_set_resizable</NAME>
<RETURNS>void</RETURNS>
GdkToplevelLayout *layout, gboolean           resizable
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_resizable</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<STRUCT>
<NAME>GdkToplevelLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_CURRENT_TIME</NAME>
#define GDK_CURRENT_TIME     0L
</MACRO>
<STRUCT>
<NAME>GdkPoint</NAME>
struct _GdkPoint
{
  gint x;
  gint y;
};
</STRUCT>
<STRUCT>
<NAME>GdkRectangle</NAME>
struct _GdkRectangle
{
    int x, y;
    int width, height;
};
</STRUCT>
<ENUM>
<NAME>GdkGravity</NAME>
typedef enum
{
  GDK_GRAVITY_NORTH_WEST = 1,
  GDK_GRAVITY_NORTH,
  GDK_GRAVITY_NORTH_EAST,
  GDK_GRAVITY_WEST,
  GDK_GRAVITY_CENTER,
  GDK_GRAVITY_EAST,
  GDK_GRAVITY_SOUTH_WEST,
  GDK_GRAVITY_SOUTH,
  GDK_GRAVITY_SOUTH_EAST,
  GDK_GRAVITY_STATIC
} GdkGravity;
</ENUM>
<ENUM>
<NAME>GdkModifierType</NAME>
typedef enum
{
  GDK_SHIFT_MASK    = 1 << 0,
  GDK_LOCK_MASK     = 1 << 1,
  GDK_CONTROL_MASK  = 1 << 2,
  GDK_ALT_MASK      = 1 << 3,

  GDK_BUTTON1_MASK  = 1 << 8,
  GDK_BUTTON2_MASK  = 1 << 9,
  GDK_BUTTON3_MASK  = 1 << 10,
  GDK_BUTTON4_MASK  = 1 << 11,
  GDK_BUTTON5_MASK  = 1 << 12,

  GDK_SUPER_MASK    = 1 << 26,
  GDK_HYPER_MASK    = 1 << 27,
  GDK_META_MASK     = 1 << 28,
} GdkModifierType;
</ENUM>
<MACRO>
<NAME>GDK_MODIFIER_MASK</NAME>
#define GDK_MODIFIER_MASK (GDK_SHIFT_MASK|GDK_LOCK_MASK|GDK_CONTROL_MASK| \
                           GDK_ALT_MASK|GDK_SUPER_MASK|GDK_HYPER_MASK|GDK_META_MASK| \
                           GDK_BUTTON1_MASK|GDK_BUTTON2_MASK|GDK_BUTTON3_MASK| \
                           GDK_BUTTON4_MASK|GDK_BUTTON5_MASK)
</MACRO>
<ENUM>
<NAME>GdkGLError</NAME>
typedef enum {
  GDK_GL_ERROR_NOT_AVAILABLE,
  GDK_GL_ERROR_UNSUPPORTED_FORMAT,
  GDK_GL_ERROR_UNSUPPORTED_PROFILE,
  GDK_GL_ERROR_COMPILATION_FAILED,
  GDK_GL_ERROR_LINK_FAILED
} GdkGLError;
</ENUM>
<ENUM>
<NAME>GdkVulkanError</NAME>
typedef enum {
  GDK_VULKAN_ERROR_UNSUPPORTED,
  GDK_VULKAN_ERROR_NOT_AVAILABLE,
} GdkVulkanError;
</ENUM>
<ENUM>
<NAME>GdkAxisUse</NAME>
typedef enum
{
  GDK_AXIS_IGNORE,
  GDK_AXIS_X,
  GDK_AXIS_Y,
  GDK_AXIS_PRESSURE,
  GDK_AXIS_XTILT,
  GDK_AXIS_YTILT,
  GDK_AXIS_WHEEL,
  GDK_AXIS_DISTANCE,
  GDK_AXIS_ROTATION,
  GDK_AXIS_SLIDER,
  GDK_AXIS_LAST
} GdkAxisUse;
</ENUM>
<ENUM>
<NAME>GdkAxisFlags</NAME>
typedef enum
{
  GDK_AXIS_FLAG_X        = 1 << GDK_AXIS_X,
  GDK_AXIS_FLAG_Y        = 1 << GDK_AXIS_Y,
  GDK_AXIS_FLAG_PRESSURE = 1 << GDK_AXIS_PRESSURE,
  GDK_AXIS_FLAG_XTILT    = 1 << GDK_AXIS_XTILT,
  GDK_AXIS_FLAG_YTILT    = 1 << GDK_AXIS_YTILT,
  GDK_AXIS_FLAG_WHEEL    = 1 << GDK_AXIS_WHEEL,
  GDK_AXIS_FLAG_DISTANCE = 1 << GDK_AXIS_DISTANCE,
  GDK_AXIS_FLAG_ROTATION = 1 << GDK_AXIS_ROTATION,
  GDK_AXIS_FLAG_SLIDER   = 1 << GDK_AXIS_SLIDER,
} GdkAxisFlags;
</ENUM>
<ENUM>
<NAME>GdkDragAction</NAME>
typedef enum
{
  GDK_ACTION_COPY    = 1 << 0,
  GDK_ACTION_MOVE    = 1 << 1,
  GDK_ACTION_LINK    = 1 << 2,
  GDK_ACTION_ASK     = 1 << 3
} GdkDragAction;
</ENUM>
<MACRO>
<NAME>GDK_ACTION_ALL</NAME>
#define GDK_ACTION_ALL (GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK)
</MACRO>
<MACRO>
<NAME>GDK_DECLARE_INTERNAL_TYPE</NAME>
#define GDK_DECLARE_INTERNAL_TYPE(ModuleObjName, module_obj_name, MODULE, OBJ_NAME, ParentName) \
  GType module_obj_name##_get_type (void);                                                               \
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS                                                                       \
  typedef struct _##ModuleObjName ModuleObjName;                                                         \
  typedef struct _##ModuleObjName##Class ModuleObjName##Class;                                           \
                                                                                                         \
  _GLIB_DEFINE_AUTOPTR_CHAINUP (ModuleObjName, ParentName)                                               \
  G_DEFINE_AUTOPTR_CLEANUP_FUNC (ModuleObjName##Class, g_type_class_unref)                               \
                                                                                                         \
  G_GNUC_UNUSED static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) {                       \
    return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); }             \
  G_GNUC_UNUSED static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_CLASS (gpointer ptr) {        \
    return G_TYPE_CHECK_CLASS_CAST (ptr, module_obj_name##_get_type (), ModuleObjName##Class); }         \
  G_GNUC_UNUSED static inline gboolean MODULE##_IS_##OBJ_NAME (gpointer ptr) {                           \
    return G_TYPE_CHECK_INSTANCE_TYPE (ptr, module_obj_name##_get_type ()); }                            \
  G_GNUC_UNUSED static inline gboolean MODULE##_IS_##OBJ_NAME##_CLASS (gpointer ptr) {                   \
    return G_TYPE_CHECK_CLASS_TYPE (ptr, module_obj_name##_get_type ()); }                               \
  G_GNUC_UNUSED static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_GET_CLASS (gpointer ptr) {    \
    return G_TYPE_INSTANCE_GET_CLASS (ptr, module_obj_name##_get_type (), ModuleObjName##Class); }       \
  G_GNUC_END_IGNORE_DEPRECATIONS
</MACRO>
<STRUCT>
<NAME>GdkKeymapKey</NAME>
struct _GdkKeymapKey
{
  guint keycode;
  gint  group;
  gint  level;
};
</STRUCT>
<MACRO>
<NAME>GDK_EXTERN_VAR</NAME>
#        define GDK_EXTERN_VAR __declspec(dllexport)
</MACRO>
<STRUCT>
<NAME>GdkAppLaunchContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkCairoContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkClipboard</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkContentFormats</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkContentProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkCursor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDisplay</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDisplayManager</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrag</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrawContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrawingContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrop</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPoint</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkRGBA</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkRectangle</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkSeat</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkSnapshot</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkTexture</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkVulkanContext</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_VULKAN_CONTEXT</NAME>
#define GDK_TYPE_VULKAN_CONTEXT             (gdk_vulkan_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_VULKAN_CONTEXT</NAME>
#define GDK_VULKAN_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_VULKAN_CONTEXT, GdkVulkanContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_VULKAN_CONTEXT</NAME>
#define GDK_IS_VULKAN_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_VULKAN_ERROR</NAME>
#define GDK_VULKAN_ERROR                    (gdk_vulkan_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gdk_vulkan_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_strerror</NAME>
<RETURNS>const char *</RETURNS>
VkResult           result
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_instance</NAME>
<RETURNS>VkInstance</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_physical_device</NAME>
<RETURNS>VkPhysicalDevice</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_device</NAME>
<RETURNS>VkDevice</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_queue</NAME>
<RETURNS>VkQueue</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_queue_family_index</NAME>
<RETURNS>uint32_t</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_image_format</NAME>
<RETURNS>VkFormat</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_n_images</NAME>
<RETURNS>uint32_t</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_image</NAME>
<RETURNS>VkImage</RETURNS>
GdkVulkanContext  *context, guint              id
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_draw_index</NAME>
<RETURNS>uint32_t</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_draw_semaphore</NAME>
<RETURNS>VkSemaphore</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_CAIRO_CONTEXT</NAME>
#define GDK_TYPE_WAYLAND_CAIRO_CONTEXT		(gdk_wayland_cairo_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_CAIRO_CONTEXT</NAME>
#define GDK_WAYLAND_CAIRO_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WAYLAND_CAIRO_CONTEXT, GdkWaylandCairoContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_CAIRO_CONTEXT</NAME>
#define GDK_IS_WAYLAND_CAIRO_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WAYLAND_CAIRO_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_CAIRO_CONTEXT_CLASS</NAME>
#define GDK_WAYLAND_CAIRO_CONTEXT_CLASS(klass) 	(G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_CAIRO_CONTEXT, GdkWaylandCairoContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_CAIRO_CONTEXT_CLASS</NAME>
#define GDK_IS_WAYLAND_CAIRO_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_CAIRO_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_CAIRO_CONTEXT_GET_CLASS</NAME>
#define GDK_WAYLAND_CAIRO_CONTEXT_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_CAIRO_CONTEXT, GdkWaylandCairoContextClass))
</MACRO>
<STRUCT>
<NAME>GdkWaylandCairoContext</NAME>
struct _GdkWaylandCairoContext
{
  GdkCairoContext parent_instance;

  GSList *surfaces;
  cairo_surface_t *cached_surface;
  cairo_surface_t *paint_surface;
};
</STRUCT>
<STRUCT>
<NAME>GdkWaylandCairoContextClass</NAME>
struct _GdkWaylandCairoContextClass
{
  GdkCairoContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_wayland_cairo_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_CLIPBOARD</NAME>
#define GDK_TYPE_WAYLAND_CLIPBOARD    (gdk_wayland_clipboard_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_CLIPBOARD</NAME>
#define GDK_WAYLAND_CLIPBOARD(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WAYLAND_CLIPBOARD, GdkWaylandClipboard))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_CLIPBOARD</NAME>
#define GDK_IS_WAYLAND_CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WAYLAND_CLIPBOARD))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_clipboard_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_clipboard_new</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkDisplay             *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_clipboard_claim_remote</NAME>
<RETURNS>void</RETURNS>
GdkWaylandClipboard    *cb, struct wl_data_offer   *offer, GdkContentFormats      *formats
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandClipboard</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_ZWP_POINTER_GESTURES_V1_VERSION</NAME>
#define GDK_ZWP_POINTER_GESTURES_V1_VERSION 1
</MACRO>
<STRUCT>
<NAME>GsdXftSettings</NAME>
typedef struct {
        gboolean     antialias;
        gboolean     hinting;
        gint         dpi;
        const gchar *rgba;
        const gchar *hintstyle;
} GsdXftSettings;
</STRUCT>
<ENUM>
<NAME>GdkWaylandShellVariant</NAME>
typedef enum _GdkWaylandShellVariant
{
  GDK_WAYLAND_SHELL_VARIANT_XDG_SHELL,
  GDK_WAYLAND_SHELL_VARIANT_ZXDG_SHELL_V6
} GdkWaylandShellVariant;
</ENUM>
<STRUCT>
<NAME>GdkWaylandDisplay</NAME>
struct _GdkWaylandDisplay
{
  GdkDisplay parent_instance;
  GList *toplevels;

  GHashTable *settings;
  GsdXftSettings xft_settings;
  GDBusProxy *settings_portal;

  guint32    shell_capabilities;

  /* Startup notification */
  gchar *startup_notification_id;

  /* Most recent serial */
  guint32 serial;

  uint32_t xdg_wm_base_id;
  int xdg_wm_base_version;
  uint32_t zxdg_shell_v6_id;
  GdkWaylandShellVariant shell_variant;

  /* Wayland fields below */
  struct wl_display *wl_display;
  struct wl_registry *wl_registry;
  struct wl_compositor *compositor;
  struct wl_shm *shm;
  struct xdg_wm_base *xdg_wm_base;
  struct zxdg_shell_v6 *zxdg_shell_v6;
  struct gtk_shell1 *gtk_shell;
  struct wl_input_device *input_device;
  struct wl_data_device_manager *data_device_manager;
  struct wl_subcompositor *subcompositor;
  struct zwp_pointer_gestures_v1 *pointer_gestures;
  struct gtk_primary_selection_device_manager *primary_selection_manager;
  struct zwp_tablet_manager_v2 *tablet_manager;
  struct zxdg_exporter_v1 *xdg_exporter;
  struct zxdg_importer_v1 *xdg_importer;
  struct zwp_keyboard_shortcuts_inhibit_manager_v1 *keyboard_shortcuts_inhibit;
  struct org_kde_kwin_server_decoration_manager *server_decoration_manager;
  struct zxdg_output_manager_v1 *xdg_output_manager;

  GList *async_roundtrips;

  /* Keep track of the ID's of the known globals and their corresponding
   * names. This way we can check whether an interface is known, and
   * remove globals given its ID. This table is not expected to be very
   * large, meaning the lookup by interface name time is insignificant. */
  GHashTable *known_globals;
  GList *on_has_globals_closures;

  GList *event_queues;

  GList *current_popups;
  GList *current_grabbing_popups;

  struct wl_cursor_theme *cursor_theme;
  gchar *cursor_theme_name;
  int cursor_theme_size;
  GHashTable *cursor_surface_cache;

  GSource *event_source;

  int compositor_version;
  int seat_version;
  int data_device_manager_version;
  int gtk_shell_version;
  int xdg_output_manager_version;

  uint32_t server_decoration_mode;

  struct xkb_context *xkb_context;

  GListStore *monitors;

  gint64 last_bell_time_ms;

  /* egl info */
  EGLDisplay egl_display;
  int egl_major_version;
  int egl_minor_version;

  guint have_egl : 1;
  guint have_egl_khr_create_context : 1;
  guint have_egl_buffer_age : 1;
  guint have_egl_swap_buffers_with_damage : 1;
  guint have_egl_surfaceless_context : 1;
};
</STRUCT>
<STRUCT>
<NAME>GdkWaylandDisplayClass</NAME>
struct _GdkWaylandDisplayClass
{
  GdkDisplayClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdkWaylandSelection</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandGLContext</NAME>
struct _GdkWaylandGLContext
{
  GdkGLContext parent_instance;

  EGLContext egl_context;
  EGLConfig egl_config;
  gboolean is_attached;
};
</STRUCT>
<STRUCT>
<NAME>GdkWaylandGLContextClass</NAME>
struct _GdkWaylandGLContextClass
{
  GdkGLContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_wayland_display_init_gl</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay        *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_create_gl_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GdkSurface         *surface, gboolean           attach, GdkGLContext      *share, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_make_gl_context_current</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay        *display, GdkGLContext      *context
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandMonitor</NAME>
struct _GdkWaylandMonitor {
  GdkMonitor parent;

  guint32 id;
  guint32 version;
  struct wl_output *output;
  gboolean added;

  struct zxdg_output_v1 *xdg_output;
  /* Size and position, can be either from wl_output or xdg_output */
  int32_t x;
  int32_t y;
  int32_t width;
  int32_t height;
  char *name;
  gboolean wl_output_done;
  gboolean xdg_output_done;
};
</STRUCT>
<STRUCT>
<NAME>GdkWaylandMonitorClass</NAME>
struct _GdkWaylandMonitorClass {
  GdkMonitorClass parent_class;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_PRIMARY</NAME>
#define GDK_TYPE_WAYLAND_PRIMARY    (gdk_wayland_primary_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_PRIMARY</NAME>
#define GDK_WAYLAND_PRIMARY(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WAYLAND_PRIMARY, GdkWaylandPrimary))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_PRIMARY</NAME>
#define GDK_IS_WAYLAND_PRIMARY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WAYLAND_PRIMARY))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_primary_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_primary_new</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkWaylandSeat         *seat
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandPrimary</NAME>
</STRUCT>
<MACRO>
<NAME>WL_SURFACE_HAS_BUFFER_SCALE</NAME>
#define WL_SURFACE_HAS_BUFFER_SCALE 3
</MACRO>
<MACRO>
<NAME>WL_POINTER_HAS_FRAME</NAME>
#define WL_POINTER_HAS_FRAME 5
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_LOCAL_DND_MIME_TYPE</NAME>
#define GDK_WAYLAND_LOCAL_DND_MIME_TYPE "application/x-gtk-local-dnd"
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_display_system_bell</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, GdkSurface  *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_sync</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_request_frame</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_attach_image</NAME>
<RETURNS>void</RETURNS>
GdkSurface           *surface, cairo_surface_t      *cairo_surface, const cairo_region_t *damage
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drop_new</NAME>
<RETURNS>GdkDrop *</RETURNS>
GdkDevice             *device, GdkDrag               *drag, GdkContentFormats     *formats, GdkSurface            *surface, struct wl_data_offer  *offer, uint32_t               serial
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drop_set_source_actions</NAME>
<RETURNS>void</RETURNS>
GdkDrop               *drop, uint32_t               source_actions
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drop_set_action</NAME>
<RETURNS>void</RETURNS>
GdkDrop               *drop, uint32_t               action
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_data_device</NAME>
<RETURNS>struct wl_data_device *</RETURNS>
GdkDevice *gdk_device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_set_selection</NAME>
<RETURNS>void</RETURNS>
GdkDevice             *gdk_device, struct wl_data_source *source
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_drop_context</NAME>
<RETURNS>GdkDrag *</RETURNS>
GdkDevice *gdk_device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_unset_touch_grab</NAME>
<RETURNS>void</RETURNS>
GdkDevice        *device, GdkEventSequence *sequence
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_toplevel_surfaces</NAME>
<RETURNS>GList *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_output_refresh_rate</NAME>
<RETURNS>int</RETURNS>
GdkWaylandDisplay *display_wayland, struct wl_output  *output
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_output_scale</NAME>
<RETURNS>guint32</RETURNS>
GdkWaylandDisplay *display_wayland, struct wl_output  *output
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_monitor_for_output</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay       *display, struct wl_output *output
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_egl_surface</NAME>
<RETURNS>EGLSurface</RETURNS>
GdkSurface *surface, EGLConfig config
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_dummy_egl_surface</NAME>
<RETURNS>EGLSurface</RETURNS>
GdkSurface *surface, EGLConfig config
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_gtk_surface</NAME>
<RETURNS>struct gtk_surface1 *</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_set_global_cursor</NAME>
<RETURNS>void</RETURNS>
GdkSeat   *seat, GdkCursor *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_set_drag</NAME>
<RETURNS>void</RETURNS>
GdkSeat        *seat, GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_wl_output</NAME>
<RETURNS>struct wl_output *</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_inhibit_shortcuts</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, GdkSeat   *gdk_seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_restore_shortcuts</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, GdkSeat   *gdk_seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_update_scale</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>create_dnd_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_keymap_get_gdk_modifiers</NAME>
<RETURNS>GdkModifierType</RETURNS>
GdkKeymap *keymap, guint32    mods
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_SEAT</NAME>
#define GDK_TYPE_WAYLAND_SEAT         (gdk_wayland_seat_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SEAT</NAME>
#define GDK_WAYLAND_SEAT(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_WAYLAND_SEAT, GdkWaylandSeat))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SEAT_CLASS</NAME>
#define GDK_WAYLAND_SEAT_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_WAYLAND_SEAT, GdkWaylandSeatClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_SEAT</NAME>
#define GDK_IS_WAYLAND_SEAT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_WAYLAND_SEAT))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_SEAT_CLASS</NAME>
#define GDK_IS_WAYLAND_SEAT_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_WAYLAND_SEAT))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SEAT_GET_CLASS</NAME>
#define GDK_WAYLAND_SEAT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_WAYLAND_SEAT, GdkWaylandSeatClass))
</MACRO>
<STRUCT>
<NAME>GdkWaylandSeatClass</NAME>
struct _GdkWaylandSeatClass
{
  GdkSeatClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_wayland_seat_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_update_cursor_scale</NAME>
<RETURNS>void</RETURNS>
GdkWaylandSeat *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_clear_touchpoints</NAME>
<RETURNS>void</RETURNS>
GdkWaylandSeat *seat, GdkSurface     *surface
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandSeat</NAME>
</STRUCT>
<MACRO>
<NAME>VK_USE_PLATFORM_WAYLAND_KHR</NAME>
#define VK_USE_PLATFORM_WAYLAND_KHR
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_VULKAN_CONTEXT</NAME>
#define GDK_TYPE_WAYLAND_VULKAN_CONTEXT		(gdk_wayland_vulkan_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_VULKAN_CONTEXT</NAME>
#define GDK_WAYLAND_VULKAN_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WAYLAND_VULKAN_CONTEXT, GdkWaylandVulkanContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_VULKAN_CONTEXT</NAME>
#define GDK_IS_WAYLAND_VULKAN_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WAYLAND_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_VULKAN_CONTEXT_CLASS</NAME>
#define GDK_WAYLAND_VULKAN_CONTEXT_CLASS(klass) 	(G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_VULKAN_CONTEXT, GdkWaylandVulkanContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_VULKAN_CONTEXT_CLASS</NAME>
#define GDK_IS_WAYLAND_VULKAN_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_VULKAN_CONTEXT_GET_CLASS</NAME>
#define GDK_WAYLAND_VULKAN_CONTEXT_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_VULKAN_CONTEXT, GdkWaylandVulkanContextClass))
</MACRO>
<STRUCT>
<NAME>GdkWaylandVulkanContext</NAME>
struct _GdkWaylandVulkanContext
{
  GdkVulkanContext parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GdkWaylandVulkanContextClass</NAME>
struct _GdkWaylandVulkanContextClass
{
  GdkVulkanContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_wayland_vulkan_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<TYPEDEF>
<NAME>GdkWaylandDevice</NAME>
typedef GdkDevice GdkWaylandDevice;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_DEVICE</NAME>
#define GDK_TYPE_WAYLAND_DEVICE         (gdk_wayland_device_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DEVICE</NAME>
#define GDK_WAYLAND_DEVICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_WAYLAND_DEVICE, GdkWaylandDevice))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DEVICE_CLASS</NAME>
#define GDK_WAYLAND_DEVICE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_WAYLAND_DEVICE, GdkWaylandDeviceClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DEVICE</NAME>
#define GDK_IS_WAYLAND_DEVICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_WAYLAND_DEVICE))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DEVICE_CLASS</NAME>
#define GDK_IS_WAYLAND_DEVICE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_WAYLAND_DEVICE))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DEVICE_GET_CLASS</NAME>
#define GDK_WAYLAND_DEVICE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_WAYLAND_DEVICE, GdkWaylandDeviceClass))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_device_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_wl_seat</NAME>
<RETURNS>struct wl_seat *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_wl_pointer</NAME>
<RETURNS>struct wl_pointer *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_wl_keyboard</NAME>
<RETURNS>struct wl_keyboard *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_get_wl_seat</NAME>
<RETURNS>struct wl_seat *</RETURNS>
GdkSeat   *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_node_path</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_pad_set_feedback</NAME>
<RETURNS>void</RETURNS>
GdkDevice           *device, GdkDevicePadFeature  element, guint                idx, const gchar         *label
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandDeviceClass</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GdkWaylandDisplay</NAME>
typedef GdkDisplay GdkWaylandDisplay;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_DISPLAY</NAME>
#define GDK_TYPE_WAYLAND_DISPLAY              (gdk_wayland_display_get_type())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DISPLAY</NAME>
#define GDK_WAYLAND_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_DISPLAY, GdkWaylandDisplay))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DISPLAY_CLASS</NAME>
#define GDK_WAYLAND_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_DISPLAY, GdkWaylandDisplayClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DISPLAY</NAME>
#define GDK_IS_WAYLAND_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DISPLAY_CLASS</NAME>
#define GDK_IS_WAYLAND_DISPLAY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DISPLAY_GET_CLASS</NAME>
#define GDK_WAYLAND_DISPLAY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_DISPLAY, GdkWaylandDisplayClass))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_display_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_wl_display</NAME>
<RETURNS>struct wl_display *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_wl_compositor</NAME>
<RETURNS>struct wl_compositor *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_set_cursor_theme</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const gchar *theme, gint         size
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_startup_notification_id</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_set_startup_notification_id</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, const char *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_prefers_ssd</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_query_registry</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display, const gchar *global
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandDisplay</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandDisplayClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_GL_CONTEXT</NAME>
#define GDK_TYPE_WAYLAND_GL_CONTEXT		(gdk_wayland_gl_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_GL_CONTEXT</NAME>
#define GDK_WAYLAND_GL_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WAYLAND_GL_CONTEXT, GdkWaylandGLContext))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_IS_GL_CONTEXT</NAME>
#define GDK_WAYLAND_IS_GL_CONTEXT(obj)	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WAYLAND_GL_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_gl_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandGLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandGLContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_MONITOR</NAME>
#define GDK_TYPE_WAYLAND_MONITOR           (gdk_wayland_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_MONITOR</NAME>
#define GDK_WAYLAND_MONITOR(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_MONITOR, GdkWaylandMonitor))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_MONITOR</NAME>
#define GDK_IS_WAYLAND_MONITOR(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_MONITOR))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_monitor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_monitor_get_wl_output</NAME>
<RETURNS>struct wl_output *</RETURNS>
GdkMonitor *monitor
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandMonitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandMonitorClass</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GdkWaylandSurface</NAME>
typedef GdkSurface GdkWaylandSurface;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_SURFACE</NAME>
#define GDK_TYPE_WAYLAND_SURFACE              (gdk_wayland_surface_get_type())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SURFACE</NAME>
#define GDK_WAYLAND_SURFACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_SURFACE, GdkWaylandSurface))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SURFACE_CLASS</NAME>
#define GDK_WAYLAND_SURFACE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_SURFACE, GdkWaylandSurfaceClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_SURFACE</NAME>
#define GDK_IS_WAYLAND_SURFACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_SURFACE_CLASS</NAME>
#define GDK_IS_WAYLAND_SURFACE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SURFACE_GET_CLASS</NAME>
#define GDK_WAYLAND_SURFACE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_SURFACE, GdkWaylandSurfaceClass))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_surface_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_wl_surface</NAME>
<RETURNS>struct wl_surface *</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_set_dbus_properties_libgtk_only</NAME>
<RETURNS>void</RETURNS>
GdkSurface  *surface, const char *application_id, const char *app_menu_path, const char *menubar_path, const char *window_object_path, const char *application_object_path, const char *unique_bus_name
</FUNCTION>
<USER_FUNCTION>
<NAME>GdkWaylandSurfaceExported</NAME>
<RETURNS>void</RETURNS>
GdkSurface  *surface, const char *handle, gpointer    user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_export_handle</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface               *surface, GdkWaylandSurfaceExported callback, gpointer                 user_data, GDestroyNotify           destroy_func
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_unexport_handle</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_set_transient_for_exported</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *surface, char      *parent_handle_str
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_announce_csd</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandSurfaceClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>translate_wm_button_layout_to_gtk</NAME>
<RETURNS>void</RETURNS>
char *layout
</FUNCTION>
<FUNCTION>
<NAME>os_create_anonymous_file</NAME>
<RETURNS>int</RETURNS>
off_t size
</FUNCTION>
<STRUCT>
<NAME>wl_cursor_image</NAME>
struct wl_cursor_image {
	uint32_t width;		/* actual width */
	uint32_t height;	/* actual height */
	uint32_t hotspot_x;	/* hot spot x (must be inside image) */
	uint32_t hotspot_y;	/* hot spot y (must be inside image) */
	uint32_t delay;		/* animation delay to next frame (ms) */
};
</STRUCT>
<STRUCT>
<NAME>wl_cursor</NAME>
struct wl_cursor {
	unsigned int image_count;
	struct wl_cursor_image **images;
	char *name;
        unsigned int size;
};
</STRUCT>
<FUNCTION>
<NAME>wl_cursor_theme_create</NAME>
<RETURNS>struct wl_cursor_theme *</RETURNS>
const char *name, int size, struct wl_shm *shm
</FUNCTION>
<FUNCTION>
<NAME>wl_cursor_theme_destroy</NAME>
<RETURNS>void</RETURNS>
struct wl_cursor_theme *theme
</FUNCTION>
<FUNCTION>
<NAME>wl_cursor_theme_get_cursor</NAME>
<RETURNS>struct wl_cursor *</RETURNS>
struct wl_cursor_theme *theme, const char *name, unsigned int scale
</FUNCTION>
<FUNCTION>
<NAME>wl_cursor_image_get_buffer</NAME>
<RETURNS>struct wl_buffer *</RETURNS>
struct wl_cursor_image *image
</FUNCTION>
<STRUCT>
<NAME>wl_buffer</NAME>
struct wl_buffer;
</STRUCT>
<STRUCT>
<NAME>wl_cursor_theme</NAME>
struct wl_cursor_theme;
</STRUCT>
<STRUCT>
<NAME>wl_shm</NAME>
struct wl_shm;
</STRUCT>
<TYPEDEF>
<NAME>XcursorBool</NAME>
typedef int		XcursorBool;
</TYPEDEF>
<TYPEDEF>
<NAME>XcursorUInt</NAME>
typedef unsigned int	XcursorUInt;
</TYPEDEF>
<TYPEDEF>
<NAME>XcursorDim</NAME>
typedef XcursorUInt	XcursorDim;
</TYPEDEF>
<TYPEDEF>
<NAME>XcursorPixel</NAME>
typedef XcursorUInt	XcursorPixel;
</TYPEDEF>
<STRUCT>
<NAME>XcursorImage</NAME>
typedef struct _XcursorImage {
    XcursorUInt	    version;	/* version of the image data */
    XcursorDim	    size;	/* nominal size for matching */
    XcursorDim	    width;	/* actual width */
    XcursorDim	    height;	/* actual height */
    XcursorDim	    xhot;	/* hot spot x (must be inside image) */
    XcursorDim	    yhot;	/* hot spot y (must be inside image) */
    XcursorUInt	    delay;	/* animation delay to next frame (ms) */
    XcursorPixel    *pixels;	/* pointer to pixels */
} XcursorImage;
</STRUCT>
<STRUCT>
<NAME>XcursorImages</NAME>
typedef struct _XcursorImages {
    int		    nimage;	/* number of images */
    XcursorImage    **images;	/* array of XcursorImage pointers */
    char	    *name;	/* name used to load images */
} XcursorImages;
</STRUCT>
<FUNCTION>
<NAME>xcursor_images_destroy</NAME>
<RETURNS>void</RETURNS>
XcursorImages *images
</FUNCTION>
<FUNCTION>
<NAME>xcursor_load_images</NAME>
<RETURNS>XcursorImages *</RETURNS>
const char *path, int size
</FUNCTION>
<STRUCT>
<NAME>MotifWmInfo</NAME>
typedef struct {
    unsigned long flags;
    unsigned long functions;
    unsigned long decorations;
    long input_mode;
    unsigned long status;
} MotifWmHints, MwmHints;

#define MWM_HINTS_FUNCTIONS     (1L << 0)
#define MWM_HINTS_DECORATIONS   (1L << 1)
#define MWM_HINTS_INPUT_MODE    (1L << 2)
#define MWM_HINTS_STATUS        (1L << 3)

#define MWM_FUNC_ALL            (1L << 0)
#define MWM_FUNC_RESIZE         (1L << 1)
#define MWM_FUNC_MOVE           (1L << 2)
#define MWM_FUNC_MINIMIZE       (1L << 3)
#define MWM_FUNC_MAXIMIZE       (1L << 4)
#define MWM_FUNC_CLOSE          (1L << 5)

#define MWM_DECOR_ALL           (1L << 0)
#define MWM_DECOR_BORDER        (1L << 1)
#define MWM_DECOR_RESIZEH       (1L << 2)
#define MWM_DECOR_TITLE         (1L << 3)
#define MWM_DECOR_MENU          (1L << 4)
#define MWM_DECOR_MINIMIZE      (1L << 5)
#define MWM_DECOR_MAXIMIZE      (1L << 6)

#define MWM_INPUT_MODELESS 0
#define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1
#define MWM_INPUT_SYSTEM_MODAL 2
#define MWM_INPUT_FULL_APPLICATION_MODAL 3
#define MWM_INPUT_APPLICATION_MODAL MWM_INPUT_PRIMARY_APPLICATION_MODAL

#define MWM_TEAROFF_WINDOW	(1L<<0)

/*
 * atoms
 */
#define _XA_MOTIF_BINDINGS		"_MOTIF_BINDINGS"
#define _XA_MOTIF_WM_HINTS		"_MOTIF_WM_HINTS"
#define _XA_MOTIF_WM_MESSAGES		"_MOTIF_WM_MESSAGES"
#define _XA_MOTIF_WM_OFFSET		"_MOTIF_WM_OFFSET"
#define _XA_MOTIF_WM_MENU		"_MOTIF_WM_MENU"
#define _XA_MOTIF_WM_INFO		"_MOTIF_WM_INFO"
#define _XA_MWM_HINTS			_XA_MOTIF_WM_HINTS
#define _XA_MWM_MESSAGES		_XA_MOTIF_WM_MESSAGES
#define _XA_MWM_MENU			_XA_MOTIF_WM_MENU
#define _XA_MWM_INFO			_XA_MOTIF_WM_INFO


/*
 * _MWM_INFO property
 */
typedef struct {
    long flags;
    Window wm_window;
} MotifWmInfo;
</STRUCT>
<TYPEDEF>
<NAME>MwmInfo</NAME>
typedef MotifWmInfo MwmInfo;
</TYPEDEF>
<MACRO>
<NAME>MWM_INFO_STARTUP_STANDARD</NAME>
#define MWM_INFO_STARTUP_STANDARD	(1L<<0)
</MACRO>
<MACRO>
<NAME>MWM_INFO_STARTUP_CUSTOM</NAME>
#define MWM_INFO_STARTUP_CUSTOM		(1L<<1)
</MACRO>
<STRUCT>
<NAME>PropMotifWmHints</NAME>
typedef struct {
    unsigned long flags;
    unsigned long functions;
    unsigned long decorations;
    long inputMode;
    unsigned long status;
} PropMotifWmHints;
</STRUCT>
<TYPEDEF>
<NAME>PropMwmHints</NAME>
typedef PropMotifWmHints PropMwmHints;
</TYPEDEF>
<MACRO>
<NAME>PROP_MOTIF_WM_HINTS_ELEMENTS</NAME>
#define PROP_MOTIF_WM_HINTS_ELEMENTS 5
</MACRO>
<MACRO>
<NAME>PROP_MWM_HINTS_ELEMENTS</NAME>
#define PROP_MWM_HINTS_ELEMENTS PROP_MOTIF_WM_HINTS_ELEMENTS
</MACRO>
<STRUCT>
<NAME>PropMotifWmInfo</NAME>
typedef struct {
    unsigned long flags;
    unsigned long wmWindow;
} PropMotifWmInfo;
</STRUCT>
<TYPEDEF>
<NAME>PropMwmInfo</NAME>
typedef PropMotifWmInfo PropMwmInfo;
</TYPEDEF>
<MACRO>
<NAME>PROP_MOTIF_WM_INFO_ELEMENTS</NAME>
#define PROP_MOTIF_WM_INFO_ELEMENTS 2
</MACRO>
<MACRO>
<NAME>PROP_MWM_INFO_ELEMENTS</NAME>
#define PROP_MWM_INFO_ELEMENTS PROP_MOTIF_WM_INFO_ELEMENTS
</MACRO>
<USER_FUNCTION>
<NAME>GdkSendXEventCallback</NAME>
<RETURNS>void</RETURNS>
Window   window, gboolean success, gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdkRoundTripCallback</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, gpointer data, gulong serial
</USER_FUNCTION>
<STRUCT>
<NAME>GdkChildInfoX11</NAME>
struct _GdkChildInfoX11
{
  Window window;
  gint x;
  gint y;
  gint width;
  gint height;
  guint is_mapped : 1;
  guint has_wm_state : 1;
  guint window_class : 2;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_CAIRO_CONTEXT</NAME>
#define GDK_TYPE_X11_CAIRO_CONTEXT		(gdk_x11_cairo_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_CAIRO_CONTEXT</NAME>
#define GDK_X11_CAIRO_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_CAIRO_CONTEXT, GdkX11CairoContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_CAIRO_CONTEXT</NAME>
#define GDK_IS_X11_CAIRO_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_X11_CAIRO_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_CAIRO_CONTEXT_CLASS</NAME>
#define GDK_X11_CAIRO_CONTEXT_CLASS(klass) 	(G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_CAIRO_CONTEXT, GdkX11CairoContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_CAIRO_CONTEXT_CLASS</NAME>
#define GDK_IS_X11_CAIRO_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_CAIRO_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_CAIRO_CONTEXT_GET_CLASS</NAME>
#define GDK_X11_CAIRO_CONTEXT_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_CAIRO_CONTEXT, GdkX11CairoContextClass))
</MACRO>
<STRUCT>
<NAME>GdkX11CairoContext</NAME>
struct _GdkX11CairoContext
{
  GdkCairoContext parent_instance;

  cairo_surface_t *window_surface;
  cairo_surface_t *paint_surface;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11CairoContextClass</NAME>
struct _GdkX11CairoContextClass
{
  GdkCairoContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_cairo_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_CLIPBOARD</NAME>
#define GDK_TYPE_X11_CLIPBOARD    (gdk_x11_clipboard_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_CLIPBOARD</NAME>
#define GDK_X11_CLIPBOARD(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_CLIPBOARD, GdkX11Clipboard))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_CLIPBOARD</NAME>
#define GDK_IS_X11_CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_X11_CLIPBOARD))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_clipboard_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_clipboard_new</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkDisplay             *display, const gchar            *selection
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_clipboard_formats_to_targets</NAME>
<RETURNS>GSList *</RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_clipboard_formats_to_atoms</NAME>
<RETURNS>Atom *</RETURNS>
GdkDisplay             *display, gboolean                include_special, GdkContentFormats      *formats, gsize                  *n_atoms
</FUNCTION>
<STRUCT>
<NAME>GdkX11Clipboard</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceManagerCore</NAME>
struct _GdkX11DeviceManagerCore
{
  GObject parent_instance;
  GdkDisplay *display;
  GdkDevice *core_pointer;
  GdkDevice *core_keyboard;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceManagerCoreClass</NAME>
struct _GdkX11DeviceManagerCoreClass
{
  GObjectClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11Display</NAME>
struct _GdkX11Display
{
  GdkDisplay parent_instance;
  Display *xdisplay;
  GdkX11Screen *screen;
  GList *screens;
  GList *toplevels;
  GdkX11DeviceManagerXI2 *device_manager;

  GSource *event_source;

  gint grab_count;

  /* Visual infos for creating Windows */
  int window_depth;
  Visual *window_visual;
  Colormap window_colormap;

  /* Keyboard related information */
  gint xkb_event_type;
  gboolean use_xkb;

  /* Whether we were able to turn on detectable-autorepeat using
   * XkbSetDetectableAutorepeat. If FALSE, we'll fall back
   * to checking the next event with XPending().
   */
  gboolean have_xkb_autorepeat;

  GdkKeymap *keymap;
  guint      keymap_serial;

  gboolean have_xfixes;
  gint xfixes_event_base;

  gboolean have_xcomposite;

  gboolean have_randr12;
  gboolean have_randr13;
  gboolean have_randr15;
  gint xrandr_event_base;

  /* If the SECURITY extension is in place, whether this client holds
   * a trusted authorization and so is allowed to make various requests
   * (grabs, properties etc.) Otherwise always TRUE.
   */
  gboolean trusted_client;

  /* drag and drop information */
  GdkDrop *current_drop;

  /* Mapping to/from virtual atoms */
  GHashTable *atom_from_string;
  GHashTable *atom_to_string;

  /* Session Management leader window see ICCCM */
  char *program_class;
  Window leader_window;
  GdkSurface *leader_gdk_surface;
  gboolean leader_window_title_set;

  /* X ID hashtable */
  GHashTable *xid_ht;

  /* streams reading selections */
  GSList *streams;

  /* GdkCursor => XCursor */
  GHashTable *cursors;

  GListStore *monitors;
  int primary_monitor;

  /* Startup notification */
  gchar *startup_notification_id;

  /* Time of most recent user interaction. */
  gulong user_time;

  /* Sets of atoms for DND */
  guint use_sync : 1;

  guint have_shapes : 1;
  guint have_input_shapes : 1;
  gint shape_event_base;

  GSList *error_traps;

  gint wm_moveresize_button;

  /* GLX information */
  gint glx_version;
  gint glx_error_base;
  gint glx_event_base;

  /* Translation between X server time and system-local monotonic time */
  gint64 server_time_query_time;
  gint64 server_time_offset;

  guint server_time_is_monotonic_time : 1;

  guint have_glx : 1;

  /* GLX extensions we check */
  guint has_glx_swap_interval : 1;
  guint has_glx_create_context : 1;
  guint has_glx_texture_from_pixmap : 1;
  guint has_glx_video_sync : 1;
  guint has_glx_buffer_age : 1;
  guint has_glx_sync_control : 1;
  guint has_glx_multisample : 1;
  guint has_glx_visual_rating : 1;
  guint has_glx_create_es2_context : 1;
  guint has_async_glx_swap_buffers : 1;

#ifdef HAVE_XDAMAGE
  gint damage_event_base;
  gint damage_error_base;
  guint have_damage;
#endif
};
</STRUCT>
<STRUCT>
<NAME>GdkX11DisplayClass</NAME>
struct _GdkX11DisplayClass
{
  GdkDisplayClass parent_class;

  gboolean              (* xevent)                              (GdkX11Display          *display,
                                                                 const XEvent           *event);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_display_get_max_request_size</NAME>
<RETURNS>gsize</RETURNS>
GdkDisplay             *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_request_selection_notification</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay             *display, const char             *selection
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_EVENT_TRANSLATOR</NAME>
#define GDK_TYPE_EVENT_TRANSLATOR         (_gdk_x11_event_translator_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_EVENT_TRANSLATOR</NAME>
#define GDK_EVENT_TRANSLATOR(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_EVENT_TRANSLATOR, GdkEventTranslator))
</MACRO>
<MACRO>
<NAME>GDK_IS_EVENT_TRANSLATOR</NAME>
#define GDK_IS_EVENT_TRANSLATOR(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_EVENT_TRANSLATOR))
</MACRO>
<MACRO>
<NAME>GDK_EVENT_TRANSLATOR_GET_IFACE</NAME>
#define GDK_EVENT_TRANSLATOR_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE  ((o), GDK_TYPE_EVENT_TRANSLATOR, GdkEventTranslatorIface))
</MACRO>
<STRUCT>
<NAME>GdkEventTranslatorIface</NAME>
struct _GdkEventTranslatorIface
{
  GTypeInterface iface;

  /* VMethods */
  GdkEvent * (* translate_event) (GdkEventTranslator *translator,
                                  GdkDisplay         *display,
                                  const XEvent       *xevent);

  GdkEventMask (* get_handled_events)    (GdkEventTranslator *translator);
  void         (* select_surface_events) (GdkEventTranslator *translator,
                                          Window              window,
                                          GdkEventMask        event_mask);
  GdkSurface *  (* get_surface)          (GdkEventTranslator *translator,
                                          const XEvent       *xevent);
};
</STRUCT>
<STRUCT>
<NAME>GdkEventTranslator</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11GLContext</NAME>
struct _GdkX11GLContext
{
  GdkGLContext parent_instance;

  GLXContext glx_context;
  GLXFBConfig glx_config;
  GLXDrawable attached_drawable;
  GLXDrawable unattached_drawable;

#ifdef HAVE_XDAMAGE
  GLsync frame_fence;
  Damage xdamage;
#endif

  guint is_attached : 1;
  guint is_direct : 1;
  guint do_frame_sync : 1;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11GLContextClass</NAME>
struct _GdkX11GLContextClass
{
  GdkGLContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_screen_init_gl</NAME>
<RETURNS>gboolean</RETURNS>
GdkX11Screen      *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_create_gl_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GdkSurface         *window, gboolean           attached, GdkGLContext      *share, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_make_gl_context_current</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay        *display, GdkGLContext      *context
</FUNCTION>
<TYPEDEF>
<NAME>GdkX11Keymap</NAME>
typedef GdkKeymap GdkX11Keymap;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_X11_KEYMAP</NAME>
#define GDK_TYPE_X11_KEYMAP              (gdk_x11_keymap_get_type())
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP</NAME>
#define GDK_X11_KEYMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_KEYMAP, GdkX11Keymap))
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP_CLASS</NAME>
#define GDK_X11_KEYMAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_KEYMAP, GdkX11KeymapClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_KEYMAP</NAME>
#define GDK_IS_X11_KEYMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_KEYMAP))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_KEYMAP_CLASS</NAME>
#define GDK_IS_X11_KEYMAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_KEYMAP))
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP_GET_CLASS</NAME>
#define GDK_X11_KEYMAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_KEYMAP, GdkX11KeymapClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_keymap_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_keymap_get_group_for_state</NAME>
<RETURNS>gint</RETURNS>
GdkKeymap *keymap, guint      state
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_keymap_key_is_modifier</NAME>
<RETURNS>gboolean</RETURNS>
GdkKeymap *keymap, guint      keycode
</FUNCTION>
<STRUCT>
<NAME>GdkX11Keymap</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11KeymapClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11Monitor</NAME>
struct _GdkX11Monitor
{
  GdkMonitor parent;

  XID output;
  guint add     : 1;
  guint remove  : 1;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11MonitorClass</NAME>
struct _GdkX11MonitorClass {
  GdkMonitorClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11Screen</NAME>
struct _GdkX11Screen
{
  GObject parent_instance;

  GdkDisplay *display;
  Display *xdisplay;
  Screen *xscreen;
  Window xroot_window;
  gint screen_num;

  gint surface_scale;
  gboolean fixed_surface_scale;

  /* Xft resources for the display, used for default values for
   * the Xft/ XSETTINGS
   */
  gint xft_hintstyle;
  gint xft_rgba;
  gint xft_dpi;

  /* Window manager */
  long last_wmspec_check_time;
  Window wmspec_check_window;
  char *window_manager_name;

  /* X Settings */
  Window xsettings_manager_window;
  Atom xsettings_selection_atom;
  GHashTable *xsettings; /* string of GDK settings name => GValue */

  /* TRUE if wmspec_check_window has changed since last
   * fetch of _NET_SUPPORTED
   */
  guint need_refetch_net_supported : 1;
  /* TRUE if wmspec_check_window has changed since last
   * fetch of window manager name
   */
  guint need_refetch_wm_name : 1;
  guint xft_init : 1; /* Whether we've initialized these values yet */
  guint xft_antialias : 1;
  guint xft_hinting : 1;

  /* Visual Part */
  gint nvisuals;
  GdkX11Visual **visuals;
  GdkX11Visual *system_visual;
  gint available_depths[7];
  GdkVisualType available_types[6];
  gint16 navailable_depths;
  gint16 navailable_types;
  GdkX11Visual *rgba_visual;

  /* cache for window->translate vfunc */
  GC subwindow_gcs[32];
};
</STRUCT>
<STRUCT>
<NAME>GdkX11ScreenClass</NAME>
struct _GdkX11ScreenClass
{
  GObjectClass parent_class;

  void (* window_manager_changed) (GdkX11Screen *x11_screen);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_screen_get_work_area</NAME>
<RETURNS>void</RETURNS>
GdkX11Screen *screen, GdkRectangle *area
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_setting</NAME>
<RETURNS>gboolean</RETURNS>
GdkX11Screen *screen, const char   *name, GValue       *value
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_SELECTION_INPUT_STREAM</NAME>
#define GDK_TYPE_X11_SELECTION_INPUT_STREAM         (gdk_x11_selection_input_stream_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_INPUT_STREAM</NAME>
#define GDK_X11_SELECTION_INPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_SELECTION_INPUT_STREAM, GdkX11SelectionInputStream))
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_INPUT_STREAM_CLASS</NAME>
#define GDK_X11_SELECTION_INPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), GDK_TYPE_X11_SELECTION_INPUT_STREAM, GdkX11SelectionInputStreamClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SELECTION_INPUT_STREAM</NAME>
#define GDK_IS_X11_SELECTION_INPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_SELECTION_INPUT_STREAM))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SELECTION_INPUT_STREAM_CLASS</NAME>
#define GDK_IS_X11_SELECTION_INPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GDK_TYPE_X11_SELECTION_INPUT_STREAM))
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_INPUT_STREAM_GET_CLASS</NAME>
#define GDK_X11_SELECTION_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_SELECTION_INPUT_STREAM, GdkX11SelectionInputStreamClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11SelectionInputStream</NAME>
typedef struct GdkX11SelectionInputStream         GdkX11SelectionInputStream;
</TYPEDEF>
<TYPEDEF>
<NAME>GdkX11SelectionInputStreamClass</NAME>
typedef struct GdkX11SelectionInputStreamClass    GdkX11SelectionInputStreamClass;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_selection_input_stream_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_selection_input_stream_new_async</NAME>
<RETURNS>void</RETURNS>
GdkDisplay                 *display, const char                 *selection, const char                 *target, guint32                     timestamp, int                         io_priority, GCancellable               *cancellable, GAsyncReadyCallback         callback, gpointer                    user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_selection_input_stream_new_finish</NAME>
<RETURNS>GInputStream *</RETURNS>
GAsyncResult               *result, const char                **type, int                        *format, GError                    **error
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_SELECTION_OUTPUT_STREAM</NAME>
#define GDK_TYPE_X11_SELECTION_OUTPUT_STREAM         (gdk_x11_selection_output_stream_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_OUTPUT_STREAM</NAME>
#define GDK_X11_SELECTION_OUTPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_SELECTION_OUTPUT_STREAM, GdkX11SelectionOutputStream))
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_OUTPUT_STREAM_CLASS</NAME>
#define GDK_X11_SELECTION_OUTPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), GDK_TYPE_X11_SELECTION_OUTPUT_STREAM, GdkX11SelectionOutputStreamClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SELECTION_OUTPUT_STREAM</NAME>
#define GDK_IS_X11_SELECTION_OUTPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_SELECTION_OUTPUT_STREAM))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SELECTION_OUTPUT_STREAM_CLASS</NAME>
#define GDK_IS_X11_SELECTION_OUTPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GDK_TYPE_X11_SELECTION_OUTPUT_STREAM))
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_OUTPUT_STREAM_GET_CLASS</NAME>
#define GDK_X11_SELECTION_OUTPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_SELECTION_OUTPUT_STREAM, GdkX11SelectionOutputStreamClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11SelectionOutputStream</NAME>
typedef struct GdkX11SelectionOutputStream         GdkX11SelectionOutputStream;
</TYPEDEF>
<TYPEDEF>
<NAME>GdkX11SelectionOutputStreamClass</NAME>
typedef struct GdkX11SelectionOutputStreamClass    GdkX11SelectionOutputStreamClass;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GdkX11SelectionOutputHandler</NAME>
<RETURNS>void</RETURNS>
GOutputStream *stream, const char *mime_type, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_x11_selection_output_stream_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_selection_output_streams_create</NAME>
<RETURNS>void</RETURNS>
GdkDisplay             *display, GdkContentFormats      *formats, Window                  requestor, Atom                    selection, Atom                    target, Atom                    property, gulong                  timestamp, GdkX11SelectionOutputHandler handler, gpointer                user_data
</FUNCTION>
<STRUCT>
<NAME>GdkX11Surface</NAME>
struct _GdkX11Surface
{
  GdkSurface parent_instance;

  Window xid;

  GdkToplevelX11 *toplevel;	/* Toplevel-specific information */
  GdkCursor *cursor;

  guint no_bg : 1;        /* Set when the window background is temporarily
                           * unset during resizing and scaling */
  guint override_redirect : 1;
  guint frame_clock_connected : 1;
  guint frame_sync_enabled : 1;
  guint tracking_damage: 1;

  gint surface_scale;

  /* Width and height not divided by surface_scale - this matters in the
   * corner-case where the window manager assigns us a size that isn't
   * a multiple of surface_scale - for example for a maximized window
   * with an odd-sized title-bar.
   */
  gint unscaled_width;
  gint unscaled_height;

  cairo_surface_t *cairo_surface;

  int abs_x;
  int abs_y;

  guint64 map_time;

  GList *surface_is_on_monitor;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11SurfaceClass</NAME>
struct _GdkX11SurfaceClass 
{
  GdkSurfaceClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdkToplevelX11</NAME>
struct _GdkToplevelX11
{

  /* Set if the window, or any descendent of it, is the server's focus window
   */
  guint has_focus_window : 1;

  /* Set if window->has_focus_window and the focus isn't grabbed elsewhere.
   */
  guint has_focus : 1;

  /* Set if the pointer is inside this window. (This is needed for
   * for focus tracking)
   */
  guint has_pointer : 1;
  
  /* Set if the window is a descendent of the focus window and the pointer is
   * inside it. (This is the case where the window will receive keystroke
   * events even window->has_focus_window is FALSE)
   */
  guint has_pointer_focus : 1;

  /* Set if we are requesting these hints */
  guint skip_taskbar_hint : 1;
  guint skip_pager_hint : 1;
  guint urgency_hint : 1;

  guint on_all_desktops : 1;   /* _NET_WM_STICKY == 0xFFFFFFFF */

  guint have_maxvert : 1;       /* _NET_WM_STATE_MAXIMIZED_VERT */
  guint have_maxhorz : 1;       /* _NET_WM_STATE_MAXIMIZED_HORZ */
  guint have_fullscreen : 1;    /* _NET_WM_STATE_FULLSCREEN */
  guint have_hidden : 1;	/* _NET_WM_STATE_HIDDEN */

  guint is_leader : 1;

  /* Set if the WM is presenting us as focused, i.e. with active decorations
   */
  guint have_focused : 1;

  guint in_frame : 1;

  /* If we're waiting for damage from the X server after painting a frame */
  guint frame_still_painting : 1;

  /* If we're expecting a response from the compositor after painting a frame */
  guint frame_pending : 1;

  /* Whether pending_counter_value/configure_counter_value are updates
   * to the extended update counter */
  guint pending_counter_value_is_extended : 1;
  guint configure_counter_value_is_extended : 1;

  gulong map_serial;	/* Serial of last transition from unmapped */
  
  cairo_surface_t *icon_pixmap;
  cairo_surface_t *icon_mask;
  GdkSurface *group_leader;

  /* Time of most recent user interaction. */
  gulong user_time;

  /* We use an extra X window for toplevel windows that we XSetInputFocus()
   * to in order to avoid getting keyboard events redirected to subwindows
   * that might not even be part of this app
   */
  Window focus_window;

  GdkSurfaceHints last_geometry_hints_mask;
  GdkGeometry last_geometry_hints;
  
  /* Constrained edge information */
  guint edge_constraints;

#ifdef HAVE_XSYNC
  XID update_counter;
  XID extended_update_counter;
  gint64 pending_counter_value; /* latest _NET_WM_SYNC_REQUEST value received */
  gint64 configure_counter_value; /* Latest _NET_WM_SYNC_REQUEST value received
				 * where we have also seen the corresponding
				 * ConfigureNotify
				 */
  gint64 current_counter_value;

  /* After a _NET_WM_FRAME_DRAWN message, this is the soonest that we think
   * frame after will be presented */
  gint64 throttled_presentation_time;
#endif
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_surface_pre_damage</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_move</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gint        x, gint        y
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_check_monitor</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, GdkMonitor *monitor
</FUNCTION>
<STRUCT>
<NAME>GdkXPositionInfo</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_TEXT_LIST_CONVERTER</NAME>
#define GDK_TYPE_X11_TEXT_LIST_CONVERTER         (gdk_x11_text_list_converter_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_TEXT_LIST_CONVERTER</NAME>
#define GDK_X11_TEXT_LIST_CONVERTER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_TEXT_LIST_CONVERTER, GdkX11TextListConverter))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_TEXT_LIST_CONVERTER</NAME>
#define GDK_IS_X11_TEXT_LIST_CONVERTER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_TEXT_LIST_CONVERTER))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_text_list_converter_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_text_list_converter_to_utf8_new</NAME>
<RETURNS>GConverter *</RETURNS>
GdkDisplay     *display, const char     *encoding, int             format
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_text_list_converter_from_utf8_new</NAME>
<RETURNS>GConverter *</RETURNS>
GdkDisplay     *display, const char     *encoding, int             format
</FUNCTION>
<STRUCT>
<NAME>GdkX11TextListConverter</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_VISUAL</NAME>
#define GDK_TYPE_X11_VISUAL              (gdk_x11_visual_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_VISUAL</NAME>
#define GDK_X11_VISUAL(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_VISUAL, GdkX11Visual))
</MACRO>
<MACRO>
<NAME>GDK_X11_VISUAL_CLASS</NAME>
#define GDK_X11_VISUAL_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_VISUAL, GdkX11VisualClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_VISUAL</NAME>
#define GDK_IS_X11_VISUAL(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_VISUAL))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_VISUAL_CLASS</NAME>
#define GDK_IS_X11_VISUAL_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_VISUAL))
</MACRO>
<MACRO>
<NAME>GDK_X11_VISUAL_GET_CLASS</NAME>
#define GDK_X11_VISUAL_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_VISUAL, GdkX11VisualClass))
</MACRO>
<ENUM>
<NAME>GdkVisualType</NAME>
typedef enum
{
  GDK_VISUAL_STATIC_GRAY,
  GDK_VISUAL_GRAYSCALE,
  GDK_VISUAL_STATIC_COLOR,
  GDK_VISUAL_PSEUDO_COLOR,
  GDK_VISUAL_TRUE_COLOR,
  GDK_VISUAL_DIRECT_COLOR
} GdkVisualType;
</ENUM>
<ENUM>
<NAME>GdkByteOrder</NAME>
typedef enum
{
  GDK_LSB_FIRST,
  GDK_MSB_FIRST
} GdkByteOrder;
</ENUM>
<STRUCT>
<NAME>GdkX11Visual</NAME>
struct _GdkX11Visual
{
  GObject parent_instance;

  GdkVisualType type;
  gint depth;
  GdkByteOrder byte_order;
  gint colormap_size;
  gint bits_per_rgb;

  guint32 red_mask;
  guint32 green_mask;
  guint32 blue_mask;

  Visual *xvisual;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_visual_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_visual_get_xvisual</NAME>
<RETURNS>Visual *</RETURNS>
GdkX11Visual *visual
</FUNCTION>
<MACRO>
<NAME>GDK_VISUAL_XVISUAL</NAME>
#define GDK_VISUAL_XVISUAL(visual)    (gdk_x11_visual_get_xvisual (visual))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_screen_lookup_visual</NAME>
<RETURNS>GdkX11Visual *</RETURNS>
GdkX11Screen *screen, VisualID      xvisualid
</FUNCTION>
<STRUCT>
<NAME>GdkX11VisualClass</NAME>
</STRUCT>
<MACRO>
<NAME>VK_USE_PLATFORM_XLIB_KHR</NAME>
#define VK_USE_PLATFORM_XLIB_KHR
</MACRO>
<MACRO>
<NAME>GDK_TYPE_X11_VULKAN_CONTEXT</NAME>
#define GDK_TYPE_X11_VULKAN_CONTEXT		(gdk_x11_vulkan_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_VULKAN_CONTEXT</NAME>
#define GDK_X11_VULKAN_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_VULKAN_CONTEXT, GdkX11VulkanContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_VULKAN_CONTEXT</NAME>
#define GDK_IS_X11_VULKAN_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_X11_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_VULKAN_CONTEXT_CLASS</NAME>
#define GDK_X11_VULKAN_CONTEXT_CLASS(klass) 	(G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_VULKAN_CONTEXT, GdkX11VulkanContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_VULKAN_CONTEXT_CLASS</NAME>
#define GDK_IS_X11_VULKAN_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_VULKAN_CONTEXT_GET_CLASS</NAME>
#define GDK_X11_VULKAN_CONTEXT_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_VULKAN_CONTEXT, GdkX11VulkanContextClass))
</MACRO>
<STRUCT>
<NAME>GdkX11VulkanContext</NAME>
struct _GdkX11VulkanContext
{
  GdkVulkanContext parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11VulkanContextClass</NAME>
struct _GdkX11VulkanContextClass
{
  GdkVulkanContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_vulkan_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_APP_LAUNCH_CONTEXT</NAME>
#define GDK_TYPE_X11_APP_LAUNCH_CONTEXT              (gdk_x11_app_launch_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_APP_LAUNCH_CONTEXT</NAME>
#define GDK_X11_APP_LAUNCH_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_APP_LAUNCH_CONTEXT, GdkX11AppLaunchContext))
</MACRO>
<MACRO>
<NAME>GDK_X11_APP_LAUNCH_CONTEXT_CLASS</NAME>
#define GDK_X11_APP_LAUNCH_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_APP_LAUNCH_CONTEXT, GdkX11AppLaunchContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_APP_LAUNCH_CONTEXT</NAME>
#define GDK_IS_X11_APP_LAUNCH_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_APP_LAUNCH_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_APP_LAUNCH_CONTEXT_CLASS</NAME>
#define GDK_IS_X11_APP_LAUNCH_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_APP_LAUNCH_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_APP_LAUNCH_CONTEXT_GET_CLASS</NAME>
#define GDK_X11_APP_LAUNCH_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_APP_LAUNCH_CONTEXT, GdkX11AppLaunchContextClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11AppLaunchContext</NAME>
typedef GdkAppLaunchContext GdkX11AppLaunchContext;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_app_launch_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11AppLaunchContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11AppLaunchContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_DEVICE_XI2</NAME>
#define GDK_TYPE_X11_DEVICE_XI2         (gdk_x11_device_xi2_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2</NAME>
#define GDK_X11_DEVICE_XI2(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2_CLASS</NAME>
#define GDK_X11_DEVICE_XI2_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2Class))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_XI2</NAME>
#define GDK_IS_X11_DEVICE_XI2(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_XI2))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_XI2_CLASS</NAME>
#define GDK_IS_X11_DEVICE_XI2_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_XI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2_GET_CLASS</NAME>
#define GDK_X11_DEVICE_XI2_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2Class))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_device_xi2_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceXI2</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceXI2Class</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_device_get_id</NAME>
<RETURNS>gint</RETURNS>
GdkDevice *device
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_DEVICE_MANAGER_XI2</NAME>
#define GDK_TYPE_X11_DEVICE_MANAGER_XI2         (gdk_x11_device_manager_xi2_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI2</NAME>
#define GDK_X11_DEVICE_MANAGER_XI2(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI2, GdkX11DeviceManagerXI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI2_CLASS</NAME>
#define GDK_X11_DEVICE_MANAGER_XI2_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_MANAGER_XI2, GdkX11DeviceManagerXI2Class))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_MANAGER_XI2</NAME>
#define GDK_IS_X11_DEVICE_MANAGER_XI2(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI2))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_MANAGER_XI2_CLASS</NAME>
#define GDK_IS_X11_DEVICE_MANAGER_XI2_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_MANAGER_XI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI2_GET_CLASS</NAME>
#define GDK_X11_DEVICE_MANAGER_XI2_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI2, GdkX11DeviceManagerXI2Class))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_device_manager_xi2_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceManagerXI2</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceManagerXI2Class</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_device_manager_lookup</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkX11DeviceManagerXI2 *device_manager, gint                    device_id
</FUNCTION>
<TYPEDEF>
<NAME>GdkX11Display</NAME>
typedef GdkDisplay GdkX11Display;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_X11_DISPLAY</NAME>
#define GDK_TYPE_X11_DISPLAY              (gdk_x11_display_get_type())
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY</NAME>
#define GDK_X11_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_DISPLAY, GdkX11Display))
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY_CLASS</NAME>
#define GDK_X11_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_DISPLAY, GdkX11DisplayClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DISPLAY</NAME>
#define GDK_IS_X11_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DISPLAY_CLASS</NAME>
#define GDK_IS_X11_DISPLAY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY_GET_CLASS</NAME>
#define GDK_X11_DISPLAY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_DISPLAY, GdkX11DisplayClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_display_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_open</NAME>
<RETURNS>GdkDisplay *</RETURNS>
const char  *display_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xdisplay</NAME>
<RETURNS>Display *</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xscreen</NAME>
<RETURNS>Screen *</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xrootwindow</NAME>
<RETURNS>Window</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xcursor</NAME>
<RETURNS>Cursor</RETURNS>
GdkDisplay  *display, GdkCursor   *cursor
</FUNCTION>
<MACRO>
<NAME>GDK_DISPLAY_XDISPLAY</NAME>
#define GDK_DISPLAY_XDISPLAY(display) (gdk_x11_display_get_xdisplay (display))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_display_get_user_time</NAME>
<RETURNS>guint32</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_startup_notification_id</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_startup_notification_id</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const gchar *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_program_class</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const char  *program_class
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_cursor_theme</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const gchar *theme, const gint   size
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_broadcast_startup_message</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, const char *message_type, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_lookup_xdisplay</NAME>
<RETURNS>GdkDisplay *</RETURNS>
Display *xdisplay
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_screen</NAME>
<RETURNS>GdkX11Screen *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_primary_monitor</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_grab</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_ungrab</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_surface_scale</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, gint scale
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_push</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_pop</NAME>
<RETURNS>gint</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_pop_ignored</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_set_sm_client_id</NAME>
<RETURNS>void</RETURNS>
const gchar *sm_client_id
</FUNCTION>
<STRUCT>
<NAME>GdkX11Display</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DisplayClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_DRAG</NAME>
#define GDK_TYPE_X11_DRAG              (gdk_x11_drag_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG</NAME>
#define GDK_X11_DRAG(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_DRAG, GdkX11Drag))
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG_CLASS</NAME>
#define GDK_X11_DRAG_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_DRAG, GdkX11DragClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DRAG</NAME>
#define GDK_IS_X11_DRAG(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_DRAG))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DRAG_CLASS</NAME>
#define GDK_IS_X11_DRAG_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_DRAG))
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG_GET_CLASS</NAME>
#define GDK_X11_DRAG_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_DRAG, GdkX11DragClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11Drag</NAME>
typedef GdkDrag GdkX11Drag;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_drag_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11Drag</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DragClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_GL_CONTEXT</NAME>
#define GDK_TYPE_X11_GL_CONTEXT		(gdk_x11_gl_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_GL_CONTEXT</NAME>
#define GDK_X11_GL_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_GL_CONTEXT, GdkX11GLContext))
</MACRO>
<MACRO>
<NAME>GDK_X11_IS_GL_CONTEXT</NAME>
#define GDK_X11_IS_GL_CONTEXT(obj)	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_X11_GL_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_gl_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_glx_version</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay *display, gint       *major, gint       *minor
</FUNCTION>
<STRUCT>
<NAME>GdkX11GLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11GLContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_MONITOR</NAME>
#define GDK_TYPE_X11_MONITOR           (gdk_x11_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_MONITOR</NAME>
#define GDK_X11_MONITOR(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_MONITOR, GdkX11Monitor))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_MONITOR</NAME>
#define GDK_IS_X11_MONITOR(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_MONITOR))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_monitor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_monitor_get_output</NAME>
<RETURNS>XID</RETURNS>
GdkMonitor *monitor
</FUNCTION>
<STRUCT>
<NAME>GdkX11Monitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11MonitorClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_get_xatom_by_name_for_display</NAME>
<RETURNS>Atom</RETURNS>
GdkDisplay  *display, const gchar *atom_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_get_xatom_name_for_display</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDisplay  *display, Atom         xatom
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_SCREEN</NAME>
#define GDK_TYPE_X11_SCREEN              (gdk_x11_screen_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN</NAME>
#define GDK_X11_SCREEN(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_SCREEN, GdkX11Screen))
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN_CLASS</NAME>
#define GDK_X11_SCREEN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_SCREEN, GdkX11ScreenClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SCREEN</NAME>
#define GDK_IS_X11_SCREEN(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_SCREEN))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SCREEN_CLASS</NAME>
#define GDK_IS_X11_SCREEN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_SCREEN))
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN_GET_CLASS</NAME>
#define GDK_X11_SCREEN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_SCREEN, GdkX11ScreenClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_screen_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_xscreen</NAME>
<RETURNS>Screen *</RETURNS>
GdkX11Screen   *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_screen_number</NAME>
<RETURNS>int</RETURNS>
GdkX11Screen   *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_window_manager_name</NAME>
<RETURNS>const char *</RETURNS>
GdkX11Screen *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_supports_net_wm_hint</NAME>
<RETURNS>gboolean</RETURNS>
GdkX11Screen *screen, const char   *property_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_monitor_output</NAME>
<RETURNS>XID</RETURNS>
GdkX11Screen *screen, gint          monitor_num
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_number_of_desktops</NAME>
<RETURNS>guint32</RETURNS>
GdkX11Screen *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_current_desktop</NAME>
<RETURNS>guint32</RETURNS>
GdkX11Screen *screen
</FUNCTION>
<STRUCT>
<NAME>GdkX11Screen</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11ScreenClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_display_text_property_to_text_list</NAME>
<RETURNS>gint</RETURNS>
GdkDisplay   *display, const char   *encoding, gint          format, const guchar *text, gint          length, gchar      ***list
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_free_text_list</NAME>
<RETURNS>void</RETURNS>
gchar       **list
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_string_to_compound_text</NAME>
<RETURNS>gint</RETURNS>
GdkDisplay   *display, const char   *str, const char  **encoding, gint         *format, guchar      **ctext, gint         *length
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_utf8_to_compound_text</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay   *display, const char   *str, const char  **encoding, gint         *format, guchar      **ctext, gint         *length
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_free_compound_text</NAME>
<RETURNS>void</RETURNS>
guchar       *ctext
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_SURFACE</NAME>
#define GDK_TYPE_X11_SURFACE              (gdk_x11_surface_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SURFACE</NAME>
#define GDK_X11_SURFACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_SURFACE, GdkX11Surface))
</MACRO>
<MACRO>
<NAME>GDK_X11_SURFACE_CLASS</NAME>
#define GDK_X11_SURFACE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_SURFACE, GdkX11SurfaceClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SURFACE</NAME>
#define GDK_IS_X11_SURFACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SURFACE_CLASS</NAME>
#define GDK_IS_X11_SURFACE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_X11_SURFACE_GET_CLASS</NAME>
#define GDK_X11_SURFACE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_SURFACE, GdkX11SurfaceClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11Surface</NAME>
typedef GdkSurface GdkX11Surface;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_surface_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_get_xid</NAME>
<RETURNS>Window</RETURNS>
GdkSurface   *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_user_time</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, guint32      timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_utf8_property</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, const gchar *name, const gchar *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_theme_variant</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, const char  *variant
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_move_to_current_desktop</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_get_desktop</NAME>
<RETURNS>guint32</RETURNS>
GdkSurface   *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_move_to_desktop</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, guint32      desktop
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_frame_sync_enabled</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean   frame_sync_enabled
</FUNCTION>
<MACRO>
<NAME>GDK_SURFACE_XDISPLAY</NAME>
#define GDK_SURFACE_XDISPLAY(win)      (GDK_DISPLAY_XDISPLAY (gdk_surface_get_display (win)))
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_XID</NAME>
#define GDK_SURFACE_XID(win)           (gdk_x11_surface_get_xid (win))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_get_server_time</NAME>
<RETURNS>guint32</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_lookup_for_display</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay *display, Window      window
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_skip_taskbar_hint</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean    skips_taskbar
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_skip_pager_hint</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean    skips_pager
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_urgency_hint</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean    urgent
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_group</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, GdkSurface *leader
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_get_group</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkSurface *surface
</FUNCTION>
<STRUCT>
<NAME>GdkX11Surface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11SurfaceClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_XID_TO_POINTER</NAME>
#define GDK_XID_TO_POINTER(xid) GUINT_TO_POINTER(xid)
</MACRO>
<MACRO>
<NAME>GDK_POINTER_TO_XID</NAME>
#define GDK_POINTER_TO_XID(pointer) GPOINTER_TO_UINT(pointer)
</MACRO>
<FUNCTION>
<NAME>gdk_xsettings_root_window_filter</NAME>
<RETURNS>GdkFilterReturn</RETURNS>
const XEvent *xevent, gpointer      data
</FUNCTION>
<FUNCTION>
<NAME>gdk_xsettings_manager_window_filter</NAME>
<RETURNS>GdkFilterReturn</RETURNS>
const XEvent *xevent, gpointer      data
</FUNCTION>
<MACRO>
<NAME>GDK_WINDOWING_X11</NAME>
#define GDK_WINDOWING_X11
</MACRO>
<MACRO>
<NAME>GDK_WINDOWING_WAYLAND</NAME>
#define GDK_WINDOWING_WAYLAND
</MACRO>
<MACRO>
<NAME>GDK_RENDERING_VULKAN</NAME>
#define GDK_RENDERING_VULKAN
</MACRO>
<MACRO>
<NAME>GDK_TYPE_INPUT_SOURCE</NAME>
#define GDK_TYPE_INPUT_SOURCE (gdk_input_source_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TYPE</NAME>
#define GDK_TYPE_DEVICE_TYPE (gdk_device_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_PAD_FEATURE</NAME>
#define GDK_TYPE_DEVICE_PAD_FEATURE (gdk_device_pad_feature_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TOOL_TYPE</NAME>
#define GDK_TYPE_DEVICE_TOOL_TYPE (gdk_device_tool_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DRAG_CANCEL_REASON</NAME>
#define GDK_TYPE_DRAG_CANCEL_REASON (gdk_drag_cancel_reason_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_EVENT_TYPE</NAME>
#define GDK_TYPE_EVENT_TYPE (gdk_event_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_TOUCHPAD_GESTURE_PHASE</NAME>
#define GDK_TYPE_TOUCHPAD_GESTURE_PHASE (gdk_touchpad_gesture_phase_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SCROLL_DIRECTION</NAME>
#define GDK_TYPE_SCROLL_DIRECTION (gdk_scroll_direction_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_NOTIFY_TYPE</NAME>
#define GDK_TYPE_NOTIFY_TYPE (gdk_notify_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_CROSSING_MODE</NAME>
#define GDK_TYPE_CROSSING_MODE (gdk_crossing_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_KEY_MATCH</NAME>
#define GDK_TYPE_KEY_MATCH (gdk_key_match_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_FRAME_CLOCK_PHASE</NAME>
#define GDK_TYPE_FRAME_CLOCK_PHASE (gdk_frame_clock_phase_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MEMORY_FORMAT</NAME>
#define GDK_TYPE_MEMORY_FORMAT (gdk_memory_format_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SUBPIXEL_LAYOUT</NAME>
#define GDK_TYPE_SUBPIXEL_LAYOUT (gdk_subpixel_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_PAINTABLE_FLAGS</NAME>
#define GDK_TYPE_PAINTABLE_FLAGS (gdk_paintable_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_ANCHOR_HINTS</NAME>
#define GDK_TYPE_ANCHOR_HINTS (gdk_anchor_hints_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SEAT_CAPABILITIES</NAME>
#define GDK_TYPE_SEAT_CAPABILITIES (gdk_seat_capabilities_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SURFACE_EDGE</NAME>
#define GDK_TYPE_SURFACE_EDGE (gdk_surface_edge_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_FULLSCREEN_MODE</NAME>
#define GDK_TYPE_FULLSCREEN_MODE (gdk_fullscreen_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SURFACE_STATE</NAME>
#define GDK_TYPE_SURFACE_STATE (gdk_surface_state_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAVITY</NAME>
#define GDK_TYPE_GRAVITY (gdk_gravity_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MODIFIER_TYPE</NAME>
#define GDK_TYPE_MODIFIER_TYPE (gdk_modifier_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GL_ERROR</NAME>
#define GDK_TYPE_GL_ERROR (gdk_gl_error_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_VULKAN_ERROR</NAME>
#define GDK_TYPE_VULKAN_ERROR (gdk_vulkan_error_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_AXIS_USE</NAME>
#define GDK_TYPE_AXIS_USE (gdk_axis_use_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_AXIS_FLAGS</NAME>
#define GDK_TYPE_AXIS_FLAGS (gdk_axis_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DRAG_ACTION</NAME>
#define GDK_TYPE_DRAG_ACTION (gdk_drag_action_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_MAJOR_VERSION</NAME>
#define GDK_MAJOR_VERSION (3)
</MACRO>
<MACRO>
<NAME>GDK_MINOR_VERSION</NAME>
#define GDK_MINOR_VERSION (98)
</MACRO>
<MACRO>
<NAME>GDK_MICRO_VERSION</NAME>
#define GDK_MICRO_VERSION (5)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED</NAME>
#define GDK_DEPRECATED _GDK_EXTERN
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_FOR</NAME>
#define GDK_DEPRECATED_FOR(f) _GDK_EXTERN
</MACRO>
<MACRO>
<NAME>GDK_UNAVAILABLE</NAME>
#define GDK_UNAVAILABLE(maj,min) _GDK_EXTERN
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_92</NAME>
#define GDK_VERSION_3_92        (G_ENCODE_VERSION (3, 92))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_94</NAME>
#define GDK_VERSION_3_94        (G_ENCODE_VERSION (3, 94))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_4_0</NAME>
#define GDK_VERSION_4_0        (G_ENCODE_VERSION (4, 0))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_CUR_STABLE</NAME>
#define GDK_VERSION_CUR_STABLE         (G_ENCODE_VERSION (GDK_MAJOR_VERSION, GDK_MINOR_VERSION + 1))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_PREV_STABLE</NAME>
#define GDK_VERSION_PREV_STABLE        (G_ENCODE_VERSION (GDK_MAJOR_VERSION, GDK_MINOR_VERSION - 1))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_MIN_REQUIRED</NAME>
# define GDK_VERSION_MIN_REQUIRED      (GDK_VERSION_CUR_STABLE)
</MACRO>
<MACRO>
<NAME>GDK_VERSION_MAX_ALLOWED</NAME>
#  define GDK_VERSION_MAX_ALLOWED      GDK_VERSION_MIN_REQUIRED
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_ALL</NAME>
#define GDK_AVAILABLE_IN_ALL                  _GDK_EXTERN
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_4_0</NAME>
# define GDK_AVAILABLE_IN_4_0                GDK_UNAVAILABLE(4, 0)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_4_0</NAME>
# define GDK_DEPRECATED_IN_4_0                GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_4_0_FOR</NAME>
# define GDK_DEPRECATED_IN_4_0_FOR(f)         GDK_DEPRECATED_FOR(f)
</MACRO>
<VARIABLE>
<NAME>gtk_primary_selection_device_manager_interface</NAME>
extern const struct wl_interface gtk_primary_selection_device_manager_interface;
</VARIABLE>
<VARIABLE>
<NAME>gtk_primary_selection_device_interface</NAME>
extern const struct wl_interface gtk_primary_selection_device_interface;
</VARIABLE>
<VARIABLE>
<NAME>gtk_primary_selection_offer_interface</NAME>
extern const struct wl_interface gtk_primary_selection_offer_interface;
</VARIABLE>
<VARIABLE>
<NAME>gtk_primary_selection_source_interface</NAME>
extern const struct wl_interface gtk_primary_selection_source_interface;
</VARIABLE>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_CREATE_SOURCE</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_CREATE_SOURCE 0
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_GET_DEVICE</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_GET_DEVICE 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_DESTROY</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_DESTROY 2
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_CREATE_SOURCE_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_CREATE_SOURCE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_GET_DEVICE_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_GET_DEVICE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_DESTROY_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_create_source</NAME>
<RETURNS>struct gtk_primary_selection_source *</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_get_device</NAME>
<RETURNS>struct gtk_primary_selection_device *</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager, struct wl_seat *seat
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager
</FUNCTION>
<STRUCT>
<NAME>gtk_primary_selection_device_listener</NAME>
struct gtk_primary_selection_device_listener {
	/**
	 * introduce a new wp_primary_selection_offer
	 *
	 * Introduces a new wp_primary_selection_offer object that may be
	 * used to receive the current primary selection. Immediately
	 * following this event, the new wp_primary_selection_offer object
	 * will send wp_primary_selection_offer.offer events to describe
	 * the offered mime types.
	 */
	void (*data_offer)(void *data,
			   struct gtk_primary_selection_device *gtk_primary_selection_device,
			   struct gtk_primary_selection_offer *offer);
	/**
	 * advertise a new primary selection
	 *
	 * The wp_primary_selection_device.selection event is sent to
	 * notify the client of a new primary selection. This event is sent
	 * after the wp_primary_selection.data_offer event introducing this
	 * object, and after the offer has announced its mimetypes through
	 * wp_primary_selection_offer.offer.
	 *
	 * The data_offer is valid until a new 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 gtk_primary_selection_device *gtk_primary_selection_device,
			  struct gtk_primary_selection_offer *id);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_primary_selection_device_add_listener</NAME>
<RETURNS>int</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device, const struct gtk_primary_selection_device_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_SET_SELECTION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_SET_SELECTION 0
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_DESTROY</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_DESTROY 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_DATA_OFFER_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_DATA_OFFER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_SELECTION_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_SELECTION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_SET_SELECTION_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_SET_SELECTION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_DESTROY_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_primary_selection_device_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_set_selection</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device, struct gtk_primary_selection_source *source, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device
</FUNCTION>
<STRUCT>
<NAME>gtk_primary_selection_offer_listener</NAME>
struct gtk_primary_selection_offer_listener {
	/**
	 * advertise offered mime type
	 *
	 * Sent immediately after creating announcing the
	 * wp_primary_selection_offer through
	 * wp_primary_selection_device.data_offer. One event is sent per
	 * offered mime type.
	 */
	void (*offer)(void *data,
		      struct gtk_primary_selection_offer *gtk_primary_selection_offer,
		      const char *mime_type);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_primary_selection_offer_add_listener</NAME>
<RETURNS>int</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer, const struct gtk_primary_selection_offer_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_OFFER_RECEIVE</NAME>
#define GTK_PRIMARY_SELECTION_OFFER_RECEIVE 0
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_OFFER_DESTROY</NAME>
#define GTK_PRIMARY_SELECTION_OFFER_DESTROY 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_OFFER_OFFER_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_OFFER_OFFER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_OFFER_RECEIVE_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_OFFER_RECEIVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_OFFER_DESTROY_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_OFFER_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_primary_selection_offer_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_offer_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_offer_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_offer_receive</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer, const char *mime_type, int32_t fd
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_offer_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer
</FUNCTION>
<STRUCT>
<NAME>gtk_primary_selection_source_listener</NAME>
struct gtk_primary_selection_source_listener {
	/**
	 * send the primary selection contents
	 *
	 * Request for the current primary selection contents from the
	 * client. Send the specified mime type over the passed file
	 * descriptor, then close it.
	 */
	void (*send)(void *data,
		     struct gtk_primary_selection_source *gtk_primary_selection_source,
		     const char *mime_type,
		     int32_t fd);
	/**
	 * request for primary selection contents was canceled
	 *
	 * This primary selection source is no longer valid. The client
	 * should clean up and destroy this primary selection source.
	 */
	void (*cancelled)(void *data,
			  struct gtk_primary_selection_source *gtk_primary_selection_source);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_primary_selection_source_add_listener</NAME>
<RETURNS>int</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source, const struct gtk_primary_selection_source_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_OFFER</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_OFFER 0
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_DESTROY</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_DESTROY 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_SEND_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_SEND_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_CANCELLED_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_CANCELLED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_OFFER_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_OFFER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_DESTROY_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_primary_selection_source_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_source_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_source_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_source_offer</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source, const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_source_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source
</FUNCTION>
<STRUCT>
<NAME>gtk_primary_selection_device</NAME>
struct gtk_primary_selection_device;
</STRUCT>
<STRUCT>
<NAME>gtk_primary_selection_device_manager</NAME>
struct gtk_primary_selection_device_manager;
</STRUCT>
<STRUCT>
<NAME>gtk_primary_selection_offer</NAME>
struct gtk_primary_selection_offer;
</STRUCT>
<STRUCT>
<NAME>gtk_primary_selection_source</NAME>
struct gtk_primary_selection_source;
</STRUCT>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<VARIABLE>
<NAME>gtk_shell1_interface</NAME>
extern const struct wl_interface gtk_shell1_interface;
</VARIABLE>
<VARIABLE>
<NAME>gtk_surface1_interface</NAME>
extern const struct wl_interface gtk_surface1_interface;
</VARIABLE>
<MACRO>
<NAME>GTK_SHELL1_CAPABILITY_ENUM</NAME>
#define GTK_SHELL1_CAPABILITY_ENUM
</MACRO>
<ENUM>
<NAME>gtk_shell1_capability</NAME>
enum gtk_shell1_capability {
	GTK_SHELL1_CAPABILITY_GLOBAL_APP_MENU = 1,
	GTK_SHELL1_CAPABILITY_GLOBAL_MENU_BAR = 2,
	GTK_SHELL1_CAPABILITY_DESKTOP_ICONS = 3,
};
</ENUM>
<STRUCT>
<NAME>gtk_shell1_listener</NAME>
struct gtk_shell1_listener {
	/**
	 */
	void (*capabilities)(void *data,
			     struct gtk_shell1 *gtk_shell1,
			     uint32_t capabilities);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_shell1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct gtk_shell1 *gtk_shell1, const struct gtk_shell1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>GTK_SHELL1_GET_GTK_SURFACE</NAME>
#define GTK_SHELL1_GET_GTK_SURFACE 0
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_SET_STARTUP_ID</NAME>
#define GTK_SHELL1_SET_STARTUP_ID 1
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_SYSTEM_BELL</NAME>
#define GTK_SHELL1_SYSTEM_BELL 2
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_CAPABILITIES_SINCE_VERSION</NAME>
#define GTK_SHELL1_CAPABILITIES_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_GET_GTK_SURFACE_SINCE_VERSION</NAME>
#define GTK_SHELL1_GET_GTK_SURFACE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_SET_STARTUP_ID_SINCE_VERSION</NAME>
#define GTK_SHELL1_SET_STARTUP_ID_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_SYSTEM_BELL_SINCE_VERSION</NAME>
#define GTK_SHELL1_SYSTEM_BELL_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_shell1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_shell1 *gtk_shell1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct gtk_shell1 *gtk_shell1
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_shell1 *gtk_shell1
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_shell1 *gtk_shell1
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_get_gtk_surface</NAME>
<RETURNS>struct gtk_surface1 *</RETURNS>
struct gtk_shell1 *gtk_shell1, struct wl_surface *surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_set_startup_id</NAME>
<RETURNS>void</RETURNS>
struct gtk_shell1 *gtk_shell1, const char *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_system_bell</NAME>
<RETURNS>void</RETURNS>
struct gtk_shell1 *gtk_shell1, struct gtk_surface1 *surface
</FUNCTION>
<MACRO>
<NAME>GTK_SURFACE1_STATE_ENUM</NAME>
#define GTK_SURFACE1_STATE_ENUM
</MACRO>
<ENUM>
<NAME>gtk_surface1_state</NAME>
enum gtk_surface1_state {
	GTK_SURFACE1_STATE_TILED = 1,
	/**
	 * @since 2
	 */
	GTK_SURFACE1_STATE_TILED_TOP = 2,
	/**
	 * @since 2
	 */
	GTK_SURFACE1_STATE_TILED_RIGHT = 3,
	/**
	 * @since 2
	 */
	GTK_SURFACE1_STATE_TILED_BOTTOM = 4,
	/**
	 * @since 2
	 */
	GTK_SURFACE1_STATE_TILED_LEFT = 5,
};
</ENUM>
<MACRO>
<NAME>GTK_SURFACE1_STATE_TILED_TOP_SINCE_VERSION</NAME>
#define GTK_SURFACE1_STATE_TILED_TOP_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_STATE_TILED_RIGHT_SINCE_VERSION</NAME>
#define GTK_SURFACE1_STATE_TILED_RIGHT_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_STATE_TILED_BOTTOM_SINCE_VERSION</NAME>
#define GTK_SURFACE1_STATE_TILED_BOTTOM_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_STATE_TILED_LEFT_SINCE_VERSION</NAME>
#define GTK_SURFACE1_STATE_TILED_LEFT_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_EDGE_CONSTRAINT_ENUM</NAME>
#define GTK_SURFACE1_EDGE_CONSTRAINT_ENUM
</MACRO>
<ENUM>
<NAME>gtk_surface1_edge_constraint</NAME>
enum gtk_surface1_edge_constraint {
	GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_TOP = 1,
	GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_RIGHT = 2,
	GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_BOTTOM = 3,
	GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_LEFT = 4,
};
</ENUM>
<STRUCT>
<NAME>gtk_surface1_listener</NAME>
struct gtk_surface1_listener {
	/**
	 */
	void (*configure)(void *data,
			  struct gtk_surface1 *gtk_surface1,
			  struct wl_array *states);
	/**
	 * @since 2
	 */
	void (*configure_edges)(void *data,
				struct gtk_surface1 *gtk_surface1,
				struct wl_array *constraints);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_surface1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct gtk_surface1 *gtk_surface1, const struct gtk_surface1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>GTK_SURFACE1_SET_DBUS_PROPERTIES</NAME>
#define GTK_SURFACE1_SET_DBUS_PROPERTIES 0
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_SET_MODAL</NAME>
#define GTK_SURFACE1_SET_MODAL 1
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_UNSET_MODAL</NAME>
#define GTK_SURFACE1_UNSET_MODAL 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_PRESENT</NAME>
#define GTK_SURFACE1_PRESENT 3
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_CONFIGURE_SINCE_VERSION</NAME>
#define GTK_SURFACE1_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_CONFIGURE_EDGES_SINCE_VERSION</NAME>
#define GTK_SURFACE1_CONFIGURE_EDGES_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_SET_DBUS_PROPERTIES_SINCE_VERSION</NAME>
#define GTK_SURFACE1_SET_DBUS_PROPERTIES_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_SET_MODAL_SINCE_VERSION</NAME>
#define GTK_SURFACE1_SET_MODAL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_UNSET_MODAL_SINCE_VERSION</NAME>
#define GTK_SURFACE1_UNSET_MODAL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_PRESENT_SINCE_VERSION</NAME>
#define GTK_SURFACE1_PRESENT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_surface1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct gtk_surface1 *gtk_surface1
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_surface1 *gtk_surface1
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_set_dbus_properties</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1, const char *application_id, const char *app_menu_path, const char *menubar_path, const char *window_object_path, const char *application_object_path, const char *unique_bus_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_set_modal</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_unset_modal</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_present</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1, uint32_t time
</FUNCTION>
<STRUCT>
<NAME>gtk_shell1</NAME>
struct gtk_shell1;
</STRUCT>
<STRUCT>
<NAME>gtk_surface1</NAME>
struct gtk_surface1;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<VARIABLE>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_interface</NAME>
extern const struct wl_interface zwp_keyboard_shortcuts_inhibit_manager_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_interface</NAME>
extern const struct wl_interface zwp_keyboard_shortcuts_inhibitor_v1_interface;
</VARIABLE>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_ERROR_ENUM</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_error</NAME>
enum zwp_keyboard_shortcuts_inhibit_manager_v1_error {
	/**
	 * the shortcuts are already inhibited for this surface
	 */
	ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_ERROR_ALREADY_INHIBITED = 0,
};
</ENUM>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_DESTROY</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_INHIBIT_SHORTCUTS</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_INHIBIT_SHORTCUTS 1
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_INHIBIT_SHORTCUTS_SINCE_VERSION</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_INHIBIT_SHORTCUTS_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_keyboard_shortcuts_inhibit_manager_v1 *zwp_keyboard_shortcuts_inhibit_manager_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_keyboard_shortcuts_inhibit_manager_v1 *zwp_keyboard_shortcuts_inhibit_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_keyboard_shortcuts_inhibit_manager_v1 *zwp_keyboard_shortcuts_inhibit_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_keyboard_shortcuts_inhibit_manager_v1 *zwp_keyboard_shortcuts_inhibit_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_inhibit_shortcuts</NAME>
<RETURNS>struct zwp_keyboard_shortcuts_inhibitor_v1 *</RETURNS>
struct zwp_keyboard_shortcuts_inhibit_manager_v1 *zwp_keyboard_shortcuts_inhibit_manager_v1, struct wl_surface *surface, struct wl_seat *seat
</FUNCTION>
<STRUCT>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_listener</NAME>
struct zwp_keyboard_shortcuts_inhibitor_v1_listener {
	/**
	 * shortcuts are inhibited
	 *
	 * This event indicates that the shortcut inhibitor is active.
	 *
	 * The compositor sends this event every time compositor shortcuts
	 * are inhibited on behalf of the surface. When active, the client
	 * may receive input events normally reserved by the compositor
	 * (see zwp_keyboard_shortcuts_inhibitor_v1).
	 *
	 * This occurs typically when the initial request
	 * "inhibit_shortcuts" first becomes active or when the user
	 * instructs the compositor to re-enable and existing shortcuts
	 * inhibitor using any mechanism offered by the compositor.
	 */
	void (*active)(void *data,
		       struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1);
	/**
	 * shortcuts are restored
	 *
	 * This event indicates that the shortcuts inhibitor is inactive,
	 * normal shortcuts processing is restored by the compositor.
	 */
	void (*inactive)(void *data,
			 struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1, const struct zwp_keyboard_shortcuts_inhibitor_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_DESTROY</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_ACTIVE_SINCE_VERSION</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_ACTIVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_INACTIVE_SINCE_VERSION</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_INACTIVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1
</FUNCTION>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1</NAME>
struct zwp_keyboard_shortcuts_inhibit_manager_v1;
</STRUCT>
<STRUCT>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1</NAME>
struct zwp_keyboard_shortcuts_inhibitor_v1;
</STRUCT>
<VARIABLE>
<NAME>zwp_pointer_gestures_v1_interface</NAME>
extern const struct wl_interface zwp_pointer_gestures_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_pointer_gesture_swipe_v1_interface</NAME>
extern const struct wl_interface zwp_pointer_gesture_swipe_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_pointer_gesture_pinch_v1_interface</NAME>
extern const struct wl_interface zwp_pointer_gesture_pinch_v1_interface;
</VARIABLE>
<MACRO>
<NAME>ZWP_POINTER_GESTURES_V1_GET_SWIPE_GESTURE</NAME>
#define ZWP_POINTER_GESTURES_V1_GET_SWIPE_GESTURE 0
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURES_V1_GET_PINCH_GESTURE</NAME>
#define ZWP_POINTER_GESTURES_V1_GET_PINCH_GESTURE 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURES_V1_RELEASE</NAME>
#define ZWP_POINTER_GESTURES_V1_RELEASE 2
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURES_V1_GET_SWIPE_GESTURE_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURES_V1_GET_SWIPE_GESTURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURES_V1_GET_PINCH_GESTURE_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURES_V1_GET_PINCH_GESTURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURES_V1_RELEASE_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURES_V1_RELEASE_SINCE_VERSION 2
</MACRO>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_get_swipe_gesture</NAME>
<RETURNS>struct zwp_pointer_gesture_swipe_v1 *</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1, struct wl_pointer *pointer
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_get_pinch_gesture</NAME>
<RETURNS>struct zwp_pointer_gesture_pinch_v1 *</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1, struct wl_pointer *pointer
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_release</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1
</FUNCTION>
<STRUCT>
<NAME>zwp_pointer_gesture_swipe_v1_listener</NAME>
struct zwp_pointer_gesture_swipe_v1_listener {
	/**
	 * multi-finger swipe begin
	 *
	 * This event is sent when a multi-finger swipe gesture is
	 * detected on the device.
	 * @param time timestamp with millisecond granularity
	 * @param fingers number of fingers
	 */
	void (*begin)(void *data,
		      struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1,
		      uint32_t serial,
		      uint32_t time,
		      struct wl_surface *surface,
		      uint32_t fingers);
	/**
	 * multi-finger swipe motion
	 *
	 * This event is sent when a multi-finger swipe gesture changes
	 * the position of the logical center.
	 *
	 * The dx and dy coordinates are relative coordinates of the
	 * logical center of the gesture compared to the previous event.
	 * @param time timestamp with millisecond granularity
	 * @param dx delta x coordinate in surface coordinate space
	 * @param dy delta y coordinate in surface coordinate space
	 */
	void (*update)(void *data,
		       struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1,
		       uint32_t time,
		       wl_fixed_t dx,
		       wl_fixed_t dy);
	/**
	 * multi-finger swipe end
	 *
	 * This event is sent when a multi-finger swipe gesture ceases to
	 * be valid. This may happen when one or more fingers are lifted or
	 * the gesture is cancelled.
	 *
	 * When a gesture is cancelled, the client should undo state
	 * changes caused by this gesture. What causes a gesture to be
	 * cancelled is implementation-dependent.
	 * @param time timestamp with millisecond granularity
	 * @param cancelled 1 if the gesture was cancelled, 0 otherwise
	 */
	void (*end)(void *data,
		    struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1,
		    uint32_t serial,
		    uint32_t time,
		    int32_t cancelled);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_pointer_gesture_swipe_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1, const struct zwp_pointer_gesture_swipe_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_SWIPE_V1_DESTROY</NAME>
#define ZWP_POINTER_GESTURE_SWIPE_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_SWIPE_V1_BEGIN_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_SWIPE_V1_BEGIN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_SWIPE_V1_UPDATE_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_SWIPE_V1_UPDATE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_SWIPE_V1_END_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_SWIPE_V1_END_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_SWIPE_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_SWIPE_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_pointer_gesture_swipe_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_swipe_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_swipe_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_swipe_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1
</FUNCTION>
<STRUCT>
<NAME>zwp_pointer_gesture_pinch_v1_listener</NAME>
struct zwp_pointer_gesture_pinch_v1_listener {
	/**
	 * multi-finger pinch begin
	 *
	 * This event is sent when a multi-finger pinch gesture is
	 * detected on the device.
	 * @param time timestamp with millisecond granularity
	 * @param fingers number of fingers
	 */
	void (*begin)(void *data,
		      struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1,
		      uint32_t serial,
		      uint32_t time,
		      struct wl_surface *surface,
		      uint32_t fingers);
	/**
	 * multi-finger pinch motion
	 *
	 * This event is sent when a multi-finger pinch gesture changes
	 * the position of the logical center, the rotation or the relative
	 * scale.
	 *
	 * The dx and dy coordinates are relative coordinates in the
	 * surface coordinate space of the logical center of the gesture.
	 *
	 * The scale factor is an absolute scale compared to the
	 * pointer_gesture_pinch.begin event, e.g. a scale of 2 means the
	 * fingers are now twice as far apart as on
	 * pointer_gesture_pinch.begin.
	 *
	 * The rotation is the relative angle in degrees clockwise compared
	 * to the previous pointer_gesture_pinch.begin or
	 * pointer_gesture_pinch.update event.
	 * @param time timestamp with millisecond granularity
	 * @param dx delta x coordinate in surface coordinate space
	 * @param dy delta y coordinate in surface coordinate space
	 * @param scale scale relative to the initial finger position
	 * @param rotation angle in degrees cw relative to the previous event
	 */
	void (*update)(void *data,
		       struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1,
		       uint32_t time,
		       wl_fixed_t dx,
		       wl_fixed_t dy,
		       wl_fixed_t scale,
		       wl_fixed_t rotation);
	/**
	 * multi-finger pinch end
	 *
	 * This event is sent when a multi-finger pinch gesture ceases to
	 * be valid. This may happen when one or more fingers are lifted or
	 * the gesture is cancelled.
	 *
	 * When a gesture is cancelled, the client should undo state
	 * changes caused by this gesture. What causes a gesture to be
	 * cancelled is implementation-dependent.
	 * @param time timestamp with millisecond granularity
	 * @param cancelled 1 if the gesture was cancelled, 0 otherwise
	 */
	void (*end)(void *data,
		    struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1,
		    uint32_t serial,
		    uint32_t time,
		    int32_t cancelled);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_pointer_gesture_pinch_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1, const struct zwp_pointer_gesture_pinch_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_PINCH_V1_DESTROY</NAME>
#define ZWP_POINTER_GESTURE_PINCH_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_PINCH_V1_BEGIN_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_PINCH_V1_BEGIN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_PINCH_V1_UPDATE_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_PINCH_V1_UPDATE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_PINCH_V1_END_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_PINCH_V1_END_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_PINCH_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_PINCH_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_pointer_gesture_pinch_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_pinch_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_pinch_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_pinch_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1
</FUNCTION>
<STRUCT>
<NAME>wl_pointer</NAME>
struct wl_pointer;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zwp_pointer_gesture_pinch_v1</NAME>
struct zwp_pointer_gesture_pinch_v1;
</STRUCT>
<STRUCT>
<NAME>zwp_pointer_gesture_swipe_v1</NAME>
struct zwp_pointer_gesture_swipe_v1;
</STRUCT>
<STRUCT>
<NAME>zwp_pointer_gestures_v1</NAME>
struct zwp_pointer_gestures_v1;
</STRUCT>
<VARIABLE>
<NAME>org_kde_kwin_server_decoration_manager_interface</NAME>
extern const struct wl_interface org_kde_kwin_server_decoration_manager_interface;
</VARIABLE>
<VARIABLE>
<NAME>org_kde_kwin_server_decoration_interface</NAME>
extern const struct wl_interface org_kde_kwin_server_decoration_interface;
</VARIABLE>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_ENUM</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_ENUM
</MACRO>
<ENUM>
<NAME>org_kde_kwin_server_decoration_manager_mode</NAME>
enum org_kde_kwin_server_decoration_manager_mode {
	/**
	 * Undecorated: The surface is not decorated at all, neither server nor client-side. An example is a popup surface which should not be decorated.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_NONE = 0,
	/**
	 * Client-side decoration: The decoration is part of the surface and the client.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_CLIENT = 1,
	/**
	 * Server-side decoration: The server embeds the surface into a decoration frame.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_SERVER = 2,
};
</ENUM>
<STRUCT>
<NAME>org_kde_kwin_server_decoration_manager_listener</NAME>
struct org_kde_kwin_server_decoration_manager_listener {
	/**
	 * The default mode used on the server
	 *
	 * This event is emitted directly after binding the interface. It
	 * contains the default mode for the decoration. When a new server
	 * decoration object is created this new object will be in the
	 * default mode until the first request_mode is requested.
	 *
	 * The server may change the default mode at any time.
	 * @param mode The default decoration mode applied to newly created server decorations.
	 */
	void (*default_mode)(void *data,
			     struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager,
			     uint32_t mode);
};
</STRUCT>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_add_listener</NAME>
<RETURNS>int</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager, const struct org_kde_kwin_server_decoration_manager_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_CREATE</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_CREATE 0
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_DEFAULT_MODE_SINCE_VERSION</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_DEFAULT_MODE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_CREATE_SINCE_VERSION</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_CREATE_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_destroy</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_create</NAME>
<RETURNS>struct org_kde_kwin_server_decoration *</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager, struct wl_surface *surface
</FUNCTION>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MODE_ENUM</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MODE_ENUM
</MACRO>
<ENUM>
<NAME>org_kde_kwin_server_decoration_mode</NAME>
enum org_kde_kwin_server_decoration_mode {
	/**
	 * Undecorated: The surface is not decorated at all, neither server nor client-side. An example is a popup surface which should not be decorated.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MODE_NONE = 0,
	/**
	 * Client-side decoration: The decoration is part of the surface and the client.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MODE_CLIENT = 1,
	/**
	 * Server-side decoration: The server embeds the surface into a decoration frame.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MODE_SERVER = 2,
};
</ENUM>
<STRUCT>
<NAME>org_kde_kwin_server_decoration_listener</NAME>
struct org_kde_kwin_server_decoration_listener {
	/**
	 * The new decoration mode applied by the server
	 *
	 * This event is emitted directly after the decoration is created
	 * and represents the base decoration policy by the server. E.g. a
	 * server which wants all surfaces to be client-side decorated will
	 * send Client, a server which wants server-side decoration will
	 * send Server.
	 *
	 * The client can request a different mode through the decoration
	 * request. The server will acknowledge this by another event with
	 * the same mode. So even if a server prefers server-side
	 * decoration it's possible to force a client-side decoration.
	 *
	 * The server may emit this event at any time. In this case the
	 * client can again request a different mode. It's the
	 * responsibility of the server to prevent a feedback loop.
	 * @param mode The decoration mode applied to the surface by the server.
	 */
	void (*mode)(void *data,
		     struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration,
		     uint32_t mode);
};
</STRUCT>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_add_listener</NAME>
<RETURNS>int</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration, const struct org_kde_kwin_server_decoration_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_RELEASE</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_RELEASE 0
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_REQUEST_MODE</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_REQUEST_MODE 1
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MODE_SINCE_VERSION</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MODE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_RELEASE_SINCE_VERSION</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_RELEASE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_REQUEST_MODE_SINCE_VERSION</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_REQUEST_MODE_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_destroy</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_release</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_request_mode</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration, uint32_t mode
</FUNCTION>
<STRUCT>
<NAME>org_kde_kwin_server_decoration</NAME>
struct org_kde_kwin_server_decoration;
</STRUCT>
<STRUCT>
<NAME>org_kde_kwin_server_decoration_manager</NAME>
struct org_kde_kwin_server_decoration_manager;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<VARIABLE>
<NAME>zwp_tablet_manager_v2_interface</NAME>
extern const struct wl_interface zwp_tablet_manager_v2_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_tablet_seat_v2_interface</NAME>
extern const struct wl_interface zwp_tablet_seat_v2_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_tablet_tool_v2_interface</NAME>
extern const struct wl_interface zwp_tablet_tool_v2_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_tablet_v2_interface</NAME>
extern const struct wl_interface zwp_tablet_v2_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_tablet_pad_ring_v2_interface</NAME>
extern const struct wl_interface zwp_tablet_pad_ring_v2_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_tablet_pad_strip_v2_interface</NAME>
extern const struct wl_interface zwp_tablet_pad_strip_v2_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_tablet_pad_group_v2_interface</NAME>
extern const struct wl_interface zwp_tablet_pad_group_v2_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_tablet_pad_v2_interface</NAME>
extern const struct wl_interface zwp_tablet_pad_v2_interface;
</VARIABLE>
<MACRO>
<NAME>ZWP_TABLET_MANAGER_V2_GET_TABLET_SEAT</NAME>
#define ZWP_TABLET_MANAGER_V2_GET_TABLET_SEAT 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_MANAGER_V2_DESTROY</NAME>
#define ZWP_TABLET_MANAGER_V2_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_MANAGER_V2_GET_TABLET_SEAT_SINCE_VERSION</NAME>
#define ZWP_TABLET_MANAGER_V2_GET_TABLET_SEAT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_MANAGER_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_MANAGER_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_manager_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_manager_v2 *zwp_tablet_manager_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_manager_v2_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_tablet_manager_v2 *zwp_tablet_manager_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_manager_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_manager_v2 *zwp_tablet_manager_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_manager_v2_get_tablet_seat</NAME>
<RETURNS>struct zwp_tablet_seat_v2 *</RETURNS>
struct zwp_tablet_manager_v2 *zwp_tablet_manager_v2, struct wl_seat *seat
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_manager_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_manager_v2 *zwp_tablet_manager_v2
</FUNCTION>
<STRUCT>
<NAME>zwp_tablet_seat_v2_listener</NAME>
struct zwp_tablet_seat_v2_listener {
	/**
	 * new device notification
	 *
	 * This event is sent whenever a new tablet becomes available on
	 * this seat. This event only provides the object id of the tablet,
	 * any static information about the tablet (device name, vid/pid,
	 * etc.) is sent through the wp_tablet interface.
	 * @param id the newly added graphics tablet
	 */
	void (*tablet_added)(void *data,
			     struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2,
			     struct zwp_tablet_v2 *id);
	/**
	 * a new tool has been used with a tablet
	 *
	 * This event is sent whenever a tool that has not previously
	 * been used with a tablet comes into use. This event only provides
	 * the object id of the tool; any static information about the tool
	 * (capabilities, type, etc.) is sent through the wp_tablet_tool
	 * interface.
	 * @param id the newly added tablet tool
	 */
	void (*tool_added)(void *data,
			   struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2,
			   struct zwp_tablet_tool_v2 *id);
	/**
	 * new pad notification
	 *
	 * This event is sent whenever a new pad is known to the system.
	 * Typically, pads are physically attached to tablets and a
	 * pad_added event is sent immediately after the
	 * wp_tablet_seat.tablet_added. However, some standalone pad
	 * devices logically attach to tablets at runtime, and the client
	 * must wait for wp_tablet_pad.enter to know the tablet a pad is
	 * attached to.
	 *
	 * This event only provides the object id of the pad. All further
	 * features (buttons, strips, rings) are sent through the
	 * wp_tablet_pad interface.
	 * @param id the newly added pad
	 */
	void (*pad_added)(void *data,
			  struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2,
			  struct zwp_tablet_pad_v2 *id);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_seat_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2, const struct zwp_tablet_seat_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_SEAT_V2_DESTROY</NAME>
#define ZWP_TABLET_SEAT_V2_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_SEAT_V2_TABLET_ADDED_SINCE_VERSION</NAME>
#define ZWP_TABLET_SEAT_V2_TABLET_ADDED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_SEAT_V2_TOOL_ADDED_SINCE_VERSION</NAME>
#define ZWP_TABLET_SEAT_V2_TOOL_ADDED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_SEAT_V2_PAD_ADDED_SINCE_VERSION</NAME>
#define ZWP_TABLET_SEAT_V2_PAD_ADDED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_SEAT_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_SEAT_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_seat_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_seat_v2_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_seat_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_seat_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_TYPE_ENUM</NAME>
#define ZWP_TABLET_TOOL_V2_TYPE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_tool_v2_type</NAME>
enum zwp_tablet_tool_v2_type {
	/**
	 * Pen
	 */
	ZWP_TABLET_TOOL_V2_TYPE_PEN = 0x140,
	/**
	 * Eraser
	 */
	ZWP_TABLET_TOOL_V2_TYPE_ERASER = 0x141,
	/**
	 * Brush
	 */
	ZWP_TABLET_TOOL_V2_TYPE_BRUSH = 0x142,
	/**
	 * Pencil
	 */
	ZWP_TABLET_TOOL_V2_TYPE_PENCIL = 0x143,
	/**
	 * Airbrush
	 */
	ZWP_TABLET_TOOL_V2_TYPE_AIRBRUSH = 0x144,
	/**
	 * Finger
	 */
	ZWP_TABLET_TOOL_V2_TYPE_FINGER = 0x145,
	/**
	 * Mouse
	 */
	ZWP_TABLET_TOOL_V2_TYPE_MOUSE = 0x146,
	/**
	 * Lens
	 */
	ZWP_TABLET_TOOL_V2_TYPE_LENS = 0x147,
};
</ENUM>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_CAPABILITY_ENUM</NAME>
#define ZWP_TABLET_TOOL_V2_CAPABILITY_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_tool_v2_capability</NAME>
enum zwp_tablet_tool_v2_capability {
	/**
	 * Tilt axes
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_TILT = 1,
	/**
	 * Pressure axis
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_PRESSURE = 2,
	/**
	 * Distance axis
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_DISTANCE = 3,
	/**
	 * Z-rotation axis
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_ROTATION = 4,
	/**
	 * Slider axis
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_SLIDER = 5,
	/**
	 * Wheel axis
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_WHEEL = 6,
};
</ENUM>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_BUTTON_STATE_ENUM</NAME>
#define ZWP_TABLET_TOOL_V2_BUTTON_STATE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_tool_v2_button_state</NAME>
enum zwp_tablet_tool_v2_button_state {
	/**
	 * button is not pressed
	 */
	ZWP_TABLET_TOOL_V2_BUTTON_STATE_RELEASED = 0,
	/**
	 * button is pressed
	 */
	ZWP_TABLET_TOOL_V2_BUTTON_STATE_PRESSED = 1,
};
</ENUM>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_ERROR_ENUM</NAME>
#define ZWP_TABLET_TOOL_V2_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_tool_v2_error</NAME>
enum zwp_tablet_tool_v2_error {
	/**
	 * given wl_surface has another role
	 */
	ZWP_TABLET_TOOL_V2_ERROR_ROLE = 0,
};
</ENUM>
<STRUCT>
<NAME>zwp_tablet_tool_v2_listener</NAME>
struct zwp_tablet_tool_v2_listener {
	/**
	 * tool type
	 *
	 * The tool type is the high-level type of the tool and usually
	 * decides the interaction expected from this tool.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_tool.done event.
	 * @param tool_type the physical tool type
	 */
	void (*type)(void *data,
		     struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		     uint32_t tool_type);
	/**
	 * unique hardware serial number of the tool
	 *
	 * If the physical tool can be identified by a unique 64-bit
	 * serial number, this event notifies the client of this serial
	 * number.
	 *
	 * If multiple tablets are available in the same seat and the tool
	 * is uniquely identifiable by the serial number, that tool may
	 * move between tablets.
	 *
	 * Otherwise, if the tool has no serial number and this event is
	 * missing, the tool is tied to the tablet it first comes into
	 * proximity with. Even if the physical tool is used on multiple
	 * tablets, separate wp_tablet_tool objects will be created, one
	 * per tablet.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_tool.done event.
	 * @param hardware_serial_hi the unique serial number of the tool, most significant bits
	 * @param hardware_serial_lo the unique serial number of the tool, least significant bits
	 */
	void (*hardware_serial)(void *data,
				struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
				uint32_t hardware_serial_hi,
				uint32_t hardware_serial_lo);
	/**
	 * hardware id notification in Wacom's format
	 *
	 * This event notifies the client of a hardware id available on
	 * this tool.
	 *
	 * The hardware id is a device-specific 64-bit id that provides
	 * extra information about the tool in use, beyond the wl_tool.type
	 * enumeration. The format of the id is specific to tablets made by
	 * Wacom Inc. For example, the hardware id of a Wacom Grip Pen (a
	 * stylus) is 0x802.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_tool.done event.
	 * @param hardware_id_hi the hardware id, most significant bits
	 * @param hardware_id_lo the hardware id, least significant bits
	 */
	void (*hardware_id_wacom)(void *data,
				  struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
				  uint32_t hardware_id_hi,
				  uint32_t hardware_id_lo);
	/**
	 * tool capability notification
	 *
	 * This event notifies the client of any capabilities of this
	 * tool, beyond the main set of x/y axes and tip up/down detection.
	 *
	 * One event is sent for each extra capability available on this
	 * tool.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_tool.done event.
	 * @param capability the capability
	 */
	void (*capability)(void *data,
			   struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
			   uint32_t capability);
	/**
	 * tool description events sequence complete
	 *
	 * This event signals the end of the initial burst of descriptive
	 * events. A client may consider the static description of the tool
	 * to be complete and finalize initialization of the tool.
	 */
	void (*done)(void *data,
		     struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2);
	/**
	 * tool removed
	 *
	 * This event is sent when the tool is removed from the system
	 * and will send no further events. Should the physical tool come
	 * back into proximity later, a new wp_tablet_tool object will be
	 * created.
	 *
	 * It is compositor-dependent when a tool is removed. A compositor
	 * may remove a tool on proximity out, tablet removal or any other
	 * reason. A compositor may also keep a tool alive until shutdown.
	 *
	 * If the tool is currently in proximity, a proximity_out event
	 * will be sent before the removed event. See
	 * wp_tablet_tool.proximity_out for the handling of any buttons
	 * logically down.
	 *
	 * When this event is received, the client must
	 * wp_tablet_tool.destroy the object.
	 */
	void (*removed)(void *data,
			struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2);
	/**
	 * proximity in event
	 *
	 * Notification that this tool is focused on a certain surface.
	 *
	 * This event can be received when the tool has moved from one
	 * surface to another, or when the tool has come back into
	 * proximity above the surface.
	 *
	 * If any button is logically down when the tool comes into
	 * proximity, the respective button event is sent after the
	 * proximity_in event but within the same frame as the proximity_in
	 * event.
	 * @param tablet The tablet the tool is in proximity of
	 * @param surface The current surface the tablet tool is over
	 */
	void (*proximity_in)(void *data,
			     struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
			     uint32_t serial,
			     struct zwp_tablet_v2 *tablet,
			     struct wl_surface *surface);
	/**
	 * proximity out event
	 *
	 * Notification that this tool has either left proximity, or is
	 * no longer focused on a certain surface.
	 *
	 * When the tablet tool leaves proximity of the tablet, button
	 * release events are sent for each button that was held down at
	 * the time of leaving proximity. These events are sent before the
	 * proximity_out event but within the same wp_tablet.frame.
	 *
	 * If the tool stays within proximity of the tablet, but the focus
	 * changes from one surface to another, a button release event may
	 * not be sent until the button is actually released or the tool
	 * leaves the proximity of the tablet.
	 */
	void (*proximity_out)(void *data,
			      struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2);
	/**
	 * tablet tool is making contact
	 *
	 * Sent whenever the tablet tool comes in contact with the
	 * surface of the tablet.
	 *
	 * If the tool is already in contact with the tablet when entering
	 * the input region, the client owning said region will receive a
	 * wp_tablet.proximity_in event, followed by a wp_tablet.down event
	 * and a wp_tablet.frame event.
	 *
	 * Note that this event describes logical contact, not physical
	 * contact. On some devices, a compositor may not consider a tool
	 * in logical contact until a minimum physical pressure threshold
	 * is exceeded.
	 */
	void (*down)(void *data,
		     struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		     uint32_t serial);
	/**
	 * tablet tool is no longer making contact
	 *
	 * Sent whenever the tablet tool stops making contact with the
	 * surface of the tablet, or when the tablet tool moves out of the
	 * input region and the compositor grab (if any) is dismissed.
	 *
	 * If the tablet tool moves out of the input region while in
	 * contact with the surface of the tablet and the compositor does
	 * not have an ongoing grab on the surface, the client owning said
	 * region will receive a wp_tablet.up event, followed by a
	 * wp_tablet.proximity_out event and a wp_tablet.frame event. If
	 * the compositor has an ongoing grab on this device, this event
	 * sequence is sent whenever the grab is dismissed in the future.
	 *
	 * Note that this event describes logical contact, not physical
	 * contact. On some devices, a compositor may not consider a tool
	 * out of logical contact until physical pressure falls below a
	 * specific threshold.
	 */
	void (*up)(void *data,
		   struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2);
	/**
	 * motion event
	 *
	 * Sent whenever a tablet tool moves.
	 * @param x surface-local x coordinate
	 * @param y surface-local y coordinate
	 */
	void (*motion)(void *data,
		       struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		       wl_fixed_t x,
		       wl_fixed_t y);
	/**
	 * pressure change event
	 *
	 * Sent whenever the pressure axis on a tool changes. The value
	 * of this event is normalized to a value between 0 and 65535.
	 *
	 * Note that pressure may be nonzero even when a tool is not in
	 * logical contact. See the down and up events for more details.
	 * @param pressure The current pressure value
	 */
	void (*pressure)(void *data,
			 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
			 uint32_t pressure);
	/**
	 * distance change event
	 *
	 * Sent whenever the distance axis on a tool changes. The value
	 * of this event is normalized to a value between 0 and 65535.
	 *
	 * Note that distance may be nonzero even when a tool is not in
	 * logical contact. See the down and up events for more details.
	 * @param distance The current distance value
	 */
	void (*distance)(void *data,
			 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
			 uint32_t distance);
	/**
	 * tilt change event
	 *
	 * Sent whenever one or both of the tilt axes on a tool change.
	 * Each tilt value is in degrees, relative to the z-axis of the
	 * tablet. The angle is positive when the top of a tool tilts along
	 * the positive x or y axis.
	 * @param tilt_x The current value of the X tilt axis
	 * @param tilt_y The current value of the Y tilt axis
	 */
	void (*tilt)(void *data,
		     struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		     wl_fixed_t tilt_x,
		     wl_fixed_t tilt_y);
	/**
	 * z-rotation change event
	 *
	 * Sent whenever the z-rotation axis on the tool changes. The
	 * rotation value is in degrees clockwise from the tool's logical
	 * neutral position.
	 * @param degrees The current rotation of the Z axis
	 */
	void (*rotation)(void *data,
			 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
			 wl_fixed_t degrees);
	/**
	 * Slider position change event
	 *
	 * Sent whenever the slider position on the tool changes. The
	 * value is normalized between -65535 and 65535, with 0 as the
	 * logical neutral position of the slider.
	 *
	 * The slider is available on e.g. the Wacom Airbrush tool.
	 * @param position The current position of slider
	 */
	void (*slider)(void *data,
		       struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		       int32_t position);
	/**
	 * Wheel delta event
	 *
	 * Sent whenever the wheel on the tool emits an event. This event
	 * contains two values for the same axis change. The degrees value
	 * is in the same orientation as the wl_pointer.vertical_scroll
	 * axis. The clicks value is in discrete logical clicks of the
	 * mouse wheel. This value may be zero if the movement of the wheel
	 * was less than one logical click.
	 *
	 * Clients should choose either value and avoid mixing degrees and
	 * clicks. The compositor may accumulate values smaller than a
	 * logical click and emulate click events when a certain threshold
	 * is met. Thus, wl_tablet_tool.wheel events with non-zero clicks
	 * values may have different degrees values.
	 * @param degrees The wheel delta in degrees
	 * @param clicks The wheel delta in discrete clicks
	 */
	void (*wheel)(void *data,
		      struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		      wl_fixed_t degrees,
		      int32_t clicks);
	/**
	 * button event
	 *
	 * Sent whenever a button on the tool is pressed or released.
	 *
	 * If a button is held down when the tool moves in or out of
	 * proximity, button events are generated by the compositor. See
	 * wp_tablet_tool.proximity_in and wp_tablet_tool.proximity_out for
	 * details.
	 * @param button The button whose state has changed
	 * @param state Whether the button was pressed or released
	 */
	void (*button)(void *data,
		       struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		       uint32_t serial,
		       uint32_t button,
		       uint32_t state);
	/**
	 * frame event
	 *
	 * Marks the end of a series of axis and/or button updates from
	 * the tablet. The Wayland protocol requires axis updates to be
	 * sent sequentially, however all events within a frame should be
	 * considered one hardware event.
	 * @param time The time of the event with millisecond granularity
	 */
	void (*frame)(void *data,
		      struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		      uint32_t time);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2, const struct zwp_tablet_tool_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_SET_CURSOR</NAME>
#define ZWP_TABLET_TOOL_V2_SET_CURSOR 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_DESTROY</NAME>
#define ZWP_TABLET_TOOL_V2_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_TYPE_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_TYPE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_HARDWARE_SERIAL_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_HARDWARE_SERIAL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_HARDWARE_ID_WACOM_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_HARDWARE_ID_WACOM_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_CAPABILITY_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_CAPABILITY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_DONE_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_REMOVED_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_REMOVED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_PROXIMITY_IN_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_PROXIMITY_IN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_PROXIMITY_OUT_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_PROXIMITY_OUT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_DOWN_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_DOWN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_UP_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_UP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_MOTION_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_MOTION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_PRESSURE_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_PRESSURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_DISTANCE_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_DISTANCE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_TILT_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_TILT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_ROTATION_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_ROTATION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_SLIDER_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_SLIDER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_WHEEL_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_WHEEL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_BUTTON_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_BUTTON_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_FRAME_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_FRAME_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_SET_CURSOR_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_SET_CURSOR_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_set_cursor</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2, uint32_t serial, struct wl_surface *surface, int32_t hotspot_x, int32_t hotspot_y
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2
</FUNCTION>
<STRUCT>
<NAME>zwp_tablet_v2_listener</NAME>
struct zwp_tablet_v2_listener {
	/**
	 * tablet device name
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet.done event.
	 * @param name the device name
	 */
	void (*name)(void *data,
		     struct zwp_tablet_v2 *zwp_tablet_v2,
		     const char *name);
	/**
	 * tablet device USB vendor/product id
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet.done event.
	 * @param vid USB vendor id
	 * @param pid USB product id
	 */
	void (*id)(void *data,
		   struct zwp_tablet_v2 *zwp_tablet_v2,
		   uint32_t vid,
		   uint32_t pid);
	/**
	 * path to the device
	 *
	 * A system-specific device path that indicates which device is
	 * behind this wp_tablet. This information may be used to gather
	 * additional information about the device, e.g. through libwacom.
	 *
	 * A device may have more than one device path. If so, multiple
	 * wp_tablet.path events are sent. A device may be emulated and not
	 * have a device path, and in that case this event will not be
	 * sent.
	 *
	 * The format of the path is unspecified, it may be a device node,
	 * a sysfs path, or some other identifier. It is up to the client
	 * to identify the string provided.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet.done event.
	 * @param path path to local device
	 */
	void (*path)(void *data,
		     struct zwp_tablet_v2 *zwp_tablet_v2,
		     const char *path);
	/**
	 * tablet description events sequence complete
	 *
	 * This event is sent immediately to signal the end of the
	 * initial burst of descriptive events. A client may consider the
	 * static description of the tablet to be complete and finalize
	 * initialization of the tablet.
	 */
	void (*done)(void *data,
		     struct zwp_tablet_v2 *zwp_tablet_v2);
	/**
	 * tablet removed event
	 *
	 * Sent when the tablet has been removed from the system. When a
	 * tablet is removed, some tools may be removed.
	 *
	 * When this event is received, the client must wp_tablet.destroy
	 * the object.
	 */
	void (*removed)(void *data,
			struct zwp_tablet_v2 *zwp_tablet_v2);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_v2 *zwp_tablet_v2, const struct zwp_tablet_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_V2_DESTROY</NAME>
#define ZWP_TABLET_V2_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_NAME_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_NAME_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_ID_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_ID_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_PATH_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_PATH_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_DONE_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_REMOVED_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_REMOVED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_v2 *zwp_tablet_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_v2_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_tablet_v2 *zwp_tablet_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_v2 *zwp_tablet_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_v2 *zwp_tablet_v2
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_SOURCE_ENUM</NAME>
#define ZWP_TABLET_PAD_RING_V2_SOURCE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_pad_ring_v2_source</NAME>
enum zwp_tablet_pad_ring_v2_source {
	/**
	 * finger
	 */
	ZWP_TABLET_PAD_RING_V2_SOURCE_FINGER = 1,
};
</ENUM>
<STRUCT>
<NAME>zwp_tablet_pad_ring_v2_listener</NAME>
struct zwp_tablet_pad_ring_v2_listener {
	/**
	 * ring event source
	 *
	 * Source information for ring events.
	 *
	 * This event does not occur on its own. It is sent before a
	 * wp_tablet_pad_ring.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 wp_tablet_pad_ring.source.finger, a wp_tablet_pad_ring.stop
	 * event will be sent when the user lifts the finger off the
	 * device.
	 *
	 * This event is optional. If the source is unknown for an
	 * interaction, no event is sent.
	 * @param source the event source
	 */
	void (*source)(void *data,
		       struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2,
		       uint32_t source);
	/**
	 * angle changed
	 *
	 * Sent whenever the angle on a ring changes.
	 *
	 * The angle is provided in degrees clockwise from the logical
	 * north of the ring in the pad's current rotation.
	 * @param degrees the current angle in degrees
	 */
	void (*angle)(void *data,
		      struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2,
		      wl_fixed_t degrees);
	/**
	 * interaction stopped
	 *
	 * Stop notification for ring events.
	 *
	 * For some wp_tablet_pad_ring.source types, a
	 * wp_tablet_pad_ring.stop event is sent to notify a client that
	 * the interaction with the ring has terminated. This enables the
	 * client to implement kinetic scrolling. See the
	 * wp_tablet_pad_ring.source documentation for information on when
	 * this event may be generated.
	 *
	 * Any wp_tablet_pad_ring.angle events with the same source after
	 * this event should be considered as the start of a new
	 * interaction.
	 */
	void (*stop)(void *data,
		     struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2);
	/**
	 * end of a ring event sequence
	 *
	 * Indicates the end of a set of ring events that logically
	 * belong together. A client is expected to accumulate the data in
	 * all events within the frame before proceeding.
	 *
	 * All wp_tablet_pad_ring events before a wp_tablet_pad_ring.frame
	 * event belong logically together. For example, on termination of
	 * a finger interaction on a ring the compositor will send a
	 * wp_tablet_pad_ring.source event, a wp_tablet_pad_ring.stop event
	 * and a wp_tablet_pad_ring.frame event.
	 *
	 * A wp_tablet_pad_ring.frame event is sent for every logical event
	 * group, even if the group only contains a single
	 * wp_tablet_pad_ring event. Specifically, a client may get a
	 * sequence: angle, frame, angle, frame, etc.
	 * @param time timestamp with millisecond granularity
	 */
	void (*frame)(void *data,
		      struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2,
		      uint32_t time);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2, const struct zwp_tablet_pad_ring_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_SET_FEEDBACK</NAME>
#define ZWP_TABLET_PAD_RING_V2_SET_FEEDBACK 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_DESTROY</NAME>
#define ZWP_TABLET_PAD_RING_V2_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_SOURCE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_SOURCE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_ANGLE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_ANGLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_STOP_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_STOP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_FRAME_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_FRAME_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_SET_FEEDBACK_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_SET_FEEDBACK_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_set_feedback</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2, const char *description, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_SOURCE_ENUM</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_SOURCE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_pad_strip_v2_source</NAME>
enum zwp_tablet_pad_strip_v2_source {
	/**
	 * finger
	 */
	ZWP_TABLET_PAD_STRIP_V2_SOURCE_FINGER = 1,
};
</ENUM>
<STRUCT>
<NAME>zwp_tablet_pad_strip_v2_listener</NAME>
struct zwp_tablet_pad_strip_v2_listener {
	/**
	 * strip event source
	 *
	 * Source information for strip events.
	 *
	 * This event does not occur on its own. It is sent before a
	 * wp_tablet_pad_strip.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 wp_tablet_pad_strip.source.finger, a wp_tablet_pad_strip.stop
	 * event will be sent when the user lifts their finger off the
	 * device.
	 *
	 * This event is optional. If the source is unknown for an
	 * interaction, no event is sent.
	 * @param source the event source
	 */
	void (*source)(void *data,
		       struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2,
		       uint32_t source);
	/**
	 * position changed
	 *
	 * Sent whenever the position on a strip changes.
	 *
	 * The position is normalized to a range of [0, 65535], the 0-value
	 * represents the top-most and/or left-most position of the strip
	 * in the pad's current rotation.
	 * @param position the current position
	 */
	void (*position)(void *data,
			 struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2,
			 uint32_t position);
	/**
	 * interaction stopped
	 *
	 * Stop notification for strip events.
	 *
	 * For some wp_tablet_pad_strip.source types, a
	 * wp_tablet_pad_strip.stop event is sent to notify a client that
	 * the interaction with the strip has terminated. This enables the
	 * client to implement kinetic scrolling. See the
	 * wp_tablet_pad_strip.source documentation for information on when
	 * this event may be generated.
	 *
	 * Any wp_tablet_pad_strip.position events with the same source
	 * after this event should be considered as the start of a new
	 * interaction.
	 */
	void (*stop)(void *data,
		     struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2);
	/**
	 * end of a strip event sequence
	 *
	 * Indicates the end of a set of events that represent one
	 * logical hardware strip event. A client is expected to accumulate
	 * the data in all events within the frame before proceeding.
	 *
	 * All wp_tablet_pad_strip events before a
	 * wp_tablet_pad_strip.frame event belong logically together. For
	 * example, on termination of a finger interaction on a strip the
	 * compositor will send a wp_tablet_pad_strip.source event, a
	 * wp_tablet_pad_strip.stop event and a wp_tablet_pad_strip.frame
	 * event.
	 *
	 * A wp_tablet_pad_strip.frame event is sent for every logical
	 * event group, even if the group only contains a single
	 * wp_tablet_pad_strip event. Specifically, a client may get a
	 * sequence: position, frame, position, frame, etc.
	 * @param time timestamp with millisecond granularity
	 */
	void (*frame)(void *data,
		      struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2,
		      uint32_t time);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2, const struct zwp_tablet_pad_strip_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_SET_FEEDBACK</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_SET_FEEDBACK 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_DESTROY</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_SOURCE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_SOURCE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_POSITION_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_POSITION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_STOP_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_STOP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_FRAME_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_FRAME_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_SET_FEEDBACK_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_SET_FEEDBACK_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_set_feedback</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2, const char *description, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2
</FUNCTION>
<STRUCT>
<NAME>zwp_tablet_pad_group_v2_listener</NAME>
struct zwp_tablet_pad_group_v2_listener {
	/**
	 * buttons announced
	 *
	 * Sent on wp_tablet_pad_group initialization to announce the
	 * available buttons in the group. Button indices start at 0, a
	 * button may only be in one group at a time.
	 *
	 * This event is first sent in the initial burst of events before
	 * the wp_tablet_pad_group.done event.
	 *
	 * Some buttons are reserved by the compositor. These buttons may
	 * not be assigned to any wp_tablet_pad_group. Compositors may
	 * broadcast this event in the case of changes to the mapping of
	 * these reserved buttons. If the compositor happens to reserve all
	 * buttons in a group, this event will be sent with an empty array.
	 * @param buttons buttons in this group
	 */
	void (*buttons)(void *data,
			struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
			struct wl_array *buttons);
	/**
	 * ring announced
	 *
	 * Sent on wp_tablet_pad_group initialization to announce
	 * available rings. One event is sent for each ring available on
	 * this pad group.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad_group.done event.
	 */
	void (*ring)(void *data,
		     struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
		     struct zwp_tablet_pad_ring_v2 *ring);
	/**
	 * strip announced
	 *
	 * Sent on wp_tablet_pad initialization to announce available
	 * strips. One event is sent for each strip available on this pad
	 * group.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad_group.done event.
	 */
	void (*strip)(void *data,
		      struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
		      struct zwp_tablet_pad_strip_v2 *strip);
	/**
	 * mode-switch ability announced
	 *
	 * Sent on wp_tablet_pad_group initialization to announce that
	 * the pad group may switch between modes. A client may use a mode
	 * to store a specific configuration for buttons, rings and strips
	 * and use the wl_tablet_pad_group.mode_switch event to toggle
	 * between these configurations. Mode indices start at 0.
	 *
	 * Switching modes is compositor-dependent. See the
	 * wp_tablet_pad_group.mode_switch event for more details.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad_group.done event. This event is only sent when
	 * more than more than one mode is available.
	 * @param modes the number of modes
	 */
	void (*modes)(void *data,
		      struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
		      uint32_t modes);
	/**
	 * tablet group description events sequence complete
	 *
	 * This event is sent immediately to signal the end of the
	 * initial burst of descriptive events. A client may consider the
	 * static description of the tablet to be complete and finalize
	 * initialization of the tablet group.
	 */
	void (*done)(void *data,
		     struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2);
	/**
	 * mode switch event
	 *
	 * Notification that the mode was switched.
	 *
	 * A mode applies to all buttons, rings and strips in a group
	 * simultaneously, but a client is not required to assign different
	 * actions for each mode. For example, a client may have
	 * mode-specific button mappings but map the ring to vertical
	 * scrolling in all modes. Mode indices start at 0.
	 *
	 * Switching modes is compositor-dependent. The compositor may
	 * provide visual cues to the client about the mode, e.g. by
	 * toggling LEDs on the tablet device. Mode-switching may be
	 * software-controlled or controlled by one or more physical
	 * buttons. For example, on a Wacom Intuos Pro, the button inside
	 * the ring may be assigned to switch between modes.
	 *
	 * The compositor will also send this event after
	 * wp_tablet_pad.enter on each group in order to notify of the
	 * current mode. Groups that only feature one mode will use mode=0
	 * when emitting this event.
	 *
	 * If a button action in the new mode differs from the action in
	 * the previous mode, the client should immediately issue a
	 * wp_tablet_pad.set_feedback request for each changed button.
	 *
	 * If a ring or strip action in the new mode differs from the
	 * action in the previous mode, the client should immediately issue
	 * a wp_tablet_ring.set_feedback or wp_tablet_strip.set_feedback
	 * request for each changed ring or strip.
	 * @param time the time of the event with millisecond granularity
	 * @param mode the new mode of the pad
	 */
	void (*mode_switch)(void *data,
			    struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
			    uint32_t time,
			    uint32_t serial,
			    uint32_t mode);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_pad_group_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2, const struct zwp_tablet_pad_group_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_DESTROY</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_BUTTONS_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_BUTTONS_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_RING_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_RING_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_STRIP_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_STRIP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_MODES_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_MODES_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_DONE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_MODE_SWITCH_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_MODE_SWITCH_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_pad_group_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_group_v2_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_group_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_group_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_BUTTON_STATE_ENUM</NAME>
#define ZWP_TABLET_PAD_V2_BUTTON_STATE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_pad_v2_button_state</NAME>
enum zwp_tablet_pad_v2_button_state {
	/**
	 * the button is not pressed
	 */
	ZWP_TABLET_PAD_V2_BUTTON_STATE_RELEASED = 0,
	/**
	 * the button is pressed
	 */
	ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED = 1,
};
</ENUM>
<STRUCT>
<NAME>zwp_tablet_pad_v2_listener</NAME>
struct zwp_tablet_pad_v2_listener {
	/**
	 * group announced
	 *
	 * Sent on wp_tablet_pad initialization to announce available
	 * groups. One event is sent for each pad group available.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad.done event. At least one group will be announced.
	 */
	void (*group)(void *data,
		      struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
		      struct zwp_tablet_pad_group_v2 *pad_group);
	/**
	 * path to the device
	 *
	 * A system-specific device path that indicates which device is
	 * behind this wp_tablet_pad. This information may be used to
	 * gather additional information about the device, e.g. through
	 * libwacom.
	 *
	 * The format of the path is unspecified, it may be a device node,
	 * a sysfs path, or some other identifier. It is up to the client
	 * to identify the string provided.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad.done event.
	 * @param path path to local device
	 */
	void (*path)(void *data,
		     struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
		     const char *path);
	/**
	 * buttons announced
	 *
	 * Sent on wp_tablet_pad initialization to announce the available
	 * buttons.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad.done event. This event is only sent when at least
	 * one button is available.
	 * @param buttons the number of buttons
	 */
	void (*buttons)(void *data,
			struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
			uint32_t buttons);
	/**
	 * pad description event sequence complete
	 *
	 * This event signals the end of the initial burst of descriptive
	 * events. A client may consider the static description of the pad
	 * to be complete and finalize initialization of the pad.
	 */
	void (*done)(void *data,
		     struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2);
	/**
	 * physical button state
	 *
	 * Sent whenever the physical state of a button changes.
	 * @param time the time of the event with millisecond granularity
	 * @param button the index of the button that changed state
	 */
	void (*button)(void *data,
		       struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
		       uint32_t time,
		       uint32_t button,
		       uint32_t state);
	/**
	 * enter event
	 *
	 * Notification that this pad is focused on the specified
	 * surface.
	 * @param serial serial number of the enter event
	 * @param tablet the tablet the pad is attached to
	 * @param surface surface the pad is focused on
	 */
	void (*enter)(void *data,
		      struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
		      uint32_t serial,
		      struct zwp_tablet_v2 *tablet,
		      struct wl_surface *surface);
	/**
	 * enter event
	 *
	 * Notification that this pad is no longer focused on the
	 * specified surface.
	 * @param serial serial number of the leave event
	 * @param surface surface the pad is no longer focused on
	 */
	void (*leave)(void *data,
		      struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
		      uint32_t serial,
		      struct wl_surface *surface);
	/**
	 * pad removed event
	 *
	 * Sent when the pad has been removed from the system. When a
	 * tablet is removed its pad(s) will be removed too.
	 *
	 * When this event is received, the client must destroy all rings,
	 * strips and groups that were offered by this pad, and issue
	 * wp_tablet_pad.destroy the pad itself.
	 */
	void (*removed)(void *data,
			struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2, const struct zwp_tablet_pad_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_SET_FEEDBACK</NAME>
#define ZWP_TABLET_PAD_V2_SET_FEEDBACK 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_DESTROY</NAME>
#define ZWP_TABLET_PAD_V2_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_GROUP_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_GROUP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_PATH_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_PATH_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_BUTTONS_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_BUTTONS_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_DONE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_BUTTON_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_BUTTON_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_ENTER_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_ENTER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_LEAVE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_LEAVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_REMOVED_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_REMOVED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_SET_FEEDBACK_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_SET_FEEDBACK_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_set_feedback</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2, uint32_t button, const char *description, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2
</FUNCTION>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_manager_v2</NAME>
struct zwp_tablet_manager_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_pad_group_v2</NAME>
struct zwp_tablet_pad_group_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_pad_ring_v2</NAME>
struct zwp_tablet_pad_ring_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_pad_strip_v2</NAME>
struct zwp_tablet_pad_strip_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_pad_v2</NAME>
struct zwp_tablet_pad_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_seat_v2</NAME>
struct zwp_tablet_seat_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_tool_v2</NAME>
struct zwp_tablet_tool_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_v2</NAME>
struct zwp_tablet_v2;
</STRUCT>
<VARIABLE>
<NAME>zxdg_exporter_v1_interface</NAME>
extern const struct wl_interface zxdg_exporter_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zxdg_importer_v1_interface</NAME>
extern const struct wl_interface zxdg_importer_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zxdg_exported_v1_interface</NAME>
extern const struct wl_interface zxdg_exported_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zxdg_imported_v1_interface</NAME>
extern const struct wl_interface zxdg_imported_v1_interface;
</VARIABLE>
<MACRO>
<NAME>ZXDG_EXPORTER_V1_DESTROY</NAME>
#define ZXDG_EXPORTER_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_EXPORTER_V1_EXPORT</NAME>
#define ZXDG_EXPORTER_V1_EXPORT 1
</MACRO>
<MACRO>
<NAME>ZXDG_EXPORTER_V1_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_EXPORTER_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_EXPORTER_V1_EXPORT_SINCE_VERSION</NAME>
#define ZXDG_EXPORTER_V1_EXPORT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_exporter_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_exporter_v1 *zxdg_exporter_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exporter_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_exporter_v1 *zxdg_exporter_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exporter_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_exporter_v1 *zxdg_exporter_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exporter_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_exporter_v1 *zxdg_exporter_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exporter_v1_export</NAME>
<RETURNS>struct zxdg_exported_v1 *</RETURNS>
struct zxdg_exporter_v1 *zxdg_exporter_v1, struct wl_surface *surface
</FUNCTION>
<MACRO>
<NAME>ZXDG_IMPORTER_V1_DESTROY</NAME>
#define ZXDG_IMPORTER_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTER_V1_IMPORT</NAME>
#define ZXDG_IMPORTER_V1_IMPORT 1
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTER_V1_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_IMPORTER_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTER_V1_IMPORT_SINCE_VERSION</NAME>
#define ZXDG_IMPORTER_V1_IMPORT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_importer_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_importer_v1 *zxdg_importer_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_importer_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_importer_v1 *zxdg_importer_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_importer_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_importer_v1 *zxdg_importer_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_importer_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_importer_v1 *zxdg_importer_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_importer_v1_import</NAME>
<RETURNS>struct zxdg_imported_v1 *</RETURNS>
struct zxdg_importer_v1 *zxdg_importer_v1, const char *handle
</FUNCTION>
<STRUCT>
<NAME>zxdg_exported_v1_listener</NAME>
struct zxdg_exported_v1_listener {
	/**
	 * the exported surface handle
	 *
	 * The handle event contains the unique handle of this exported
	 * surface reference. It may be shared with any client, which then
	 * can use it to import the surface by calling xdg_importer.import.
	 * A handle may be used to import the surface multiple times.
	 * @param handle the exported surface handle
	 */
	void (*handle)(void *data,
		       struct zxdg_exported_v1 *zxdg_exported_v1,
		       const char *handle);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_exported_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_exported_v1 *zxdg_exported_v1, const struct zxdg_exported_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_EXPORTED_V1_DESTROY</NAME>
#define ZXDG_EXPORTED_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_EXPORTED_V1_HANDLE_SINCE_VERSION</NAME>
#define ZXDG_EXPORTED_V1_HANDLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_EXPORTED_V1_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_EXPORTED_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_exported_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_exported_v1 *zxdg_exported_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exported_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_exported_v1 *zxdg_exported_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exported_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_exported_v1 *zxdg_exported_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exported_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_exported_v1 *zxdg_exported_v1
</FUNCTION>
<STRUCT>
<NAME>zxdg_imported_v1_listener</NAME>
struct zxdg_imported_v1_listener {
	/**
	 * the imported surface handle has been destroyed
	 *
	 * The imported surface handle has been destroyed and any
	 * relationship set up has been invalidated. This may happen for
	 * various reasons, for example if the exported surface or the
	 * exported surface handle has been destroyed, if the handle used
	 * for importing was invalid.
	 */
	void (*destroyed)(void *data,
			  struct zxdg_imported_v1 *zxdg_imported_v1);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_imported_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1, const struct zxdg_imported_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_IMPORTED_V1_DESTROY</NAME>
#define ZXDG_IMPORTED_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTED_V1_SET_PARENT_OF</NAME>
#define ZXDG_IMPORTED_V1_SET_PARENT_OF 1
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTED_V1_DESTROYED_SINCE_VERSION</NAME>
#define ZXDG_IMPORTED_V1_DESTROYED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTED_V1_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_IMPORTED_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTED_V1_SET_PARENT_OF_SINCE_VERSION</NAME>
#define ZXDG_IMPORTED_V1_SET_PARENT_OF_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_imported_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_imported_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_imported_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_imported_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_imported_v1_set_parent_of</NAME>
<RETURNS>void</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1, struct wl_surface *surface
</FUNCTION>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zxdg_exported_v1</NAME>
struct zxdg_exported_v1;
</STRUCT>
<STRUCT>
<NAME>zxdg_exporter_v1</NAME>
struct zxdg_exporter_v1;
</STRUCT>
<STRUCT>
<NAME>zxdg_imported_v1</NAME>
struct zxdg_imported_v1;
</STRUCT>
<STRUCT>
<NAME>zxdg_importer_v1</NAME>
struct zxdg_importer_v1;
</STRUCT>
<VARIABLE>
<NAME>zxdg_output_manager_v1_interface</NAME>
extern const struct wl_interface zxdg_output_manager_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zxdg_output_v1_interface</NAME>
extern const struct wl_interface zxdg_output_v1_interface;
</VARIABLE>
<MACRO>
<NAME>ZXDG_OUTPUT_MANAGER_V1_DESTROY</NAME>
#define ZXDG_OUTPUT_MANAGER_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_OUTPUT_MANAGER_V1_GET_XDG_OUTPUT</NAME>
#define ZXDG_OUTPUT_MANAGER_V1_GET_XDG_OUTPUT 1
</MACRO>
<MACRO>
<NAME>ZXDG_OUTPUT_MANAGER_V1_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_OUTPUT_MANAGER_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_OUTPUT_MANAGER_V1_GET_XDG_OUTPUT_SINCE_VERSION</NAME>
#define ZXDG_OUTPUT_MANAGER_V1_GET_XDG_OUTPUT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_output_manager_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_output_manager_v1 *zxdg_output_manager_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_output_manager_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_output_manager_v1 *zxdg_output_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_output_manager_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_output_manager_v1 *zxdg_output_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_output_manager_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_output_manager_v1 *zxdg_output_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_output_manager_v1_get_xdg_output</NAME>
<RETURNS>struct zxdg_output_v1 *</RETURNS>
struct zxdg_output_manager_v1 *zxdg_output_manager_v1, struct wl_output *output
</FUNCTION>
<STRUCT>
<NAME>zxdg_output_v1_listener</NAME>
struct zxdg_output_v1_listener {
	/**
	 * position of the output within the global compositor space
	 *
	 * The position event describes the location of the wl_output
	 * within the global compositor space.
	 *
	 * The logical_position event is sent after creating an xdg_output
	 * (see xdg_output_manager.get_xdg_output) and whenever the
	 * location of the output changes within the global compositor
	 * space.
	 * @param x x position within the global compositor space
	 * @param y y position within the global compositor space
	 */
	void (*logical_position)(void *data,
				 struct zxdg_output_v1 *zxdg_output_v1,
				 int32_t x,
				 int32_t y);
	/**
	 * size of the output in the global compositor space
	 *
	 * The logical_size event describes the size of the output in the
	 * global compositor space.
	 *
	 * For example, a surface without any buffer scale, transformation
	 * nor rotation set, with the size matching the logical_size will
	 * have the same size as the corresponding output when displayed.
	 *
	 * Most regular Wayland clients should not pay attention to the
	 * logical size and would rather rely on xdg_shell interfaces.
	 *
	 * Some clients such as Xwayland, however, need this to configure
	 * their surfaces in the global compositor space as the compositor
	 * may apply a different scale from what is advertised by the
	 * output scaling property (to achieve fractional scaling, for
	 * example).
	 *
	 * For example, for a wl_output mode 3840×2160 and a scale factor
	 * 2:
	 *
	 * - A compositor not scaling the surface buffers will advertise a
	 * logical size of 3840×2160,
	 *
	 * - A compositor automatically scaling the surface buffers will
	 * advertise a logical size of 1920×1080,
	 *
	 * - A compositor using a fractional scale of 1.5 will advertise a
	 * logical size to 2560×1620.
	 *
	 * For example, for a wl_output mode 1920×1080 and a 90 degree
	 * rotation, the compositor will advertise a logical size of
	 * 1080x1920.
	 *
	 * The logical_size event is sent after creating an xdg_output (see
	 * xdg_output_manager.get_xdg_output) and whenever the logical size
	 * of the output changes, either as a result of a change in the
	 * applied scale or because of a change in the corresponding output
	 * mode(see wl_output.mode) or transform (see wl_output.transform).
	 * @param width width in global compositor space
	 * @param height height in global compositor space
	 */
	void (*logical_size)(void *data,
			     struct zxdg_output_v1 *zxdg_output_v1,
			     int32_t width,
			     int32_t height);
	/**
	 * all information about the output have been sent
	 *
	 * This event is sent after all other properties of an xdg_output
	 * have been sent.
	 *
	 * This allows changes to the xdg_output properties to be seen as
	 * atomic, even if they happen via multiple events.
	 *
	 * For objects version 3 onwards, this event is deprecated.
	 * Compositors are not required to send it anymore and must send
	 * wl_output.done instead.
	 */
	void (*done)(void *data,
		     struct zxdg_output_v1 *zxdg_output_v1);
	/**
	 * name of this output
	 *
	 * Many compositors will assign names to their outputs, show them
	 * to the user, allow them to be configured by name, etc. The
	 * client may wish to know this name as well to offer the user
	 * similar behaviors.
	 *
	 * The naming convention is compositor defined, but limited to
	 * alphanumeric characters and dashes (-). Each name is unique
	 * among all wl_output globals, but if a wl_output global is
	 * destroyed the same name may be reused later. The names will also
	 * remain consistent across sessions with the same hardware and
	 * software configuration.
	 *
	 * Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc.
	 * However, do not assume that the name is a reflection of an
	 * underlying DRM connector, X11 connection, etc.
	 *
	 * The name event is sent after creating an xdg_output (see
	 * xdg_output_manager.get_xdg_output). This event is only sent once
	 * per xdg_output, and the name does not change over the lifetime
	 * of the wl_output global.
	 * @param name output name
	 * @since 2
	 */
	void (*name)(void *data,
		     struct zxdg_output_v1 *zxdg_output_v1,
		     const char *name);
	/**
	 * human-readable description of this output
	 *
	 * Many compositors can produce human-readable descriptions of
	 * their outputs. The client may wish to know this description as
	 * well, to communicate the user for various purposes.
	 *
	 * The description is a UTF-8 string with no convention defined for
	 * its contents. Examples might include 'Foocorp 11" Display' or
	 * 'Virtual X11 output via :1'.
	 *
	 * The description event is sent after creating an xdg_output (see
	 * xdg_output_manager.get_xdg_output) and whenever the description
	 * changes. The description is optional, and may not be sent at
	 * all.
	 *
	 * For objects of version 2 and lower, this event is only sent once
	 * per xdg_output, and the description does not change over the
	 * lifetime of the wl_output global.
	 * @param description output description
	 * @since 2
	 */
	void (*description)(void *data,
			    struct zxdg_output_v1 *zxdg_output_v1,
			    const char *description);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_output_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_output_v1 *zxdg_output_v1, const struct zxdg_output_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_OUTPUT_V1_DESTROY</NAME>
#define ZXDG_OUTPUT_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_OUTPUT_V1_LOGICAL_POSITION_SINCE_VERSION</NAME>
#define ZXDG_OUTPUT_V1_LOGICAL_POSITION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_OUTPUT_V1_LOGICAL_SIZE_SINCE_VERSION</NAME>
#define ZXDG_OUTPUT_V1_LOGICAL_SIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_OUTPUT_V1_DONE_SINCE_VERSION</NAME>
#define ZXDG_OUTPUT_V1_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_OUTPUT_V1_NAME_SINCE_VERSION</NAME>
#define ZXDG_OUTPUT_V1_NAME_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>ZXDG_OUTPUT_V1_DESCRIPTION_SINCE_VERSION</NAME>
#define ZXDG_OUTPUT_V1_DESCRIPTION_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>ZXDG_OUTPUT_V1_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_OUTPUT_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_output_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_output_v1 *zxdg_output_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_output_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_output_v1 *zxdg_output_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_output_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_output_v1 *zxdg_output_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_output_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_output_v1 *zxdg_output_v1
</FUNCTION>
<STRUCT>
<NAME>wl_output</NAME>
struct wl_output;
</STRUCT>
<STRUCT>
<NAME>zxdg_output_manager_v1</NAME>
struct zxdg_output_manager_v1;
</STRUCT>
<STRUCT>
<NAME>zxdg_output_v1</NAME>
struct zxdg_output_v1;
</STRUCT>
<VARIABLE>
<NAME>xdg_wm_base_interface</NAME>
extern const struct wl_interface xdg_wm_base_interface;
</VARIABLE>
<VARIABLE>
<NAME>xdg_positioner_interface</NAME>
extern const struct wl_interface xdg_positioner_interface;
</VARIABLE>
<VARIABLE>
<NAME>xdg_surface_interface</NAME>
extern const struct wl_interface xdg_surface_interface;
</VARIABLE>
<VARIABLE>
<NAME>xdg_toplevel_interface</NAME>
extern const struct wl_interface xdg_toplevel_interface;
</VARIABLE>
<VARIABLE>
<NAME>xdg_popup_interface</NAME>
extern const struct wl_interface xdg_popup_interface;
</VARIABLE>
<MACRO>
<NAME>XDG_WM_BASE_ERROR_ENUM</NAME>
#define XDG_WM_BASE_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>xdg_wm_base_error</NAME>
enum xdg_wm_base_error {
	/**
	 * given wl_surface has another role
	 */
	XDG_WM_BASE_ERROR_ROLE = 0,
	/**
	 * xdg_wm_base was destroyed before children
	 */
	XDG_WM_BASE_ERROR_DEFUNCT_SURFACES = 1,
	/**
	 * the client tried to map or destroy a non-topmost popup
	 */
	XDG_WM_BASE_ERROR_NOT_THE_TOPMOST_POPUP = 2,
	/**
	 * the client specified an invalid popup parent surface
	 */
	XDG_WM_BASE_ERROR_INVALID_POPUP_PARENT = 3,
	/**
	 * the client provided an invalid surface state
	 */
	XDG_WM_BASE_ERROR_INVALID_SURFACE_STATE = 4,
	/**
	 * the client provided an invalid positioner
	 */
	XDG_WM_BASE_ERROR_INVALID_POSITIONER = 5,
};
</ENUM>
<STRUCT>
<NAME>xdg_wm_base_listener</NAME>
struct xdg_wm_base_listener {
	/**
	 * check if the client is alive
	 *
	 * The ping event asks the client if it's still alive. Pass the
	 * serial specified in the event back to the compositor by sending
	 * a "pong" request back with the specified serial. See
	 * xdg_wm_base.pong.
	 *
	 * Compositors can use this to determine if the client is still
	 * alive. It's unspecified what will happen if the client doesn't
	 * respond to the ping request, or in what timeframe. Clients
	 * should try to respond in a reasonable amount of time.
	 *
	 * A compositor is free to ping in any way it wants, but a client
	 * must always respond to any xdg_wm_base object it created.
	 * @param serial pass this to the pong request
	 */
	void (*ping)(void *data,
		     struct xdg_wm_base *xdg_wm_base,
		     uint32_t serial);
};
</STRUCT>
<FUNCTION>
<NAME>xdg_wm_base_add_listener</NAME>
<RETURNS>int</RETURNS>
struct xdg_wm_base *xdg_wm_base, const struct xdg_wm_base_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>XDG_WM_BASE_DESTROY</NAME>
#define XDG_WM_BASE_DESTROY 0
</MACRO>
<MACRO>
<NAME>XDG_WM_BASE_CREATE_POSITIONER</NAME>
#define XDG_WM_BASE_CREATE_POSITIONER 1
</MACRO>
<MACRO>
<NAME>XDG_WM_BASE_GET_XDG_SURFACE</NAME>
#define XDG_WM_BASE_GET_XDG_SURFACE 2
</MACRO>
<MACRO>
<NAME>XDG_WM_BASE_PONG</NAME>
#define XDG_WM_BASE_PONG 3
</MACRO>
<MACRO>
<NAME>XDG_WM_BASE_PING_SINCE_VERSION</NAME>
#define XDG_WM_BASE_PING_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_WM_BASE_DESTROY_SINCE_VERSION</NAME>
#define XDG_WM_BASE_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_WM_BASE_CREATE_POSITIONER_SINCE_VERSION</NAME>
#define XDG_WM_BASE_CREATE_POSITIONER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_WM_BASE_GET_XDG_SURFACE_SINCE_VERSION</NAME>
#define XDG_WM_BASE_GET_XDG_SURFACE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_WM_BASE_PONG_SINCE_VERSION</NAME>
#define XDG_WM_BASE_PONG_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>xdg_wm_base_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct xdg_wm_base *xdg_wm_base, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>xdg_wm_base_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct xdg_wm_base *xdg_wm_base
</FUNCTION>
<FUNCTION>
<NAME>xdg_wm_base_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct xdg_wm_base *xdg_wm_base
</FUNCTION>
<FUNCTION>
<NAME>xdg_wm_base_destroy</NAME>
<RETURNS>void</RETURNS>
struct xdg_wm_base *xdg_wm_base
</FUNCTION>
<FUNCTION>
<NAME>xdg_wm_base_create_positioner</NAME>
<RETURNS>struct xdg_positioner *</RETURNS>
struct xdg_wm_base *xdg_wm_base
</FUNCTION>
<FUNCTION>
<NAME>xdg_wm_base_get_xdg_surface</NAME>
<RETURNS>struct xdg_surface *</RETURNS>
struct xdg_wm_base *xdg_wm_base, struct wl_surface *surface
</FUNCTION>
<FUNCTION>
<NAME>xdg_wm_base_pong</NAME>
<RETURNS>void</RETURNS>
struct xdg_wm_base *xdg_wm_base, uint32_t serial
</FUNCTION>
<MACRO>
<NAME>XDG_POSITIONER_ERROR_ENUM</NAME>
#define XDG_POSITIONER_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>xdg_positioner_error</NAME>
enum xdg_positioner_error {
	/**
	 * invalid input provided
	 */
	XDG_POSITIONER_ERROR_INVALID_INPUT = 0,
};
</ENUM>
<MACRO>
<NAME>XDG_POSITIONER_ANCHOR_ENUM</NAME>
#define XDG_POSITIONER_ANCHOR_ENUM
</MACRO>
<ENUM>
<NAME>xdg_positioner_anchor</NAME>
enum xdg_positioner_anchor {
	XDG_POSITIONER_ANCHOR_NONE = 0,
	XDG_POSITIONER_ANCHOR_TOP = 1,
	XDG_POSITIONER_ANCHOR_BOTTOM = 2,
	XDG_POSITIONER_ANCHOR_LEFT = 3,
	XDG_POSITIONER_ANCHOR_RIGHT = 4,
	XDG_POSITIONER_ANCHOR_TOP_LEFT = 5,
	XDG_POSITIONER_ANCHOR_BOTTOM_LEFT = 6,
	XDG_POSITIONER_ANCHOR_TOP_RIGHT = 7,
	XDG_POSITIONER_ANCHOR_BOTTOM_RIGHT = 8,
};
</ENUM>
<MACRO>
<NAME>XDG_POSITIONER_GRAVITY_ENUM</NAME>
#define XDG_POSITIONER_GRAVITY_ENUM
</MACRO>
<ENUM>
<NAME>xdg_positioner_gravity</NAME>
enum xdg_positioner_gravity {
	XDG_POSITIONER_GRAVITY_NONE = 0,
	XDG_POSITIONER_GRAVITY_TOP = 1,
	XDG_POSITIONER_GRAVITY_BOTTOM = 2,
	XDG_POSITIONER_GRAVITY_LEFT = 3,
	XDG_POSITIONER_GRAVITY_RIGHT = 4,
	XDG_POSITIONER_GRAVITY_TOP_LEFT = 5,
	XDG_POSITIONER_GRAVITY_BOTTOM_LEFT = 6,
	XDG_POSITIONER_GRAVITY_TOP_RIGHT = 7,
	XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT = 8,
};
</ENUM>
<MACRO>
<NAME>XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM</NAME>
#define XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM
</MACRO>
<ENUM>
<NAME>xdg_positioner_constraint_adjustment</NAME>
enum xdg_positioner_constraint_adjustment {
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_NONE = 0,
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X = 1,
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y = 2,
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X = 4,
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y = 8,
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X = 16,
	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y = 32,
};
</ENUM>
<MACRO>
<NAME>XDG_POSITIONER_DESTROY</NAME>
#define XDG_POSITIONER_DESTROY 0
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_SIZE</NAME>
#define XDG_POSITIONER_SET_SIZE 1
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_ANCHOR_RECT</NAME>
#define XDG_POSITIONER_SET_ANCHOR_RECT 2
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_ANCHOR</NAME>
#define XDG_POSITIONER_SET_ANCHOR 3
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_GRAVITY</NAME>
#define XDG_POSITIONER_SET_GRAVITY 4
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT</NAME>
#define XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT 5
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_OFFSET</NAME>
#define XDG_POSITIONER_SET_OFFSET 6
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_REACTIVE</NAME>
#define XDG_POSITIONER_SET_REACTIVE 7
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_PARENT_SIZE</NAME>
#define XDG_POSITIONER_SET_PARENT_SIZE 8
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_PARENT_CONFIGURE</NAME>
#define XDG_POSITIONER_SET_PARENT_CONFIGURE 9
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_DESTROY_SINCE_VERSION</NAME>
#define XDG_POSITIONER_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_SIZE_SINCE_VERSION</NAME>
#define XDG_POSITIONER_SET_SIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_ANCHOR_RECT_SINCE_VERSION</NAME>
#define XDG_POSITIONER_SET_ANCHOR_RECT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_ANCHOR_SINCE_VERSION</NAME>
#define XDG_POSITIONER_SET_ANCHOR_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_GRAVITY_SINCE_VERSION</NAME>
#define XDG_POSITIONER_SET_GRAVITY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION</NAME>
#define XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_OFFSET_SINCE_VERSION</NAME>
#define XDG_POSITIONER_SET_OFFSET_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_REACTIVE_SINCE_VERSION</NAME>
#define XDG_POSITIONER_SET_REACTIVE_SINCE_VERSION 3
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_PARENT_SIZE_SINCE_VERSION</NAME>
#define XDG_POSITIONER_SET_PARENT_SIZE_SINCE_VERSION 3
</MACRO>
<MACRO>
<NAME>XDG_POSITIONER_SET_PARENT_CONFIGURE_SINCE_VERSION</NAME>
#define XDG_POSITIONER_SET_PARENT_CONFIGURE_SINCE_VERSION 3
</MACRO>
<FUNCTION>
<NAME>xdg_positioner_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct xdg_positioner *xdg_positioner
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct xdg_positioner *xdg_positioner
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_destroy</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_set_size</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_set_anchor_rect</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner, int32_t x, int32_t y, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_set_anchor</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner, uint32_t anchor
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_set_gravity</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner, uint32_t gravity
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_set_constraint_adjustment</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner, uint32_t constraint_adjustment
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_set_offset</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner, int32_t x, int32_t y
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_set_reactive</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_set_parent_size</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner, int32_t parent_width, int32_t parent_height
</FUNCTION>
<FUNCTION>
<NAME>xdg_positioner_set_parent_configure</NAME>
<RETURNS>void</RETURNS>
struct xdg_positioner *xdg_positioner, uint32_t serial
</FUNCTION>
<MACRO>
<NAME>XDG_SURFACE_ERROR_ENUM</NAME>
#define XDG_SURFACE_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>xdg_surface_error</NAME>
enum xdg_surface_error {
	XDG_SURFACE_ERROR_NOT_CONSTRUCTED = 1,
	XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED = 2,
	XDG_SURFACE_ERROR_UNCONFIGURED_BUFFER = 3,
};
</ENUM>
<STRUCT>
<NAME>xdg_surface_listener</NAME>
struct xdg_surface_listener {
	/**
	 * suggest a surface change
	 *
	 * The configure event marks the end of a configure sequence. A
	 * configure sequence is a set of one or more events configuring
	 * the state of the xdg_surface, including the final
	 * xdg_surface.configure event.
	 *
	 * Where applicable, xdg_surface surface roles will during a
	 * configure sequence extend this event as a latched state sent as
	 * events before the xdg_surface.configure event. Such events
	 * should be considered to make up a set of atomically applied
	 * configuration states, where the xdg_surface.configure commits
	 * the accumulated state.
	 *
	 * Clients should arrange their surface for the new states, and
	 * then send an ack_configure request with the serial sent in this
	 * configure event at some point before committing the new surface.
	 *
	 * If the client receives multiple configure events before it can
	 * respond to one, it is free to discard all but the last event it
	 * received.
	 * @param serial serial of the configure event
	 */
	void (*configure)(void *data,
			  struct xdg_surface *xdg_surface,
			  uint32_t serial);
};
</STRUCT>
<FUNCTION>
<NAME>xdg_surface_add_listener</NAME>
<RETURNS>int</RETURNS>
struct xdg_surface *xdg_surface, const struct xdg_surface_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>XDG_SURFACE_DESTROY</NAME>
#define XDG_SURFACE_DESTROY 0
</MACRO>
<MACRO>
<NAME>XDG_SURFACE_GET_TOPLEVEL</NAME>
#define XDG_SURFACE_GET_TOPLEVEL 1
</MACRO>
<MACRO>
<NAME>XDG_SURFACE_GET_POPUP</NAME>
#define XDG_SURFACE_GET_POPUP 2
</MACRO>
<MACRO>
<NAME>XDG_SURFACE_SET_WINDOW_GEOMETRY</NAME>
#define XDG_SURFACE_SET_WINDOW_GEOMETRY 3
</MACRO>
<MACRO>
<NAME>XDG_SURFACE_ACK_CONFIGURE</NAME>
#define XDG_SURFACE_ACK_CONFIGURE 4
</MACRO>
<MACRO>
<NAME>XDG_SURFACE_CONFIGURE_SINCE_VERSION</NAME>
#define XDG_SURFACE_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_SURFACE_DESTROY_SINCE_VERSION</NAME>
#define XDG_SURFACE_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_SURFACE_GET_TOPLEVEL_SINCE_VERSION</NAME>
#define XDG_SURFACE_GET_TOPLEVEL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_SURFACE_GET_POPUP_SINCE_VERSION</NAME>
#define XDG_SURFACE_GET_POPUP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_SURFACE_SET_WINDOW_GEOMETRY_SINCE_VERSION</NAME>
#define XDG_SURFACE_SET_WINDOW_GEOMETRY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_SURFACE_ACK_CONFIGURE_SINCE_VERSION</NAME>
#define XDG_SURFACE_ACK_CONFIGURE_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>xdg_surface_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct xdg_surface *xdg_surface, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>xdg_surface_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct xdg_surface *xdg_surface
</FUNCTION>
<FUNCTION>
<NAME>xdg_surface_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct xdg_surface *xdg_surface
</FUNCTION>
<FUNCTION>
<NAME>xdg_surface_destroy</NAME>
<RETURNS>void</RETURNS>
struct xdg_surface *xdg_surface
</FUNCTION>
<FUNCTION>
<NAME>xdg_surface_get_toplevel</NAME>
<RETURNS>struct xdg_toplevel *</RETURNS>
struct xdg_surface *xdg_surface
</FUNCTION>
<FUNCTION>
<NAME>xdg_surface_get_popup</NAME>
<RETURNS>struct xdg_popup *</RETURNS>
struct xdg_surface *xdg_surface, struct xdg_surface *parent, struct xdg_positioner *positioner
</FUNCTION>
<FUNCTION>
<NAME>xdg_surface_set_window_geometry</NAME>
<RETURNS>void</RETURNS>
struct xdg_surface *xdg_surface, int32_t x, int32_t y, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>xdg_surface_ack_configure</NAME>
<RETURNS>void</RETURNS>
struct xdg_surface *xdg_surface, uint32_t serial
</FUNCTION>
<MACRO>
<NAME>XDG_TOPLEVEL_RESIZE_EDGE_ENUM</NAME>
#define XDG_TOPLEVEL_RESIZE_EDGE_ENUM
</MACRO>
<ENUM>
<NAME>xdg_toplevel_resize_edge</NAME>
enum xdg_toplevel_resize_edge {
	XDG_TOPLEVEL_RESIZE_EDGE_NONE = 0,
	XDG_TOPLEVEL_RESIZE_EDGE_TOP = 1,
	XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM = 2,
	XDG_TOPLEVEL_RESIZE_EDGE_LEFT = 4,
	XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT = 5,
	XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT = 6,
	XDG_TOPLEVEL_RESIZE_EDGE_RIGHT = 8,
	XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT = 9,
	XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT = 10,
};
</ENUM>
<MACRO>
<NAME>XDG_TOPLEVEL_STATE_ENUM</NAME>
#define XDG_TOPLEVEL_STATE_ENUM
</MACRO>
<ENUM>
<NAME>xdg_toplevel_state</NAME>
enum xdg_toplevel_state {
	/**
	 * the surface is maximized
	 */
	XDG_TOPLEVEL_STATE_MAXIMIZED = 1,
	/**
	 * the surface is fullscreen
	 */
	XDG_TOPLEVEL_STATE_FULLSCREEN = 2,
	/**
	 * the surface is being resized
	 */
	XDG_TOPLEVEL_STATE_RESIZING = 3,
	/**
	 * the surface is now activated
	 */
	XDG_TOPLEVEL_STATE_ACTIVATED = 4,
	/**
	 * @since 2
	 */
	XDG_TOPLEVEL_STATE_TILED_LEFT = 5,
	/**
	 * @since 2
	 */
	XDG_TOPLEVEL_STATE_TILED_RIGHT = 6,
	/**
	 * @since 2
	 */
	XDG_TOPLEVEL_STATE_TILED_TOP = 7,
	/**
	 * @since 2
	 */
	XDG_TOPLEVEL_STATE_TILED_BOTTOM = 8,
};
</ENUM>
<MACRO>
<NAME>XDG_TOPLEVEL_STATE_TILED_LEFT_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_STATE_TILED_LEFT_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_STATE_TILED_TOP_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_STATE_TILED_TOP_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_STATE_TILED_BOTTOM_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_STATE_TILED_BOTTOM_SINCE_VERSION 2
</MACRO>
<STRUCT>
<NAME>xdg_toplevel_listener</NAME>
struct xdg_toplevel_listener {
	/**
	 * suggest a surface change
	 *
	 * This configure event asks the client to resize its toplevel
	 * surface or to change its state. The configured state should not
	 * be applied immediately. See xdg_surface.configure for details.
	 *
	 * The width and height arguments specify a hint to the window
	 * about how its surface should be resized in window geometry
	 * coordinates. See set_window_geometry.
	 *
	 * If the width or height arguments are zero, it means the client
	 * should decide its own window dimension. This may happen when the
	 * compositor needs to configure the state of the surface but
	 * doesn't have any information about any previous or expected
	 * dimension.
	 *
	 * The states listed in the event specify how the width/height
	 * arguments should be interpreted, and possibly how it should be
	 * drawn.
	 *
	 * Clients must send an ack_configure in response to this event.
	 * See xdg_surface.configure and xdg_surface.ack_configure for
	 * details.
	 */
	void (*configure)(void *data,
			  struct xdg_toplevel *xdg_toplevel,
			  int32_t width,
			  int32_t height,
			  struct wl_array *states);
	/**
	 * surface wants to be closed
	 *
	 * The close event is sent by the compositor when the user wants
	 * the surface to be closed. This should be equivalent to the user
	 * clicking the close button in client-side decorations, if your
	 * application has any.
	 *
	 * This is only a request that the user intends to close the
	 * window. The client may choose to ignore this request, or show a
	 * dialog to ask the user to save their data, etc.
	 */
	void (*close)(void *data,
		      struct xdg_toplevel *xdg_toplevel);
};
</STRUCT>
<FUNCTION>
<NAME>xdg_toplevel_add_listener</NAME>
<RETURNS>int</RETURNS>
struct xdg_toplevel *xdg_toplevel, const struct xdg_toplevel_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>XDG_TOPLEVEL_DESTROY</NAME>
#define XDG_TOPLEVEL_DESTROY 0
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_PARENT</NAME>
#define XDG_TOPLEVEL_SET_PARENT 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_TITLE</NAME>
#define XDG_TOPLEVEL_SET_TITLE 2
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_APP_ID</NAME>
#define XDG_TOPLEVEL_SET_APP_ID 3
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SHOW_WINDOW_MENU</NAME>
#define XDG_TOPLEVEL_SHOW_WINDOW_MENU 4
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_MOVE</NAME>
#define XDG_TOPLEVEL_MOVE 5
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_RESIZE</NAME>
#define XDG_TOPLEVEL_RESIZE 6
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_MAX_SIZE</NAME>
#define XDG_TOPLEVEL_SET_MAX_SIZE 7
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_MIN_SIZE</NAME>
#define XDG_TOPLEVEL_SET_MIN_SIZE 8
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_MAXIMIZED</NAME>
#define XDG_TOPLEVEL_SET_MAXIMIZED 9
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_UNSET_MAXIMIZED</NAME>
#define XDG_TOPLEVEL_UNSET_MAXIMIZED 10
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_FULLSCREEN</NAME>
#define XDG_TOPLEVEL_SET_FULLSCREEN 11
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_UNSET_FULLSCREEN</NAME>
#define XDG_TOPLEVEL_UNSET_FULLSCREEN 12
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_MINIMIZED</NAME>
#define XDG_TOPLEVEL_SET_MINIMIZED 13
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_CONFIGURE_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_CLOSE_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_CLOSE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_DESTROY_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_PARENT_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_SET_PARENT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_TITLE_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_SET_TITLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_APP_ID_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_SET_APP_ID_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SHOW_WINDOW_MENU_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_SHOW_WINDOW_MENU_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_MOVE_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_MOVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_RESIZE_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_RESIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_MAX_SIZE_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_SET_MAX_SIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_MIN_SIZE_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_SET_MIN_SIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_MAXIMIZED_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_SET_MAXIMIZED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_UNSET_MAXIMIZED_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_UNSET_MAXIMIZED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_FULLSCREEN_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_SET_FULLSCREEN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_UNSET_FULLSCREEN_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_UNSET_FULLSCREEN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_TOPLEVEL_SET_MINIMIZED_SINCE_VERSION</NAME>
#define XDG_TOPLEVEL_SET_MINIMIZED_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>xdg_toplevel_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct xdg_toplevel *xdg_toplevel
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct xdg_toplevel *xdg_toplevel
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_destroy</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_set_parent</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel, struct xdg_toplevel *parent
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_set_title</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel, const char *title
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_set_app_id</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel, const char *app_id
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_show_window_menu</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial, int32_t x, int32_t y
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_move</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_resize</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial, uint32_t edges
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_set_max_size</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_set_min_size</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_set_maximized</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_unset_maximized</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_set_fullscreen</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel, struct wl_output *output
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_unset_fullscreen</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel
</FUNCTION>
<FUNCTION>
<NAME>xdg_toplevel_set_minimized</NAME>
<RETURNS>void</RETURNS>
struct xdg_toplevel *xdg_toplevel
</FUNCTION>
<MACRO>
<NAME>XDG_POPUP_ERROR_ENUM</NAME>
#define XDG_POPUP_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>xdg_popup_error</NAME>
enum xdg_popup_error {
	/**
	 * tried to grab after being mapped
	 */
	XDG_POPUP_ERROR_INVALID_GRAB = 0,
};
</ENUM>
<STRUCT>
<NAME>xdg_popup_listener</NAME>
struct xdg_popup_listener {
	/**
	 * configure the popup surface
	 *
	 * This event asks the popup surface to configure itself given
	 * the configuration. The configured state should not be applied
	 * immediately. See xdg_surface.configure for details.
	 *
	 * The x and y arguments represent the position the popup was
	 * placed at given the xdg_positioner rule, relative to the upper
	 * left corner of the window geometry of the parent surface.
	 *
	 * For version 2 or older, the configure event for an xdg_popup is
	 * only ever sent once for the initial configuration. Starting with
	 * version 3, it may be sent again if the popup is setup with an
	 * xdg_positioner with set_reactive requested, or in response to
	 * xdg_popup.reposition requests.
	 * @param x x position relative to parent surface window geometry
	 * @param y y position relative to parent surface window geometry
	 * @param width window geometry width
	 * @param height window geometry height
	 */
	void (*configure)(void *data,
			  struct xdg_popup *xdg_popup,
			  int32_t x,
			  int32_t y,
			  int32_t width,
			  int32_t height);
	/**
	 * popup interaction is done
	 *
	 * The popup_done event is sent out when a popup is dismissed by
	 * the compositor. The client should destroy the xdg_popup object
	 * at this point.
	 */
	void (*popup_done)(void *data,
			   struct xdg_popup *xdg_popup);
	/**
	 * signal the completion of a repositioned request
	 *
	 * The repositioned event is sent as part of a popup
	 * configuration sequence, together with xdg_popup.configure and
	 * lastly xdg_surface.configure to notify the completion of a
	 * reposition request.
	 *
	 * The repositioned event is to notify about the completion of a
	 * xdg_popup.reposition request. The token argument is the token
	 * passed in the xdg_popup.reposition request.
	 *
	 * Immediately after this event is emitted, xdg_popup.configure and
	 * xdg_surface.configure will be sent with the updated size and
	 * position, as well as a new configure serial.
	 *
	 * The client should optionally update the content of the popup,
	 * but must acknowledge the new popup configuration for the new
	 * position to take effect. See xdg_surface.ack_configure for
	 * details.
	 * @param token reposition request token
	 * @since 3
	 */
	void (*repositioned)(void *data,
			     struct xdg_popup *xdg_popup,
			     uint32_t token);
};
</STRUCT>
<FUNCTION>
<NAME>xdg_popup_add_listener</NAME>
<RETURNS>int</RETURNS>
struct xdg_popup *xdg_popup, const struct xdg_popup_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>XDG_POPUP_DESTROY</NAME>
#define XDG_POPUP_DESTROY 0
</MACRO>
<MACRO>
<NAME>XDG_POPUP_GRAB</NAME>
#define XDG_POPUP_GRAB 1
</MACRO>
<MACRO>
<NAME>XDG_POPUP_REPOSITION</NAME>
#define XDG_POPUP_REPOSITION 2
</MACRO>
<MACRO>
<NAME>XDG_POPUP_CONFIGURE_SINCE_VERSION</NAME>
#define XDG_POPUP_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POPUP_POPUP_DONE_SINCE_VERSION</NAME>
#define XDG_POPUP_POPUP_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POPUP_REPOSITIONED_SINCE_VERSION</NAME>
#define XDG_POPUP_REPOSITIONED_SINCE_VERSION 3
</MACRO>
<MACRO>
<NAME>XDG_POPUP_DESTROY_SINCE_VERSION</NAME>
#define XDG_POPUP_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POPUP_GRAB_SINCE_VERSION</NAME>
#define XDG_POPUP_GRAB_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>XDG_POPUP_REPOSITION_SINCE_VERSION</NAME>
#define XDG_POPUP_REPOSITION_SINCE_VERSION 3
</MACRO>
<FUNCTION>
<NAME>xdg_popup_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct xdg_popup *xdg_popup, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>xdg_popup_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct xdg_popup *xdg_popup
</FUNCTION>
<FUNCTION>
<NAME>xdg_popup_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct xdg_popup *xdg_popup
</FUNCTION>
<FUNCTION>
<NAME>xdg_popup_destroy</NAME>
<RETURNS>void</RETURNS>
struct xdg_popup *xdg_popup
</FUNCTION>
<FUNCTION>
<NAME>xdg_popup_grab</NAME>
<RETURNS>void</RETURNS>
struct xdg_popup *xdg_popup, struct wl_seat *seat, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>xdg_popup_reposition</NAME>
<RETURNS>void</RETURNS>
struct xdg_popup *xdg_popup, struct xdg_positioner *positioner, uint32_t token
</FUNCTION>
<STRUCT>
<NAME>wl_output</NAME>
struct wl_output;
</STRUCT>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>xdg_popup</NAME>
struct xdg_popup;
</STRUCT>
<STRUCT>
<NAME>xdg_positioner</NAME>
struct xdg_positioner;
</STRUCT>
<STRUCT>
<NAME>xdg_surface</NAME>
struct xdg_surface;
</STRUCT>
<STRUCT>
<NAME>xdg_toplevel</NAME>
struct xdg_toplevel;
</STRUCT>
<STRUCT>
<NAME>xdg_wm_base</NAME>
struct xdg_wm_base;
</STRUCT>
<VARIABLE>
<NAME>zxdg_shell_v6_interface</NAME>
extern const struct wl_interface zxdg_shell_v6_interface;
</VARIABLE>
<VARIABLE>
<NAME>zxdg_positioner_v6_interface</NAME>
extern const struct wl_interface zxdg_positioner_v6_interface;
</VARIABLE>
<VARIABLE>
<NAME>zxdg_surface_v6_interface</NAME>
extern const struct wl_interface zxdg_surface_v6_interface;
</VARIABLE>
<VARIABLE>
<NAME>zxdg_toplevel_v6_interface</NAME>
extern const struct wl_interface zxdg_toplevel_v6_interface;
</VARIABLE>
<VARIABLE>
<NAME>zxdg_popup_v6_interface</NAME>
extern const struct wl_interface zxdg_popup_v6_interface;
</VARIABLE>
<MACRO>
<NAME>ZXDG_SHELL_V6_ERROR_ENUM</NAME>
#define ZXDG_SHELL_V6_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_shell_v6_error</NAME>
enum zxdg_shell_v6_error {
	/**
	 * given wl_surface has another role
	 */
	ZXDG_SHELL_V6_ERROR_ROLE = 0,
	/**
	 * xdg_shell was destroyed before children
	 */
	ZXDG_SHELL_V6_ERROR_DEFUNCT_SURFACES = 1,
	/**
	 * the client tried to map or destroy a non-topmost popup
	 */
	ZXDG_SHELL_V6_ERROR_NOT_THE_TOPMOST_POPUP = 2,
	/**
	 * the client specified an invalid popup parent surface
	 */
	ZXDG_SHELL_V6_ERROR_INVALID_POPUP_PARENT = 3,
	/**
	 * the client provided an invalid surface state
	 */
	ZXDG_SHELL_V6_ERROR_INVALID_SURFACE_STATE = 4,
	/**
	 * the client provided an invalid positioner
	 */
	ZXDG_SHELL_V6_ERROR_INVALID_POSITIONER = 5,
};
</ENUM>
<STRUCT>
<NAME>zxdg_shell_v6_listener</NAME>
struct zxdg_shell_v6_listener {
	/**
	 * check if the client is alive
	 *
	 * The ping event asks the client if it's still alive. Pass the
	 * serial specified in the event back to the compositor by sending
	 * a "pong" request back with the specified serial. See
	 * xdg_shell.ping.
	 *
	 * Compositors can use this to determine if the client is still
	 * alive. It's unspecified what will happen if the client doesn't
	 * respond to the ping request, or in what timeframe. Clients
	 * should try to respond in a reasonable amount of time.
	 *
	 * A compositor is free to ping in any way it wants, but a client
	 * must always respond to any xdg_shell object it created.
	 * @param serial pass this to the pong request
	 */
	void (*ping)(void *data,
		     struct zxdg_shell_v6 *zxdg_shell_v6,
		     uint32_t serial);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_shell_v6_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6, const struct zxdg_shell_v6_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_SHELL_V6_DESTROY</NAME>
#define ZXDG_SHELL_V6_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_CREATE_POSITIONER</NAME>
#define ZXDG_SHELL_V6_CREATE_POSITIONER 1
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_GET_XDG_SURFACE</NAME>
#define ZXDG_SHELL_V6_GET_XDG_SURFACE 2
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_PONG</NAME>
#define ZXDG_SHELL_V6_PONG 3
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_PING_SINCE_VERSION</NAME>
#define ZXDG_SHELL_V6_PING_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_SHELL_V6_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_CREATE_POSITIONER_SINCE_VERSION</NAME>
#define ZXDG_SHELL_V6_CREATE_POSITIONER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_GET_XDG_SURFACE_SINCE_VERSION</NAME>
#define ZXDG_SHELL_V6_GET_XDG_SURFACE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_PONG_SINCE_VERSION</NAME>
#define ZXDG_SHELL_V6_PONG_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_shell_v6_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_create_positioner</NAME>
<RETURNS>struct zxdg_positioner_v6 *</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_get_xdg_surface</NAME>
<RETURNS>struct zxdg_surface_v6 *</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6, struct wl_surface *surface
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_pong</NAME>
<RETURNS>void</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6, uint32_t serial
</FUNCTION>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_ERROR_ENUM</NAME>
#define ZXDG_POSITIONER_V6_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_positioner_v6_error</NAME>
enum zxdg_positioner_v6_error {
	/**
	 * invalid input provided
	 */
	ZXDG_POSITIONER_V6_ERROR_INVALID_INPUT = 0,
};
</ENUM>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_ANCHOR_ENUM</NAME>
#define ZXDG_POSITIONER_V6_ANCHOR_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_positioner_v6_anchor</NAME>
enum zxdg_positioner_v6_anchor {
	/**
	 * the center of the anchor rectangle
	 */
	ZXDG_POSITIONER_V6_ANCHOR_NONE = 0,
	/**
	 * the top edge of the anchor rectangle
	 */
	ZXDG_POSITIONER_V6_ANCHOR_TOP = 1,
	/**
	 * the bottom edge of the anchor rectangle
	 */
	ZXDG_POSITIONER_V6_ANCHOR_BOTTOM = 2,
	/**
	 * the left edge of the anchor rectangle
	 */
	ZXDG_POSITIONER_V6_ANCHOR_LEFT = 4,
	/**
	 * the right edge of the anchor rectangle
	 */
	ZXDG_POSITIONER_V6_ANCHOR_RIGHT = 8,
};
</ENUM>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_GRAVITY_ENUM</NAME>
#define ZXDG_POSITIONER_V6_GRAVITY_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_positioner_v6_gravity</NAME>
enum zxdg_positioner_v6_gravity {
	/**
	 * center over the anchor edge
	 */
	ZXDG_POSITIONER_V6_GRAVITY_NONE = 0,
	/**
	 * position above the anchor edge
	 */
	ZXDG_POSITIONER_V6_GRAVITY_TOP = 1,
	/**
	 * position below the anchor edge
	 */
	ZXDG_POSITIONER_V6_GRAVITY_BOTTOM = 2,
	/**
	 * position to the left of the anchor edge
	 */
	ZXDG_POSITIONER_V6_GRAVITY_LEFT = 4,
	/**
	 * position to the right of the anchor edge
	 */
	ZXDG_POSITIONER_V6_GRAVITY_RIGHT = 8,
};
</ENUM>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_ENUM</NAME>
#define ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_positioner_v6_constraint_adjustment</NAME>
enum zxdg_positioner_v6_constraint_adjustment {
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_NONE = 0,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_SLIDE_X = 1,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_SLIDE_Y = 2,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_FLIP_X = 4,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_FLIP_Y = 8,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_RESIZE_X = 16,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_RESIZE_Y = 32,
};
</ENUM>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_DESTROY</NAME>
#define ZXDG_POSITIONER_V6_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_SIZE</NAME>
#define ZXDG_POSITIONER_V6_SET_SIZE 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_ANCHOR_RECT</NAME>
#define ZXDG_POSITIONER_V6_SET_ANCHOR_RECT 2
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_ANCHOR</NAME>
#define ZXDG_POSITIONER_V6_SET_ANCHOR 3
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_GRAVITY</NAME>
#define ZXDG_POSITIONER_V6_SET_GRAVITY 4
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT</NAME>
#define ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT 5
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_OFFSET</NAME>
#define ZXDG_POSITIONER_V6_SET_OFFSET 6
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_SIZE_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_SIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_ANCHOR_RECT_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_ANCHOR_RECT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_ANCHOR_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_ANCHOR_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_GRAVITY_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_GRAVITY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_OFFSET_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_OFFSET_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_size</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_anchor_rect</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, int32_t x, int32_t y, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_anchor</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, uint32_t anchor
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_gravity</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, uint32_t gravity
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_constraint_adjustment</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, uint32_t constraint_adjustment
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_offset</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, int32_t x, int32_t y
</FUNCTION>
<MACRO>
<NAME>ZXDG_SURFACE_V6_ERROR_ENUM</NAME>
#define ZXDG_SURFACE_V6_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_surface_v6_error</NAME>
enum zxdg_surface_v6_error {
	ZXDG_SURFACE_V6_ERROR_NOT_CONSTRUCTED = 1,
	ZXDG_SURFACE_V6_ERROR_ALREADY_CONSTRUCTED = 2,
	ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER = 3,
};
</ENUM>
<STRUCT>
<NAME>zxdg_surface_v6_listener</NAME>
struct zxdg_surface_v6_listener {
	/**
	 * suggest a surface change
	 *
	 * The configure event marks the end of a configure sequence. A
	 * configure sequence is a set of one or more events configuring
	 * the state of the xdg_surface, including the final
	 * xdg_surface.configure event.
	 *
	 * Where applicable, xdg_surface surface roles will during a
	 * configure sequence extend this event as a latched state sent as
	 * events before the xdg_surface.configure event. Such events
	 * should be considered to make up a set of atomically applied
	 * configuration states, where the xdg_surface.configure commits
	 * the accumulated state.
	 *
	 * Clients should arrange their surface for the new states, and
	 * then send an ack_configure request with the serial sent in this
	 * configure event at some point before committing the new surface.
	 *
	 * If the client receives multiple configure events before it can
	 * respond to one, it is free to discard all but the last event it
	 * received.
	 * @param serial serial of the configure event
	 */
	void (*configure)(void *data,
			  struct zxdg_surface_v6 *zxdg_surface_v6,
			  uint32_t serial);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_surface_v6_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6, const struct zxdg_surface_v6_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_SURFACE_V6_DESTROY</NAME>
#define ZXDG_SURFACE_V6_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_GET_TOPLEVEL</NAME>
#define ZXDG_SURFACE_V6_GET_TOPLEVEL 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_GET_POPUP</NAME>
#define ZXDG_SURFACE_V6_GET_POPUP 2
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY</NAME>
#define ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY 3
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_ACK_CONFIGURE</NAME>
#define ZXDG_SURFACE_V6_ACK_CONFIGURE 4
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_CONFIGURE_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_GET_TOPLEVEL_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_GET_TOPLEVEL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_GET_POPUP_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_GET_POPUP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_ACK_CONFIGURE_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_ACK_CONFIGURE_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_surface_v6_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_get_toplevel</NAME>
<RETURNS>struct zxdg_toplevel_v6 *</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_get_popup</NAME>
<RETURNS>struct zxdg_popup_v6 *</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6, struct zxdg_surface_v6 *parent, struct zxdg_positioner_v6 *positioner
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_set_window_geometry</NAME>
<RETURNS>void</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6, int32_t x, int32_t y, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_ack_configure</NAME>
<RETURNS>void</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6, uint32_t serial
</FUNCTION>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_RESIZE_EDGE_ENUM</NAME>
#define ZXDG_TOPLEVEL_V6_RESIZE_EDGE_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_toplevel_v6_resize_edge</NAME>
enum zxdg_toplevel_v6_resize_edge {
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_NONE = 0,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP = 1,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM = 2,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_LEFT = 4,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP_LEFT = 5,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM_LEFT = 6,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_RIGHT = 8,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP_RIGHT = 9,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM_RIGHT = 10,
};
</ENUM>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_STATE_ENUM</NAME>
#define ZXDG_TOPLEVEL_V6_STATE_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_toplevel_v6_state</NAME>
enum zxdg_toplevel_v6_state {
	/**
	 * the surface is maximized
	 */
	ZXDG_TOPLEVEL_V6_STATE_MAXIMIZED = 1,
	/**
	 * the surface is fullscreen
	 */
	ZXDG_TOPLEVEL_V6_STATE_FULLSCREEN = 2,
	/**
	 * the surface is being resized
	 */
	ZXDG_TOPLEVEL_V6_STATE_RESIZING = 3,
	/**
	 * the surface is now activated
	 */
	ZXDG_TOPLEVEL_V6_STATE_ACTIVATED = 4,
};
</ENUM>
<STRUCT>
<NAME>zxdg_toplevel_v6_listener</NAME>
struct zxdg_toplevel_v6_listener {
	/**
	 * suggest a surface change
	 *
	 * This configure event asks the client to resize its toplevel
	 * surface or to change its state. The configured state should not
	 * be applied immediately. See xdg_surface.configure for details.
	 *
	 * The width and height arguments specify a hint to the window
	 * about how its surface should be resized in window geometry
	 * coordinates. See set_window_geometry.
	 *
	 * If the width or height arguments are zero, it means the client
	 * should decide its own window dimension. This may happen when the
	 * compositor needs to configure the state of the surface but
	 * doesn't have any information about any previous or expected
	 * dimension.
	 *
	 * The states listed in the event specify how the width/height
	 * arguments should be interpreted, and possibly how it should be
	 * drawn.
	 *
	 * Clients must send an ack_configure in response to this event.
	 * See xdg_surface.configure and xdg_surface.ack_configure for
	 * details.
	 */
	void (*configure)(void *data,
			  struct zxdg_toplevel_v6 *zxdg_toplevel_v6,
			  int32_t width,
			  int32_t height,
			  struct wl_array *states);
	/**
	 * surface wants to be closed
	 *
	 * The close event is sent by the compositor when the user wants
	 * the surface to be closed. This should be equivalent to the user
	 * clicking the close button in client-side decorations, if your
	 * application has any.
	 *
	 * This is only a request that the user intends to close the
	 * window. The client may choose to ignore this request, or show a
	 * dialog to ask the user to save their data, etc.
	 */
	void (*close)(void *data,
		      struct zxdg_toplevel_v6 *zxdg_toplevel_v6);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_toplevel_v6_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, const struct zxdg_toplevel_v6_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_DESTROY</NAME>
#define ZXDG_TOPLEVEL_V6_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_PARENT</NAME>
#define ZXDG_TOPLEVEL_V6_SET_PARENT 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_TITLE</NAME>
#define ZXDG_TOPLEVEL_V6_SET_TITLE 2
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_APP_ID</NAME>
#define ZXDG_TOPLEVEL_V6_SET_APP_ID 3
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU</NAME>
#define ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU 4
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_MOVE</NAME>
#define ZXDG_TOPLEVEL_V6_MOVE 5
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_RESIZE</NAME>
#define ZXDG_TOPLEVEL_V6_RESIZE 6
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MAX_SIZE</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MAX_SIZE 7
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MIN_SIZE</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MIN_SIZE 8
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MAXIMIZED</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MAXIMIZED 9
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED</NAME>
#define ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED 10
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_FULLSCREEN</NAME>
#define ZXDG_TOPLEVEL_V6_SET_FULLSCREEN 11
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN</NAME>
#define ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN 12
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MINIMIZED</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MINIMIZED 13
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_CONFIGURE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_CLOSE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_CLOSE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_PARENT_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_PARENT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_TITLE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_TITLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_APP_ID_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_APP_ID_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_MOVE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_MOVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_RESIZE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_RESIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MAX_SIZE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MAX_SIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MIN_SIZE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MIN_SIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MAXIMIZED_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MAXIMIZED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_FULLSCREEN_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_FULLSCREEN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MINIMIZED_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MINIMIZED_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_parent</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct zxdg_toplevel_v6 *parent
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_title</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, const char *title
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_app_id</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, const char *app_id
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_show_window_menu</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_seat *seat, uint32_t serial, int32_t x, int32_t y
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_move</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_seat *seat, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_resize</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_seat *seat, uint32_t serial, uint32_t edges
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_max_size</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_min_size</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_maximized</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_unset_maximized</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_fullscreen</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_output *output
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_unset_fullscreen</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_minimized</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<MACRO>
<NAME>ZXDG_POPUP_V6_ERROR_ENUM</NAME>
#define ZXDG_POPUP_V6_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_popup_v6_error</NAME>
enum zxdg_popup_v6_error {
	/**
	 * tried to grab after being mapped
	 */
	ZXDG_POPUP_V6_ERROR_INVALID_GRAB = 0,
};
</ENUM>
<STRUCT>
<NAME>zxdg_popup_v6_listener</NAME>
struct zxdg_popup_v6_listener {
	/**
	 * configure the popup surface
	 *
	 * This event asks the popup surface to configure itself given
	 * the configuration. The configured state should not be applied
	 * immediately. See xdg_surface.configure for details.
	 *
	 * The x and y arguments represent the position the popup was
	 * placed at given the xdg_positioner rule, relative to the upper
	 * left corner of the window geometry of the parent surface.
	 * @param x x position relative to parent surface window geometry
	 * @param y y position relative to parent surface window geometry
	 * @param width window geometry width
	 * @param height window geometry height
	 */
	void (*configure)(void *data,
			  struct zxdg_popup_v6 *zxdg_popup_v6,
			  int32_t x,
			  int32_t y,
			  int32_t width,
			  int32_t height);
	/**
	 * popup interaction is done
	 *
	 * The popup_done event is sent out when a popup is dismissed by
	 * the compositor. The client should destroy the xdg_popup object
	 * at this point.
	 */
	void (*popup_done)(void *data,
			   struct zxdg_popup_v6 *zxdg_popup_v6);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_popup_v6_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6, const struct zxdg_popup_v6_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_POPUP_V6_DESTROY</NAME>
#define ZXDG_POPUP_V6_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_POPUP_V6_GRAB</NAME>
#define ZXDG_POPUP_V6_GRAB 1
</MACRO>
<MACRO>
<NAME>ZXDG_POPUP_V6_CONFIGURE_SINCE_VERSION</NAME>
#define ZXDG_POPUP_V6_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POPUP_V6_POPUP_DONE_SINCE_VERSION</NAME>
#define ZXDG_POPUP_V6_POPUP_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POPUP_V6_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_POPUP_V6_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POPUP_V6_GRAB_SINCE_VERSION</NAME>
#define ZXDG_POPUP_V6_GRAB_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_popup_v6_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_popup_v6_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_popup_v6_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_popup_v6_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_popup_v6_grab</NAME>
<RETURNS>void</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6, struct wl_seat *seat, uint32_t serial
</FUNCTION>
<STRUCT>
<NAME>wl_output</NAME>
struct wl_output;
</STRUCT>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zxdg_popup_v6</NAME>
struct zxdg_popup_v6;
</STRUCT>
<STRUCT>
<NAME>zxdg_positioner_v6</NAME>
struct zxdg_positioner_v6;
</STRUCT>
<STRUCT>
<NAME>zxdg_shell_v6</NAME>
struct zxdg_shell_v6;
</STRUCT>
<STRUCT>
<NAME>zxdg_surface_v6</NAME>
struct zxdg_surface_v6;
</STRUCT>
<STRUCT>
<NAME>zxdg_toplevel_v6</NAME>
struct zxdg_toplevel_v6;
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_event_source_new</NAME>
<RETURNS>GSource *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_event_source_add_translator</NAME>
<RETURNS>void</RETURNS>
GdkEventSource  *source, GdkEventTranslator *translator
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_event_source_select_events</NAME>
<RETURNS>void</RETURNS>
GdkEventSource *source, Window          window, GdkEventMask    event_mask, unsigned int    extra_x_mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_source_xevent</NAME>
<RETURNS>gboolean</RETURNS>
GdkX11Display  *x11_display, const XEvent   *xevent
</FUNCTION>
<STRUCT>
<NAME>GdkEventSource</NAME>
</STRUCT>
<ENUM>
<NAME>GdkFilterReturn</NAME>
typedef enum {
  GDK_FILTER_CONTINUE,
  GDK_FILTER_TRANSLATE,
  GDK_FILTER_REMOVE
} GdkFilterReturn;
</ENUM>
<USER_FUNCTION>
<NAME>GdkFilterFunc</NAME>
<RETURNS>GdkFilterReturn</RETURNS>
const XEvent *xevent, GdkEvent     *event, gpointer      data
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_display_setup_window_visual</NAME>
<RETURNS>void</RETURNS>
GdkDisplay     *display, gint            depth, Visual         *visual, Colormap        colormap, gboolean        rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_window_depth</NAME>
<RETURNS>int</RETURNS>
GdkX11Display  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_window_visual</NAME>
<RETURNS>Visual *</RETURNS>
GdkX11Display  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_window_colormap</NAME>
<RETURNS>Colormap</RETURNS>
GdkX11Display  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_utf8_to_string_target</NAME>
<RETURNS>char *</RETURNS>
const char     *utf8_str, gboolean        return_latin1
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_device_xi2_get_last_axis_value</NAME>
<RETURNS>gdouble</RETURNS>
GdkX11DeviceXI2 *device, gint             n_axis
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_device_xi2_store_axes</NAME>
<RETURNS>void</RETURNS>
GdkX11DeviceXI2 *device, gdouble         *axes, gint             n_axes
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_toplevel_windows</NAME>
<RETURNS>GList *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_drag_find</NAME>
<RETURNS>GdkDrag *</RETURNS>
GdkDisplay             *display, Window                  source_xid, Window                  dest_xid
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_drag_handle_status</NAME>
<RETURNS>void</RETURNS>
GdkDisplay             *display, const XEvent           *xevent
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_drag_handle_finished</NAME>
<RETURNS>void</RETURNS>
GdkDisplay             *display, const XEvent           *xevent
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_drop_read_actions</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *drop
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_drop_filter</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface             *surface, const XEvent           *xevent
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_cache_get</NAME>
<RETURNS>GdkSurfaceCache *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_cache_filter</NAME>
<RETURNS>GdkFilterReturn</RETURNS>
const XEvent *xevent, gpointer      data
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_cache_shape_filter</NAME>
<RETURNS>GdkFilterReturn</RETURNS>
const XEvent *xevent, gpointer      data
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_update_popups</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_enter_leave_monitors</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_get_root_coords</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gint        x, gint        y, gint       *root_x, gint       *root_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_show</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean    already_mapped
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_raise</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_opacity</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, double      opacity
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_supports_edge_constraints</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *surface
</FUNCTION>
<MACRO>
<NAME>GDK_SCREEN_DISPLAY</NAME>
#define GDK_SCREEN_DISPLAY(screen)    (GDK_X11_SCREEN (screen)->display)
</MACRO>
<MACRO>
<NAME>GDK_SCREEN_XROOTWIN</NAME>
#define GDK_SCREEN_XROOTWIN(screen)   (GDK_X11_SCREEN (screen)->xroot_window)
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY_XROOTWIN</NAME>
#define GDK_DISPLAY_XROOTWIN(display) (GDK_SCREEN_XROOTWIN (GDK_X11_DISPLAY (display)->screen))
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_SCREEN</NAME>
#define GDK_SURFACE_SCREEN(win)        (GDK_X11_DISPLAY (gdk_surface_get_display (win))->screen)
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_DISPLAY</NAME>
#define GDK_SURFACE_DISPLAY(win)       (gdk_surface_get_display (win))
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_XROOTWIN</NAME>
#define GDK_SURFACE_XROOTWIN(win)      (GDK_X11_SCREEN (GDK_SURFACE_SCREEN (win))->xroot_window)
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY_XDISPLAY</NAME>
#define GDK_DISPLAY_XDISPLAY(display) (GDK_X11_DISPLAY(display)->xdisplay)
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_XDISPLAY</NAME>
#define GDK_SURFACE_XDISPLAY(win)      (GDK_X11_SCREEN (GDK_SURFACE_SCREEN (win))->xdisplay)
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_XID</NAME>
#define GDK_SURFACE_XID(win)           (GDK_X11_SURFACE (win)->xid)
</MACRO>
<MACRO>
<NAME>GDK_SCREEN_XDISPLAY</NAME>
#define GDK_SCREEN_XDISPLAY(screen)   (GDK_X11_SCREEN (screen)->xdisplay)
</MACRO>
<STRUCT>
<NAME>GdkSurfaceCache</NAME>
</STRUCT>
