<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, int                  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, double                pixbuf_x, double                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>
<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>
<FUNCTION>
<NAME>gdk_cairo_surface_paint_pixbuf</NAME>
<RETURNS>void</RETURNS>
cairo_surface_t *surface, const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_region_from_clip</NAME>
<RETURNS>cairo_region_t *</RETURNS>
cairo_t         *cr
</FUNCTION>
<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 char      *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>
<ENUM>
<NAME>GdkDebugFlags</NAME>
typedef enum {
  GDK_DEBUG_MISC            = 1 <<  0,
  GDK_DEBUG_EVENTS          = 1 <<  1,
  GDK_DEBUG_DND             = 1 <<  2,
  GDK_DEBUG_INPUT           = 1 <<  3,
  GDK_DEBUG_EVENTLOOP       = 1 <<  4,
  GDK_DEBUG_FRAMES          = 1 <<  5,
  GDK_DEBUG_SETTINGS        = 1 <<  6,
  GDK_DEBUG_OPENGL          = 1 <<  7,
  GDK_DEBUG_VULKAN          = 1 <<  8,
  GDK_DEBUG_SELECTION       = 1 <<  9,
  GDK_DEBUG_CLIPBOARD       = 1 << 10,
  /* flags below are influencing behavior */
  GDK_DEBUG_NOGRABS         = 1 << 11,
  GDK_DEBUG_GL_DISABLE      = 1 << 12,
  GDK_DEBUG_GL_SOFTWARE     = 1 << 13,
  GDK_DEBUG_GL_TEXTURE_RECT = 1 << 14,
  GDK_DEBUG_GL_LEGACY       = 1 << 15,
  GDK_DEBUG_GL_GLES         = 1 << 16,
  GDK_DEBUG_GL_DEBUG        = 1 << 17,
  GDK_DEBUG_VULKAN_DISABLE  = 1 << 18,
  GDK_DEBUG_VULKAN_VALIDATE = 1 << 19,
  GDK_DEBUG_DEFAULT_SETTINGS= 1 << 20
} GdkDebugFlags;
</ENUM>
<FUNCTION>
<NAME>gdk_display_get_debug_flags</NAME>
<RETURNS>GdkDebugFlags</RETURNS>
GdkDisplay       *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_set_debug_flags</NAME>
<RETURNS>void</RETURNS>
GdkDisplay       *display, GdkDebugFlags     flags
</FUNCTION>
<MACRO>
<NAME>GDK_DISPLAY_DEBUG_CHECK</NAME>
#define GDK_DISPLAY_DEBUG_CHECK(display,type) \
    G_UNLIKELY (gdk_display_get_debug_flags (display) & GDK_DEBUG_##type)
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY_NOTE</NAME>
#define GDK_DISPLAY_NOTE(display,type,action)          G_STMT_START {     \
    if (GDK_DISPLAY_DEBUG_CHECK (display,type))                           \
       { action; };                            } G_STMT_END
