<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_get_event</NAME>
<RETURNS>GdkEvent *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_peek_event</NAME>
<RETURNS>GdkEvent *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_put_event</NAME>
<RETURNS>void</RETURNS>
GdkDisplay     *display, GdkEvent       *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_has_pending</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_supports_shapes</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_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_n_monitors</NAME>
<RETURNS>int</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitor</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay *display, int         monitor_num
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitor_at_surface</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay *display, GdkSurface  *surface
</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_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, gint                dx, gint                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>GList *</RETURNS>
GdkEvent *event
</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>
<STRUCT>
<NAME>GdkPopupInterface</NAME>
struct _GdkPopupInterface
{
  GTypeInterface g_iface;

  gboolean      (* present)             (GdkPopup       *popup,
                                         int             width,
                                         int             height,
                                         GdkPopupLayout *layout);

  GdkGravity    (* get_surface_anchor)  (GdkPopup       *popup);
  GdkGravity    (* get_rect_anchor)     (GdkPopup       *popup);
  int           (* get_position_x)      (GdkPopup       *popup);
  int           (* get_position_y)      (GdkPopup       *popup);
};
</STRUCT>
<ENUM>
<NAME>GdkPopupProperties</NAME>
typedef enum
{
  GDK_POPUP_PROP_PARENT,
  GDK_POPUP_PROP_AUTOHIDE,
  GDK_POPUP_NUM_PROPERTIES
} GdkPopupProperties;
</ENUM>
<FUNCTION>
<NAME>gdk_popup_install_properties</NAME>
<RETURNS>guint</RETURNS>
GObjectClass *object_class, guint         first_prop
</FUNCTION>
<MACRO>
<NAME>GDK_PROFILER_IS_RUNNING</NAME>
#define GDK_PROFILER_IS_RUNNING G_UNLIKELY (gdk_profiler_is_running ())
</MACRO>
<FUNCTION>
<NAME>gdk_profiler_start</NAME>
<RETURNS>void</RETURNS>
int fd
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_stop</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_is_running</NAME>
<RETURNS>gboolean</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_add_mark</NAME>
<RETURNS>void</RETURNS>
gint64           start, guint64          duration, const char      *name, const char      *message
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_add_markf</NAME>
<RETURNS>void</RETURNS>
gint64           start, guint64          duration, const char      *name, const char      *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_end_mark</NAME>
<RETURNS>void</RETURNS>
gint64           start, const char      *name, const char      *message
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_end_markf</NAME>
<RETURNS>void</RETURNS>
gint64           start, const char      *name, const char      *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_define_counter</NAME>
<RETURNS>guint</RETURNS>
const char *name, const char *description
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_set_counter</NAME>
<RETURNS>void</RETURNS>
guint  id, gint64 time, double value
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_define_int_counter</NAME>
<RETURNS>guint</RETURNS>
const char *name, const char *description
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_set_int_counter</NAME>
<RETURNS>void</RETURNS>
guint  id, gint64 time, gint64 value
</FUNCTION>
<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_is_viewable</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *surface
</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_begin_resize_drag</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface, GdkSurfaceEdge  edge, GdkDevice      *device, gint            button, gint            x, gint            y, guint32         timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_begin_move_drag</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface, GdkDevice      *device, gint            button, gint            x, gint            y, guint32         timestamp
</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>
<ENUM>
<NAME>GdkSurfaceType</NAME>
typedef enum
{
  GDK_SURFACE_TOPLEVEL,
  GDK_SURFACE_TEMP,
  GDK_SURFACE_POPUP
} GdkSurfaceType;
</ENUM>
<STRUCT>
<NAME>GdkSurface</NAME>
struct _GdkSurface
{
  GObject parent_instance;

  GdkDisplay *display;

  GdkSurface *transient_for; /* for toplevels */
  GdkSurface *parent;        /* for popups */
  GList *children;           /* popups */

  gpointer widget;