</MACRO>
<MACRO>
<NAME>GDK_DEBUG_CHECK</NAME>
#define GDK_DEBUG_CHECK(type) GDK_DISPLAY_DEBUG_CHECK (NULL,type)
</MACRO>
<MACRO>
<NAME>GDK_NOTE</NAME>
#define GDK_NOTE(type,action) GDK_DISPLAY_NOTE (NULL,type,action)
</MACRO>
<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_KEYBOARD,
  GDK_SOURCE_TOUCHSCREEN,
  GDK_SOURCE_TOUCHPAD,
  GDK_SOURCE_TRACKPOINT,
  GDK_SOURCE_TABLET_PAD
} GdkInputSource;
</ENUM>
<STRUCT>
<NAME>GdkTimeCoord</NAME>
struct _GdkTimeCoord
{
  guint32 time;
  GdkAxisFlags flags;
  double axes[GDK_AXIS_LAST];
};
</STRUCT>
<FUNCTION>
<NAME>gdk_device_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_name</NAME>
<RETURNS>const char *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_vendor_id</NAME>
<RETURNS>const char *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_product_id</NAME>
<RETURNS>const char *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_seat</NAME>
<RETURNS>GdkSeat *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_device_tool</NAME>
<RETURNS>GdkDeviceTool *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_source</NAME>
<RETURNS>GdkInputSource</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_has_cursor</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_num_touches</NAME>
<RETURNS>guint</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>
<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_surface_at_position</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDevice *device, double    *win_x, double    *win_y
</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>int</RETURNS>
GdkDevicePad *pad
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_group_n_modes</NAME>
<RETURNS>int</RETURNS>
GdkDevicePad *pad, int           group_idx
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_n_features</NAME>
<RETURNS>int</RETURNS>
GdkDevicePad        *pad, GdkDevicePadFeature  feature
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_feature_group</NAME>
<RETURNS>int</RETURNS>
GdkDevicePad        *pad, GdkDevicePadFeature  feature, int                  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>
<FUNCTION>
<NAME>gdk_device_tool_get_axes</NAME>
<RETURNS>GdkAxisFlags</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 char *display_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_name</NAME>
<RETURNS>const char *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_device_is_grabbed</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display, GdkDevice   *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_beep</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_sync</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_flush</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_close</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_closed</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_composited</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_rgba</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_supports_input_shapes</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default</NAME>
<RETURNS>GdkDisplay *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_clipboard</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_primary_clipboard</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_notify_startup_complete</NAME>
<RETURNS>void</RETURNS>
GdkDisplay    *display, const char    *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_startup_notification_id</NAME>
<RETURNS>const char *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_app_launch_context</NAME>
<RETURNS>GdkAppLaunchContext *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default_seat</NAME>
<RETURNS>GdkSeat *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_list_seats</NAME>
<RETURNS>GList *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitors</NAME>
<RETURNS>GListModel *</RETURNS>
GdkDisplay *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitor_at_surface</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay *display, GdkSurface  *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_put_event</NAME>
<RETURNS>void</RETURNS>
GdkDisplay     *display, GdkEvent       *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_map_keyval</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display, guint          keyval, GdkKeymapKey **keys, int           *n_keys
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_map_keycode</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display, guint          keycode, GdkKeymapKey **keys, guint        **keyvals, int           *n_entries
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_translate_key</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay      *display, guint            keycode, GdkModifierType  state, int              group, guint           *keyval, int             *effective_group, int             *level, GdkModifierType *consumed
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_setting</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay *display, const char *name, GValue     *value
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DISPLAY_MANAGER</NAME>
#define GDK_TYPE_DISPLAY_MANAGER              (gdk_display_manager_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY_MANAGER</NAME>
#define GDK_DISPLAY_MANAGER(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_MANAGER, GdkDisplayManager))
</MACRO>
<MACRO>
<NAME>GDK_IS_DISPLAY_MANAGER</NAME>
#define GDK_IS_DISPLAY_MANAGER(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY_MANAGER))
</MACRO>
<FUNCTION>
<NAME>gdk_display_manager_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_get</NAME>
<RETURNS>GdkDisplayManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_get_default_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDisplayManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_set_default_display</NAME>
<RETURNS>void</RETURNS>
GdkDisplayManager *manager, GdkDisplay        *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_list_displays</NAME>
<RETURNS>GSList *</RETURNS>
GdkDisplayManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_open_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDisplayManager *manager, const char        *name
</FUNCTION>
<FUNCTION>
<NAME>gdk_set_allowed_backends</NAME>
<RETURNS>void</RETURNS>
const char        *backends
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DRAG</NAME>
#define GDK_TYPE_DRAG              (gdk_drag_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DRAG</NAME>
#define GDK_DRAG(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAG, GdkDrag))
</MACRO>
<MACRO>
<NAME>GDK_IS_DRAG</NAME>
#define GDK_IS_DRAG(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAG))
</MACRO>
<ENUM>
<NAME>GdkDragCancelReason</NAME>
typedef enum {
  GDK_DRAG_CANCEL_NO_TARGET,
  GDK_DRAG_CANCEL_USER_CANCELLED,
  GDK_DRAG_CANCEL_ERROR
} GdkDragCancelReason;
</ENUM>
<FUNCTION>
<NAME>gdk_drag_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_actions</NAME>
<RETURNS>GdkDragAction</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_selected_action</NAME>
<RETURNS>GdkDragAction</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_action_is_unique</NAME>
<RETURNS>gboolean</RETURNS>
GdkDragAction   action
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_begin</NAME>
<RETURNS>GdkDrag *</RETURNS>
GdkSurface         *surface, GdkDevice          *device, GdkContentProvider *content, GdkDragAction       actions, double              dx, double              dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_drop_done</NAME>
<RETURNS>void</RETURNS>
GdkDrag  *drag, gboolean  success
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_drag_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_set_hotspot</NAME>
<RETURNS>void</RETURNS>
GdkDrag *drag, int      hot_x, int      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_seat</NAME>
<RETURNS>GdkSeat *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_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_history</NAME>
<RETURNS>GdkTimeCoord *</RETURNS>
GdkEvent *event, guint    *out_n_coords
</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_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>
<FUNCTION>
<NAME>gdk_frame_clock_get_fps</NAME>
<RETURNS>double</RETURNS>
GdkFrameClock *frame_clock
</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 char *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_R8G8B8A8_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_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, int              x_origin, int              y_origin, const int       *index_ranges, int              n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gdk_pango_layout_get_clip_region</NAME>
<RETURNS>cairo_region_t *</RETURNS>
PangoLayout     *layout, int              x_origin, int              y_origin, const int       *index_ranges, int              n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_from_surface</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
cairo_surface_t *surface, int              src_x, int              src_y, int              width, int              height
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_from_texture</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GdkTexture      *texture
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_POPUP</NAME>
#define GDK_TYPE_POPUP (gdk_popup_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_popup_present</NAME>
<RETURNS>gboolean</RETURNS>
GdkPopup       *popup, int             width, int             height, GdkPopupLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_surface_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_rect_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_parent</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_position_x</NAME>
<RETURNS>int</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_position_y</NAME>
<RETURNS>int</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_autohide</NAME>
<RETURNS>gboolean</RETURNS>
GdkPopup       *popup
</FUNCTION>
<STRUCT>
<NAME>GdkPopup</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPopupInterface</NAME>
</STRUCT>
<ENUM>
<NAME>GdkAnchorHints</NAME>
typedef enum
{
  GDK_ANCHOR_FLIP_X   = 1 << 0,
  GDK_ANCHOR_FLIP_Y   = 1 << 1,
  GDK_ANCHOR_SLIDE_X  = 1 << 2,
  GDK_ANCHOR_SLIDE_Y  = 1 << 3,
  GDK_ANCHOR_RESIZE_X = 1 << 4,
  GDK_ANCHOR_RESIZE_Y = 1 << 5,
  GDK_ANCHOR_FLIP     = GDK_ANCHOR_FLIP_X | GDK_ANCHOR_FLIP_Y,
  GDK_ANCHOR_SLIDE    = GDK_ANCHOR_SLIDE_X | GDK_ANCHOR_SLIDE_Y,
  GDK_ANCHOR_RESIZE   = GDK_ANCHOR_RESIZE_X | GDK_ANCHOR_RESIZE_Y,
} GdkAnchorHints;
</ENUM>
<MACRO>
<NAME>GDK_TYPE_POPUP_LAYOUT</NAME>
#define GDK_TYPE_POPUP_LAYOUT (gdk_popup_layout_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_popup_layout_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_new</NAME>
<RETURNS>GdkPopupLayout *</RETURNS>
const GdkRectangle     *anchor_rect, GdkGravity              rect_anchor, GdkGravity              surface_anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_ref</NAME>
<RETURNS>GdkPopupLayout *</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_unref</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_copy</NAME>
<RETURNS>GdkPopupLayout *</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_equal</NAME>
<RETURNS>gboolean</RETURNS>
GdkPopupLayout         *layout, GdkPopupLayout         *other
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_anchor_rect</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, const GdkRectangle     *anchor_rect
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_anchor_rect</NAME>
<RETURNS>const GdkRectangle *</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_rect_anchor</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, GdkGravity              anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_rect_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_surface_anchor</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, GdkGravity              anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_surface_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_anchor_hints</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, GdkAnchorHints          anchor_hints
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_anchor_hints</NAME>
<RETURNS>GdkAnchorHints</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_offset</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, int                     dx, int                     dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_offset</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, int                    *dx, int                    *dy
</FUNCTION>
<STRUCT>
<NAME>GdkPopupLayout</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_rectangle_intersect</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRectangle *src1, const GdkRectangle *src2, GdkRectangle       *dest
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_union</NAME>
<RETURNS>void</RETURNS>
const GdkRectangle *src1, const GdkRectangle *src2, GdkRectangle       *dest
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_equal</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRectangle *rect1, const GdkRectangle *rect2
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_contains_point</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRectangle *rect, int                 x, int                 y
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_RECTANGLE</NAME>
#define GDK_TYPE_RECTANGLE (gdk_rectangle_get_type ())
</MACRO>
<STRUCT>
<NAME>GdkRGBA</NAME>
struct _GdkRGBA
{
  float red;
  float green;
  float blue;
  float alpha;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_RGBA</NAME>
#define GDK_TYPE_RGBA (gdk_rgba_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_rgba_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_copy</NAME>
<RETURNS>GdkRGBA *</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_free</NAME>
<RETURNS>void</RETURNS>
GdkRGBA       *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_is_clear</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_is_opaque</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_hash</NAME>
<RETURNS>guint</RETURNS>
gconstpointer  p
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_equal</NAME>
<RETURNS>gboolean</RETURNS>
gconstpointer  p1, gconstpointer  p2
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_parse</NAME>
<RETURNS>gboolean</RETURNS>
GdkRGBA       *rgba, const char    *spec
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_to_string</NAME>
<RETURNS>char *</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_devices</NAME>
<RETURNS>GList *</RETURNS>
GdkSeat             *seat, GdkSeatCapabilities  capabilities
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_tools</NAME>
<RETURNS>GList *</RETURNS>
GdkSeat *seat
</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>
<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>
<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
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_new_popup</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkSurface    *parent, gboolean       autohide
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_destroy</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_is_destroyed</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_hide</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_input_region</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface, cairo_region_t *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_mapped</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_cursor</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_cursor</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_device_cursor</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, GdkDevice     *device, GdkCursor     *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_device_cursor</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkSurface     *surface, GdkDevice     *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_width</NAME>
<RETURNS>int</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_height</NAME>
<RETURNS>int</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_translate_coordinates</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *from, GdkSurface *to, double     *x, double     *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_scale_factor</NAME>
<RETURNS>int</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_device_position</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface      *surface, GdkDevice       *device, double          *x, double          *y, GdkModifierType *mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_similar_surface</NAME>
<RETURNS>cairo_surface_t *</RETURNS>
GdkSurface *surface, cairo_content_t  content, int              width, int              height
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_beep</NAME>
<RETURNS>void</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_queue_render</NAME>
<RETURNS>void</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, int             left, int             right, int             top, int             bottom
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_cairo_context</NAME>
<RETURNS>GdkCairoContext *</RETURNS>
GdkSurface    *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_gl_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GdkSurface     *surface, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_vulkan_context</NAME>
<RETURNS>GdkVulkanContext *</RETURNS>
GdkSurface     *surface, GError        **error
</FUNCTION>
<STRUCT>
<NAME>GdkSurfaceClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_TEXTURE</NAME>
#define GDK_TYPE_TEXTURE (gdk_texture_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TEXTURE</NAME>
#define GDK_TEXTURE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_TEXTURE, GdkTexture))
</MACRO>
<MACRO>
<NAME>GDK_IS_TEXTURE</NAME>
#define GDK_IS_TEXTURE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_TEXTURE))
</MACRO>
<FUNCTION>
<NAME>gdk_texture_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_new_for_pixbuf</NAME>
<RETURNS>GdkTexture *</RETURNS>
GdkPixbuf       *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_new_from_resource</NAME>
<RETURNS>GdkTexture *</RETURNS>
const char      *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_new_from_file</NAME>
<RETURNS>GdkTexture *</RETURNS>
GFile           *file, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_get_width</NAME>
<RETURNS>int</RETURNS>
GdkTexture      *texture
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_get_height</NAME>
<RETURNS>int</RETURNS>
GdkTexture      *texture
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_download</NAME>
<RETURNS>void</RETURNS>
GdkTexture      *texture, guchar          *data, gsize            stride
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_save_to_png</NAME>
<RETURNS>gboolean</RETURNS>
GdkTexture      *texture, const char      *filename
</FUNCTION>
<STRUCT>
<NAME>GdkTextureClass</NAME>
</STRUCT>
<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>GdkToplevelState</NAME>
typedef enum
{
  GDK_TOPLEVEL_STATE_WITHDRAWN        = 1 << 0,
  GDK_TOPLEVEL_STATE_MINIMIZED        = 1 << 1,
  GDK_TOPLEVEL_STATE_MAXIMIZED        = 1 << 2,
  GDK_TOPLEVEL_STATE_STICKY           = 1 << 3,
  GDK_TOPLEVEL_STATE_FULLSCREEN       = 1 << 4,
  GDK_TOPLEVEL_STATE_ABOVE            = 1 << 5,
  GDK_TOPLEVEL_STATE_BELOW            = 1 << 6,
  GDK_TOPLEVEL_STATE_FOCUSED          = 1 << 7,
  GDK_TOPLEVEL_STATE_TILED            = 1 << 8,
  GDK_TOPLEVEL_STATE_TOP_TILED        = 1 << 9,
  GDK_TOPLEVEL_STATE_TOP_RESIZABLE    = 1 << 10,
  GDK_TOPLEVEL_STATE_RIGHT_TILED      = 1 << 11,
  GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE  = 1 << 12,
  GDK_TOPLEVEL_STATE_BOTTOM_TILED     = 1 << 13,
  GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE = 1 << 14,
  GDK_TOPLEVEL_STATE_LEFT_TILED       = 1 << 15,
  GDK_TOPLEVEL_STATE_LEFT_RESIZABLE   = 1 << 16
} GdkToplevelState;
</ENUM>
<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, 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>GdkToplevelState</RETURNS>
GdkToplevel       *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_title</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, const char        *title
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_startup_id</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, const char        *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_transient_for</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, GdkSurface        *parent
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_modal</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, gboolean           modal
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_icon_list</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, GList             *surfaces
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_show_window_menu</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel       *toplevel, GdkEvent          *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_decorated</NAME>
<RETURNS>void</RETURNS>
GdkToplevel      *toplevel, gboolean          decorated
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_deletable</NAME>
<RETURNS>void</RETURNS>
GdkToplevel      *toplevel, gboolean          deletable
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_supports_edge_constraints</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_inhibit_system_shortcuts</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel, GdkEvent    *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_restore_system_shortcuts</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_begin_resize</NAME>
<RETURNS>void</RETURNS>
GdkToplevel    *toplevel, GdkSurfaceEdge  edge, GdkDevice      *device, int             button, double          x, double          y, guint32         timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_begin_move</NAME>
<RETURNS>void</RETURNS>
GdkToplevel    *toplevel, GdkDevice      *device, int             button, double          x, double          y, guint32         timestamp
</FUNCTION>
<STRUCT>
<NAME>GdkToplevel</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkToplevelInterface</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_TOPLEVEL_LAYOUT</NAME>
#define GDK_TYPE_TOPLEVEL_LAYOUT (gdk_toplevel_layout_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_new</NAME>
<RETURNS>GdkToplevelLayout *</RETURNS>
void
</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_maximized</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_fullscreen</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_fullscreen_monitor</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_set_resizable</NAME>
<RETURNS>void</RETURNS>
GdkToplevelLayout *layout, gboolean           resizable
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_resizable</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<STRUCT>
<NAME>GdkToplevelLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_TOPLEVEL_SIZE</NAME>
#define GDK_TYPE_TOPLEVEL_SIZE (gdk_toplevel_size_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_toplevel_size_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_size_get_bounds</NAME>
<RETURNS>void</RETURNS>
GdkToplevelSize       *size, int                   *bounds_width, int                   *bounds_height
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_size_set_size</NAME>
<RETURNS>void</RETURNS>
GdkToplevelSize       *size, int                    width, int                    height
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_size_set_min_size</NAME>
<RETURNS>void</RETURNS>
GdkToplevelSize       *size, int                    min_width, int                    min_height
</FUNCTION>
<STRUCT>
<NAME>GdkToplevelSize</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkToplevelSize</NAME>
struct _GdkToplevelSize
{
  int bounds_width;
  int bounds_height;

  int width;
  int height;
  int min_width;
  int min_height;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_toplevel_size_init</NAME>
<RETURNS>void</RETURNS>
GdkToplevelSize *size, int              bounds_width, int              bounds_height
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_size_validate</NAME>
<RETURNS>void</RETURNS>
GdkToplevelSize *size
</FUNCTION>
<MACRO>
<NAME>GDK_CURRENT_TIME</NAME>
#define GDK_CURRENT_TIME     0L
</MACRO>
<STRUCT>
<NAME>GdkPoint</NAME>
struct _GdkPoint
{
  int x;
  int y;
};
</STRUCT>
<STRUCT>
<NAME>GdkRectangle</NAME>
struct _GdkRectangle
{
    int x, y;
    int width, height;
};
</STRUCT>
<ENUM>
<NAME>GdkGravity</NAME>
typedef enum
{
  GDK_GRAVITY_NORTH_WEST = 1,
  GDK_GRAVITY_NORTH,
  GDK_GRAVITY_NORTH_EAST,
  GDK_GRAVITY_WEST,
  GDK_GRAVITY_CENTER,
  GDK_GRAVITY_EAST,
  GDK_GRAVITY_SOUTH_WEST,
  GDK_GRAVITY_SOUTH,
  GDK_GRAVITY_SOUTH_EAST,
  GDK_GRAVITY_STATIC
} GdkGravity;
</ENUM>
<ENUM>
<NAME>GdkModifierType</NAME>
typedef enum
{
  GDK_SHIFT_MASK    = 1 << 0,
  GDK_LOCK_MASK     = 1 << 1,
  GDK_CONTROL_MASK  = 1 << 2,
  GDK_ALT_MASK      = 1 << 3,

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

  GDK_SUPER_MASK    = 1 << 26,
  GDK_HYPER_MASK    = 1 << 27,
  GDK_META_MASK     = 1 << 28,
} GdkModifierType;
</ENUM>
<MACRO>
<NAME>GDK_MODIFIER_MASK</NAME>
#define GDK_MODIFIER_MASK (GDK_SHIFT_MASK|GDK_LOCK_MASK|GDK_CONTROL_MASK| \
                           GDK_ALT_MASK|GDK_SUPER_MASK|GDK_HYPER_MASK|GDK_META_MASK| \
                           GDK_BUTTON1_MASK|GDK_BUTTON2_MASK|GDK_BUTTON3_MASK| \
                           GDK_BUTTON4_MASK|GDK_BUTTON5_MASK)
</MACRO>
<ENUM>
<NAME>GdkGLError</NAME>
typedef enum {
  GDK_GL_ERROR_NOT_AVAILABLE,
  GDK_GL_ERROR_UNSUPPORTED_FORMAT,
  GDK_GL_ERROR_UNSUPPORTED_PROFILE,
  GDK_GL_ERROR_COMPILATION_FAILED,
  GDK_GL_ERROR_LINK_FAILED
} GdkGLError;
</ENUM>
<ENUM>
<NAME>GdkVulkanError</NAME>
typedef enum {
  GDK_VULKAN_ERROR_UNSUPPORTED,
  GDK_VULKAN_ERROR_NOT_AVAILABLE,
} GdkVulkanError;
</ENUM>
<ENUM>
<NAME>GdkAxisUse</NAME>
typedef enum
{
  GDK_AXIS_IGNORE,
  GDK_AXIS_X,
  GDK_AXIS_Y,
  GDK_AXIS_DELTA_X,
  GDK_AXIS_DELTA_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_DELTA_X  = 1 << GDK_AXIS_DELTA_X,
  GDK_AXIS_FLAG_DELTA_Y  = 1 << GDK_AXIS_DELTA_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;
  int   group;
  int   level;
};
</STRUCT>
<MACRO>
<NAME>GDK_EXTERN_VAR</NAME>
#        define GDK_EXTERN_VAR __declspec(dllexport)
</MACRO>
<STRUCT>
<NAME>GdkAppLaunchContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkCairoContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkClipboard</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkContentFormats</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkContentProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkCursor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDisplay</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDisplayManager</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrag</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrawContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrawingContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrop</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPoint</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkRGBA</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkRectangle</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkSeat</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkSnapshot</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkTexture</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkVulkanContext</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_VULKAN_CONTEXT</NAME>
#define GDK_TYPE_VULKAN_CONTEXT             (gdk_vulkan_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_VULKAN_CONTEXT</NAME>
#define GDK_VULKAN_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_VULKAN_CONTEXT, GdkVulkanContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_VULKAN_CONTEXT</NAME>
#define GDK_IS_VULKAN_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_VULKAN_ERROR</NAME>
#define GDK_VULKAN_ERROR                    (gdk_vulkan_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gdk_vulkan_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_strerror</NAME>
<RETURNS>const char *</RETURNS>
VkResult           result
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_instance</NAME>
<RETURNS>VkInstance</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_physical_device</NAME>
<RETURNS>VkPhysicalDevice</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_device</NAME>
<RETURNS>VkDevice</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_queue</NAME>
<RETURNS>VkQueue</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_queue_family_index</NAME>
<RETURNS>uint32_t</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_image_format</NAME>
<RETURNS>VkFormat</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_n_images</NAME>
<RETURNS>uint32_t</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_image</NAME>
<RETURNS>VkImage</RETURNS>
GdkVulkanContext  *context, guint              id
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_draw_index</NAME>
<RETURNS>uint32_t</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_draw_semaphore</NAME>
<RETURNS>VkSemaphore</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<MACRO>
<NAME>GDK_IS_MACOS_BASE_VIEW</NAME>
#define GDK_IS_MACOS_BASE_VIEW(obj) ((obj) && [obj isKindOfClass:[GdkMacosBaseView class]])
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_CAIRO_SUBVIEW</NAME>
#define GDK_IS_MACOS_CAIRO_SUBVIEW(obj) ((obj) && [obj isKindOfClass:[GdkMacosCairoSubview class]])
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_CAIRO_VIEW</NAME>
#define GDK_IS_MACOS_CAIRO_VIEW(obj) ((obj) && [obj isKindOfClass:[GdkMacosCairoView class]])
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_GL_LAYER</NAME>
#define GDK_IS_MACOS_GL_LAYER(obj) ((obj) && [obj isKindOfClass:[GdkMacosGLLayer class]])
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_WINDOW</NAME>
#define GDK_IS_MACOS_WINDOW(obj) ([obj isKindOfClass:[GdkMacosWindow class]])
</MACRO>
<FUNCTION>
<NAME>gdk_display_link_source_new</NAME>
<RETURNS>GSource *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_link_source_pause</NAME>
<RETURNS>void</RETURNS>
GdkDisplayLinkSource *source
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_link_source_unpause</NAME>
<RETURNS>void</RETURNS>
GdkDisplayLinkSource *source
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_MACOS_CAIRO_CONTEXT</NAME>
#define GDK_TYPE_MACOS_CAIRO_CONTEXT       (_gdk_macos_cairo_context_get_type())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_CAIRO_CONTEXT</NAME>
#define GDK_MACOS_CAIRO_CONTEXT(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_CAIRO_CONTEXT, GdkMacosCairoContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_CAIRO_CONTEXT</NAME>
#define GDK_IS_MACOS_CAIRO_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_CAIRO_CONTEXT))
</MACRO>
<STRUCT>
<NAME>GdkMacosCairoContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMacosCairoContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_MACOS_CLIPBOARD</NAME>
#define GDK_TYPE_MACOS_CLIPBOARD (_gdk_macos_clipboard_get_type())
</MACRO>
<STRUCT>
<NAME>GdkMacosClipboard</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_macos_device_query_state</NAME>
<RETURNS>void</RETURNS>
GdkDevice        *device, GdkSurface        *surface, GdkSurface       **child_surface, double           *win_x, double           *win_y, GdkModifierType  *mask
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_MACOS_DEVICE</NAME>
#define GDK_TYPE_MACOS_DEVICE       (gdk_macos_device_get_type())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_DEVICE</NAME>
#define GDK_MACOS_DEVICE(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_DEVICE, GdkMacosDevice))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_DEVICE</NAME>
#define GDK_IS_MACOS_DEVICE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_DEVICE))
</MACRO>
<FUNCTION>
<NAME>gdk_macos_device_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkMacosDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMacosDeviceClass</NAME>
</STRUCT>
<MACRO>
<NAME>TIC_MARKED_TEXT</NAME>
#define TIC_MARKED_TEXT      "tic-marked-text"
</MACRO>
<MACRO>
<NAME>TIC_SELECTED_POS</NAME>
#define TIC_SELECTED_POS     "tic-selected-pos"
</MACRO>
<MACRO>
<NAME>TIC_SELECTED_LEN</NAME>
#define TIC_SELECTED_LEN     "tic-selected-len"
</MACRO>
<MACRO>
<NAME>TIC_INSERT_TEXT</NAME>
#define TIC_INSERT_TEXT      "tic-insert-text"
</MACRO>
<MACRO>
<NAME>TIC_IN_KEY_DOWN</NAME>
#define TIC_IN_KEY_DOWN      "tic-in-key-down"
</MACRO>
<MACRO>
<NAME>GIC_CURSOR_RECT</NAME>
#define GIC_CURSOR_RECT      "gic-cursor-rect"
</MACRO>
<MACRO>
<NAME>GIC_FILTER_KEY</NAME>
#define GIC_FILTER_KEY       "gic-filter-key"
</MACRO>
<MACRO>
<NAME>GIC_FILTER_PASSTHRU</NAME>
#define GIC_FILTER_PASSTHRU  0
</MACRO>
<MACRO>
<NAME>GIC_FILTER_FILTERED</NAME>
#define GIC_FILTER_FILTERED  1
</MACRO>
<STRUCT>
<NAME>GdkMacosDisplay</NAME>
struct _GdkMacosDisplay
{
  GdkDisplay parent_instance;