  gint x;
  gint y;

  guint8 resize_count;

  GdkGLContext *gl_paint_context;

  cairo_region_t *update_area;
  guint update_freeze_count;
  gboolean pending_schedule_update;
  /* This is the update_area that was in effect when the current expose
     started. It may be smaller than the expose area if we'e painting
     more than we have to, but it represents the "true" damage. */
  cairo_region_t *active_update_area;

  GdkSurfaceState old_state;
  GdkSurfaceState state;

  guint8 alpha;
  guint8 fullscreen_mode;

  guint modal_hint : 1;

  guint destroyed : 2;

  guint support_multidevice : 1;
  guint viewable : 1; /* mapped and all parents mapped */
  guint in_update : 1;
  guint frame_clock_events_paused : 1;
  guint autohide : 1;

  struct {
    GdkGravity surface_anchor;
    GdkGravity rect_anchor;
  } popup;

  guint update_and_descendants_freeze_count;

  gint width, height;
  gint shadow_top;
  gint shadow_left;
  gint shadow_right;
  gint shadow_bottom;

  GdkCursor *cursor;
  GHashTable *device_cursor;

  cairo_region_t *input_region;

  GList *devices_inside;

  GdkFrameClock *frame_clock; /* NULL to use from parent or default */

  GSList *draw_contexts;
  GdkDrawContext *paint_context;

  cairo_region_t *opaque_region;

  guint shortcuts_inhibited : 1;
  GdkSeat *current_shortcuts_inhibited_seat;
};
</STRUCT>
<STRUCT>
<NAME>GdkSurfaceClass</NAME>
struct _GdkSurfaceClass
{
  GObjectClass parent_class;

  cairo_surface_t *
               (* ref_cairo_surface)    (GdkSurface       *surface);

  void         (* hide)                 (GdkSurface       *surface);
  void         (* get_geometry)         (GdkSurface       *surface,
                                         gint            *x,
                                         gint            *y,
                                         gint            *width,
                                         gint            *height);
  void         (* get_root_coords)      (GdkSurface       *surface,
                                         gint             x,
                                         gint             y,
                                         gint            *root_x,
                                         gint            *root_y);
  gboolean     (* get_device_state)     (GdkSurface       *surface,
                                         GdkDevice       *device,
                                         gdouble         *x,
                                         gdouble         *y,
                                         GdkModifierType *mask);

  void         (* set_input_region)     (GdkSurface      *surface,
                                         cairo_region_t  *shape_region);

  /* Called to do the windowing system specific part of gdk_surface_destroy(),
   *
   * surface: The window being destroyed
   * foreign_destroy: If TRUE, the surface or a parent was destroyed by some
   *     external agency. The surface has already been destroyed and no
   *     windowing system calls should be made. (This may never happen
   *     for some windowing systems.)
   */
  void         (* destroy)              (GdkSurface       *surface,
                                         gboolean         foreign_destroy);


  /* optional */
  gboolean     (* beep)                 (GdkSurface       *surface);

  void         (* begin_resize_drag)    (GdkSurface     *surface,
                                         GdkSurfaceEdge  edge,
                                         GdkDevice     *device,
                                         gint           button,
                                         gint           root_x,
                                         gint           root_y,
                                         guint32        timestamp);
  void         (* begin_move_drag)      (GdkSurface *surface,
                                         GdkDevice     *device,
                                         gint       button,
                                         gint       root_x,
                                         gint       root_y,
                                         guint32    timestamp);
  void         (* destroy_notify)       (GdkSurface *surface);
  GdkDrag *    (* drag_begin)           (GdkSurface        *surface,
                                         GdkDevice        *device,
                                         GdkContentProvider*content,
                                         GdkDragAction     actions,
                                         gint              dx,
                                         gint              dy);

  gint         (* get_scale_factor)       (GdkSurface      *surface);
  void         (* get_unscaled_size)      (GdkSurface      *surface,
                                           int            *unscaled_width,
                                           int            *unscaled_height);