  char *name;
  GdkMacosKeymap *keymap;

  /* An list of GdkMacosMonitor. The first instance is always the primary
   * monitor. This contains the 0,0 coordinate in quartz coordinates, but may
   * not be 0,0 in GDK coordinates.
   */
  GListStore *monitors;

  /* A queue of surfaces that have been made "main" so that we can update the
   * main status to the next surface when a window has lost main status (such
   * as when destroyed). This uses the GdkMacosSurface main link.
   */
  GQueue main_surfaces;

  /* A queue of surfaces sorted by their front-to-back ordering on the screen.
   * This is updated occasionally when we know that the data we have cached
   * has been invalidated. This uses the GdkMacosSurface.sorted link.
   */
  GQueue sorted_surfaces;

  /* Our CVDisplayLink based GSource which we use to freeze/thaw the
   * GdkFrameClock for the surface.
   */
  GSource *frame_source;

  /* A queue of surfaces which we know are awaiting frames to be drawn. This
   * uses the GdkMacosSurface.frame link.
   */
  GQueue awaiting_frames;

  /* The surface that is receiving keyboard events */
  GdkMacosSurface *keyboard_surface;

  /* Used to translate from quartz coordinate space to GDK */
  int width;
  int height;
  int min_x;
  int min_y;
  int max_x;
  int max_y;
};
</STRUCT>
<STRUCT>
<NAME>GdkMacosDisplayClass</NAME>
struct _GdkMacosDisplayClass
{
  GdkDisplayClass parent_class;
};
</STRUCT>
<TYPEDEF>
<NAME>GdkMacosDisplay</NAME>
typedef GdkDisplay GdkMacosDisplay;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_MACOS_DISPLAY</NAME>
#define GDK_TYPE_MACOS_DISPLAY       (gdk_macos_display_get_type())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_DISPLAY</NAME>
#define GDK_MACOS_DISPLAY(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_DISPLAY, GdkMacosDisplay))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_DISPLAY</NAME>
#define GDK_IS_MACOS_DISPLAY(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_DISPLAY))
</MACRO>
<FUNCTION>
<NAME>gdk_macos_display_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkMacosDisplay</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMacosDisplayClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_MACOS_DRAG</NAME>
#define GDK_TYPE_MACOS_DRAG            (gdk_macos_drag_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_DRAG</NAME>
#define GDK_MACOS_DRAG(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_DRAG, GdkMacosDrag))
</MACRO>
<MACRO>
<NAME>GDK_MACOS_DRAG_CLASS</NAME>
#define GDK_MACOS_DRAG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MACOS_DRAG, GdkMacosDragClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_DRAG</NAME>
#define GDK_IS_MACOS_DRAG(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_DRAG))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_DRAG_CLASS</NAME>
#define GDK_IS_MACOS_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MACOS_DRAG))
</MACRO>
<MACRO>
<NAME>GDK_MACOS_DRAG_GET_CLASS</NAME>
#define GDK_MACOS_DRAG_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MACOS_DRAG, GdkMacosDragClass))
</MACRO>
<STRUCT>
<NAME>GdkMacosDrag</NAME>
struct _GdkMacosDrag
{
  GdkDrag parent_instance;