  void         (* set_opaque_region)      (GdkSurface      *surface,
                                           cairo_region_t *region);
  void         (* set_shadow_width)       (GdkSurface      *surface,
                                           gint            left,
                                           gint            right,
                                           gint            top,
                                           gint            bottom);
  GdkGLContext *(*create_gl_context)      (GdkSurface      *surface,
                                           gboolean        attached,
                                           GdkGLContext   *share,
                                           GError        **error);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_surface_set_state</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, GdkSurfaceState  new_state
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_layout_popup_helper</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface, int             width, int             height, GdkPopupLayout *layout, GdkRectangle   *out_final_rect
</FUNCTION>
<FUNCTION>
<NAME>gdk_gravity_flip_horizontally</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkGravity anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gravity_flip_vertically</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkGravity anchor
</FUNCTION>
<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>
<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>
<STRUCT>
<NAME>GdkToplevelInterface</NAME>
struct _GdkToplevelInterface
{
  GTypeInterface g_iface;

  gboolean      (* present)             (GdkToplevel       *toplevel,
                                         int                width,
                                         int                height,
                                         GdkToplevelLayout *layout);
  gboolean      (* minimize)            (GdkToplevel       *toplevel);
  gboolean      (* lower)               (GdkToplevel       *toplevel);
  void          (* focus)               (GdkToplevel       *toplevel,
                                         guint32            timestamp);
  gboolean      (* show_window_menu)    (GdkToplevel       *toplevel,
                                         GdkEvent          *event);
  gboolean      (* supports_edge_constraints) (GdkToplevel *toplevel);
  void          (* inhibit_system_shortcuts)  (GdkToplevel *toplevel,
                                               GdkEvent    *event);
  void          (* restore_system_shortcuts)  (GdkToplevel *toplevel);
};
</STRUCT>
<ENUM>
<NAME>GdkToplevelProperties</NAME>
typedef enum
{
  GDK_TOPLEVEL_PROP_STATE,
  GDK_TOPLEVEL_PROP_TITLE,
  GDK_TOPLEVEL_PROP_STARTUP_ID,
  GDK_TOPLEVEL_PROP_TRANSIENT_FOR,
  GDK_TOPLEVEL_PROP_MODAL,
  GDK_TOPLEVEL_PROP_ICON_LIST,
  GDK_TOPLEVEL_PROP_DECORATED,
  GDK_TOPLEVEL_PROP_DELETABLE,
  GDK_TOPLEVEL_PROP_FULLSCREEN_MODE,
  GDK_TOPLEVEL_PROP_SHORTCUTS_INHIBITED,
  GDK_TOPLEVEL_NUM_PROPERTIES
} GdkToplevelProperties;
</ENUM>
<FUNCTION>
<NAME>gdk_toplevel_install_properties</NAME>
<RETURNS>guint</RETURNS>
GObjectClass *object_class, guint         first_prop
</FUNCTION>
<MACRO>
<NAME>GDK_CURRENT_TIME</NAME>
#define GDK_CURRENT_TIME     0L
</MACRO>
<MACRO>
<NAME>GDK_PARENT_RELATIVE</NAME>
#define GDK_PARENT_RELATIVE  1L
</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>GdkByteOrder</NAME>
typedef enum
{
  GDK_LSB_FIRST,
  GDK_MSB_FIRST
} GdkByteOrder;
</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>GdkEventMask</NAME>
typedef enum
{
  GDK_EXPOSURE_MASK             = 1 << 1,
  GDK_POINTER_MOTION_MASK       = 1 << 2,
  GDK_BUTTON_MOTION_MASK        = 1 << 4,
  GDK_BUTTON1_MOTION_MASK       = 1 << 5,
  GDK_BUTTON2_MOTION_MASK       = 1 << 6,
  GDK_BUTTON3_MOTION_MASK       = 1 << 7,
  GDK_BUTTON_PRESS_MASK         = 1 << 8,
  GDK_BUTTON_RELEASE_MASK       = 1 << 9,
  GDK_KEY_PRESS_MASK            = 1 << 10,
  GDK_KEY_RELEASE_MASK          = 1 << 11,
  GDK_ENTER_NOTIFY_MASK         = 1 << 12,
  GDK_LEAVE_NOTIFY_MASK         = 1 << 13,
  GDK_FOCUS_CHANGE_MASK         = 1 << 14,
  GDK_STRUCTURE_MASK            = 1 << 15,
  GDK_PROPERTY_CHANGE_MASK      = 1 << 16,
  GDK_PROXIMITY_IN_MASK         = 1 << 18,
  GDK_PROXIMITY_OUT_MASK        = 1 << 19,
  GDK_SUBSTRUCTURE_MASK         = 1 << 20,
  GDK_SCROLL_MASK               = 1 << 21,
  GDK_TOUCH_MASK                = 1 << 22,
  GDK_SMOOTH_SCROLL_MASK        = 1 << 23,
  GDK_TOUCHPAD_GESTURE_MASK     = 1 << 24,
  GDK_TABLET_PAD_MASK           = 1 << 25,
  GDK_ALL_EVENTS_MASK           = 0x3FFFFFE
} GdkEventMask;
</ENUM>
<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>GdkSurfaceTypeHint</NAME>
typedef enum
{
  GDK_SURFACE_TYPE_HINT_NORMAL,
  GDK_SURFACE_TYPE_HINT_DIALOG,
  GDK_SURFACE_TYPE_HINT_MENU,		/* Torn off menu */
  GDK_SURFACE_TYPE_HINT_TOOLBAR,
  GDK_SURFACE_TYPE_HINT_SPLASHSCREEN,
  GDK_SURFACE_TYPE_HINT_UTILITY,
  GDK_SURFACE_TYPE_HINT_DOCK,
  GDK_SURFACE_TYPE_HINT_DESKTOP,
  GDK_SURFACE_TYPE_HINT_DROPDOWN_MENU,	/* A drop down menu (from a menubar) */
  GDK_SURFACE_TYPE_HINT_POPUP_MENU,	/* A popup menu (from right-click) */
  GDK_SURFACE_TYPE_HINT_TOOLTIP,
  GDK_SURFACE_TYPE_HINT_NOTIFICATION,
  GDK_SURFACE_TYPE_HINT_COMBO,
  GDK_SURFACE_TYPE_HINT_DND
} GdkSurfaceTypeHint;
</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>GdkGeometry</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;