  GdkMacosDragSurface *drag_surface;
  GdkSeat *drag_seat;
  GdkCursor *cursor;

  int hot_x;
  int hot_y;

  int last_x;
  int last_y;

  int start_x;
  int start_y;

  guint did_update : 1;
  guint cancelled : 1;
};
</STRUCT>
<STRUCT>
<NAME>GdkMacosDragClass</NAME>
struct _GdkMacosDragClass
{
  GdkDragClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_macos_drag_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_MACOS_DRAG_SURFACE</NAME>
#define GDK_TYPE_MACOS_DRAG_SURFACE       (_gdk_macos_drag_surface_get_type())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_DRAG_SURFACE</NAME>
#define GDK_MACOS_DRAG_SURFACE(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_DRAG_SURFACE, GdkMacosDragSurface))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_DRAG_SURFACE</NAME>
#define GDK_IS_MACOS_DRAG_SURFACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_DRAG_SURFACE))
</MACRO>
<STRUCT>
<NAME>GdkMacosDragSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMacosDragSurfaceClass</NAME>
</STRUCT>
<ENUM>
<NAME>GdkMacosEventSubType</NAME>
typedef enum
{
  GDK_MACOS_EVENT_SUBTYPE_EVENTLOOP,
} GdkMacosEventSubType;
</ENUM>
<STRUCT>
<NAME>GdkMacosGLContext</NAME>
struct _GdkMacosGLContext
{
  GdkGLContext parent_instance;
  NSOpenGLContext *gl_context;

  gboolean is_attached;
};
</STRUCT>
<STRUCT>
<NAME>GdkMacosGLContextClass</NAME>
struct _GdkMacosGLContextClass
{
  GdkGLContextClass parent_class;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_MACOS_GL_CONTEXT</NAME>
#define GDK_TYPE_MACOS_GL_CONTEXT    (gdk_macos_gl_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_GL_CONTEXT</NAME>
#define GDK_MACOS_GL_CONTEXT(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_MACOS_GL_CONTEXT, GdkMacosGLContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_GL_CONTEXT</NAME>
#define GDK_IS_MACOS_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_MACOS_GL_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_macos_gl_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkMacosGLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMacosGLContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_MACOS_KEYMAP</NAME>
#define GDK_TYPE_MACOS_KEYMAP       (gdk_macos_keymap_get_type())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_KEYMAP</NAME>
#define GDK_MACOS_KEYMAP(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_KEYMAP, GdkMacosKeymap))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_KEYMAP</NAME>
#define GDK_IS_MACOS_KEYMAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_KEYMAP))
</MACRO>
<FUNCTION>
<NAME>gdk_macos_keymap_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkMacosKeymap</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMacosKeymapClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_MACOS_MONITOR</NAME>
#define GDK_TYPE_MACOS_MONITOR       (gdk_macos_monitor_get_type())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_MONITOR</NAME>
#define GDK_MACOS_MONITOR(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_MONITOR, GdkMacosMonitor))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_MONITOR</NAME>
#define GDK_IS_MACOS_MONITOR(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_MONITOR))
</MACRO>
<FUNCTION>
<NAME>gdk_macos_monitor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_macos_monitor_get_geometry</NAME>
<RETURNS>void</RETURNS>
GdkMonitor   *self, GdkRectangle *geometry
</FUNCTION>
<FUNCTION>
<NAME>gdk_macos_monitor_get_workarea</NAME>
<RETURNS>void</RETURNS>
GdkMonitor   *self, GdkRectangle *geometry
</FUNCTION>
<STRUCT>
<NAME>GdkMacosMonitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMacosMonitorClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_MACOS_POPUP_SURFACE</NAME>
#define GDK_TYPE_MACOS_POPUP_SURFACE       (_gdk_macos_popup_surface_get_type())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_POPUP_SURFACE</NAME>
#define GDK_MACOS_POPUP_SURFACE(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_POPUP_SURFACE, GdkMacosPopupSurface))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_POPUP_SURFACE</NAME>
#define GDK_IS_MACOS_POPUP_SURFACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_POPUP_SURFACE))
</MACRO>
<STRUCT>
<NAME>GdkMacosPopupSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMacosPopupSurfaceClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_MACOS_SURFACE_CLASS</NAME>
#define GDK_MACOS_SURFACE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MACOS_SURFACE, GdkMacosSurfaceClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_SURFACE_CLASS</NAME>
#define GDK_IS_MACOS_SURFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MACOS_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_MACOS_SURFACE_GET_CLASS</NAME>
#define GDK_MACOS_SURFACE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MACOS_SURFACE, GdkMacosSurfaceClass))
</MACRO>
<STRUCT>
<NAME>GdkMacosSurface</NAME>
struct _GdkMacosSurface
{
  GdkSurface parent_instance;

  GList main;
  GList sorted;
  GList frame;

  GdkMacosWindow *window;
  GPtrArray *monitors;
  cairo_region_t *input_region;
  char *title;

  int root_x;
  int root_y;

  int shadow_top;
  int shadow_right;
  int shadow_bottom;
  int shadow_left;

  gint64 pending_frame_counter;