  GPtrArray *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_wl_output</NAME>
<RETURNS>struct wl_output *</RETURNS>
GdkDisplay *display, int         monitor_num
</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>
<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_new_subsurface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay            *display, const GdkRectangle    *position
</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_xdamage;
  gint xdamage_event_base;

  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;

  /* List of functions to go from extension event => X window */
  GSList *event_types;

  /* X ID hashtable */
  GHashTable *xid_ht;

  /* streams reading selections */
  GSList *streams;

  /* input GdkSurface list */
  GList *input_surfaces;

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

  GPtrArray *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;
};
</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;

  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>
<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>
<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 intialized 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;

#if defined (HAVE_XCOMPOSITE) && defined(HAVE_XDAMAGE) && defined (HAVE_XFIXES)
  Damage damage;
#endif

  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 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>
<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>
<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 *display
</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_register_standard_event_type</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, gint        event_base, gint        n_events
</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_BYTE_ORDER</NAME>
#define GDK_TYPE_BYTE_ORDER (gdk_byte_order_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_EVENT_MASK</NAME>
#define GDK_TYPE_EVENT_MASK (gdk_event_mask_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_SURFACE_TYPE_HINT</NAME>
#define GDK_TYPE_SURFACE_TYPE_HINT (gdk_surface_type_hint_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 (3)
</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>