  guint did_initial_present : 1;
};
</STRUCT>
<STRUCT>
<NAME>GdkMacosSurfaceClass</NAME>
struct _GdkMacosSurfaceClass
{
  GdkSurfaceClass parent_class;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_MACOS_SURFACE</NAME>
#define GDK_TYPE_MACOS_SURFACE       (gdk_macos_surface_get_type())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_SURFACE</NAME>
#define GDK_MACOS_SURFACE(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_SURFACE, GdkMacosSurface))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_SURFACE</NAME>
#define GDK_IS_MACOS_SURFACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_SURFACE))
</MACRO>
<FUNCTION>
<NAME>gdk_macos_surface_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkMacosSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMacosSurfaceClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_MACOS_TOPLEVEL_SURFACE</NAME>
#define GDK_TYPE_MACOS_TOPLEVEL_SURFACE       (_gdk_macos_toplevel_surface_get_type())
</MACRO>
<MACRO>
<NAME>GDK_MACOS_TOPLEVEL_SURFACE</NAME>
#define GDK_MACOS_TOPLEVEL_SURFACE(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_TOPLEVEL_SURFACE, GdkMacosToplevelSurface))
</MACRO>
<MACRO>
<NAME>GDK_IS_MACOS_TOPLEVEL_SURFACE</NAME>
#define GDK_IS_MACOS_TOPLEVEL_SURFACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_TOPLEVEL_SURFACE))
</MACRO>
<STRUCT>
<NAME>GdkMacosToplevelSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMacosToplevelSurfaceClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_BEGIN_MACOS_ALLOC_POOL</NAME>
#define GDK_BEGIN_MACOS_ALLOC_POOL NSAutoreleasePool *_pool = [[NSAutoreleasePool alloc] init]
</MACRO>
<MACRO>
<NAME>GDK_END_MACOS_ALLOC_POOL</NAME>
#define GDK_END_MACOS_ALLOC_POOL   [_pool release]
</MACRO>
<FUNCTION>
<NAME>queue_contains</NAME>
<RETURNS>gboolean</RETURNS>
GQueue *queue, GList  *link_
</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>
<FUNCTION>
<NAME>gdk_wayland_device_query_state</NAME>
<RETURNS>void</RETURNS>
GdkDevice        *device, GdkSurface       *surface, double           *win_x, double           *win_y, GdkModifierType  *mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_pad_set_feedback</NAME>
<RETURNS>void</RETURNS>
GdkDevice           *device, GdkDevicePadFeature  feature, guint                feature_idx, const char          *label
</FUNCTION>
<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;
        int          dpi;
        const char *rgba;
        const char *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 */
  char *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 zwp_primary_selection_device_manager_v1 *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;
  struct zwp_idle_inhibit_manager_v1 *idle_inhibit_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;
  char *cursor_theme_name;
  int cursor_theme_size;
  GHashTable *cursor_surface_cache;

  GSource *event_source;

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

  uint32_t server_decoration_mode;

  struct xkb_context *xkb_context;

  GListStore *monitors;

  gint64 last_bell_time_ms;

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

  guint have_egl : 1;
  guint have_egl_khr_create_context : 1;
  guint have_egl_buffer_age : 1;
  guint have_egl_swap_buffers_with_damage : 1;
  guint have_egl_surfaceless_context : 1;
};
</STRUCT>
<STRUCT>
<NAME>GdkWaylandDisplayClass</NAME>
struct _GdkWaylandDisplayClass
{
  GdkDisplayClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_wayland_display_prefers_ssd</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay *display
</FUNCTION>
<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_commit</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_notify_committed</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_request_frame</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_attach_image</NAME>
<RETURNS>void</RETURNS>
GdkSurface           *surface, cairo_surface_t      *cairo_surface, const cairo_region_t *damage
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drop_new</NAME>
<RETURNS>GdkDrop *</RETURNS>
GdkDevice             *device, GdkDrag               *drag, GdkContentFormats     *formats, GdkSurface            *surface, struct wl_data_offer  *offer, uint32_t               serial
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drop_set_source_actions</NAME>
<RETURNS>void</RETURNS>
GdkDrop               *drop, uint32_t               source_actions
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drop_set_action</NAME>
<RETURNS>void</RETURNS>
GdkDrop               *drop, uint32_t               action
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_data_device</NAME>
<RETURNS>struct wl_data_device *</RETURNS>
GdkDevice *gdk_device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_set_selection</NAME>
<RETURNS>void</RETURNS>
GdkDevice             *gdk_device, struct wl_data_source *source
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_drop_context</NAME>
<RETURNS>GdkDrag *</RETURNS>
GdkDevice *gdk_device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_unset_touch_grab</NAME>
<RETURNS>void</RETURNS>
GdkDevice        *device, GdkEventSequence *sequence
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_toplevel_surfaces</NAME>
<RETURNS>GList *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_output_refresh_rate</NAME>
<RETURNS>int</RETURNS>
GdkWaylandDisplay *display_wayland, struct wl_output  *output
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_output_scale</NAME>
<RETURNS>guint32</RETURNS>
GdkWaylandDisplay *display_wayland, struct wl_output  *output
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_monitor_for_output</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay       *display, struct wl_output *output
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_egl_surface</NAME>
<RETURNS>EGLSurface</RETURNS>
GdkSurface *surface, EGLConfig config
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_dummy_egl_surface</NAME>
<RETURNS>EGLSurface</RETURNS>
GdkSurface *surface, EGLConfig config
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_gtk_surface</NAME>
<RETURNS>struct gtk_surface1 *</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_set_global_cursor</NAME>
<RETURNS>void</RETURNS>
GdkSeat   *seat, GdkCursor *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_set_drag</NAME>
<RETURNS>void</RETURNS>
GdkSeat        *seat, GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_wl_output</NAME>
<RETURNS>struct wl_output *</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_inhibit_shortcuts</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, GdkSeat   *gdk_seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_restore_shortcuts</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, GdkSeat   *gdk_seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_update_scale</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>create_dnd_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_keymap_get_gdk_modifiers</NAME>
<RETURNS>GdkModifierType</RETURNS>
GdkKeymap *keymap, guint32    mods
</FUNCTION>
<MACRO>
<NAME>GDK_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_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_update_cursor_scale</NAME>
<RETURNS>void</RETURNS>
GdkWaylandSeat *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_clear_touchpoints</NAME>
<RETURNS>void</RETURNS>
GdkWaylandSeat *seat, GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_set_dbus_properties</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel, 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>gdk_wayland_toplevel_announce_csd</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_inhibit_idle</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_uninhibit_idle</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel
</FUNCTION>
<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_device_get_node_path</NAME>
<RETURNS>const char *</RETURNS>
GdkDevice *device
</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 char *theme, int          size
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_startup_notification_id</NAME>
<RETURNS>const char *</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_query_registry</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display, const char *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>GdkWaylandSeat</NAME>
typedef GdkSeat GdkWaylandSeat;
</TYPEDEF>
<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_IS_WAYLAND_SEAT</NAME>
#define GDK_IS_WAYLAND_SEAT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_WAYLAND_SEAT))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_seat_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_get_wl_seat</NAME>
<RETURNS>struct wl_seat *</RETURNS>
GdkSeat *seat
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandSeat</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandSeatClass</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GdkWaylandSurface</NAME>
typedef GdkSurface GdkWaylandSurface;
</TYPEDEF>
<TYPEDEF>
<NAME>GdkWaylandToplevel</NAME>
typedef GdkToplevel GdkWaylandToplevel;
</TYPEDEF>
<TYPEDEF>
<NAME>GdkWaylandPopup</NAME>
typedef GdkPopup GdkWaylandPopup;
</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_IS_WAYLAND_SURFACE</NAME>
#define GDK_IS_WAYLAND_SURFACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_TOPLEVEL</NAME>
#define GDK_TYPE_WAYLAND_TOPLEVEL             (gdk_wayland_toplevel_get_type())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_TOPLEVEL</NAME>
#define GDK_WAYLAND_TOPLEVEL(object)          (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_TOPLEVEL, GdkWaylandToplevel))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_TOPLEVEL</NAME>
#define GDK_IS_WAYLAND_TOPLEVEL(object)       (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_TOPLEVEL))
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_POPUP</NAME>
#define GDK_TYPE_WAYLAND_POPUP                (gdk_wayland_popup_get_type())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_POPUP</NAME>
#define GDK_WAYLAND_POPUP(object)             (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_POPUP, GdkWaylandPopup))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_POPUP</NAME>
#define GDK_IS_WAYLAND_POPUP(object)          (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_POPUP))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_surface_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_popup_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_wl_surface</NAME>
<RETURNS>struct wl_surface *</RETURNS>
GdkSurface *surface
</FUNCTION>
<USER_FUNCTION>
<NAME>GdkWaylandToplevelExported</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel, const char  *handle, gpointer     user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_export_handle</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel              *toplevel, GdkWaylandToplevelExported callback, gpointer                 user_data, GDestroyNotify           destroy_func
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_unexport_handle</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_set_transient_for_exported</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel *toplevel, const char   *parent_handle_str
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_set_application_id</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel, const char  *application_id
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandPopup</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandToplevel</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;
  int x;
  int y;
  int width;
  int 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 char             *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>
<FUNCTION>
<NAME>gdk_x11_device_xi2_query_state</NAME>
<RETURNS>void</RETURNS>
GdkDevice        *device, GdkSurface       *surface, double           *win_x, double           *win_y, GdkModifierType  *mask
</FUNCTION>
<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;

  int grab_count;

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

  /* Keyboard related information */
  int 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;
  int xfixes_event_base;

  gboolean have_xcomposite;

  gboolean have_randr12;
  gboolean have_randr13;
  gboolean have_randr15;
  int xrandr_event_base;

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

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

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

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

  /* X ID hashtable */
  GHashTable *xid_ht;

  /* streams reading selections */
  GSList *streams;

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

  GListStore *monitors;
  int primary_monitor;

  /* Startup notification */
  char *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;
  int shape_event_base;

  GSList *error_traps;

  int wm_moveresize_button;

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

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

  guint server_time_is_monotonic_time : 1;

  guint have_glx : 1;

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

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

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

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

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

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

#ifdef HAVE_XDAMAGE
  GLsync frame_fence;
  Damage xdamage;
#endif

  guint is_attached : 1;
  guint is_direct : 1;
  guint do_frame_sync : 1;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11GLContextClass</NAME>
struct _GdkX11GLContextClass
{
  GdkGLContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_screen_init_gl</NAME>
<RETURNS>gboolean</RETURNS>
GdkX11Screen      *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_create_gl_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GdkSurface         *window, gboolean           attached, GdkGLContext      *share, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_make_gl_context_current</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay        *display, GdkGLContext      *context
</FUNCTION>
<TYPEDEF>
<NAME>GdkX11Keymap</NAME>
typedef GdkKeymap GdkX11Keymap;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_X11_KEYMAP</NAME>
#define GDK_TYPE_X11_KEYMAP              (gdk_x11_keymap_get_type())
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP</NAME>
#define GDK_X11_KEYMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_KEYMAP, GdkX11Keymap))
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP_CLASS</NAME>
#define GDK_X11_KEYMAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_KEYMAP, GdkX11KeymapClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_KEYMAP</NAME>
#define GDK_IS_X11_KEYMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_KEYMAP))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_KEYMAP_CLASS</NAME>
#define GDK_IS_X11_KEYMAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_KEYMAP))
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP_GET_CLASS</NAME>
#define GDK_X11_KEYMAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_KEYMAP, GdkX11KeymapClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_keymap_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_keymap_get_group_for_state</NAME>
<RETURNS>int</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, int             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>double</RETURNS>
GdkX11DeviceXI2 *device, int              n_axis
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_device_xi2_store_axes</NAME>
<RETURNS>void</RETURNS>
GdkX11DeviceXI2 *device, double          *axes, int              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, int         x, int         y, int        *root_x, int        *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;
  int screen_num;

  int surface_scale;
  gboolean fixed_surface_scale;

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

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

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

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

  /* Visual Part */
  int nvisuals;
  GdkX11Visual **visuals;
  GdkX11Visual *system_visual;
  int 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;

  int 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.
   */
  int unscaled_width;
  int unscaled_height;

  cairo_surface_t *cairo_surface;

  int abs_x;
  int abs_y;

  guint64 map_time;

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

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

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

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

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

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

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

  guint is_leader : 1;

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

  guint in_frame : 1;

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

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

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

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

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

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

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

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

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

  GdkVisualType type;
  int depth;
  GdkByteOrder byte_order;
  int colormap_size;
  int 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>
<ENUM>
<NAME>GdkX11DeviceType</NAME>
typedef enum {
  GDK_X11_DEVICE_TYPE_LOGICAL,
  GDK_X11_DEVICE_TYPE_PHYSICAL,
  GDK_X11_DEVICE_TYPE_FLOATING
} GdkX11DeviceType;
</ENUM>
<FUNCTION>
<NAME>gdk_x11_device_xi2_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_device_xi2_get_device_type</NAME>
<RETURNS>GdkX11DeviceType</RETURNS>
GdkX11DeviceXI2 *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_device_xi2_set_device_type</NAME>
<RETURNS>void</RETURNS>
GdkX11DeviceXI2  *device, GdkX11DeviceType  type
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceXI2</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceXI2Class</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_device_get_id</NAME>
<RETURNS>int</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, int                     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 char *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_startup_notification_id</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const char *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 char *theme, const int    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, int 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>int</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_pop_ignored</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_set_sm_client_id</NAME>
<RETURNS>void</RETURNS>
const char *sm_client_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_default_group</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay *display
</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, int        *major, int        *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>
<FUNCTION>
<NAME>gdk_x11_monitor_get_workarea</NAME>
<RETURNS>void</RETURNS>
GdkMonitor   *monitor, GdkRectangle *workarea
</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 char *atom_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_get_xatom_name_for_display</NAME>
<RETURNS>const char *</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, int           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>int</RETURNS>
GdkDisplay   *display, const char   *encoding, int           format, const guchar *text, int           length, char       ***list
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_free_text_list</NAME>
<RETURNS>void</RETURNS>
char        **list
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_string_to_compound_text</NAME>
<RETURNS>int</RETURNS>
GdkDisplay   *display, const char   *str, const char  **encoding, int          *format, guchar      **ctext, int          *length
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_utf8_to_compound_text</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay   *display, const char   *str, const char  **encoding, int          *format, guchar      **ctext, int          *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 char *name, const char *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_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_TOPLEVEL_STATE</NAME>
#define GDK_TYPE_TOPLEVEL_STATE (gdk_toplevel_state_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAVITY</NAME>
#define GDK_TYPE_GRAVITY (gdk_gravity_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MODIFIER_TYPE</NAME>
#define GDK_TYPE_MODIFIER_TYPE (gdk_modifier_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GL_ERROR</NAME>
#define GDK_TYPE_GL_ERROR (gdk_gl_error_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_VULKAN_ERROR</NAME>
#define GDK_TYPE_VULKAN_ERROR (gdk_vulkan_error_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_AXIS_USE</NAME>
#define GDK_TYPE_AXIS_USE (gdk_axis_use_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_AXIS_FLAGS</NAME>
#define GDK_TYPE_AXIS_FLAGS (gdk_axis_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DRAG_ACTION</NAME>
#define GDK_TYPE_DRAG_ACTION (gdk_drag_action_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_MAJOR_VERSION</NAME>
#define GDK_MAJOR_VERSION (3)
</MACRO>
<MACRO>
<NAME>GDK_MINOR_VERSION</NAME>
#define GDK_MINOR_VERSION (99)
</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>zwp_idle_inhibit_manager_v1_interface</NAME>
extern const struct wl_interface zwp_idle_inhibit_manager_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_idle_inhibitor_v1_interface</NAME>
extern const struct wl_interface zwp_idle_inhibitor_v1_interface;
</VARIABLE>
<MACRO>
<NAME>ZWP_IDLE_INHIBIT_MANAGER_V1_DESTROY</NAME>
#define ZWP_IDLE_INHIBIT_MANAGER_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_IDLE_INHIBIT_MANAGER_V1_CREATE_INHIBITOR</NAME>
#define ZWP_IDLE_INHIBIT_MANAGER_V1_CREATE_INHIBITOR 1
</MACRO>
<MACRO>
<NAME>ZWP_IDLE_INHIBIT_MANAGER_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_IDLE_INHIBIT_MANAGER_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_IDLE_INHIBIT_MANAGER_V1_CREATE_INHIBITOR_SINCE_VERSION</NAME>
#define ZWP_IDLE_INHIBIT_MANAGER_V1_CREATE_INHIBITOR_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_idle_inhibit_manager_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_idle_inhibit_manager_v1 *zwp_idle_inhibit_manager_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_idle_inhibit_manager_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_idle_inhibit_manager_v1 *zwp_idle_inhibit_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_idle_inhibit_manager_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_idle_inhibit_manager_v1 *zwp_idle_inhibit_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_idle_inhibit_manager_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_idle_inhibit_manager_v1 *zwp_idle_inhibit_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_idle_inhibit_manager_v1_create_inhibitor</NAME>
<RETURNS>struct zwp_idle_inhibitor_v1 *</RETURNS>
struct zwp_idle_inhibit_manager_v1 *zwp_idle_inhibit_manager_v1, struct wl_surface *surface
</FUNCTION>
<MACRO>
<NAME>ZWP_IDLE_INHIBITOR_V1_DESTROY</NAME>
#define ZWP_IDLE_INHIBITOR_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_IDLE_INHIBITOR_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_IDLE_INHIBITOR_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_idle_inhibitor_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_idle_inhibitor_v1 *zwp_idle_inhibitor_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_idle_inhibitor_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_idle_inhibitor_v1 *zwp_idle_inhibitor_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_idle_inhibitor_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_idle_inhibitor_v1 *zwp_idle_inhibitor_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_idle_inhibitor_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_idle_inhibitor_v1 *zwp_idle_inhibitor_v1
</FUNCTION>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zwp_idle_inhibit_manager_v1</NAME>
struct zwp_idle_inhibit_manager_v1;
</STRUCT>
<STRUCT>
<NAME>zwp_idle_inhibitor_v1</NAME>
struct zwp_idle_inhibitor_v1;
</STRUCT>
<VARIABLE>
<NAME>zwp_primary_selection_device_manager_v1_interface</NAME>
extern const struct wl_interface zwp_primary_selection_device_manager_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_primary_selection_device_v1_interface</NAME>
extern const struct wl_interface zwp_primary_selection_device_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_primary_selection_offer_v1_interface</NAME>
extern const struct wl_interface zwp_primary_selection_offer_v1_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_primary_selection_source_v1_interface</NAME>
extern const struct wl_interface zwp_primary_selection_source_v1_interface;
</VARIABLE>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_CREATE_SOURCE</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_CREATE_SOURCE 0
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_GET_DEVICE</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_GET_DEVICE 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_DESTROY</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_DESTROY 2
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_CREATE_SOURCE_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_CREATE_SOURCE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_GET_DEVICE_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_GET_DEVICE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_MANAGER_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_primary_selection_device_manager_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_device_manager_v1 *zwp_primary_selection_device_manager_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_device_manager_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_primary_selection_device_manager_v1 *zwp_primary_selection_device_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_device_manager_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_primary_selection_device_manager_v1 *zwp_primary_selection_device_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_device_manager_v1_create_source</NAME>
<RETURNS>struct zwp_primary_selection_source_v1 *</RETURNS>
struct zwp_primary_selection_device_manager_v1 *zwp_primary_selection_device_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_device_manager_v1_get_device</NAME>
<RETURNS>struct zwp_primary_selection_device_v1 *</RETURNS>
struct zwp_primary_selection_device_manager_v1 *zwp_primary_selection_device_manager_v1, struct wl_seat *seat
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_device_manager_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_device_manager_v1 *zwp_primary_selection_device_manager_v1
</FUNCTION>
<STRUCT>
<NAME>zwp_primary_selection_device_v1_listener</NAME>
struct zwp_primary_selection_device_v1_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 zwp_primary_selection_device_v1 *zwp_primary_selection_device_v1,
			   struct zwp_primary_selection_offer_v1 *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 zwp_primary_selection_device_v1 *zwp_primary_selection_device_v1,
			  struct zwp_primary_selection_offer_v1 *id);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_primary_selection_device_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_primary_selection_device_v1 *zwp_primary_selection_device_v1, const struct zwp_primary_selection_device_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_V1_SET_SELECTION</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_V1_SET_SELECTION 0
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_V1_DESTROY</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_V1_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_V1_DATA_OFFER_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_V1_DATA_OFFER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_V1_SELECTION_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_V1_SELECTION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_V1_SET_SELECTION_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_V1_SET_SELECTION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_DEVICE_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_DEVICE_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_primary_selection_device_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_device_v1 *zwp_primary_selection_device_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_device_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_primary_selection_device_v1 *zwp_primary_selection_device_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_device_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_primary_selection_device_v1 *zwp_primary_selection_device_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_device_v1_set_selection</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_device_v1 *zwp_primary_selection_device_v1, struct zwp_primary_selection_source_v1 *source, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_device_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_device_v1 *zwp_primary_selection_device_v1
</FUNCTION>
<STRUCT>
<NAME>zwp_primary_selection_offer_v1_listener</NAME>
struct zwp_primary_selection_offer_v1_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 zwp_primary_selection_offer_v1 *zwp_primary_selection_offer_v1,
		      const char *mime_type);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_primary_selection_offer_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_primary_selection_offer_v1 *zwp_primary_selection_offer_v1, const struct zwp_primary_selection_offer_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_OFFER_V1_RECEIVE</NAME>
#define ZWP_PRIMARY_SELECTION_OFFER_V1_RECEIVE 0
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_OFFER_V1_DESTROY</NAME>
#define ZWP_PRIMARY_SELECTION_OFFER_V1_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_OFFER_V1_OFFER_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_OFFER_V1_OFFER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_OFFER_V1_RECEIVE_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_OFFER_V1_RECEIVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_OFFER_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_OFFER_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_primary_selection_offer_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_offer_v1 *zwp_primary_selection_offer_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_offer_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_primary_selection_offer_v1 *zwp_primary_selection_offer_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_offer_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_primary_selection_offer_v1 *zwp_primary_selection_offer_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_offer_v1_receive</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_offer_v1 *zwp_primary_selection_offer_v1, const char *mime_type, int32_t fd
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_offer_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_offer_v1 *zwp_primary_selection_offer_v1
</FUNCTION>
<STRUCT>
<NAME>zwp_primary_selection_source_v1_listener</NAME>
struct zwp_primary_selection_source_v1_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 zwp_primary_selection_source_v1 *zwp_primary_selection_source_v1,
		     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 zwp_primary_selection_source_v1 *zwp_primary_selection_source_v1);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_primary_selection_source_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_primary_selection_source_v1 *zwp_primary_selection_source_v1, const struct zwp_primary_selection_source_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_SOURCE_V1_OFFER</NAME>
#define ZWP_PRIMARY_SELECTION_SOURCE_V1_OFFER 0
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_SOURCE_V1_DESTROY</NAME>
#define ZWP_PRIMARY_SELECTION_SOURCE_V1_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_SOURCE_V1_SEND_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_SOURCE_V1_SEND_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_SOURCE_V1_CANCELLED_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_SOURCE_V1_CANCELLED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_SOURCE_V1_OFFER_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_SOURCE_V1_OFFER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_PRIMARY_SELECTION_SOURCE_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_PRIMARY_SELECTION_SOURCE_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_primary_selection_source_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_source_v1 *zwp_primary_selection_source_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_source_v1_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_primary_selection_source_v1 *zwp_primary_selection_source_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_source_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_primary_selection_source_v1 *zwp_primary_selection_source_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_source_v1_offer</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_source_v1 *zwp_primary_selection_source_v1, const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>zwp_primary_selection_source_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_primary_selection_source_v1 *zwp_primary_selection_source_v1
</FUNCTION>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<STRUCT>
<NAME>zwp_primary_selection_device_manager_v1</NAME>
struct zwp_primary_selection_device_manager_v1;
</STRUCT>
<STRUCT>
<NAME>zwp_primary_selection_device_v1</NAME>
struct zwp_primary_selection_device_v1;
</STRUCT>
<STRUCT>
<NAME>zwp_primary_selection_offer_v1</NAME>
struct zwp_primary_selection_offer_v1;
</STRUCT>
<STRUCT>
<NAME>zwp_primary_selection_source_v1</NAME>
struct zwp_primary_selection_source_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>
